korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-23 12:14:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

driver core: have match() callback in struct bus_type take a const *

Browse Source 
In the match() callback, the struct device_driver * should not be
changed, so change the function callback to be a const *.  This is one
step of many towards making the driver core safe to have struct
device_driver in read-only memory.

Because the match() callback is in all busses, all busses are modified
to handle this properly.  This does entail switching some container_of()
calls to container_of_const() to properly handle the constant *.

For some busses, like PCI and USB and HV, the const * is cast away in
the match callback as those busses do want to modify those structures at
this point in time (they have a local lock in the driver structure.)
That will have to be changed in the future if they wish to have their
struct device * in read-only-memory.

Cc: Rafael J. Wysocki <rafael@kernel.org>
Reviewed-by: Alex Elder <elder@kernel.org>
Acked-by: Sumit Garg <sumit.garg@linaro.org>
Link: https://lore.kernel.org/r/2024070136-wrongdoer-busily-01e8@gregkh
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Greg Kroah-Hartman 2024-07-01 14:07:37 +02:00
parent 6b521fc111
commit d69d804845
163 changed files with 268 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arch/arm/common/locomo.c
View File

@ -816,10 +816,10 @@ EXPORT_SYMBOL(locomo_frontlight_set);
* We model this as a regular bus type, and hang devices directly * We model this as a regular bus type, and hang devices directly
* off this. * 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_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; return dev->devid == drv->devid;
} }

2
arch/arm/include/asm/hardware/locomo.h
View File

@ -189,7 +189,7 @@ struct locomo_driver {
void (*remove)(struct locomo_dev *); 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) #define LOCOMO_DRIVER_NAME(_ldev) ((_ldev)->dev.driver->name)

2
arch/parisc/include/asm/parisc-device.h
View File

@ -41,7 +41,7 @@ struct parisc_driver {
#define to_parisc_device(d) container_of(d, struct parisc_device, dev) #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) #define parisc_parent(d) to_parisc_device(d->dev.parent)
static inline const char *parisc_pathname(struct parisc_device *d) static inline const char *parisc_pathname(struct parisc_device *d)

4
arch/parisc/kernel/drivers.c
View File

@ -97,7 +97,7 @@ static int for_each_padev(int (*fn)(struct device *, void *), void * data)
* @driver: the PA-RISC driver to try * @driver: the PA-RISC driver to try
* @dev: the PA-RISC device 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; const struct parisc_device_id *ids;
@ -548,7 +548,7 @@ alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path)
return dev; 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)); return match_device(to_parisc_driver(drv), to_parisc_device(dev));
} }

6
arch/powerpc/include/asm/ps3.h
View File

