1 /* 2 * platform_device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <[email protected]> 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 16 #define PLATFORM_DEVID_NONE (-1) 17 #define PLATFORM_DEVID_AUTO (-2) 18 19 struct mfd_cell; 20 struct property_entry; 21 struct platform_device_id; 22 23 struct platform_device { 24 const char *name; 25 int id; 26 bool id_auto; 27 struct device dev; 28 u32 num_resources; 29 struct resource *resource; 30 31 const struct platform_device_id *id_entry; 32 char *driver_override; /* Driver name to force a match */ 33 34 /* MFD cell pointer */ 35 struct mfd_cell *mfd_cell; 36 37 /* arch specific additions */ 38 struct pdev_archdata archdata; 39 }; 40 41 #define platform_get_device_id(pdev) ((pdev)->id_entry) 42 43 #define dev_is_platform(dev) ((dev)->bus == &platform_bus_type) 44 #define to_platform_device(x) container_of((x), struct platform_device, dev) 45 46 extern int platform_device_register(struct platform_device *); 47 extern void platform_device_unregister(struct platform_device *); 48 49 extern struct bus_type platform_bus_type; 50 extern struct device platform_bus; 51 52 extern void arch_setup_pdev_archdata(struct platform_device *); 53 extern struct resource *platform_get_resource(struct platform_device *, 54 unsigned int, unsigned int); 55 extern int platform_get_irq(struct platform_device *, unsigned int); 56 extern int platform_irq_count(struct platform_device *); 57 extern struct resource *platform_get_resource_byname(struct platform_device *, 58 unsigned int, 59 const char *); 60 extern int platform_get_irq_byname(struct platform_device *, const char *); 61 extern int platform_add_devices(struct platform_device **, int); 62 63 struct platform_device_info { 64 struct device *parent; 65 struct fwnode_handle *fwnode; 66 bool of_node_reused; 67 68 const char *name; 69 int id; 70 71 const struct resource *res; 72 unsigned int num_res; 73 74 const void *data; 75 size_t size_data; 76 u64 dma_mask; 77 78 struct property_entry *properties; 79 }; 80 extern struct platform_device *platform_device_register_full( 81 const struct platform_device_info *pdevinfo); 82 83 /** 84 * platform_device_register_resndata - add a platform-level device with 85 * resources and platform-specific data 86 * 87 * @parent: parent device for the device we're adding 88 * @name: base name of the device we're adding 89 * @id: instance id 90 * @res: set of resources that needs to be allocated for the device 91 * @num: number of resources 92 * @data: platform specific data for this platform device 93 * @size: size of platform specific data 94 * 95 * Returns &struct platform_device pointer on success, or ERR_PTR() on error. 96 */ 97 static inline struct platform_device *platform_device_register_resndata( 98 struct device *parent, const char *name, int id, 99 const struct resource *res, unsigned int num, 100 const void *data, size_t size) { 101 102 struct platform_device_info pdevinfo = { 103 .parent = parent, 104 .name = name, 105 .id = id, 106 .res = res, 107 .num_res = num, 108 .data = data, 109 .size_data = size, 110 .dma_mask = 0, 111 }; 112 113 return platform_device_register_full(&pdevinfo); 114 } 115 116 /** 117 * platform_device_register_simple - add a platform-level device and its resources 118 * @name: base name of the device we're adding 119 * @id: instance id 120 * @res: set of resources that needs to be allocated for the device 121 * @num: number of resources 122 * 123 * This function creates a simple platform device that requires minimal 124 * resource and memory management. Canned release function freeing memory 125 * allocated for the device allows drivers using such devices to be 126 * unloaded without waiting for the last reference to the device to be 127 * dropped. 128 * 129 * This interface is primarily intended for use with legacy drivers which 130 * probe hardware directly. Because such drivers create sysfs device nodes 131 * themselves, rather than letting system infrastructure handle such device 132 * enumeration tasks, they don't fully conform to the Linux driver model. 133 * In particular, when such drivers are built as modules, they can't be 134 * "hotplugged". 135 * 136 * Returns &struct platform_device pointer on success, or ERR_PTR() on error. 137 */ 138 static inline struct platform_device *platform_device_register_simple( 139 const char *name, int id, 140 const struct resource *res, unsigned int num) 141 { 142 return platform_device_register_resndata(NULL, name, id, 143 res, num, NULL, 0); 144 } 145 146 /** 147 * platform_device_register_data - add a platform-level device with platform-specific data 148 * @parent: parent device for the device we're adding 149 * @name: base name of the device we're adding 150 * @id: instance id 151 * @data: platform specific data for this platform device 152 * @size: size of platform specific data 153 * 154 * This function creates a simple platform device that requires minimal 155 * resource and memory management. Canned release function freeing memory 156 * allocated for the device allows drivers using such devices to be 157 * unloaded without waiting for the last reference to the device to be 158 * dropped. 159 * 160 * Returns &struct platform_device pointer on success, or ERR_PTR() on error. 161 */ 162 static inline struct platform_device *platform_device_register_data( 163 struct device *parent, const char *name, int id, 164 const void *data, size_t size) 165 { 166 return platform_device_register_resndata(parent, name, id, 167 NULL, 0, data, size); 168 } 169 170 extern struct platform_device *platform_device_alloc(const char *name, int id); 171 extern int platform_device_add_resources(struct platform_device *pdev, 172 const struct resource *res, 173 unsigned int num); 174 extern int platform_device_add_data(struct platform_device *pdev, 175 const void *data, size_t size); 176 extern int platform_device_add_properties(struct platform_device *pdev, 177 const struct property_entry *properties); 178 extern int platform_device_add(struct platform_device *pdev); 179 extern void platform_device_del(struct platform_device *pdev); 180 extern void platform_device_put(struct platform_device *pdev); 181 182 struct platform_driver { 183 int (*probe)(struct platform_device *); 184 int (*remove)(struct platform_device *); 185 void (*shutdown)(struct platform_device *); 186 int (*suspend)(struct platform_device *, pm_message_t state); 187 int (*resume)(struct platform_device *); 188 struct device_driver driver; 189 const struct platform_device_id *id_table; 190 bool prevent_deferred_probe; 191 }; 192 193 #define to_platform_driver(drv) (container_of((drv), struct platform_driver, \ 194 driver)) 195 196 /* 197 * use a macro to avoid include chaining to get THIS_MODULE 198 */ 199 #define platform_driver_register(drv) \ 200 __platform_driver_register(drv, THIS_MODULE) 201 extern int __platform_driver_register(struct platform_driver *, 202 struct module *); 203 extern void platform_driver_unregister(struct platform_driver *); 204 205 /* non-hotpluggable platform devices may use this so that probe() and 206 * its support may live in __init sections, conserving runtime memory. 207 */ 208 #define platform_driver_probe(drv, probe) \ 209 __platform_driver_probe(drv, probe, THIS_MODULE) 210 extern int __platform_driver_probe(struct platform_driver *driver, 211 int (*probe)(struct platform_device *), struct module *module); 212 213 static inline void *platform_get_drvdata(const struct platform_device *pdev) 214 { 215 return dev_get_drvdata(&pdev->dev); 216 } 217 218 static inline void platform_set_drvdata(struct platform_device *pdev, 219 void *data) 220 { 221 dev_set_drvdata(&pdev->dev, data); 222 } 223 224 /* module_platform_driver() - Helper macro for drivers that don't do 225 * anything special in module init/exit. This eliminates a lot of 226 * boilerplate. Each module may only use this macro once, and 227 * calling it replaces module_init() and module_exit() 228 */ 229 #define module_platform_driver(__platform_driver) \ 230 module_driver(__platform_driver, platform_driver_register, \ 231 platform_driver_unregister) 232 233 /* builtin_platform_driver() - Helper macro for builtin drivers that 234 * don't do anything special in driver init. This eliminates some 235 * boilerplate. Each driver may only use this macro once, and 236 * calling it replaces device_initcall(). Note this is meant to be 237 * a parallel of module_platform_driver() above, but w/o _exit stuff. 238 */ 239 #define builtin_platform_driver(__platform_driver) \ 240 builtin_driver(__platform_driver, platform_driver_register) 241 242 /* module_platform_driver_probe() - Helper macro for drivers that don't do 243 * anything special in module init/exit. This eliminates a lot of 244 * boilerplate. Each module may only use this macro once, and 245 * calling it replaces module_init() and module_exit() 246 */ 247 #define module_platform_driver_probe(__platform_driver, __platform_probe) \ 248 static int __init __platform_driver##_init(void) \ 249 { \ 250 return platform_driver_probe(&(__platform_driver), \ 251 __platform_probe); \ 252 } \ 253 module_init(__platform_driver##_init); \ 254 static void __exit __platform_driver##_exit(void) \ 255 { \ 256 platform_driver_unregister(&(__platform_driver)); \ 257 } \ 258 module_exit(__platform_driver##_exit); 259 260 /* builtin_platform_driver_probe() - Helper macro for drivers that don't do 261 * anything special in device init. This eliminates some boilerplate. Each 262 * driver may only use this macro once, and using it replaces device_initcall. 263 * This is meant to be a parallel of module_platform_driver_probe above, but 264 * without the __exit parts. 265 */ 266 #define builtin_platform_driver_probe(__platform_driver, __platform_probe) \ 267 static int __init __platform_driver##_init(void) \ 268 { \ 269 return platform_driver_probe(&(__platform_driver), \ 270 __platform_probe); \ 271 } \ 272 device_initcall(__platform_driver##_init); \ 273 274 #define platform_create_bundle(driver, probe, res, n_res, data, size) \ 275 __platform_create_bundle(driver, probe, res, n_res, data, size, THIS_MODULE) 276 extern struct platform_device *__platform_create_bundle( 277 struct platform_driver *driver, int (*probe)(struct platform_device *), 278 struct resource *res, unsigned int n_res, 279 const void *data, size_t size, struct module *module); 280 281 int __platform_register_drivers(struct platform_driver * const *drivers, 282 unsigned int count, struct module *owner); 283 void platform_unregister_drivers(struct platform_driver * const *drivers, 284 unsigned int count); 285 286 #define platform_register_drivers(drivers, count) \ 287 __platform_register_drivers(drivers, count, THIS_MODULE) 288 289 /* early platform driver interface */ 290 struct early_platform_driver { 291 const char *class_str; 292 struct platform_driver *pdrv; 293 struct list_head list; 294 int requested_id; 295 char *buffer; 296 int bufsize; 297 }; 298 299 #define EARLY_PLATFORM_ID_UNSET -2 300 #define EARLY_PLATFORM_ID_ERROR -3 301 302 extern int early_platform_driver_register(struct early_platform_driver *epdrv, 303 char *buf); 304 extern void early_platform_add_devices(struct platform_device **devs, int num); 305 306 static inline int is_early_platform_device(struct platform_device *pdev) 307 { 308 return !pdev->dev.driver; 309 } 310 311 extern void early_platform_driver_register_all(char *class_str); 312 extern int early_platform_driver_probe(char *class_str, 313 int nr_probe, int user_only); 314 extern void early_platform_cleanup(void); 315 316 #define early_platform_init(class_string, platdrv) \ 317 early_platform_init_buffer(class_string, platdrv, NULL, 0) 318 319 #ifndef MODULE 320 #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \ 321 static __initdata struct early_platform_driver early_driver = { \ 322 .class_str = class_string, \ 323 .buffer = buf, \ 324 .bufsize = bufsiz, \ 325 .pdrv = platdrv, \ 326 .requested_id = EARLY_PLATFORM_ID_UNSET, \ 327 }; \ 328 static int __init early_platform_driver_setup_func(char *buffer) \ 329 { \ 330 return early_platform_driver_register(&early_driver, buffer); \ 331 } \ 332 early_param(class_string, early_platform_driver_setup_func) 333 #else /* MODULE */ 334 #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \ 335 static inline char *early_platform_driver_setup_func(void) \ 336 { \ 337 return bufsiz ? buf : NULL; \ 338 } 339 #endif /* MODULE */ 340 341 #ifdef CONFIG_SUSPEND 342 extern int platform_pm_suspend(struct device *dev); 343 extern int platform_pm_resume(struct device *dev); 344 #else 345 #define platform_pm_suspend NULL 346 #define platform_pm_resume NULL 347 #endif 348 349 #ifdef CONFIG_HIBERNATE_CALLBACKS 350 extern int platform_pm_freeze(struct device *dev); 351 extern int platform_pm_thaw(struct device *dev); 352 extern int platform_pm_poweroff(struct device *dev); 353 extern int platform_pm_restore(struct device *dev); 354 #else 355 #define platform_pm_freeze NULL 356 #define platform_pm_thaw NULL 357 #define platform_pm_poweroff NULL 358 #define platform_pm_restore NULL 359 #endif 360 361 extern int platform_dma_configure(struct device *dev); 362 363 #ifdef CONFIG_PM_SLEEP 364 #define USE_PLATFORM_PM_SLEEP_OPS \ 365 .suspend = platform_pm_suspend, \ 366 .resume = platform_pm_resume, \ 367 .freeze = platform_pm_freeze, \ 368 .thaw = platform_pm_thaw, \ 369 .poweroff = platform_pm_poweroff, \ 370 .restore = platform_pm_restore, 371 #else 372 #define USE_PLATFORM_PM_SLEEP_OPS 373 #endif 374 375 #endif /* _PLATFORM_DEVICE_H_ */ 376