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