@ -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); int ps3_system_bus_driver_register(struct ps3_system_bus_driver *drv);
void ps3_system_bus_driver_unregister(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( #define ps3_drv_to_system_bus_drv(_drv) container_of_const(_drv, struct ps3_system_bus_driver, core)
struct device_driver *_drv)
{
return container_of(_drv, struct ps3_system_bus_driver, core);
}
static inline struct ps3_system_bus_device *ps3_dev_to_system_bus_dev( static inline struct ps3_system_bus_device *ps3_dev_to_system_bus_dev(
const struct device *_dev) const struct device *_dev)
{ {

6
arch/powerpc/include/asm/vio.h
View File

@ -156,11 +156,7 @@ static inline int vio_enable_interrupts(struct vio_dev *dev)
} }
#endif #endif
static inline struct vio_driver *to_vio_driver(struct device_driver *drv) #define to_vio_driver(__drv) container_of_const(__drv, struct vio_driver, driver)
{
return container_of(drv, struct vio_driver, driver);
}
#define to_vio_dev(__dev) container_of_const(__dev, struct vio_dev, dev) #define to_vio_dev(__dev) container_of_const(__dev, struct vio_dev, dev)
#endif /* __KERNEL__ */ #endif /* __KERNEL__ */

4
arch/powerpc/platforms/ps3/system-bus.c
View File

@ -333,10 +333,10 @@ int ps3_mmio_region_init(struct ps3_system_bus_device *dev,
EXPORT_SYMBOL_GPL(ps3_mmio_region_init); EXPORT_SYMBOL_GPL(ps3_mmio_region_init);
static int ps3_system_bus_match(struct device *_dev, static int ps3_system_bus_match(struct device *_dev,
struct device_driver *_drv) const struct device_driver *_drv)
{ {
int result; 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); struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
if (!dev->match_sub_id) if (!dev->match_sub_id)

2
arch/powerpc/platforms/pseries/ibmebus.c
View File

@ -339,7 +339,7 @@ static struct attribute *ibmbus_bus_attrs[] = {
}; };
ATTRIBUTE_GROUPS(ibmbus_bus); 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; const struct of_device_id *matches = drv->of_match_table;

6
arch/powerpc/platforms/pseries/vio.c
View File

@ -1576,10 +1576,10 @@ void vio_unregister_device(struct vio_dev *viodev)
} }
EXPORT_SYMBOL(vio_unregister_device); 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); 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; const struct vio_device_id *ids = vio_drv->id_table;
return (ids != NULL) && (vio_match_device(ids, vio_dev) != NULL); return (ids != NULL) && (vio_match_device(ids, vio_dev) != NULL);
@ -1689,7 +1689,7 @@ struct vio_dev *vio_find_node(struct device_node *vnode)
/* construct the kobject name from the device node */ /* construct the kobject name from the device node */
if (of_node_is_type(vnode_parent, "vdevice")) { if (of_node_is_type(vnode_parent, "vdevice")) {
const __be32 *prop; const __be32 *prop;
prop = of_get_property(vnode, "reg", NULL); prop = of_get_property(vnode, "reg", NULL);
if (!prop) if (!prop)
goto out; goto out;

2
arch/s390/include/asm/ccwdev.h
View File

@ -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 get_ccwdev_lock(x) (x)->ccwlock
#define to_ccwdev(n) container_of(n, struct ccw_device, dev) #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 struct ccw_device *ccw_device_create_console(struct ccw_driver *);
extern void ccw_device_destroy_console(struct ccw_device *); extern void ccw_device_destroy_console(struct ccw_device *);

6
arch/sparc/include/asm/vio.h
View File

@ -483,11 +483,7 @@ int __vio_register_driver(struct vio_driver *drv, struct module *owner,
__vio_register_driver(driver, THIS_MODULE, KBUILD_MODNAME) __vio_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
void vio_unregister_driver(struct vio_driver *drv); void vio_unregister_driver(struct vio_driver *drv);
static inline struct vio_driver *to_vio_driver(struct device_driver *drv) #define to_vio_driver(__drv) container_of_const(__drv, struct vio_driver, driver)
{
return container_of(drv, struct vio_driver, driver);
}
#define to_vio_dev(__dev) container_of_const(__dev, struct vio_dev, dev) #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); int vio_ldc_send(struct vio_driver_state *vio, void *data, int len);

4
arch/sparc/kernel/vio.c
View File

@ -54,10 +54,10 @@ static int vio_hotplug(const struct device *dev, struct kobj_uevent_env *env)
return 0; 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_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; const struct vio_device_id *matches = vio_drv->id_table;
if (!matches) if (!matches)

4
drivers/acpi/bus.c
View File

@ -1045,10 +1045,10 @@ EXPORT_SYMBOL(acpi_bus_unregister_driver);
ACPI Bus operations 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_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 return acpi_dev->flags.match_driver
&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids); && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);

6
drivers/amba/bus.c
View File

@ -26,7 +26,7 @@
#include <linux/iommu.h> #include <linux/iommu.h>
#include <linux/dma-map-ops.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. */ /* called on periphid match and class 0x9 coresight device. */
static int static int
@ -205,10 +205,10 @@ err_out:
return ret; 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_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); mutex_lock(&pcdev->periphid_lock);
if (!pcdev->periphid) { if (!pcdev->periphid) {

2
drivers/base/auxiliary.c
View File

@ -177,7 +177,7 @@ static const struct auxiliary_device_id *auxiliary_match_id(const struct auxilia
return NULL; 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_device *auxdev = to_auxiliary_dev(dev);
const struct auxiliary_driver *auxdrv = to_auxiliary_drv(drv); const struct auxiliary_driver *auxdrv = to_auxiliary_drv(drv);

3
drivers/base/base.h
View File

@ -164,8 +164,7 @@ void device_set_deferred_probe_reason(const struct device *dev, struct va_format
static inline int driver_match_device(const struct device_driver *drv, static inline int driver_match_device(const struct device_driver *drv,
struct device *dev) struct device *dev)
{ {
/* cast will be removed in the future when match can handle a const pointer properly. */ return drv->bus->match ? drv->bus->match(dev, drv) : 1;
return drv->bus->match ? drv->bus->match(dev, (struct device_driver *)drv) : 1;
} }
static inline void dev_sync_state(struct device *dev) static inline void dev_sync_state(struct device *dev)

2
drivers/base/cpu.c
View File

@ -26,7 +26,7 @@
static DEFINE_PER_CPU(struct device *, cpu_sys_devices); 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. */ /* ACPI style match is the only one that may succeed. */
if (acpi_driver_match_device(dev, drv)) if (acpi_driver_match_device(dev, drv))

2
drivers/base/isa.c
View File

@ -23,7 +23,7 @@ struct isa_dev {
#define to_isa_dev(x) container_of((x), struct isa_dev, 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); struct isa_driver *isa_driver = to_isa_driver(driver);

2
drivers/base/platform.c
View File

@ -1332,7 +1332,7 @@ __ATTRIBUTE_GROUPS(platform_dev);
* and compare it against the name of the driver. Return whether they match * and compare it against the name of the driver. Return whether they match
* or not. * 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_device *pdev = to_platform_device(dev);
struct platform_driver *pdrv = to_platform_driver(drv); struct platform_driver *pdrv = to_platform_driver(drv);

6
drivers/bcma/main.c
View File

@ -26,7 +26,7 @@ static unsigned int bcma_bus_next_num;
/* bcma_buses_mutex locks the bcma_bus_next_num */ /* bcma_buses_mutex locks the bcma_bus_next_num */
static DEFINE_MUTEX(bcma_buses_mutex); 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 int bcma_device_probe(struct device *dev);
static void bcma_device_remove(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); 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); 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_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 *cid = &core->id;
const struct bcma_device_id *did; const struct bcma_device_id *did;

4
drivers/bus/fsl-mc/fsl-mc-bus.c
View File

@ -80,11 +80,11 @@ static phys_addr_t mc_portal_base_phys_addr;
* *
* Returns 1 on success, 0 otherwise. * 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; const struct fsl_mc_device_id *id;
struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev); 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; bool found = false;
/* When driver_override is set, only bind to the matching driver */ /* When driver_override is set, only bind to the matching driver */

4
drivers/bus/mhi/ep/main.c
View File

@ -1694,10 +1694,10 @@ static int mhi_ep_uevent(const struct device *dev, struct kobj_uevent_env *env)
mhi_dev->name); 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_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; const struct mhi_device_id *id;
/* /*

4
drivers/bus/mhi/host/init.c
View File

@ -1442,10 +1442,10 @@ static int mhi_uevent(const struct device *dev, struct kobj_uevent_env *env)
mhi_dev->name); 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_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; const struct mhi_device_id *id;
/* /*

6
drivers/bus/mips_cdmm.c
View File

@ -37,7 +37,7 @@
/* Each block of device registers is 64 bytes */ /* Each block of device registers is 64 bytes */
#define CDMM_DRB_SIZE 64 #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 */ /* Default physical base address */
static phys_addr_t mips_cdmm_default_base; 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; 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_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; return mips_cdmm_lookup(cdrv->id_table, cdev) != NULL;
} }

4
drivers/bus/moxtet.c
View File

@ -83,10 +83,10 @@ static const struct attribute_group *moxtet_dev_groups[] = {
NULL, 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_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; const enum turris_mox_module_id *t;
if (of_driver_match_device(dev, drv)) if (of_driver_match_device(dev, drv))

2
drivers/bus/sunxi-rsb.c
View File

@ -130,7 +130,7 @@ struct sunxi_rsb {
/* bus / slave device related functions */ /* bus / slave device related functions */
static const struct bus_type sunxi_rsb_bus; 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); return of_driver_match_device(dev, drv);
} }

4
drivers/cdx/cdx.c
View File

@ -262,10 +262,10 @@ EXPORT_SYMBOL_GPL(cdx_clear_master);
* *
* Return: true on success, false otherwise. * 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_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 *found_id = NULL;
const struct cdx_device_id *ids; const struct cdx_device_id *ids;

2
drivers/cxl/core/port.c
View File

@ -2082,7 +2082,7 @@ static int cxl_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
cxl_device_id(dev)); 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; return cxl_device_id(dev) == to_cxl_drv(drv)->id;
} }

5
drivers/cxl/cxl.h
View File

