~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/platform_device.h

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  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>
 15 #include <linux/mod_devicetable.h>
 16 
 17 struct mfd_cell;
 18 
 19 struct platform_device {
 20         const char      * name;
 21         int             id;
 22         struct device   dev;
 23         u32             num_resources;
 24         struct resource * resource;
 25 
 26         const struct platform_device_id *id_entry;
 27 
 28         /* MFD cell pointer */
 29         struct mfd_cell *mfd_cell;
 30 
 31         /* arch specific additions */
 32         struct pdev_archdata    archdata;
 33 };
 34 
 35 #define platform_get_device_id(pdev)    ((pdev)->id_entry)
 36 
 37 #define to_platform_device(x) container_of((x), struct platform_device, dev)
 38 
 39 extern int platform_device_register(struct platform_device *);
 40 extern void platform_device_unregister(struct platform_device *);
 41 
 42 extern struct bus_type platform_bus_type;
 43 extern struct device platform_bus;
 44 
 45 extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
 46 extern int platform_get_irq(struct platform_device *, unsigned int);
 47 extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
 48 extern int platform_get_irq_byname(struct platform_device *, const char *);
 49 extern int platform_add_devices(struct platform_device **, int);
 50 
 51 extern struct platform_device *platform_device_register_resndata(
 52                 struct device *parent, const char *name, int id,
 53                 const struct resource *res, unsigned int num,
 54                 const void *data, size_t size);
 55 
 56 /**
 57  * platform_device_register_simple - add a platform-level device and its resources
 58  * @name: base name of the device we're adding
 59  * @id: instance id
 60  * @res: set of resources that needs to be allocated for the device
 61  * @num: number of resources
 62  *
 63  * This function creates a simple platform device that requires minimal
 64  * resource and memory management. Canned release function freeing memory
 65  * allocated for the device allows drivers using such devices to be
 66  * unloaded without waiting for the last reference to the device to be
 67  * dropped.
 68  *
 69  * This interface is primarily intended for use with legacy drivers which
 70  * probe hardware directly.  Because such drivers create sysfs device nodes
 71  * themselves, rather than letting system infrastructure handle such device
 72  * enumeration tasks, they don't fully conform to the Linux driver model.
 73  * In particular, when such drivers are built as modules, they can't be
 74  * "hotplugged".
 75  *
 76  * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
 77  */
 78 static inline struct platform_device *platform_device_register_simple(
 79                 const char *name, int id,
 80                 const struct resource *res, unsigned int num)
 81 {
 82         return platform_device_register_resndata(NULL, name, id,
 83                         res, num, NULL, 0);
 84 }
 85 
 86 /**
 87  * platform_device_register_data - add a platform-level device with platform-specific data
 88  * @parent: parent device for the device we're adding
 89  * @name: base name of the device we're adding
 90  * @id: instance id
 91  * @data: platform specific data for this platform device
 92  * @size: size of platform specific data
 93  *
 94  * This function creates a simple platform device that requires minimal
 95  * resource and memory management. Canned release function freeing memory
 96  * allocated for the device allows drivers using such devices to be
 97  * unloaded without waiting for the last reference to the device to be
 98  * dropped.
 99  *
100  * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
101  */
102 static inline struct platform_device *platform_device_register_data(
103                 struct device *parent, const char *name, int id,
104                 const void *data, size_t size)
105 {
106         return platform_device_register_resndata(parent, name, id,
107                         NULL, 0, data, size);
108 }
109 
110 extern struct platform_device *platform_device_alloc(const char *name, int id);
111 extern int platform_device_add_resources(struct platform_device *pdev,
112                                          const struct resource *res,
113                                          unsigned int num);
114 extern int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size);
115 extern int platform_device_add(struct platform_device *pdev);
116 extern void platform_device_del(struct platform_device *pdev);
117 extern void platform_device_put(struct platform_device *pdev);
118 
119 struct platform_driver {
120         int (*probe)(struct platform_device *);
121         int (*remove)(struct platform_device *);
122         void (*shutdown)(struct platform_device *);
123         int (*suspend)(struct platform_device *, pm_message_t state);
124         int (*resume)(struct platform_device *);
125         struct device_driver driver;
126         const struct platform_device_id *id_table;
127 };
128 
129 extern int platform_driver_register(struct platform_driver *);
130 extern void platform_driver_unregister(struct platform_driver *);
131 
132 /* non-hotpluggable platform devices may use this so that probe() and
133  * its support may live in __init sections, conserving runtime memory.
134  */
135 extern int platform_driver_probe(struct platform_driver *driver,
136                 int (*probe)(struct platform_device *));
137 
138 static inline void *platform_get_drvdata(const struct platform_device *pdev)
139 {
140         return dev_get_drvdata(&pdev->dev);
141 }
142 
143 static inline void platform_set_drvdata(struct platform_device *pdev, void *data)
144 {
145         dev_set_drvdata(&pdev->dev, data);
146 }
147 
148 extern struct platform_device *platform_create_bundle(struct platform_driver *driver,
149                                         int (*probe)(struct platform_device *),
150                                         struct resource *res, unsigned int n_res,
151                                         const void *data, size_t size);
152 
153 /* early platform driver interface */
154 struct early_platform_driver {
155         const char *class_str;
156         struct platform_driver *pdrv;
157         struct list_head list;
158         int requested_id;
159         char *buffer;
160         int bufsize;
161 };
162 
163 #define EARLY_PLATFORM_ID_UNSET -2
164 #define EARLY_PLATFORM_ID_ERROR -3
165 
166 extern int early_platform_driver_register(struct early_platform_driver *epdrv,
167                                           char *buf);
168 extern void early_platform_add_devices(struct platform_device **devs, int num);
169 
170 static inline int is_early_platform_device(struct platform_device *pdev)
171 {
172         return !pdev->dev.driver;
173 }
174 
175 extern void early_platform_driver_register_all(char *class_str);
176 extern int early_platform_driver_probe(char *class_str,
177                                        int nr_probe, int user_only);
178 extern void early_platform_cleanup(void);
179 
180 #define early_platform_init(class_string, platdrv)              \
181         early_platform_init_buffer(class_string, platdrv, NULL, 0)
182 
183 #ifndef MODULE
184 #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)  \
185 static __initdata struct early_platform_driver early_driver = {         \
186         .class_str = class_string,                                      \
187         .buffer = buf,                                                  \
188         .bufsize = bufsiz,                                              \
189         .pdrv = platdrv,                                                \
190         .requested_id = EARLY_PLATFORM_ID_UNSET,                        \
191 };                                                                      \
192 static int __init early_platform_driver_setup_func(char *buffer)        \
193 {                                                                       \
194         return early_platform_driver_register(&early_driver, buffer);   \
195 }                                                                       \
196 early_param(class_string, early_platform_driver_setup_func)
197 #else /* MODULE */
198 #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)  \
199 static inline char *early_platform_driver_setup_func(void)              \
200 {                                                                       \
201         return bufsiz ? buf : NULL;                                     \
202 }
203 #endif /* MODULE */
204 
205 #ifdef CONFIG_PM_SLEEP
206 extern int platform_pm_prepare(struct device *dev);
207 extern void platform_pm_complete(struct device *dev);
208 #else
209 #define platform_pm_prepare     NULL
210 #define platform_pm_complete    NULL
211 #endif
212 
213 #ifdef CONFIG_SUSPEND
214 extern int platform_pm_suspend(struct device *dev);
215 extern int platform_pm_suspend_noirq(struct device *dev);
216 extern int platform_pm_resume(struct device *dev);
217 extern int platform_pm_resume_noirq(struct device *dev);
218 #else
219 #define platform_pm_suspend             NULL
220 #define platform_pm_resume              NULL
221 #define platform_pm_suspend_noirq       NULL
222 #define platform_pm_resume_noirq        NULL
223 #endif
224 
225 #ifdef CONFIG_HIBERNATE_CALLBACKS
226 extern int platform_pm_freeze(struct device *dev);
227 extern int platform_pm_freeze_noirq(struct device *dev);
228 extern int platform_pm_thaw(struct device *dev);
229 extern int platform_pm_thaw_noirq(struct device *dev);
230 extern int platform_pm_poweroff(struct device *dev);
231 extern int platform_pm_poweroff_noirq(struct device *dev);
232 extern int platform_pm_restore(struct device *dev);
233 extern int platform_pm_restore_noirq(struct device *dev);
234 #else
235 #define platform_pm_freeze              NULL
236 #define platform_pm_thaw                NULL
237 #define platform_pm_poweroff            NULL
238 #define platform_pm_restore             NULL
239 #define platform_pm_freeze_noirq        NULL
240 #define platform_pm_thaw_noirq          NULL
241 #define platform_pm_poweroff_noirq      NULL
242 #define platform_pm_restore_noirq       NULL
243 #endif
244 
245 #ifdef CONFIG_PM_SLEEP
246 #define USE_PLATFORM_PM_SLEEP_OPS \
247         .prepare = platform_pm_prepare, \
248         .complete = platform_pm_complete, \
249         .suspend = platform_pm_suspend, \
250         .resume = platform_pm_resume, \
251         .freeze = platform_pm_freeze, \
252         .thaw = platform_pm_thaw, \
253         .poweroff = platform_pm_poweroff, \
254         .restore = platform_pm_restore, \
255         .suspend_noirq = platform_pm_suspend_noirq, \
256         .resume_noirq = platform_pm_resume_noirq, \
257         .freeze_noirq = platform_pm_freeze_noirq, \
258         .thaw_noirq = platform_pm_thaw_noirq, \
259         .poweroff_noirq = platform_pm_poweroff_noirq, \
260         .restore_noirq = platform_pm_restore_noirq,
261 #else
262 #define USE_PLATFORM_PM_SLEEP_OPS
263 #endif
264 
265 #endif /* _PLATFORM_DEVICE_H_ */
266 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp