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