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 class_private; 34 struct bus_type; 35 struct bus_type_private; 36 struct device_node; 37 38 struct bus_attribute { 39 struct attribute attr; 40 ssize_t (*show)(struct bus_type *bus, char *buf); 41 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); 42 }; 43 44 #define BUS_ATTR(_name, _mode, _show, _store) \ 45 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) 46 47 extern int __must_check bus_create_file(struct bus_type *, 48 struct bus_attribute *); 49 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 50 51 struct bus_type { 52 const char *name; 53 struct bus_attribute *bus_attrs; 54 struct device_attribute *dev_attrs; 55 struct driver_attribute *drv_attrs; 56 57 int (*match)(struct device *dev, struct device_driver *drv); 58 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 59 int (*probe)(struct device *dev); 60 int (*remove)(struct device *dev); 61 void (*shutdown)(struct device *dev); 62 63 int (*suspend)(struct device *dev, pm_message_t state); 64 int (*resume)(struct device *dev); 65 66 const struct dev_pm_ops *pm; 67 68 struct bus_type_private *p; 69 }; 70 71 extern int __must_check bus_register(struct bus_type *bus); 72 extern void bus_unregister(struct bus_type *bus); 73 74 extern int __must_check bus_rescan_devices(struct bus_type *bus); 75 76 /* iterator helpers for buses */ 77 78 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, 79 int (*fn)(struct device *dev, void *data)); 80 struct device *bus_find_device(struct bus_type *bus, struct device *start, 81 void *data, 82 int (*match)(struct device *dev, void *data)); 83 struct device *bus_find_device_by_name(struct bus_type *bus, 84 struct device *start, 85 const char *name); 86 87 int __must_check bus_for_each_drv(struct bus_type *bus, 88 struct device_driver *start, void *data, 89 int (*fn)(struct device_driver *, void *)); 90 91 void bus_sort_breadthfirst(struct bus_type *bus, 92 int (*compare)(const struct device *a, 93 const struct device *b)); 94 /* 95 * Bus notifiers: Get notified of addition/removal of devices 96 * and binding/unbinding of drivers to devices. 97 * In the long run, it should be a replacement for the platform 98 * notify hooks. 99 */ 100 struct notifier_block; 101 102 extern int bus_register_notifier(struct bus_type *bus, 103 struct notifier_block *nb); 104 extern int bus_unregister_notifier(struct bus_type *bus, 105 struct notifier_block *nb); 106 107 /* All 4 notifers below get called with the target struct device * 108 * as an argument. Note that those functions are likely to be called 109 * with the device lock held in the core, so be careful. 110 */ 111 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 112 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */ 113 #define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */ 114 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be 115 unbound */ 116 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000005 /* driver is unbound 117 from the device */ 118 119 extern struct kset *bus_get_kset(struct bus_type *bus); 120 extern struct klist *bus_get_device_klist(struct bus_type *bus); 121 122 struct device_driver { 123 const char *name; 124 struct bus_type *bus; 125 126 struct module *owner; 127 const char *mod_name; /* used for built-in modules */ 128 129 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 130 131 #if defined(CONFIG_OF) 132 const struct of_device_id *of_match_table; 133 #endif 134 135 int (*probe) (struct device *dev); 136 int (*remove) (struct device *dev); 137 void (*shutdown) (struct device *dev); 138 int (*suspend) (struct device *dev, pm_message_t state); 139 int (*resume) (struct device *dev); 140 const struct attribute_group **groups; 141 142 const struct dev_pm_ops *pm; 143 144 struct driver_private *p; 145 }; 146 147 148 extern int __must_check driver_register(struct device_driver *drv); 149 extern void driver_unregister(struct device_driver *drv); 150 151 extern struct device_driver *get_driver(struct device_driver *drv); 152 extern void put_driver(struct device_driver *drv); 153 extern struct device_driver *driver_find(const char *name, 154 struct bus_type *bus); 155 extern int driver_probe_done(void); 156 extern void wait_for_device_probe(void); 157 158 159 /* sysfs interface for exporting driver attributes */ 160 161 struct driver_attribute { 162 struct attribute attr; 163 ssize_t (*show)(struct device_driver *driver, char *buf); 164 ssize_t (*store)(struct device_driver *driver, const char *buf, 165 size_t count); 166 }; 167 168 #define DRIVER_ATTR(_name, _mode, _show, _store) \ 169 struct driver_attribute driver_attr_##_name = \ 170 __ATTR(_name, _mode, _show, _store) 171 172 extern int __must_check driver_create_file(struct device_driver *driver, 173 const struct driver_attribute *attr); 174 extern void driver_remove_file(struct device_driver *driver, 175 const struct driver_attribute *attr); 176 177 extern int __must_check driver_add_kobj(struct device_driver *drv, 178 struct kobject *kobj, 179 const char *fmt, ...); 180 181 extern int __must_check driver_for_each_device(struct device_driver *drv, 182 struct device *start, 183 void *data, 184 int (*fn)(struct device *dev, 185 void *)); 186 struct device *driver_find_device(struct device_driver *drv, 187 struct device *start, void *data, 188 int (*match)(struct device *dev, void *data)); 189 190 /* 191 * device classes 192 */ 193 struct class { 194 const char *name; 195 struct module *owner; 196 197 struct class_attribute *class_attrs; 198 struct device_attribute *dev_attrs; 199 struct kobject *dev_kobj; 200 201 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); 202 char *(*devnode)(struct device *dev, mode_t *mode); 203 204 void (*class_release)(struct class *class); 205 void (*dev_release)(struct device *dev); 206 207 int (*suspend)(struct device *dev, pm_message_t state); 208 int (*resume)(struct device *dev); 209 210 const struct kobj_ns_type_operations *ns_type; 211 const void *(*namespace)(struct device *dev); 212 213 const struct dev_pm_ops *pm; 214 215 struct class_private *p; 216 }; 217 218 struct class_dev_iter { 219 struct klist_iter ki; 220 const struct device_type *type; 221 }; 222 223 extern struct kobject *sysfs_dev_block_kobj; 224 extern struct kobject *sysfs_dev_char_kobj; 225 extern int __must_check __class_register(struct class *class, 226 struct lock_class_key *key); 227 extern void class_unregister(struct class *class); 228 229 /* This is a #define to keep the compiler from merging different 230 * instances of the __key variable */ 231 #define class_register(class) \ 232 ({ \ 233 static struct lock_class_key __key; \ 234 __class_register(class, &__key); \ 235 }) 236 237 struct class_compat; 238 struct class_compat *class_compat_register(const char *name); 239 void class_compat_unregister(struct class_compat *cls); 240 int class_compat_create_link(struct class_compat *cls, struct device *dev, 241 struct device *device_link); 242 void class_compat_remove_link(struct class_compat *cls, struct device *dev, 243 struct device *device_link); 244 245 extern void class_dev_iter_init(struct class_dev_iter *iter, 246 struct class *class, 247 struct device *start, 248 const struct device_type *type); 249 extern struct device *class_dev_iter_next(struct class_dev_iter *iter); 250 extern void class_dev_iter_exit(struct class_dev_iter *iter); 251 252 extern int class_for_each_device(struct class *class, struct device *start, 253 void *data, 254 int (*fn)(struct device *dev, void *data)); 255 extern struct device *class_find_device(struct class *class, 256 struct device *start, void *data, 257 int (*match)(struct device *, void *)); 258 259 struct class_attribute { 260 struct attribute attr; 261 ssize_t (*show)(struct class *class, struct class_attribute *attr, 262 char *buf); 263 ssize_t (*store)(struct class *class, struct class_attribute *attr, 264 const char *buf, size_t count); 265 }; 266 267 #define CLASS_ATTR(_name, _mode, _show, _store) \ 268 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) 269 270 extern int __must_check class_create_file(struct class *class, 271 const struct class_attribute *attr); 272 extern void class_remove_file(struct class *class, 273 const struct class_attribute *attr); 274 275 /* Simple class attribute that is just a static string */ 276 277 struct class_attribute_string { 278 struct class_attribute attr; 279 char *str; 280 }; 281 282 /* Currently read-only only */ 283 #define _CLASS_ATTR_STRING(_name, _mode, _str) \ 284 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } 285 #define CLASS_ATTR_STRING(_name, _mode, _str) \ 286 struct class_attribute_string class_attr_##_name = \ 287 _CLASS_ATTR_STRING(_name, _mode, _str) 288 289 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 290 char *buf); 291 292 struct class_interface { 293 struct list_head node; 294 struct class *class; 295 296 int (*add_dev) (struct device *, struct class_interface *); 297 void (*remove_dev) (struct device *, struct class_interface *); 298 }; 299 300 extern int __must_check class_interface_register(struct class_interface *); 301 extern void class_interface_unregister(struct class_interface *); 302 303 extern struct class * __must_check __class_create(struct module *owner, 304 const char *name, 305 struct lock_class_key *key); 306 extern void class_destroy(struct class *cls); 307 308 /* This is a #define to keep the compiler from merging different 309 * instances of the __key variable */ 310 #define class_create(owner, name) \ 311 ({ \ 312 static struct lock_class_key __key; \ 313 __class_create(owner, name, &__key); \ 314 }) 315 316 /* 317 * The type of device, "struct device" is embedded in. A class 318 * or bus can contain devices of different types 319 * like "partitions" and "disks", "mouse" and "event". 320 * This identifies the device type and carries type-specific 321 * information, equivalent to the kobj_type of a kobject. 322 * If "name" is specified, the uevent will contain it in 323 * the DEVTYPE variable. 324 */ 325 struct device_type { 326 const char *name; 327 const struct attribute_group **groups; 328 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 329 char *(*devnode)(struct device *dev, mode_t *mode); 330 void (*release)(struct device *dev); 331 332 const struct dev_pm_ops *pm; 333 }; 334 335 /* interface for exporting device attributes */ 336 struct device_attribute { 337 struct attribute attr; 338 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 339 char *buf); 340 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 341 const char *buf, size_t count); 342 }; 343 344 #define DEVICE_ATTR(_name, _mode, _show, _store) \ 345 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 346 347 extern int __must_check device_create_file(struct device *device, 348 const struct device_attribute *entry); 349 extern void device_remove_file(struct device *dev, 350 const struct device_attribute *attr); 351 extern int __must_check device_create_bin_file(struct device *dev, 352 const struct bin_attribute *attr); 353 extern void device_remove_bin_file(struct device *dev, 354 const struct bin_attribute *attr); 355 extern int device_schedule_callback_owner(struct device *dev, 356 void (*func)(struct device *dev), struct module *owner); 357 358 /* This is a macro to avoid include problems with THIS_MODULE */ 359 #define device_schedule_callback(dev, func) \ 360 device_schedule_callback_owner(dev, func, THIS_MODULE) 361 362 /* device resource management */ 363 typedef void (*dr_release_t)(struct device *dev, void *res); 364 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 365 366 #ifdef CONFIG_DEBUG_DEVRES 367 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 368 const char *name); 369 #define devres_alloc(release, size, gfp) \ 370 __devres_alloc(release, size, gfp, #release) 371 #else 372 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 373 #endif 374 extern void devres_free(void *res); 375 extern void devres_add(struct device *dev, void *res); 376 extern void *devres_find(struct device *dev, dr_release_t release, 377 dr_match_t match, void *match_data); 378 extern void *devres_get(struct device *dev, void *new_res, 379 dr_match_t match, void *match_data); 380 extern void *devres_remove(struct device *dev, dr_release_t release, 381 dr_match_t match, void *match_data); 382 extern int devres_destroy(struct device *dev, dr_release_t release, 383 dr_match_t match, void *match_data); 384 385 /* devres group */ 386 extern void * __must_check devres_open_group(struct device *dev, void *id, 387 gfp_t gfp); 388 extern void devres_close_group(struct device *dev, void *id); 389 extern void devres_remove_group(struct device *dev, void *id); 390 extern int devres_release_group(struct device *dev, void *id); 391 392 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */ 393 extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp); 394 extern void devm_kfree(struct device *dev, void *p); 395 396 struct device_dma_parameters { 397 /* 398 * a low level driver may set these to teach IOMMU code about 399 * sg limitations. 400 */ 401 unsigned int max_segment_size; 402 unsigned long segment_boundary_mask; 403 }; 404 405 struct device { 406 struct device *parent; 407 408 struct device_private *p; 409 410 struct kobject kobj; 411 const char *init_name; /* initial name of the device */ 412 struct device_type *type; 413 414 struct mutex mutex; /* mutex to synchronize calls to 415 * its driver. 416 */ 417 418 struct bus_type *bus; /* type of bus device is on */ 419 struct device_driver *driver; /* which driver has allocated this 420 device */ 421 void *platform_data; /* Platform specific data, device 422 core doesn't touch it */ 423 struct dev_pm_info power; 424 425 #ifdef CONFIG_NUMA 426 int numa_node; /* NUMA node this device is close to */ 427 #endif 428 u64 *dma_mask; /* dma mask (if dma'able device) */ 429 u64 coherent_dma_mask;/* Like dma_mask, but for 430 alloc_coherent mappings as 431 not all hardware supports 432 64 bit addresses for consistent 433 allocations such descriptors. */ 434 435 struct device_dma_parameters *dma_parms; 436 437 struct list_head dma_pools; /* dma pools (if dma'ble) */ 438 439 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 440 override */ 441 /* arch specific additions */ 442 struct dev_archdata archdata; 443 #ifdef CONFIG_OF 444 struct device_node *of_node; 445 #endif 446 447 dev_t devt; /* dev_t, creates the sysfs "dev" */ 448 449 spinlock_t devres_lock; 450 struct list_head devres_head; 451 452 struct klist_node knode_class; 453 struct class *class; 454 const struct attribute_group **groups; /* optional groups */ 455 456 void (*release)(struct device *dev); 457 }; 458 459 /* Get the wakeup routines, which depend on struct device */ 460 #include <linux/pm_wakeup.h> 461 462 static inline const char *dev_name(const struct device *dev) 463 { 464 /* Use the init name until the kobject becomes available */ 465 if (dev->init_name) 466 return dev->init_name; 467 468 return kobject_name(&dev->kobj); 469 } 470 471 extern int dev_set_name(struct device *dev, const char *name, ...) 472 __attribute__((format(printf, 2, 3))); 473 474 #ifdef CONFIG_NUMA 475 static inline int dev_to_node(struct device *dev) 476 { 477 return dev->numa_node; 478 } 479 static inline void set_dev_node(struct device *dev, int node) 480 { 481 dev->numa_node = node; 482 } 483 #else 484 static inline int dev_to_node(struct device *dev) 485 { 486 return -1; 487 } 488 static inline void set_dev_node(struct device *dev, int node) 489 { 490 } 491 #endif 492 493 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 494 { 495 return dev->kobj.uevent_suppress; 496 } 497 498 static inline void dev_set_uevent_suppress(struct device *dev, int val) 499 { 500 dev->kobj.uevent_suppress = val; 501 } 502 503 static inline int device_is_registered(struct device *dev) 504 { 505 return dev->kobj.state_in_sysfs; 506 } 507 508 static inline void device_enable_async_suspend(struct device *dev) 509 { 510 if (dev->power.status == DPM_ON) 511 dev->power.async_suspend = true; 512 } 513 514 static inline void device_disable_async_suspend(struct device *dev) 515 { 516 if (dev->power.status == DPM_ON) 517 dev->power.async_suspend = false; 518 } 519 520 static inline bool device_async_suspend_enabled(struct device *dev) 521 { 522 return !!dev->power.async_suspend; 523 } 524 525 static inline void device_lock(struct device *dev) 526 { 527 mutex_lock(&dev->mutex); 528 } 529 530 static inline int device_trylock(struct device *dev) 531 { 532 return mutex_trylock(&dev->mutex); 533 } 534 535 static inline void device_unlock(struct device *dev) 536 { 537 mutex_unlock(&dev->mutex); 538 } 539 540 void driver_init(void); 541 542 /* 543 * High level routines for use by the bus drivers 544 */ 545 extern int __must_check device_register(struct device *dev); 546 extern void device_unregister(struct device *dev); 547 extern void device_initialize(struct device *dev); 548 extern int __must_check device_add(struct device *dev); 549 extern void device_del(struct device *dev); 550 extern int device_for_each_child(struct device *dev, void *data, 551 int (*fn)(struct device *dev, void *data)); 552 extern struct device *device_find_child(struct device *dev, void *data, 553 int (*match)(struct device *dev, void *data)); 554 extern int device_rename(struct device *dev, char *new_name); 555 extern int device_move(struct device *dev, struct device *new_parent, 556 enum dpm_order dpm_order); 557 extern const char *device_get_devnode(struct device *dev, 558 mode_t *mode, const char **tmp); 559 extern void *dev_get_drvdata(const struct device *dev); 560 extern void dev_set_drvdata(struct device *dev, void *data); 561 562 /* 563 * Root device objects for grouping under /sys/devices 564 */ 565 extern struct device *__root_device_register(const char *name, 566 struct module *owner); 567 static inline struct device *root_device_register(const char *name) 568 { 569 return __root_device_register(name, THIS_MODULE); 570 } 571 extern void root_device_unregister(struct device *root); 572 573 static inline void *dev_get_platdata(const struct device *dev) 574 { 575 return dev->platform_data; 576 } 577 578 /* 579 * Manual binding of a device to driver. See drivers/base/bus.c 580 * for information on use. 581 */ 582 extern int __must_check device_bind_driver(struct device *dev); 583 extern void device_release_driver(struct device *dev); 584 extern int __must_check device_attach(struct device *dev); 585 extern int __must_check driver_attach(struct device_driver *drv); 586 extern int __must_check device_reprobe(struct device *dev); 587 588 /* 589 * Easy functions for dynamically creating devices on the fly 590 */ 591 extern struct device *device_create_vargs(struct class *cls, 592 struct device *parent, 593 dev_t devt, 594 void *drvdata, 595 const char *fmt, 596 va_list vargs); 597 extern struct device *device_create(struct class *cls, struct device *parent, 598 dev_t devt, void *drvdata, 599 const char *fmt, ...) 600 __attribute__((format(printf, 5, 6))); 601 extern void device_destroy(struct class *cls, dev_t devt); 602 603 /* 604 * Platform "fixup" functions - allow the platform to have their say 605 * about devices and actions that the general device layer doesn't 606 * know about. 607 */ 608 /* Notify platform of device discovery */ 609 extern int (*platform_notify)(struct device *dev); 610 611 extern int (*platform_notify_remove)(struct device *dev); 612 613 614 /** 615 * get_device - atomically increment the reference count for the device. 616 * 617 */ 618 extern struct device *get_device(struct device *dev); 619 extern void put_device(struct device *dev); 620 621 extern void wait_for_device_probe(void); 622 623 #ifdef CONFIG_DEVTMPFS 624 extern int devtmpfs_create_node(struct device *dev); 625 extern int devtmpfs_delete_node(struct device *dev); 626 extern int devtmpfs_mount(const char *mntdir); 627 #else 628 static inline int devtmpfs_create_node(struct device *dev) { return 0; } 629 static inline int devtmpfs_delete_node(struct device *dev) { return 0; } 630 static inline int devtmpfs_mount(const char *mountpoint) { return 0; } 631 #endif 632 633 /* drivers/base/power/shutdown.c */ 634 extern void device_shutdown(void); 635 636 /* drivers/base/sys.c */ 637 extern void sysdev_shutdown(void); 638 639 /* debugging and troubleshooting/diagnostic helpers. */ 640 extern const char *dev_driver_string(const struct device *dev); 641 #define dev_printk(level, dev, format, arg...) \ 642 printk(level "%s %s: " format , dev_driver_string(dev) , \ 643 dev_name(dev) , ## arg) 644 645 #define dev_emerg(dev, format, arg...) \ 646 dev_printk(KERN_EMERG , dev , format , ## arg) 647 #define dev_alert(dev, format, arg...) \ 648 dev_printk(KERN_ALERT , dev , format , ## arg) 649 #define dev_crit(dev, format, arg...) \ 650 dev_printk(KERN_CRIT , dev , format , ## arg) 651 #define dev_err(dev, format, arg...) \ 652 dev_printk(KERN_ERR , dev , format , ## arg) 653 #define dev_warn(dev, format, arg...) \ 654 dev_printk(KERN_WARNING , dev , format , ## arg) 655 #define dev_notice(dev, format, arg...) \ 656 dev_printk(KERN_NOTICE , dev , format , ## arg) 657 #define dev_info(dev, format, arg...) \ 658 dev_printk(KERN_INFO , dev , format , ## arg) 659 660 #if defined(DEBUG) 661 #define dev_dbg(dev, format, arg...) \ 662 dev_printk(KERN_DEBUG , dev , format , ## arg) 663 #elif defined(CONFIG_DYNAMIC_DEBUG) 664 #define dev_dbg(dev, format, ...) do { \ 665 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ 666 } while (0) 667 #else 668 #define dev_dbg(dev, format, arg...) \ 669 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; }) 670 #endif 671 672 #ifdef VERBOSE_DEBUG 673 #define dev_vdbg dev_dbg 674 #else 675 676 #define dev_vdbg(dev, format, arg...) \ 677 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; }) 678 #endif 679 680 /* 681 * dev_WARN() acts like dev_printk(), but with the key difference 682 * of using a WARN/WARN_ON to get the message out, including the 683 * file/line information and a backtrace. 684 */ 685 #define dev_WARN(dev, format, arg...) \ 686 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg); 687 688 /* Create alias, so I can be autoloaded. */ 689 #define MODULE_ALIAS_CHARDEV(major,minor) \ 690 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 691 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 692 MODULE_ALIAS("char-major-" __stringify(major) "-*") 693 #endif /* _DEVICE_H_ */ 694