1 /* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <[email protected]> 5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <[email protected]> 6 * Copyright (c) 2008-2009 Novell Inc. 7 * 8 * This file is released under the GPLv2 9 * 10 * See Documentation/driver-model/ for more information. 11 */ 12 13 #ifndef _DEVICE_H_ 14 #define _DEVICE_H_ 15 16 #include <linux/ioport.h> 17 #include <linux/kobject.h> 18 #include <linux/klist.h> 19 #include <linux/list.h> 20 #include <linux/lockdep.h> 21 #include <linux/compiler.h> 22 #include <linux/types.h> 23 #include <linux/module.h> 24 #include <linux/pm.h> 25 #include <asm/atomic.h> 26 #include <asm/device.h> 27 28 struct device; 29 struct device_private; 30 struct device_driver; 31 struct driver_private; 32 struct class; 33 struct subsys_private; 34 struct bus_type; 35 struct device_node; 36 37 struct bus_attribute { 38 struct attribute attr; 39 ssize_t (*show)(struct bus_type *bus, char *buf); 40 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); 41 }; 42 43 #define BUS_ATTR(_name, _mode, _show, _store) \ 44 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) 45 46 extern int __must_check bus_create_file(struct bus_type *, 47 struct bus_attribute *); 48 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 49 50 /** 51 * struct bus_type - The bus type of the device 52 * 53 * @name: The name of the bus. 54 * @bus_attrs: Default attributes of the bus. 55 * @dev_attrs: Default attributes of the devices on the bus. 56 * @drv_attrs: Default attributes of the device drivers on the bus. 57 * @match: Called, perhaps multiple times, whenever a new device or driver 58 * is added for this bus. It should return a nonzero value if the 59 * given device can be handled by the given driver. 60 * @uevent: Called when a device is added, removed, or a few other things 61 * that generate uevents to add the environment variables. 62 * @probe: Called when a new device or driver add to this bus, and callback 63 * the specific driver's probe to initial the matched device. 64 * @remove: Called when a device removed from this bus. 65 * @shutdown: Called at shut-down time to quiesce the device. 66 * @suspend: Called when a device on this bus wants to go to sleep mode. 67 * @resume: Called to bring a device on this bus out of sleep mode. 68 * @pm: Power management operations of this bus, callback the specific 69 * device driver's pm-ops. 70 * @p: The private data of the driver core, only the driver core can 71 * touch this. 72 * 73 * A bus is a channel between the processor and one or more devices. For the 74 * purposes of the device model, all devices are connected via a bus, even if 75 * it is an internal, virtual, "platform" bus. Buses can plug into each other. 76 * A USB controller is usually a PCI device, for example. The device model 77 * represents the actual connections between buses and the devices they control. 78 * A bus is represented by the bus_type structure. It contains the name, the 79 * default attributes, the bus' methods, PM operations, and the driver core's 80 * private data. 81 */ 82 struct bus_type { 83 const char *name; 84 struct bus_attribute *bus_attrs; 85 struct device_attribute *dev_attrs; 86 struct driver_attribute *drv_attrs; 87 88 int (*match)(struct device *dev, struct device_driver *drv); 89 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 90 int (*probe)(struct device *dev); 91 int (*remove)(struct device *dev); 92 void (*shutdown)(struct device *dev); 93 94 int (*suspend)(struct device *dev, pm_message_t state); 95 int (*resume)(struct device *dev); 96 97 const struct dev_pm_ops *pm; 98 99 struct subsys_private *p; 100 }; 101 102 extern int __must_check bus_register(struct bus_type *bus); 103 extern void bus_unregister(struct bus_type *bus); 104 105 extern int __must_check bus_rescan_devices(struct bus_type *bus); 106 107 /* iterator helpers for buses */ 108 109 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, 110 int (*fn)(struct device *dev, void *data)); 111 struct device *bus_find_device(struct bus_type *bus, struct device *start, 112 void *data, 113 int (*match)(struct device *dev, void *data)); 114 struct device *bus_find_device_by_name(struct bus_type *bus, 115 struct device *start, 116 const char *name); 117 118 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 119 void *data, int (*fn)(struct device_driver *, void *)); 120 121 void bus_sort_breadthfirst(struct bus_type *bus, 122 int (*compare)(const struct device *a, 123 const struct device *b)); 124 /* 125 * Bus notifiers: Get notified of addition/removal of devices 126 * and binding/unbinding of drivers to devices. 127 * In the long run, it should be a replacement for the platform 128 * notify hooks. 129 */ 130 struct notifier_block; 131 132 extern int bus_register_notifier(struct bus_type *bus, 133 struct notifier_block *nb); 134 extern int bus_unregister_notifier(struct bus_type *bus, 135 struct notifier_block *nb); 136 137 /* All 4 notifers below get called with the target struct device * 138 * as an argument. Note that those functions are likely to be called 139 * with the device lock held in the core, so be careful. 140 */ 141 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 142 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */ 143 #define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be 144 bound */ 145 #define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */ 146 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be 147 unbound */ 148 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound 149 from the device */ 150 151 extern struct kset *bus_get_kset(struct bus_type *bus); 152 extern struct klist *bus_get_device_klist(struct bus_type *bus); 153 154 /** 155 * struct device_driver - The basic device driver structure 156 * @name: Name of the device driver. 157 * @bus: The bus which the device of this driver belongs to. 158 * @owner: The module owner. 159 * @mod_name: Used for built-in modules. 160 * @suppress_bind_attrs: Disables bind/unbind via sysfs. 161 * @of_match_table: The open firmware table. 162 * @probe: Called to query the existence of a specific device, 163 * whether this driver can work with it, and bind the driver 164 * to a specific device. 165 * @remove: Called when the device is removed from the system to 166 * unbind a device from this driver. 167 * @shutdown: Called at shut-down time to quiesce the device. 168 * @suspend: Called to put the device to sleep mode. Usually to a 169 * low power state. 170 * @resume: Called to bring a device from sleep mode. 171 * @groups: Default attributes that get created by the driver core 172 * automatically. 173 * @pm: Power management operations of the device which matched 174 * this driver. 175 * @p: Driver core's private data, no one other than the driver 176 * core can touch this. 177 * 178 * The device driver-model tracks all of the drivers known to the system. 179 * The main reason for this tracking is to enable the driver core to match 180 * up drivers with new devices. Once drivers are known objects within the 181 * system, however, a number of other things become possible. Device drivers 182 * can export information and configuration variables that are independent 183 * of any specific device. 184 */ 185 struct device_driver { 186 const char *name; 187 struct bus_type *bus; 188 189 struct module *owner; 190 const char *mod_name; /* used for built-in modules */ 191 192 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 193 194 const struct of_device_id *of_match_table; 195 196 int (*probe) (struct device *dev); 197 int (*remove) (struct device *dev); 198 void (*shutdown) (struct device *dev); 199 int (*suspend) (struct device *dev, pm_message_t state); 200 int (*resume) (struct device *dev); 201 const struct attribute_group **groups; 202 203 const struct dev_pm_ops *pm; 204 205 struct driver_private *p; 206 }; 207 208 209 extern int __must_check driver_register(struct device_driver *drv); 210 extern void driver_unregister(struct device_driver *drv); 211 212 extern struct device_driver *get_driver(struct device_driver *drv); 213 extern void put_driver(struct device_driver *drv); 214 extern struct device_driver *driver_find(const char *name, 215 struct bus_type *bus); 216 extern int driver_probe_done(void); 217 extern void wait_for_device_probe(void); 218 219 220 /* sysfs interface for exporting driver attributes */ 221 222 struct driver_attribute { 223 struct attribute attr; 224 ssize_t (*show)(struct device_driver *driver, char *buf); 225 ssize_t (*store)(struct device_driver *driver, const char *buf, 226 size_t count); 227 }; 228 229 #define DRIVER_ATTR(_name, _mode, _show, _store) \ 230 struct driver_attribute driver_attr_##_name = \ 231 __ATTR(_name, _mode, _show, _store) 232 233 extern int __must_check driver_create_file(struct device_driver *driver, 234 const struct driver_attribute *attr); 235 extern void driver_remove_file(struct device_driver *driver, 236 const struct driver_attribute *attr); 237 238 extern int __must_check driver_add_kobj(struct device_driver *drv, 239 struct kobject *kobj, 240 const char *fmt, ...); 241 242 extern int __must_check driver_for_each_device(struct device_driver *drv, 243 struct device *start, 244 void *data, 245 int (*fn)(struct device *dev, 246 void *)); 247 struct device *driver_find_device(struct device_driver *drv, 248 struct device *start, void *data, 249 int (*match)(struct device *dev, void *data)); 250 251 /** 252 * struct class - device classes 253 * @name: Name of the class. 254 * @owner: The module owner. 255 * @class_attrs: Default attributes of this class. 256 * @dev_attrs: Default attributes of the devices belong to the class. 257 * @dev_bin_attrs: Default binary attributes of the devices belong to the class. 258 * @dev_kobj: The kobject that represents this class and links it into the hierarchy. 259 * @dev_uevent: Called when a device is added, removed from this class, or a 260 * few other things that generate uevents to add the environment 261 * variables. 262 * @devnode: Callback to provide the devtmpfs. 263 * @class_release: Called to release this class. 264 * @dev_release: Called to release the device. 265 * @suspend: Used to put the device to sleep mode, usually to a low power 266 * state. 267 * @resume: Used to bring the device from the sleep mode. 268 * @ns_type: Callbacks so sysfs can detemine namespaces. 269 * @namespace: Namespace of the device belongs to this class. 270 * @pm: The default device power management operations of this class. 271 * @p: The private data of the driver core, no one other than the 272 * driver core can touch this. 273 * 274 * A class is a higher-level view of a device that abstracts out low-level 275 * implementation details. Drivers may see a SCSI disk or an ATA disk, but, 276 * at the class level, they are all simply disks. Classes allow user space 277 * to work with devices based on what they do, rather than how they are 278 * connected or how they work. 279 */ 280 struct class { 281 const char *name; 282 struct module *owner; 283 284 struct class_attribute *class_attrs; 285 struct device_attribute *dev_attrs; 286 struct bin_attribute *dev_bin_attrs; 287 struct kobject *dev_kobj; 288 289 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); 290 char *(*devnode)(struct device *dev, mode_t *mode); 291 292 void (*class_release)(struct class *class); 293 void (*dev_release)(struct device *dev); 294 295 int (*suspend)(struct device *dev, pm_message_t state); 296 int (*resume)(struct device *dev); 297 298 const struct kobj_ns_type_operations *ns_type; 299 const void *(*namespace)(struct device *dev); 300 301 const struct dev_pm_ops *pm; 302 303 struct subsys_private *p; 304 }; 305 306 struct class_dev_iter { 307 struct klist_iter ki; 308 const struct device_type *type; 309 }; 310 311 extern struct kobject *sysfs_dev_block_kobj; 312 extern struct kobject *sysfs_dev_char_kobj; 313 extern int __must_check __class_register(struct class *class, 314 struct lock_class_key *key); 315 extern void class_unregister(struct class *class); 316 317 /* This is a #define to keep the compiler from merging different 318 * instances of the __key variable */ 319 #define class_register(class) \ 320 ({ \ 321 static struct lock_class_key __key; \ 322 __class_register(class, &__key); \ 323 }) 324 325 struct class_compat; 326 struct class_compat *class_compat_register(const char *name); 327 void class_compat_unregister(struct class_compat *cls); 328 int class_compat_create_link(struct class_compat *cls, struct device *dev, 329 struct device *device_link); 330 void class_compat_remove_link(struct class_compat *cls, struct device *dev, 331 struct device *device_link); 332 333 extern void class_dev_iter_init(struct class_dev_iter *iter, 334 struct class *class, 335 struct device *start, 336 const struct device_type *type); 337 extern struct device *class_dev_iter_next(struct class_dev_iter *iter); 338 extern void class_dev_iter_exit(struct class_dev_iter *iter); 339 340 extern int class_for_each_device(struct class *class, struct device *start, 341 void *data, 342 int (*fn)(struct device *dev, void *data)); 343 extern struct device *class_find_device(struct class *class, 344 struct device *start, void *data, 345 int (*match)(struct device *, void *)); 346 347 struct class_attribute { 348 struct attribute attr; 349 ssize_t (*show)(struct class *class, struct class_attribute *attr, 350 char *buf); 351 ssize_t (*store)(struct class *class, struct class_attribute *attr, 352 const char *buf, size_t count); 353 }; 354 355 #define CLASS_ATTR(_name, _mode, _show, _store) \ 356 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) 357 358 extern int __must_check class_create_file(struct class *class, 359 const struct class_attribute *attr); 360 extern void class_remove_file(struct class *class, 361 const struct class_attribute *attr); 362 363 /* Simple class attribute that is just a static string */ 364 365 struct class_attribute_string { 366 struct class_attribute attr; 367 char *str; 368 }; 369 370 /* Currently read-only only */ 371 #define _CLASS_ATTR_STRING(_name, _mode, _str) \ 372 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } 373 #define CLASS_ATTR_STRING(_name, _mode, _str) \ 374 struct class_attribute_string class_attr_##_name = \ 375 _CLASS_ATTR_STRING(_name, _mode, _str) 376 377 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 378 char *buf); 379 380 struct class_interface { 381 struct list_head node; 382 struct class *class; 383 384 int (*add_dev) (struct device *, struct class_interface *); 385 void (*remove_dev) (struct device *, struct class_interface *); 386 }; 387 388 extern int __must_check class_interface_register(struct class_interface *); 389 extern void class_interface_unregister(struct class_interface *); 390 391 extern struct class * __must_check __class_create(struct module *owner, 392 const char *name, 393 struct lock_class_key *key); 394 extern void class_destroy(struct class *cls); 395 396 /* This is a #define to keep the compiler from merging different 397 * instances of the __key variable */ 398 #define class_create(owner, name) \ 399 ({ \ 400 static struct lock_class_key __key; \ 401 __class_create(owner, name, &__key); \ 402 }) 403 404 /* 405 * The type of device, "struct device" is embedded in. A class 406 * or bus can contain devices of different types 407 * like "partitions" and "disks", "mouse" and "event". 408 * This identifies the device type and carries type-specific 409 * information, equivalent to the kobj_type of a kobject. 410 * If "name" is specified, the uevent will contain it in 411 * the DEVTYPE variable. 412 */ 413 struct device_type { 414 const char *name; 415 const struct attribute_group **groups; 416 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 417 char *(*devnode)(struct device *dev, mode_t *mode); 418 void (*release)(struct device *dev); 419 420 const struct dev_pm_ops *pm; 421 }; 422 423 /* interface for exporting device attributes */ 424 struct device_attribute { 425 struct attribute attr; 426 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 427 char *buf); 428 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 429 const char *buf, size_t count); 430 }; 431 432 #define DEVICE_ATTR(_name, _mode, _show, _store) \ 433 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 434 435 extern int __must_check device_create_file(struct device *device, 436 const struct device_attribute *entry); 437 extern void device_remove_file(struct device *dev, 438 const struct device_attribute *attr); 439 extern int __must_check device_create_bin_file(struct device *dev, 440 const struct bin_attribute *attr); 441 extern void device_remove_bin_file(struct device *dev, 442 const struct bin_attribute *attr); 443 extern int device_schedule_callback_owner(struct device *dev, 444 void (*func)(struct device *dev), struct module *owner); 445 446 /* This is a macro to avoid include problems with THIS_MODULE */ 447 #define device_schedule_callback(dev, func) \ 448 device_schedule_callback_owner(dev, func, THIS_MODULE) 449 450 /* device resource management */ 451 typedef void (*dr_release_t)(struct device *dev, void *res); 452 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 453 454 #ifdef CONFIG_DEBUG_DEVRES 455 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 456 const char *name); 457 #define devres_alloc(release, size, gfp) \ 458 __devres_alloc(release, size, gfp, #release) 459 #else 460 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 461 #endif 462 extern void devres_free(void *res); 463 extern void devres_add(struct device *dev, void *res); 464 extern void *devres_find(struct device *dev, dr_release_t release, 465 dr_match_t match, void *match_data); 466 extern void *devres_get(struct device *dev, void *new_res, 467 dr_match_t match, void *match_data); 468 extern void *devres_remove(struct device *dev, dr_release_t release, 469 dr_match_t match, void *match_data); 470 extern int devres_destroy(struct device *dev, dr_release_t release, 471 dr_match_t match, void *match_data); 472 473 /* devres group */ 474 extern void * __must_check devres_open_group(struct device *dev, void *id, 475 gfp_t gfp); 476 extern void devres_close_group(struct device *dev, void *id); 477 extern void devres_remove_group(struct device *dev, void *id); 478 extern int devres_release_group(struct device *dev, void *id); 479 480 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */ 481 extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp); 482 extern void devm_kfree(struct device *dev, void *p); 483 484 struct device_dma_parameters { 485 /* 486 * a low level driver may set these to teach IOMMU code about 487 * sg limitations. 488 */ 489 unsigned int max_segment_size; 490 unsigned long segment_boundary_mask; 491 }; 492 493 /** 494 * struct device - The basic device structure 495 * @parent: The device's "parent" device, the device to which it is attached. 496 * In most cases, a parent device is some sort of bus or host 497 * controller. If parent is NULL, the device, is a top-level device, 498 * which is not usually what you want. 499 * @p: Holds the private data of the driver core portions of the device. 500 * See the comment of the struct device_private for detail. 501 * @kobj: A top-level, abstract class from which other classes are derived. 502 * @init_name: Initial name of the device. 503 * @type: The type of device. 504 * This identifies the device type and carries type-specific 505 * information. 506 * @mutex: Mutex to synchronize calls to its driver. 507 * @bus: Type of bus device is on. 508 * @driver: Which driver has allocated this 509 * @platform_data: Platform data specific to the device. 510 * Example: For devices on custom boards, as typical of embedded 511 * and SOC based hardware, Linux often uses platform_data to point 512 * to board-specific structures describing devices and how they 513 * are wired. That can include what ports are available, chip 514 * variants, which GPIO pins act in what additional roles, and so 515 * on. This shrinks the "Board Support Packages" (BSPs) and 516 * minimizes board-specific #ifdefs in drivers. 517 * @power: For device power management. 518 * See Documentation/power/devices.txt for details. 519 * @pwr_domain: Provide callbacks that are executed during system suspend, 520 * hibernation, system resume and during runtime PM transitions 521 * along with subsystem-level and driver-level callbacks. 522 * @numa_node: NUMA node this device is close to. 523 * @dma_mask: Dma mask (if dma'ble device). 524 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all 525 * hardware supports 64-bit addresses for consistent allocations 526 * such descriptors. 527 * @dma_parms: A low level driver may set these to teach IOMMU code about 528 * segment limitations. 529 * @dma_pools: Dma pools (if dma'ble device). 530 * @dma_mem: Internal for coherent mem override. 531 * @archdata: For arch-specific additions. 532 * @of_node: Associated device tree node. 533 * @of_match: Matching of_device_id from driver. 534 * @devt: For creating the sysfs "dev". 535 * @devres_lock: Spinlock to protect the resource of the device. 536 * @devres_head: The resources list of the device. 537 * @knode_class: The node used to add the device to the class list. 538 * @class: The class of the device. 539 * @groups: Optional attribute groups. 540 * @release: Callback to free the device after all references have 541 * gone away. This should be set by the allocator of the 542 * device (i.e. the bus driver that discovered the device). 543 * 544 * At the lowest level, every device in a Linux system is represented by an 545 * instance of struct device. The device structure contains the information 546 * that the device model core needs to model the system. Most subsystems, 547 * however, track additional information about the devices they host. As a 548 * result, it is rare for devices to be represented by bare device structures; 549 * instead, that structure, like kobject structures, is usually embedded within 550 * a higher-level representation of the device. 551 */ 552 struct device { 553 struct device *parent; 554 555 struct device_private *p; 556 557 struct kobject kobj; 558 const char *init_name; /* initial name of the device */ 559 const struct device_type *type; 560 561 struct mutex mutex; /* mutex to synchronize calls to 562 * its driver. 563 */ 564 565 struct bus_type *bus; /* type of bus device is on */ 566 struct device_driver *driver; /* which driver has allocated this 567 device */ 568 void *platform_data; /* Platform specific data, device 569 core doesn't touch it */ 570 struct dev_pm_info power; 571 struct dev_power_domain *pwr_domain; 572 573 #ifdef CONFIG_NUMA 574 int numa_node; /* NUMA node this device is close to */ 575 #endif 576 u64 *dma_mask; /* dma mask (if dma'able device) */ 577 u64 coherent_dma_mask;/* Like dma_mask, but for 578 alloc_coherent mappings as 579 not all hardware supports 580 64 bit addresses for consistent 581 allocations such descriptors. */ 582 583 struct device_dma_parameters *dma_parms; 584 585 struct list_head dma_pools; /* dma pools (if dma'ble) */ 586 587 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 588 override */ 589 /* arch specific additions */ 590 struct dev_archdata archdata; 591 592 struct device_node *of_node; /* associated device tree node */ 593 594 dev_t devt; /* dev_t, creates the sysfs "dev" */ 595 596 spinlock_t devres_lock; 597 struct list_head devres_head; 598 599 struct klist_node knode_class; 600 struct class *class; 601 const struct attribute_group **groups; /* optional groups */ 602 603 void (*release)(struct device *dev); 604 }; 605 606 /* Get the wakeup routines, which depend on struct device */ 607 #include <linux/pm_wakeup.h> 608 609 static inline const char *dev_name(const struct device *dev) 610 { 611 /* Use the init name until the kobject becomes available */ 612 if (dev->init_name) 613 return dev->init_name; 614 615 return kobject_name(&dev->kobj); 616 } 617 618 extern int dev_set_name(struct device *dev, const char *name, ...) 619 __attribute__((format(printf, 2, 3))); 620 621 #ifdef CONFIG_NUMA 622 static inline int dev_to_node(struct device *dev) 623 { 624 return dev->numa_node; 625 } 626 static inline void set_dev_node(struct device *dev, int node) 627 { 628 dev->numa_node = node; 629 } 630 #else 631 static inline int dev_to_node(struct device *dev) 632 { 633 return -1; 634 } 635 static inline void set_dev_node(struct device *dev, int node) 636 { 637 } 638 #endif 639 640 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 641 { 642 return dev->kobj.uevent_suppress; 643 } 644 645 static inline void dev_set_uevent_suppress(struct device *dev, int val) 646 { 647 dev->kobj.uevent_suppress = val; 648 } 649 650 static inline int device_is_registered(struct device *dev) 651 { 652 return dev->kobj.state_in_sysfs; 653 } 654 655 static inline void device_enable_async_suspend(struct device *dev) 656 { 657 if (!dev->power.in_suspend) 658 dev->power.async_suspend = true; 659 } 660 661 static inline void device_disable_async_suspend(struct device *dev) 662 { 663 if (!dev->power.in_suspend) 664 dev->power.async_suspend = false; 665 } 666 667 static inline bool device_async_suspend_enabled(struct device *dev) 668 { 669 return !!dev->power.async_suspend; 670 } 671 672 static inline void device_lock(struct device *dev) 673 { 674 mutex_lock(&dev->mutex); 675 } 676 677 static inline int device_trylock(struct device *dev) 678 { 679 return mutex_trylock(&dev->mutex); 680 } 681 682 static inline void device_unlock(struct device *dev) 683 { 684 mutex_unlock(&dev->mutex); 685 } 686 687 void driver_init(void); 688 689 /* 690 * High level routines for use by the bus drivers 691 */ 692 extern int __must_check device_register(struct device *dev); 693 extern void device_unregister(struct device *dev); 694 extern void device_initialize(struct device *dev); 695 extern int __must_check device_add(struct device *dev); 696 extern void device_del(struct device *dev); 697 extern int device_for_each_child(struct device *dev, void *data, 698 int (*fn)(struct device *dev, void *data)); 699 extern struct device *device_find_child(struct device *dev, void *data, 700 int (*match)(struct device *dev, void *data)); 701 extern int device_rename(struct device *dev, const char *new_name); 702 extern int device_move(struct device *dev, struct device *new_parent, 703 enum dpm_order dpm_order); 704 extern const char *device_get_devnode(struct device *dev, 705 mode_t *mode, const char **tmp); 706 extern void *dev_get_drvdata(const struct device *dev); 707 extern int dev_set_drvdata(struct device *dev, void *data); 708 709 /* 710 * Root device objects for grouping under /sys/devices 711 */ 712 extern struct device *__root_device_register(const char *name, 713 struct module *owner); 714 static inline struct device *root_device_register(const char *name) 715 { 716 return __root_device_register(name, THIS_MODULE); 717 } 718 extern void root_device_unregister(struct device *root); 719 720 static inline void *dev_get_platdata(const struct device *dev) 721 { 722 return dev->platform_data; 723 } 724 725 /* 726 * Manual binding of a device to driver. See drivers/base/bus.c 727 * for information on use. 728 */ 729 extern int __must_check device_bind_driver(struct device *dev); 730 extern void device_release_driver(struct device *dev); 731 extern int __must_check device_attach(struct device *dev); 732 extern int __must_check driver_attach(struct device_driver *drv); 733 extern int __must_check device_reprobe(struct device *dev); 734 735 /* 736 * Easy functions for dynamically creating devices on the fly 737 */ 738 extern struct device *device_create_vargs(struct class *cls, 739 struct device *parent, 740 dev_t devt, 741 void *drvdata, 742 const char *fmt, 743 va_list vargs); 744 extern struct device *device_create(struct class *cls, struct device *parent, 745 dev_t devt, void *drvdata, 746 const char *fmt, ...) 747 __attribute__((format(printf, 5, 6))); 748 extern void device_destroy(struct class *cls, dev_t devt); 749 750 /* 751 * Platform "fixup" functions - allow the platform to have their say 752 * about devices and actions that the general device layer doesn't 753 * know about. 754 */ 755 /* Notify platform of device discovery */ 756 extern int (*platform_notify)(struct device *dev); 757 758 extern int (*platform_notify_remove)(struct device *dev); 759 760 761 /* 762 * get_device - atomically increment the reference count for the device. 763 * 764 */ 765 extern struct device *get_device(struct device *dev); 766 extern void put_device(struct device *dev); 767 768 extern void wait_for_device_probe(void); 769 770 #ifdef CONFIG_DEVTMPFS 771 extern int devtmpfs_create_node(struct device *dev); 772 extern int devtmpfs_delete_node(struct device *dev); 773 extern int devtmpfs_mount(const char *mntdir); 774 #else 775 static inline int devtmpfs_create_node(struct device *dev) { return 0; } 776 static inline int devtmpfs_delete_node(struct device *dev) { return 0; } 777 static inline int devtmpfs_mount(const char *mountpoint) { return 0; } 778 #endif 779 780 /* drivers/base/power/shutdown.c */ 781 extern void device_shutdown(void); 782 783 /* debugging and troubleshooting/diagnostic helpers. */ 784 extern const char *dev_driver_string(const struct device *dev); 785 786 787 #ifdef CONFIG_PRINTK 788 789 extern int dev_printk(const char *level, const struct device *dev, 790 const char *fmt, ...) 791 __attribute__ ((format (printf, 3, 4))); 792 extern int dev_emerg(const struct device *dev, const char *fmt, ...) 793 __attribute__ ((format (printf, 2, 3))); 794 extern int dev_alert(const struct device *dev, const char *fmt, ...) 795 __attribute__ ((format (printf, 2, 3))); 796 extern int dev_crit(const struct device *dev, const char *fmt, ...) 797 __attribute__ ((format (printf, 2, 3))); 798 extern int dev_err(const struct device *dev, const char *fmt, ...) 799 __attribute__ ((format (printf, 2, 3))); 800 extern int dev_warn(const struct device *dev, const char *fmt, ...) 801 __attribute__ ((format (printf, 2, 3))); 802 extern int dev_notice(const struct device *dev, const char *fmt, ...) 803 __attribute__ ((format (printf, 2, 3))); 804 extern int _dev_info(const struct device *dev, const char *fmt, ...) 805 __attribute__ ((format (printf, 2, 3))); 806 807 #else 808 809 static inline int dev_printk(const char *level, const struct device *dev, 810 const char *fmt, ...) 811 __attribute__ ((format (printf, 3, 4))); 812 static inline int dev_printk(const char *level, const struct device *dev, 813 const char *fmt, ...) 814 { return 0; } 815 816 static inline int dev_emerg(const struct device *dev, const char *fmt, ...) 817 __attribute__ ((format (printf, 2, 3))); 818 static inline int dev_emerg(const struct device *dev, const char *fmt, ...) 819 { return 0; } 820 static inline int dev_crit(const struct device *dev, const char *fmt, ...) 821 __attribute__ ((format (printf, 2, 3))); 822 static inline int dev_crit(const struct device *dev, const char *fmt, ...) 823 { return 0; } 824 static inline int dev_alert(const struct device *dev, const char *fmt, ...) 825 __attribute__ ((format (printf, 2, 3))); 826 static inline int dev_alert(const struct device *dev, const char *fmt, ...) 827 { return 0; } 828 static inline int dev_err(const struct device *dev, const char *fmt, ...) 829 __attribute__ ((format (printf, 2, 3))); 830 static inline int dev_err(const struct device *dev, const char *fmt, ...) 831 { return 0; } 832 static inline int dev_warn(const struct device *dev, const char *fmt, ...) 833 __attribute__ ((format (printf, 2, 3))); 834 static inline int dev_warn(const struct device *dev, const char *fmt, ...) 835 { return 0; } 836 static inline int dev_notice(const struct device *dev, const char *fmt, ...) 837 __attribute__ ((format (printf, 2, 3))); 838 static inline int dev_notice(const struct device *dev, const char *fmt, ...) 839 { return 0; } 840 static inline int _dev_info(const struct device *dev, const char *fmt, ...) 841 __attribute__ ((format (printf, 2, 3))); 842 static inline int _dev_info(const struct device *dev, const char *fmt, ...) 843 { return 0; } 844 845 #endif 846 847 /* 848 * Stupid hackaround for existing uses of non-printk uses dev_info 849 * 850 * Note that the definition of dev_info below is actually _dev_info 851 * and a macro is used to avoid redefining dev_info 852 */ 853 854 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg) 855 856 #if defined(DEBUG) 857 #define dev_dbg(dev, format, arg...) \ 858 dev_printk(KERN_DEBUG, dev, format, ##arg) 859 #elif defined(CONFIG_DYNAMIC_DEBUG) 860 #define dev_dbg(dev, format, ...) \ 861 do { \ 862 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ 863 } while (0) 864 #else 865 #define dev_dbg(dev, format, arg...) \ 866 ({ \ 867 if (0) \ 868 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 869 0; \ 870 }) 871 #endif 872 873 #ifdef VERBOSE_DEBUG 874 #define dev_vdbg dev_dbg 875 #else 876 #define dev_vdbg(dev, format, arg...) \ 877 ({ \ 878 if (0) \ 879 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 880 0; \ 881 }) 882 #endif 883 884 /* 885 * dev_WARN*() acts like dev_printk(), but with the key difference 886 * of using a WARN/WARN_ON to get the message out, including the 887 * file/line information and a backtrace. 888 */ 889 #define dev_WARN(dev, format, arg...) \ 890 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg); 891 892 #define dev_WARN_ONCE(dev, condition, format, arg...) \ 893 WARN_ONCE(condition, "Device %s\n" format, \ 894 dev_driver_string(dev), ## arg) 895 896 /* Create alias, so I can be autoloaded. */ 897 #define MODULE_ALIAS_CHARDEV(major,minor) \ 898 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 899 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 900 MODULE_ALIAS("char-major-" __stringify(major) "-*") 901 902 #ifdef CONFIG_SYSFS_DEPRECATED 903 extern long sysfs_deprecated; 904 #else 905 #define sysfs_deprecated 0 906 #endif 907 908 #endif /* _DEVICE_H_ */ 909