/**
* cdev_add() - add a char device to the system
* @p: the cdev structure for the device
* @dev: the first device number for which this device is responsible
* @count: the number of consecutive minor numbers corresponding to this
* device
*
* cdev_add() adds the device represented by @p to the system, making it
* live immediately. A negative error code is returned on failure.
*/
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
p->dev = dev;
p->count = count;
return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}
static void cdev_unmap(dev_t dev, unsigned count)
{
kobj_unmap(cdev_map, dev, count);
}
/**
* cdev_del() - remove a cdev from the system
* @p: the cdev structure to be removed
*
* cdev_del() removes @p from the system, possibly freeing the structure
* itself.
*/
void cdev_del(struct cdev *p)
{
cdev_unmap(p->dev, p->count);
kobject_put(&p->kobj);
}
static void cdev_default_release(struct kobject *kobj)
{
struct cdev *p = container_of(kobj, struct cdev, kobj);
cdev_purge(p);
}
static void cdev_dynamic_release(struct kobject *kobj)
{
struct cdev *p = container_of(kobj, struct cdev, kobj);
cdev_purge(p);
kfree(p);
}
static struct kobj_type ktype_cdev_default = {
.release = cdev_default_release,
};
static struct kobj_type ktype_cdev_dynamic = {
.release = cdev_dynamic_release,
};
/**
* cdev_alloc() - allocate a cdev structure
*
* Allocates and returns a cdev structure, or NULL on failure.
*/
struct cdev *cdev_alloc(void)
{
struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
if (p) {
INIT_LIST_HEAD(&p->list);
kobject_init(&p->kobj, &ktype_cdev_dynamic);
}
return p;
}
/**
* cdev_init() - initialize a cdev structure
* @cdev: the structure to initialize
* @fops: the file_operations for this device
*
* Initializes @cdev, remembering @fops, making it ready to add to the
* system with cdev_add().
*/
void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
memset(cdev, 0, sizeof *cdev);
INIT_LIST_HEAD(&cdev->list);
kobject_init(&cdev->kobj, &ktype_cdev_default);
cdev->ops = fops;
}
static struct kobject *base_probe(dev_t dev, int *part, void *data)
{
if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
/* Make old-style 2.4 aliases work */
request_module("char-major-%d", MAJOR(dev));
return NULL;
}
void __init chrdev_init(void)
{
cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
bdi_init(&directly_mappable_cdev_bdi);
}
/* Let modules do char dev stuff */
EXPORT_SYMBOL(register_chrdev_region);
EXPORT_SYMBOL(unregister_chrdev_region);
EXPORT_SYMBOL(alloc_chrdev_region);
EXPORT_SYMBOL(cdev_init);
EXPORT_SYMBOL(cdev_alloc);
EXPORT_SYMBOL(cdev_del);
EXPORT_SYMBOL(cdev_add);
EXPORT_SYMBOL(cdev_index);
EXPORT_SYMBOL(__register_chrdev);
EXPORT_SYMBOL(__unregister_chrdev);
EXPORT_SYMBOL(directly_mappable_cdev_bdi);
/drivers/base/base.h
/**
003 * struct bus_type_private - structure to hold the private to the driver core portions of the bus_type structure.
004 *
005 * @subsys - the struct kset that defines this bus. This is the main kobject
006 * @drivers_kset - the list of drivers associated with this bus
007 * @devices_kset - the list of devices associated with this bus
008 * @klist_devices - the klist to iterate over the @devices_kset
009 * @klist_drivers - the klist to iterate over the @drivers_kset
010 * @bus_notifier - the bus notifier list for anything that cares about things
011 * on this bus.
012 * @bus - pointer back to the struct bus_type that this structure is associated
013 * with.
014 *
015 * This structure is the one that is the actual kobject allowing struct
016 * bus_type to be statically allocated safely. Nothing outside of the driver
017 * core should ever touch these fields.
018 */
019 struct bus_type_private {
020 struct kset subsys;
021 struct kset *drivers_kset;
022 struct kset *devices_kset;
023 struct klist klist_devices;
024 struct klist klist_drivers;
025 struct blocking_notifier_head bus_notifier;
026 unsigned int drivers_autoprobe:1;
027 struct bus_type *bus;
028 };
029
030 struct driver_private {
031 struct kobject kobj;
032 struct klist klist_devices;
033 struct klist_node knode_bus;
034 struct module_kobject *mkobj;
035 struct device_driver *driver;
036 };
037 #define to_driver(obj) container_of(obj, struct driver_private, kobj)
038
039
040 /**
041 * struct class_private - structure to hold the private to the driver core portions of the class structure.
042 *
043 * @class_subsys - the struct kset that defines this class. This is the main kobject
044 * @class_devices - list of devices associated with this class
045 * @class_interfaces - list of class_interfaces associated with this class
046 * @class_dirs - "glue" directory for virtual devices associated with this class
047 * @class_mutex - mutex to protect the children, devices, and interfaces lists.
048 * @class - pointer back to the struct class that this structure is associated
049 * with.
050 *
051 * This structure is the one that is the actual kobject allowing struct
052 * class to be statically allocated safely. Nothing outside of the driver
053 * core should ever touch these fields.
054 */
055 struct class_private {
056 struct kset class_subsys;
057 struct klist class_devices;
058 struct list_head class_interfaces;
059 struct kset class_dirs;
060 struct mutex class_mutex;
061 struct class *class;
062 };
063 #define to_class(obj) \
064 container_of(obj, struct class_private, class_subsys.kobj)
065
066 /**
067 * struct device_private - structure to hold the private to the driver core portions of the device structure.
068 *
069 * @klist_children - klist containing all children of this device
070 * @knode_parent - node in sibling list
071 * @knode_driver - node in driver list
072 * @knode_bus - node in bus list
073 * @driver_data - private pointer for driver specific info. Will turn into a
074 * list soon.
075 * @device - pointer back to the struct class that this structure is
076 * associated with.
077 *
078 * Nothing outside of the driver core should ever touch these fields.
079 */
080 struct device_private {
081 struct klist klist_children;
082 struct klist_node knode_parent;
083 struct klist_node knode_driver;
084 struct klist_node knode_bus;
085 void *driver_data;
086 struct device *device;
087 };
088 #define to_device_private_parent(obj) \
089 container_of(obj, struct device_private, knode_parent)
090 #define to_device_private_driver(obj) \
091 container_of(obj, struct device_private, knode_driver)
092 #define to_device_private_bus(obj) \
093 container_of(obj, struct device_private, knode_bus)
094
095 extern int device_private_init(struct device *dev);
096
097 /* initialisation functions */
098 extern int devices_init(void);
099 extern int buses_init(void);
100 extern int classes_init(void);
101 extern int firmware_init(void);
102 #ifdef CONFIG_SYS_HYPERVISOR
103 extern int hypervisor_init(void);
104 #else
105 static inline int hypervisor_init(void) { return 0; }
106 #endif
107 extern int platform_bus_init(void);
108 extern int system_bus_init(void);
109 extern int cpu_dev_init(void);
110
111 extern int bus_add_device(struct device *dev);
112 extern void bus_probe_device(struct device *dev);
113 extern void bus_remove_device(struct device *dev);
114
115 extern int bus_add_driver(struct device_driver *drv);
116 extern void bus_remove_driver(struct device_driver *drv);
117
118 extern void driver_detach(struct device_driver *drv);
119 extern int driver_probe_device(struct device_driver *drv, struct device *dev);
120 static inline int driver_match_device(struct device_driver *drv,
121 struct device *dev)
122 {
123 return drv->bus->match ? drv->bus->match(dev, drv) : 1;
124 }
125
126 extern void sysdev_shutdown(void);
127
128 extern char *make_class_name(const char *name, struct kobject *kobj);
129
130 extern int devres_release_all(struct device *dev);
131
132 extern struct kset *devices_kset;
133
134 #if defined(CONFIG_MODULES) && defined(CONFIG_SYSFS)
135 extern void module_add_driver(struct module *mod, struct device_driver *drv);
136 extern void module_remove_driver(struct device_driver *drv);
137 #else
138 static inline void module_add_driver(struct module *mod,
139 struct device_driver *drv) { }
140 static inline void module_remove_driver(struct device_driver *drv) { }
141 #endif
142
143 #ifdef CONFIG_DEVTMPFS
144 extern int devtmpfs_init(void);
145 #else
146 static inline int devtmpfs_init(void) { return 0; }
147 #endif