@ -823,10 +823,7 @@ struct cxl_driver {
int id; int id;
}; };
static inline struct cxl_driver *to_cxl_drv(struct device_driver *drv) #define to_cxl_drv(__drv) container_of_const(__drv, struct cxl_driver, drv)
{
return container_of(drv, struct cxl_driver, drv);
}
int __cxl_driver_register(struct cxl_driver *cxl_drv, struct module *owner, int __cxl_driver_register(struct cxl_driver *cxl_drv, struct module *owner,
const char *modname); const char *modname);

17
drivers/dax/bus.c
View File

@ -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); return add_uevent_var(env, "MODALIAS=" DAX_DEVICE_MODALIAS_FMT, 0);
} }
static struct dax_device_driver *to_dax_drv(struct device_driver *drv) #define to_dax_drv(__drv) container_of_const(__drv, struct dax_device_driver, drv)
{
return container_of(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) const char *dev_name)
{ {
struct dax_id *dax_id; struct dax_id *dax_id;
@ -57,7 +54,7 @@ static struct dax_id *__dax_match_id(struct dax_device_driver *dax_drv,
return NULL; 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; int match;
@ -68,7 +65,7 @@ static int dax_match_id(struct dax_device_driver *dax_drv, struct device *dev)
return match; 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; enum dax_driver_type type = DAXDRV_DEVICE_TYPE;
struct dev_dax *dev_dax = to_dev_dax(dev); struct dev_dax *dev_dax = to_dev_dax(dev);
@ -156,7 +153,7 @@ static struct attribute *dax_drv_attrs[] = {
}; };
ATTRIBUTE_GROUPS(dax_drv); 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 * 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, .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)) if (dax_match_id(dax_drv, dev))
return 1; return 1;

6
drivers/dma/idxd/bus.c
View File

@ -33,10 +33,10 @@ void idxd_driver_unregister(struct idxd_device_driver *idxd_drv)
EXPORT_SYMBOL_GPL(idxd_driver_unregister); EXPORT_SYMBOL_GPL(idxd_driver_unregister);
static int idxd_config_bus_match(struct device *dev, static int idxd_config_bus_match(struct device *dev,
struct device_driver *drv) const struct device_driver *drv)
{ {
struct idxd_device_driver *idxd_drv = const struct idxd_device_driver *idxd_drv =
container_of(drv, struct idxd_device_driver, drv); container_of_const(drv, struct idxd_device_driver, drv);
struct idxd_dev *idxd_dev = confdev_to_idxd_dev(dev); struct idxd_dev *idxd_dev = confdev_to_idxd_dev(dev);
int i = 0; int i = 0;

4
drivers/eisa/eisa-bus.c
View File

@ -105,10 +105,10 @@ static char __init *decode_eisa_sig(unsigned long addr)
return sig_str; 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_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; const struct eisa_device_id *eids = edrv->id_table;
if (!eids) if (!eids)

6
drivers/firewire/core-device.c
View File

@ -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, 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 = 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}; int id[] = {0, 0, 0, 0};
get_modalias_ids(fw_unit(dev), id); 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 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. */ /* We only allow binding to fw_units. */
return is_fw_unit(dev) && unit_match(dev, drv) != NULL; return is_fw_unit(dev) && unit_match(dev, drv) != NULL;

2
drivers/firmware/arm_ffa/bus.c
View File

@ -19,7 +19,7 @@
static DEFINE_IDA(ffa_bus_id); 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; const struct ffa_device_id *id_table;
struct ffa_device *ffa_dev; struct ffa_device *ffa_dev;

6
drivers/firmware/arm_scmi/bus.c
View File

@ -207,7 +207,7 @@ scmi_protocol_table_unregister(const struct scmi_device_id *id_table)
} }
static const struct scmi_device_id * 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; 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; 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); struct scmi_device *scmi_dev = to_scmi_dev(dev);
const struct scmi_device_id *id; const struct scmi_device_id *id;

6
drivers/firmware/google/coreboot_table.c
View File

@ -22,12 +22,12 @@
#include "coreboot_table.h" #include "coreboot_table.h"
#define CB_DEV(d) container_of(d, struct coreboot_device, dev) #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_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; const struct coreboot_device_id *id;
if (!driver->id_table) if (!driver->id_table)

4
drivers/fpga/dfl.c
View File

@ -257,10 +257,10 @@ dfl_match_one_device(const struct dfl_device_id *id, struct dfl_device *ddev)
return NULL; 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_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; const struct dfl_device_id *id_entry;
id_entry = ddrv->id_table; id_entry = ddrv->id_table;

4
drivers/fsi/fsi-core.c
View File

@ -1361,10 +1361,10 @@ EXPORT_SYMBOL_GPL(fsi_master_unregister);
/* FSI core & Linux bus type definitions */ /* 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_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; const struct fsi_device_id *id;
if (!fsi_drv->id_table) if (!fsi_drv->id_table)

2
drivers/gpio/gpiolib.c
View File

@ -53,7 +53,7 @@ static DEFINE_IDA(gpio_ida);
static dev_t gpio_devt; static dev_t gpio_devt;
#define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */ #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); struct fwnode_handle *fwnode = dev_fwnode(dev);

2
drivers/gpu/drm/display/drm_dp_aux_bus.c
View File

@ -36,7 +36,7 @@ struct dp_aux_ep_device_with_data {
* *
* Return: True if this driver matches this device; false otherwise. * 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); return !!of_match_device(drv->of_match_table, dev);
} }

2
drivers/gpu/drm/drm_mipi_dsi.c
View File

@ -48,7 +48,7 @@
* subset of the MIPI DCS command set. * 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); struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);

2
drivers/gpu/host1x/bus.c
View File

@ -333,7 +333,7 @@ static int host1x_del_client(struct host1x *host1x,
return -ENODEV; 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; return strcmp(dev_name(dev), drv->name) == 0;
} }

4
drivers/greybus/core.c
View File

@ -90,9 +90,9 @@ greybus_match_id(struct gb_bundle *bundle, const struct greybus_bundle_id *id)
return NULL; 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; struct gb_bundle *bundle;
const struct greybus_bundle_id *id; const struct greybus_bundle_id *id;

2
drivers/hid/hid-core.c
View File

@ -2562,7 +2562,7 @@ const struct hid_device_id *hid_match_device(struct hid_device *hdev,
} }
EXPORT_SYMBOL_GPL(hid_match_device); 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_driver *hdrv = to_hid_driver(drv);
struct hid_device *hdev = to_hid_device(dev); struct hid_device *hdev = to_hid_device(dev);

2
drivers/hid/intel-ish-hid/ishtp/bus.c
View File

