leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Driver core changes for 5.18-rc1

Browse Source 
Here is the set of driver core changes for 5.18-rc1.
 
 Not much here, primarily it was a bunch of cleanups and small updates:
 	- kobj_type cleanups for default_groups
 	- documentation updates
 	- firmware loader minor changes
 	- component common helper added and take advantage of it in many
 	  drivers (the largest part of this pull request).
 
 There will be a merge conflict in drivers/power/supply/ab8500_chargalg.c
 with your tree, the merge conflict should be easy (take all the
 changes).
 
 All of these have been in linux-next for a while with no reported
 problems.
 
 Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
 -----BEGIN PGP SIGNATURE-----
 
 iG0EABECAC0WIQT0tgzFv3jCIUoxPcsxR9QN2y37KQUCYkG6PA8cZ3JlZ0Brcm9h
 aC5jb20ACgkQMUfUDdst+ylMFwCfSIyAU4oLEgj+/Rfmx4o45cAVIWMAnit3zbdU
 wUUCGqKcOnTJEcW6dMPh
 =1VVi
 -----END PGP SIGNATURE-----

Merge tag 'driver-core-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core

Pull driver core updates from Greg KH:
 "Here is the set of driver core changes for 5.18-rc1.

  Not much here, primarily it was a bunch of cleanups and small updates:

   - kobj_type cleanups for default_groups

   - documentation updates

   - firmware loader minor changes

   - component common helper added and take advantage of it in many
     drivers (the largest part of this pull request).

  All of these have been in linux-next for a while with no reported
  problems"

* tag 'driver-core-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: (54 commits)
  Documentation: update stable review cycle documentation
  drivers/base/dd.c : Remove the initial value of the global variable
  Documentation: update stable tree link
  Documentation: add link to stable release candidate tree
  devres: fix typos in comments
  Documentation: add note block surrounding security patch note
  samples/kobject: Use sysfs_emit instead of sprintf
  base: soc: Make soc_device_match() simpler and easier to read
  driver core: dd: fix return value of __setup handler
  driver core: Refactor sysfs and drv/bus remove hooks
  driver core: Refactor multiple copies of device cleanup
  scripts: get_abi.pl: Fix typo in help message
  kernfs: fix typos in comments
  kernfs: remove unneeded #if 0 guard
  ALSA: hda/realtek: Make use of the helper component_compare_dev_name
  video: omapfb: dss: Make use of the helper component_compare_dev
  power: supply: ab8500: Make use of the helper component_compare_dev
  ASoC: codecs: wcd938x: Make use of the helper component_compare/release_of
  iommu/mediatek: Make use of the helper component_compare/release_of
  drm: of: Make use of the helper component_release_of
  ...
This commit is contained in:
Linus Torvalds 2022-03-28 12:41:28 -07:00
commit 266d17a8c0
51 changed files with 372 additions and 430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Documentation/process/stable-kernel-rules.rst
View File

@ -35,7 +35,9 @@ Rules on what kind of patches are accepted, and which ones are not, into the
Procedure for submitting patches to the -stable tree
----------------------------------------------------
- Security patches should not be handled (solely) by the -stable review
.. note::
Security patches should not be handled (solely) by the -stable review
process but should follow the procedures in
:ref:`Documentation/admin-guide/security-bugs.rst <securitybugs>`.
@ -81,8 +83,8 @@ it to be applied to.
:ref:`option_2` and :ref:`option_3` are more useful if the patch isn't deemed
worthy at the time it is applied to a public git tree (for instance, because
it deserves more regression testing first). :ref:`option_3` is especially
useful if the patch needs some special handling to apply to an older kernel
(e.g., if API's have changed in the meantime).
useful if the original upstream patch needs to be backported (for example
the backport needs some special handling due to e.g. API changes).
Note that for :ref:`option_3`, if the patch deviates from the original
upstream patch (for example because it had to be backported) this must be very
@ -151,8 +153,17 @@ Review cycle
- If the patch is rejected by a member of the committee, or linux-kernel
members object to the patch, bringing up issues that the maintainers and
members did not realize, the patch will be dropped from the queue.
- At the end of the review cycle, the ACKed patches will be added to the
latest -stable release, and a new -stable release will happen.
- The ACKed patches will be posted again as part of release candidate (-rc)
to be tested by developers and testers.
- Usually only one -rc release is made, however if there are any outstanding
issues, some patches may be modified or dropped or additional patches may
be queued. Additional -rc releases are then released and tested until no
issues are found.
- Responding to the -rc releases can be done on the mailing list by sending
a "Tested-by:" email with any testing information desired. The "Tested-by:"
tags will be collected and added to the release commit.
- At the end of the review cycle, the new -stable release will be released
containing all the queued and tested patches.
- Security patches will be accepted into the -stable tree directly from the
security kernel team, and not go through the normal review cycle.
Contact the kernel security team for more details on this procedure.
@ -168,7 +179,16 @@ Trees
- The finalized and tagged releases of all stable kernels can be found
in separate branches per version at:
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
- The release candidate of all stable kernel versions can be found at:
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git/
.. warning::
The -stable-rc tree is a snapshot in time of the stable-queue tree and
will change frequently, hence will be rebased often. It should only be
used for testing purposes (e.g. to be consumed by CI systems).
Review committee

4
arch/x86/kernel/cpu/resctrl/rdtgroup.c
View File

@ -3221,13 +3221,13 @@ static int __init rdtgroup_setup_root(void)
list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups);
ret = rdtgroup_add_files(rdt_root->kn, RF_CTRL_BASE);
ret = rdtgroup_add_files(kernfs_root_to_node(rdt_root), RF_CTRL_BASE);
if (ret) {
kernfs_destroy_root(rdt_root);
goto out;
}
rdtgroup_default.kn = rdt_root->kn;
rdtgroup_default.kn = kernfs_root_to_node(rdt_root);
kernfs_activate(rdtgroup_default.kn);
out:

300
drivers/base/component.c
View File

