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