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