cregit-Linux how code gets into the kernel

Release 4.15 include/linux/platform_device.h

Directory: include/linux
/*
 * platform_device.h - generic, centralized driver model
 *
 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
 *
 * This file is released under the GPLv2
 *
 * See Documentation/driver-model/ for more information.
 */

#ifndef _PLATFORM_DEVICE_H_

#define _PLATFORM_DEVICE_H_

#include <linux/device.h>
#include <linux/mod_devicetable.h>


#define PLATFORM_DEVID_NONE	(-1)

#define PLATFORM_DEVID_AUTO	(-2)

struct mfd_cell;
struct property_entry;


struct platform_device {
	
const char	*name;
	
int		id;
	
bool		id_auto;
	
struct device	dev;
	
u32		num_resources;
	
struct resource	*resource;

	
const struct platform_device_id	*id_entry;
	
char *driver_override; /* Driver name to force a match */

	/* MFD cell pointer */
	
struct mfd_cell *mfd_cell;

	/* arch specific additions */
	
struct pdev_archdata	archdata;
};


#define platform_get_device_id(pdev)	((pdev)->id_entry)


#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;

extern void arch_setup_pdev_archdata(struct platform_device *);
extern struct resource *platform_get_resource(struct platform_device *,
					      unsigned int, unsigned int);
extern int platform_get_irq(struct platform_device *, unsigned int);
extern int platform_irq_count(struct platform_device *);
extern struct resource *platform_get_resource_byname(struct platform_device *,
						     unsigned int,
						     const char *);
extern int platform_get_irq_byname(struct platform_device *, const char *);
extern int platform_add_devices(struct platform_device **, int);


struct platform_device_info {
		
struct device *parent;
		
struct fwnode_handle *fwnode;

		
const char *name;
		
int id;

		
const struct resource *res;
		
unsigned int num_res;

		
const void *data;
		
size_t size_data;
		
u64 dma_mask;

		
struct property_entry *properties;
};
extern struct platform_device *platform_device_register_full(
		const struct platform_device_info *pdevinfo);

/**
 * 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( struct device *parent, const char *name, int id, const struct resource *res, unsigned int num, 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); }

Contributors

PersonTokensPropCommitsCommitProp
Uwe Kleine-König7782.80%233.33%
Russell King1313.98%116.67%
Stephen Rothwell11.08%116.67%
Jean Delvare11.08%116.67%
Geert Uytterhoeven11.08%116.67%
Total93100.00%6100.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); }

Contributors

PersonTokensPropCommitsCommitProp
Uwe Kleine-König45100.00%1100.00%
Total45100.00%1100.00%

/** * 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); }

Contributors

PersonTokensPropCommitsCommitProp
Uwe Kleine-König2756.25%133.33%
Dmitry Baryshkov1837.50%133.33%
Russell King36.25%133.33%
Total48100.00%3100.00%

extern struct platform_device *platform_device_alloc(const char *name, int id); extern int platform_device_add_resources(struct platform_device *pdev, const struct resource *res, unsigned int num); extern int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size); extern int platform_device_add_properties(struct platform_device *pdev, const struct property_entry *properties); extern int platform_device_add(struct platform_device *pdev); extern void platform_device_del(struct platform_device *pdev); extern void platform_device_put(struct platform_device *pdev); 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; const struct platform_device_id *id_table; bool prevent_deferred_probe; }; #define to_platform_driver(drv) (container_of((drv), struct platform_driver, \ driver)) /* * 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 *); extern void platform_driver_unregister(struct platform_driver *); /* non-hotpluggable platform devices may use this so that probe() and * its support may live in __init sections, conserving runtime memory. */ #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);
static inline void *platform_get_drvdata(const struct platform_device *pdev) { return dev_get_drvdata(&pdev->dev); }

Contributors

PersonTokensPropCommitsCommitProp
Marc Kleine-Budde2086.96%150.00%
Russell King313.04%150.00%
Total23100.00%2100.00%


