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 <linux/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 * @pm_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 * @devt: For creating the sysfs "dev". 534 * @devres_lock: Spinlock to protect the resource of the device. 535 * @devres_head: The resources list of the device. 536 * @knode_class: The node used to add the device to the class list. 537 * @class: The class of the device. 538 * @groups: Optional attribute groups. 539 * @release: Callback to free the device after all references have 540 * gone away. This should be set by the allocator of the 541 * device (i.e. the bus driver that discovered the device). 542 * 543 * At the lowest level, every device in a Linux system is represented by an 544 * instance of struct device. The device structure contains the information 545 * that the device model core needs to model the system. Most subsystems, 546 * however, track additional information about the devices they host. As a 547 * result, it is rare for devices to be represented by bare device structures; 548 * instead, that structure, like kobject structures, is usually embedded within 549 * a higher-level representation of the device. 550 */ 551 struct device { 552 struct device *parent; 553 554 struct device_private *p; 555 556 struct kobject kobj; 557 const char *init_name; /* initial name of the device */ 558 const struct device_type *type; 559 560 struct mutex mutex; /* mutex to synchronize calls to 561 * its driver. 562 */ 563 564 struct bus_type *bus; /* type of bus device is on */ 565 struct device_driver *driver; /* which driver has allocated this 566 device */ 567 void *platform_data; /* Platform specific data, device 568 core doesn't touch it */ 569 struct dev_pm_info power; 570 struct dev_pm_domain *pm_domain; 571 572 #ifdef CONFIG_NUMA 573 int numa_node; /* NUMA node this device is close to */ 574 #endif 575 u64 *dma_mask; /* dma mask (if dma'able device) */ 576 u64 coherent_dma_mask;/* Like dma_mask, but for 577 alloc_coherent mappings as 578 not all hardware supports 579 64 bit addresses for consistent 580 allocations such descriptors. */ 581 582 struct device_dma_parameters *dma_parms; 583 584 struct list_head dma_pools; /* dma pools (if dma'ble) */ 585 586 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 587 override */ 588 /* arch specific additions */ 589 struct dev_archdata archdata; 590 591 struct device_node *of_node; /* associated device tree node */ 592 593 dev_t devt; /* dev_t, creates the sysfs "dev" */ 594 595 spinlock_t devres_lock; 596 struct list_head devres_head; 597 598 struct klist_node knode_class; 599 struct class *class; 600 const struct attribute_group **groups; /* optional groups */ 601 602 void (*release)(struct device *dev); 603 }; 604 605 /* Get the wakeup routines, which depend on struct device */ 606 #include <linux/pm_wakeup.h> 607 608 static inline const char *dev_name(const struct device *dev) 609 { 610 /* Use the init name until the kobject becomes available */ 611 if (dev->init_name) 612 return dev->init_name; 613 614 return kobject_name(&dev->kobj); 615 } 616 617 extern int dev_set_name(struct device *dev, const char *name, ...) 618 __attribute__((format(printf, 2, 3))); 619 620 #ifdef CONFIG_NUMA 621 static inline int dev_to_node(struct device *dev) 622 { 623 return dev->numa_node; 624 } 625 static inline void set_dev_node(struct device *dev, int node) 626 { 627 dev->numa_node = node; 628 } 629 #else 630 static inline int dev_to_node(struct device *dev) 631 { 632 return -1; 633 } 634 static inline void set_dev_node(struct device *dev, int node) 635 { 636 } 637 #endif 638 639 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 640 { 641 return dev->kobj.uevent_suppress; 642 } 643 644 static inline void dev_set_uevent_suppress(struct device *dev, int val) 645 { 646 dev->kobj.uevent_suppress = val; 647 } 648 649 static inline int device_is_registered(struct device *dev) 650 { 651 return dev->kobj.state_in_sysfs; 652 } 653 654 static inline void device_enable_async_suspend(struct device *dev) 655 { 656 if (!dev->power.is_prepared) 657 dev->power.async_suspend = true; 658 } 659 660 static inline void device_disable_async_suspend(struct device *dev) 661 { 662 if (!dev->power.is_prepared) 663 dev->power.async_suspend = false; 664 } 665 666 static inline bool device_async_suspend_enabled(struct device *dev) 667 { 668 return !!dev->power.async_suspend; 669 } 670 671 static inline void device_lock(struct device *dev) 672 { 673 mutex_lock(&dev->mutex); 674 } 675 676 static inline int device_trylock(struct device *dev) 677 { 678 return mutex_trylock(&dev->mutex); 679 } 680 681 static inline void device_unlock(struct device *dev) 682 { 683 mutex_unlock(&dev->mutex); 684 } 685 686 void driver_init(void); 687 688 /* 689 * High level routines for use by the bus drivers 690 */ 691 extern int __must_check device_register(struct device *dev); 692 extern void device_unregister(struct device *dev); 693 extern void device_initialize(struct device *dev); 694 extern int __must_check device_add(struct device *dev); 695 extern void device_del(struct device *dev); 696 extern int device_for_each_child(struct device *dev, void *data, 697 int (*fn)(struct device *dev, void *data)); 698 extern struct device *device_find_child(struct device *dev, void *data, 699 int (*match)(struct device *dev, void *data)); 700 extern int device_rename(struct device *dev, const char *new_name); 701 extern int device_move(struct device *dev, struct device *new_parent, 702 enum dpm_order dpm_order); 703 extern const char *device_get_devnode(struct device *dev, 704 mode_t *mode, const char **tmp); 705 extern void *dev_get_drvdata(const struct device *dev); 706 extern int dev_set_drvdata(struct device *dev, void *data); 707 708 /* 709 * Root device objects for grouping under /sys/devices 710 */ 711 extern struct device *__root_device_register(const char *name, 712 struct module *owner); 713 static inline struct device *root_device_register(const char *name) 714 { 715 return __root_device_register(name, THIS_MODULE); 716 } 717 extern void root_device_unregister(struct device *root); 718 719 static inline void *dev_get_platdata(const struct device *dev) 720 { 721 return dev->platform_data; 722 } 723 724 /* 725 * Manual binding of a device to driver. See drivers/base/bus.c 726 * for information on use. 727 */ 728 extern int __must_check device_bind_driver(struct device *dev); 729 extern void device_release_driver(struct device *dev); 730 extern int __must_check device_attach(struct device *dev); 731 extern int __must_check driver_attach(struct device_driver *drv); 732 extern int __must_check device_reprobe(struct device *dev); 733 734 /* 735 * Easy functions for dynamically creating devices on the fly 736 */ 737 extern struct device *device_create_vargs(struct class *cls, 738 struct device *parent, 739 dev_t devt, 740 void *drvdata, 741 const char *fmt, 742 va_list vargs); 743 extern struct device *device_create(struct class *cls, struct device *parent, 744 dev_t devt, void *drvdata, 745 const char *fmt, ...) 746 __attribute__((format(printf, 5, 6))); 747 extern void device_destroy(struct class *cls, dev_t devt); 748 749 /* 750 * Platform "fixup" functions - allow the platform to have their say 751 * about devices and actions that the general device layer doesn't 752 * know about. 753 */ 754 /* Notify platform of device discovery */ 755 extern int (*platform_notify)(struct device *dev); 756 757 extern int (*platform_notify_remove)(struct device *dev); 758 759 760 /* 761 * get_device - atomically increment the reference count for the device. 762 * 763 */ 764 extern struct device *get_device(struct device *dev); 765 extern void put_device(struct device *dev); 766 767 extern void wait_for_device_probe(void); 768 769 #ifdef CONFIG_DEVTMPFS 770 extern int devtmpfs_create_node(struct device *dev); 771 extern int devtmpfs_delete_node(struct device *dev); 772 extern int devtmpfs_mount(const char *mntdir); 773 #else 774 static inline int devtmpfs_create_node(struct device *dev) { return 0; } 775 static inline int devtmpfs_delete_node(struct device *dev) { return 0; } 776 static inline int devtmpfs_mount(const char *mountpoint) { return 0; } 777 #endif 778 779 /* drivers/base/power/shutdown.c */ 780 extern void device_shutdown(void); 781 782 /* debugging and troubleshooting/diagnostic helpers. */ 783 extern const char *dev_driver_string(const struct device *dev); 784 785 786 #ifdef CONFIG_PRINTK 787 788 extern int dev_printk(const char *level, const struct device *dev, 789 const char *fmt, ...) 790 __attribute__ ((format (printf, 3, 4))); 791 extern int dev_emerg(const struct device *dev, const char *fmt, ...) 792 __attribute__ ((format (printf, 2, 3))); 793 extern int dev_alert(const struct device *dev, const char *fmt, ...) 794 __attribute__ ((format (printf, 2, 3))); 795 extern int dev_crit(const struct device *dev, const char *fmt, ...) 796 __attribute__ ((format (printf, 2, 3))); 797 extern int dev_err(const struct device *dev, const char *fmt, ...) 798 __attribute__ ((format (printf, 2, 3))); 799 extern int dev_warn(const struct device *dev, const char *fmt, ...) 800 __attribute__ ((format (printf, 2, 3))); 801 extern int dev_notice(const struct device *dev, const char *fmt, ...) 802 __attribute__ ((format (printf, 2, 3))); 803 extern int _dev_info(const struct device *dev, const char *fmt, ...) 804 __attribute__ ((format (printf, 2, 3))); 805 806 #else 807 808 static inline int dev_printk(const char *level, const struct device *dev, 809 const char *fmt, ...) 810 __attribute__ ((format (printf, 3, 4))); 811 static inline int dev_printk(const char *level, const struct device *dev, 812 const char *fmt, ...) 813 { return 0; } 814 815 static inline int dev_emerg(const struct device *dev, const char *fmt, ...) 816 __attribute__ ((format (printf, 2, 3))); 817 static inline int dev_emerg(const struct device *dev, const char *fmt, ...) 818 { return 0; } 819 static inline int dev_crit(const struct device *dev, const char *fmt, ...) 820 __attribute__ ((format (printf, 2, 3))); 821 static inline int dev_crit(const struct device *dev, const char *fmt, ...) 822 { return 0; } 823 static inline int dev_alert(const struct device *dev, const char *fmt, ...) 824 __attribute__ ((format (printf, 2, 3))); 825 static inline int dev_alert(const struct device *dev, const char *fmt, ...) 826 { return 0; } 827 static inline int dev_err(const struct device *dev, const char *fmt, ...) 828 __attribute__ ((format (printf, 2, 3))); 829 static inline int dev_err(const struct device *dev, const char *fmt, ...) 830 { return 0; } 831 static inline int dev_warn(const struct device *dev, const char *fmt, ...) 832 __attribute__ ((format (printf, 2, 3))); 833 static inline int dev_warn(const struct device *dev, const char *fmt, ...) 834 { return 0; } 835 static inline int dev_notice(const struct device *dev, const char *fmt, ...) 836 __attribute__ ((format (printf, 2, 3))); 837 static inline int dev_notice(const struct device *dev, const char *fmt, ...) 838 { return 0; } 839 static inline int _dev_info(const struct device *dev, const char *fmt, ...) 840 __attribute__ ((format (printf, 2, 3))); 841 static inline int _dev_info(const struct device *dev, const char *fmt, ...) 842 { return 0; } 843 844 #endif 845 846 /* 847 * Stupid hackaround for existing uses of non-printk uses dev_info 848 * 849 * Note that the definition of dev_info below is actually _dev_info 850 * and a macro is used to avoid redefining dev_info 851 */ 852 853 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg) 854 855 #if defined(DEBUG) 856 #define dev_dbg(dev, format, arg...) \ 857 dev_printk(KERN_DEBUG, dev, format, ##arg) 858 #elif defined(CONFIG_DYNAMIC_DEBUG) 859 #define dev_dbg(dev, format, ...) \ 860 do { \ 861 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ 862 } while (0) 863 #else 864 #define dev_dbg(dev, format, arg...) \ 865 ({ \ 866 if (0) \ 867 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 868 0; \ 869 }) 870 #endif 871 872 #ifdef VERBOSE_DEBUG 873 #define dev_vdbg dev_dbg 874 #else 875 #define dev_vdbg(dev, format, arg...) \ 876 ({ \ 877 if (0) \ 878 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 879 0; \ 880 }) 881 #endif 882 883 /* 884 * dev_WARN*() acts like dev_printk(), but with the key difference 885 * of using a WARN/WARN_ON to get the message out, including the 886 * file/line information and a backtrace. 887 */ 888 #define dev_WARN(dev, format, arg...) \ 889 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg); 890 891 #define dev_WARN_ONCE(dev, condition, format, arg...) \ 892 WARN_ONCE(condition, "Device %s\n" format, \ 893 dev_driver_string(dev), ## arg) 894 895 /* Create alias, so I can be autoloaded. */ 896 #define MODULE_ALIAS_CHARDEV(major,minor) \ 897 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 898 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 899 MODULE_ALIAS("char-major-" __stringify(major) "-*") 900 901 #ifdef CONFIG_SYSFS_DEPRECATED 902 extern long sysfs_deprecated; 903 #else 904 #define sysfs_deprecated 0 905 #endif 906 907 #endif /* _DEVICE_H_ */ 908