1/** 2 * System devices follow a slightly different driver model. 3 * They don't need to do dynammic driver binding, can't be probed, 4 * and don't reside on any type of peripheral bus. 5 * So, we represent and treat them a little differently. 6 * 7 * We still have a notion of a driver for a system device, because we still 8 * want to perform basic operations on these devices. 9 * 10 * We also support auxillary drivers binding to devices of a certain class. 11 * 12 * This allows configurable drivers to register themselves for devices of 13 * a certain type. And, it allows class definitions to reside in generic 14 * code while arch-specific code can register specific drivers. 15 * 16 * Auxillary drivers registered with a NULL cls are registered as drivers 17 * for all system devices, and get notification calls for each device. 18 */ 19 20 21#ifndef _SYSDEV_H_ 22#define _SYSDEV_H_ 23 24#include <linux/kobject.h> 25#include <linux/module.h> 26#include <linux/pm.h> 27 28 29struct sys_device; 30struct sysdev_class_attribute; 31 32struct sysdev_class { 33 const char *name; 34 struct list_head drivers; 35 struct sysdev_class_attribute **attrs; 36 37 /* Default operations for these types of devices */ 38 int (*shutdown)(struct sys_device *); 39 int (*suspend)(struct sys_device *, pm_message_t state); 40 int (*resume)(struct sys_device *); 41 struct kset kset; 42}; 43 44struct sysdev_class_attribute { 45 struct attribute attr; 46 ssize_t (*show)(struct sysdev_class *, struct sysdev_class_attribute *, 47 char *); 48 ssize_t (*store)(struct sysdev_class *, struct sysdev_class_attribute *, 49 const char *, size_t); 50}; 51 52#define _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store) \ 53{ \ 54 .attr = {.name = __stringify(_name), .mode = _mode }, \ 55 .show = _show, \ 56 .store = _store, \ 57} 58 59#define SYSDEV_CLASS_ATTR(_name,_mode,_show,_store) \ 60 struct sysdev_class_attribute attr_##_name = \ 61 _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store) 62 63 64extern int sysdev_class_register(struct sysdev_class *); 65extern void sysdev_class_unregister(struct sysdev_class *); 66 67extern int sysdev_class_create_file(struct sysdev_class *, 68 struct sysdev_class_attribute *); 69extern void sysdev_class_remove_file(struct sysdev_class *, 70 struct sysdev_class_attribute *); 71/** 72 * Auxillary system device drivers. 73 */ 74 75struct sysdev_driver { 76 struct list_head entry; 77 int (*add)(struct sys_device *); 78 int (*remove)(struct sys_device *); 79 int (*shutdown)(struct sys_device *); 80 int (*suspend)(struct sys_device *, pm_message_t state); 81 int (*resume)(struct sys_device *); 82}; 83 84 85extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *); 86extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *); 87 88 89/** 90 * sys_devices can be simplified a lot from regular devices, because they're 91 * simply not as versatile. 92 */ 93 94struct sys_device { 95 u32 id; 96 struct sysdev_class * cls; 97 struct kobject kobj; 98}; 99 100extern int sysdev_register(struct sys_device *); 101extern void sysdev_unregister(struct sys_device *); 102 103 104struct sysdev_attribute { 105 struct attribute attr; 106 ssize_t (*show)(struct sys_device *, struct sysdev_attribute *, char *); 107 ssize_t (*store)(struct sys_device *, struct sysdev_attribute *, 108 const char *, size_t); 109}; 110 111 112#define _SYSDEV_ATTR(_name, _mode, _show, _store) \ 113{ \ 114 .attr = { .name = __stringify(_name), .mode = _mode }, \ 115 .show = _show, \ 116 .store = _store, \ 117} 118 119#define SYSDEV_ATTR(_name, _mode, _show, _store) \ 120 struct sysdev_attribute attr_##_name = \ 121 _SYSDEV_ATTR(_name, _mode, _show, _store); 122 123extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *); 124extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *); 125 126/* Create/remove NULL terminated attribute list */ 127static inline int 128sysdev_create_files(struct sys_device *d, struct sysdev_attribute **a) 129{ 130 return sysfs_create_files(&d->kobj, (const struct attribute **)a); 131} 132 133static inline void 134sysdev_remove_files(struct sys_device *d, struct sysdev_attribute **a) 135{ 136 return sysfs_remove_files(&d->kobj, (const struct attribute **)a); 137} 138 139struct sysdev_ext_attribute { 140 struct sysdev_attribute attr; 141 void *var; 142}; 143 144/* 145 * Support for simple variable sysdev attributes. 146 * The pointer to the variable is stored in a sysdev_ext_attribute 147 */ 148 149/* Add more types as needed */ 150 151extern ssize_t sysdev_show_ulong(struct sys_device *, struct sysdev_attribute *, 152 char *); 153extern ssize_t sysdev_store_ulong(struct sys_device *, 154 struct sysdev_attribute *, const char *, size_t); 155extern ssize_t sysdev_show_int(struct sys_device *, struct sysdev_attribute *, 156 char *); 157extern ssize_t sysdev_store_int(struct sys_device *, 158 struct sysdev_attribute *, const char *, size_t); 159 160#define _SYSDEV_ULONG_ATTR(_name, _mode, _var) \ 161 { _SYSDEV_ATTR(_name, _mode, sysdev_show_ulong, sysdev_store_ulong), \ 162 &(_var) } 163#define SYSDEV_ULONG_ATTR(_name, _mode, _var) \ 164 struct sysdev_ext_attribute attr_##_name = \ 165 _SYSDEV_ULONG_ATTR(_name, _mode, _var); 166#define _SYSDEV_INT_ATTR(_name, _mode, _var) \ 167 { _SYSDEV_ATTR(_name, _mode, sysdev_show_int, sysdev_store_int), \ 168 &(_var) } 169#define SYSDEV_INT_ATTR(_name, _mode, _var) \ 170 struct sysdev_ext_attribute attr_##_name = \ 171 _SYSDEV_INT_ATTR(_name, _mode, _var); 172 173#endif /* _SYSDEV_H_ */ 174