@ -236,7 +236,7 @@ static int ishtp_cl_device_probe(struct device *dev)
* *
* Return: 1 if dev & drv matches, 0 otherwise. * 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_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv); struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv);

2
drivers/hsi/hsi_core.c
View File

@ -37,7 +37,7 @@ static int hsi_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
return 0; 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)) if (of_driver_match_device(dev, driver))
return true; return true;

8
drivers/hv/vmbus_drv.c
View File

@ -685,7 +685,7 @@ static const struct hv_vmbus_device_id vmbus_device_null;
* Return a matching hv_vmbus_device_id pointer. * Return a matching hv_vmbus_device_id pointer.
* If there is no match, return NULL. * 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) struct hv_device *dev)
{ {
const guid_t *guid = &dev->dev_type; 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; return NULL;
/* Look at the dynamic ids first, before the static ones */ /* 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) if (!id)
id = hv_vmbus_dev_match(drv->id_table, guid); 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 * 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); struct hv_device *hv_dev = device_to_hv_device(device);
/* The hv_sock driver handles all hv_sock offers. */ /* The hv_sock driver handles all hv_sock offers. */

4
drivers/hwtracing/intel_th/core.c
View File

@ -26,9 +26,9 @@ module_param(host_mode, bool, 0444);
static DEFINE_IDA(intel_th_ida); 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); struct intel_th_device *thdev = to_intel_th_device(dev);
if (thdev->type == INTEL_TH_SWITCH && if (thdev->type == INTEL_TH_SWITCH &&

2
drivers/hwtracing/intel_th/intel_th.h
View File

@ -189,7 +189,7 @@ struct intel_th_driver {
}; };
#define to_intel_th_driver(_d) \ #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) \ #define to_intel_th_driver_or_null(_d) \
((_d) ? to_intel_th_driver(_d) : NULL) ((_d) ? to_intel_th_driver(_d) : NULL)

4
drivers/i2c/i2c-core-base.c
View File

@ -136,10 +136,10 @@ const void *i2c_get_match_data(const struct i2c_client *client)
} }
EXPORT_SYMBOL(i2c_get_match_data); 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_client *client = i2c_verify_client(dev);
struct i2c_driver *driver; const struct i2c_driver *driver;
/* Attempt an OF style match */ /* Attempt an OF style match */

4
drivers/i3c/master.c
View File

@ -301,10 +301,10 @@ static const struct device_type i3c_device_type = {
.uevent = i3c_device_uevent, .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_device *i3cdev;
struct i3c_driver *i3cdrv; const struct i3c_driver *i3cdrv;
if (dev->type != &i3c_device_type) if (dev->type != &i3c_device_type)
return 0; return 0;

4
drivers/input/gameport/gameport.c
View File

@ -806,9 +806,9 @@ start_over:
} }
EXPORT_SYMBOL(gameport_unregister_driver); 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; return !gameport_drv->ignore;
} }

6
drivers/input/rmi4/rmi_bus.c
View File

@ -144,9 +144,9 @@ bool rmi_is_function_device(struct device *dev)
return dev->type == &rmi_function_type; 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); struct rmi_function *fn = to_rmi_function(dev);
return fn->fd.function_number == handler->func; return fn->fd.function_number == handler->func;
@ -333,7 +333,7 @@ EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
/* Bus specific stuff */ /* 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); bool physical = rmi_is_physical_device(dev);

2
drivers/input/rmi4/rmi_bus.h
View File

@ -87,7 +87,7 @@ struct rmi_function_handler {
}; };
#define to_rmi_function_handler(d) \ #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 *, int __must_check __rmi_register_function_handler(struct rmi_function_handler *,
struct module *, const char *); struct module *, const char *);

2
drivers/input/rmi4/rmi_driver.c
View File

@ -1258,7 +1258,7 @@ static struct rmi_driver rmi_physical_driver = {
.set_input_params = rmi_driver_set_input_params, .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; return drv == &rmi_physical_driver.driver;
} }

2
drivers/input/rmi4/rmi_driver.h
View File

@ -84,7 +84,7 @@ int rmi_register_desc_calc_reg_offset(
bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item *item, bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item *item,
u8 subpacket); 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); int rmi_register_physical_driver(void);
void rmi_unregister_physical_driver(void); void rmi_unregister_physical_driver(void);
void rmi_free_function_list(struct rmi_device *rmi_dev); void rmi_free_function_list(struct rmi_device *rmi_dev);

4
drivers/input/serio/serio.c
View File

@ -877,10 +877,10 @@ static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
serio_continue_rx(serio); 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 *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) if (serio->manual_bind || serio_drv->manual_bind)
return 0; return 0;

6
drivers/ipack/ipack.c
View File

@ -13,7 +13,7 @@
#include <linux/ipack.h> #include <linux/ipack.h>
#define to_ipack_dev(device) container_of(device, struct ipack_device, dev) #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); static DEFINE_IDA(ipack_ida);
@ -49,10 +49,10 @@ ipack_match_id(const struct ipack_device_id *ids, struct ipack_device *idev)
return NULL; 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_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; const struct ipack_device_id *found_id;
found_id = ipack_match_id(idrv->id_table, idev); found_id = ipack_match_id(idrv->id_table, idev);

2
drivers/macintosh/macio_asic.c
View File

@ -36,7 +36,7 @@
static struct macio_chip *macio_on_hold; 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; const struct of_device_id * matches = drv->of_match_table;

4
drivers/mcb/mcb-core.c
View File

@ -28,9 +28,9 @@ static const struct mcb_device_id *mcb_match_id(const struct mcb_device_id *ids,
return NULL; 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); struct mcb_device *mdev = to_mcb_device(dev);
const struct mcb_device_id *found_id; const struct mcb_device_id *found_id;

4
drivers/media/pci/bt8xx/bttv-gpio.c
View File

@ -28,9 +28,9 @@
/* ----------------------------------------------------------------------- */ /* ----------------------------------------------------------------------- */
/* internal: the bttv "bus" */ /* 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); int len = strlen(sub->wanted);
if (0 == strncmp(dev_name(dev), sub->wanted, len)) if (0 == strncmp(dev_name(dev), sub->wanted, len))

2
drivers/media/pci/bt8xx/bttv.h
View File

@ -341,7 +341,7 @@ struct bttv_sub_driver {
int (*probe)(struct bttv_sub_device *sub); int (*probe)(struct bttv_sub_device *sub);
void (*remove)(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_register(struct bttv_sub_driver *drv, char *wanted);
int bttv_sub_unregister(struct bttv_sub_driver *drv); int bttv_sub_unregister(struct bttv_sub_driver *drv);

7
drivers/memstick/core/memstick.c
View File

@ -38,13 +38,12 @@ static int memstick_dev_match(struct memstick_dev *card,
return 0; 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, struct memstick_dev *card = container_of(dev, struct memstick_dev,
dev); dev);
struct memstick_driver *ms_drv = container_of(drv, const struct memstick_driver *ms_drv = container_of_const(drv, struct memstick_driver,
struct memstick_driver, driver);
driver);
struct memstick_device_id *ids = ms_drv->id_table; struct memstick_device_id *ids = ms_drv->id_table;
if (ids) { if (ids) {

2
drivers/mfd/mcp-core.c
View File

@ -20,7 +20,7 @@
#define to_mcp(d) container_of(d, struct mcp, attached_device) #define to_mcp(d) container_of(d, struct mcp, attached_device)
#define to_mcp_driver(d) container_of(d, struct mcp_driver, drv) #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; return 1;
} }

4
drivers/misc/mei/bus.c
View File

@ -19,7 +19,7 @@
#include "mei_dev.h" #include "mei_dev.h"
#include "client.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) * __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 * 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_device *cldev = to_mei_cl_device(dev);
const struct mei_cl_driver *cldrv = to_mei_cl_driver(drv); const struct mei_cl_driver *cldrv = to_mei_cl_driver(drv);

6
drivers/misc/tifm_core.c
View File

@ -38,11 +38,11 @@ static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id)
return 0; 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_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); driver);
struct tifm_device_id *ids = fm_drv->id_table; struct tifm_device_id *ids = fm_drv->id_table;
if (ids) { if (ids) {

10
drivers/mmc/core/sdio_bus.c
View File

@ -26,7 +26,7 @@
#include "sdio_cis.h" #include "sdio_cis.h"
#include "sdio_bus.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 */ /* show configuration fields */
#define sdio_config_attr(field, format_string, args...) \ #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, 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; 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; 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_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)) if (sdio_match_device(func, sdrv))
return 1; return 1;
@ -129,7 +129,7 @@ sdio_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
"SDIO_CLASS=%02X", func->class)) "SDIO_CLASS=%02X", func->class))
return -ENOMEM; return -ENOMEM;
if (add_uevent_var(env, if (add_uevent_var(env,
"SDIO_ID=%04X:%04X", func->vendor, func->device)) "SDIO_ID=%04X:%04X", func->vendor, func->device))
return -ENOMEM; return -ENOMEM;

