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 * @groups: optional additional groups to be created 204 * @dev: if set, a symlink to the struct device is created in the sysfs 205 * directory for this struct class device. 206 * @class_data: pointer to whatever you want to store here for this struct 207 * class_device. Use class_get_devdata() and class_set_devdata() to get and 208 * set this pointer. 209 * @parent: pointer to a struct class_device that is the parent of this struct 210 * class_device. If NULL, this class_device will show up at the root of the 211 * struct class in sysfs (which is probably what you want to have happen.) 212 * @release: pointer to a release function for this struct class_device. If 213 * set, this will be called instead of the class specific release function. 214 * Only use this if you want to override the default release function, like 215 * when you are nesting class_device structures. 216 * @uevent: pointer to a uevent function for this struct class_device. If 217 * set, this will be called instead of the class specific uevent function. 218 * Only use this if you want to override the default uevent function, like 219 * when you are nesting class_device structures. 220 */ 221 struct class_device { 222 struct list_head node; 223 224 struct kobject kobj; 225 struct class * class; /* required */ 226 dev_t devt; /* dev_t, creates the sysfs "dev" */ 227 struct class_device_attribute *devt_attr; 228 struct class_device_attribute uevent_attr; 229 struct device * dev; /* not necessary, but nice to have */ 230 void * class_data; /* class-specific data */ 231 struct class_device *parent; /* parent of this child device, if there is one */ 232 struct attribute_group ** groups; /* optional groups */ 233 234 void (*release)(struct class_device *dev); 235 int (*uevent)(struct class_device *dev, char **envp, 236 int num_envp, char *buffer, int buffer_size); 237 char class_id[BUS_ID_SIZE]; /* unique to this class */ 238 }; 239 240 static inline void * 241 class_get_devdata (struct class_device *dev) 242 { 243 return dev->class_data; 244 } 245 246 static inline void 247 class_set_devdata (struct class_device *dev, void *data) 248 { 249 dev->class_data = data; 250 } 251 252 253 extern int class_device_register(struct class_device *); 254 extern void class_device_unregister(struct class_device *); 255 extern void class_device_initialize(struct class_device *); 256 extern int class_device_add(struct class_device *); 257 extern void class_device_del(struct class_device *); 258 259 extern int class_device_rename(struct class_device *, char *); 260 261 extern struct class_device * class_device_get(struct class_device *); 262 extern void class_device_put(struct class_device *); 263 264 extern void class_device_remove_file(struct class_device *, 265 const struct class_device_attribute *); 266 extern int class_device_create_bin_file(struct class_device *, 267 struct bin_attribute *); 268 extern void class_device_remove_bin_file(struct class_device *, 269 struct bin_attribute *); 270 271 struct class_interface { 272 struct list_head node; 273 struct class *class; 274 275 int (*add) (struct class_device *, struct class_interface *); 276 void (*remove) (struct class_device *, struct class_interface *); 277 }; 278 279 extern int class_interface_register(struct class_interface *); 280 extern void class_interface_unregister(struct class_interface *); 281 282 extern struct class *class_create(struct module *owner, char *name); 283 extern void class_destroy(struct class *cls); 284 extern struct class_device *class_device_create(struct class *cls, 285 struct class_device *parent, 286 dev_t devt, 287 struct device *device, 288 char *fmt, ...) 289 __attribute__((format(printf,5,6))); 290 extern void class_device_destroy(struct class *cls, dev_t devt); 291 292 293 /* interface for exporting device attributes */ 294 struct device_attribute { 295 struct attribute attr; 296 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 297 char *buf); 298 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 299 const char *buf, size_t count); 300 }; 301 302 #define DEVICE_ATTR(_name,_mode,_show,_store) \ 303 struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store) 304 305 extern int device_create_file(struct device *device, struct device_attribute * entry); 306 extern void device_remove_file(struct device * dev, struct device_attribute * attr); 307 struct device { 308 struct klist klist_children; 309 struct klist_node knode_parent; /* node in sibling list */ 310 struct klist_node knode_driver; 311 struct klist_node knode_bus; 312 struct device * parent; 313 314 struct kobject kobj; 315 char bus_id[BUS_ID_SIZE]; /* position on parent bus */ 316 struct device_attribute uevent_attr; 317 318 struct semaphore sem; /* semaphore to synchronize calls to 319 * its driver. 320 */ 321 322 struct bus_type * bus; /* type of bus device is on */ 323 struct device_driver *driver; /* which driver has allocated this 324 device */ 325 void *driver_data; /* data private to the driver */ 326 void *platform_data; /* Platform specific data, device 327 core doesn't touch it */ 328 void *firmware_data; /* Firmware specific data (e.g. ACPI, 329 BIOS data),reserved for device core*/ 330 struct dev_pm_info power; 331 332 u64 *dma_mask; /* dma mask (if dma'able device) */ 333 u64 coherent_dma_mask;/* Like dma_mask, but for 334 alloc_coherent mappings as 335 not all hardware supports 336 64 bit addresses for consistent 337 allocations such descriptors. */ 338 339 struct list_head dma_pools; /* dma pools (if dma'ble) */ 340 341 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 342 override */ 343 344 void (*release)(struct device * dev); 345 }; 346 347 static inline void * 348 dev_get_drvdata (struct device *dev) 349 { 350 return dev->driver_data; 351 } 352 353 static inline void 354 dev_set_drvdata (struct device *dev, void *data) 355 { 356 dev->driver_data = data; 357 } 358 359 static inline int device_is_registered(struct device *dev) 360 { 361 return klist_node_attached(&dev->knode_bus); 362 } 363 364 /* 365 * High level routines for use by the bus drivers 366 */ 367 extern int device_register(struct device * dev); 368 extern void device_unregister(struct device * dev); 369 extern void device_initialize(struct device * dev); 370 extern int device_add(struct device * dev); 371 extern void device_del(struct device * dev); 372 extern int device_for_each_child(struct device *, void *, 373 int (*fn)(struct device *, void *)); 374 375 /* 376 * Manual binding of a device to driver. See drivers/base/bus.c 377 * for information on use. 378 */ 379 extern void device_bind_driver(struct device * dev); 380 extern void device_release_driver(struct device * dev); 381 extern int device_attach(struct device * dev); 382 extern void driver_attach(struct device_driver * drv); 383 extern void device_reprobe(struct device *dev); 384 385 386 /* 387 * Platform "fixup" functions - allow the platform to have their say 388 * about devices and actions that the general device layer doesn't 389 * know about. 390 */ 391 /* Notify platform of device discovery */ 392 extern int (*platform_notify)(struct device * dev); 393 394 extern int (*platform_notify_remove)(struct device * dev); 395 396 397 /** 398 * get_device - atomically increment the reference count for the device. 399 * 400 */ 401 extern struct device * get_device(struct device * dev); 402 extern void put_device(struct device * dev); 403 404 405 /* drivers/base/power/shutdown.c */ 406 extern void device_shutdown(void); 407 408 409 /* drivers/base/firmware.c */ 410 extern int firmware_register(struct subsystem *); 411 extern void firmware_unregister(struct subsystem *); 412 413 /* debugging and troubleshooting/diagnostic helpers. */ 414 #define dev_printk(level, dev, format, arg...) \ 415 printk(level "%s %s: " format , (dev)->driver ? (dev)->driver->name : "" , (dev)->bus_id , ## arg) 416 417 #ifdef DEBUG 418 #define dev_dbg(dev, format, arg...) \ 419 dev_printk(KERN_DEBUG , dev , format , ## arg) 420 #else 421 #define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0) 422 #endif 423 424 #define dev_err(dev, format, arg...) \ 425 dev_printk(KERN_ERR , dev , format , ## arg) 426 #define dev_info(dev, format, arg...) \ 427 dev_printk(KERN_INFO , dev , format , ## arg) 428 #define dev_warn(dev, format, arg...) \ 429 dev_printk(KERN_WARNING , dev , format , ## arg) 430 #define dev_notice(dev, format, arg...) \ 431 dev_printk(KERN_NOTICE , dev , format , ## arg) 432 433 /* Create alias, so I can be autoloaded. */ 434 #define MODULE_ALIAS_CHARDEV(major,minor) \ 435 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 436 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 437 MODULE_ALIAS("char-major-" __stringify(major) "-*") 438 #endif /* _DEVICE_H_ */ 439