1/* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org> 5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de> 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/mutex.h> 24#include <linux/pinctrl/devinfo.h> 25#include <linux/pm.h> 26#include <linux/atomic.h> 27#include <linux/ratelimit.h> 28#include <linux/uidgid.h> 29#include <linux/gfp.h> 30#include <asm/device.h> 31 32struct device; 33struct device_private; 34struct device_driver; 35struct driver_private; 36struct module; 37struct class; 38struct subsys_private; 39struct bus_type; 40struct device_node; 41struct fwnode_handle; 42struct iommu_ops; 43struct iommu_group; 44 45struct bus_attribute { 46 struct attribute attr; 47 ssize_t (*show)(struct bus_type *bus, char *buf); 48 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); 49}; 50 51#define BUS_ATTR(_name, _mode, _show, _store) \ 52 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) 53#define BUS_ATTR_RW(_name) \ 54 struct bus_attribute bus_attr_##_name = __ATTR_RW(_name) 55#define BUS_ATTR_RO(_name) \ 56 struct bus_attribute bus_attr_##_name = __ATTR_RO(_name) 57 58extern int __must_check bus_create_file(struct bus_type *, 59 struct bus_attribute *); 60extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 61 62/** 63 * struct bus_type - The bus type of the device 64 * 65 * @name: The name of the bus. 66 * @dev_name: Used for subsystems to enumerate devices like ("foo%u", dev->id). 67 * @dev_root: Default device to use as the parent. 68 * @dev_attrs: Default attributes of the devices on the bus. 69 * @bus_groups: Default attributes of the bus. 70 * @dev_groups: Default attributes of the devices on the bus. 71 * @drv_groups: Default attributes of the device drivers on the bus. 72 * @match: Called, perhaps multiple times, whenever a new device or driver 73 * is added for this bus. It should return a nonzero value if the 74 * given device can be handled by the given driver. 75 * @uevent: Called when a device is added, removed, or a few other things 76 * that generate uevents to add the environment variables. 77 * @probe: Called when a new device or driver add to this bus, and callback 78 * the specific driver's probe to initial the matched device. 79 * @remove: Called when a device removed from this bus. 80 * @shutdown: Called at shut-down time to quiesce the device. 81 * 82 * @online: Called to put the device back online (after offlining it). 83 * @offline: Called to put the device offline for hot-removal. May fail. 84 * 85 * @suspend: Called when a device on this bus wants to go to sleep mode. 86 * @resume: Called to bring a device on this bus out of sleep mode. 87 * @pm: Power management operations of this bus, callback the specific 88 * device driver's pm-ops. 89 * @iommu_ops: IOMMU specific operations for this bus, used to attach IOMMU 90 * driver implementations to a bus and allow the driver to do 91 * bus-specific setup 92 * @p: The private data of the driver core, only the driver core can 93 * touch this. 94 * @lock_key: Lock class key for use by the lock validator 95 * 96 * A bus is a channel between the processor and one or more devices. For the 97 * purposes of the device model, all devices are connected via a bus, even if 98 * it is an internal, virtual, "platform" bus. Buses can plug into each other. 99 * A USB controller is usually a PCI device, for example. The device model 100 * represents the actual connections between buses and the devices they control. 101 * A bus is represented by the bus_type structure. It contains the name, the 102 * default attributes, the bus' methods, PM operations, and the driver core's 103 * private data. 104 */ 105struct bus_type { 106 const char *name; 107 const char *dev_name; 108 struct device *dev_root; 109 struct device_attribute *dev_attrs; /* use dev_groups instead */ 110 const struct attribute_group **bus_groups; 111 const struct attribute_group **dev_groups; 112 const struct attribute_group **drv_groups; 113 114 int (*match)(struct device *dev, struct device_driver *drv); 115 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 116 int (*probe)(struct device *dev); 117 int (*remove)(struct device *dev); 118 void (*shutdown)(struct device *dev); 119 120 int (*online)(struct device *dev); 121 int (*offline)(struct device *dev); 122 123 int (*suspend)(struct device *dev, pm_message_t state); 124 int (*resume)(struct device *dev); 125 126 const struct dev_pm_ops *pm; 127 128 const struct iommu_ops *iommu_ops; 129 130 struct subsys_private *p; 131 struct lock_class_key lock_key; 132}; 133 134extern int __must_check bus_register(struct bus_type *bus); 135 136extern void bus_unregister(struct bus_type *bus); 137 138extern int __must_check bus_rescan_devices(struct bus_type *bus); 139 140/* iterator helpers for buses */ 141struct subsys_dev_iter { 142 struct klist_iter ki; 143 const struct device_type *type; 144}; 145void subsys_dev_iter_init(struct subsys_dev_iter *iter, 146 struct bus_type *subsys, 147 struct device *start, 148 const struct device_type *type); 149struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter); 150void subsys_dev_iter_exit(struct subsys_dev_iter *iter); 151 152int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, 153 int (*fn)(struct device *dev, void *data)); 154struct device *bus_find_device(struct bus_type *bus, struct device *start, 155 void *data, 156 int (*match)(struct device *dev, void *data)); 157struct device *bus_find_device_by_name(struct bus_type *bus, 158 struct device *start, 159 const char *name); 160struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id, 161 struct device *hint); 162int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 163 void *data, int (*fn)(struct device_driver *, void *)); 164void bus_sort_breadthfirst(struct bus_type *bus, 165 int (*compare)(const struct device *a, 166 const struct device *b)); 167/* 168 * Bus notifiers: Get notified of addition/removal of devices 169 * and binding/unbinding of drivers to devices. 170 * In the long run, it should be a replacement for the platform 171 * notify hooks. 172 */ 173struct notifier_block; 174 175extern int bus_register_notifier(struct bus_type *bus, 176 struct notifier_block *nb); 177extern int bus_unregister_notifier(struct bus_type *bus, 178 struct notifier_block *nb); 179 180/* All 4 notifers below get called with the target struct device * 181 * as an argument. Note that those functions are likely to be called 182 * with the device lock held in the core, so be careful. 183 */ 184#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 185#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device to be removed */ 186#define BUS_NOTIFY_REMOVED_DEVICE 0x00000003 /* device removed */ 187#define BUS_NOTIFY_BIND_DRIVER 0x00000004 /* driver about to be 188 bound */ 189#define BUS_NOTIFY_BOUND_DRIVER 0x00000005 /* driver bound to device */ 190#define BUS_NOTIFY_UNBIND_DRIVER 0x00000006 /* driver about to be 191 unbound */ 192#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000007 /* driver is unbound 193 from the device */ 194 195extern struct kset *bus_get_kset(struct bus_type *bus); 196extern struct klist *bus_get_device_klist(struct bus_type *bus); 197 198/** 199 * struct device_driver - The basic device driver structure 200 * @name: Name of the device driver. 201 * @bus: The bus which the device of this driver belongs to. 202 * @owner: The module owner. 203 * @mod_name: Used for built-in modules. 204 * @suppress_bind_attrs: Disables bind/unbind via sysfs. 205 * @of_match_table: The open firmware table. 206 * @acpi_match_table: The ACPI match table. 207 * @probe: Called to query the existence of a specific device, 208 * whether this driver can work with it, and bind the driver 209 * to a specific device. 210 * @remove: Called when the device is removed from the system to 211 * unbind a device from this driver. 212 * @shutdown: Called at shut-down time to quiesce the device. 213 * @suspend: Called to put the device to sleep mode. Usually to a 214 * low power state. 215 * @resume: Called to bring a device from sleep mode. 216 * @groups: Default attributes that get created by the driver core 217 * automatically. 218 * @pm: Power management operations of the device which matched 219 * this driver. 220 * @p: Driver core's private data, no one other than the driver 221 * core can touch this. 222 * 223 * The device driver-model tracks all of the drivers known to the system. 224 * The main reason for this tracking is to enable the driver core to match 225 * up drivers with new devices. Once drivers are known objects within the 226 * system, however, a number of other things become possible. Device drivers 227 * can export information and configuration variables that are independent 228 * of any specific device. 229 */ 230struct device_driver { 231 const char *name; 232 struct bus_type *bus; 233 234 struct module *owner; 235 const char *mod_name; /* used for built-in modules */ 236 237 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 238 239 const struct of_device_id *of_match_table; 240 const struct acpi_device_id *acpi_match_table; 241 242 int (*probe) (struct device *dev); 243 int (*remove) (struct device *dev); 244 void (*shutdown) (struct device *dev); 245 int (*suspend) (struct device *dev, pm_message_t state); 246 int (*resume) (struct device *dev); 247 const struct attribute_group **groups; 248 249 const struct dev_pm_ops *pm; 250 251 struct driver_private *p; 252}; 253 254 255extern int __must_check driver_register(struct device_driver *drv); 256extern void driver_unregister(struct device_driver *drv); 257 258extern struct device_driver *driver_find(const char *name, 259 struct bus_type *bus); 260extern int driver_probe_done(void); 261extern void wait_for_device_probe(void); 262 263 264/* sysfs interface for exporting driver attributes */ 265 266struct driver_attribute { 267 struct attribute attr; 268 ssize_t (*show)(struct device_driver *driver, char *buf); 269 ssize_t (*store)(struct device_driver *driver, const char *buf, 270 size_t count); 271}; 272 273#define DRIVER_ATTR(_name, _mode, _show, _store) \ 274 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store) 275#define DRIVER_ATTR_RW(_name) \ 276 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name) 277#define DRIVER_ATTR_RO(_name) \ 278 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name) 279#define DRIVER_ATTR_WO(_name) \ 280 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name) 281 282extern int __must_check driver_create_file(struct device_driver *driver, 283 const struct driver_attribute *attr); 284extern void driver_remove_file(struct device_driver *driver, 285 const struct driver_attribute *attr); 286 287extern int __must_check driver_for_each_device(struct device_driver *drv, 288 struct device *start, 289 void *data, 290 int (*fn)(struct device *dev, 291 void *)); 292struct device *driver_find_device(struct device_driver *drv, 293 struct device *start, void *data, 294 int (*match)(struct device *dev, void *data)); 295 296/** 297 * struct subsys_interface - interfaces to device functions 298 * @name: name of the device function 299 * @subsys: subsytem of the devices to attach to 300 * @node: the list of functions registered at the subsystem 301 * @add_dev: device hookup to device function handler 302 * @remove_dev: device hookup to device function handler 303 * 304 * Simple interfaces attached to a subsystem. Multiple interfaces can 305 * attach to a subsystem and its devices. Unlike drivers, they do not 306 * exclusively claim or control devices. Interfaces usually represent 307 * a specific functionality of a subsystem/class of devices. 308 */ 309struct subsys_interface { 310 const char *name; 311 struct bus_type *subsys; 312 struct list_head node; 313 int (*add_dev)(struct device *dev, struct subsys_interface *sif); 314 int (*remove_dev)(struct device *dev, struct subsys_interface *sif); 315}; 316 317int subsys_interface_register(struct subsys_interface *sif); 318void subsys_interface_unregister(struct subsys_interface *sif); 319 320int subsys_system_register(struct bus_type *subsys, 321 const struct attribute_group **groups); 322int subsys_virtual_register(struct bus_type *subsys, 323 const struct attribute_group **groups); 324 325/** 326 * struct class - device classes 327 * @name: Name of the class. 328 * @owner: The module owner. 329 * @class_attrs: Default attributes of this class. 330 * @dev_groups: Default attributes of the devices that belong to the class. 331 * @dev_kobj: The kobject that represents this class and links it into the hierarchy. 332 * @dev_uevent: Called when a device is added, removed from this class, or a 333 * few other things that generate uevents to add the environment 334 * variables. 335 * @devnode: Callback to provide the devtmpfs. 336 * @class_release: Called to release this class. 337 * @dev_release: Called to release the device. 338 * @suspend: Used to put the device to sleep mode, usually to a low power 339 * state. 340 * @resume: Used to bring the device from the sleep mode. 341 * @ns_type: Callbacks so sysfs can detemine namespaces. 342 * @namespace: Namespace of the device belongs to this class. 343 * @pm: The default device power management operations of this class. 344 * @p: The private data of the driver core, no one other than the 345 * driver core can touch this. 346 * 347 * A class is a higher-level view of a device that abstracts out low-level 348 * implementation details. Drivers may see a SCSI disk or an ATA disk, but, 349 * at the class level, they are all simply disks. Classes allow user space 350 * to work with devices based on what they do, rather than how they are 351 * connected or how they work. 352 */ 353struct class { 354 const char *name; 355 struct module *owner; 356 357 struct class_attribute *class_attrs; 358 const struct attribute_group **dev_groups; 359 struct kobject *dev_kobj; 360 361 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); 362 char *(*devnode)(struct device *dev, umode_t *mode); 363 364 void (*class_release)(struct class *class); 365 void (*dev_release)(struct device *dev); 366 367 int (*suspend)(struct device *dev, pm_message_t state); 368 int (*resume)(struct device *dev); 369 370 const struct kobj_ns_type_operations *ns_type; 371 const void *(*namespace)(struct device *dev); 372 373 const struct dev_pm_ops *pm; 374 375 struct subsys_private *p; 376}; 377 378struct class_dev_iter { 379 struct klist_iter ki; 380 const struct device_type *type; 381}; 382 383extern struct kobject *sysfs_dev_block_kobj; 384extern struct kobject *sysfs_dev_char_kobj; 385extern int __must_check __class_register(struct class *class, 386 struct lock_class_key *key); 387extern void class_unregister(struct class *class); 388 389/* This is a #define to keep the compiler from merging different 390 * instances of the __key variable */ 391#define class_register(class) \ 392({ \ 393 static struct lock_class_key __key; \ 394 __class_register(class, &__key); \ 395}) 396 397struct class_compat; 398struct class_compat *class_compat_register(const char *name); 399void class_compat_unregister(struct class_compat *cls); 400int class_compat_create_link(struct class_compat *cls, struct device *dev, 401 struct device *device_link); 402void class_compat_remove_link(struct class_compat *cls, struct device *dev, 403 struct device *device_link); 404 405extern void class_dev_iter_init(struct class_dev_iter *iter, 406 struct class *class, 407 struct device *start, 408 const struct device_type *type); 409extern struct device *class_dev_iter_next(struct class_dev_iter *iter); 410extern void class_dev_iter_exit(struct class_dev_iter *iter); 411 412extern int class_for_each_device(struct class *class, struct device *start, 413 void *data, 414 int (*fn)(struct device *dev, void *data)); 415extern struct device *class_find_device(struct class *class, 416 struct device *start, const void *data, 417 int (*match)(struct device *, const void *)); 418 419struct class_attribute { 420 struct attribute attr; 421 ssize_t (*show)(struct class *class, struct class_attribute *attr, 422 char *buf); 423 ssize_t (*store)(struct class *class, struct class_attribute *attr, 424 const char *buf, size_t count); 425}; 426 427#define CLASS_ATTR(_name, _mode, _show, _store) \ 428 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) 429#define CLASS_ATTR_RW(_name) \ 430 struct class_attribute class_attr_##_name = __ATTR_RW(_name) 431#define CLASS_ATTR_RO(_name) \ 432 struct class_attribute class_attr_##_name = __ATTR_RO(_name) 433 434extern int __must_check class_create_file_ns(struct class *class, 435 const struct class_attribute *attr, 436 const void *ns); 437extern void class_remove_file_ns(struct class *class, 438 const struct class_attribute *attr, 439 const void *ns); 440 441static inline int __must_check class_create_file(struct class *class, 442 const struct class_attribute *attr) 443{ 444 return class_create_file_ns(class, attr, NULL); 445} 446 447static inline void class_remove_file(struct class *class, 448 const struct class_attribute *attr) 449{ 450 return class_remove_file_ns(class, attr, NULL); 451} 452 453/* Simple class attribute that is just a static string */ 454struct class_attribute_string { 455 struct class_attribute attr; 456 char *str; 457}; 458 459/* Currently read-only only */ 460#define _CLASS_ATTR_STRING(_name, _mode, _str) \ 461 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } 462#define CLASS_ATTR_STRING(_name, _mode, _str) \ 463 struct class_attribute_string class_attr_##_name = \ 464 _CLASS_ATTR_STRING(_name, _mode, _str) 465 466extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 467 char *buf); 468 469struct class_interface { 470 struct list_head node; 471 struct class *class; 472 473 int (*add_dev) (struct device *, struct class_interface *); 474 void (*remove_dev) (struct device *, struct class_interface *); 475}; 476 477extern int __must_check class_interface_register(struct class_interface *); 478extern void class_interface_unregister(struct class_interface *); 479 480extern struct class * __must_check __class_create(struct module *owner, 481 const char *name, 482 struct lock_class_key *key); 483extern void class_destroy(struct class *cls); 484 485/* This is a #define to keep the compiler from merging different 486 * instances of the __key variable */ 487#define class_create(owner, name) \ 488({ \ 489 static struct lock_class_key __key; \ 490 __class_create(owner, name, &__key); \ 491}) 492 493/* 494 * The type of device, "struct device" is embedded in. A class 495 * or bus can contain devices of different types 496 * like "partitions" and "disks", "mouse" and "event". 497 * This identifies the device type and carries type-specific 498 * information, equivalent to the kobj_type of a kobject. 499 * If "name" is specified, the uevent will contain it in 500 * the DEVTYPE variable. 501 */ 502struct device_type { 503 const char *name; 504 const struct attribute_group **groups; 505 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 506 char *(*devnode)(struct device *dev, umode_t *mode, 507 kuid_t *uid, kgid_t *gid); 508 void (*release)(struct device *dev); 509 510 const struct dev_pm_ops *pm; 511}; 512 513/* interface for exporting device attributes */ 514struct device_attribute { 515 struct attribute attr; 516 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 517 char *buf); 518 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 519 const char *buf, size_t count); 520}; 521 522struct dev_ext_attribute { 523 struct device_attribute attr; 524 void *var; 525}; 526 527ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr, 528 char *buf); 529ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr, 530 const char *buf, size_t count); 531ssize_t device_show_int(struct device *dev, struct device_attribute *attr, 532 char *buf); 533ssize_t device_store_int(struct device *dev, struct device_attribute *attr, 534 const char *buf, size_t count); 535ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 536 char *buf); 537ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 538 const char *buf, size_t count); 539 540#define DEVICE_ATTR(_name, _mode, _show, _store) \ 541 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 542#define DEVICE_ATTR_RW(_name) \ 543 struct device_attribute dev_attr_##_name = __ATTR_RW(_name) 544#define DEVICE_ATTR_RO(_name) \ 545 struct device_attribute dev_attr_##_name = __ATTR_RO(_name) 546#define DEVICE_ATTR_WO(_name) \ 547 struct device_attribute dev_attr_##_name = __ATTR_WO(_name) 548#define DEVICE_ULONG_ATTR(_name, _mode, _var) \ 549 struct dev_ext_attribute dev_attr_##_name = \ 550 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } 551#define DEVICE_INT_ATTR(_name, _mode, _var) \ 552 struct dev_ext_attribute dev_attr_##_name = \ 553 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) } 554#define DEVICE_BOOL_ATTR(_name, _mode, _var) \ 555 struct dev_ext_attribute dev_attr_##_name = \ 556 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) } 557#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \ 558 struct device_attribute dev_attr_##_name = \ 559 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) 560 561extern int device_create_file(struct device *device, 562 const struct device_attribute *entry); 563extern void device_remove_file(struct device *dev, 564 const struct device_attribute *attr); 565extern bool device_remove_file_self(struct device *dev, 566 const struct device_attribute *attr); 567extern int __must_check device_create_bin_file(struct device *dev, 568 const struct bin_attribute *attr); 569extern void device_remove_bin_file(struct device *dev, 570 const struct bin_attribute *attr); 571 572/* device resource management */ 573typedef void (*dr_release_t)(struct device *dev, void *res); 574typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 575 576#ifdef CONFIG_DEBUG_DEVRES 577extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 578 const char *name); 579#define devres_alloc(release, size, gfp) \ 580 __devres_alloc(release, size, gfp, #release) 581#else 582extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 583#endif 584extern void devres_for_each_res(struct device *dev, dr_release_t release, 585 dr_match_t match, void *match_data, 586 void (*fn)(struct device *, void *, void *), 587 void *data); 588extern void devres_free(void *res); 589extern void devres_add(struct device *dev, void *res); 590extern void *devres_find(struct device *dev, dr_release_t release, 591 dr_match_t match, void *match_data); 592extern void *devres_get(struct device *dev, void *new_res, 593 dr_match_t match, void *match_data); 594extern void *devres_remove(struct device *dev, dr_release_t release, 595 dr_match_t match, void *match_data); 596extern int devres_destroy(struct device *dev, dr_release_t release, 597 dr_match_t match, void *match_data); 598extern int devres_release(struct device *dev, dr_release_t release, 599 dr_match_t match, void *match_data); 600 601/* devres group */ 602extern void * __must_check devres_open_group(struct device *dev, void *id, 603 gfp_t gfp); 604extern void devres_close_group(struct device *dev, void *id); 605extern void devres_remove_group(struct device *dev, void *id); 606extern int devres_release_group(struct device *dev, void *id); 607 608/* managed devm_k.alloc/kfree for device drivers */ 609extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp); 610extern char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt, 611 va_list ap); 612extern __printf(3, 4) 613char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...); 614static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp) 615{ 616 return devm_kmalloc(dev, size, gfp | __GFP_ZERO); 617} 618static inline void *devm_kmalloc_array(struct device *dev, 619 size_t n, size_t size, gfp_t flags) 620{ 621 if (size != 0 && n > SIZE_MAX / size) 622 return NULL; 623 return devm_kmalloc(dev, n * size, flags); 624} 625static inline void *devm_kcalloc(struct device *dev, 626 size_t n, size_t size, gfp_t flags) 627{ 628 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); 629} 630extern void devm_kfree(struct device *dev, void *p); 631extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp); 632extern void *devm_kmemdup(struct device *dev, const void *src, size_t len, 633 gfp_t gfp); 634 635extern unsigned long devm_get_free_pages(struct device *dev, 636 gfp_t gfp_mask, unsigned int order); 637extern void devm_free_pages(struct device *dev, unsigned long addr); 638 639void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); 640 641/* allows to add/remove a custom action to devres stack */ 642int devm_add_action(struct device *dev, void (*action)(void *), void *data); 643void devm_remove_action(struct device *dev, void (*action)(void *), void *data); 644 645struct device_dma_parameters { 646 /* 647 * a low level driver may set these to teach IOMMU code about 648 * sg limitations. 649 */ 650 unsigned int max_segment_size; 651 unsigned long segment_boundary_mask; 652}; 653 654/** 655 * struct device - The basic device structure 656 * @parent: The device's "parent" device, the device to which it is attached. 657 * In most cases, a parent device is some sort of bus or host 658 * controller. If parent is NULL, the device, is a top-level device, 659 * which is not usually what you want. 660 * @p: Holds the private data of the driver core portions of the device. 661 * See the comment of the struct device_private for detail. 662 * @kobj: A top-level, abstract class from which other classes are derived. 663 * @init_name: Initial name of the device. 664 * @type: The type of device. 665 * This identifies the device type and carries type-specific 666 * information. 667 * @mutex: Mutex to synchronize calls to its driver. 668 * @bus: Type of bus device is on. 669 * @driver: Which driver has allocated this 670 * @platform_data: Platform data specific to the device. 671 * Example: For devices on custom boards, as typical of embedded 672 * and SOC based hardware, Linux often uses platform_data to point 673 * to board-specific structures describing devices and how they 674 * are wired. That can include what ports are available, chip 675 * variants, which GPIO pins act in what additional roles, and so 676 * on. This shrinks the "Board Support Packages" (BSPs) and 677 * minimizes board-specific #ifdefs in drivers. 678 * @driver_data: Private pointer for driver specific info. 679 * @power: For device power management. 680 * See Documentation/power/devices.txt for details. 681 * @pm_domain: Provide callbacks that are executed during system suspend, 682 * hibernation, system resume and during runtime PM transitions 683 * along with subsystem-level and driver-level callbacks. 684 * @pins: For device pin management. 685 * See Documentation/pinctrl.txt for details. 686 * @numa_node: NUMA node this device is close to. 687 * @dma_mask: Dma mask (if dma'ble device). 688 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all 689 * hardware supports 64-bit addresses for consistent allocations 690 * such descriptors. 691 * @dma_pfn_offset: offset of DMA memory range relatively of RAM 692 * @dma_parms: A low level driver may set these to teach IOMMU code about 693 * segment limitations. 694 * @dma_pools: Dma pools (if dma'ble device). 695 * @dma_mem: Internal for coherent mem override. 696 * @cma_area: Contiguous memory area for dma allocations 697 * @archdata: For arch-specific additions. 698 * @of_node: Associated device tree node. 699 * @fwnode: Associated device node supplied by platform firmware. 700 * @devt: For creating the sysfs "dev". 701 * @id: device instance 702 * @devres_lock: Spinlock to protect the resource of the device. 703 * @devres_head: The resources list of the device. 704 * @knode_class: The node used to add the device to the class list. 705 * @class: The class of the device. 706 * @groups: Optional attribute groups. 707 * @release: Callback to free the device after all references have 708 * gone away. This should be set by the allocator of the 709 * device (i.e. the bus driver that discovered the device). 710 * @iommu_group: IOMMU group the device belongs to. 711 * 712 * @offline_disabled: If set, the device is permanently online. 713 * @offline: Set after successful invocation of bus type's .offline(). 714 * 715 * At the lowest level, every device in a Linux system is represented by an 716 * instance of struct device. The device structure contains the information 717 * that the device model core needs to model the system. Most subsystems, 718 * however, track additional information about the devices they host. As a 719 * result, it is rare for devices to be represented by bare device structures; 720 * instead, that structure, like kobject structures, is usually embedded within 721 * a higher-level representation of the device. 722 */ 723struct device { 724 struct device *parent; 725 726 struct device_private *p; 727 728 struct kobject kobj; 729 const char *init_name; /* initial name of the device */ 730 const struct device_type *type; 731 732 struct mutex mutex; /* mutex to synchronize calls to 733 * its driver. 734 */ 735 736 struct bus_type *bus; /* type of bus device is on */ 737 struct device_driver *driver; /* which driver has allocated this 738 device */ 739 void *platform_data; /* Platform specific data, device 740 core doesn't touch it */ 741 void *driver_data; /* Driver data, set and get with 742 dev_set/get_drvdata */ 743 struct dev_pm_info power; 744 struct dev_pm_domain *pm_domain; 745 746#ifdef CONFIG_PINCTRL 747 struct dev_pin_info *pins; 748#endif 749 750#ifdef CONFIG_NUMA 751 int numa_node; /* NUMA node this device is close to */ 752#endif 753 u64 *dma_mask; /* dma mask (if dma'able device) */ 754 u64 coherent_dma_mask;/* Like dma_mask, but for 755 alloc_coherent mappings as 756 not all hardware supports 757 64 bit addresses for consistent 758 allocations such descriptors. */ 759 unsigned long dma_pfn_offset; 760 761 struct device_dma_parameters *dma_parms; 762 763 struct list_head dma_pools; /* dma pools (if dma'ble) */ 764 765 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 766 override */ 767#ifdef CONFIG_DMA_CMA 768 struct cma *cma_area; /* contiguous memory area for dma 769 allocations */ 770#endif 771 /* arch specific additions */ 772 struct dev_archdata archdata; 773 774 struct device_node *of_node; /* associated device tree node */ 775 struct fwnode_handle *fwnode; /* firmware device node */ 776 777 dev_t devt; /* dev_t, creates the sysfs "dev" */ 778 u32 id; /* device instance */ 779 780 spinlock_t devres_lock; 781 struct list_head devres_head; 782 783 struct klist_node knode_class; 784 struct class *class; 785 const struct attribute_group **groups; /* optional groups */ 786 787 void (*release)(struct device *dev); 788 struct iommu_group *iommu_group; 789 790 bool offline_disabled:1; 791 bool offline:1; 792}; 793 794static inline struct device *kobj_to_dev(struct kobject *kobj) 795{ 796 return container_of(kobj, struct device, kobj); 797} 798 799/* Get the wakeup routines, which depend on struct device */ 800#include <linux/pm_wakeup.h> 801 802static inline const char *dev_name(const struct device *dev) 803{ 804 /* Use the init name until the kobject becomes available */ 805 if (dev->init_name) 806 return dev->init_name; 807 808 return kobject_name(&dev->kobj); 809} 810 811extern __printf(2, 3) 812int dev_set_name(struct device *dev, const char *name, ...); 813 814#ifdef CONFIG_NUMA 815static inline int dev_to_node(struct device *dev) 816{ 817 return dev->numa_node; 818} 819static inline void set_dev_node(struct device *dev, int node) 820{ 821 dev->numa_node = node; 822} 823#else 824static inline int dev_to_node(struct device *dev) 825{ 826 return -1; 827} 828static inline void set_dev_node(struct device *dev, int node) 829{ 830} 831#endif 832 833static inline void *dev_get_drvdata(const struct device *dev) 834{ 835 return dev->driver_data; 836} 837 838static inline void dev_set_drvdata(struct device *dev, void *data) 839{ 840 dev->driver_data = data; 841} 842 843static inline struct pm_subsys_data *dev_to_psd(struct device *dev) 844{ 845 return dev ? dev->power.subsys_data : NULL; 846} 847 848static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 849{ 850 return dev->kobj.uevent_suppress; 851} 852 853static inline void dev_set_uevent_suppress(struct device *dev, int val) 854{ 855 dev->kobj.uevent_suppress = val; 856} 857 858static inline int device_is_registered(struct device *dev) 859{ 860 return dev->kobj.state_in_sysfs; 861} 862 863static inline void device_enable_async_suspend(struct device *dev) 864{ 865 if (!dev->power.is_prepared) 866 dev->power.async_suspend = true; 867} 868 869static inline void device_disable_async_suspend(struct device *dev) 870{ 871 if (!dev->power.is_prepared) 872 dev->power.async_suspend = false; 873} 874 875static inline bool device_async_suspend_enabled(struct device *dev) 876{ 877 return !!dev->power.async_suspend; 878} 879 880static inline void pm_suspend_ignore_children(struct device *dev, bool enable) 881{ 882 dev->power.ignore_children = enable; 883} 884 885static inline void dev_pm_syscore_device(struct device *dev, bool val) 886{ 887#ifdef CONFIG_PM_SLEEP 888 dev->power.syscore = val; 889#endif 890} 891 892static inline void device_lock(struct device *dev) 893{ 894 mutex_lock(&dev->mutex); 895} 896 897static inline int device_trylock(struct device *dev) 898{ 899 return mutex_trylock(&dev->mutex); 900} 901 902static inline void device_unlock(struct device *dev) 903{ 904 mutex_unlock(&dev->mutex); 905} 906 907static inline void device_lock_assert(struct device *dev) 908{ 909 lockdep_assert_held(&dev->mutex); 910} 911 912static inline struct device_node *dev_of_node(struct device *dev) 913{ 914 if (!IS_ENABLED(CONFIG_OF)) 915 return NULL; 916 return dev->of_node; 917} 918 919void driver_init(void); 920 921/* 922 * High level routines for use by the bus drivers 923 */ 924extern int __must_check device_register(struct device *dev); 925extern void device_unregister(struct device *dev); 926extern void device_initialize(struct device *dev); 927extern int __must_check device_add(struct device *dev); 928extern void device_del(struct device *dev); 929extern int device_for_each_child(struct device *dev, void *data, 930 int (*fn)(struct device *dev, void *data)); 931extern struct device *device_find_child(struct device *dev, void *data, 932 int (*match)(struct device *dev, void *data)); 933extern int device_rename(struct device *dev, const char *new_name); 934extern int device_move(struct device *dev, struct device *new_parent, 935 enum dpm_order dpm_order); 936extern const char *device_get_devnode(struct device *dev, 937 umode_t *mode, kuid_t *uid, kgid_t *gid, 938 const char **tmp); 939 940static inline bool device_supports_offline(struct device *dev) 941{ 942 return dev->bus && dev->bus->offline && dev->bus->online; 943} 944 945extern void lock_device_hotplug(void); 946extern void unlock_device_hotplug(void); 947extern int lock_device_hotplug_sysfs(void); 948extern int device_offline(struct device *dev); 949extern int device_online(struct device *dev); 950extern void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode); 951extern void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode); 952 953/* 954 * Root device objects for grouping under /sys/devices 955 */ 956extern struct device *__root_device_register(const char *name, 957 struct module *owner); 958 959/* This is a macro to avoid include problems with THIS_MODULE */ 960#define root_device_register(name) \ 961 __root_device_register(name, THIS_MODULE) 962 963extern void root_device_unregister(struct device *root); 964 965static inline void *dev_get_platdata(const struct device *dev) 966{ 967 return dev->platform_data; 968} 969 970/* 971 * Manual binding of a device to driver. See drivers/base/bus.c 972 * for information on use. 973 */ 974extern int __must_check device_bind_driver(struct device *dev); 975extern void device_release_driver(struct device *dev); 976extern int __must_check device_attach(struct device *dev); 977extern int __must_check driver_attach(struct device_driver *drv); 978extern int __must_check device_reprobe(struct device *dev); 979 980/* 981 * Easy functions for dynamically creating devices on the fly 982 */ 983extern struct device *device_create_vargs(struct class *cls, 984 struct device *parent, 985 dev_t devt, 986 void *drvdata, 987 const char *fmt, 988 va_list vargs); 989extern __printf(5, 6) 990struct device *device_create(struct class *cls, struct device *parent, 991 dev_t devt, void *drvdata, 992 const char *fmt, ...); 993extern __printf(6, 7) 994struct device *device_create_with_groups(struct class *cls, 995 struct device *parent, dev_t devt, void *drvdata, 996 const struct attribute_group **groups, 997 const char *fmt, ...); 998extern void device_destroy(struct class *cls, dev_t devt); 999 1000/* 1001 * Platform "fixup" functions - allow the platform to have their say 1002 * about devices and actions that the general device layer doesn't 1003 * know about. 1004 */ 1005/* Notify platform of device discovery */ 1006extern int (*platform_notify)(struct device *dev); 1007 1008extern int (*platform_notify_remove)(struct device *dev); 1009 1010 1011/* 1012 * get_device - atomically increment the reference count for the device. 1013 * 1014 */ 1015extern struct device *get_device(struct device *dev); 1016extern void put_device(struct device *dev); 1017 1018#ifdef CONFIG_DEVTMPFS 1019extern int devtmpfs_create_node(struct device *dev); 1020extern int devtmpfs_delete_node(struct device *dev); 1021extern int devtmpfs_mount(const char *mntdir); 1022#else 1023static inline int devtmpfs_create_node(struct device *dev) { return 0; } 1024static inline int devtmpfs_delete_node(struct device *dev) { return 0; } 1025static inline int devtmpfs_mount(const char *mountpoint) { return 0; } 1026#endif 1027 1028/* drivers/base/power/shutdown.c */ 1029extern void device_shutdown(void); 1030 1031/* debugging and troubleshooting/diagnostic helpers. */ 1032extern const char *dev_driver_string(const struct device *dev); 1033 1034 1035#ifdef CONFIG_PRINTK 1036 1037extern __printf(3, 0) 1038int dev_vprintk_emit(int level, const struct device *dev, 1039 const char *fmt, va_list args); 1040extern __printf(3, 4) 1041int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...); 1042 1043extern __printf(3, 4) 1044void dev_printk(const char *level, const struct device *dev, 1045 const char *fmt, ...); 1046extern __printf(2, 3) 1047void dev_emerg(const struct device *dev, const char *fmt, ...); 1048extern __printf(2, 3) 1049void dev_alert(const struct device *dev, const char *fmt, ...); 1050extern __printf(2, 3) 1051void dev_crit(const struct device *dev, const char *fmt, ...); 1052extern __printf(2, 3) 1053void dev_err(const struct device *dev, const char *fmt, ...); 1054extern __printf(2, 3) 1055void dev_warn(const struct device *dev, const char *fmt, ...); 1056extern __printf(2, 3) 1057void dev_notice(const struct device *dev, const char *fmt, ...); 1058extern __printf(2, 3) 1059void _dev_info(const struct device *dev, const char *fmt, ...); 1060 1061#else 1062 1063static inline __printf(3, 0) 1064int dev_vprintk_emit(int level, const struct device *dev, 1065 const char *fmt, va_list args) 1066{ return 0; } 1067static inline __printf(3, 4) 1068int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 1069{ return 0; } 1070 1071static inline void __dev_printk(const char *level, const struct device *dev, 1072 struct va_format *vaf) 1073{} 1074static inline __printf(3, 4) 1075void dev_printk(const char *level, const struct device *dev, 1076 const char *fmt, ...) 1077{} 1078 1079static inline __printf(2, 3) 1080void dev_emerg(const struct device *dev, const char *fmt, ...) 1081{} 1082static inline __printf(2, 3) 1083void dev_crit(const struct device *dev, const char *fmt, ...) 1084{} 1085static inline __printf(2, 3) 1086void dev_alert(const struct device *dev, const char *fmt, ...) 1087{} 1088static inline __printf(2, 3) 1089void dev_err(const struct device *dev, const char *fmt, ...) 1090{} 1091static inline __printf(2, 3) 1092void dev_warn(const struct device *dev, const char *fmt, ...) 1093{} 1094static inline __printf(2, 3) 1095void dev_notice(const struct device *dev, const char *fmt, ...) 1096{} 1097static inline __printf(2, 3) 1098void _dev_info(const struct device *dev, const char *fmt, ...) 1099{} 1100 1101#endif 1102 1103/* 1104 * Stupid hackaround for existing uses of non-printk uses dev_info 1105 * 1106 * Note that the definition of dev_info below is actually _dev_info 1107 * and a macro is used to avoid redefining dev_info 1108 */ 1109 1110#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg) 1111 1112#if defined(CONFIG_DYNAMIC_DEBUG) 1113#define dev_dbg(dev, format, ...) \ 1114do { \ 1115 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ 1116} while (0) 1117#elif defined(DEBUG) 1118#define dev_dbg(dev, format, arg...) \ 1119 dev_printk(KERN_DEBUG, dev, format, ##arg) 1120#else 1121#define dev_dbg(dev, format, arg...) \ 1122({ \ 1123 if (0) \ 1124 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 1125}) 1126#endif 1127 1128#ifdef CONFIG_PRINTK 1129#define dev_level_once(dev_level, dev, fmt, ...) \ 1130do { \ 1131 static bool __print_once __read_mostly; \ 1132 \ 1133 if (!__print_once) { \ 1134 __print_once = true; \ 1135 dev_level(dev, fmt, ##__VA_ARGS__); \ 1136 } \ 1137} while (0) 1138#else 1139#define dev_level_once(dev_level, dev, fmt, ...) \ 1140do { \ 1141 if (0) \ 1142 dev_level(dev, fmt, ##__VA_ARGS__); \ 1143} while (0) 1144#endif 1145 1146#define dev_emerg_once(dev, fmt, ...) \ 1147 dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__) 1148#define dev_alert_once(dev, fmt, ...) \ 1149 dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__) 1150#define dev_crit_once(dev, fmt, ...) \ 1151 dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__) 1152#define dev_err_once(dev, fmt, ...) \ 1153 dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__) 1154#define dev_warn_once(dev, fmt, ...) \ 1155 dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__) 1156#define dev_notice_once(dev, fmt, ...) \ 1157 dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__) 1158#define dev_info_once(dev, fmt, ...) \ 1159 dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__) 1160#define dev_dbg_once(dev, fmt, ...) \ 1161 dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__) 1162 1163#define dev_level_ratelimited(dev_level, dev, fmt, ...) \ 1164do { \ 1165 static DEFINE_RATELIMIT_STATE(_rs, \ 1166 DEFAULT_RATELIMIT_INTERVAL, \ 1167 DEFAULT_RATELIMIT_BURST); \ 1168 if (__ratelimit(&_rs)) \ 1169 dev_level(dev, fmt, ##__VA_ARGS__); \ 1170} while (0) 1171 1172#define dev_emerg_ratelimited(dev, fmt, ...) \ 1173 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__) 1174#define dev_alert_ratelimited(dev, fmt, ...) \ 1175 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__) 1176#define dev_crit_ratelimited(dev, fmt, ...) \ 1177 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__) 1178#define dev_err_ratelimited(dev, fmt, ...) \ 1179 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__) 1180#define dev_warn_ratelimited(dev, fmt, ...) \ 1181 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__) 1182#define dev_notice_ratelimited(dev, fmt, ...) \ 1183 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__) 1184#define dev_info_ratelimited(dev, fmt, ...) \ 1185 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__) 1186#if defined(CONFIG_DYNAMIC_DEBUG) 1187/* descriptor check is first to prevent flooding with "callbacks suppressed" */ 1188#define dev_dbg_ratelimited(dev, fmt, ...) \ 1189do { \ 1190 static DEFINE_RATELIMIT_STATE(_rs, \ 1191 DEFAULT_RATELIMIT_INTERVAL, \ 1192 DEFAULT_RATELIMIT_BURST); \ 1193 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \ 1194 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \ 1195 __ratelimit(&_rs)) \ 1196 __dynamic_dev_dbg(&descriptor, dev, fmt, \ 1197 ##__VA_ARGS__); \ 1198} while (0) 1199#elif defined(DEBUG) 1200#define dev_dbg_ratelimited(dev, fmt, ...) \ 1201do { \ 1202 static DEFINE_RATELIMIT_STATE(_rs, \ 1203 DEFAULT_RATELIMIT_INTERVAL, \ 1204 DEFAULT_RATELIMIT_BURST); \ 1205 if (__ratelimit(&_rs)) \ 1206 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \ 1207} while (0) 1208#else 1209#define dev_dbg_ratelimited(dev, fmt, ...) \ 1210 no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) 1211#endif 1212 1213#ifdef VERBOSE_DEBUG 1214#define dev_vdbg dev_dbg 1215#else 1216#define dev_vdbg(dev, format, arg...) \ 1217({ \ 1218 if (0) \ 1219 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 1220}) 1221#endif 1222 1223/* 1224 * dev_WARN*() acts like dev_printk(), but with the key difference of 1225 * using WARN/WARN_ONCE to include file/line information and a backtrace. 1226 */ 1227#define dev_WARN(dev, format, arg...) \ 1228 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg); 1229 1230#define dev_WARN_ONCE(dev, condition, format, arg...) \ 1231 WARN_ONCE(condition, "%s %s: " format, \ 1232 dev_driver_string(dev), dev_name(dev), ## arg) 1233 1234/* Create alias, so I can be autoloaded. */ 1235#define MODULE_ALIAS_CHARDEV(major,minor) \ 1236 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 1237#define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 1238 MODULE_ALIAS("char-major-" __stringify(major) "-*") 1239 1240#ifdef CONFIG_SYSFS_DEPRECATED 1241extern long sysfs_deprecated; 1242#else 1243#define sysfs_deprecated 0 1244#endif 1245 1246/** 1247 * module_driver() - Helper macro for drivers that don't do anything 1248 * special in module init/exit. This eliminates a lot of boilerplate. 1249 * Each module may only use this macro once, and calling it replaces 1250 * module_init() and module_exit(). 1251 * 1252 * @__driver: driver name 1253 * @__register: register function for this driver type 1254 * @__unregister: unregister function for this driver type 1255 * @...: Additional arguments to be passed to __register and __unregister. 1256 * 1257 * Use this macro to construct bus specific macros for registering 1258 * drivers, and do not use it on its own. 1259 */ 1260#define module_driver(__driver, __register, __unregister, ...) \ 1261static int __init __driver##_init(void) \ 1262{ \ 1263 return __register(&(__driver) , ##__VA_ARGS__); \ 1264} \ 1265module_init(__driver##_init); \ 1266static void __exit __driver##_exit(void) \ 1267{ \ 1268 __unregister(&(__driver) , ##__VA_ARGS__); \ 1269} \ 1270module_exit(__driver##_exit); 1271 1272#endif /* _DEVICE_H_ */ 1273