2
drivers/most/core.c
View File

@ -491,7 +491,7 @@ static int print_links(struct device *dev, void *data)
return 0; 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")) if (!strcmp(dev_name(dev), "most"))
return 0; return 0;

4
drivers/net/phy/mdio_bus.c
View File

@ -1375,9 +1375,9 @@ EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed);
* require calling the devices own match function, since different classes * require calling the devices own match function, since different classes
* of MDIO devices have different match criteria. * 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); struct mdio_device *mdio = to_mdio_device(dev);
/* Both the driver and device must type-match */ /* Both the driver and device must type-match */

4
drivers/net/phy/mdio_device.c
View File

@ -35,10 +35,10 @@ static void mdio_device_release(struct device *dev)
kfree(to_mdio_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_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) if (mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)
return 0; return 0;

4
drivers/net/phy/phy_device.c
View File

@ -533,10 +533,10 @@ static int phy_scan_fixups(struct phy_device *phydev)
return 0; 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_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); const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
int i; int i;

2
drivers/ntb/ntb_transport.c
View File

@ -284,7 +284,7 @@ static void ntb_memcpy_rx(struct ntb_queue_entry *entry, void *offset);
static int ntb_transport_bus_match(struct device *dev, static int ntb_transport_bus_match(struct device *dev,
struct device_driver *drv) const struct device_driver *drv)
{ {
return !strncmp(dev_name(dev), drv->name, strlen(drv->name)); return !strncmp(dev_name(dev), drv->name, strlen(drv->name));
} }

6
drivers/nvdimm/bus.c
View File

@ -272,7 +272,7 @@ long nvdimm_clear_poison(struct device *dev, phys_addr_t phys,
} }
EXPORT_SYMBOL_GPL(nvdimm_clear_poison); EXPORT_SYMBOL_GPL(nvdimm_clear_poison);
static int nvdimm_bus_match(struct device *dev, struct device_driver *drv); static int nvdimm_bus_match(struct device *dev, const struct device_driver *drv);
static const struct bus_type nvdimm_bus_type = { static const struct bus_type nvdimm_bus_type = {
.name = "nd", .name = "nd",
@ -468,9 +468,9 @@ static struct nd_device_driver nd_bus_driver = {
}, },
}; };
static int nvdimm_bus_match(struct device *dev, struct device_driver *drv) static int nvdimm_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct nd_device_driver *nd_drv = to_nd_device_driver(drv); const struct nd_device_driver *nd_drv = to_nd_device_driver(drv);
if (is_nvdimm_bus(dev) && nd_drv == &nd_bus_driver) if (is_nvdimm_bus(dev) && nd_drv == &nd_bus_driver)
return true; return true;

4
drivers/nvmem/layouts.c
View File

@ -17,11 +17,11 @@
#include "internals.h" #include "internals.h"
#define to_nvmem_layout_driver(drv) \ #define to_nvmem_layout_driver(drv) \
(container_of((drv), struct nvmem_layout_driver, driver)) (container_of_const((drv), struct nvmem_layout_driver, driver))
#define to_nvmem_layout_device(_dev) \ #define to_nvmem_layout_device(_dev) \
container_of((_dev), struct nvmem_layout, dev) container_of((_dev), struct nvmem_layout, dev)
static int nvmem_layout_bus_match(struct device *dev, struct device_driver *drv) static int nvmem_layout_bus_match(struct device *dev, const struct device_driver *drv)
{ {
return of_driver_match_device(dev, drv); return of_driver_match_device(dev, drv);
} }

4
drivers/pci/endpoint/pci-epf-core.c
View File

