blob: 58f1e75ba105ca9096f8fbf1d60b808e08087c03 [file] [log] [blame]
Russell Kingbbbf5082005-10-29 22:17:58 +01001/*
2 * platform_device.h - generic, centralized driver model
3 *
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
5 *
6 * This file is released under the GPLv2
7 *
8 * See Documentation/driver-model/ for more information.
9 */
10
11#ifndef _PLATFORM_DEVICE_H_
12#define _PLATFORM_DEVICE_H_
13
14#include <linux/device.h>
Eric Miao57fee4a2009-02-04 11:52:40 +080015#include <linux/mod_devicetable.h>
Russell Kingbbbf5082005-10-29 22:17:58 +010016
Jean Delvare689ae232012-07-27 22:14:59 +020017#define PLATFORM_DEVID_NONE (-1)
18#define PLATFORM_DEVID_AUTO (-2)
19
Samuel Ortize710d7d2011-04-08 00:43:01 +020020struct mfd_cell;
21
Russell Kingbbbf5082005-10-29 22:17:58 +010022struct platform_device {
Fabio Porcedda6ae07f22013-03-26 10:35:17 +010023 const char *name;
Jean Delvare1359555e2007-09-09 12:54:16 +020024 int id;
Jean Delvare689ae232012-07-27 22:14:59 +020025 bool id_auto;
Russell Kingbbbf5082005-10-29 22:17:58 +010026 struct device dev;
27 u32 num_resources;
Fabio Porcedda6ae07f22013-03-26 10:35:17 +010028 struct resource *resource;
Eric Miao57fee4a2009-02-04 11:52:40 +080029
Eric Miao3d03ba42010-01-01 15:43:28 +080030 const struct platform_device_id *id_entry;
Kim Phillips3d713e02014-06-02 19:42:58 -050031 char *driver_override; /* Driver name to force a match */
Magnus Dammd7aacad2009-07-08 13:21:31 +020032
Samuel Ortize710d7d2011-04-08 00:43:01 +020033 /* MFD cell pointer */
34 struct mfd_cell *mfd_cell;
35
Magnus Dammd7aacad2009-07-08 13:21:31 +020036 /* arch specific additions */
37 struct pdev_archdata archdata;
Russell Kingbbbf5082005-10-29 22:17:58 +010038};
39
Eric Miao57fee4a2009-02-04 11:52:40 +080040#define platform_get_device_id(pdev) ((pdev)->id_entry)
41
Russell Kingbbbf5082005-10-29 22:17:58 +010042#define to_platform_device(x) container_of((x), struct platform_device, dev)
43
44extern int platform_device_register(struct platform_device *);
45extern void platform_device_unregister(struct platform_device *);
46
47extern struct bus_type platform_bus_type;
48extern struct device platform_bus;
49
Kumar Galaa77ce812011-06-10 01:52:57 -050050extern void arch_setup_pdev_archdata(struct platform_device *);
Fabio Porcedda6ae07f22013-03-26 10:35:17 +010051extern struct resource *platform_get_resource(struct platform_device *,
52 unsigned int, unsigned int);
Russell Kingbbbf5082005-10-29 22:17:58 +010053extern int platform_get_irq(struct platform_device *, unsigned int);
Fabio Porcedda6ae07f22013-03-26 10:35:17 +010054extern struct resource *platform_get_resource_byname(struct platform_device *,
55 unsigned int,
56 const char *);
Linus Walleijc0afe7b2009-04-27 02:38:16 +020057extern int platform_get_irq_byname(struct platform_device *, const char *);
Russell Kingbbbf5082005-10-29 22:17:58 +010058extern int platform_add_devices(struct platform_device **, int);
59
Uwe Kleine-König01dcc602011-08-25 11:16:00 +020060struct platform_device_info {
61 struct device *parent;
Rafael J. Wysockice793482015-03-16 23:49:03 +010062 struct fwnode_handle *fwnode;
Uwe Kleine-König01dcc602011-08-25 11:16:00 +020063
64 const char *name;
65 int id;
66
67 const struct resource *res;
68 unsigned int num_res;
69
70 const void *data;
71 size_t size_data;
72 u64 dma_mask;
73};
74extern struct platform_device *platform_device_register_full(
Uwe Kleine-König5a3072b2011-12-08 22:53:29 +010075 const struct platform_device_info *pdevinfo);
Uwe Kleine-König01dcc602011-08-25 11:16:00 +020076
77/**
78 * platform_device_register_resndata - add a platform-level device with
79 * resources and platform-specific data
80 *
81 * @parent: parent device for the device we're adding
82 * @name: base name of the device we're adding
83 * @id: instance id
84 * @res: set of resources that needs to be allocated for the device
85 * @num: number of resources
86 * @data: platform specific data for this platform device
87 * @size: size of platform specific data
88 *
89 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
90 */
91static inline struct platform_device *platform_device_register_resndata(
Uwe Kleine-König44f28bd2010-06-21 16:11:44 +020092 struct device *parent, const char *name, int id,
93 const struct resource *res, unsigned int num,
Uwe Kleine-König01dcc602011-08-25 11:16:00 +020094 const void *data, size_t size) {
95
96 struct platform_device_info pdevinfo = {
97 .parent = parent,
98 .name = name,
99 .id = id,
100 .res = res,
101 .num_res = num,
102 .data = data,
103 .size_data = size,
104 .dma_mask = 0,
105 };
106
107 return platform_device_register_full(&pdevinfo);
108}
Uwe Kleine-König44f28bd2010-06-21 16:11:44 +0200109
110/**
111 * platform_device_register_simple - add a platform-level device and its resources
112 * @name: base name of the device we're adding
113 * @id: instance id
114 * @res: set of resources that needs to be allocated for the device
115 * @num: number of resources
116 *
117 * This function creates a simple platform device that requires minimal
118 * resource and memory management. Canned release function freeing memory
119 * allocated for the device allows drivers using such devices to be
120 * unloaded without waiting for the last reference to the device to be
121 * dropped.
122 *
123 * This interface is primarily intended for use with legacy drivers which
124 * probe hardware directly. Because such drivers create sysfs device nodes
125 * themselves, rather than letting system infrastructure handle such device
126 * enumeration tasks, they don't fully conform to the Linux driver model.
127 * In particular, when such drivers are built as modules, they can't be
128 * "hotplugged".
129 *
130 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
131 */
132static inline struct platform_device *platform_device_register_simple(
133 const char *name, int id,
134 const struct resource *res, unsigned int num)
135{
136 return platform_device_register_resndata(NULL, name, id,
137 res, num, NULL, 0);
138}
139
140/**
141 * platform_device_register_data - add a platform-level device with platform-specific data
142 * @parent: parent device for the device we're adding
143 * @name: base name of the device we're adding
144 * @id: instance id
145 * @data: platform specific data for this platform device
146 * @size: size of platform specific data
147 *
148 * This function creates a simple platform device that requires minimal
149 * resource and memory management. Canned release function freeing memory
150 * allocated for the device allows drivers using such devices to be
151 * unloaded without waiting for the last reference to the device to be
152 * dropped.
153 *
154 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
155 */
156static inline struct platform_device *platform_device_register_data(
157 struct device *parent, const char *name, int id,
158 const void *data, size_t size)
159{
160 return platform_device_register_resndata(parent, name, id,
161 NULL, 0, data, size);
162}
Russell Kingbbbf5082005-10-29 22:17:58 +0100163
Jean Delvare1359555e2007-09-09 12:54:16 +0200164extern struct platform_device *platform_device_alloc(const char *name, int id);
Geert Uytterhoeven0b7f1a72009-01-28 21:01:02 +0100165extern int platform_device_add_resources(struct platform_device *pdev,
166 const struct resource *res,
167 unsigned int num);
Fabio Porcedda6ae07f22013-03-26 10:35:17 +0100168extern int platform_device_add_data(struct platform_device *pdev,
169 const void *data, size_t size);
Russell King37c12e72005-11-05 21:19:33 +0000170extern int platform_device_add(struct platform_device *pdev);
Dmitry Torokhov93ce30612005-12-10 01:36:27 -0500171extern void platform_device_del(struct platform_device *pdev);
Russell King37c12e72005-11-05 21:19:33 +0000172extern void platform_device_put(struct platform_device *pdev);
173
Russell King00d3dcd2005-11-09 17:23:39 +0000174struct platform_driver {
175 int (*probe)(struct platform_device *);
176 int (*remove)(struct platform_device *);
177 void (*shutdown)(struct platform_device *);
178 int (*suspend)(struct platform_device *, pm_message_t state);
179 int (*resume)(struct platform_device *);
180 struct device_driver driver;
Uwe Kleine-König831fad22010-01-26 09:35:00 +0100181 const struct platform_device_id *id_table;
Johan Hovold3f9120b2013-09-23 16:27:26 +0200182 bool prevent_deferred_probe;
Russell King00d3dcd2005-11-09 17:23:39 +0000183};
184
Rob Herring10dbc5e2013-04-21 16:38:31 -0500185#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
186 driver))
187
Libo Chen94470572013-05-25 12:40:50 +0800188/*
189 * use a macro to avoid include chaining to get THIS_MODULE
190 */
191#define platform_driver_register(drv) \
192 __platform_driver_register(drv, THIS_MODULE)
193extern int __platform_driver_register(struct platform_driver *,
194 struct module *);
Russell King00d3dcd2005-11-09 17:23:39 +0000195extern void platform_driver_unregister(struct platform_driver *);
196
David Brownellc67334f2006-11-16 23:28:47 -0800197/* non-hotpluggable platform devices may use this so that probe() and
198 * its support may live in __init sections, conserving runtime memory.
199 */
Wolfram Sangc3b50dc2014-10-28 17:40:41 +0100200#define platform_driver_probe(drv, probe) \
201 __platform_driver_probe(drv, probe, THIS_MODULE)
202extern int __platform_driver_probe(struct platform_driver *driver,
203 int (*probe)(struct platform_device *), struct module *module);
David Brownellc67334f2006-11-16 23:28:47 -0800204
Marc Kleine-Budde71d64292011-02-16 23:23:27 +0100205static inline void *platform_get_drvdata(const struct platform_device *pdev)
206{
207 return dev_get_drvdata(&pdev->dev);
208}
209
Fabio Porcedda6ae07f22013-03-26 10:35:17 +0100210static inline void platform_set_drvdata(struct platform_device *pdev,
211 void *data)
Marc Kleine-Budde71d64292011-02-16 23:23:27 +0100212{
213 dev_set_drvdata(&pdev->dev, data);
214}
Russell King00d3dcd2005-11-09 17:23:39 +0000215
Grant Likely940ab882011-10-05 11:29:49 -0600216/* module_platform_driver() - Helper macro for drivers that don't do
217 * anything special in module init/exit. This eliminates a lot of
218 * boilerplate. Each module may only use this macro once, and
219 * calling it replaces module_init() and module_exit()
220 */
221#define module_platform_driver(__platform_driver) \
Lars-Peter Clausen907d0ed2011-11-16 10:13:35 +0100222 module_driver(__platform_driver, platform_driver_register, \
223 platform_driver_unregister)
Grant Likely940ab882011-10-05 11:29:49 -0600224
Fabio Porceddabab734f2013-01-09 12:15:26 +0100225/* module_platform_driver_probe() - Helper macro for drivers that don't do
226 * anything special in module init/exit. This eliminates a lot of
227 * boilerplate. Each module may only use this macro once, and
228 * calling it replaces module_init() and module_exit()
229 */
230#define module_platform_driver_probe(__platform_driver, __platform_probe) \
231static int __init __platform_driver##_init(void) \
232{ \
233 return platform_driver_probe(&(__platform_driver), \
234 __platform_probe); \
235} \
236module_init(__platform_driver##_init); \
237static void __exit __platform_driver##_exit(void) \
238{ \
239 platform_driver_unregister(&(__platform_driver)); \
240} \
241module_exit(__platform_driver##_exit);
242
Wolfram Sang291f6532014-10-28 17:40:42 +0100243#define platform_create_bundle(driver, probe, res, n_res, data, size) \
244 __platform_create_bundle(driver, probe, res, n_res, data, size, THIS_MODULE)
245extern struct platform_device *__platform_create_bundle(
Fabio Porcedda6ae07f22013-03-26 10:35:17 +0100246 struct platform_driver *driver, int (*probe)(struct platform_device *),
247 struct resource *res, unsigned int n_res,
Wolfram Sang291f6532014-10-28 17:40:42 +0100248 const void *data, size_t size, struct module *module);
Dmitry Torokhovecdf6ce2009-12-29 20:11:20 -0800249
Magnus Damm13977092009-03-30 14:37:25 -0700250/* early platform driver interface */
251struct early_platform_driver {
252 const char *class_str;
253 struct platform_driver *pdrv;
254 struct list_head list;
255 int requested_id;
Magnus Dammc60e0502009-11-27 17:38:51 +0900256 char *buffer;
257 int bufsize;
Magnus Damm13977092009-03-30 14:37:25 -0700258};
259
260#define EARLY_PLATFORM_ID_UNSET -2
261#define EARLY_PLATFORM_ID_ERROR -3
262
263extern int early_platform_driver_register(struct early_platform_driver *epdrv,
264 char *buf);
265extern void early_platform_add_devices(struct platform_device **devs, int num);
266
267static inline int is_early_platform_device(struct platform_device *pdev)
268{
269 return !pdev->dev.driver;
270}
271
272extern void early_platform_driver_register_all(char *class_str);
273extern int early_platform_driver_probe(char *class_str,
274 int nr_probe, int user_only);
275extern void early_platform_cleanup(void);
276
Magnus Dammc60e0502009-11-27 17:38:51 +0900277#define early_platform_init(class_string, platdrv) \
278 early_platform_init_buffer(class_string, platdrv, NULL, 0)
Magnus Damm13977092009-03-30 14:37:25 -0700279
280#ifndef MODULE
Magnus Dammc60e0502009-11-27 17:38:51 +0900281#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
Magnus Damm13977092009-03-30 14:37:25 -0700282static __initdata struct early_platform_driver early_driver = { \
283 .class_str = class_string, \
Magnus Dammc60e0502009-11-27 17:38:51 +0900284 .buffer = buf, \
285 .bufsize = bufsiz, \
286 .pdrv = platdrv, \
Magnus Damm13977092009-03-30 14:37:25 -0700287 .requested_id = EARLY_PLATFORM_ID_UNSET, \
288}; \
Magnus Dammc60e0502009-11-27 17:38:51 +0900289static int __init early_platform_driver_setup_func(char *buffer) \
Magnus Damm13977092009-03-30 14:37:25 -0700290{ \
Magnus Dammc60e0502009-11-27 17:38:51 +0900291 return early_platform_driver_register(&early_driver, buffer); \
Magnus Damm13977092009-03-30 14:37:25 -0700292} \
293early_param(class_string, early_platform_driver_setup_func)
294#else /* MODULE */
Magnus Dammc60e0502009-11-27 17:38:51 +0900295#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
296static inline char *early_platform_driver_setup_func(void) \
297{ \
298 return bufsiz ? buf : NULL; \
299}
Magnus Damm13977092009-03-30 14:37:25 -0700300#endif /* MODULE */
301
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200302#ifdef CONFIG_SUSPEND
303extern int platform_pm_suspend(struct device *dev);
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200304extern int platform_pm_resume(struct device *dev);
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200305#else
306#define platform_pm_suspend NULL
307#define platform_pm_resume NULL
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200308#endif
309
310#ifdef CONFIG_HIBERNATE_CALLBACKS
311extern int platform_pm_freeze(struct device *dev);
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200312extern int platform_pm_thaw(struct device *dev);
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200313extern int platform_pm_poweroff(struct device *dev);
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200314extern int platform_pm_restore(struct device *dev);
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200315#else
316#define platform_pm_freeze NULL
317#define platform_pm_thaw NULL
318#define platform_pm_poweroff NULL
319#define platform_pm_restore NULL
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200320#endif
321
322#ifdef CONFIG_PM_SLEEP
323#define USE_PLATFORM_PM_SLEEP_OPS \
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200324 .suspend = platform_pm_suspend, \
325 .resume = platform_pm_resume, \
326 .freeze = platform_pm_freeze, \
327 .thaw = platform_pm_thaw, \
328 .poweroff = platform_pm_poweroff, \
Rafael J. Wysocki9b39e732011-12-18 00:34:24 +0100329 .restore = platform_pm_restore,
Rafael J. Wysocki69c9dd12011-04-29 00:36:05 +0200330#else
331#define USE_PLATFORM_PM_SLEEP_OPS
332#endif
333
Russell Kingbbbf5082005-10-29 22:17:58 +0100334#endif /* _PLATFORM_DEVICE_H_ */