1 /* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <[email protected]> 5 * 6 * This file is released under the GPLv2 7 * 8 * See Documentation/driver-model/ for more information. 9 */ 10 11 #ifndef _DEVICE_H_ 12 #define _DEVICE_H_ 13 14 #include <linux/config.h> 15 #include <linux/ioport.h> 16 #include <linux/kobject.h> 17 #include <linux/klist.h> 18 #include <linux/list.h> 19 #include <linux/types.h> 20 #include <linux/module.h> 21 #include <linux/pm.h> 22 #include <asm/semaphore.h> 23 #include <asm/atomic.h> 24 25 #define DEVICE_NAME_SIZE 50 26 #define DEVICE_NAME_HALF __stringify(20) /* Less than half to accommodate slop */ 27 #define DEVICE_ID_SIZE 32 28 #define BUS_ID_SIZE KOBJ_NAME_LEN 29 30 31 struct device; 32 struct device_driver; 33 struct class; 34 struct class_device; 35 36 struct bus_type { 37 const char * name; 38 39 struct subsystem subsys; 40 struct kset drivers; 41 struct kset devices; 42 struct klist klist_devices; 43 struct klist klist_drivers; 44 45 struct bus_attribute * bus_attrs; 46 struct device_attribute * dev_attrs; 47 struct driver_attribute * drv_attrs; 48 49 int (*match)(struct device * dev, struct device_driver * drv); 50 int (*uevent)(struct device *dev, char **envp, 51 int num_envp, char *buffer, int buffer_size); 52 int (*probe)(struct device * dev); 53 int (*remove)(struct device * dev); 54 void (*shutdown)(struct device * dev); 55 int (*suspend)(struct device * dev, pm_message_t state); 56 int (*resume)(struct device * dev); 57 }; 58 59 extern int bus_register(struct bus_type * bus); 60 extern void bus_unregister(struct bus_type * bus); 61 62 extern void bus_rescan_devices(struct bus_type * bus); 63 64 extern struct bus_type * get_bus(struct bus_type * bus); 65 extern void put_bus(struct bus_type * bus); 66 67 extern struct bus_type * find_bus(char * name); 68 69 /* iterator helpers for buses */ 70 71 int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data, 72 int (*fn)(struct device *, void *)); 73 struct device * bus_find_device(struct bus_type *bus, struct device *start, 74 void *data, int (*match)(struct device *, void *)); 75 76 int bus_for_each_drv(struct bus_type * bus, struct device_driver * start, 77 void * data, int (*fn)(struct device_driver *, void *)); 78 79 80 /* driverfs interface for exporting bus attributes */ 81 82 struct bus_attribute { 83 struct attribute attr; 84 ssize_t (*show)(struct bus_type *, char * buf); 85 ssize_t (*store)(struct bus_type *, const char * buf, size_t count); 86 }; 87 88 #define BUS_ATTR(_name,_mode,_show,_store) \ 89 struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store) 90 91 extern int bus_create_file(struct bus_type *, struct bus_attribute *); 92 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 93 94 struct device_driver { 95 const char * name; 96 struct bus_type * bus; 97 98 struct completion unloaded; 99 struct kobject kobj; 100 struct klist klist_devices; 101 struct klist_node knode_bus; 102 103 struct module * owner; 104 105 int (*probe) (struct device * dev); 106 int (*remove) (struct device * dev); 107 void (*shutdown) (struct device * dev); 108 int (*suspend) (struct device * dev, pm_message_t state); 109 int (*resume) (struct device * dev); 110 }; 111 112 113 extern int driver_register(struct device_driver * drv); 114 extern void driver_unregister(struct device_driver * drv); 115 116 extern struct device_driver * get_driver(struct device_driver * drv); 117 extern void put_driver(struct device_driver * drv); 118 extern struct device_driver *driver_find(const char *name, struct bus_type *bus); 119 120 121 /* driverfs interface for exporting driver attributes */ 122 123 struct driver_attribute { 124 struct attribute attr; 125 ssize_t (*show)(struct device_driver *, char * buf); 126 ssize_t (*store)(struct device_driver *, const char * buf, size_t count); 127 }; 128 129 #define DRIVER_ATTR(_name,_mode,_show,_store) \ 130 struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store) 131 132 extern int driver_create_file(struct device_driver *, struct driver_attribute *); 133 extern void driver_remove_file(struct device_driver *, struct driver_attribute *); 134 135 extern int driver_for_each_device(struct device_driver * drv, struct device * start, 136 void * data, int (*fn)(struct device *, void *)); 137 struct device * driver_find_device(struct device_driver *drv, 138 struct device *start, void *data, 139 int (*match)(struct device *, void *)); 140 141 142 /* 143 * device classes 144 */ 145 struct class { 146 const char * name; 147 struct module * owner; 148 149 struct subsystem subsys; 150 struct list_head children; 151 struct list_head interfaces; 152 struct semaphore sem; /* locks both the children and interfaces lists */ 153 154 struct class_attribute * class_attrs; 155 struct class_device_attribute * class_dev_attrs; 156 157 int (*uevent)(struct class_device *dev, char **envp, 158 int num_envp, char *buffer, int buffer_size); 159 160 void (*release)(struct class_device *dev); 161 void (*class_release)(struct class *class); 162 }; 163 164 extern int class_register(struct class *); 165 extern void class_unregister(struct class *); 166 167 extern struct class * class_get(struct class *); 168 extern void class_put(struct class *); 169 170 171 struct class_attribute { 172 struct attribute attr; 173 ssize_t (*show)(struct class *, char * buf); 174 ssize_t (*store)(struct class *, const char * buf, size_t count); 175 }; 176 177 #define CLASS_ATTR(_name,_mode,_show,_store) \ 178 struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store) 179 180 extern int class_create_file(struct class *, const struct class_attribute *); 181 extern void class_remove_file(struct class *, const struct class_attribute *); 182 183 struct class_device_attribute { 184 struct attribute attr; 185 ssize_t (*show)(struct class_device *, char * buf); 186 ssize_t (*store)(struct class_device *, const char * buf, size_t count); 187 }; 188 189 #define CLASS_DEVICE_ATTR(_name,_mode,_show,_store) \ 190 struct class_device_attribute class_device_attr_##_name = \ 191 __ATTR(_name,_mode,_show,_store) 192 193 extern int class_device_create_file(struct class_device *, 194 const struct class_device_attribute *); 195 196 /** 197 * struct class_device - class devices 198 * @class: pointer to the parent class for this class device. This is required. 199 * @devt: for internal use by the driver core only. 200 * @node: for internal use by the driver core only. 201 * @kobj: for internal use by the driver core only. 202 * @devt_attr: for internal use by the driver core only. 203 * @dev: if set, a symlink to the struct device is created in the sysfs 204 * directory for this struct class device. 205 * @class_data: pointer to whatever you want to store here for this struct 206 * class_device. Use class_get_devdata() and class_set_devdata() to get and 207 * set this pointer. 208 * @parent: pointer to a struct class_device that is the parent of this struct 209 * class_device. If NULL, this class_device will show up at the root of the 210 * struct class in sysfs (which is probably what you want to have happen.) 211 * @release: pointer to a release function for this struct class_device. If 212 * set, this will be called instead of the class specific release function. 213 * Only use this if you want to override the default release function, like 214 * when you are nesting class_device structures. 215 * @uevent: pointer to a uevent function for this struct class_device. If 216 * set, this will be called instead of the class specific uevent function. 217 * Only use this if you want to override the default uevent function, like 218 * when you are nesting class_device structures. 219 */ 220 struct class_device { 221 struct list_head node; 222 223 struct kobject kobj; 224 struct class * class; /* required */ 225 dev_t devt; /* dev_t, creates the sysfs "dev" */ 226 struct class_device_attribute *devt_attr; 227 struct class_device_attribute uevent_attr; 228 struct device * dev; /* not necessary, but nice to have */ 229 void * class_data; /* class-specific data */ 230 struct class_device *parent; /* parent of this child device, if there is one */ 231 232 void (*release)(struct class_device *dev); 233 int (*uevent)(struct class_device *dev, char **envp, 234 int num_envp, char *buffer, int buffer_size); 235 char class_id[BUS_ID_SIZE]; /* unique to this class */ 236 }; 237 238 static inline void * 239 class_get_devdata (struct class_device *dev) 240 { 241 return dev->class_data; 242 } 243 244 static inline void 245 class_set_devdata (struct class_device *dev, void *data) 246 { 247 dev->class_data = data; 248 } 249 250 251 extern int class_device_register(struct class_device *); 252 extern void class_device_unregister(struct class_device *); 253 extern void class_device_initialize(struct class_device *); 254 extern int class_device_add(struct class_device *); 255 extern void class_device_del(struct class_device *); 256 257 extern int class_device_rename(struct class_device *, char *); 258 259 extern struct class_device * class_device_get(struct class_device *); 260 extern void class_device_put(struct class_device *); 261 262 extern void class_device_remove_file(struct class_device *, 263 const struct class_device_attribute *); 264 extern int class_device_create_bin_file(struct class_device *, 265 struct bin_attribute *); 266 extern void class_device_remove_bin_file(struct class_device *, 267 struct bin_attribute *); 268 269 struct class_interface { 270 struct list_head node; 271 struct class *class; 272 273 int (*add) (struct class_device *, struct class_interface *); 274 void (*remove) (struct class_device *, struct class_interface *); 275 }; 276 277 extern int class_interface_register(struct class_interface *); 278 extern void class_interface_unregister(struct class_interface *); 279 280 extern struct class *class_create(struct module *owner, char *name); 281 extern void class_destroy(struct class *cls); 282 extern struct class_device *class_device_create(struct class *cls, 283 struct class_device *parent, 284 dev_t devt, 285 struct device *device, 286 char *fmt, ...) 287 __attribute__((format(printf,5,6))); 288 extern void class_device_destroy(struct class *cls, dev_t devt); 289 290 291 /* interface for exporting device attributes */ 292 struct device_attribute { 293 struct attribute attr; 294 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 295 char *buf); 296 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 297 const char *buf, size_t count); 298 }; 299 300 #define DEVICE_ATTR(_name,_mode,_show,_store) \ 301 struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store) 302 303 extern int device_create_file(struct device *device, struct device_attribute * entry); 304 extern void device_remove_file(struct device * dev, struct device_attribute * attr); 305 struct device { 306 struct klist klist_children; 307 struct klist_node knode_parent; /* node in sibling list */ 308 struct klist_node knode_driver; 309 struct klist_node knode_bus; 310 struct device * parent; 311 312 struct kobject kobj; 313 char bus_id[BUS_ID_SIZE]; /* position on parent bus */ 314 struct device_attribute uevent_attr; 315 316 struct semaphore sem; /* semaphore to synchronize calls to 317 * its driver. 318 */ 319 320 struct bus_type * bus; /* type of bus device is on */ 321 struct device_driver *driver; /* which driver has allocated this 322 device */ 323 void *driver_data; /* data private to the driver */ 324 void *platform_data; /* Platform specific data, device 325 core doesn't touch it */ 326 void *firmware_data; /* Firmware specific data (e.g. ACPI, 327 BIOS data),reserved for device core*/ 328 struct dev_pm_info power; 329 330 u64 *dma_mask; /* dma mask (if dma'able device) */ 331 u64 coherent_dma_mask;/* Like dma_mask, but for 332 alloc_coherent mappings as 333 not all hardware supports 334 64 bit addresses for consistent 335 allocations such descriptors. */ 336 337 struct list_head dma_pools; /* dma pools (if dma'ble) */ 338 339 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 340 override */ 341 342 void (*release)(struct device * dev); 343 }; 344 345 static inline void * 346 dev_get_drvdata (struct device *dev) 347 { 348 return dev->driver_data; 349 } 350 351 static inline void 352 dev_set_drvdata (struct device *dev, void *data) 353 { 354 dev->driver_data = data; 355 } 356 357 static inline int device_is_registered(struct device *dev) 358 { 359 return klist_node_attached(&dev->knode_bus); 360 } 361 362 /* 363 * High level routines for use by the bus drivers 364 */ 365 extern int device_register(struct device * dev); 366 extern void device_unregister(struct device * dev); 367 extern void device_initialize(struct device * dev); 368 extern int device_add(struct device * dev); 369 extern void device_del(struct device * dev); 370 extern int device_for_each_child(struct device *, void *, 371 int (*fn)(struct device *, void *)); 372 373 /* 374 * Manual binding of a device to driver. See drivers/base/bus.c 375 * for information on use. 376 */ 377 extern void device_bind_driver(struct device * dev); 378 extern void device_release_driver(struct device * dev); 379 extern int device_attach(struct device * dev); 380 extern void driver_attach(struct device_driver * drv); 381 extern void device_reprobe(struct device *dev); 382 383 384 /* 385 * Platform "fixup" functions - allow the platform to have their say 386 * about devices and actions that the general device layer doesn't 387 * know about. 388 */ 389 /* Notify platform of device discovery */ 390 extern int (*platform_notify)(struct device * dev); 391 392 extern int (*platform_notify_remove)(struct device * dev); 393 394 395 /** 396 * get_device - atomically increment the reference count for the device. 397 * 398 */ 399 extern struct device * get_device(struct device * dev); 400 extern void put_device(struct device * dev); 401 402 403 /* drivers/base/power/shutdown.c */ 404 extern void device_shutdown(void); 405 406 407 /* drivers/base/firmware.c */ 408 extern int firmware_register(struct subsystem *); 409 extern void firmware_unregister(struct subsystem *); 410 411 /* debugging and troubleshooting/diagnostic helpers. */ 412 #define dev_printk(level, dev, format, arg...) \ 413 printk(level "%s %s: " format , (dev)->driver ? (dev)->driver->name : "" , (dev)->bus_id , ## arg) 414 415 #ifdef DEBUG 416 #define dev_dbg(dev, format, arg...) \ 417 dev_printk(KERN_DEBUG , dev , format , ## arg) 418 #else 419 #define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0) 420 #endif 421 422 #define dev_err(dev, format, arg...) \ 423 dev_printk(KERN_ERR , dev , format , ## arg) 424 #define dev_info(dev, format, arg...) \ 425 dev_printk(KERN_INFO , dev , format , ## arg) 426 #define dev_warn(dev, format, arg...) \ 427 dev_printk(KERN_WARNING , dev , format , ## arg) 428 #define dev_notice(dev, format, arg...) \ 429 dev_printk(KERN_NOTICE , dev , format , ## arg) 430 431 /* Create alias, so I can be autoloaded. */ 432 #define MODULE_ALIAS_CHARDEV(major,minor) \ 433 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 434 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 435 MODULE_ALIAS("char-major-" __stringify(major) "-*") 436 #endif /* _DEVICE_H_ */ 437