1 /* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <[email protected]> 5 * Copyright (c) 2004-2007 Greg Kroah-Hartman <[email protected]> 6 * 7 * This file is released under the GPLv2 8 * 9 * See Documentation/driver-model/ for more information. 10 */ 11 12 #ifndef _DEVICE_H_ 13 #define _DEVICE_H_ 14 15 #include <linux/ioport.h> 16 #include <linux/kobject.h> 17 #include <linux/klist.h> 18 #include <linux/list.h> 19 #include <linux/compiler.h> 20 #include <linux/types.h> 21 #include <linux/module.h> 22 #include <linux/pm.h> 23 #include <asm/semaphore.h> 24 #include <asm/atomic.h> 25 #include <asm/device.h> 26 27 #define DEVICE_NAME_SIZE 50 28 #define DEVICE_NAME_HALF __stringify(20) /* Less than half to accommodate slop */ 29 #define DEVICE_ID_SIZE 32 30 #define BUS_ID_SIZE KOBJ_NAME_LEN 31 32 33 struct device; 34 struct device_driver; 35 struct class; 36 struct class_device; 37 38 struct bus_type { 39 const char * name; 40 41 struct subsystem subsys; 42 struct kset drivers; 43 struct kset devices; 44 struct klist klist_devices; 45 struct klist klist_drivers; 46 47 struct blocking_notifier_head bus_notifier; 48 49 struct bus_attribute * bus_attrs; 50 struct device_attribute * dev_attrs; 51 struct driver_attribute * drv_attrs; 52 53 int (*match)(struct device * dev, struct device_driver * drv); 54 int (*uevent)(struct device *dev, char **envp, 55 int num_envp, char *buffer, int buffer_size); 56 int (*probe)(struct device * dev); 57 int (*remove)(struct device * dev); 58 void (*shutdown)(struct device * dev); 59 60 int (*suspend)(struct device * dev, pm_message_t state); 61 int (*suspend_late)(struct device * dev, pm_message_t state); 62 int (*resume_early)(struct device * dev); 63 int (*resume)(struct device * dev); 64 }; 65 66 extern int __must_check bus_register(struct bus_type * bus); 67 extern void bus_unregister(struct bus_type * bus); 68 69 extern int __must_check bus_rescan_devices(struct bus_type * bus); 70 71 /* iterator helpers for buses */ 72 73 int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data, 74 int (*fn)(struct device *, void *)); 75 struct device * bus_find_device(struct bus_type *bus, struct device *start, 76 void *data, int (*match)(struct device *, void *)); 77 78 int __must_check bus_for_each_drv(struct bus_type *bus, 79 struct device_driver *start, void *data, 80 int (*fn)(struct device_driver *, void *)); 81 82 /* 83 * Bus notifiers: Get notified of addition/removal of devices 84 * and binding/unbinding of drivers to devices. 85 * In the long run, it should be a replacement for the platform 86 * notify hooks. 87 */ 88 struct notifier_block; 89 90 extern int bus_register_notifier(struct bus_type *bus, 91 struct notifier_block *nb); 92 extern int bus_unregister_notifier(struct bus_type *bus, 93 struct notifier_block *nb); 94 95 /* All 4 notifers below get called with the target struct device * 96 * as an argument. Note that those functions are likely to be called 97 * with the device semaphore held in the core, so be careful. 98 */ 99 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 100 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */ 101 #define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */ 102 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be 103 unbound */ 104 105 /* sysfs interface for exporting bus attributes */ 106 107 struct bus_attribute { 108 struct attribute attr; 109 ssize_t (*show)(struct bus_type *, char * buf); 110 ssize_t (*store)(struct bus_type *, const char * buf, size_t count); 111 }; 112 113 #define BUS_ATTR(_name,_mode,_show,_store) \ 114 struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store) 115 116 extern int __must_check bus_create_file(struct bus_type *, 117 struct bus_attribute *); 118 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 119 120 struct device_driver { 121 const char * name; 122 struct bus_type * bus; 123 124 struct completion unloaded; 125 struct kobject kobj; 126 struct klist klist_devices; 127 struct klist_node knode_bus; 128 129 struct module * owner; 130 const char * mod_name; /* used for built-in modules */ 131 132 int (*probe) (struct device * dev); 133 int (*remove) (struct device * dev); 134 void (*shutdown) (struct device * dev); 135 int (*suspend) (struct device * dev, pm_message_t state); 136 int (*resume) (struct device * dev); 137 138 unsigned int multithread_probe:1; 139 }; 140 141 142 extern int __must_check driver_register(struct device_driver * drv); 143 extern void driver_unregister(struct device_driver * drv); 144 145 extern struct device_driver * get_driver(struct device_driver * drv); 146 extern void put_driver(struct device_driver * drv); 147 extern struct device_driver *driver_find(const char *name, struct bus_type *bus); 148 extern int driver_probe_done(void); 149 150 /* sysfs interface for exporting driver attributes */ 151 152 struct driver_attribute { 153 struct attribute attr; 154 ssize_t (*show)(struct device_driver *, char * buf); 155 ssize_t (*store)(struct device_driver *, const char * buf, size_t count); 156 }; 157 158 #define DRIVER_ATTR(_name,_mode,_show,_store) \ 159 struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store) 160 161 extern int __must_check driver_create_file(struct device_driver *, 162 struct driver_attribute *); 163 extern void driver_remove_file(struct device_driver *, struct driver_attribute *); 164 165 extern int __must_check driver_for_each_device(struct device_driver * drv, 166 struct device *start, void *data, 167 int (*fn)(struct device *, void *)); 168 struct device * driver_find_device(struct device_driver *drv, 169 struct device *start, void *data, 170 int (*match)(struct device *, void *)); 171 172 /* 173 * device classes 174 */ 175 struct class { 176 const char * name; 177 struct module * owner; 178 179 struct subsystem subsys; 180 struct list_head children; 181 struct list_head devices; 182 struct list_head interfaces; 183 struct semaphore sem; /* locks both the children and interfaces lists */ 184 185 struct kobject *virtual_dir; 186 187 struct class_attribute * class_attrs; 188 struct class_device_attribute * class_dev_attrs; 189 struct device_attribute * dev_attrs; 190 191 int (*uevent)(struct class_device *dev, char **envp, 192 int num_envp, char *buffer, int buffer_size); 193 int (*dev_uevent)(struct device *dev, char **envp, int num_envp, 194 char *buffer, int buffer_size); 195 196 void (*release)(struct class_device *dev); 197 void (*class_release)(struct class *class); 198 void (*dev_release)(struct device *dev); 199 200 int (*suspend)(struct device *, pm_message_t state); 201 int (*resume)(struct device *); 202 }; 203 204 extern int __must_check class_register(struct class *); 205 extern void class_unregister(struct class *); 206 207 208 struct class_attribute { 209 struct attribute attr; 210 ssize_t (*show)(struct class *, char * buf); 211 ssize_t (*store)(struct class *, const char * buf, size_t count); 212 }; 213 214 #define CLASS_ATTR(_name,_mode,_show,_store) \ 215 struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store) 216 217 extern int __must_check class_create_file(struct class *, 218 const struct class_attribute *); 219 extern void class_remove_file(struct class *, const struct class_attribute *); 220 221 struct class_device_attribute { 222 struct attribute attr; 223 ssize_t (*show)(struct class_device *, char * buf); 224 ssize_t (*store)(struct class_device *, const char * buf, size_t count); 225 }; 226 227 #define CLASS_DEVICE_ATTR(_name,_mode,_show,_store) \ 228 struct class_device_attribute class_device_attr_##_name = \ 229 __ATTR(_name,_mode,_show,_store) 230 231 extern int __must_check class_device_create_file(struct class_device *, 232 const struct class_device_attribute *); 233 234 /** 235 * struct class_device - class devices 236 * @class: pointer to the parent class for this class device. This is required. 237 * @devt: for internal use by the driver core only. 238 * @node: for internal use by the driver core only. 239 * @kobj: for internal use by the driver core only. 240 * @devt_attr: for internal use by the driver core only. 241 * @groups: optional additional groups to be created 242 * @dev: if set, a symlink to the struct device is created in the sysfs 243 * directory for this struct class device. 244 * @class_data: pointer to whatever you want to store here for this struct 245 * class_device. Use class_get_devdata() and class_set_devdata() to get and 246 * set this pointer. 247 * @parent: pointer to a struct class_device that is the parent of this struct 248 * class_device. If NULL, this class_device will show up at the root of the 249 * struct class in sysfs (which is probably what you want to have happen.) 250 * @release: pointer to a release function for this struct class_device. If 251 * set, this will be called instead of the class specific release function. 252 * Only use this if you want to override the default release function, like 253 * when you are nesting class_device structures. 254 * @uevent: pointer to a uevent function for this struct class_device. If 255 * set, this will be called instead of the class specific uevent function. 256 * Only use this if you want to override the default uevent function, like 257 * when you are nesting class_device structures. 258 */ 259 struct class_device { 260 struct list_head node; 261 262 struct kobject kobj; 263 struct class * class; /* required */ 264 dev_t devt; /* dev_t, creates the sysfs "dev" */ 265 struct class_device_attribute *devt_attr; 266 struct class_device_attribute uevent_attr; 267 struct device * dev; /* not necessary, but nice to have */ 268 void * class_data; /* class-specific data */ 269 struct class_device *parent; /* parent of this child device, if there is one */ 270 struct attribute_group ** groups; /* optional groups */ 271 272 void (*release)(struct class_device *dev); 273 int (*uevent)(struct class_device *dev, char **envp, 274 int num_envp, char *buffer, int buffer_size); 275 char class_id[BUS_ID_SIZE]; /* unique to this class */ 276 }; 277 278 static inline void * 279 class_get_devdata (struct class_device *dev) 280 { 281 return dev->class_data; 282 } 283 284 static inline void 285 class_set_devdata (struct class_device *dev, void *data) 286 { 287 dev->class_data = data; 288 } 289 290 291 extern int __must_check class_device_register(struct class_device *); 292 extern void class_device_unregister(struct class_device *); 293 extern void class_device_initialize(struct class_device *); 294 extern int __must_check class_device_add(struct class_device *); 295 extern void class_device_del(struct class_device *); 296 297 extern struct class_device * class_device_get(struct class_device *); 298 extern void class_device_put(struct class_device *); 299 300 extern void class_device_remove_file(struct class_device *, 301 const struct class_device_attribute *); 302 extern int __must_check class_device_create_bin_file(struct class_device *, 303 struct bin_attribute *); 304 extern void class_device_remove_bin_file(struct class_device *, 305 struct bin_attribute *); 306 307 struct class_interface { 308 struct list_head node; 309 struct class *class; 310 311 int (*add) (struct class_device *, struct class_interface *); 312 void (*remove) (struct class_device *, struct class_interface *); 313 int (*add_dev) (struct device *, struct class_interface *); 314 void (*remove_dev) (struct device *, struct class_interface *); 315 }; 316 317 extern int __must_check class_interface_register(struct class_interface *); 318 extern void class_interface_unregister(struct class_interface *); 319 320 extern struct class *class_create(struct module *owner, const char *name); 321 extern void class_destroy(struct class *cls); 322 extern struct class_device *class_device_create(struct class *cls, 323 struct class_device *parent, 324 dev_t devt, 325 struct device *device, 326 const char *fmt, ...) 327 __attribute__((format(printf,5,6))); 328 extern void class_device_destroy(struct class *cls, dev_t devt); 329 330 struct device_type { 331 struct device_attribute *attrs; 332 int (*uevent)(struct device *dev, char **envp, int num_envp, 333 char *buffer, int buffer_size); 334 void (*release)(struct device *dev); 335 }; 336 337 /* interface for exporting device attributes */ 338 struct device_attribute { 339 struct attribute attr; 340 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 341 char *buf); 342 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 343 const char *buf, size_t count); 344 }; 345 346 #define DEVICE_ATTR(_name,_mode,_show,_store) \ 347 struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store) 348 349 extern int __must_check device_create_file(struct device *device, 350 struct device_attribute * entry); 351 extern void device_remove_file(struct device * dev, struct device_attribute * attr); 352 extern int __must_check device_create_bin_file(struct device *dev, 353 struct bin_attribute *attr); 354 extern void device_remove_bin_file(struct device *dev, 355 struct bin_attribute *attr); 356 357 /* device resource management */ 358 typedef void (*dr_release_t)(struct device *dev, void *res); 359 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 360 361 #ifdef CONFIG_DEBUG_DEVRES 362 extern void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 363 const char *name); 364 #define devres_alloc(release, size, gfp) \ 365 __devres_alloc(release, size, gfp, #release) 366 #else 367 extern void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 368 #endif 369 extern void devres_free(void *res); 370 extern void devres_add(struct device *dev, void *res); 371 extern void * devres_find(struct device *dev, dr_release_t release, 372 dr_match_t match, void *match_data); 373 extern void * devres_get(struct device *dev, void *new_res, 374 dr_match_t match, void *match_data); 375 extern void * devres_remove(struct device *dev, dr_release_t release, 376 dr_match_t match, void *match_data); 377 extern int devres_destroy(struct device *dev, dr_release_t release, 378 dr_match_t match, void *match_data); 379 380 /* devres group */ 381 extern void * __must_check devres_open_group(struct device *dev, void *id, 382 gfp_t gfp); 383 extern void devres_close_group(struct device *dev, void *id); 384 extern void devres_remove_group(struct device *dev, void *id); 385 extern int devres_release_group(struct device *dev, void *id); 386 387 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */ 388 extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp); 389 extern void devm_kfree(struct device *dev, void *p); 390 391 struct device { 392 struct klist klist_children; 393 struct klist_node knode_parent; /* node in sibling list */ 394 struct klist_node knode_driver; 395 struct klist_node knode_bus; 396 struct device * parent; 397 398 struct kobject kobj; 399 char bus_id[BUS_ID_SIZE]; /* position on parent bus */ 400 struct device_type *type; 401 unsigned is_registered:1; 402 struct device_attribute uevent_attr; 403 struct device_attribute *devt_attr; 404 405 struct semaphore sem; /* semaphore to synchronize calls to 406 * its driver. 407 */ 408 409 struct bus_type * bus; /* type of bus device is on */ 410 struct device_driver *driver; /* which driver has allocated this 411 device */ 412 void *driver_data; /* data private to the driver */ 413 void *platform_data; /* Platform specific data, device 414 core doesn't touch it */ 415 struct dev_pm_info power; 416 417 #ifdef CONFIG_NUMA 418 int numa_node; /* NUMA node this device is close to */ 419 #endif 420 u64 *dma_mask; /* dma mask (if dma'able device) */ 421 u64 coherent_dma_mask;/* Like dma_mask, but for 422 alloc_coherent mappings as 423 not all hardware supports 424 64 bit addresses for consistent 425 allocations such descriptors. */ 426 427 struct list_head dma_pools; /* dma pools (if dma'ble) */ 428 429 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 430 override */ 431 /* arch specific additions */ 432 struct dev_archdata archdata; 433 434 spinlock_t devres_lock; 435 struct list_head devres_head; 436 437 /* class_device migration path */ 438 struct list_head node; 439 struct class *class; 440 dev_t devt; /* dev_t, creates the sysfs "dev" */ 441 struct attribute_group **groups; /* optional groups */ 442 int uevent_suppress; 443 444 void (*release)(struct device * dev); 445 }; 446 447 #ifdef CONFIG_NUMA 448 static inline int dev_to_node(struct device *dev) 449 { 450 return dev->numa_node; 451 } 452 static inline void set_dev_node(struct device *dev, int node) 453 { 454 dev->numa_node = node; 455 } 456 #else 457 static inline int dev_to_node(struct device *dev) 458 { 459 return -1; 460 } 461 static inline void set_dev_node(struct device *dev, int node) 462 { 463 } 464 #endif 465 466 static inline void * 467 dev_get_drvdata (struct device *dev) 468 { 469 return dev->driver_data; 470 } 471 472 static inline void 473 dev_set_drvdata (struct device *dev, void *data) 474 { 475 dev->driver_data = data; 476 } 477 478 static inline int device_is_registered(struct device *dev) 479 { 480 return dev->is_registered; 481 } 482 483 void driver_init(void); 484 485 /* 486 * High level routines for use by the bus drivers 487 */ 488 extern int __must_check device_register(struct device * dev); 489 extern void device_unregister(struct device * dev); 490 extern void device_initialize(struct device * dev); 491 extern int __must_check device_add(struct device * dev); 492 extern void device_del(struct device * dev); 493 extern int device_for_each_child(struct device *, void *, 494 int (*fn)(struct device *, void *)); 495 extern struct device *device_find_child(struct device *, void *data, 496 int (*match)(struct device *, void *)); 497 extern int device_rename(struct device *dev, char *new_name); 498 extern int device_move(struct device *dev, struct device *new_parent); 499 500 /* 501 * Manual binding of a device to driver. See drivers/base/bus.c 502 * for information on use. 503 */ 504 extern int __must_check device_bind_driver(struct device *dev); 505 extern void device_release_driver(struct device * dev); 506 extern int __must_check device_attach(struct device * dev); 507 extern int __must_check driver_attach(struct device_driver *drv); 508 extern int __must_check device_reprobe(struct device *dev); 509 510 /* 511 * Easy functions for dynamically creating devices on the fly 512 */ 513 extern struct device *device_create(struct class *cls, struct device *parent, 514 dev_t devt, const char *fmt, ...) 515 __attribute__((format(printf,4,5))); 516 extern void device_destroy(struct class *cls, dev_t devt); 517 518 /* 519 * Platform "fixup" functions - allow the platform to have their say 520 * about devices and actions that the general device layer doesn't 521 * know about. 522 */ 523 /* Notify platform of device discovery */ 524 extern int (*platform_notify)(struct device * dev); 525 526 extern int (*platform_notify_remove)(struct device * dev); 527 528 529 /** 530 * get_device - atomically increment the reference count for the device. 531 * 532 */ 533 extern struct device * get_device(struct device * dev); 534 extern void put_device(struct device * dev); 535 536 537 /* drivers/base/power/shutdown.c */ 538 extern void device_shutdown(void); 539 540 541 /* drivers/base/firmware.c */ 542 extern int __must_check firmware_register(struct subsystem *); 543 extern void firmware_unregister(struct subsystem *); 544 545 /* debugging and troubleshooting/diagnostic helpers. */ 546 extern const char *dev_driver_string(struct device *dev); 547 #define dev_printk(level, dev, format, arg...) \ 548 printk(level "%s %s: " format , dev_driver_string(dev) , (dev)->bus_id , ## arg) 549 550 #ifdef DEBUG 551 #define dev_dbg(dev, format, arg...) \ 552 dev_printk(KERN_DEBUG , dev , format , ## arg) 553 #else 554 #define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0) 555 #endif 556 557 #define dev_err(dev, format, arg...) \ 558 dev_printk(KERN_ERR , dev , format , ## arg) 559 #define dev_info(dev, format, arg...) \ 560 dev_printk(KERN_INFO , dev , format , ## arg) 561 #define dev_warn(dev, format, arg...) \ 562 dev_printk(KERN_WARNING , dev , format , ## arg) 563 #define dev_notice(dev, format, arg...) \ 564 dev_printk(KERN_NOTICE , dev , format , ## arg) 565 566 /* Create alias, so I can be autoloaded. */ 567 #define MODULE_ALIAS_CHARDEV(major,minor) \ 568 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 569 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 570 MODULE_ALIAS("char-major-" __stringify(major) "-*") 571 #endif /* _DEVICE_H_ */ 572