mirror of
https://github.com/torvalds/linux.git
synced 2024-11-24 21:21:41 +00:00
Driver core changes for 6.11-rc1
Here is the big set of driver core changes for 6.11-rc1. Lots of stuff in here, with not a huge diffstat, but apis are evolving which required lots of files to be touched. Highlights of the changes in here are: - platform remove callback api final fixups (Uwe took many releases to get here, finally!) - Rust bindings for basic firmware apis and initial driver-core interactions. It's not all that useful for a "write a whole driver in rust" type of thing, but the firmware bindings do help out the phy rust drivers, and the driver core bindings give a solid base on which others can start their work. There is still a long way to go here before we have a multitude of rust drivers being added, but it's a great first step. - driver core const api changes. This reached across all bus types, and there are some fix-ups for some not-common bus types that linux-next and 0-day testing shook out. This work is being done to help make the rust bindings more safe, as well as the C code, moving toward the end-goal of allowing us to put driver structures into read-only memory. We aren't there yet, but are getting closer. - minor devres cleanups and fixes found by code inspection - arch_topology minor changes - other minor driver core cleanups All of these have been in linux-next for a very long time with no reported problems. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> -----BEGIN PGP SIGNATURE----- iG0EABECAC0WIQT0tgzFv3jCIUoxPcsxR9QN2y37KQUCZqH+aQ8cZ3JlZ0Brcm9h aC5jb20ACgkQMUfUDdst+ymoOQCfVBdLcBjEDAGh3L8qHRGMPy4rV2EAoL/r+zKm cJEYtJpGtWX6aAtugm9E =ZyJV -----END PGP SIGNATURE----- Merge tag 'driver-core-6.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core Pull driver core updates from Greg KH: "Here is the big set of driver core changes for 6.11-rc1. Lots of stuff in here, with not a huge diffstat, but apis are evolving which required lots of files to be touched. Highlights of the changes in here are: - platform remove callback api final fixups (Uwe took many releases to get here, finally!) - Rust bindings for basic firmware apis and initial driver-core interactions. It's not all that useful for a "write a whole driver in rust" type of thing, but the firmware bindings do help out the phy rust drivers, and the driver core bindings give a solid base on which others can start their work. There is still a long way to go here before we have a multitude of rust drivers being added, but it's a great first step. - driver core const api changes. This reached across all bus types, and there are some fix-ups for some not-common bus types that linux-next and 0-day testing shook out. This work is being done to help make the rust bindings more safe, as well as the C code, moving toward the end-goal of allowing us to put driver structures into read-only memory. We aren't there yet, but are getting closer. - minor devres cleanups and fixes found by code inspection - arch_topology minor changes - other minor driver core cleanups All of these have been in linux-next for a very long time with no reported problems" * tag 'driver-core-6.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: (55 commits) ARM: sa1100: make match function take a const pointer sysfs/cpu: Make crash_hotplug attribute world-readable dio: Have dio_bus_match() callback take a const * zorro: make match function take a const pointer driver core: module: make module_[add|remove]_driver take a const * driver core: make driver_find_device() take a const * driver core: make driver_[create|remove]_file take a const * firmware_loader: fix soundness issue in `request_internal` firmware_loader: annotate doctests as `no_run` devres: Correct code style for functions that return a pointer type devres: Initialize an uninitialized struct member devres: Fix memory leakage caused by driver API devm_free_percpu() devres: Fix devm_krealloc() wasting memory driver core: platform: Switch to use kmemdup_array() driver core: have match() callback in struct bus_type take a const * MAINTAINERS: add Rust device abstractions to DRIVER CORE device: rust: improve safety comments MAINTAINERS: add Danilo as FIRMWARE LOADER maintainer MAINTAINERS: add Rust FW abstractions to FIRMWARE LOADER firmware: rust: improve safety comments ...
This commit is contained in:
commit
c2a96b7f18
@ -6850,6 +6850,7 @@ F: include/linux/fwnode.h
|
||||
F: include/linux/kobj*
|
||||
F: include/linux/property.h
|
||||
F: lib/kobj*
|
||||
F: rust/kernel/device.rs
|
||||
|
||||
DRIVERS FOR OMAP ADAPTIVE VOLTAGE SCALING (AVS)
|
||||
M: Nishanth Menon <nm@ti.com>
|
||||
@ -8716,10 +8717,12 @@ F: include/linux/arm_ffa.h
|
||||
FIRMWARE LOADER (request_firmware)
|
||||
M: Luis Chamberlain <mcgrof@kernel.org>
|
||||
M: Russ Weight <russ.weight@linux.dev>
|
||||
M: Danilo Krummrich <dakr@redhat.com>
|
||||
L: linux-kernel@vger.kernel.org
|
||||
S: Maintained
|
||||
F: Documentation/firmware_class/
|
||||
F: drivers/base/firmware_loader/
|
||||
F: rust/kernel/firmware.rs
|
||||
F: include/linux/firmware.h
|
||||
|
||||
FLEXTIMER FTM-QUADDEC DRIVER
|
||||
|
@ -816,10 +816,10 @@ EXPORT_SYMBOL(locomo_frontlight_set);
|
||||
* We model this as a regular bus type, and hang devices directly
|
||||
* off this.
|
||||
*/
|
||||
static int locomo_match(struct device *_dev, struct device_driver *_drv)
|
||||
static int locomo_match(struct device *_dev, const struct device_driver *_drv)
|
||||
{
|
||||
struct locomo_dev *dev = LOCOMO_DEV(_dev);
|
||||
struct locomo_driver *drv = LOCOMO_DRV(_drv);
|
||||
const struct locomo_driver *drv = LOCOMO_DRV(_drv);
|
||||
|
||||
return dev->devid == drv->devid;
|
||||
}
|
||||
|
@ -1339,10 +1339,10 @@ EXPORT_SYMBOL_GPL(sa1111_get_irq);
|
||||
* We model this as a regular bus type, and hang devices directly
|
||||
* off this.
|
||||
*/
|
||||
static int sa1111_match(struct device *_dev, struct device_driver *_drv)
|
||||
static int sa1111_match(struct device *_dev, const struct device_driver *_drv)
|
||||
{
|
||||
struct sa1111_dev *dev = to_sa1111_device(_dev);
|
||||
struct sa1111_driver *drv = SA1111_DRV(_drv);
|
||||
const struct sa1111_driver *drv = SA1111_DRV(_drv);
|
||||
|
||||
return !!(dev->devid & drv->devid);
|
||||
}
|
||||
|
@ -189,7 +189,7 @@ struct locomo_driver {
|
||||
void (*remove)(struct locomo_dev *);
|
||||
};
|
||||
|
||||
#define LOCOMO_DRV(_d) container_of((_d), struct locomo_driver, drv)
|
||||
#define LOCOMO_DRV(_d) container_of_const((_d), struct locomo_driver, drv)
|
||||
|
||||
#define LOCOMO_DRIVER_NAME(_ldev) ((_ldev)->dev.driver->name)
|
||||
|
||||
|
@ -404,7 +404,7 @@ struct sa1111_driver {
|
||||
void (*remove)(struct sa1111_dev *);
|
||||
};
|
||||
|
||||
#define SA1111_DRV(_d) container_of((_d), struct sa1111_driver, drv)
|
||||
#define SA1111_DRV(_d) container_of_const((_d), struct sa1111_driver, drv)
|
||||
|
||||
#define SA1111_DRIVER_NAME(_sadev) ((_sadev)->dev.driver->name)
|
||||
|
||||
|
@ -41,7 +41,7 @@ struct parisc_driver {
|
||||
|
||||
|
||||
#define to_parisc_device(d) container_of(d, struct parisc_device, dev)
|
||||
#define to_parisc_driver(d) container_of(d, struct parisc_driver, drv)
|
||||
#define to_parisc_driver(d) container_of_const(d, struct parisc_driver, drv)
|
||||
#define parisc_parent(d) to_parisc_device(d->dev.parent)
|
||||
|
||||
static inline const char *parisc_pathname(struct parisc_device *d)
|
||||
|
@ -97,7 +97,7 @@ static int for_each_padev(int (*fn)(struct device *, void *), void * data)
|
||||
* @driver: the PA-RISC driver to try
|
||||
* @dev: the PA-RISC device to try
|
||||
*/
|
||||
static int match_device(struct parisc_driver *driver, struct parisc_device *dev)
|
||||
static int match_device(const struct parisc_driver *driver, struct parisc_device *dev)
|
||||
{
|
||||
const struct parisc_device_id *ids;
|
||||
|
||||
@ -548,7 +548,7 @@ alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path)
|
||||
return dev;
|
||||
}
|
||||
|
||||
static int parisc_generic_match(struct device *dev, struct device_driver *drv)
|
||||
static int parisc_generic_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
return match_device(to_parisc_driver(drv), to_parisc_device(dev));
|
||||
}
|
||||
|
@ -390,11 +390,7 @@ int ps3_system_bus_device_register(struct ps3_system_bus_device *dev);
|
||||
int ps3_system_bus_driver_register(struct ps3_system_bus_driver *drv);
|
||||
void ps3_system_bus_driver_unregister(struct ps3_system_bus_driver *drv);
|
||||
|
||||
static inline struct ps3_system_bus_driver *ps3_drv_to_system_bus_drv(
|
||||
struct device_driver *_drv)
|
||||
{
|
||||
return container_of(_drv, struct ps3_system_bus_driver, core);
|
||||
}
|
||||
#define ps3_drv_to_system_bus_drv(_drv) container_of_const(_drv, struct ps3_system_bus_driver, core)
|
||||
static inline struct ps3_system_bus_device *ps3_dev_to_system_bus_dev(
|
||||
const struct device *_dev)
|
||||
{
|
||||
|
@ -156,11 +156,7 @@ static inline int vio_enable_interrupts(struct vio_dev *dev)
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline struct vio_driver *to_vio_driver(struct device_driver *drv)
|
||||
{
|
||||
return container_of(drv, struct vio_driver, driver);
|
||||
}
|
||||
|
||||
#define to_vio_driver(__drv) container_of_const(__drv, struct vio_driver, driver)
|
||||
#define to_vio_dev(__dev) container_of_const(__dev, struct vio_dev, dev)
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
|
@ -333,10 +333,10 @@ int ps3_mmio_region_init(struct ps3_system_bus_device *dev,
|
||||
EXPORT_SYMBOL_GPL(ps3_mmio_region_init);
|
||||
|
||||
static int ps3_system_bus_match(struct device *_dev,
|
||||
struct device_driver *_drv)
|
||||
const struct device_driver *_drv)
|
||||
{
|
||||
int result;
|
||||
struct ps3_system_bus_driver *drv = ps3_drv_to_system_bus_drv(_drv);
|
||||
const struct ps3_system_bus_driver *drv = ps3_drv_to_system_bus_drv(_drv);
|
||||
struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
|
||||
|
||||
if (!dev->match_sub_id)
|
||||
|
@ -339,7 +339,7 @@ static struct attribute *ibmbus_bus_attrs[] = {
|
||||
};
|
||||
ATTRIBUTE_GROUPS(ibmbus_bus);
|
||||
|
||||
static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int ibmebus_bus_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
const struct of_device_id *matches = drv->of_match_table;
|
||||
|
||||
|
@ -1576,10 +1576,10 @@ void vio_unregister_device(struct vio_dev *viodev)
|
||||
}
|
||||
EXPORT_SYMBOL(vio_unregister_device);
|
||||
|
||||
static int vio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int vio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
const struct vio_dev *vio_dev = to_vio_dev(dev);
|
||||
struct vio_driver *vio_drv = to_vio_driver(drv);
|
||||
const struct vio_driver *vio_drv = to_vio_driver(drv);
|
||||
const struct vio_device_id *ids = vio_drv->id_table;
|
||||
|
||||
return (ids != NULL) && (vio_match_device(ids, vio_dev) != NULL);
|
||||
|
@ -210,7 +210,7 @@ extern void ccw_device_get_id(struct ccw_device *, struct ccw_dev_id *);
|
||||
#define get_ccwdev_lock(x) (x)->ccwlock
|
||||
|
||||
#define to_ccwdev(n) container_of(n, struct ccw_device, dev)
|
||||
#define to_ccwdrv(n) container_of(n, struct ccw_driver, driver)
|
||||
#define to_ccwdrv(n) container_of_const(n, struct ccw_driver, driver)
|
||||
|
||||
extern struct ccw_device *ccw_device_create_console(struct ccw_driver *);
|
||||
extern void ccw_device_destroy_console(struct ccw_device *);
|
||||
|
@ -483,11 +483,7 @@ int __vio_register_driver(struct vio_driver *drv, struct module *owner,
|
||||
__vio_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
|
||||
void vio_unregister_driver(struct vio_driver *drv);
|
||||
|
||||
static inline struct vio_driver *to_vio_driver(struct device_driver *drv)
|
||||
{
|
||||
return container_of(drv, struct vio_driver, driver);
|
||||
}
|
||||
|
||||
#define to_vio_driver(__drv) container_of_const(__drv, struct vio_driver, driver)
|
||||
#define to_vio_dev(__dev) container_of_const(__dev, struct vio_dev, dev)
|
||||
|
||||
int vio_ldc_send(struct vio_driver_state *vio, void *data, int len);
|
||||
|
@ -54,10 +54,10 @@ static int vio_hotplug(const struct device *dev, struct kobj_uevent_env *env)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int vio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int vio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct vio_dev *vio_dev = to_vio_dev(dev);
|
||||
struct vio_driver *vio_drv = to_vio_driver(drv);
|
||||
const struct vio_driver *vio_drv = to_vio_driver(drv);
|
||||
const struct vio_device_id *matches = vio_drv->id_table;
|
||||
|
||||
if (!matches)
|
||||
|
@ -1047,10 +1047,10 @@ EXPORT_SYMBOL(acpi_bus_unregister_driver);
|
||||
ACPI Bus operations
|
||||
-------------------------------------------------------------------------- */
|
||||
|
||||
static int acpi_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int acpi_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
struct acpi_driver *acpi_drv = to_acpi_driver(drv);
|
||||
const struct acpi_driver *acpi_drv = to_acpi_driver(drv);
|
||||
|
||||
return acpi_dev->flags.match_driver
|
||||
&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
|
||||
|
@ -26,7 +26,7 @@
|
||||
#include <linux/iommu.h>
|
||||
#include <linux/dma-map-ops.h>
|
||||
|
||||
#define to_amba_driver(d) container_of(d, struct amba_driver, drv)
|
||||
#define to_amba_driver(d) container_of_const(d, struct amba_driver, drv)
|
||||
|
||||
/* called on periphid match and class 0x9 coresight device. */
|
||||
static int
|
||||
@ -205,10 +205,10 @@ err_out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int amba_match(struct device *dev, struct device_driver *drv)
|
||||
static int amba_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct amba_device *pcdev = to_amba_device(dev);
|
||||
struct amba_driver *pcdrv = to_amba_driver(drv);
|
||||
const struct amba_driver *pcdrv = to_amba_driver(drv);
|
||||
|
||||
mutex_lock(&pcdev->periphid_lock);
|
||||
if (!pcdev->periphid) {
|
||||
|
@ -8,6 +8,7 @@
|
||||
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/cacheinfo.h>
|
||||
#include <linux/cleanup.h>
|
||||
#include <linux/cpu.h>
|
||||
#include <linux/cpufreq.h>
|
||||
#include <linux/device.h>
|
||||
@ -513,10 +514,10 @@ core_initcall(free_raw_capacity);
|
||||
*/
|
||||
static int __init get_cpu_for_node(struct device_node *node)
|
||||
{
|
||||
struct device_node *cpu_node;
|
||||
int cpu;
|
||||
struct device_node *cpu_node __free(device_node) =
|
||||
of_parse_phandle(node, "cpu", 0);
|
||||
|
||||
cpu_node = of_parse_phandle(node, "cpu", 0);
|
||||
if (!cpu_node)
|
||||
return -1;
|
||||
|
||||
@ -527,7 +528,6 @@ static int __init get_cpu_for_node(struct device_node *node)
|
||||
pr_info("CPU node for %pOF exist but the possible cpu range is :%*pbl\n",
|
||||
cpu_node, cpumask_pr_args(cpu_possible_mask));
|
||||
|
||||
of_node_put(cpu_node);
|
||||
return cpu;
|
||||
}
|
||||
|
||||
@ -538,12 +538,15 @@ static int __init parse_core(struct device_node *core, int package_id,
|
||||
bool leaf = true;
|
||||
int i = 0;
|
||||
int cpu;
|
||||
struct device_node *t;
|
||||
|
||||
do {
|
||||
snprintf(name, sizeof(name), "thread%d", i);
|
||||
t = of_get_child_by_name(core, name);
|
||||
if (t) {
|
||||
struct device_node *t __free(device_node) =
|
||||
of_get_child_by_name(core, name);
|
||||
|
||||
if (!t)
|
||||
break;
|
||||
|
||||
leaf = false;
|
||||
cpu = get_cpu_for_node(t);
|
||||
if (cpu >= 0) {
|
||||
@ -553,13 +556,10 @@ static int __init parse_core(struct device_node *core, int package_id,
|
||||
cpu_topology[cpu].thread_id = i;
|
||||
} else if (cpu != -ENODEV) {
|
||||
pr_err("%pOF: Can't get CPU for thread\n", t);
|
||||
of_node_put(t);
|
||||
return -EINVAL;
|
||||
}
|
||||
of_node_put(t);
|
||||
}
|
||||
i++;
|
||||
} while (t);
|
||||
} while (1);
|
||||
|
||||
cpu = get_cpu_for_node(core);
|
||||
if (cpu >= 0) {
|
||||
@ -586,7 +586,6 @@ static int __init parse_cluster(struct device_node *cluster, int package_id,
|
||||
char name[20];
|
||||
bool leaf = true;
|
||||
bool has_cores = false;
|
||||
struct device_node *c;
|
||||
int core_id = 0;
|
||||
int i, ret;
|
||||
|
||||
@ -598,49 +597,50 @@ static int __init parse_cluster(struct device_node *cluster, int package_id,
|
||||
i = 0;
|
||||
do {
|
||||
snprintf(name, sizeof(name), "cluster%d", i);
|
||||
c = of_get_child_by_name(cluster, name);
|
||||
if (c) {
|
||||
struct device_node *c __free(device_node) =
|
||||
of_get_child_by_name(cluster, name);
|
||||
|
||||
if (!c)
|
||||
break;
|
||||
|
||||
leaf = false;
|
||||
ret = parse_cluster(c, package_id, i, depth + 1);
|
||||
if (depth > 0)
|
||||
pr_warn("Topology for clusters of clusters not yet supported\n");
|
||||
of_node_put(c);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
}
|
||||
i++;
|
||||
} while (c);
|
||||
} while (1);
|
||||
|
||||
/* Now check for cores */
|
||||
i = 0;
|
||||
do {
|
||||
snprintf(name, sizeof(name), "core%d", i);
|
||||
c = of_get_child_by_name(cluster, name);
|
||||
if (c) {
|
||||
struct device_node *c __free(device_node) =
|
||||
of_get_child_by_name(cluster, name);
|
||||
|
||||
if (!c)
|
||||
break;
|
||||
|
||||
has_cores = true;
|
||||
|
||||
if (depth == 0) {
|
||||
pr_err("%pOF: cpu-map children should be clusters\n",
|
||||
c);
|
||||
of_node_put(c);
|
||||
pr_err("%pOF: cpu-map children should be clusters\n", c);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (leaf) {
|
||||
ret = parse_core(c, package_id, cluster_id,
|
||||
core_id++);
|
||||
ret = parse_core(c, package_id, cluster_id, core_id++);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
} else {
|
||||
pr_err("%pOF: Non-leaf cluster with core %s\n",
|
||||
cluster, name);
|
||||
ret = -EINVAL;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
of_node_put(c);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
}
|
||||
i++;
|
||||
} while (c);
|
||||
} while (1);
|
||||
|
||||
if (leaf && !has_cores)
|
||||
pr_warn("%pOF: empty cluster\n", cluster);
|
||||
@ -651,22 +651,24 @@ static int __init parse_cluster(struct device_node *cluster, int package_id,
|
||||
static int __init parse_socket(struct device_node *socket)
|
||||
{
|
||||
char name[20];
|
||||
struct device_node *c;
|
||||
bool has_socket = false;
|
||||
int package_id = 0, ret;
|
||||
|
||||
do {
|
||||
snprintf(name, sizeof(name), "socket%d", package_id);
|
||||
c = of_get_child_by_name(socket, name);
|
||||
if (c) {
|
||||
struct device_node *c __free(device_node) =
|
||||
of_get_child_by_name(socket, name);
|
||||
|
||||
if (!c)
|
||||
break;
|
||||
|
||||
has_socket = true;
|
||||
ret = parse_cluster(c, package_id, -1, 0);
|
||||
of_node_put(c);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
package_id++;
|
||||
} while (c);
|
||||
} while (1);
|
||||
|
||||
if (!has_socket)
|
||||
ret = parse_cluster(socket, 0, -1, 0);
|
||||
@ -676,11 +678,11 @@ static int __init parse_socket(struct device_node *socket)
|
||||
|
||||
static int __init parse_dt_topology(void)
|
||||
{
|
||||
struct device_node *cn, *map;
|
||||
int ret = 0;
|
||||
int cpu;
|
||||
struct device_node *cn __free(device_node) =
|
||||
of_find_node_by_path("/cpus");
|
||||
|
||||
cn = of_find_node_by_path("/cpus");
|
||||
if (!cn) {
|
||||
pr_err("No CPU information found in DT\n");
|
||||
return 0;
|
||||
@ -690,13 +692,15 @@ static int __init parse_dt_topology(void)
|
||||
* When topology is provided cpu-map is essentially a root
|
||||
* cluster with restricted subnodes.
|
||||
*/
|
||||
map = of_get_child_by_name(cn, "cpu-map");
|
||||
struct device_node *map __free(device_node) =
|
||||
of_get_child_by_name(cn, "cpu-map");
|
||||
|
||||
if (!map)
|
||||
goto out;
|
||||
return ret;
|
||||
|
||||
ret = parse_socket(map);
|
||||
if (ret != 0)
|
||||
goto out_map;
|
||||
return ret;
|
||||
|
||||
topology_normalize_cpu_scale();
|
||||
|
||||
@ -706,14 +710,9 @@ static int __init parse_dt_topology(void)
|
||||
*/
|
||||
for_each_possible_cpu(cpu)
|
||||
if (cpu_topology[cpu].package_id < 0) {
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
out_map:
|
||||
of_node_put(map);
|
||||
out:
|
||||
of_node_put(cn);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
@ -177,10 +177,10 @@ static const struct auxiliary_device_id *auxiliary_match_id(const struct auxilia
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int auxiliary_match(struct device *dev, struct device_driver *drv)
|
||||
static int auxiliary_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
|
||||
struct auxiliary_driver *auxdrv = to_auxiliary_drv(drv);
|
||||
const struct auxiliary_driver *auxdrv = to_auxiliary_drv(drv);
|
||||
|
||||
return !!auxiliary_match_id(auxdrv->id_table, auxdev);
|
||||
}
|
||||
@ -203,7 +203,7 @@ static const struct dev_pm_ops auxiliary_dev_pm_ops = {
|
||||
|
||||
static int auxiliary_bus_probe(struct device *dev)
|
||||
{
|
||||
struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
|
||||
const struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
|
||||
struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
|
||||
int ret;
|
||||
|
||||
@ -222,7 +222,7 @@ static int auxiliary_bus_probe(struct device *dev)
|
||||
|
||||
static void auxiliary_bus_remove(struct device *dev)
|
||||
{
|
||||
struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
|
||||
const struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
|
||||
struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
|
||||
|
||||
if (auxdrv->remove)
|
||||
@ -232,7 +232,7 @@ static void auxiliary_bus_remove(struct device *dev)
|
||||
|
||||
static void auxiliary_bus_shutdown(struct device *dev)
|
||||
{
|
||||
struct auxiliary_driver *auxdrv = NULL;
|
||||
const struct auxiliary_driver *auxdrv = NULL;
|
||||
struct auxiliary_device *auxdev;
|
||||
|
||||
if (dev->driver) {
|
||||
|
@ -112,7 +112,7 @@ struct device_private {
|
||||
struct klist_node knode_bus;
|
||||
struct klist_node knode_class;
|
||||
struct list_head deferred_probe;
|
||||
struct device_driver *async_driver;
|
||||
const struct device_driver *async_driver;
|
||||
char *deferred_probe_reason;
|
||||
struct device *device;
|
||||
u8 dead:1;
|
||||
@ -155,13 +155,13 @@ bool bus_is_registered(const struct bus_type *bus);
|
||||
|
||||
int bus_add_driver(struct device_driver *drv);
|
||||
void bus_remove_driver(struct device_driver *drv);
|
||||
void device_release_driver_internal(struct device *dev, struct device_driver *drv,
|
||||
void device_release_driver_internal(struct device *dev, const struct device_driver *drv,
|
||||
struct device *parent);
|
||||
|
||||
void driver_detach(struct device_driver *drv);
|
||||
void driver_detach(const struct device_driver *drv);
|
||||
void driver_deferred_probe_del(struct device *dev);
|
||||
void device_set_deferred_probe_reason(const struct device *dev, struct va_format *vaf);
|
||||
static inline int driver_match_device(struct device_driver *drv,
|
||||
static inline int driver_match_device(const struct device_driver *drv,
|
||||
struct device *dev)
|
||||
{
|
||||
return drv->bus->match ? drv->bus->match(dev, drv) : 1;
|
||||
@ -175,8 +175,8 @@ static inline void dev_sync_state(struct device *dev)
|
||||
dev->driver->sync_state(dev);
|
||||
}
|
||||
|
||||
int driver_add_groups(struct device_driver *drv, const struct attribute_group **groups);
|
||||
void driver_remove_groups(struct device_driver *drv, const struct attribute_group **groups);
|
||||
int driver_add_groups(const struct device_driver *drv, const struct attribute_group **groups);
|
||||
void driver_remove_groups(const struct device_driver *drv, const struct attribute_group **groups);
|
||||
void device_driver_detach(struct device *dev);
|
||||
|
||||
int devres_release_all(struct device *dev);
|
||||
@ -192,8 +192,8 @@ extern struct kset *devices_kset;
|
||||
void devices_kset_move_last(struct device *dev);
|
||||
|
||||
#if defined(CONFIG_MODULES) && defined(CONFIG_SYSFS)
|
||||
int module_add_driver(struct module *mod, struct device_driver *drv);
|
||||
void module_remove_driver(struct device_driver *drv);
|
||||
int module_add_driver(struct module *mod, const struct device_driver *drv);
|
||||
void module_remove_driver(const struct device_driver *drv);
|
||||
#else
|
||||
static inline int module_add_driver(struct module *mod,
|
||||
struct device_driver *drv)
|
||||
|
@ -5021,11 +5021,22 @@ int dev_err_probe(const struct device *dev, int err, const char *fmt, ...)
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
if (err != -EPROBE_DEFER) {
|
||||
dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
|
||||
} else {
|
||||
switch (err) {
|
||||
case -EPROBE_DEFER:
|
||||
device_set_deferred_probe_reason(dev, &vaf);
|
||||
dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
|
||||
break;
|
||||
|
||||
case -ENOMEM:
|
||||
/*
|
||||
* We don't print anything on -ENOMEM, there is already enough
|
||||
* output.
|
||||
*/
|
||||
break;
|
||||
|
||||
default:
|
||||
dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
|
||||
break;
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
|
@ -26,7 +26,7 @@
|
||||
|
||||
static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
|
||||
|
||||
static int cpu_subsys_match(struct device *dev, struct device_driver *drv)
|
||||
static int cpu_subsys_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
/* ACPI style match is the only one that may succeed. */
|
||||
if (acpi_driver_match_device(dev, drv))
|
||||
@ -316,7 +316,7 @@ static ssize_t crash_hotplug_show(struct device *dev,
|
||||
{
|
||||
return sysfs_emit(buf, "%d\n", crash_check_hotplug_support());
|
||||
}
|
||||
static DEVICE_ATTR_ADMIN_RO(crash_hotplug);
|
||||
static DEVICE_ATTR_RO(crash_hotplug);
|
||||
#endif
|
||||
|
||||
static void cpu_device_release(struct device *dev)
|
||||
|
@ -568,7 +568,7 @@ static void device_remove(struct device *dev)
|
||||
dev->driver->remove(dev);
|
||||
}
|
||||
|
||||
static int call_driver_probe(struct device *dev, struct device_driver *drv)
|
||||
static int call_driver_probe(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
@ -599,7 +599,7 @@ static int call_driver_probe(struct device *dev, struct device_driver *drv)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int really_probe(struct device *dev, struct device_driver *drv)
|
||||
static int really_probe(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) &&
|
||||
!drv->suppress_bind_attrs;
|
||||
@ -628,7 +628,8 @@ static int really_probe(struct device *dev, struct device_driver *drv)
|
||||
}
|
||||
|
||||
re_probe:
|
||||
dev->driver = drv;
|
||||
// FIXME - this cast should not be needed "soon"
|
||||
dev->driver = (struct device_driver *)drv;
|
||||
|
||||
/* If using pinctrl, bind pins now before probing */
|
||||
ret = pinctrl_bind_pins(dev);
|
||||
@ -727,7 +728,7 @@ done:
|
||||
/*
|
||||
* For initcall_debug, show the driver probe time.
|
||||
*/
|
||||
static int really_probe_debug(struct device *dev, struct device_driver *drv)
|
||||
static int really_probe_debug(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
ktime_t calltime, rettime;
|
||||
int ret;
|
||||
@ -774,7 +775,7 @@ void wait_for_device_probe(void)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(wait_for_device_probe);
|
||||
|
||||
static int __driver_probe_device(struct device_driver *drv, struct device *dev)
|
||||
static int __driver_probe_device(const struct device_driver *drv, struct device *dev)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
@ -819,7 +820,7 @@ static int __driver_probe_device(struct device_driver *drv, struct device *dev)
|
||||
*
|
||||
* If the device has a parent, runtime-resume the parent before driver probing.
|
||||
*/
|
||||
static int driver_probe_device(struct device_driver *drv, struct device *dev)
|
||||
static int driver_probe_device(const struct device_driver *drv, struct device *dev)
|
||||
{
|
||||
int trigger_count = atomic_read(&deferred_trigger_count);
|
||||
int ret;
|
||||
@ -863,7 +864,7 @@ static int __init save_async_options(char *buf)
|
||||
}
|
||||
__setup("driver_async_probe=", save_async_options);
|
||||
|
||||
static bool driver_allows_async_probing(struct device_driver *drv)
|
||||
static bool driver_allows_async_probing(const struct device_driver *drv)
|
||||
{
|
||||
switch (drv->probe_type) {
|
||||
case PROBE_PREFER_ASYNCHRONOUS:
|
||||
@ -1117,7 +1118,7 @@ static void __device_driver_unlock(struct device *dev, struct device *parent)
|
||||
* Manually attach driver to a device. Will acquire both @dev lock and
|
||||
* @dev->parent lock if needed. Returns 0 on success, -ERR on failure.
|
||||
*/
|
||||
int device_driver_attach(struct device_driver *drv, struct device *dev)
|
||||
int device_driver_attach(const struct device_driver *drv, struct device *dev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
@ -1137,7 +1138,7 @@ EXPORT_SYMBOL_GPL(device_driver_attach);
|
||||
static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie)
|
||||
{
|
||||
struct device *dev = _dev;
|
||||
struct device_driver *drv;
|
||||
const struct device_driver *drv;
|
||||
int ret;
|
||||
|
||||
__device_driver_lock(dev, dev->parent);
|
||||
@ -1153,7 +1154,7 @@ static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie)
|
||||
|
||||
static int __driver_attach(struct device *dev, void *data)
|
||||
{
|
||||
struct device_driver *drv = data;
|
||||
const struct device_driver *drv = data;
|
||||
bool async = false;
|
||||
int ret;
|
||||
|
||||
@ -1226,9 +1227,10 @@ static int __driver_attach(struct device *dev, void *data)
|
||||
* returns 0 and the @dev->driver is set, we've found a
|
||||
* compatible pair.
|
||||
*/
|
||||
int driver_attach(struct device_driver *drv)
|
||||
int driver_attach(const struct device_driver *drv)
|
||||
{
|
||||
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
|
||||
/* The (void *) will be put back to const * in __driver_attach() */
|
||||
return bus_for_each_dev(drv->bus, NULL, (void *)drv, __driver_attach);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(driver_attach);
|
||||
|
||||
@ -1284,7 +1286,7 @@ static void __device_release_driver(struct device *dev, struct device *parent)
|
||||
}
|
||||
|
||||
void device_release_driver_internal(struct device *dev,
|
||||
struct device_driver *drv,
|
||||
const struct device_driver *drv,
|
||||
struct device *parent)
|
||||
{
|
||||
__device_driver_lock(dev, parent);
|
||||
@ -1333,7 +1335,7 @@ void device_driver_detach(struct device *dev)
|
||||
* driver_detach - detach driver from all devices it controls.
|
||||
* @drv: driver.
|
||||
*/
|
||||
void driver_detach(struct device_driver *drv)
|
||||
void driver_detach(const struct device_driver *drv)
|
||||
{
|
||||
struct device_private *dev_prv;
|
||||
struct device *dev;
|
||||
|
@ -567,6 +567,7 @@ void * devres_open_group(struct device *dev, void *id, gfp_t gfp)
|
||||
grp->id = grp;
|
||||
if (id)
|
||||
grp->id = id;
|
||||
grp->color = 0;
|
||||
|
||||
spin_lock_irqsave(&dev->devres_lock, flags);
|
||||
add_dr(dev, &grp->node[0]);
|
||||
@ -896,9 +897,12 @@ void *devm_krealloc(struct device *dev, void *ptr, size_t new_size, gfp_t gfp)
|
||||
/*
|
||||
* Otherwise: allocate new, larger chunk. We need to allocate before
|
||||
* taking the lock as most probably the caller uses GFP_KERNEL.
|
||||
* alloc_dr() will call check_dr_size() to reserve extra memory
|
||||
* for struct devres automatically, so size @new_size user request
|
||||
* is delivered to it directly as devm_kmalloc() does.
|
||||
*/
|
||||
new_dr = alloc_dr(devm_kmalloc_release,
|
||||
total_new_size, gfp, dev_to_node(dev));
|
||||
new_size, gfp, dev_to_node(dev));
|
||||
if (!new_dr)
|
||||
return NULL;
|
||||
|
||||
@ -1222,7 +1226,11 @@ EXPORT_SYMBOL_GPL(__devm_alloc_percpu);
|
||||
*/
|
||||
void devm_free_percpu(struct device *dev, void __percpu *pdata)
|
||||
{
|
||||
WARN_ON(devres_destroy(dev, devm_percpu_release, devm_percpu_match,
|
||||
/*
|
||||
* Use devres_release() to prevent memory leakage as
|
||||
* devm_free_pages() does.
|
||||
*/
|
||||
WARN_ON(devres_release(dev, devm_percpu_release, devm_percpu_match,
|
||||
(__force void *)pdata));
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_free_percpu);
|
||||
|
@ -148,7 +148,7 @@ EXPORT_SYMBOL_GPL(driver_for_each_device);
|
||||
* if it does. If the callback returns non-zero, this function will
|
||||
* return to the caller and not iterate over any more devices.
|
||||
*/
|
||||
struct device *driver_find_device(struct device_driver *drv,
|
||||
struct device *driver_find_device(const struct device_driver *drv,
|
||||
struct device *start, const void *data,
|
||||
int (*match)(struct device *dev, const void *data))
|
||||
{
|
||||
@ -173,7 +173,7 @@ EXPORT_SYMBOL_GPL(driver_find_device);
|
||||
* @drv: driver.
|
||||
* @attr: driver attribute descriptor.
|
||||
*/
|
||||
int driver_create_file(struct device_driver *drv,
|
||||
int driver_create_file(const struct device_driver *drv,
|
||||
const struct driver_attribute *attr)
|
||||
{
|
||||
int error;
|
||||
@ -191,7 +191,7 @@ EXPORT_SYMBOL_GPL(driver_create_file);
|
||||
* @drv: driver.
|
||||
* @attr: driver attribute descriptor.
|
||||
*/
|
||||
void driver_remove_file(struct device_driver *drv,
|
||||
void driver_remove_file(const struct device_driver *drv,
|
||||
const struct driver_attribute *attr)
|
||||
{
|
||||
if (drv)
|
||||
@ -199,13 +199,13 @@ void driver_remove_file(struct device_driver *drv,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(driver_remove_file);
|
||||
|
||||
int driver_add_groups(struct device_driver *drv,
|
||||
int driver_add_groups(const struct device_driver *drv,
|
||||
const struct attribute_group **groups)
|
||||
{
|
||||
return sysfs_create_groups(&drv->p->kobj, groups);
|
||||
}
|
||||
|
||||
void driver_remove_groups(struct device_driver *drv,
|
||||
void driver_remove_groups(const struct device_driver *drv,
|
||||
const struct attribute_group **groups)
|
||||
{
|
||||
sysfs_remove_groups(&drv->p->kobj, groups);
|
||||
|
@ -37,6 +37,13 @@ config FW_LOADER_DEBUG
|
||||
SHA256 checksums to the kernel log for each firmware file that is
|
||||
loaded.
|
||||
|
||||
config RUST_FW_LOADER_ABSTRACTIONS
|
||||
bool "Rust Firmware Loader abstractions"
|
||||
depends on RUST
|
||||
depends on FW_LOADER=y
|
||||
help
|
||||
This enables the Rust abstractions for the firmware loader API.
|
||||
|
||||
if FW_LOADER
|
||||
|
||||
config FW_LOADER_PAGED_BUF
|
||||
|
@ -23,7 +23,7 @@ struct isa_dev {
|
||||
|
||||
#define to_isa_dev(x) container_of((x), struct isa_dev, dev)
|
||||
|
||||
static int isa_bus_match(struct device *dev, struct device_driver *driver)
|
||||
static int isa_bus_match(struct device *dev, const struct device_driver *driver)
|
||||
{
|
||||
struct isa_driver *isa_driver = to_isa_driver(driver);
|
||||
|
||||
|
@ -9,7 +9,7 @@
|
||||
#include <linux/string.h>
|
||||
#include "base.h"
|
||||
|
||||
static char *make_driver_name(struct device_driver *drv)
|
||||
static char *make_driver_name(const struct device_driver *drv)
|
||||
{
|
||||
char *driver_name;
|
||||
|
||||
@ -30,7 +30,7 @@ static void module_create_drivers_dir(struct module_kobject *mk)
|
||||
mutex_unlock(&drivers_dir_mutex);
|
||||
}
|
||||
|
||||
int module_add_driver(struct module *mod, struct device_driver *drv)
|
||||
int module_add_driver(struct module *mod, const struct device_driver *drv)
|
||||
{
|
||||
char *driver_name;
|
||||
struct module_kobject *mk = NULL;
|
||||
@ -89,7 +89,7 @@ out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
void module_remove_driver(struct device_driver *drv)
|
||||
void module_remove_driver(const struct device_driver *drv)
|
||||
{
|
||||
struct module_kobject *mk = NULL;
|
||||
char *driver_name;
|
||||
|
@ -608,7 +608,7 @@ int platform_device_add_resources(struct platform_device *pdev,
|
||||
struct resource *r = NULL;
|
||||
|
||||
if (res) {
|
||||
r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
|
||||
r = kmemdup_array(res, num, sizeof(*r), GFP_KERNEL);
|
||||
if (!r)
|
||||
return -ENOMEM;
|
||||
}
|
||||
@ -1122,7 +1122,7 @@ static int platform_legacy_resume(struct device *dev)
|
||||
|
||||
int platform_pm_suspend(struct device *dev)
|
||||
{
|
||||
struct device_driver *drv = dev->driver;
|
||||
const struct device_driver *drv = dev->driver;
|
||||
int ret = 0;
|
||||
|
||||
if (!drv)
|
||||
@ -1140,7 +1140,7 @@ int platform_pm_suspend(struct device *dev)
|
||||
|
||||
int platform_pm_resume(struct device *dev)
|
||||
{
|
||||
struct device_driver *drv = dev->driver;
|
||||
const struct device_driver *drv = dev->driver;
|
||||
int ret = 0;
|
||||
|
||||
if (!drv)
|
||||
@ -1162,7 +1162,7 @@ int platform_pm_resume(struct device *dev)
|
||||
|
||||
int platform_pm_freeze(struct device *dev)
|
||||
{
|
||||
struct device_driver *drv = dev->driver;
|
||||
const struct device_driver *drv = dev->driver;
|
||||
int ret = 0;
|
||||
|
||||
if (!drv)
|
||||
@ -1180,7 +1180,7 @@ int platform_pm_freeze(struct device *dev)
|
||||
|
||||
int platform_pm_thaw(struct device *dev)
|
||||
{
|
||||
struct device_driver *drv = dev->driver;
|
||||
const struct device_driver *drv = dev->driver;
|
||||
int ret = 0;
|
||||
|
||||
if (!drv)
|
||||
@ -1198,7 +1198,7 @@ int platform_pm_thaw(struct device *dev)
|
||||
|
||||
int platform_pm_poweroff(struct device *dev)
|
||||
{
|
||||
struct device_driver *drv = dev->driver;
|
||||
const struct device_driver *drv = dev->driver;
|
||||
int ret = 0;
|
||||
|
||||
if (!drv)
|
||||
@ -1216,7 +1216,7 @@ int platform_pm_poweroff(struct device *dev)
|
||||
|
||||
int platform_pm_restore(struct device *dev)
|
||||
{
|
||||
struct device_driver *drv = dev->driver;
|
||||
const struct device_driver *drv = dev->driver;
|
||||
int ret = 0;
|
||||
|
||||
if (!drv)
|
||||
@ -1332,7 +1332,7 @@ __ATTRIBUTE_GROUPS(platform_dev);
|
||||
* and compare it against the name of the driver. Return whether they match
|
||||
* or not.
|
||||
*/
|
||||
static int platform_match(struct device *dev, struct device_driver *drv)
|
||||
static int platform_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct platform_driver *pdrv = to_platform_driver(drv);
|
||||
@ -1420,14 +1420,8 @@ static void platform_remove(struct device *_dev)
|
||||
struct platform_driver *drv = to_platform_driver(_dev->driver);
|
||||
struct platform_device *dev = to_platform_device(_dev);
|
||||
|
||||
if (drv->remove_new) {
|
||||
drv->remove_new(dev);
|
||||
} else if (drv->remove) {
|
||||
int ret = drv->remove(dev);
|
||||
|
||||
if (ret)
|
||||
dev_warn(_dev, "remove callback returned a non-zero value. This will be ignored.\n");
|
||||
}
|
||||
if (drv->remove)
|
||||
drv->remove(dev);
|
||||
dev_pm_domain_detach(_dev, true);
|
||||
}
|
||||
|
||||
|
@ -26,7 +26,7 @@ static unsigned int bcma_bus_next_num;
|
||||
/* bcma_buses_mutex locks the bcma_bus_next_num */
|
||||
static DEFINE_MUTEX(bcma_buses_mutex);
|
||||
|
||||
static int bcma_bus_match(struct device *dev, struct device_driver *drv);
|
||||
static int bcma_bus_match(struct device *dev, const struct device_driver *drv);
|
||||
static int bcma_device_probe(struct device *dev);
|
||||
static void bcma_device_remove(struct device *dev);
|
||||
static int bcma_device_uevent(const struct device *dev, struct kobj_uevent_env *env);
|
||||
@ -584,10 +584,10 @@ void bcma_driver_unregister(struct bcma_driver *drv)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bcma_driver_unregister);
|
||||
|
||||
static int bcma_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int bcma_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct bcma_device *core = container_of(dev, struct bcma_device, dev);
|
||||
struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
|
||||
const struct bcma_driver *adrv = container_of_const(drv, struct bcma_driver, drv);
|
||||
const struct bcma_device_id *cid = &core->id;
|
||||
const struct bcma_device_id *did;
|
||||
|
||||
|
@ -80,11 +80,11 @@ static phys_addr_t mc_portal_base_phys_addr;
|
||||
*
|
||||
* Returns 1 on success, 0 otherwise.
|
||||
*/
|
||||
static int fsl_mc_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int fsl_mc_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
const struct fsl_mc_device_id *id;
|
||||
struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
|
||||
struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(drv);
|
||||
const struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(drv);
|
||||
bool found = false;
|
||||
|
||||
/* When driver_override is set, only bind to the matching driver */
|
||||
|
@ -1694,10 +1694,10 @@ static int mhi_ep_uevent(const struct device *dev, struct kobj_uevent_env *env)
|
||||
mhi_dev->name);
|
||||
}
|
||||
|
||||
static int mhi_ep_match(struct device *dev, struct device_driver *drv)
|
||||
static int mhi_ep_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mhi_ep_device *mhi_dev = to_mhi_ep_device(dev);
|
||||
struct mhi_ep_driver *mhi_drv = to_mhi_ep_driver(drv);
|
||||
const struct mhi_ep_driver *mhi_drv = to_mhi_ep_driver(drv);
|
||||
const struct mhi_device_id *id;
|
||||
|
||||
/*
|
||||
|
@ -1442,10 +1442,10 @@ static int mhi_uevent(const struct device *dev, struct kobj_uevent_env *env)
|
||||
mhi_dev->name);
|
||||
}
|
||||
|
||||
static int mhi_match(struct device *dev, struct device_driver *drv)
|
||||
static int mhi_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mhi_device *mhi_dev = to_mhi_device(dev);
|
||||
struct mhi_driver *mhi_drv = to_mhi_driver(drv);
|
||||
const struct mhi_driver *mhi_drv = to_mhi_driver(drv);
|
||||
const struct mhi_device_id *id;
|
||||
|
||||
/*
|
||||
|
@ -37,7 +37,7 @@
|
||||
/* Each block of device registers is 64 bytes */
|
||||
#define CDMM_DRB_SIZE 64
|
||||
|
||||
#define to_mips_cdmm_driver(d) container_of(d, struct mips_cdmm_driver, drv)
|
||||
#define to_mips_cdmm_driver(d) container_of_const(d, struct mips_cdmm_driver, drv)
|
||||
|
||||
/* Default physical base address */
|
||||
static phys_addr_t mips_cdmm_default_base;
|
||||
@ -59,10 +59,10 @@ mips_cdmm_lookup(const struct mips_cdmm_device_id *table,
|
||||
return ret ? table : NULL;
|
||||
}
|
||||
|
||||
static int mips_cdmm_match(struct device *dev, struct device_driver *drv)
|
||||
static int mips_cdmm_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mips_cdmm_device *cdev = to_mips_cdmm_device(dev);
|
||||
struct mips_cdmm_driver *cdrv = to_mips_cdmm_driver(drv);
|
||||
const struct mips_cdmm_driver *cdrv = to_mips_cdmm_driver(drv);
|
||||
|
||||
return mips_cdmm_lookup(cdrv->id_table, cdev) != NULL;
|
||||
}
|
||||
|
@ -83,10 +83,10 @@ static const struct attribute_group *moxtet_dev_groups[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
static int moxtet_match(struct device *dev, struct device_driver *drv)
|
||||
static int moxtet_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct moxtet_device *mdev = to_moxtet_device(dev);
|
||||
struct moxtet_driver *tdrv = to_moxtet_driver(drv);
|
||||
const struct moxtet_driver *tdrv = to_moxtet_driver(drv);
|
||||
const enum turris_mox_module_id *t;
|
||||
|
||||
if (of_driver_match_device(dev, drv))
|
||||
|
@ -130,7 +130,7 @@ struct sunxi_rsb {
|
||||
/* bus / slave device related functions */
|
||||
static const struct bus_type sunxi_rsb_bus;
|
||||
|
||||
static int sunxi_rsb_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int sunxi_rsb_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
return of_driver_match_device(dev, drv);
|
||||
}
|
||||
|
@ -262,10 +262,10 @@ EXPORT_SYMBOL_GPL(cdx_clear_master);
|
||||
*
|
||||
* Return: true on success, false otherwise.
|
||||
*/
|
||||
static int cdx_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int cdx_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct cdx_device *cdx_dev = to_cdx_device(dev);
|
||||
struct cdx_driver *cdx_drv = to_cdx_driver(drv);
|
||||
const struct cdx_driver *cdx_drv = to_cdx_driver(drv);
|
||||
const struct cdx_device_id *found_id = NULL;
|
||||
const struct cdx_device_id *ids;
|
||||
|
||||
|
@ -2082,7 +2082,7 @@ static int cxl_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
|
||||
cxl_device_id(dev));
|
||||
}
|
||||
|
||||
static int cxl_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int cxl_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
return cxl_device_id(dev) == to_cxl_drv(drv)->id;
|
||||
}
|
||||
|
@ -825,10 +825,7 @@ struct cxl_driver {
|
||||
int id;
|
||||
};
|
||||
|
||||
static inline struct cxl_driver *to_cxl_drv(struct device_driver *drv)
|
||||
{
|
||||
return container_of(drv, struct cxl_driver, drv);
|
||||
}
|
||||
#define to_cxl_drv(__drv) container_of_const(__drv, struct cxl_driver, drv)
|
||||
|
||||
int __cxl_driver_register(struct cxl_driver *cxl_drv, struct module *owner,
|
||||
const char *modname);
|
||||
|
@ -39,12 +39,9 @@ static int dax_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
|
||||
return add_uevent_var(env, "MODALIAS=" DAX_DEVICE_MODALIAS_FMT, 0);
|
||||
}
|
||||
|
||||
static struct dax_device_driver *to_dax_drv(struct device_driver *drv)
|
||||
{
|
||||
return container_of(drv, struct dax_device_driver, drv);
|
||||
}
|
||||
#define to_dax_drv(__drv) container_of_const(__drv, struct dax_device_driver, drv)
|
||||
|
||||
static struct dax_id *__dax_match_id(struct dax_device_driver *dax_drv,
|
||||
static struct dax_id *__dax_match_id(const struct dax_device_driver *dax_drv,
|
||||
const char *dev_name)
|
||||
{
|
||||
struct dax_id *dax_id;
|
||||
@ -57,7 +54,7 @@ static struct dax_id *__dax_match_id(struct dax_device_driver *dax_drv,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int dax_match_id(struct dax_device_driver *dax_drv, struct device *dev)
|
||||
static int dax_match_id(const struct dax_device_driver *dax_drv, struct device *dev)
|
||||
{
|
||||
int match;
|
||||
|
||||
@ -68,7 +65,7 @@ static int dax_match_id(struct dax_device_driver *dax_drv, struct device *dev)
|
||||
return match;
|
||||
}
|
||||
|
||||
static int dax_match_type(struct dax_device_driver *dax_drv, struct device *dev)
|
||||
static int dax_match_type(const struct dax_device_driver *dax_drv, struct device *dev)
|
||||
{
|
||||
enum dax_driver_type type = DAXDRV_DEVICE_TYPE;
|
||||
struct dev_dax *dev_dax = to_dev_dax(dev);
|
||||
@ -156,7 +153,7 @@ static struct attribute *dax_drv_attrs[] = {
|
||||
};
|
||||
ATTRIBUTE_GROUPS(dax_drv);
|
||||
|
||||
static int dax_bus_match(struct device *dev, struct device_driver *drv);
|
||||
static int dax_bus_match(struct device *dev, const struct device_driver *drv);
|
||||
|
||||
/*
|
||||
* Static dax regions are regions created by an external subsystem
|
||||
@ -250,9 +247,9 @@ static const struct bus_type dax_bus_type = {
|
||||
.drv_groups = dax_drv_groups,
|
||||
};
|
||||
|
||||
static int dax_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int dax_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct dax_device_driver *dax_drv = to_dax_drv(drv);
|
||||
const struct dax_device_driver *dax_drv = to_dax_drv(drv);
|
||||
|
||||
if (dax_match_id(dax_drv, dev))
|
||||
return 1;
|
||||
|
@ -13,7 +13,9 @@
|
||||
#include <linux/gfp.h>
|
||||
#include <linux/export.h>
|
||||
|
||||
static struct class *dca_class;
|
||||
static const struct class dca_class = {
|
||||
.name = "dca",
|
||||
};
|
||||
static struct idr dca_idr;
|
||||
static spinlock_t dca_idr_lock;
|
||||
|
||||
@ -22,14 +24,14 @@ int dca_sysfs_add_req(struct dca_provider *dca, struct device *dev, int slot)
|
||||
struct device *cd;
|
||||
static int req_count;
|
||||
|
||||
cd = device_create(dca_class, dca->cd, MKDEV(0, slot + 1), NULL,
|
||||
cd = device_create(&dca_class, dca->cd, MKDEV(0, slot + 1), NULL,
|
||||
"requester%d", req_count++);
|
||||
return PTR_ERR_OR_ZERO(cd);
|
||||
}
|
||||
|
||||
void dca_sysfs_remove_req(struct dca_provider *dca, int slot)
|
||||
{
|
||||
device_destroy(dca_class, MKDEV(0, slot + 1));
|
||||
device_destroy(&dca_class, MKDEV(0, slot + 1));
|
||||
}
|
||||
|
||||
int dca_sysfs_add_provider(struct dca_provider *dca, struct device *dev)
|
||||
@ -49,7 +51,7 @@ int dca_sysfs_add_provider(struct dca_provider *dca, struct device *dev)
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
cd = device_create(dca_class, dev, MKDEV(0, 0), NULL, "dca%d", dca->id);
|
||||
cd = device_create(&dca_class, dev, MKDEV(0, 0), NULL, "dca%d", dca->id);
|
||||
if (IS_ERR(cd)) {
|
||||
spin_lock(&dca_idr_lock);
|
||||
idr_remove(&dca_idr, dca->id);
|
||||
@ -71,20 +73,22 @@ void dca_sysfs_remove_provider(struct dca_provider *dca)
|
||||
|
||||
int __init dca_sysfs_init(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
idr_init(&dca_idr);
|
||||
spin_lock_init(&dca_idr_lock);
|
||||
|
||||
dca_class = class_create("dca");
|
||||
if (IS_ERR(dca_class)) {
|
||||
err = class_register(&dca_class);
|
||||
if (err) {
|
||||
idr_destroy(&dca_idr);
|
||||
return PTR_ERR(dca_class);
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void __exit dca_sysfs_exit(void)
|
||||
{
|
||||
class_destroy(dca_class);
|
||||
class_unregister(&dca_class);
|
||||
idr_destroy(&dca_idr);
|
||||
}
|
||||
|
||||
|
@ -110,10 +110,10 @@ void dio_unregister_driver(struct dio_driver *drv)
|
||||
* and 0 if there is no match.
|
||||
*/
|
||||
|
||||
static int dio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int dio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct dio_dev *d = to_dio_dev(dev);
|
||||
struct dio_driver *dio_drv = to_dio_driver(drv);
|
||||
const struct dio_driver *dio_drv = to_dio_driver(drv);
|
||||
const struct dio_device_id *ids = dio_drv->id_table;
|
||||
|
||||
if (!ids)
|
||||
|
@ -33,10 +33,10 @@ void idxd_driver_unregister(struct idxd_device_driver *idxd_drv)
|
||||
EXPORT_SYMBOL_GPL(idxd_driver_unregister);
|
||||
|
||||
static int idxd_config_bus_match(struct device *dev,
|
||||
struct device_driver *drv)
|
||||
const struct device_driver *drv)
|
||||
{
|
||||
struct idxd_device_driver *idxd_drv =
|
||||
container_of(drv, struct idxd_device_driver, drv);
|
||||
const struct idxd_device_driver *idxd_drv =
|
||||
container_of_const(drv, struct idxd_device_driver, drv);
|
||||
struct idxd_dev *idxd_dev = confdev_to_idxd_dev(dev);
|
||||
int i = 0;
|
||||
|
||||
|
@ -7,7 +7,6 @@
|
||||
#include <linux/device/bus.h>
|
||||
#include "idxd.h"
|
||||
|
||||
extern int device_driver_attach(struct device_driver *drv, struct device *dev);
|
||||
extern void device_driver_detach(struct device *dev);
|
||||
|
||||
#define DRIVER_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
|
||||
|
@ -105,10 +105,10 @@ static char __init *decode_eisa_sig(unsigned long addr)
|
||||
return sig_str;
|
||||
}
|
||||
|
||||
static int eisa_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int eisa_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct eisa_device *edev = to_eisa_device(dev);
|
||||
struct eisa_driver *edrv = to_eisa_driver(drv);
|
||||
const struct eisa_driver *edrv = to_eisa_driver(drv);
|
||||
const struct eisa_device_id *eids = edrv->id_table;
|
||||
|
||||
if (!eids)
|
||||
|
@ -190,10 +190,10 @@ static bool match_ids(const struct ieee1394_device_id *id_table, int *id)
|
||||
}
|
||||
|
||||
static const struct ieee1394_device_id *unit_match(struct device *dev,
|
||||
struct device_driver *drv)
|
||||
const struct device_driver *drv)
|
||||
{
|
||||
const struct ieee1394_device_id *id_table =
|
||||
container_of(drv, struct fw_driver, driver)->id_table;
|
||||
container_of_const(drv, struct fw_driver, driver)->id_table;
|
||||
int id[] = {0, 0, 0, 0};
|
||||
|
||||
get_modalias_ids(fw_unit(dev), id);
|
||||
@ -207,7 +207,7 @@ static const struct ieee1394_device_id *unit_match(struct device *dev,
|
||||
|
||||
static bool is_fw_unit(const struct device *dev);
|
||||
|
||||
static int fw_unit_match(struct device *dev, struct device_driver *drv)
|
||||
static int fw_unit_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
/* We only allow binding to fw_units. */
|
||||
return is_fw_unit(dev) && unit_match(dev, drv) != NULL;
|
||||
|
@ -19,7 +19,7 @@
|
||||
|
||||
static DEFINE_IDA(ffa_bus_id);
|
||||
|
||||
static int ffa_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int ffa_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
const struct ffa_device_id *id_table;
|
||||
struct ffa_device *ffa_dev;
|
||||
|
@ -207,7 +207,7 @@ scmi_protocol_table_unregister(const struct scmi_device_id *id_table)
|
||||
}
|
||||
|
||||
static const struct scmi_device_id *
|
||||
scmi_dev_match_id(struct scmi_device *scmi_dev, struct scmi_driver *scmi_drv)
|
||||
scmi_dev_match_id(struct scmi_device *scmi_dev, const struct scmi_driver *scmi_drv)
|
||||
{
|
||||
const struct scmi_device_id *id = scmi_drv->id_table;
|
||||
|
||||
@ -225,9 +225,9 @@ scmi_dev_match_id(struct scmi_device *scmi_dev, struct scmi_driver *scmi_drv)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int scmi_dev_match(struct device *dev, struct device_driver *drv)
|
||||
static int scmi_dev_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct scmi_driver *scmi_drv = to_scmi_driver(drv);
|
||||
const struct scmi_driver *scmi_drv = to_scmi_driver(drv);
|
||||
struct scmi_device *scmi_dev = to_scmi_dev(dev);
|
||||
const struct scmi_device_id *id;
|
||||
|
||||
|
@ -22,12 +22,12 @@
|
||||
#include "coreboot_table.h"
|
||||
|
||||
#define CB_DEV(d) container_of(d, struct coreboot_device, dev)
|
||||
#define CB_DRV(d) container_of(d, struct coreboot_driver, drv)
|
||||
#define CB_DRV(d) container_of_const(d, struct coreboot_driver, drv)
|
||||
|
||||
static int coreboot_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int coreboot_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct coreboot_device *device = CB_DEV(dev);
|
||||
struct coreboot_driver *driver = CB_DRV(drv);
|
||||
const struct coreboot_driver *driver = CB_DRV(drv);
|
||||
const struct coreboot_device_id *id;
|
||||
|
||||
if (!driver->id_table)
|
||||
|
@ -257,10 +257,10 @@ dfl_match_one_device(const struct dfl_device_id *id, struct dfl_device *ddev)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int dfl_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int dfl_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct dfl_device *ddev = to_dfl_dev(dev);
|
||||
struct dfl_driver *ddrv = to_dfl_drv(drv);
|
||||
const struct dfl_driver *ddrv = to_dfl_drv(drv);
|
||||
const struct dfl_device_id *id_entry;
|
||||
|
||||
id_entry = ddrv->id_table;
|
||||
|
@ -1361,10 +1361,10 @@ EXPORT_SYMBOL_GPL(fsi_master_unregister);
|
||||
|
||||
/* FSI core & Linux bus type definitions */
|
||||
|
||||
static int fsi_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int fsi_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct fsi_device *fsi_dev = to_fsi_dev(dev);
|
||||
struct fsi_driver *fsi_drv = to_fsi_drv(drv);
|
||||
const struct fsi_driver *fsi_drv = to_fsi_drv(drv);
|
||||
const struct fsi_device_id *id;
|
||||
|
||||
if (!fsi_drv->id_table)
|
||||
|
@ -646,14 +646,12 @@ err_free_aspeed:
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int fsi_master_aspeed_remove(struct platform_device *pdev)
|
||||
static void fsi_master_aspeed_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct fsi_master_aspeed *aspeed = platform_get_drvdata(pdev);
|
||||
|
||||
fsi_master_unregister(&aspeed->master);
|
||||
clk_disable_unprepare(aspeed->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id fsi_master_aspeed_match[] = {
|
||||
@ -668,7 +666,7 @@ static struct platform_driver fsi_master_aspeed_driver = {
|
||||
.of_match_table = fsi_master_aspeed_match,
|
||||
},
|
||||
.probe = fsi_master_aspeed_probe,
|
||||
.remove = fsi_master_aspeed_remove,
|
||||
.remove_new = fsi_master_aspeed_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(fsi_master_aspeed_driver);
|
||||
|
@ -1412,15 +1412,13 @@ static int fsi_master_acf_probe(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
|
||||
static int fsi_master_acf_remove(struct platform_device *pdev)
|
||||
static void fsi_master_acf_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct fsi_master_acf *master = platform_get_drvdata(pdev);
|
||||
|
||||
device_remove_file(master->dev, &dev_attr_external_mode);
|
||||
|
||||
fsi_master_unregister(&master->master);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id fsi_master_acf_match[] = {
|
||||
@ -1436,7 +1434,7 @@ static struct platform_driver fsi_master_acf = {
|
||||
.of_match_table = fsi_master_acf_match,
|
||||
},
|
||||
.probe = fsi_master_acf_probe,
|
||||
.remove = fsi_master_acf_remove,
|
||||
.remove_new = fsi_master_acf_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(fsi_master_acf);
|
||||
|
@ -867,15 +867,13 @@ static int fsi_master_gpio_probe(struct platform_device *pdev)
|
||||
|
||||
|
||||
|
||||
static int fsi_master_gpio_remove(struct platform_device *pdev)
|
||||
static void fsi_master_gpio_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct fsi_master_gpio *master = platform_get_drvdata(pdev);
|
||||
|
||||
device_remove_file(&pdev->dev, &dev_attr_external_mode);
|
||||
|
||||
fsi_master_unregister(&master->master);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id fsi_master_gpio_match[] = {
|
||||
@ -890,7 +888,7 @@ static struct platform_driver fsi_master_gpio_driver = {
|
||||
.of_match_table = fsi_master_gpio_match,
|
||||
},
|
||||
.probe = fsi_master_gpio_probe,
|
||||
.remove = fsi_master_gpio_remove,
|
||||
.remove_new = fsi_master_gpio_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(fsi_master_gpio_driver);
|
||||
|
@ -702,7 +702,7 @@ static int occ_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int occ_remove(struct platform_device *pdev)
|
||||
static void occ_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct occ *occ = platform_get_drvdata(pdev);
|
||||
|
||||
@ -719,8 +719,6 @@ static int occ_remove(struct platform_device *pdev)
|
||||
device_for_each_child(&pdev->dev, NULL, occ_unregister_of_child);
|
||||
|
||||
ida_free(&occ_ida, occ->idx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id occ_match[] = {
|
||||
@ -742,7 +740,7 @@ static struct platform_driver occ_driver = {
|
||||
.of_match_table = occ_match,
|
||||
},
|
||||
.probe = occ_probe,
|
||||
.remove = occ_remove,
|
||||
.remove_new = occ_remove,
|
||||
};
|
||||
|
||||
static int occ_init(void)
|
||||
|
@ -55,7 +55,7 @@ static DEFINE_IDA(gpio_ida);
|
||||
static dev_t gpio_devt;
|
||||
#define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
|
||||
|
||||
static int gpio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int gpio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct fwnode_handle *fwnode = dev_fwnode(dev);
|
||||
|
||||
|
@ -36,7 +36,7 @@ struct dp_aux_ep_device_with_data {
|
||||
*
|
||||
* Return: True if this driver matches this device; false otherwise.
|
||||
*/
|
||||
static int dp_aux_ep_match(struct device *dev, struct device_driver *drv)
|
||||
static int dp_aux_ep_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
return !!of_match_device(drv->of_match_table, dev);
|
||||
}
|
||||
|
@ -48,7 +48,7 @@
|
||||
* subset of the MIPI DCS command set.
|
||||
*/
|
||||
|
||||
static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int mipi_dsi_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
|
||||
|
||||
|
@ -1451,8 +1451,7 @@ err_context_fini:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
pvr_remove(struct platform_device *plat_dev)
|
||||
static void pvr_remove(struct platform_device *plat_dev)
|
||||
{
|
||||
struct drm_device *drm_dev = platform_get_drvdata(plat_dev);
|
||||
struct pvr_device *pvr_dev = to_pvr_device(drm_dev);
|
||||
@ -1469,8 +1468,6 @@ pvr_remove(struct platform_device *plat_dev)
|
||||
pvr_watchdog_fini(pvr_dev);
|
||||
pvr_queue_device_fini(pvr_dev);
|
||||
pvr_context_device_fini(pvr_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id dt_match[] = {
|
||||
@ -1485,7 +1482,7 @@ static const struct dev_pm_ops pvr_pm_ops = {
|
||||
|
||||
static struct platform_driver pvr_driver = {
|
||||
.probe = pvr_probe,
|
||||
.remove = pvr_remove,
|
||||
.remove_new = pvr_remove,
|
||||
.driver = {
|
||||
.name = PVR_DRIVER_NAME,
|
||||
.pm = &pvr_pm_ops,
|
||||
|
@ -1186,15 +1186,13 @@ err_lvds_probe:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int lvds_remove(struct platform_device *pdev)
|
||||
static void lvds_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct stm_lvds *lvds = platform_get_drvdata(pdev);
|
||||
|
||||
lvds_pixel_clk_unregister(lvds);
|
||||
|
||||
drm_bridge_remove(&lvds->lvds_bridge);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id lvds_dt_ids[] = {
|
||||
|
@ -333,7 +333,7 @@ static int host1x_del_client(struct host1x *host1x,
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static int host1x_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int host1x_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
return strcmp(dev_name(dev), drv->name) == 0;
|
||||
}
|
||||
|
@ -677,7 +677,7 @@ destroy_cache:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int host1x_remove(struct platform_device *pdev)
|
||||
static void host1x_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct host1x *host = platform_get_drvdata(pdev);
|
||||
|
||||
@ -692,8 +692,6 @@ static int host1x_remove(struct platform_device *pdev)
|
||||
host1x_channel_list_free(&host->channel_list);
|
||||
host1x_iommu_exit(host);
|
||||
host1x_bo_cache_destroy(&host->cache);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused host1x_runtime_suspend(struct device *dev)
|
||||
@ -778,7 +776,7 @@ static struct platform_driver tegra_host1x_driver = {
|
||||
.pm = &host1x_pm_ops,
|
||||
},
|
||||
.probe = host1x_probe,
|
||||
.remove = host1x_remove,
|
||||
.remove_new = host1x_remove,
|
||||
};
|
||||
|
||||
static struct platform_driver * const drivers[] = {
|
||||
|
@ -501,7 +501,6 @@ static int tegra_mipi_probe(struct platform_device *pdev)
|
||||
{
|
||||
const struct of_device_id *match;
|
||||
struct tegra_mipi *mipi;
|
||||
int err;
|
||||
|
||||
match = of_match_node(tegra_mipi_of_match, pdev->dev.of_node);
|
||||
if (!match)
|
||||
@ -520,35 +519,21 @@ static int tegra_mipi_probe(struct platform_device *pdev)
|
||||
|
||||
mutex_init(&mipi->lock);
|
||||
|
||||
mipi->clk = devm_clk_get(&pdev->dev, NULL);
|
||||
mipi->clk = devm_clk_get_prepared(&pdev->dev, NULL);
|
||||
if (IS_ERR(mipi->clk)) {
|
||||
dev_err(&pdev->dev, "failed to get clock\n");
|
||||
return PTR_ERR(mipi->clk);
|
||||
}
|
||||
|
||||
err = clk_prepare(mipi->clk);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
platform_set_drvdata(pdev, mipi);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra_mipi_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct tegra_mipi *mipi = platform_get_drvdata(pdev);
|
||||
|
||||
clk_unprepare(mipi->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct platform_driver tegra_mipi_driver = {
|
||||
.driver = {
|
||||
.name = "tegra-mipi",
|
||||
.of_match_table = tegra_mipi_of_match,
|
||||
},
|
||||
.probe = tegra_mipi_probe,
|
||||
.remove = tegra_mipi_remove,
|
||||
};
|
||||
|
@ -1450,7 +1450,7 @@ out_failed_reset:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ipu_remove(struct platform_device *pdev)
|
||||
static void ipu_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ipu_soc *ipu = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1459,8 +1459,6 @@ static int ipu_remove(struct platform_device *pdev)
|
||||
ipu_irq_exit(ipu);
|
||||
|
||||
clk_disable_unprepare(ipu->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver imx_ipu_driver = {
|
||||
@ -1469,7 +1467,7 @@ static struct platform_driver imx_ipu_driver = {
|
||||
.of_match_table = imx_ipu_dt_ids,
|
||||
},
|
||||
.probe = ipu_probe,
|
||||
.remove = ipu_remove,
|
||||
.remove_new = ipu_remove,
|
||||
};
|
||||
|
||||
static struct platform_driver * const drivers[] = {
|
||||
|
@ -351,7 +351,7 @@ static int ipu_pre_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ipu_pre_remove(struct platform_device *pdev)
|
||||
static void ipu_pre_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ipu_pre *pre = platform_get_drvdata(pdev);
|
||||
|
||||
@ -365,7 +365,6 @@ static int ipu_pre_remove(struct platform_device *pdev)
|
||||
if (pre->buffer_virt)
|
||||
gen_pool_free(pre->iram, (unsigned long)pre->buffer_virt,
|
||||
IPU_PRE_MAX_WIDTH * IPU_PRE_NUM_SCANLINES * 4);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id ipu_pre_dt_ids[] = {
|
||||
@ -375,7 +374,7 @@ static const struct of_device_id ipu_pre_dt_ids[] = {
|
||||
|
||||
struct platform_driver ipu_pre_drv = {
|
||||
.probe = ipu_pre_probe,
|
||||
.remove = ipu_pre_remove,
|
||||
.remove_new = ipu_pre_remove,
|
||||
.driver = {
|
||||
.name = "imx-ipu-pre",
|
||||
.of_match_table = ipu_pre_dt_ids,
|
||||
|
@ -419,15 +419,13 @@ static int ipu_prg_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ipu_prg_remove(struct platform_device *pdev)
|
||||
static void ipu_prg_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ipu_prg *prg = platform_get_drvdata(pdev);
|
||||
|
||||
mutex_lock(&ipu_prg_list_mutex);
|
||||
list_del(&prg->list);
|
||||
mutex_unlock(&ipu_prg_list_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
@ -471,7 +469,7 @@ static const struct of_device_id ipu_prg_dt_ids[] = {
|
||||
|
||||
struct platform_driver ipu_prg_drv = {
|
||||
.probe = ipu_prg_probe,
|
||||
.remove = ipu_prg_remove,
|
||||
.remove_new = ipu_prg_remove,
|
||||
.driver = {
|
||||
.name = "imx-ipu-prg",
|
||||
.pm = &prg_pm_ops,
|
||||
|
@ -90,9 +90,9 @@ greybus_match_id(struct gb_bundle *bundle, const struct greybus_bundle_id *id)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int greybus_match_device(struct device *dev, struct device_driver *drv)
|
||||
static int greybus_match_device(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct greybus_driver *driver = to_greybus_driver(drv);
|
||||
const struct greybus_driver *driver = to_greybus_driver(drv);
|
||||
struct gb_bundle *bundle;
|
||||
const struct greybus_bundle_id *id;
|
||||
|
||||
|
@ -2604,7 +2604,7 @@ const struct hid_device_id *hid_match_device(struct hid_device *hdev,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(hid_match_device);
|
||||
|
||||
static int hid_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int hid_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct hid_driver *hdrv = to_hid_driver(drv);
|
||||
struct hid_device *hdev = to_hid_device(dev);
|
||||
|
@ -236,7 +236,7 @@ static int ishtp_cl_device_probe(struct device *dev)
|
||||
*
|
||||
* Return: 1 if dev & drv matches, 0 otherwise.
|
||||
*/
|
||||
static int ishtp_cl_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int ishtp_cl_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
|
||||
struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv);
|
||||
|
@ -37,7 +37,7 @@ static int hsi_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int hsi_bus_match(struct device *dev, struct device_driver *driver)
|
||||
static int hsi_bus_match(struct device *dev, const struct device_driver *driver)
|
||||
{
|
||||
if (of_driver_match_device(dev, driver))
|
||||
return true;
|
||||
|
@ -685,7 +685,7 @@ static const struct hv_vmbus_device_id vmbus_device_null;
|
||||
* Return a matching hv_vmbus_device_id pointer.
|
||||
* If there is no match, return NULL.
|
||||
*/
|
||||
static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv,
|
||||
static const struct hv_vmbus_device_id *hv_vmbus_get_id(const struct hv_driver *drv,
|
||||
struct hv_device *dev)
|
||||
{
|
||||
const guid_t *guid = &dev->dev_type;
|
||||
@ -696,7 +696,7 @@ static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv,
|
||||
return NULL;
|
||||
|
||||
/* Look at the dynamic ids first, before the static ones */
|
||||
id = hv_vmbus_dynid_match(drv, guid);
|
||||
id = hv_vmbus_dynid_match((struct hv_driver *)drv, guid);
|
||||
if (!id)
|
||||
id = hv_vmbus_dev_match(drv->id_table, guid);
|
||||
|
||||
@ -809,9 +809,9 @@ ATTRIBUTE_GROUPS(vmbus_drv);
|
||||
/*
|
||||
* vmbus_match - Attempt to match the specified device to the specified driver
|
||||
*/
|
||||
static int vmbus_match(struct device *device, struct device_driver *driver)
|
||||
static int vmbus_match(struct device *device, const struct device_driver *driver)
|
||||
{
|
||||
struct hv_driver *drv = drv_to_hv_drv(driver);
|
||||
const struct hv_driver *drv = drv_to_hv_drv(driver);
|
||||
struct hv_device *hv_dev = device_to_hv_device(device);
|
||||
|
||||
/* The hv_sock driver handles all hv_sock offers. */
|
||||
|
@ -26,9 +26,9 @@ module_param(host_mode, bool, 0444);
|
||||
|
||||
static DEFINE_IDA(intel_th_ida);
|
||||
|
||||
static int intel_th_match(struct device *dev, struct device_driver *driver)
|
||||
static int intel_th_match(struct device *dev, const struct device_driver *driver)
|
||||
{
|
||||
struct intel_th_driver *thdrv = to_intel_th_driver(driver);
|
||||
const struct intel_th_driver *thdrv = to_intel_th_driver(driver);
|
||||
struct intel_th_device *thdev = to_intel_th_device(dev);
|
||||
|
||||
if (thdev->type == INTEL_TH_SWITCH &&
|
||||
|
@ -189,7 +189,7 @@ struct intel_th_driver {
|
||||
};
|
||||
|
||||
#define to_intel_th_driver(_d) \
|
||||
container_of((_d), struct intel_th_driver, driver)
|
||||
container_of_const((_d), struct intel_th_driver, driver)
|
||||
|
||||
#define to_intel_th_driver_or_null(_d) \
|
||||
((_d) ? to_intel_th_driver(_d) : NULL)
|
||||
|
@ -136,10 +136,10 @@ const void *i2c_get_match_data(const struct i2c_client *client)
|
||||
}
|
||||
EXPORT_SYMBOL(i2c_get_match_data);
|
||||
|
||||
static int i2c_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int i2c_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct i2c_client *client = i2c_verify_client(dev);
|
||||
struct i2c_driver *driver;
|
||||
const struct i2c_driver *driver;
|
||||
|
||||
|
||||
/* Attempt an OF style match */
|
||||
|
@ -301,10 +301,10 @@ static const struct device_type i3c_device_type = {
|
||||
.uevent = i3c_device_uevent,
|
||||
};
|
||||
|
||||
static int i3c_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int i3c_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct i3c_device *i3cdev;
|
||||
struct i3c_driver *i3cdrv;
|
||||
const struct i3c_driver *i3cdrv;
|
||||
|
||||
if (dev->type != &i3c_device_type)
|
||||
return 0;
|
||||
|
@ -806,9 +806,9 @@ start_over:
|
||||
}
|
||||
EXPORT_SYMBOL(gameport_unregister_driver);
|
||||
|
||||
static int gameport_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int gameport_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct gameport_driver *gameport_drv = to_gameport_driver(drv);
|
||||
const struct gameport_driver *gameport_drv = to_gameport_driver(drv);
|
||||
|
||||
return !gameport_drv->ignore;
|
||||
}
|
||||
|
@ -144,9 +144,9 @@ bool rmi_is_function_device(struct device *dev)
|
||||
return dev->type == &rmi_function_type;
|
||||
}
|
||||
|
||||
static int rmi_function_match(struct device *dev, struct device_driver *drv)
|
||||
static int rmi_function_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct rmi_function_handler *handler = to_rmi_function_handler(drv);
|
||||
const struct rmi_function_handler *handler = to_rmi_function_handler(drv);
|
||||
struct rmi_function *fn = to_rmi_function(dev);
|
||||
|
||||
return fn->fd.function_number == handler->func;
|
||||
@ -333,7 +333,7 @@ EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
|
||||
|
||||
/* Bus specific stuff */
|
||||
|
||||
static int rmi_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int rmi_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
bool physical = rmi_is_physical_device(dev);
|
||||
|
||||
|
@ -87,7 +87,7 @@ struct rmi_function_handler {
|
||||
};
|
||||
|
||||
#define to_rmi_function_handler(d) \
|
||||
container_of(d, struct rmi_function_handler, driver)
|
||||
container_of_const(d, struct rmi_function_handler, driver)
|
||||
|
||||
int __must_check __rmi_register_function_handler(struct rmi_function_handler *,
|
||||
struct module *, const char *);
|
||||
|
@ -1258,7 +1258,7 @@ static struct rmi_driver rmi_physical_driver = {
|
||||
.set_input_params = rmi_driver_set_input_params,
|
||||
};
|
||||
|
||||
bool rmi_is_physical_driver(struct device_driver *drv)
|
||||
bool rmi_is_physical_driver(const struct device_driver *drv)
|
||||
{
|
||||
return drv == &rmi_physical_driver.driver;
|
||||
}
|
||||
|
@ -84,7 +84,7 @@ int rmi_register_desc_calc_reg_offset(
|
||||
bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item *item,
|
||||
u8 subpacket);
|
||||
|
||||
bool rmi_is_physical_driver(struct device_driver *);
|
||||
bool rmi_is_physical_driver(const struct device_driver *);
|
||||
int rmi_register_physical_driver(void);
|
||||
void rmi_unregister_physical_driver(void);
|
||||
void rmi_free_function_list(struct rmi_device *rmi_dev);
|
||||
|
@ -877,10 +877,10 @@ static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
|
||||
serio_continue_rx(serio);
|
||||
}
|
||||
|
||||
static int serio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int serio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct serio *serio = to_serio_port(dev);
|
||||
struct serio_driver *serio_drv = to_serio_driver(drv);
|
||||
const struct serio_driver *serio_drv = to_serio_driver(drv);
|
||||
|
||||
if (serio->manual_bind || serio_drv->manual_bind)
|
||||
return 0;
|
||||
|
@ -13,7 +13,7 @@
|
||||
#include <linux/ipack.h>
|
||||
|
||||
#define to_ipack_dev(device) container_of(device, struct ipack_device, dev)
|
||||
#define to_ipack_driver(drv) container_of(drv, struct ipack_driver, driver)
|
||||
#define to_ipack_driver(drv) container_of_const(drv, struct ipack_driver, driver)
|
||||
|
||||
static DEFINE_IDA(ipack_ida);
|
||||
|
||||
@ -49,10 +49,10 @@ ipack_match_id(const struct ipack_device_id *ids, struct ipack_device *idev)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int ipack_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int ipack_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct ipack_device *idev = to_ipack_dev(dev);
|
||||
struct ipack_driver *idrv = to_ipack_driver(drv);
|
||||
const struct ipack_driver *idrv = to_ipack_driver(drv);
|
||||
const struct ipack_device_id *found_id;
|
||||
|
||||
found_id = ipack_match_id(idrv->id_table, idev);
|
||||
|
@ -36,7 +36,7 @@
|
||||
|
||||
static struct macio_chip *macio_on_hold;
|
||||
|
||||
static int macio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int macio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
const struct of_device_id * matches = drv->of_match_table;
|
||||
|
||||
|
@ -28,9 +28,9 @@ static const struct mcb_device_id *mcb_match_id(const struct mcb_device_id *ids,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int mcb_match(struct device *dev, struct device_driver *drv)
|
||||
static int mcb_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mcb_driver *mdrv = to_mcb_driver(drv);
|
||||
const struct mcb_driver *mdrv = to_mcb_driver(drv);
|
||||
struct mcb_device *mdev = to_mcb_device(dev);
|
||||
const struct mcb_device_id *found_id;
|
||||
|
||||
|
@ -28,9 +28,9 @@
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/* internal: the bttv "bus" */
|
||||
|
||||
static int bttv_sub_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int bttv_sub_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct bttv_sub_driver *sub = to_bttv_sub_drv(drv);
|
||||
const struct bttv_sub_driver *sub = to_bttv_sub_drv(drv);
|
||||
int len = strlen(sub->wanted);
|
||||
|
||||
if (0 == strncmp(dev_name(dev), sub->wanted, len))
|
||||
|
@ -341,7 +341,7 @@ struct bttv_sub_driver {
|
||||
int (*probe)(struct bttv_sub_device *sub);
|
||||
void (*remove)(struct bttv_sub_device *sub);
|
||||
};
|
||||
#define to_bttv_sub_drv(x) container_of((x), struct bttv_sub_driver, drv)
|
||||
#define to_bttv_sub_drv(x) container_of_const((x), struct bttv_sub_driver, drv)
|
||||
|
||||
int bttv_sub_register(struct bttv_sub_driver *drv, char *wanted);
|
||||
int bttv_sub_unregister(struct bttv_sub_driver *drv);
|
||||
|
@ -21,7 +21,7 @@ struct ipu6_buttress_ctrl;
|
||||
|
||||
struct ipu6_bus_device {
|
||||
struct auxiliary_device auxdev;
|
||||
struct auxiliary_driver *auxdrv;
|
||||
const struct auxiliary_driver *auxdrv;
|
||||
const struct ipu6_auxdrv_data *auxdrv_data;
|
||||
struct list_head list;
|
||||
void *pdata;
|
||||
|
@ -38,12 +38,11 @@ static int memstick_dev_match(struct memstick_dev *card,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int memstick_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int memstick_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct memstick_dev *card = container_of(dev, struct memstick_dev,
|
||||
dev);
|
||||
struct memstick_driver *ms_drv = container_of(drv,
|
||||
struct memstick_driver,
|
||||
const struct memstick_driver *ms_drv = container_of_const(drv, struct memstick_driver,
|
||||
driver);
|
||||
struct memstick_device_id *ids = ms_drv->id_table;
|
||||
|
||||
|
@ -20,7 +20,7 @@
|
||||
#define to_mcp(d) container_of(d, struct mcp, attached_device)
|
||||
#define to_mcp_driver(d) container_of(d, struct mcp_driver, drv)
|
||||
|
||||
static int mcp_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int mcp_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
@ -19,7 +19,7 @@
|
||||
#include "mei_dev.h"
|
||||
#include "client.h"
|
||||
|
||||
#define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
|
||||
#define to_mei_cl_driver(d) container_of_const(d, struct mei_cl_driver, driver)
|
||||
|
||||
/**
|
||||
* __mei_cl_send - internal client send (write)
|
||||
@ -1124,7 +1124,7 @@ struct mei_cl_device_id *mei_cl_device_find(const struct mei_cl_device *cldev,
|
||||
*
|
||||
* Return: 1 if matching device was found 0 otherwise
|
||||
*/
|
||||
static int mei_cl_device_match(struct device *dev, struct device_driver *drv)
|
||||
static int mei_cl_device_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
const struct mei_cl_device *cldev = to_mei_cl_device(dev);
|
||||
const struct mei_cl_driver *cldrv = to_mei_cl_driver(drv);
|
||||
|
@ -38,10 +38,10 @@ static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tifm_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int tifm_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
|
||||
struct tifm_driver *fm_drv = container_of(drv, struct tifm_driver,
|
||||
const struct tifm_driver *fm_drv = container_of_const(drv, struct tifm_driver,
|
||||
driver);
|
||||
struct tifm_device_id *ids = fm_drv->id_table;
|
||||
|
||||
|
@ -26,7 +26,7 @@
|
||||
#include "sdio_cis.h"
|
||||
#include "sdio_bus.h"
|
||||
|
||||
#define to_sdio_driver(d) container_of(d, struct sdio_driver, drv)
|
||||
#define to_sdio_driver(d) container_of_const(d, struct sdio_driver, drv)
|
||||
|
||||
/* show configuration fields */
|
||||
#define sdio_config_attr(field, format_string, args...) \
|
||||
@ -91,7 +91,7 @@ static const struct sdio_device_id *sdio_match_one(struct sdio_func *func,
|
||||
}
|
||||
|
||||
static const struct sdio_device_id *sdio_match_device(struct sdio_func *func,
|
||||
struct sdio_driver *sdrv)
|
||||
const struct sdio_driver *sdrv)
|
||||
{
|
||||
const struct sdio_device_id *ids;
|
||||
|
||||
@ -108,10 +108,10 @@ static const struct sdio_device_id *sdio_match_device(struct sdio_func *func,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int sdio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int sdio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct sdio_func *func = dev_to_sdio_func(dev);
|
||||
struct sdio_driver *sdrv = to_sdio_driver(drv);
|
||||
const struct sdio_driver *sdrv = to_sdio_driver(drv);
|
||||
|
||||
if (sdio_match_device(func, sdrv))
|
||||
return 1;
|
||||
|
@ -491,7 +491,7 @@ static int print_links(struct device *dev, void *data)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int most_match(struct device *dev, struct device_driver *drv)
|
||||
static int most_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
if (!strcmp(dev_name(dev), "most"))
|
||||
return 0;
|
||||
|
@ -239,7 +239,7 @@ void bnxt_ulp_stop(struct bnxt *bp)
|
||||
|
||||
adev = &aux_priv->aux_dev;
|
||||
if (adev->dev.driver) {
|
||||
struct auxiliary_driver *adrv;
|
||||
const struct auxiliary_driver *adrv;
|
||||
pm_message_t pm = {};
|
||||
|
||||
adrv = to_auxiliary_drv(adev->dev.driver);
|
||||
@ -277,7 +277,7 @@ void bnxt_ulp_start(struct bnxt *bp, int err)
|
||||
|
||||
adev = &aux_priv->aux_dev;
|
||||
if (adev->dev.driver) {
|
||||
struct auxiliary_driver *adrv;
|
||||
const struct auxiliary_driver *adrv;
|
||||
|
||||
adrv = to_auxiliary_drv(adev->dev.driver);
|
||||
edev->en_state = bp->state;
|
||||
|
@ -2915,7 +2915,7 @@ static struct ice_pf *
|
||||
ice_ptp_aux_dev_to_owner_pf(struct auxiliary_device *aux_dev)
|
||||
{
|
||||
struct ice_ptp_port_owner *ports_owner;
|
||||
struct auxiliary_driver *aux_drv;
|
||||
const struct auxiliary_driver *aux_drv;
|
||||
struct ice_ptp *owner_ptp;
|
||||
|
||||
if (!aux_dev->dev.driver)
|
||||
|
@ -349,7 +349,7 @@ int mlx5_attach_device(struct mlx5_core_dev *dev)
|
||||
{
|
||||
struct mlx5_priv *priv = &dev->priv;
|
||||
struct auxiliary_device *adev;
|
||||
struct auxiliary_driver *adrv;
|
||||
const struct auxiliary_driver *adrv;
|
||||
int ret = 0, i;
|
||||
|
||||
devl_assert_locked(priv_to_devlink(dev));
|
||||
@ -406,7 +406,7 @@ void mlx5_detach_device(struct mlx5_core_dev *dev, bool suspend)
|
||||
{
|
||||
struct mlx5_priv *priv = &dev->priv;
|
||||
struct auxiliary_device *adev;
|
||||
struct auxiliary_driver *adrv;
|
||||
const struct auxiliary_driver *adrv;
|
||||
pm_message_t pm = {};
|
||||
int i;
|
||||
|
||||
|
@ -1358,7 +1358,7 @@ error_free:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int rtsn_remove(struct platform_device *pdev)
|
||||
static void rtsn_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtsn_private *priv = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1372,8 +1372,6 @@ static int rtsn_remove(struct platform_device *pdev)
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
free_netdev(priv->ndev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver rtsn_driver = {
|
||||
|
@ -1375,9 +1375,9 @@ EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed);
|
||||
* require calling the devices own match function, since different classes
|
||||
* of MDIO devices have different match criteria.
|
||||
*/
|
||||
static int mdio_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int mdio_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mdio_driver *mdiodrv = to_mdio_driver(drv);
|
||||
const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
|
||||
struct mdio_device *mdio = to_mdio_device(dev);
|
||||
|
||||
/* Both the driver and device must type-match */
|
||||
|
@ -35,10 +35,10 @@ static void mdio_device_release(struct device *dev)
|
||||
kfree(to_mdio_device(dev));
|
||||
}
|
||||
|
||||
int mdio_device_bus_match(struct device *dev, struct device_driver *drv)
|
||||
int mdio_device_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct mdio_device *mdiodev = to_mdio_device(dev);
|
||||
struct mdio_driver *mdiodrv = to_mdio_driver(drv);
|
||||
const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
|
||||
|
||||
if (mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)
|
||||
return 0;
|
||||
|
@ -533,10 +533,10 @@ static int phy_scan_fixups(struct phy_device *phydev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int phy_bus_match(struct device *dev, struct device_driver *drv)
|
||||
static int phy_bus_match(struct device *dev, const struct device_driver *drv)
|
||||
{
|
||||
struct phy_device *phydev = to_phy_device(dev);
|
||||
struct phy_driver *phydrv = to_phy_driver(drv);
|
||||
const struct phy_driver *phydrv = to_phy_driver(drv);
|
||||
const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
|
||||
int i;
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user