static inline void platform_set_drvdata(struct platform_device *pdev, void *data) { dev_set_drvdata(&pdev->dev, data); }

Contributors

PersonTokensPropCommitsCommitProp
Marc Kleine-Budde2180.77%150.00%
Russell King519.23%150.00%
Total26100.00%2100.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) \ module_driver(__platform_driver, platform_driver_register, \ platform_driver_unregister) /* 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) /* 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); /* 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); \ #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( struct platform_driver *driver, int (*probe)(struct platform_device *), struct resource *res, unsigned int n_res, const void *data, size_t size, struct module *module); 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) /* early platform driver interface */ struct early_platform_driver { const char *class_str; struct platform_driver *pdrv; struct list_head list; int requested_id; char *buffer; int bufsize; }; #define EARLY_PLATFORM_ID_UNSET -2 #define EARLY_PLATFORM_ID_ERROR -3 extern int early_platform_driver_register(struct early_platform_driver *epdrv, char *buf); extern void early_platform_add_devices(struct platform_device **devs, int num);
static inline int is_early_platform_device(struct platform_device *pdev) { return !pdev->dev.driver; }

Contributors

PersonTokensPropCommitsCommitProp
Magnus Damm20100.00%1100.00%
Total20100.00%1100.00%

extern void early_platform_driver_register_all(char *class_str); extern int early_platform_driver_probe(char *class_str, int nr_probe, int user_only); extern void early_platform_cleanup(void); #define early_platform_init(class_string, platdrv) \ early_platform_init_buffer(class_string, platdrv, NULL, 0) #ifndef MODULE #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \ static __initdata struct early_platform_driver early_driver = { \ .class_str = class_string, \ .buffer = buf, \ .bufsize = bufsiz, \ .pdrv = platdrv, \ .requested_id = EARLY_PLATFORM_ID_UNSET, \ }; \ static int __init early_platform_driver_setup_func(char *buffer) \ { \ return early_platform_driver_register(&early_driver, buffer); \ } \ early_param(class_string, early_platform_driver_setup_func) #else /* MODULE */ #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \ static inline char *early_platform_driver_setup_func(void) \ { \ return bufsiz ? buf : NULL; \ } #endif /* MODULE */ #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, \ .restore = platform_pm_restore, #else #define USE_PLATFORM_PM_SLEEP_OPS #endif #endif /* _PLATFORM_DEVICE_H_ */

Overall Contributors

PersonTokensPropCommitsCommitProp
Russell King32127.46%36.67%
Uwe Kleine-König20117.19%48.89%
Magnus Damm16914.46%36.67%
Rafael J. Wysocki11810.09%48.89%
Dmitry Torokhov484.11%24.44%
Thierry Reding453.85%12.22%
Marc Kleine-Budde413.51%12.22%
Wolfram Sang282.40%24.44%
Dmitry Baryshkov221.88%12.22%
David Brownell211.80%12.22%
Eric Miao211.80%24.44%
Mika Westerberg181.54%12.22%
Libo Chen141.20%12.22%
Paul Gortmaker141.20%12.22%
Jean Delvare131.11%24.44%
Fabio Porcedda110.94%12.22%
Kumar Gala90.77%12.22%
Samuel Ortiz90.77%12.22%
Stephen Boyd90.77%12.22%
Grant C. Likely80.68%12.22%
Rob Herring70.60%12.22%
Heikki Krogerus50.43%12.22%
Kim Phillips50.43%12.22%
Johan Hovold30.26%12.22%
Linus Walleij20.17%12.22%
Geert Uytterhoeven20.17%12.22%
Scott Wood10.09%12.22%
Kevin Hilman10.09%12.22%
Stephen Rothwell10.09%12.22%
Lars-Peter Clausen10.09%12.22%
Jan Kiszka10.09%12.22%
Total1169100.00%45100.00%
Directory: include/linux
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.