@ -488,10 +488,10 @@ pci_epf_match_id(const struct pci_epf_device_id *id, const struct pci_epf *epf)
return NULL; return NULL;
} }
static int pci_epf_device_match(struct device *dev, struct device_driver *drv) static int pci_epf_device_match(struct device *dev, const struct device_driver *drv)
{ {
struct pci_epf *epf = to_pci_epf(dev); struct pci_epf *epf = to_pci_epf(dev);
struct pci_epf_driver *driver = to_pci_epf_driver(drv); const struct pci_epf_driver *driver = to_pci_epf_driver(drv);
if (driver->id_table) if (driver->id_table)
return !!pci_epf_match_id(driver->id_table, epf); return !!pci_epf_match_id(driver->id_table, epf);

8
drivers/pci/pci-driver.c
View File

@ -1503,7 +1503,7 @@ EXPORT_SYMBOL(pci_dev_driver);
* system is in its list of supported devices. Returns the matching * system is in its list of supported devices. Returns the matching
* pci_device_id structure or %NULL if there is no match. * pci_device_id structure or %NULL if there is no match.
*/ */
static int pci_bus_match(struct device *dev, struct device_driver *drv) static int pci_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct pci_dev *pci_dev = to_pci_dev(dev); struct pci_dev *pci_dev = to_pci_dev(dev);
struct pci_driver *pci_drv; struct pci_driver *pci_drv;
@ -1512,7 +1512,7 @@ static int pci_bus_match(struct device *dev, struct device_driver *drv)
if (!pci_dev->match_driver) if (!pci_dev->match_driver)
return 0; return 0;
pci_drv = to_pci_driver(drv); pci_drv = (struct pci_driver *)to_pci_driver(drv);
found_id = pci_match_device(pci_drv, pci_dev); found_id = pci_match_device(pci_drv, pci_dev);
if (found_id) if (found_id)
return 1; return 1;
@ -1688,10 +1688,10 @@ struct bus_type pci_bus_type = {
EXPORT_SYMBOL(pci_bus_type); EXPORT_SYMBOL(pci_bus_type);
#ifdef CONFIG_PCIEPORTBUS #ifdef CONFIG_PCIEPORTBUS
static int pcie_port_bus_match(struct device *dev, struct device_driver *drv) static int pcie_port_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct pcie_device *pciedev; struct pcie_device *pciedev;
struct pcie_port_service_driver *driver; const struct pcie_port_service_driver *driver;
if (drv->bus != &pcie_port_bus_type || dev->bus != &pcie_port_bus_type) if (drv->bus != &pcie_port_bus_type || dev->bus != &pcie_port_bus_type)
return 0; return 0;

2
drivers/pcmcia/ds.c
View File

@ -900,7 +900,7 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev,
} }
static int pcmcia_bus_match(struct device *dev, struct device_driver *drv) static int pcmcia_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct pcmcia_device *p_dev = to_pcmcia_dev(dev); struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
struct pcmcia_driver *p_drv = to_pcmcia_drv(drv); struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);

4
drivers/peci/core.c
View File

@ -173,10 +173,10 @@ peci_bus_match_device_id(const struct peci_device_id *id, struct peci_device *de
return NULL; return NULL;
} }
static int peci_bus_device_match(struct device *dev, struct device_driver *drv) static int peci_bus_device_match(struct device *dev, const struct device_driver *drv)
{ {
struct peci_device *device = to_peci_device(dev); struct peci_device *device = to_peci_device(dev);
struct peci_driver *peci_drv = to_peci_driver(drv); const struct peci_driver *peci_drv = to_peci_driver(drv);
if (dev->type != &peci_device_type) if (dev->type != &peci_device_type)
return 0; return 0;

5
drivers/peci/internal.h
View File

@ -98,10 +98,7 @@ struct peci_driver {
const struct peci_device_id *id_table; const struct peci_device_id *id_table;
}; };
static inline struct peci_driver *to_peci_driver(struct device_driver *d) #define to_peci_driver(__drv) container_of_const(__drv, struct peci_driver, driver)
{
return container_of(d, struct peci_driver, driver);
}
int __peci_driver_register(struct peci_driver *driver, struct module *owner, int __peci_driver_register(struct peci_driver *driver, struct module *owner,
const char *mod_name); const char *mod_name);

4
drivers/platform/surface/aggregator/bus.c
View File

@ -306,9 +306,9 @@ const void *ssam_device_get_match_data(const struct ssam_device *dev)
} }
EXPORT_SYMBOL_GPL(ssam_device_get_match_data); EXPORT_SYMBOL_GPL(ssam_device_get_match_data);
static int ssam_bus_match(struct device *dev, struct device_driver *drv) static int ssam_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct ssam_device_driver *sdrv = to_ssam_device_driver(drv); const struct ssam_device_driver *sdrv = to_ssam_device_driver(drv);
struct ssam_device *sdev = to_ssam_device(dev); struct ssam_device *sdev = to_ssam_device(dev);
if (!is_ssam_device(dev)) if (!is_ssam_device(dev))

9
drivers/platform/x86/wmi.c
View File

