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