2019-06-01 16:08:42 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2005-10-30 05:17:58 +08:00
|
|
|
/*
|
|
|
|
|
* platform_device.h - generic, centralized driver model
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
|
|
|
|
|
*
|
2019-06-18 23:34:59 +08:00
|
|
|
* See Documentation/driver-api/driver-model/ for more information.
|
2005-10-30 05:17:58 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _PLATFORM_DEVICE_H_
|
|
|
|
|
#define _PLATFORM_DEVICE_H_
|
|
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
|
|
2012-07-28 04:14:59 +08:00
|
|
|
#define PLATFORM_DEVID_NONE (-1)
|
|
|
|
|
#define PLATFORM_DEVID_AUTO (-2)
|
|
|
|
|
|
2020-12-02 18:36:56 +08:00
|
|
|
struct irq_affinity;
|
2011-04-08 06:43:01 +08:00
|
|
|
struct mfd_cell;
|
2016-03-29 19:52:23 +08:00
|
|
|
struct property_entry;
|
2018-06-20 13:47:28 +08:00
|
|
|
struct platform_device_id;
|
2011-04-08 06:43:01 +08:00
|
|
|
|
2005-10-30 05:17:58 +08:00
|
|
|
struct platform_device {
|
2013-03-26 17:35:17 +08:00
|
|
|
const char *name;
|
2007-09-09 18:54:16 +08:00
|
|
|
int id;
|
2012-07-28 04:14:59 +08:00
|
|
|
bool id_auto;
|
2005-10-30 05:17:58 +08:00
|
|
|
struct device dev;
|
driver code: clarify and fix platform device DMA mask allocation
This does three inter-related things to clarify the usage of the
platform device dma_mask field. In the process, fix the bug introduced
by cdfee5623290 ("driver core: initialize a default DMA mask for
platform device") that caused Artem Tashkinov's laptop to not boot with
newer Fedora kernels.
This does:
- First off, rename the field to "platform_dma_mask" to make it
greppable.
We have way too many different random fields called "dma_mask" in
various data structures, where some of them are actual masks, and
some of them are just pointers to the mask. And the structures all
have pointers to each other, or embed each other inside themselves,
and "pdev" sometimes means "platform device" and sometimes it means
"PCI device".
So to make it clear in the code when you actually use this new field,
give it a unique name (it really should be something even more unique
like "platform_device_dma_mask", since it's per platform device, not
per platform, but that gets old really fast, and this is unique
enough in context).
To further clarify when the field gets used, initialize it when we
actually start using it with the default value.
- Then, use this field instead of the random one-off allocation in
platform_device_register_full() that is now unnecessary since we now
already have a perfectly fine allocation for it in the platform
device structure.
- The above then allows us to fix the actual bug, where the error path
of platform_device_register_full() would unconditionally free the
platform device DMA allocation with 'kfree()'.
That kfree() was dont regardless of whether the allocation had been
done earlier with the (now removed) kmalloc, or whether
setup_pdev_dma_masks() had already been used and the dma_mask pointer
pointed to the mask that was part of the platform device.
It seems most people never triggered the error path, or only triggered
it from a call chain that set an explicit pdevinfo->dma_mask value (and
thus caused the unnecessary allocation that was "cleaned up" in the
error path) before calling platform_device_register_full().
Robin Murphy points out that in Artem's case the wdat_wdt driver failed
in platform_device_add(), and that was the one that had called
platform_device_register_full() with pdevinfo.dma_mask = 0, and would
have caused that kfree() of pdev.dma_mask corrupting the heap.
A later unrelated kmalloc() then oopsed due to the heap corruption.
Fixes: cdfee5623290 ("driver core: initialize a default DMA mask for platform device")
Reported-bisected-and-tested-by: Artem S. Tashkinov <aros@gmx.com>
Reviewed-by: Robin Murphy <robin.murphy@arm.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-03-12 00:07:10 +08:00
|
|
|
u64 platform_dma_mask;
|
2020-04-22 18:09:54 +08:00
|
|
|
struct device_dma_parameters dma_parms;
|
2005-10-30 05:17:58 +08:00
|
|
|
u32 num_resources;
|
2013-03-26 17:35:17 +08:00
|
|
|
struct resource *resource;
|
2009-02-04 11:52:40 +08:00
|
|
|
|
2010-01-01 15:43:28 +08:00
|
|
|
const struct platform_device_id *id_entry;
|
2022-04-19 19:34:24 +08:00
|
|
|
/*
|
|
|
|
|
* Driver name to force a match. Do not set directly, because core
|
|
|
|
|
* frees it. Use driver_set_override() to set or clear it.
|
|
|
|
|
*/
|
|
|
|
|
const char *driver_override;
|
2009-07-08 19:21:31 +08:00
|
|
|
|
2011-04-08 06:43:01 +08:00
|
|
|
/* MFD cell pointer */
|
|
|
|
|
struct mfd_cell *mfd_cell;
|
|
|
|
|
|
2009-07-08 19:21:31 +08:00
|
|
|
/* arch specific additions */
|
|
|
|
|
struct pdev_archdata archdata;
|
2005-10-30 05:17:58 +08:00
|
|
|
};
|
|
|
|
|
|
2009-02-04 11:52:40 +08:00
|
|
|
#define platform_get_device_id(pdev) ((pdev)->id_entry)
|
|
|
|
|
|
2018-08-20 21:45:41 +08:00
|
|
|
#define dev_is_platform(dev) ((dev)->bus == &platform_bus_type)
|
2005-10-30 05:17:58 +08:00
|
|
|
#define to_platform_device(x) container_of((x), struct platform_device, dev)
|
|
|
|
|
|
|
|
|
|
extern int platform_device_register(struct platform_device *);
|
|
|
|
|
extern void platform_device_unregister(struct platform_device *);
|
|
|
|
|
|
|
|
|
|
extern struct bus_type platform_bus_type;
|
|
|
|
|
extern struct device platform_bus;
|
|
|
|
|
|
2013-03-26 17:35:17 +08:00
|
|
|
extern struct resource *platform_get_resource(struct platform_device *,
|
|
|
|
|
unsigned int, unsigned int);
|
2020-12-10 04:36:38 +08:00
|
|
|
extern struct resource *platform_get_mem_or_io(struct platform_device *,
|
|
|
|
|
unsigned int);
|
|
|
|
|
|
2019-07-24 06:18:38 +08:00
|
|
|
extern struct device *
|
|
|
|
|
platform_find_device_by_driver(struct device *start,
|
|
|
|
|
const struct device_driver *drv);
|
2019-02-20 19:12:39 +08:00
|
|
|
extern void __iomem *
|
2020-03-24 00:06:08 +08:00
|
|
|
devm_platform_get_and_ioremap_resource(struct platform_device *pdev,
|
|
|
|
|
unsigned int index, struct resource **res);
|
|
|
|
|
extern void __iomem *
|
2019-02-20 19:12:39 +08:00
|
|
|
devm_platform_ioremap_resource(struct platform_device *pdev,
|
|
|
|
|
unsigned int index);
|
2019-10-22 16:43:14 +08:00
|
|
|
extern void __iomem *
|
2019-10-22 16:43:16 +08:00
|
|
|
devm_platform_ioremap_resource_byname(struct platform_device *pdev,
|
|
|
|
|
const char *name);
|
2005-10-30 05:17:58 +08:00
|
|
|
extern int platform_get_irq(struct platform_device *, unsigned int);
|
2019-08-28 16:34:10 +08:00
|
|
|
extern int platform_get_irq_optional(struct platform_device *, unsigned int);
|
2016-01-07 09:12:47 +08:00
|
|
|
extern int platform_irq_count(struct platform_device *);
|
2020-12-02 18:36:56 +08:00
|
|
|
extern int devm_platform_get_irqs_affinity(struct platform_device *dev,
|
|
|
|
|
struct irq_affinity *affd,
|
|
|
|
|
unsigned int minvec,
|
|
|
|
|
unsigned int maxvec,
|
|
|
|
|
int **irqs);
|
2013-03-26 17:35:17 +08:00
|
|
|
extern struct resource *platform_get_resource_byname(struct platform_device *,
|
|
|
|
|
unsigned int,
|
|
|
|
|
const char *);
|
2009-04-27 08:38:16 +08:00
|
|
|
extern int platform_get_irq_byname(struct platform_device *, const char *);
|
2019-10-06 05:04:47 +08:00
|
|
|
extern int platform_get_irq_byname_optional(struct platform_device *dev,
|
|
|
|
|
const char *name);
|
2005-10-30 05:17:58 +08:00
|
|
|
extern int platform_add_devices(struct platform_device **, int);
|
|
|
|
|
|
2011-08-25 17:16:00 +08:00
|
|
|
struct platform_device_info {
|
|
|
|
|
struct device *parent;
|
2015-03-17 06:49:03 +08:00
|
|
|
struct fwnode_handle *fwnode;
|
2019-02-21 19:29:35 +08:00
|
|
|
bool of_node_reused;
|
2011-08-25 17:16:00 +08:00
|
|
|
|
|
|
|
|
const char *name;
|
|
|
|
|
int id;
|
|
|
|
|
|
|
|
|
|
const struct resource *res;
|
|
|
|
|
unsigned int num_res;
|
|
|
|
|
|
|
|
|
|
const void *data;
|
|
|
|
|
size_t size_data;
|
|
|
|
|
u64 dma_mask;
|
2015-11-30 23:11:38 +08:00
|
|
|
|
2020-02-09 02:44:07 +08:00
|
|
|
const struct property_entry *properties;
|
2011-08-25 17:16:00 +08:00
|
|
|
};
|
|
|
|
|
extern struct platform_device *platform_device_register_full(
|
2011-12-09 05:53:29 +08:00
|
|
|
const struct platform_device_info *pdevinfo);
|
2011-08-25 17:16:00 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* platform_device_register_resndata - add a platform-level device with
|
|
|
|
|
* resources and platform-specific data
|
|
|
|
|
*
|
|
|
|
|
* @parent: parent device for the device we're adding
|
|
|
|
|
* @name: base name of the device we're adding
|
|
|
|
|
* @id: instance id
|
|
|
|
|
* @res: set of resources that needs to be allocated for the device
|
|
|
|
|
* @num: number of resources
|
|
|
|
|
* @data: platform specific data for this platform device
|
|
|
|
|
* @size: size of platform specific data
|
|
|
|
|
*
|
|
|
|
|
* Returns &struct platform_device pointer on success, or ERR_PTR() on error.
|
|
|
|
|
*/
|
|
|
|
|
static inline struct platform_device *platform_device_register_resndata(
|
2010-06-21 22:11:44 +08:00
|
|
|
struct device *parent, const char *name, int id,
|
|
|
|
|
const struct resource *res, unsigned int num,
|
2011-08-25 17:16:00 +08:00
|
|
|
const void *data, size_t size) {
|
|
|
|
|
|
|
|
|
|
struct platform_device_info pdevinfo = {
|
|
|
|
|
.parent = parent,
|
|
|
|
|
.name = name,
|
|
|
|
|
.id = id,
|
|
|
|
|
.res = res,
|
|
|
|
|
.num_res = num,
|
|
|
|
|
.data = data,
|
|
|
|
|
.size_data = size,
|
|
|
|
|
.dma_mask = 0,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return platform_device_register_full(&pdevinfo);
|
|
|
|
|
}
|
2010-06-21 22:11:44 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* platform_device_register_simple - add a platform-level device and its resources
|
|
|
|
|
* @name: base name of the device we're adding
|
|
|
|
|
* @id: instance id
|
|
|
|
|
* @res: set of resources that needs to be allocated for the device
|
|
|
|
|
* @num: number of resources
|
|
|
|
|
*
|
|
|
|
|
* This function creates a simple platform device that requires minimal
|
|
|
|
|
* resource and memory management. Canned release function freeing memory
|
|
|
|
|
* allocated for the device allows drivers using such devices to be
|
|
|
|
|
* unloaded without waiting for the last reference to the device to be
|
|
|
|
|
* dropped.
|
|
|
|
|
*
|
|
|
|
|
* This interface is primarily intended for use with legacy drivers which
|
|
|
|
|
* probe hardware directly. Because such drivers create sysfs device nodes
|
|
|
|
|
* themselves, rather than letting system infrastructure handle such device
|
|
|
|
|
* enumeration tasks, they don't fully conform to the Linux driver model.
|
|
|
|
|
* In particular, when such drivers are built as modules, they can't be
|
|
|
|
|
* "hotplugged".
|
|
|
|
|
*
|
|
|
|
|
* Returns &struct platform_device pointer on success, or ERR_PTR() on error.
|
|
|
|
|
*/
|
|
|
|
|
static inline struct platform_device *platform_device_register_simple(
|
|
|
|
|
const char *name, int id,
|
|
|
|
|
const struct resource *res, unsigned int num)
|
|
|
|
|
{
|
|
|
|
|
return platform_device_register_resndata(NULL, name, id,
|
|
|
|
|
res, num, NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* platform_device_register_data - add a platform-level device with platform-specific data
|
|
|
|
|
* @parent: parent device for the device we're adding
|
|
|
|
|
* @name: base name of the device we're adding
|
|
|
|
|
* @id: instance id
|
|
|
|
|
* @data: platform specific data for this platform device
|
|
|
|
|
* @size: size of platform specific data
|
|
|
|
|
*
|
|
|
|
|
* This function creates a simple platform device that requires minimal
|
|
|
|
|
* resource and memory management. Canned release function freeing memory
|
|
|
|
|
* allocated for the device allows drivers using such devices to be
|
|
|
|
|
* unloaded without waiting for the last reference to the device to be
|
|
|
|
|
* dropped.
|
|
|
|
|
*
|
|
|
|
|
* Returns &struct platform_device pointer on success, or ERR_PTR() on error.
|
|
|
|
|
*/
|
|
|
|
|
static inline struct platform_device *platform_device_register_data(
|
|
|
|
|
struct device *parent, const char *name, int id,
|
|
|
|
|
const void *data, size_t size)
|
|
|
|
|
{
|
|
|
|
|
return platform_device_register_resndata(parent, name, id,
|
|
|
|
|
NULL, 0, data, size);
|
|
|
|
|
}
|
2005-10-30 05:17:58 +08:00
|
|
|
|
2007-09-09 18:54:16 +08:00
|
|
|
extern struct platform_device *platform_device_alloc(const char *name, int id);
|
2009-01-29 04:01:02 +08:00
|
|
|
extern int platform_device_add_resources(struct platform_device *pdev,
|
|
|
|
|
const struct resource *res,
|
|
|
|
|
unsigned int num);
|
2013-03-26 17:35:17 +08:00
|
|
|
extern int platform_device_add_data(struct platform_device *pdev,
|
|
|
|
|
const void *data, size_t size);
|
2005-11-06 05:19:33 +08:00
|
|
|
extern int platform_device_add(struct platform_device *pdev);
|
2005-12-10 14:36:27 +08:00
|
|
|
extern void platform_device_del(struct platform_device *pdev);
|
2005-11-06 05:19:33 +08:00
|
|
|
extern void platform_device_put(struct platform_device *pdev);
|
|
|
|
|
|
2005-11-10 01:23:39 +08:00
|
|
|
struct platform_driver {
|
|
|
|
|
int (*probe)(struct platform_device *);
|
|
|
|
|
int (*remove)(struct platform_device *);
|
|
|
|
|
void (*shutdown)(struct platform_device *);
|
|
|
|
|
int (*suspend)(struct platform_device *, pm_message_t state);
|
|
|
|
|
int (*resume)(struct platform_device *);
|
|
|
|
|
struct device_driver driver;
|
2010-01-26 16:35:00 +08:00
|
|
|
const struct platform_device_id *id_table;
|
2013-09-23 22:27:26 +08:00
|
|
|
bool prevent_deferred_probe;
|
bus: platform,amba,fsl-mc,PCI: Add device DMA ownership management
The devices on platform/amba/fsl-mc/PCI buses could be bound to drivers
with the device DMA managed by kernel drivers or user-space applications.
Unfortunately, multiple devices may be placed in the same IOMMU group
because they cannot be isolated from each other. The DMA on these devices
must either be entirely under kernel control or userspace control, never
a mixture. Otherwise the driver integrity is not guaranteed because they
could access each other through the peer-to-peer accesses which by-pass
the IOMMU protection.
This checks and sets the default DMA mode during driver binding, and
cleanups during driver unbinding. In the default mode, the device DMA is
managed by the device driver which handles DMA operations through the
kernel DMA APIs (see Documentation/core-api/dma-api.rst).
For cases where the devices are assigned for userspace control through the
userspace driver framework(i.e. VFIO), the drivers(for example, vfio_pci/
vfio_platfrom etc.) may set a new flag (driver_managed_dma) to skip this
default setting in the assumption that the drivers know what they are
doing with the device DMA.
Calling iommu_device_use_default_domain() before {of,acpi}_dma_configure
is currently a problem. As things stand, the IOMMU driver ignored the
initial iommu_probe_device() call when the device was added, since at
that point it had no fwspec yet. In this situation,
{of,acpi}_iommu_configure() are retriggering iommu_probe_device() after
the IOMMU driver has seen the firmware data via .of_xlate to learn that
it actually responsible for the given device. As the result, before
that gets fixed, iommu_use_default_domain() goes at the end, and calls
arch_teardown_dma_ops() if it fails.
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Stuart Yoder <stuyoder@gmail.com>
Cc: Laurentiu Tudor <laurentiu.tudor@nxp.com>
Signed-off-by: Lu Baolu <baolu.lu@linux.intel.com>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Robin Murphy <robin.murphy@arm.com>
Tested-by: Eric Auger <eric.auger@redhat.com>
Link: https://lore.kernel.org/r/20220418005000.897664-5-baolu.lu@linux.intel.com
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2022-04-18 08:49:53 +08:00
|
|
|
/*
|
|
|
|
|
* For most device drivers, no need to care about this flag as long as
|
|
|
|
|
* all DMAs are handled through the kernel DMA API. For some special
|
|
|
|
|
* ones, for example VFIO drivers, they know how to manage the DMA
|
|
|
|
|
* themselves and set this flag so that the IOMMU layer will allow them
|
|
|
|
|
* to setup and manage their own I/O address space.
|
|
|
|
|
*/
|
|
|
|
|
bool driver_managed_dma;
|
2005-11-10 01:23:39 +08:00
|
|
|
};
|
|
|
|
|
|
2013-04-22 05:38:31 +08:00
|
|
|
#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
|
|
|
|
|
driver))
|
|
|
|
|
|
2013-05-25 12:40:50 +08:00
|
|
|
/*
|
|
|
|
|
* use a macro to avoid include chaining to get THIS_MODULE
|
|
|
|
|
*/
|
|
|
|
|
#define platform_driver_register(drv) \
|
|
|
|
|
__platform_driver_register(drv, THIS_MODULE)
|
|
|
|
|
extern int __platform_driver_register(struct platform_driver *,
|
|
|
|
|
struct module *);
|
2005-11-10 01:23:39 +08:00
|
|
|
extern void platform_driver_unregister(struct platform_driver *);
|
|
|
|
|
|
2006-11-17 15:28:47 +08:00
|
|
|
/* non-hotpluggable platform devices may use this so that probe() and
|
|
|
|
|
* its support may live in __init sections, conserving runtime memory.
|
|
|
|
|
*/
|
2014-10-29 00:40:41 +08:00
|
|
|
#define platform_driver_probe(drv, probe) \
|
|
|
|
|
__platform_driver_probe(drv, probe, THIS_MODULE)
|
|
|
|
|
extern int __platform_driver_probe(struct platform_driver *driver,
|
|
|
|
|
int (*probe)(struct platform_device *), struct module *module);
|
2006-11-17 15:28:47 +08:00
|
|
|
|
2011-02-17 06:23:27 +08:00
|
|
|
static inline void *platform_get_drvdata(const struct platform_device *pdev)
|
|
|
|
|
{
|
|
|
|
|
return dev_get_drvdata(&pdev->dev);
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-26 17:35:17 +08:00
|
|
|
static inline void platform_set_drvdata(struct platform_device *pdev,
|
|
|
|
|
void *data)
|
2011-02-17 06:23:27 +08:00
|
|
|
{
|
|
|
|
|
dev_set_drvdata(&pdev->dev, data);
|
|
|
|
|
}
|
2005-11-10 01:23:39 +08:00
|
|
|
|
2011-10-06 01:29:49 +08:00
|
|
|
/* module_platform_driver() - Helper macro for drivers that don't do
|
|
|
|
|
* anything special in module init/exit. This eliminates a lot of
|
|
|
|
|
* boilerplate. Each module may only use this macro once, and
|
|
|
|
|
* calling it replaces module_init() and module_exit()
|
|
|
|
|
*/
|
|
|
|
|
#define module_platform_driver(__platform_driver) \
|
2011-11-16 17:13:35 +08:00
|
|
|
module_driver(__platform_driver, platform_driver_register, \
|
|
|
|
|
platform_driver_unregister)
|
2011-10-06 01:29:49 +08:00
|
|
|
|
2015-05-02 08:10:57 +08:00
|
|
|
/* builtin_platform_driver() - Helper macro for builtin drivers that
|
|
|
|
|
* don't do anything special in driver init. This eliminates some
|
|
|
|
|
* boilerplate. Each driver may only use this macro once, and
|
|
|
|
|
* calling it replaces device_initcall(). Note this is meant to be
|
|
|
|
|
* a parallel of module_platform_driver() above, but w/o _exit stuff.
|
|
|
|
|
*/
|
|
|
|
|
#define builtin_platform_driver(__platform_driver) \
|
|
|
|
|
builtin_driver(__platform_driver, platform_driver_register)
|
|
|
|
|
|
2013-01-09 19:15:26 +08:00
|
|
|
/* module_platform_driver_probe() - Helper macro for drivers that don't do
|
|
|
|
|
* anything special in module init/exit. This eliminates a lot of
|
|
|
|
|
* boilerplate. Each module may only use this macro once, and
|
|
|
|
|
* calling it replaces module_init() and module_exit()
|
|
|
|
|
*/
|
|
|
|
|
#define module_platform_driver_probe(__platform_driver, __platform_probe) \
|
|
|
|
|
static int __init __platform_driver##_init(void) \
|
|
|
|
|
{ \
|
|
|
|
|
return platform_driver_probe(&(__platform_driver), \
|
|
|
|
|
__platform_probe); \
|
|
|
|
|
} \
|
|
|
|
|
module_init(__platform_driver##_init); \
|
|
|
|
|
static void __exit __platform_driver##_exit(void) \
|
|
|
|
|
{ \
|
|
|
|
|
platform_driver_unregister(&(__platform_driver)); \
|
|
|
|
|
} \
|
|
|
|
|
module_exit(__platform_driver##_exit);
|
|
|
|
|
|
2015-05-02 08:10:57 +08:00
|
|
|
/* builtin_platform_driver_probe() - Helper macro for drivers that don't do
|
|
|
|
|
* anything special in device init. This eliminates some boilerplate. Each
|
|
|
|
|
* driver may only use this macro once, and using it replaces device_initcall.
|
|
|
|
|
* This is meant to be a parallel of module_platform_driver_probe above, but
|
|
|
|
|
* without the __exit parts.
|
|
|
|
|
*/
|
|
|
|
|
#define builtin_platform_driver_probe(__platform_driver, __platform_probe) \
|
|
|
|
|
static int __init __platform_driver##_init(void) \
|
|
|
|
|
{ \
|
|
|
|
|
return platform_driver_probe(&(__platform_driver), \
|
|
|
|
|
__platform_probe); \
|
|
|
|
|
} \
|
|
|
|
|
device_initcall(__platform_driver##_init); \
|
|
|
|
|
|
2014-10-29 00:40:42 +08:00
|
|
|
#define platform_create_bundle(driver, probe, res, n_res, data, size) \
|
|
|
|
|
__platform_create_bundle(driver, probe, res, n_res, data, size, THIS_MODULE)
|
|
|
|
|
extern struct platform_device *__platform_create_bundle(
|
2013-03-26 17:35:17 +08:00
|
|
|
struct platform_driver *driver, int (*probe)(struct platform_device *),
|
|
|
|
|
struct resource *res, unsigned int n_res,
|
2014-10-29 00:40:42 +08:00
|
|
|
const void *data, size_t size, struct module *module);
|
2009-12-30 12:11:20 +08:00
|
|
|
|
2015-09-25 23:29:04 +08:00
|
|
|
int __platform_register_drivers(struct platform_driver * const *drivers,
|
|
|
|
|
unsigned int count, struct module *owner);
|
|
|
|
|
void platform_unregister_drivers(struct platform_driver * const *drivers,
|
|
|
|
|
unsigned int count);
|
|
|
|
|
|
|
|
|
|
#define platform_register_drivers(drivers, count) \
|
|
|
|
|
__platform_register_drivers(drivers, count, THIS_MODULE)
|
|
|
|
|
|
2011-04-29 06:36:05 +08:00
|
|
|
#ifdef CONFIG_SUSPEND
|
|
|
|
|
extern int platform_pm_suspend(struct device *dev);
|
|
|
|
|
extern int platform_pm_resume(struct device *dev);
|
|
|
|
|
#else
|
|
|
|
|
#define platform_pm_suspend NULL
|
|
|
|
|
#define platform_pm_resume NULL
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_HIBERNATE_CALLBACKS
|
|
|
|
|
extern int platform_pm_freeze(struct device *dev);
|
|
|
|
|
extern int platform_pm_thaw(struct device *dev);
|
|
|
|
|
extern int platform_pm_poweroff(struct device *dev);
|
|
|
|
|
extern int platform_pm_restore(struct device *dev);
|
|
|
|
|
#else
|
|
|
|
|
#define platform_pm_freeze NULL
|
|
|
|
|
#define platform_pm_thaw NULL
|
|
|
|
|
#define platform_pm_poweroff NULL
|
|
|
|
|
#define platform_pm_restore NULL
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
#define USE_PLATFORM_PM_SLEEP_OPS \
|
|
|
|
|
.suspend = platform_pm_suspend, \
|
|
|
|
|
.resume = platform_pm_resume, \
|
|
|
|
|
.freeze = platform_pm_freeze, \
|
|
|
|
|
.thaw = platform_pm_thaw, \
|
|
|
|
|
.poweroff = platform_pm_poweroff, \
|
2011-12-18 07:34:24 +08:00
|
|
|
.restore = platform_pm_restore,
|
2011-04-29 06:36:05 +08:00
|
|
|
#else
|
|
|
|
|
#define USE_PLATFORM_PM_SLEEP_OPS
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-10-03 17:29:12 +08:00
|
|
|
#ifndef CONFIG_SUPERH
|
|
|
|
|
/*
|
|
|
|
|
* REVISIT: This stub is needed for all non-SuperH users of early platform
|
|
|
|
|
* drivers. It should go away once we introduce the new platform_device-based
|
|
|
|
|
* early driver framework.
|
|
|
|
|
*/
|
2019-10-03 17:29:13 +08:00
|
|
|
static inline int is_sh_early_platform_device(struct platform_device *pdev)
|
2019-10-03 17:29:12 +08:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_SUPERH */
|
|
|
|
|
|
2021-03-31 23:05:25 +08:00
|
|
|
/* For now only SuperH uses it */
|
|
|
|
|
void early_platform_cleanup(void);
|
|
|
|
|
|
2005-10-30 05:17:58 +08:00
|
|
|
#endif /* _PLATFORM_DEVICE_H_ */
|