@ -727,10 +727,7 @@ char *wmi_get_acpi_device_uid(const char *guid_string)
} }
EXPORT_SYMBOL_GPL(wmi_get_acpi_device_uid); EXPORT_SYMBOL_GPL(wmi_get_acpi_device_uid);
static inline struct wmi_driver *drv_to_wdrv(struct device_driver *drv) #define drv_to_wdrv(__drv) container_of_const(__drv, struct wmi_driver, driver)
{
return container_of(drv, struct wmi_driver, driver);
}
/* /*
* sysfs interface * sysfs interface
@ -848,9 +845,9 @@ static void wmi_dev_release(struct device *dev)
kfree(wblock); kfree(wblock);
} }
static int wmi_dev_match(struct device *dev, struct device_driver *driver) static int wmi_dev_match(struct device *dev, const struct device_driver *driver)
{ {
struct wmi_driver *wmi_driver = drv_to_wdrv(driver); const struct wmi_driver *wmi_driver = drv_to_wdrv(driver);
struct wmi_block *wblock = dev_to_wblock(dev); struct wmi_block *wblock = dev_to_wblock(dev);
const struct wmi_device_id *id = wmi_driver->id_table; const struct wmi_device_id *id = wmi_driver->id_table;

6
drivers/pnp/driver.c
View File

@ -41,7 +41,7 @@ int compare_pnp_id(struct pnp_id *pos, const char *id)
return 0; return 0;
} }
static const struct pnp_device_id *match_device(struct pnp_driver *drv, static const struct pnp_device_id *match_device(const struct pnp_driver *drv,
struct pnp_dev *dev) struct pnp_dev *dev)
{ {
const struct pnp_device_id *drv_id = drv->id_table; const struct pnp_device_id *drv_id = drv->id_table;
@ -150,10 +150,10 @@ static void pnp_device_shutdown(struct device *dev)
drv->shutdown(pnp_dev); drv->shutdown(pnp_dev);
} }
static int pnp_bus_match(struct device *dev, struct device_driver *drv) static int pnp_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct pnp_dev *pnp_dev = to_pnp_dev(dev); struct pnp_dev *pnp_dev = to_pnp_dev(dev);
struct pnp_driver *pnp_drv = to_pnp_driver(drv); const struct pnp_driver *pnp_drv = to_pnp_driver(drv);
if (match_device(pnp_drv, pnp_dev) == NULL) if (match_device(pnp_drv, pnp_dev) == NULL)
return 0; return 0;

4
drivers/rapidio/rio-driver.c
View File

@ -186,10 +186,10 @@ EXPORT_SYMBOL_GPL(rio_attach_device);
* there is a matching &struct rio_device_id or 0 if there is * there is a matching &struct rio_device_id or 0 if there is
* no match. * no match.
*/ */
static int rio_match_bus(struct device *dev, struct device_driver *drv) static int rio_match_bus(struct device *dev, const struct device_driver *drv)
{ {
struct rio_dev *rdev = to_rio_dev(dev); struct rio_dev *rdev = to_rio_dev(dev);
struct rio_driver *rdrv = to_rio_driver(drv); const struct rio_driver *rdrv = to_rio_driver(drv);
const struct rio_device_id *id = rdrv->id_table; const struct rio_device_id *id = rdrv->id_table;
const struct rio_device_id *found_id; const struct rio_device_id *found_id;

4
drivers/rpmsg/rpmsg_core.c
View File

@ -493,10 +493,10 @@ static inline int rpmsg_id_match(const struct rpmsg_device *rpdev,
} }
/* match rpmsg channel and rpmsg driver */ /* match rpmsg channel and rpmsg driver */
static int rpmsg_dev_match(struct device *dev, struct device_driver *drv) static int rpmsg_dev_match(struct device *dev, const struct device_driver *drv)
{ {
struct rpmsg_device *rpdev = to_rpmsg_device(dev); struct rpmsg_device *rpdev = to_rpmsg_device(dev);
struct rpmsg_driver *rpdrv = to_rpmsg_driver(drv); const struct rpmsg_driver *rpdrv = to_rpmsg_driver(drv);
const struct rpmsg_device_id *ids = rpdrv->id_table; const struct rpmsg_device_id *ids = rpdrv->id_table;
unsigned int i; unsigned int i;

2
drivers/rpmsg/rpmsg_internal.h
View File

@ -16,7 +16,7 @@
#include <linux/poll.h> #include <linux/poll.h>
#define to_rpmsg_device(d) container_of(d, struct rpmsg_device, dev) #define to_rpmsg_device(d) container_of(d, struct rpmsg_device, dev)
#define to_rpmsg_driver(d) container_of(d, struct rpmsg_driver, drv) #define to_rpmsg_driver(d) container_of_const(d, struct rpmsg_driver, drv)
extern const struct class rpmsg_class; extern const struct class rpmsg_class;

4
drivers/s390/cio/css.c
View File

@ -1354,10 +1354,10 @@ int sch_is_pseudo_sch(struct subchannel *sch)
return sch == to_css(sch->dev.parent)->pseudo_subchannel; return sch == to_css(sch->dev.parent)->pseudo_subchannel;
} }
static int css_bus_match(struct device *dev, struct device_driver *drv) static int css_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct subchannel *sch = to_subchannel(dev); struct subchannel *sch = to_subchannel(dev);
struct css_driver *driver = to_cssdriver(drv); const struct css_driver *driver = to_cssdriver(drv);
struct css_device_id *id; struct css_device_id *id;
/* When driver_override is set, only bind to the matching driver */ /* When driver_override is set, only bind to the matching driver */

2
drivers/s390/cio/css.h
View File

@ -103,7 +103,7 @@ struct css_driver {
int (*settle)(void); int (*settle)(void);
}; };
#define to_cssdriver(n) container_of(n, struct css_driver, drv) #define to_cssdriver(n) container_of_const(n, struct css_driver, drv)
extern int css_driver_register(struct css_driver *); extern int css_driver_register(struct css_driver *);
extern void css_driver_unregister(struct css_driver *); extern void css_driver_unregister(struct css_driver *);

4
drivers/s390/cio/device.c
View File