@ -1,16 +1,12 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Componentized device handling.
*
* This is work in progress. We gather up the component devices into a list,
* and bind them when instructed. At the moment, we're specific to the DRM
* subsystem, and only handles one master device, but this doesn't have to be
* the case.
*/
#include <linux/component.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/debugfs.h>
@ -57,7 +53,7 @@ struct component_match {
struct component_match_array *compare;
};
struct master {
struct aggregate_device {
struct list_head node;
bool bound;
@ -68,7 +64,7 @@ struct master {
struct component {
struct list_head node;
struct master *master;
struct aggregate_device *adev;
bool bound;
const struct component_ops *ops;
@ -78,7 +74,7 @@ struct component {
static DEFINE_MUTEX(component_mutex);
static LIST_HEAD(component_list);
static LIST_HEAD(masters);
static LIST_HEAD(aggregate_devices);
#ifdef CONFIG_DEBUG_FS
@ -86,12 +82,12 @@ static struct dentry *component_debugfs_dir;
static int component_devices_show(struct seq_file *s, void *data)
{
struct master *m = s->private;
struct aggregate_device *m = s->private;
struct component_match *match = m->match;
size_t i;
mutex_lock(&component_mutex);
seq_printf(s, "%-40s %20s\n", "master name", "status");
seq_printf(s, "%-40s %20s\n", "aggregate_device name", "status");
seq_puts(s, "-------------------------------------------------------------\n");
seq_printf(s, "%-40s %20s\n\n",
dev_name(m->parent), m->bound ? "bound" : "not bound");
@ -121,46 +117,46 @@ static int __init component_debug_init(void)
core_initcall(component_debug_init);
static void component_master_debugfs_add(struct master *m)
static void component_debugfs_add(struct aggregate_device *m)
{
debugfs_create_file(dev_name(m->parent), 0444, component_debugfs_dir, m,
&component_devices_fops);
}
static void component_master_debugfs_del(struct master *m)
static void component_debugfs_del(struct aggregate_device *m)
{
debugfs_remove(debugfs_lookup(dev_name(m->parent), component_debugfs_dir));
}
#else
static void component_master_debugfs_add(struct master *m)
static void component_debugfs_add(struct aggregate_device *m)
{ }
static void component_master_debugfs_del(struct master *m)
static void component_debugfs_del(struct aggregate_device *m)
{ }
#endif
static struct master *__master_find(struct device *parent,
static struct aggregate_device *__aggregate_find(struct device *parent,
const struct component_master_ops *ops)
{
struct master *m;
struct aggregate_device *m;
list_for_each_entry(m, &masters, node)
list_for_each_entry(m, &aggregate_devices, node)
if (m->parent == parent && (!ops || m->ops == ops))
return m;
return NULL;
}
static struct component *find_component(struct master *master,
static struct component *find_component(struct aggregate_device *adev,
struct component_match_array *mc)
{
struct component *c;
list_for_each_entry(c, &component_list, node) {
if (c->master && c->master != master)
if (c->adev && c->adev != adev)
continue;
if (mc->compare && mc->compare(c->dev, mc->data))
@ -174,102 +170,103 @@ static struct component *find_component(struct master *master,
return NULL;
}
static int find_components(struct master *master)
static int find_components(struct aggregate_device *adev)
{
struct component_match *match = master->match;
struct component_match *match = adev->match;
size_t i;
int ret = 0;
/*
* Scan the array of match functions and attach
* any components which are found to this master.
* any components which are found to this adev.
*/
for (i = 0; i < match->num; i++) {
struct component_match_array *mc = &match->compare[i];
struct component *c;
dev_dbg(master->parent, "Looking for component %zu\n", i);
dev_dbg(adev->parent, "Looking for component %zu\n", i);
if (match->compare[i].component)
continue;
c = find_component(master, mc);
c = find_component(adev, mc);
if (!c) {
ret = -ENXIO;
break;
}
dev_dbg(master->parent, "found component %s, duplicate %u\n", dev_name(c->dev), !!c->master);
dev_dbg(adev->parent, "found component %s, duplicate %u\n",
dev_name(c->dev), !!c->adev);
/* Attach this component to the master */
match->compare[i].duplicate = !!c->master;
/* Attach this component to the adev */
match->compare[i].duplicate = !!c->adev;
match->compare[i].component = c;
c->master = master;
c->adev = adev;
}
return ret;
}
/* Detach component from associated master */
static void remove_component(struct master *master, struct component *c)
/* Detach component from associated aggregate_device */
static void remove_component(struct aggregate_device *adev, struct component *c)
{
size_t i;
/* Detach the component from this master. */
for (i = 0; i < master->match->num; i++)
if (master->match->compare[i].component == c)
master->match->compare[i].component = NULL;
/* Detach the component from this adev. */
for (i = 0; i < adev->match->num; i++)
if (adev->match->compare[i].component == c)
adev->match->compare[i].component = NULL;
}
/*
* Try to bring up a master. If component is NULL, we're interested in
* this master, otherwise it's a component which must be present to try
* and bring up the master.
* Try to bring up an aggregate device. If component is NULL, we're interested
* in this aggregate device, otherwise it's a component which must be present
* to try and bring up the aggregate device.
*
* Returns 1 for successful bringup, 0 if not ready, or -ve errno.
*/
static int try_to_bring_up_master(struct master *master,
static int try_to_bring_up_aggregate_device(struct aggregate_device *adev,
struct component *component)
{
int ret;
dev_dbg(master->parent, "trying to bring up master\n");
dev_dbg(adev->parent, "trying to bring up adev\n");
if (find_components(master)) {
dev_dbg(master->parent, "master has incomplete components\n");
if (find_components(adev)) {
dev_dbg(adev->parent, "master has incomplete components\n");
return 0;
}
if (component && component->master != master) {
dev_dbg(master->parent, "master is not for this component (%s)\n",
if (component && component->adev != adev) {
dev_dbg(adev->parent, "master is not for this component (%s)\n",
dev_name(component->dev));
return 0;
}
if (!devres_open_group(master->parent, master, GFP_KERNEL))
if (!devres_open_group(adev->parent, adev, GFP_KERNEL))
return -ENOMEM;
/* Found all components */
ret = master->ops->bind(master->parent);
ret = adev->ops->bind(adev->parent);
if (ret < 0) {
devres_release_group(master->parent, NULL);
devres_release_group(adev->parent, NULL);
if (ret != -EPROBE_DEFER)
dev_info(master->parent, "master bind failed: %d\n", ret);
dev_info(adev->parent, "adev bind failed: %d\n", ret);
return ret;
}
devres_close_group(master->parent, NULL);
master->bound = true;
devres_close_group(adev->parent, NULL);
adev->bound = true;
return 1;
}
static int try_to_bring_up_masters(struct component *component)
{
struct master *m;
struct aggregate_device *adev;
int ret = 0;
list_for_each_entry(m, &masters, node) {
if (!m->bound) {
ret = try_to_bring_up_master(m, component);
list_for_each_entry(adev, &aggregate_devices, node) {
if (!adev->bound) {
ret = try_to_bring_up_aggregate_device(adev, component);
if (ret != 0)
break;
}
@ -278,15 +275,72 @@ static int try_to_bring_up_masters(struct component *component)
return ret;
}
static void take_down_master(struct master *master)
static void take_down_aggregate_device(struct aggregate_device *adev)
{
if (master->bound) {
master->ops->unbind(master->parent);
devres_release_group(master->parent, master);
master->bound = false;
if (adev->bound) {
adev->ops->unbind(adev->parent);
devres_release_group(adev->parent, adev);
adev->bound = false;
}
}
/**
* component_compare_of - A common component compare function for of_node
* @dev: component device
* @data: @compare_data from component_match_add_release()
*
* A common compare function when compare_data is device of_node. e.g.
* component_match_add_release(masterdev, &match, component_release_of,
* component_compare_of, component_dev_of_node)
*/
int component_compare_of(struct device *dev, void *data)
{
return device_match_of_node(dev, data);
}
EXPORT_SYMBOL_GPL(component_compare_of);
/**
* component_release_of - A common component release function for of_node
* @dev: component device
* @data: @compare_data from component_match_add_release()
*
* About the example, Please see component_compare_of().
*/
void component_release_of(struct device *dev, void *data)
{
of_node_put(data);
}
EXPORT_SYMBOL_GPL(component_release_of);
/**
* component_compare_dev - A common component compare function for dev
* @dev: component device
* @data: @compare_data from component_match_add_release()
*
* A common compare function when compare_data is struce device. e.g.
* component_match_add(masterdev, &match, component_compare_dev, component_dev)
*/
int component_compare_dev(struct device *dev, void *data)
{
return dev == data;
}
EXPORT_SYMBOL_GPL(component_compare_dev);
/**
* component_compare_dev_name - A common component compare function for device name
* @dev: component device
* @data: @compare_data from component_match_add_release()
*
* A common compare function when compare_data is device name string. e.g.
* component_match_add(masterdev, &match, component_compare_dev_name,
* "component_dev_name")
*/
int component_compare_dev_name(struct device *dev, void *data)
{
return device_match_name(dev, data);
}
EXPORT_SYMBOL_GPL(component_compare_dev_name);
static void devm_component_match_release(struct device *parent, void *res)
{
struct component_match *match = res;
@ -324,7 +378,7 @@ static int component_match_realloc(struct component_match *match, size_t num)
return 0;
}
static void __component_match_add(struct device *master,
static void __component_match_add(struct device *parent,
struct component_match **matchptr,
void (*release)(struct device *, void *),
int (*compare)(struct device *, void *),
@ -344,7 +398,7 @@ static void __component_match_add(struct device *master,
return;
}
devres_add(master, match);
devres_add(parent, match);
*matchptr = match;
}
@ -370,13 +424,13 @@ static void __component_match_add(struct device *master,
/**
* component_match_add_release - add a component match entry with release callback
* @master: device with the aggregate driver
* @parent: parent device of the aggregate driver
* @matchptr: pointer to the list of component matches
* @release: release function for @compare_data
* @compare: compare function to match against all components
* @compare_data: opaque pointer passed to the @compare function
*
* Adds a new component match to the list stored in @matchptr, which the @master
* Adds a new component match to the list stored in @matchptr, which the
* aggregate driver needs to function. The list of component matches pointed to
* by @matchptr must be initialized to NULL before adding the first match. This
* only matches against components added with component_add().
@ -388,24 +442,24 @@ static void __component_match_add(struct device *master,
*
* See also component_match_add() and component_match_add_typed().
*/
void component_match_add_release(struct device *master,
void component_match_add_release(struct device *parent,
struct component_match **matchptr,
void (*release)(struct device *, void *),
int (*compare)(struct device *, void *), void *compare_data)
{
__component_match_add(master, matchptr, release, compare, NULL,
__component_match_add(parent, matchptr, release, compare, NULL,
compare_data);
}
EXPORT_SYMBOL(component_match_add_release);
/**
* component_match_add_typed - add a component match entry for a typed component
* @master: device with the aggregate driver
* @parent: parent device of the aggregate driver
* @matchptr: pointer to the list of component matches
* @compare_typed: compare function to match against all typed components
* @compare_data: opaque pointer passed to the @compare function
*
* Adds a new component match to the list stored in @matchptr, which the @master
* Adds a new component match to the list stored in @matchptr, which the
* aggregate driver needs to function. The list of component matches pointed to
* by @matchptr must be initialized to NULL before adding the first match. This
* only matches against components added with component_add_typed().
@ -415,32 +469,32 @@ EXPORT_SYMBOL(component_match_add_release);
*
* See also component_match_add_release() and component_match_add_typed().
*/
void component_match_add_typed(struct device *master,
void component_match_add_typed(struct device *parent,
struct component_match **matchptr,
int (*compare_typed)(struct device *, int, void *), void *compare_data)
{
__component_match_add(master, matchptr, NULL, NULL, compare_typed,
__component_match_add(parent, matchptr, NULL, NULL, compare_typed,
compare_data);
}
EXPORT_SYMBOL(component_match_add_typed);
static void free_master(struct master *master)
static void free_aggregate_device(struct aggregate_device *adev)
{
struct component_match *match = master->match;
struct component_match *match = adev->match;
int i;
component_master_debugfs_del(master);
list_del(&master->node);
component_debugfs_del(adev);
list_del(&adev->node);
if (match) {
for (i = 0; i < match->num; i++) {
struct component *c = match->compare[i].component;
if (c)
c->master = NULL;
c->adev = NULL;
}
}
kfree(master);
kfree(adev);
}
/**
@ -459,7 +513,7 @@ int component_master_add_with_match(struct device *parent,
const struct component_master_ops *ops,
struct component_match *match)
{
struct master *master;
struct aggregate_device *adev;
int ret;
/* Reallocate the match array for its true size */
@ -467,23 +521,23 @@ int component_master_add_with_match(struct device *parent,
if (ret)
return ret;
master = kzalloc(sizeof(*master), GFP_KERNEL);
if (!master)
adev = kzalloc(sizeof(*adev), GFP_KERNEL);
if (!adev)
return -ENOMEM;
master->parent = parent;
master->ops = ops;
master->match = match;
adev->parent = parent;
adev->ops = ops;
adev->match = match;
component_master_debugfs_add(master);
/* Add to the list of available masters. */
component_debugfs_add(adev);
/* Add to the list of available aggregate devices. */
mutex_lock(&component_mutex);
list_add(&master->node, &masters);
list_add(&adev->node, &aggregate_devices);
ret = try_to_bring_up_master(master, NULL);
ret = try_to_bring_up_aggregate_device(adev, NULL);
if (ret < 0)
free_master(master);
free_aggregate_device(adev);
mutex_unlock(&component_mutex);
@ -503,25 +557,25 @@ EXPORT_SYMBOL_GPL(component_master_add_with_match);
void component_master_del(struct device *parent,
const struct component_master_ops *ops)
{
struct master *master;
struct aggregate_device *adev;
mutex_lock(&component_mutex);
master = __master_find(parent, ops);
if (master) {
take_down_master(master);
free_master(master);
adev = __aggregate_find(parent, ops);
if (adev) {
take_down_aggregate_device(adev);
free_aggregate_device(adev);
}
mutex_unlock(&component_mutex);
}
EXPORT_SYMBOL_GPL(component_master_del);
static void component_unbind(struct component *component,
struct master *master, void *data)
struct aggregate_device *adev, void *data)
{
WARN_ON(!component->bound);
if (component->ops && component->ops->unbind)
component->ops->unbind(component->dev, master->parent, data);
component->ops->unbind(component->dev, adev->parent, data);
component->bound = false;
/* Release all resources claimed in the binding of this component */
@ -539,26 +593,26 @@ static void component_unbind(struct component *component,
*/
void component_unbind_all(struct device *parent, void *data)
{
struct master *master;
struct aggregate_device *adev;
struct component *c;
size_t i;
WARN_ON(!mutex_is_locked(&component_mutex));
master = __master_find(parent, NULL);
if (!master)
adev = __aggregate_find(parent, NULL);
if (!adev)
return;
/* Unbind components in reverse order */
for (i = master->match->num; i--; )
if (!master->match->compare[i].duplicate) {
c = master->match->compare[i].component;
component_unbind(c, master, data);
for (i = adev->match->num; i--; )
if (!adev->match->compare[i].duplicate) {
c = adev->match->compare[i].component;
component_unbind(c, adev, data);
}
}
EXPORT_SYMBOL_GPL(component_unbind_all);
static int component_bind(struct component *component, struct master *master,
static int component_bind(struct component *component, struct aggregate_device *adev,
void *data)
{
int ret;
@ -568,7 +622,7 @@ static int component_bind(struct component *component, struct master *master,
* This allows us to roll-back a failed component without
* affecting anything else.
*/
if (!devres_open_group(master->parent, NULL, GFP_KERNEL))
if (!devres_open_group(adev->parent, NULL, GFP_KERNEL))
return -ENOMEM;
/*
@ -577,14 +631,14 @@ static int component_bind(struct component *component, struct master *master,
* at the appropriate moment.
*/
if (!devres_open_group(component->dev, component, GFP_KERNEL)) {
devres_release_group(master->parent, NULL);
devres_release_group(adev->parent, NULL);
return -ENOMEM;
}
dev_dbg(master->parent, "binding %s (ops %ps)\n",
dev_dbg(adev->parent, "binding %s (ops %ps)\n",
dev_name(component->dev), component->ops);
ret = component->ops->bind(component->dev, master->parent, data);
ret = component->ops->bind(component->dev, adev->parent, data);
if (!ret) {
component->bound = true;
@ -595,16 +649,16 @@ static int component_bind(struct component *component, struct master *master,
* can clean those resources up independently.
*/
devres_close_group(component->dev, NULL);
devres_remove_group(master->parent, NULL);
devres_remove_group(adev->parent, NULL);
dev_info(master->parent, "bound %s (ops %ps)\n",
dev_info(adev->parent, "bound %s (ops %ps)\n",
dev_name(component->dev), component->ops);
} else {
devres_release_group(component->dev, NULL);
devres_release_group(master->parent, NULL);
devres_release_group(adev->parent, NULL);
if (ret != -EPROBE_DEFER)
dev_err(master->parent, "failed to bind %s (ops %ps): %d\n",
dev_err(adev->parent, "failed to bind %s (ops %ps): %d\n",
dev_name(component->dev), component->ops, ret);
}
@ -622,31 +676,31 @@ static int component_bind(struct component *component, struct master *master,
*/
int component_bind_all(struct device *parent, void *data)
{
struct master *master;
struct aggregate_device *adev;
struct component *c;
size_t i;
int ret = 0;
WARN_ON(!mutex_is_locked(&component_mutex));
master = __master_find(parent, NULL);
if (!master)
adev = __aggregate_find(parent, NULL);
if (!adev)
return -EINVAL;
/* Bind components in match order */
for (i = 0; i < master->match->num; i++)
if (!master->match->compare[i].duplicate) {
c = master->match->compare[i].component;
ret = component_bind(c, master, data);
for (i = 0; i < adev->match->num; i++)
if (!adev->match->compare[i].duplicate) {
c = adev->match->compare[i].component;
ret = component_bind(c, adev, data);
if (ret)
break;
}
if (ret != 0) {
for (; i > 0; i--)
if (!master->match->compare[i - 1].duplicate) {
c = master->match->compare[i - 1].component;
component_unbind(c, master, data);
if (!adev->match->compare[i - 1].duplicate) {
c = adev->match->compare[i - 1].component;
component_unbind(c, adev, data);
}
}
@ -675,8 +729,8 @@ static int __component_add(struct device *dev, const struct component_ops *ops,
ret = try_to_bring_up_masters(component);
if (ret < 0) {
if (component->master)
remove_component(component->master, component);
if (component->adev)
remove_component(component->adev, component);
list_del(&component->node);
kfree(component);
@ -757,9 +811,9 @@ void component_del(struct device *dev, const struct component_ops *ops)
break;
}
if (component && component->master) {
take_down_master(component->master);
remove_component(component->master, component);
if (component && component->adev) {
take_down_aggregate_device(component->adev);
remove_component(component->adev, component);
}
mutex_unlock(&component_mutex);

88
drivers/base/dd.c
View File

@ -152,7 +152,7 @@ void driver_deferred_probe_del(struct device *dev)
mutex_unlock(&deferred_probe_mutex);
}
static bool driver_deferred_probe_enable = false;
static bool driver_deferred_probe_enable;
/**
* driver_deferred_probe_trigger() - Kick off re-probing deferred devices
*
@ -506,6 +506,30 @@ static ssize_t state_synced_show(struct device *dev,
}
static DEVICE_ATTR_RO(state_synced);
static void device_unbind_cleanup(struct device *dev)
{
devres_release_all(dev);
arch_teardown_dma_ops(dev);
kfree(dev->dma_range_map);
dev->dma_range_map = NULL;
dev->driver = NULL;
dev_set_drvdata(dev, NULL);
if (dev->pm_domain && dev->pm_domain->dismiss)
dev->pm_domain->dismiss(dev);
pm_runtime_reinit(dev);
dev_pm_set_driver_flags(dev, 0);
}
static void device_remove(struct device *dev)
{
device_remove_file(dev, &dev_attr_state_synced);
device_remove_groups(dev, dev->driver->dev_groups);
if (dev->bus && dev->bus->remove)
dev->bus->remove(dev);
else if (dev->driver->remove)
dev->driver->remove(dev);
}
static int call_driver_probe(struct device *dev, struct device_driver *drv)
{
@ -620,24 +644,9 @@ re_probe:
if (test_remove) {
test_remove = false;
device_remove_file(dev, &dev_attr_state_synced);
device_remove_groups(dev, drv->dev_groups);
if (dev->bus->remove)
dev->bus->remove(dev);
else if (drv->remove)
drv->remove(dev);
devres_release_all(dev);
arch_teardown_dma_ops(dev);
kfree(dev->dma_range_map);
dev->dma_range_map = NULL;
device_remove(dev);
driver_sysfs_remove(dev);
dev->driver = NULL;
dev_set_drvdata(dev, NULL);
if (dev->pm_domain && dev->pm_domain->dismiss)
dev->pm_domain->dismiss(dev);
pm_runtime_reinit(dev);
device_unbind_cleanup(dev);
goto re_probe;
}
@ -653,12 +662,8 @@ re_probe:
goto done;
dev_sysfs_state_synced_failed:
device_remove_groups(dev, drv->dev_groups);
dev_groups_failed:
if (dev->bus->remove)
dev->bus->remove(dev);
else if (drv->remove)
drv->remove(dev);
device_remove(dev);
probe_failed:
driver_sysfs_remove(dev);
sysfs_failed:
@ -667,16 +672,7 @@ sysfs_failed:
BUS_NOTIFY_DRIVER_NOT_BOUND, dev);
pinctrl_bind_failed:
device_links_no_driver(dev);
devres_release_all(dev);
arch_teardown_dma_ops(dev);
kfree(dev->dma_range_map);
dev->dma_range_map = NULL;
dev->driver = NULL;
dev_set_drvdata(dev, NULL);
if (dev->pm_domain && dev->pm_domain->dismiss)
dev->pm_domain->dismiss(dev);
pm_runtime_reinit(dev);
dev_pm_set_driver_flags(dev, 0);
device_unbind_cleanup(dev);
done:
return ret;
}
@ -810,7 +806,7 @@ static int __init save_async_options(char *buf)
pr_warn("Too long list of driver names for 'driver_async_probe'!\n");
strlcpy(async_probe_drv_names, buf, ASYNC_DRV_NAMES_MAX_LEN);
return 0;
return 1;
}
__setup("driver_async_probe=", save_async_options);
@ -838,7 +834,7 @@ struct device_attach_data {
struct device *dev;
/*
* Indicates whether we are are considering asynchronous probing or
* Indicates whether we are considering asynchronous probing or
* not. Only initial binding after device or driver registration
* (including deferral processing) may be done asynchronously, the
* rest is always synchronous, as we expect it is being done by
@ -1042,7 +1038,7 @@ static void __device_driver_lock(struct device *dev, struct device *parent)
* @parent: Parent device. Needed if the bus requires parent lock
*
* This function will release the required locks for manipulating dev->drv.
* Normally this will just be the the @dev lock, but when called for a
* Normally this will just be the @dev lock, but when called for a
* USB interface, @parent lock will be released as well.
*/
static void __device_driver_unlock(struct device *dev, struct device *parent)
@ -1200,26 +1196,10 @@ static void __device_release_driver(struct device *dev, struct device *parent)
pm_runtime_put_sync(dev);
device_remove_file(dev, &dev_attr_state_synced);
device_remove_groups(dev, drv->dev_groups);
if (dev->bus && dev->bus->remove)
dev->bus->remove(dev);
else if (drv->remove)
drv->remove(dev);
device_remove(dev);
device_links_driver_cleanup(dev);
devres_release_all(dev);
arch_teardown_dma_ops(dev);
kfree(dev->dma_range_map);
dev->dma_range_map = NULL;
dev->driver = NULL;
dev_set_drvdata(dev, NULL);
if (dev->pm_domain && dev->pm_domain->dismiss)
dev->pm_domain->dismiss(dev);
pm_runtime_reinit(dev);
dev_pm_set_driver_flags(dev, 0);
device_unbind_cleanup(dev);
klist_remove(&dev->p->knode_driver);
device_pm_check_callbacks(dev);

4
drivers/base/devres.c
View File

@ -692,7 +692,7 @@ EXPORT_SYMBOL_GPL(devres_release_group);
/*
* Custom devres actions allow inserting a simple function call
* into the teadown sequence.
* into the teardown sequence.
*/
struct action_devres {
@ -916,7 +916,7 @@ void *devm_krealloc(struct device *dev, void *ptr, size_t new_size, gfp_t gfp)
/*
* We can copy the memory contents after releasing the lock as we're
* no longer modyfing the list links.
* no longer modifying the list links.
*/
memcpy(new_dr->data, old_dr->data,
total_old_size - offsetof(struct devres, data));

2
drivers/base/devtmpfs.c
View File

@ -81,10 +81,8 @@ static struct file_system_type internal_fs_type = {
.name = "devtmpfs",
#ifdef CONFIG_TMPFS
.init_fs_context = shmem_init_fs_context,
.parameters = shmem_fs_parameters,
#else
.init_fs_context = ramfs_init_fs_context,
.parameters = ramfs_fs_parameters,
#endif
.kill_sb = kill_litter_super,
};

5
drivers/base/firmware_loader/Kconfig
View File

@ -60,6 +60,8 @@ config EXTRA_FIRMWARE
image since it combines both GPL and non-GPL work. You should
consult a lawyer of your own before distributing such an image.
NOTE: Compressed files are not supported in EXTRA_FIRMWARE.
config EXTRA_FIRMWARE_DIR
string "Firmware blobs root directory"
depends on EXTRA_FIRMWARE != ""
@ -169,6 +171,9 @@ config FW_LOADER_COMPRESS
be compressed with either none or crc32 integrity check type (pass
"-C crc32" option to xz command).
Compressed firmware support does not apply to firmware images
that are built into the kernel image (CONFIG_EXTRA_FIRMWARE).
config FW_CACHE
bool "Enable firmware caching during suspend"
depends on PM_SLEEP

6
drivers/base/platform.c
View File

@ -467,9 +467,9 @@ int platform_get_irq_byname(struct platform_device *dev, const char *name)
int ret;
ret = __platform_get_irq_byname(dev, name);
if (ret < 0 && ret != -EPROBE_DEFER)
dev_err(&dev->dev, "IRQ %s not found\n", name);
if (ret < 0)
return dev_err_probe(&dev->dev, ret, "IRQ %s not found\n",
name);
return ret;
}
EXPORT_SYMBOL_GPL(platform_get_irq_byname);

14
drivers/base/soc.c
View File

@ -241,15 +241,13 @@ static int soc_device_match_one(struct device *dev, void *arg)
const struct soc_device_attribute *soc_device_match(
const struct soc_device_attribute *matches)
{
int ret = 0;
int ret;
if (!matches)
return NULL;
while (!ret) {
if (!(matches->machine || matches->family ||
matches->revision || matches->soc_id))
break;
while (matches->machine || matches->family || matches->revision ||
matches->soc_id) {
ret = bus_for_each_dev(&soc_bus_type, NULL, (void *)matches,
soc_device_match_one);
if (ret < 0 && early_soc_dev_attr)
@ -257,10 +255,10 @@ const struct soc_device_attribute *soc_device_match(
matches);
if (ret < 0)
return NULL;
if (!ret)
matches++;
else
if (ret)
return matches;
matches++;
}
return NULL;
}

7
drivers/gpu/drm/arm/display/komeda/komeda_drv.c
View File

@ -93,11 +93,6 @@ static const struct component_master_ops komeda_master_ops = {
.unbind = komeda_unbind,
};
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static void komeda_add_slave(struct device *master,
struct component_match **match,
struct device_node *np,
@ -107,7 +102,7 @@ static void komeda_add_slave(struct device *master,
remote = of_graph_get_remote_node(np, port, endpoint);
if (remote) {
drm_of_component_match_add(master, match, compare_of, remote);
drm_of_component_match_add(master, match, component_compare_of, remote);
of_node_put(remote);
}
}

17
drivers/gpu/drm/armada/armada_drv.c
View File

@ -177,17 +177,6 @@ static void armada_drm_unbind(struct device *dev)
drm_mm_takedown(&priv->linear);
}
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static int compare_dev_name(struct device *dev, void *data)
{
const char *name = data;
return !strcmp(dev_name(dev), name);
}
static void armada_add_endpoints(struct device *dev,
struct component_match **match, struct device_node *dev_node)
{
@ -196,7 +185,7 @@ static void armada_add_endpoints(struct device *dev,
for_each_endpoint_of_node(dev_node, ep) {
remote = of_graph_get_remote_port_parent(ep);
if (remote && of_device_is_available(remote))
drm_of_component_match_add(dev, match, compare_of,
drm_of_component_match_add(dev, match, component_compare_of,
remote);
of_node_put(remote);
}
@ -213,7 +202,7 @@ static int armada_drm_probe(struct platform_device *pdev)
struct device *dev = &pdev->dev;
int ret;
ret = drm_of_component_probe(dev, compare_dev_name, &armada_master_ops);
ret = drm_of_component_probe(dev, component_compare_dev_name, &armada_master_ops);
if (ret != -EINVAL)
return ret;
@ -223,7 +212,7 @@ static int armada_drm_probe(struct platform_device *pdev)
int i;
for (i = 0; devices[i]; i++)
component_match_add(dev, &match, compare_dev_name,
component_match_add(dev, &match, component_compare_dev_name,
devices[i]);
if (i == 0) {

7
drivers/gpu/drm/drm_of.c
View File

@ -18,11 +18,6 @@
* properties.
*/
static void drm_release_of(struct device *dev, void *data)
{
of_node_put(data);
}
/**
* drm_of_crtc_port_mask - find the mask of a registered CRTC by port OF node
* @dev: DRM device
@ -94,7 +89,7 @@ void drm_of_component_match_add(struct device *master,
struct device_node *node)
{
of_node_get(node);
component_match_add_release(master, matchptr, drm_release_of,
component_match_add_release(master, matchptr, component_release_of,
compare, node);
}
EXPORT_SYMBOL_GPL(drm_of_component_match_add);

16
drivers/gpu/drm/etnaviv/etnaviv_drv.c
View File

@ -574,18 +574,6 @@ static const struct component_master_ops etnaviv_master_ops = {
.unbind = etnaviv_unbind,
};
static int compare_of(struct device *dev, void *data)
{
struct device_node *np = data;
return dev->of_node == np;
}
static int compare_str(struct device *dev, void *data)
{
return !strcmp(dev_name(dev), data);
}
static int etnaviv_pdev_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@ -603,14 +591,14 @@ static int etnaviv_pdev_probe(struct platform_device *pdev)
first_node = core_node;
drm_of_component_match_add(&pdev->dev, &match,
compare_of, core_node);
component_compare_of, core_node);
}
} else {
char **names = dev->platform_data;
unsigned i;
for (i = 0; names[i]; i++)
component_match_add(dev, &match, compare_str, names[i]);
component_match_add(dev, &match, component_compare_dev_name, names[i]);
}
/*

8
drivers/gpu/drm/exynos/exynos_drm_drv.c
View File

@ -212,11 +212,6 @@ static struct exynos_drm_driver_info exynos_drm_drivers[] = {
}
};
static int compare_dev(struct device *dev, void *data)
{
return dev == (struct device *)data;
}
static struct component_match *exynos_drm_match_add(struct device *dev)
{
struct component_match *match = NULL;
@ -234,8 +229,7 @@ static struct component_match *exynos_drm_match_add(struct device *dev)
if (!(info->flags & DRM_FIMC_DEVICE) ||
exynos_drm_check_fimc_device(d) == 0)
component_match_add(dev, &match,
compare_dev, d);
component_match_add(dev, &match, component_compare_dev, d);
p = d;
}
put_device(p);

7
drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
View File

@ -204,11 +204,6 @@ err_mode_config_cleanup:
return ret;
}
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static int kirin_drm_kms_cleanup(struct drm_device *dev)
{
drm_kms_helper_poll_fini(dev);
@ -279,7 +274,7 @@ static int kirin_drm_platform_probe(struct platform_device *pdev)
if (!remote)
return -ENODEV;
drm_of_component_match_add(dev, &match, compare_of, remote);
drm_of_component_match_add(dev, &match, component_compare_of, remote);
of_node_put(remote);
return component_master_add_with_match(dev, &kirin_drm_ops, match);

7
drivers/gpu/drm/ingenic/ingenic-drm-drv.c
View File

@ -1371,11 +1371,6 @@ static int ingenic_drm_bind_with_components(struct device *dev)
return ingenic_drm_bind(dev, true);
}
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static void ingenic_drm_unbind(struct device *dev)
{
struct ingenic_drm *priv = dev_get_drvdata(dev);
@ -1409,7 +1404,7 @@ static int ingenic_drm_probe(struct platform_device *pdev)
if (!np)
return ingenic_drm_bind(dev, false);
drm_of_component_match_add(dev, &match, compare_of, np);
drm_of_component_match_add(dev, &match, component_compare_of, np);
of_node_put(np);
return component_master_add_with_match(dev, &ingenic_master_ops, match);

7
drivers/gpu/drm/mcde/mcde_drv.c
View File

@ -265,11 +265,6 @@ static struct platform_driver *const mcde_component_drivers[] = {
&mcde_dsi_driver,
};
static int mcde_compare_dev(struct device *dev, void *data)
{
return dev == data;
}
static int mcde_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@ -399,7 +394,7 @@ static int mcde_probe(struct platform_device *pdev)
while ((d = platform_find_device_by_driver(p, drv))) {
put_device(p);
component_match_add(dev, &match, mcde_compare_dev, d);
component_match_add(dev, &match, component_compare_dev, d);
p = d;
}
put_device(p);

7
drivers/gpu/drm/mediatek/mtk_drm_drv.c
View File

@ -372,11 +372,6 @@ static const struct drm_driver mtk_drm_driver = {
.minor = DRIVER_MINOR,
};
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static int mtk_drm_bind(struct device *dev)
{
struct mtk_drm_private *private = dev_get_drvdata(dev);
@ -617,7 +612,7 @@ static int mtk_drm_probe(struct platform_device *pdev)
comp_type == MTK_DSI) {
dev_info(dev, "Adding component match for %pOF\n",
node);
drm_of_component_match_add(dev, &match, compare_of,
drm_of_component_match_add(dev, &match, component_compare_of,
node);
}

10
drivers/gpu/drm/meson/meson_drv.c
View File

@ -425,14 +425,6 @@ static int __maybe_unused meson_drv_pm_resume(struct device *dev)
return drm_mode_config_helper_resume(priv->drm);
}
static int compare_of(struct device *dev, void *data)
{
DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
dev->of_node, data);
return dev->of_node == data;
}
static void meson_drv_shutdown(struct platform_device *pdev)
{
struct meson_drm *priv = dev_get_drvdata(&pdev->dev);
@ -475,7 +467,7 @@ static int meson_drv_probe(struct platform_device *pdev)
dev_dbg(&pdev->dev, "parent %pOF remote match add %pOF parent %s\n",
np, remote, dev_name(&pdev->dev));
component_match_add(&pdev->dev, &match, compare_of, remote);
component_match_add(&pdev->dev, &match, component_compare_of, remote);
of_node_put(remote);

15
drivers/gpu/drm/msm/msm_drv.c
View File

@ -1049,15 +1049,6 @@ static const struct dev_pm_ops msm_pm_ops = {
* Componentized driver support:
*/
/*
* NOTE: duplication of the same code as exynos or imx (or probably any other).
* so probably some room for some helpers
*/
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
/*
* Identify what components need to be added by parsing what remote-endpoints
* our MDP output ports are connected to. In the case of LVDS on MDP4, there
@ -1115,7 +1106,7 @@ static int add_components_mdp(struct device *mdp_dev,
if (of_device_is_available(intf))
drm_of_component_match_add(master_dev, matchptr,
compare_of, intf);
component_compare_of, intf);
of_node_put(intf);
}
@ -1161,7 +1152,7 @@ static int add_display_components(struct platform_device *pdev,
put_device(mdp_dev);
/* add the MDP component itself */
drm_of_component_match_add(dev, matchptr, compare_of,
drm_of_component_match_add(dev, matchptr, component_compare_of,
mdp_dev->of_node);
break;
case KMS_MDP4:
@ -1200,7 +1191,7 @@ static int add_gpu_components(struct device *dev,
return 0;
if (of_device_is_available(np))
drm_of_component_match_add(dev, matchptr, compare_of, np);
drm_of_component_match_add(dev, matchptr, component_compare_of, np);
of_node_put(np);

8
drivers/gpu/drm/omapdrm/dss/dss.c
View File

@ -1344,12 +1344,6 @@ static const struct component_master_ops dss_component_ops = {
.unbind = dss_unbind,
};
static int dss_component_compare(struct device *dev, void *data)
{
struct device *child = data;
return dev == child;
}
struct dss_component_match_data {
struct device *dev;
struct component_match **match;
@ -1379,7 +1373,7 @@ static int dss_add_child_component(struct device *dev, void *data)
return device_for_each_child(dev, cmatch,
dss_add_child_component);
component_match_add(cmatch->dev, match, dss_component_compare, dev);
component_match_add(cmatch->dev, match, component_compare_dev, dev);
return 0;
}

7
drivers/gpu/drm/rockchip/rockchip_drm_drv.c
View File

@ -290,11 +290,6 @@ int rockchip_drm_endpoint_is_subdriver(struct device_node *ep)
return false;
}
static int compare_dev(struct device *dev, void *data)
{
return dev == (struct device *)data;
}
static void rockchip_drm_match_remove(struct device *dev)
{
struct device_link *link;
@ -321,7 +316,7 @@ static struct component_match *rockchip_drm_match_add(struct device *dev)
break;
device_link_add(dev, d, DL_FLAG_STATELESS);
component_match_add(dev, &match, compare_dev, d);
component_match_add(dev, &match, component_compare_dev, d);
} while (true);
}

7
drivers/gpu/drm/sprd/sprd_drm.c
View File

@ -133,14 +133,9 @@ static const struct component_master_ops drm_component_ops = {
.unbind = sprd_drm_unbind,
};
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static int sprd_drm_probe(struct platform_device *pdev)
{
return drm_of_component_probe(&pdev->dev, compare_of, &drm_component_ops);
return drm_of_component_probe(&pdev->dev, component_compare_of, &drm_component_ops);
}
static int sprd_drm_remove(struct platform_device *pdev)

7
drivers/gpu/drm/sti/sti_drv.c
View File

@ -144,11 +144,6 @@ static const struct drm_driver sti_driver = {
.minor = DRIVER_MINOR,
};
static int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static int sti_init(struct drm_device *ddev)
{
struct sti_private *private;
@ -244,7 +239,7 @@ static int sti_platform_probe(struct platform_device *pdev)
child_np = of_get_next_available_child(node, NULL);
while (child_np) {
drm_of_component_match_add(dev, &match, compare_of,
drm_of_component_match_add(dev, &match, component_compare_of,
child_np);
child_np = of_get_next_available_child(node, child_np);
}

11
drivers/gpu/drm/sun4i/sun4i_drv.c
View File

@ -202,15 +202,6 @@ static bool sun4i_drv_node_is_tcon_top(struct device_node *node)
!!of_match_node(sun8i_tcon_top_of_table, node);
}
static int compare_of(struct device *dev, void *data)
{
DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
dev->of_node,
data);
return dev->of_node == data;
}
/*
* The encoder drivers use drm_of_find_possible_crtcs to get upstream
* crtcs from the device tree using of_graph. For the results to be
@ -330,7 +321,7 @@ static int sun4i_drv_add_endpoints(struct device *dev,
of_device_is_available(node))) {
/* Add current component */
DRM_DEBUG_DRIVER("Adding component %pOF\n", node);
drm_of_component_match_add(dev, match, compare_of, node);
drm_of_component_match_add(dev, match, component_compare_of, node);
count++;
}

7
drivers/gpu/drm/vc4/vc4_drv.c
View File

@ -189,11 +189,6 @@ static struct drm_driver vc4_drm_driver = {
.patchlevel = DRIVER_PATCHLEVEL,
};
static int compare_dev(struct device *dev, void *data)
{
return dev == data;
}
static void vc4_match_add_drivers(struct device *dev,
struct component_match **match,
struct platform_driver *const *drivers,
@ -207,7 +202,7 @@ static void vc4_match_add_drivers(struct device *dev,
while ((d = platform_find_device_by_driver(p, drv))) {
put_device(p);
component_match_add(dev, match, compare_dev, d);
component_match_add(dev, match, component_compare_dev, d);
p = d;
}
put_device(p);

4
drivers/iommu/mtk_iommu.c
View File

@ -883,8 +883,8 @@ static int mtk_iommu_probe(struct platform_device *pdev)
}
data->larb_imu[id].dev = &plarbdev->dev;
component_match_add_release(dev, &match, release_of,
compare_of, larbnode);
component_match_add_release(dev, &match, component_release_of,
component_compare_of, larbnode);
}
/* Get smi-common dev from the last larb. */

10
drivers/iommu/mtk_iommu.h
View File

@ -84,16 +84,6 @@ struct mtk_iommu_data {
struct mtk_smi_larb_iommu larb_imu[MTK_LARB_NR_MAX];
};
static inline int compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static inline void release_of(struct device *dev, void *data)
{
of_node_put(data);
}
static inline int mtk_iommu_bind(struct device *dev)
{
struct mtk_iommu_data *data = dev_get_drvdata(dev);

4
drivers/iommu/mtk_iommu_v1.c
View File

@ -641,8 +641,8 @@ static int mtk_iommu_probe(struct platform_device *pdev)
}
data->larb_imu[i].dev = &plarbdev->dev;
component_match_add_release(dev, &match, release_of,
compare_of, larbnode);
component_match_add_release(dev, &match, component_release_of,
component_compare_of, larbnode);
}
platform_set_drvdata(pdev, data);

3
drivers/md/bcache/stats.c
View File

@ -78,7 +78,7 @@ static void bch_stats_release(struct kobject *k)
{
}
static struct attribute *bch_stats_files[] = {
static struct attribute *bch_stats_attrs[] = {
&sysfs_cache_hits,
&sysfs_cache_misses,
&sysfs_cache_bypass_hits,
@ -88,6 +88,7 @@ static struct attribute *bch_stats_files[] = {
&sysfs_bypassed,
NULL
};
ATTRIBUTE_GROUPS(bch_stats);
static KTYPE(bch_stats);
int bch_cache_accounting_add_kobjs(struct cache_accounting *acc,

15
drivers/md/bcache/sysfs.c
View File

@ -500,7 +500,7 @@ STORE(bch_cached_dev)
return size;
}
static struct attribute *bch_cached_dev_files[] = {
static struct attribute *bch_cached_dev_attrs[] = {
&sysfs_attach,
&sysfs_detach,
&sysfs_stop,
@ -543,6 +543,7 @@ static struct attribute *bch_cached_dev_files[] = {
&sysfs_backing_dev_uuid,
NULL
};
ATTRIBUTE_GROUPS(bch_cached_dev);
KTYPE(bch_cached_dev);
SHOW(bch_flash_dev)
@ -600,7 +601,7 @@ STORE(__bch_flash_dev)
}
STORE_LOCKED(bch_flash_dev)
static struct attribute *bch_flash_dev_files[] = {
static struct attribute *bch_flash_dev_attrs[] = {
&sysfs_unregister,
#if 0
&sysfs_data_csum,
@ -609,6 +610,7 @@ static struct attribute *bch_flash_dev_files[] = {
&sysfs_size,
NULL
};
ATTRIBUTE_GROUPS(bch_flash_dev);
KTYPE(bch_flash_dev);
struct bset_stats_op {
@ -955,7 +957,7 @@ static void bch_cache_set_internal_release(struct kobject *k)
{
}
static struct attribute *bch_cache_set_files[] = {
static struct attribute *bch_cache_set_attrs[] = {
&sysfs_unregister,
&sysfs_stop,
&sysfs_synchronous,
@ -980,9 +982,10 @@ static struct attribute *bch_cache_set_files[] = {
&sysfs_clear_stats,
NULL
};
ATTRIBUTE_GROUPS(bch_cache_set);
KTYPE(bch_cache_set);
static struct attribute *bch_cache_set_internal_files[] = {
static struct attribute *bch_cache_set_internal_attrs[] = {
&sysfs_active_journal_entries,
sysfs_time_stats_attribute_list(btree_gc, sec, ms)
@ -1022,6 +1025,7 @@ static struct attribute *bch_cache_set_internal_files[] = {
&sysfs_feature_incompat,
NULL
};
ATTRIBUTE_GROUPS(bch_cache_set_internal);
KTYPE(bch_cache_set_internal);
static int __bch_cache_cmp(const void *l, const void *r)
@ -1182,7 +1186,7 @@ STORE(__bch_cache)
}
STORE_LOCKED(bch_cache)
static struct attribute *bch_cache_files[] = {
static struct attribute *bch_cache_attrs[] = {
&sysfs_bucket_size,
&sysfs_block_size,
&sysfs_nbuckets,
@ -1196,4 +1200,5 @@ static struct attribute *bch_cache_files[] = {
&sysfs_cache_replacement_policy,
NULL
};
ATTRIBUTE_GROUPS(bch_cache);
KTYPE(bch_cache);

2
drivers/md/bcache/sysfs.h
View File

@ -9,7 +9,7 @@ struct kobj_type type ## _ktype = { \
.show = type ## _show, \
.store = type ## _store \
}), \
.default_attrs = type ## _files \
.default_groups = type ## _groups \
}
#define SHOW(fn) \

8
drivers/power/supply/ab8500_charger.c
View File

@ -3421,11 +3421,6 @@ static struct platform_driver *const ab8500_charger_component_drivers[] = {
&ab8500_chargalg_driver,
};
static int ab8500_charger_compare_dev(struct device *dev, void *data)
{
return dev == data;
}
static int ab8500_charger_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@ -3666,8 +3661,7 @@ static int ab8500_charger_probe(struct platform_device *pdev)
while ((d = platform_find_device_by_driver(p, drv))) {
put_device(p);
component_match_add(dev, &match,
ab8500_charger_compare_dev, d);
component_match_add(dev, &match, component_compare_dev, d);
p = d;
}
put_device(p);

3
drivers/power/supply/ab8500_fg.c
View File

@ -2537,10 +2537,11 @@ static struct attribute *ab8500_fg_attrs[] = {
&charge_now_attr.attr,
NULL,
};
ATTRIBUTE_GROUPS(ab8500_fg);
static struct kobj_type ab8500_fg_ktype = {
.sysfs_ops = &ab8500_fg_sysfs_ops,
.default_attrs = ab8500_fg_attrs,
.default_groups = ab8500_fg_groups,
};
/**

8
drivers/video/fbdev/omap2/omapfb/dss/dss.c
View File

@ -1193,12 +1193,6 @@ static const struct component_master_ops dss_component_ops = {
.unbind = dss_unbind,
};
static int dss_component_compare(struct device *dev, void *data)
{
struct device *child = data;
return dev == child;
}
static int dss_add_child_component(struct device *dev, void *data)
{
struct component_match **match = data;
@ -1212,7 +1206,7 @@ static int dss_add_child_component(struct device *dev, void *data)
if (strstr(dev_name(dev), "rfbi"))
return 0;
component_match_add(dev->parent, match, dss_component_compare, dev);
component_match_add(dev->parent, match, component_compare_dev, dev);
return 0;
}

10
fs/debugfs/inode.c
View File

@ -450,6 +450,11 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
*
* If debugfs is not enabled in the kernel, the value -%ENODEV will be
* returned.
*
* NOTE: it's expected that most callers should _ignore_ the errors returned
* by this function. Other debugfs functions handle the fact that the "dentry"
* passed to them could be an error and they don't crash in that case.
* Drivers should generally work fine even if debugfs fails to init anyway.
*/
struct dentry *debugfs_create_file(const char *name, umode_t mode,
struct dentry *parent, void *data,
@ -551,6 +556,11 @@ EXPORT_SYMBOL_GPL(debugfs_create_file_size);
*
* If debugfs is not enabled in the kernel, the value -%ENODEV will be
* returned.
*
* NOTE: it's expected that most callers should _ignore_ the errors returned
* by this function. Other debugfs functions handle the fact that the "dentry"
* passed to them could be an error and they don't crash in that case.
* Drivers should generally work fine even if debugfs fails to init anyway.
*/
struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
{

9
fs/kernfs/dir.c
View File

@ -970,6 +970,15 @@ void kernfs_destroy_root(struct kernfs_root *root)
kernfs_put(root->kn); /* will also free @root */
}
/**
* kernfs_root_to_node - return the kernfs_node associated with a kernfs_root
* @root: root to use to lookup
*/
struct kernfs_node *kernfs_root_to_node(struct kernfs_root *root)
{
return root->kn;
}
/**
* kernfs_create_dir_ns - create a directory
* @parent: parent in which to create a new directory

2
fs/kernfs/file.c
View File

@ -1002,7 +1002,7 @@ struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
#endif
/*
* kn->attr.ops is accesible only while holding active ref. We
* kn->attr.ops is accessible only while holding active ref. We
* need to know whether some ops are implemented outside active
* ref. Cache their existence in flags.
*/

19
fs/kernfs/kernfs-internal.h
View File

@ -31,6 +31,24 @@ struct kernfs_iattrs {
atomic_t user_xattr_size;
};
struct kernfs_root {
/* published fields */
struct kernfs_node *kn;
unsigned int flags; /* KERNFS_ROOT_* flags */
/* private fields, do not use outside kernfs proper */
struct idr ino_idr;
u32 last_id_lowbits;
u32 id_highbits;
struct kernfs_syscall_ops *syscall_ops;
/* list of kernfs_super_info of this root, protected by kernfs_rwsem */
struct list_head supers;
wait_queue_head_t deactivate_waitq;
struct rw_semaphore kernfs_rwsem;
};
/* +1 to avoid triggering overflow warning when negating it */
#define KN_DEACTIVATED_BIAS (INT_MIN + 1)
@ -122,7 +140,6 @@ int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
/*
* dir.c
*/
extern struct rw_semaphore kernfs_rwsem;
extern const struct dentry_operations kernfs_dops;
extern const struct file_operations kernfs_dir_fops;
extern const struct inode_operations kernfs_dir_iops;

2
fs/sysfs/mount.c
View File

@ -103,7 +103,7 @@ int __init sysfs_init(void)
if (IS_ERR(sysfs_root))
return PTR_ERR(sysfs_root);
sysfs_root_kn = sysfs_root->kn;
sysfs_root_kn = kernfs_root_to_node(sysfs_root);
err = register_filesystem(&sysfs_fs_type);
if (err) {

3
fs/ubifs/sysfs.c
View File

@ -42,6 +42,7 @@ static struct attribute *ubifs_attrs[] = {
ATTR_LIST(errors_crc),
NULL,
};
ATTRIBUTE_GROUPS(ubifs);
static ssize_t ubifs_attr_show(struct kobject *kobj,
struct attribute *attr, char *buf)
@ -74,7 +75,7 @@ static const struct sysfs_ops ubifs_attr_ops = {
};
static struct kobj_type ubifs_sb_ktype = {
.default_attrs = ubifs_attrs,
.default_groups = ubifs_groups,
.sysfs_ops = &ubifs_attr_ops,
.release = ubifs_sb_release,
};

24
include/linux/component.h
View File

@ -38,10 +38,10 @@ int component_add_typed(struct device *dev, const struct component_ops *ops,
int subcomponent);
void component_del(struct device *, const struct component_ops *);
int component_bind_all(struct device *master, void *master_data);
void component_unbind_all(struct device *master, void *master_data);
int component_bind_all(struct device *parent, void *data);
void component_unbind_all(struct device *parent, void *data);
struct master;
struct aggregate_device;
/**
* struct component_master_ops - callback for the aggregate driver
@ -82,6 +82,12 @@ struct component_master_ops {
void (*unbind)(struct device *master);
};
/* A set helper functions for component compare/release */
int component_compare_of(struct device *dev, void *data);
void component_release_of(struct device *dev, void *data);
int component_compare_dev(struct device *dev, void *data);
int component_compare_dev_name(struct device *dev, void *data);
void component_master_del(struct device *,
const struct component_master_ops *);
@ -89,22 +95,22 @@ struct component_match;
int component_master_add_with_match(struct device *,
const struct component_master_ops *, struct component_match *);
void component_match_add_release(struct device *master,
void component_match_add_release(struct device *parent,
struct component_match **matchptr,
void (*release)(struct device *, void *),
int (*compare)(struct device *, void *), void *compare_data);
void component_match_add_typed(struct device *master,
void component_match_add_typed(struct device *parent,
struct component_match **matchptr,
int (*compare_typed)(struct device *, int, void *), void *compare_data);
/**
* component_match_add - add a component match entry
* @master: device with the aggregate driver
* @parent: device with the aggregate driver
* @matchptr: pointer to the list of component matches
* @compare: compare function to match against all components
* @compare_data: opaque pointer passed to the @compare function
*
* Adds a new component match to the list stored in @matchptr, which the @master
* Adds a new component match to the list stored in @matchptr, which the @parent
* aggregate driver needs to function. The list of component matches pointed to
* by @matchptr must be initialized to NULL before adding the first match. This
* only matches against components added with component_add().
@ -114,11 +120,11 @@ void component_match_add_typed(struct device *master,
*
* See also component_match_add_release() and component_match_add_typed().
*/
static inline void component_match_add(struct device *master,
static inline void component_match_add(struct device *parent,
struct component_match **matchptr,
int (*compare)(struct device *, void *), void *compare_data)
{
component_match_add_release(master, matchptr, NULL, compare,
component_match_add_release(parent, matchptr, NULL, compare,
compare_data);
}

2
include/linux/firmware.h
View File

@ -34,7 +34,7 @@ static inline bool firmware_request_builtin(struct firmware *fw,
}
#endif
#if defined(CONFIG_FW_LOADER) || (defined(CONFIG_FW_LOADER_MODULE) && defined(MODULE))
#if IS_REACHABLE(CONFIG_FW_LOADER)
int request_firmware(const struct firmware **fw, const char *name,
struct device *device);
int firmware_request_nowarn(const struct firmware **fw, const char *name,

18
include/linux/kernfs.h
View File

@ -185,23 +185,7 @@ struct kernfs_syscall_ops {
struct kernfs_root *root);
};
struct kernfs_root {
/* published fields */
struct kernfs_node *kn;
unsigned int flags; /* KERNFS_ROOT_* flags */
/* private fields, do not use outside kernfs proper */
struct idr ino_idr;
u32 last_id_lowbits;
u32 id_highbits;
struct kernfs_syscall_ops *syscall_ops;
/* list of kernfs_super_info of this root, protected by kernfs_rwsem */
struct list_head supers;
wait_queue_head_t deactivate_waitq;
struct rw_semaphore kernfs_rwsem;
};
struct kernfs_node *kernfs_root_to_node(struct kernfs_root *root);
struct kernfs_open_file {
/* published fields */

4
kernel/cgroup/cgroup.c
View File

@ -1302,7 +1302,7 @@ static struct css_set *find_css_set(struct css_set *old_cset,
struct cgroup_root *cgroup_root_from_kf(struct kernfs_root *kf_root)
{
struct cgroup *root_cgrp = kf_root->kn->priv;
struct cgroup *root_cgrp = kernfs_root_to_node(kf_root)->priv;
return root_cgrp->root;
}
@ -2025,7 +2025,7 @@ int cgroup_setup_root(struct cgroup_root *root, u16 ss_mask)
ret = PTR_ERR(root->kf_root);
goto exit_root_id;
}
root_cgrp->kn = root->kf_root->kn;
root_cgrp->kn = kernfs_root_to_node(root->kf_root);
WARN_ON_ONCE(cgroup_ino(root_cgrp) != 1);
root_cgrp->ancestor_ids[0] = cgroup_id(root_cgrp);

4
samples/kobject/kobject-example.c
View File

@ -28,7 +28,7 @@ static int bar;
static ssize_t foo_show(struct kobject *kobj, struct kobj_attribute *attr,
char *buf)
{
return sprintf(buf, "%d\n", foo);
return sysfs_emit(buf, "%d\n", foo);
}
static ssize_t foo_store(struct kobject *kobj, struct kobj_attribute *attr,
@ -60,7 +60,7 @@ static ssize_t b_show(struct kobject *kobj, struct kobj_attribute *attr,
var = baz;
else
var = bar;
return sprintf(buf, "%d\n", var);
return sysfs_emit(buf, "%d\n", var);
}
static ssize_t b_store(struct kobject *kobj, struct kobj_attribute *attr,

4
samples/kobject/kset-example.c
View File

@ -112,7 +112,7 @@ static void foo_release(struct kobject *kobj)
static ssize_t foo_show(struct foo_obj *foo_obj, struct foo_attribute *attr,
char *buf)
{
return sprintf(buf, "%d\n", foo_obj->foo);
return sysfs_emit(buf, "%d\n", foo_obj->foo);
}
static ssize_t foo_store(struct foo_obj *foo_obj, struct foo_attribute *attr,
@ -144,7 +144,7 @@ static ssize_t b_show(struct foo_obj *foo_obj, struct foo_attribute *attr,
var = foo_obj->baz;
else
var = foo_obj->bar;
return sprintf(buf, "%d\n", var);
return sysfs_emit(buf, "%d\n", var);
}
static ssize_t b_store(struct foo_obj *foo_obj, struct foo_attribute *attr,

3
scripts/get_abi.pl
View File

@ -92,6 +92,7 @@ sub parse_abi {
my $mode = (stat($file))[2];
return if ($mode & S_IFDIR);
return if ($file =~ m,/README,);
return if ($file =~ m,/\.,);
my $name = $file;
$name =~ s,.*/,,;
@ -987,7 +988,7 @@ abi_book.pl - parse the Linux ABI files and produce a ReST book.
B<abi_book.pl> [--debug <level>] [--enable-lineno] [--man] [--help]
[--(no-)rst-source] [--dir=<dir>] [--show-hints]
[--search-string <regex>]
<COMAND> [<ARGUMENT>]
<COMMAND> [<ARGUMENT>]
Where B<COMMAND> can be:

2
scripts/spdxcheck.py
View File

@ -200,7 +200,7 @@ class id_parser(object):
tok = pe.tok.value
sys.stdout.write('%s: %d:%d %s: %s\n' %(fname, self.curline, col, pe.txt, tok))
else:
sys.stdout.write('%s: %d:0 %s\n' %(fname, self.curline, col, pe.txt))
sys.stdout.write('%s: %d:0 %s\n' %(fname, self.curline, pe.txt))
self.spdx_errors += 1
def scan_git_tree(tree):

11
sound/pci/hda/patch_realtek.c
View File

@ -6581,11 +6581,6 @@ static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
}
}
static int comp_match_dev_name(struct device *dev, void *data)
{
return strcmp(dev_name(dev), data) == 0;
}
static int find_comp_by_dev_name(struct alc_spec *spec, const char *name)
{
int i;
@ -6646,7 +6641,7 @@ static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char
"%s-%s:00-cs35l41-hda.%d", bus, hid, i);
if (!name)
return;
component_match_add(dev, &spec->match, comp_match_dev_name, name);
component_match_add(dev, &spec->match, component_compare_dev_name, name);
}
ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
if (ret)
@ -6705,9 +6700,9 @@ static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const st
switch (action) {
case HDA_FIXUP_ACT_PRE_PROBE:
component_match_add(dev, &spec->match, comp_match_dev_name,
component_match_add(dev, &spec->match, component_compare_dev_name,
"i2c-CLSA0100:00-cs35l41-hda.0");
component_match_add(dev, &spec->match, comp_match_dev_name,
component_match_add(dev, &spec->match, component_compare_dev_name,
"i2c-CLSA0100:00-cs35l41-hda.1");
ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
if (ret)

18
sound/soc/codecs/wcd938x.c
View File

@ -4447,16 +4447,6 @@ static const struct component_master_ops wcd938x_comp_ops = {
.unbind = wcd938x_unbind,
};
static int wcd938x_compare_of(struct device *dev, void *data)
{
return dev->of_node == data;
}
static void wcd938x_release_of(struct device *dev, void *data)
{
of_node_put(data);
}
static int wcd938x_add_slave_components(struct wcd938x_priv *wcd938x,
struct device *dev,
struct component_match **matchptr)
@ -4472,8 +4462,8 @@ static int wcd938x_add_slave_components(struct wcd938x_priv *wcd938x,
}
of_node_get(wcd938x->rxnode);
component_match_add_release(dev, matchptr, wcd938x_release_of,
wcd938x_compare_of, wcd938x->rxnode);
component_match_add_release(dev, matchptr, component_release_of,
component_compare_of, wcd938x->rxnode);
wcd938x->txnode = of_parse_phandle(np, "qcom,tx-device", 0);
if (!wcd938x->txnode) {
@ -4481,8 +4471,8 @@ static int wcd938x_add_slave_components(struct wcd938x_priv *wcd938x,
return -ENODEV;
}
of_node_get(wcd938x->txnode);
component_match_add_release(dev, matchptr, wcd938x_release_of,
wcd938x_compare_of, wcd938x->txnode);
component_match_add_release(dev, matchptr, component_release_of,
component_compare_of, wcd938x->txnode);
return 0;
}