@ -58,10 +58,10 @@ static const struct bus_type ccw_bus_type;
* subsystem driver and one channel system per machine, but * subsystem driver and one channel system per machine, but
* we still use the abstraction. T.R. says it's a good idea. */ * we still use the abstraction. T.R. says it's a good idea. */
static int static int
ccw_bus_match (struct device * dev, struct device_driver * drv) ccw_bus_match (struct device * dev, const struct device_driver * drv)
{ {
struct ccw_device *cdev = to_ccwdev(dev); struct ccw_device *cdev = to_ccwdev(dev);
struct ccw_driver *cdrv = to_ccwdrv(drv); const struct ccw_driver *cdrv = to_ccwdrv(drv);
const struct ccw_device_id *ids = cdrv->ids, *found; const struct ccw_device_id *ids = cdrv->ids, *found;
if (!ids) if (!ids)

4
drivers/s390/crypto/ap_bus.c
View File

@ -552,9 +552,9 @@ static void ap_poll_thread_stop(void)
* *
* AP bus driver registration/unregistration. * AP bus driver registration/unregistration.
*/ */
static int ap_bus_match(struct device *dev, struct device_driver *drv) static int ap_bus_match(struct device *dev, const struct device_driver *drv)
{ {
struct ap_driver *ap_drv = to_ap_drv(drv); const struct ap_driver *ap_drv = to_ap_drv(drv);
struct ap_device_id *id; struct ap_device_id *id;
/* /*

2
drivers/s390/crypto/ap_bus.h
View File

@ -158,7 +158,7 @@ struct ap_driver {
struct ap_config_info *old_config_info); struct ap_config_info *old_config_info);
}; };
#define to_ap_drv(x) container_of((x), struct ap_driver, driver) #define to_ap_drv(x) container_of_const((x), struct ap_driver, driver)
int ap_driver_register(struct ap_driver *, struct module *, char *); int ap_driver_register(struct ap_driver *, struct module *, char *);
void ap_driver_unregister(struct ap_driver *); void ap_driver_unregister(struct ap_driver *);

2
drivers/scsi/fcoe/fcoe_sysfs.c
View File

@ -600,7 +600,7 @@ static const struct attribute_group *fcoe_fcf_attr_groups[] = {
static const struct bus_type fcoe_bus_type; static const struct bus_type fcoe_bus_type;
static int fcoe_bus_match(struct device *dev, static int fcoe_bus_match(struct device *dev,
struct device_driver *drv) const struct device_driver *drv)
{ {
if (dev->bus == &fcoe_bus_type) if (dev->bus == &fcoe_bus_type)
return 1; return 1;

6
drivers/scsi/scsi_sysfs.c
View File

@ -528,7 +528,7 @@ static struct class sdev_class = {
}; };
/* all probing is done in the individual ->probe routines */ /* all probing is done in the individual ->probe routines */
static int scsi_bus_match(struct device *dev, struct device_driver *gendrv) static int scsi_bus_match(struct device *dev, const struct device_driver *gendrv)
{ {
struct scsi_device *sdp; struct scsi_device *sdp;
@ -661,7 +661,7 @@ static int scsi_sdev_check_buf_bit(const char *buf)
return 1; return 1;
else if (buf[0] == '0') else if (buf[0] == '0')
return 0; return 0;
else else
return -EINVAL; return -EINVAL;
} else } else
return -EINVAL; return -EINVAL;
@ -886,7 +886,7 @@ store_queue_type_field(struct device *dev, struct device_attribute *attr,
if (!sdev->tagged_supported) if (!sdev->tagged_supported)
return -EINVAL; return -EINVAL;
sdev_printk(KERN_INFO, sdev, sdev_printk(KERN_INFO, sdev,
"ignoring write to deprecated queue_type attribute"); "ignoring write to deprecated queue_type attribute");
return count; return count;

2
drivers/scsi/scsi_transport_iscsi.c
View File

@ -1204,7 +1204,7 @@ static const struct device_type iscsi_flashnode_conn_dev_type = {
static const struct bus_type iscsi_flashnode_bus; static const struct bus_type iscsi_flashnode_bus;
int iscsi_flashnode_bus_match(struct device *dev, int iscsi_flashnode_bus_match(struct device *dev,
struct device_driver *drv) const struct device_driver *drv)
{ {
if (dev->bus == &iscsi_flashnode_bus) if (dev->bus == &iscsi_flashnode_bus)
return 1; return 1;

4
drivers/sh/maple/maple.c
View File

@ -747,9 +747,9 @@ static int maple_get_dma_buffer(void)
} }
static int maple_match_bus_driver(struct device *devptr, static int maple_match_bus_driver(struct device *devptr,
struct device_driver *drvptr) const struct device_driver *drvptr)
{ {
struct maple_driver *maple_drv = to_maple_driver(drvptr); const struct maple_driver *maple_drv = to_maple_driver(drvptr);
struct maple_device *maple_dev = to_maple_dev(devptr); struct maple_device *maple_dev = to_maple_dev(devptr);
/* Trap empty port case */ /* Trap empty port case */

2
drivers/siox/siox-core.c
View File

@ -503,7 +503,7 @@ static const struct device_type siox_device_type = {
.release = siox_device_release, .release = siox_device_release,
}; };
static int siox_match(struct device *dev, struct device_driver *drv) static int siox_match(struct device *dev, const struct device_driver *drv)
{ {
if (dev->type != &siox_device_type) if (dev->type != &siox_device_type)
return 0; return 0;

4
drivers/slimbus/core.c
View File

@ -30,10 +30,10 @@ static const struct slim_device_id *slim_match(const struct slim_device_id *id,
return NULL; return NULL;
} }
static int slim_device_match(struct device *dev, struct device_driver *drv) static int slim_device_match(struct device *dev, const struct device_driver *drv)
{ {
struct slim_device *sbdev = to_slim_device(dev); struct slim_device *sbdev = to_slim_device(dev);
struct slim_driver *sbdrv = to_slim_driver(drv); const struct slim_driver *sbdrv = to_slim_driver(drv);
/* Attempt an OF style match first */ /* Attempt an OF style match first */
if (of_driver_match_device(dev, drv)) if (of_driver_match_device(dev, drv))

4
drivers/soc/qcom/apr.c
View File

@ -338,10 +338,10 @@ static void apr_rxwq(struct work_struct *work)
} }
} }
static int apr_device_match(struct device *dev, struct device_driver *drv) static int apr_device_match(struct device *dev, const struct device_driver *drv)
{ {
struct apr_device *adev = to_apr_device(dev); struct apr_device *adev = to_apr_device(dev);
struct apr_driver *adrv = to_apr_driver(drv); const struct apr_driver *adrv = to_apr_driver(drv);
const struct apr_device_id *id = adrv->id_table; const struct apr_device_id *id = adrv->id_table;
/* Attempt an OF style match first */ /* Attempt an OF style match first */

6
drivers/soundwire/bus_type.c
View File

@ -19,7 +19,7 @@
* struct sdw_device_id. * struct sdw_device_id.
*/ */
static const struct sdw_device_id * static const struct sdw_device_id *
sdw_get_device_id(struct sdw_slave *slave, struct sdw_driver *drv) sdw_get_device_id(struct sdw_slave *slave, const struct sdw_driver *drv)
{ {
const struct sdw_device_id *id; const struct sdw_device_id *id;
@ -35,10 +35,10 @@ sdw_get_device_id(struct sdw_slave *slave, struct sdw_driver *drv)
return NULL; return NULL;
} }
static int sdw_bus_match(struct device *dev, struct device_driver *ddrv) static int sdw_bus_match(struct device *dev, const struct device_driver *ddrv)
{ {
struct sdw_slave *slave; struct sdw_slave *slave;
struct sdw_driver *drv; const struct sdw_driver *drv;
int ret = 0; int ret = 0;
if (is_sdw_slave(dev)) { if (is_sdw_slave(dev)) {

2
drivers/spi/spi.c
View File

@ -371,7 +371,7 @@ const void *spi_get_device_match_data(const struct spi_device *sdev)
} }
EXPORT_SYMBOL_GPL(spi_get_device_match_data); EXPORT_SYMBOL_GPL(spi_get_device_match_data);
static int spi_match_device(struct device *dev, struct device_driver *drv) static int spi_match_device(struct device *dev, const struct device_driver *drv)
{ {
const struct spi_device *spi = to_spi_device(dev); const struct spi_device *spi = to_spi_device(dev);
const struct spi_driver *sdrv = to_spi_driver(drv); const struct spi_driver *sdrv = to_spi_driver(drv);

2
drivers/spmi/spmi.c
View File

@ -43,7 +43,7 @@ static const struct device_type spmi_ctrl_type = {
.release = spmi_ctrl_release, .release = spmi_ctrl_release,
}; };
static int spmi_device_match(struct device *dev, struct device_driver *drv) static int spmi_device_match(struct device *dev, const struct device_driver *drv)
{ {
if (of_driver_match_device(dev, drv)) if (of_driver_match_device(dev, drv))
return 1; return 1;

Some files were not shown because too many files have changed in this diff Show More