总线、设备、驱动、类 .

最新推荐文章于 2022-10-20 15:39:19 发布

gjy938815

最新推荐文章于 2022-10-20 15:39:19 发布

阅读量538

点赞数

分类专栏： Linux 总线设备驱动模型

Linux 总线设备驱动模型专栏收录该内容

5 篇文章 0 订阅

订阅专栏

分类： linux设备驱动 2012-12-18 21:40 353人阅读评论(0) 收藏举报

一. 总线、设备、驱动、类各自的相关结构体

1.总线

1.1 总线类型结构体

struct bus_type {
	const char	*name;	//总线类型名
	struct bus_attribute	*bus_attrs;	//总线属性
	struct device_attribute	*dev_attrs;	//设备属性
	struct driver_attribute	*drv_attrs;	//驱动属性
	int (*match)(struct device *dev, struct device_driver *drv);	//match方法
	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);	//uevent方法
	int (*probe)(struct device *dev);		//总线probe方法
	int (*remove)(struct device *dev);		//总线remove方法
	void (*shutdown)(struct device *dev);	//总线remove方法
	int (*suspend)(struct device *dev, pm_message_t state);	//总线shutdown方法
	int (*resume)(struct device *dev);		//总线resume方法
	const struct dev_pm_ops *pm;	//总线电源管理函数集
	struct bus_type_private *p;		//总线私有数据
};

1.2 总线私有数据结构体

struct bus_type_private {
	struct kset subsys;
	struct kset *drivers_kset;
	struct kset *devices_kset;
	struct klist klist_devices;
	struct klist klist_drivers;
	struct blocking_notifier_head bus_notifier;
	unsigned int drivers_autoprobe:1;
	struct bus_type *bus;
};

1.3 总线类型属性结构体

struct bus_attribute {
	struct attribute	attr;
	ssize_t (*show)(struct bus_type *bus, char *buf);
	ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};

1.4 设备属性结构体

struct device_attribute {
	struct attribute	attr;
	ssize_t (*show)(struct device *dev, struct device_attribute *attr,char *buf);
	ssize_t (*store)(struct device *dev, struct device_attribute *attr,const char *buf, size_t count);
};

1.5 设备驱动属性结构体

struct driver_attribute {
	struct attribute attr;
	ssize_t (*show)(struct device_driver *driver, char *buf);
	ssize_t (*store)(struct device_driver *driver, const char *buf,size_t count);
};

2.设备

2.1 设备结构体

struct device {
	struct device	*parent;	//父设备指针
	struct device_private	*p;	//设备私有数据
	struct kobject kobj;
	const char	*init_name; /* initial name of the device */
	struct device_type	*type;
	struct mutex	mutex;
	struct bus_type	*bus;	/* type of bus device is on */
	struct device_driver *driver;	//匹配的设备驱动
	void	*platform_data;	//平台数据	
	struct dev_pm_info	power;
#ifdef CONFIG_NUMA
	int	numa_node;/* NUMA node this device is close to */
#endif
	u64	*dma_mask;/* dma mask (if dma'able device) */
	u64	coherent_dma_mask;
	struct device_dma_parameters *dma_parms;
	struct list_head	dma_pools;	/* dma pools (if dma'ble) */
	struct dma_coherent_mem	*dma_mem; /* internal for coherent mem override */
	/* arch specific additions */
	struct dev_archdata	archdata;
#ifdef CONFIG_OF
	struct device_node	*of_node;
#endif
	dev_t	devt;	//设备号
	spinlock_t	devres_lock;
	struct list_head	devres_head;
	struct klist_node	knode_class;
	struct class	*class;	//对应的设备类
	const struct attribute_group **groups;	/* optional groups */
	void	(*release)(struct device *dev);	//release方法
};

2.2 设备私有数据结构体

struct device_private {
	struct klist klist_children;
	struct klist_node knode_parent;
	struct klist_node knode_driver;
	struct klist_node knode_bus;
	void *driver_data;
	struct device *device;
};

3.驱动

3.1 设备驱动结构体

struct device_driver {
	const char	*name;	//设备驱动名
	struct bus_type	*bus;	//所属总线类型
	struct module	*owner;	//模块所有者
	const char	*mod_name;	/* used for built-in modules */
	bool suppress_bind_attrs;	/* disables bind/unbind via sysfs */
#if defined(CONFIG_OF)
	const struct of_device_id	*of_match_table;
#endif
	int (*probe) (struct device *dev);	//probe方法
	int (*remove) (struct device *dev);	//remove方法
	void (*shutdown) (struct device *dev);	//shutdown方法
	int (*suspend) (struct device *dev, pm_message_t state);	//suspend方法
	int (*resume) (struct device *dev);	//resume方法
	const struct attribute_group **groups;
	const struct dev_pm_ops *pm;	//电源管理函数集
	struct driver_private *p;	//设备驱动私有数据
};

3.2 设备驱动私有数据结构体

struct driver_private {
	struct kobject kobj;
	struct klist klist_devices;
	struct klist_node knode_bus;
	struct module_kobject *mkobj;
	struct device_driver *driver;
};

4.类

4.1 设备类结构体

struct class {
	const char	*name;	//类名
	struct module	*owner;	//模块所有者
	struct class_attribute	*class_attrs;	//类属性
	struct device_attribute	*dev_attrs;	//设备属性
	struct kobject	*dev_kobj;
	int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
	char *(*devnode)(struct device *dev, mode_t *mode);
	void (*class_release)(struct class *class);
	void (*dev_release)(struct device *dev);
	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);
	const struct kobj_ns_type_operations *ns_type;
	const void *(*namespace)(struct device *dev);
	const struct dev_pm_ops *pm;	//电源管理函数集
	struct class_private *p;	//类私有数据结构
};

4.2 类属私有数据结构体

struct class_private {
	struct kset class_subsys;
	struct klist class_devices;
	struct list_head class_interfaces;
	struct kset class_dirs;
	struct mutex class_mutex;
	struct class *class;
};

4.3 类属性结构体

struct class_attribute {
	struct attribute attr;
	ssize_t (*show)(struct class *class, struct class_attribute *attr,char *buf);
	ssize_t (*store)(struct class *class, struct class_attribute *attr,const char *buf, size_t count);
};

二. 初始化过程

1 系统启动过程中调用start_kernel函数->rest_init()->创建kernel_init线程->do_basic_setup()->driver_init()

2.driver_init

void __init driver_init(void)
{
	devtmpfs_init();		//初始化devtmpfs文件系统
	devices_init();		//设备初始化
	buses_init();		//总线初始化
	classes_init();		//设备类初始化
	firmware_init();
	hypervisor_init();
	platform_bus_init();
	system_bus_init();
	cpu_dev_init();
	memory_dev_init();
}

3. devices_init

int __init devices_init(void)
{
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);	//创建"/sys/devices"
	if (!devices_kset)
		return -ENOMEM;
	dev_kobj = kobject_create_and_add("dev", NULL);	//创建"/sys/dev"
	if (!dev_kobj)
		goto dev_kobj_err;
	sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);	//创建"/sys/dev/block"
	if (!sysfs_dev_block_kobj)
		goto block_kobj_err;
	sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);		//创建"/sys/dev/char"
	if (!sysfs_dev_char_kobj)
		goto char_kobj_err;
	return 0;

 char_kobj_err:
	kobject_put(sysfs_dev_block_kobj);
 block_kobj_err:
	kobject_put(dev_kobj);
 dev_kobj_err:
	kset_unregister(devices_kset);
	return -ENOMEM;
}

4. buses_init

int __init buses_init(void)
{
	bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);	//创建"/sys/bus"
	if (!bus_kset)
		return -ENOMEM;
	return 0;
}

5. classes_init

int __init classes_init(void)
{
	class_kset = kset_create_and_add("class", NULL, NULL);		//创建"/sys/class"
	if (!class_kset)
		return -ENOMEM;
	return 0;
}

6.经过上面的初始化得到一些全局的变量

bus_kset --> /sys/bus
class_kset --> /sys/class
devices_kset --> /sys/devices
dev_kobj--> /sys/dev
sysfs_dev_block_kobj --> /sys/dev/block
sysfs_dev_char_kobj --> /sys/dev/char

三. 总线设备驱动类的注册与注销

1. 总线注册与注销

1.1 注册

int bus_register(struct bus_type *bus)
{
	int retval;
	struct bus_type_private *priv;

	priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);	//分配总线类型私有数据结构体
	if (!priv)
		return -ENOMEM;

	priv->bus = bus;		//私有数据结构体的总线指针指向总线
	bus->p = priv;		//总线的私有数据指针指向私有数据结构体

	BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);	//初始化通知链表头

	retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
	if (retval)
		goto out;

	priv->subsys.kobj.kset = bus_kset;		//bus_kset --> /sys/bus
        priv->subsys.kobj.ktype = &bus_ktype;
	priv->drivers_autoprobe = 1;

	retval = kset_register(&priv->subsys);	//创建"/sys/bus/xxx"
	if (retval)
		goto out;

	retval = bus_create_file(bus, &bus_attr_uevent);
	if (retval)
		goto bus_uevent_fail;

	priv->devices_kset = kset_create_and_add("devices", NULL,&priv->subsys.kobj);	//创建"/sys/bus/xxx/devices"
	if (!priv->devices_kset) {
		retval = -ENOMEM;
		goto bus_devices_fail;
	}

	priv->drivers_kset = kset_create_and_add("drivers", NULL,&priv->subsys.kobj);	//创建"/sys/bus/xxx/drivers"
	if (!priv->drivers_kset) {
		retval = -ENOMEM;
		goto bus_drivers_fail;
	}

	klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
	klist_init(&priv->klist_drivers, NULL, NULL);

	retval = add_probe_files(bus);
	if (retval)
		goto bus_probe_files_fail;

	retval = bus_add_attrs(bus);
	if (retval)
		goto bus_attrs_fail;

	pr_debug("bus: '%s': registered\n", bus->name);
	return 0;

bus_attrs_fail:
	remove_probe_files(bus);
bus_probe_files_fail:
	kset_unregister(bus->p->drivers_kset);
bus_drivers_fail:
	kset_unregister(bus->p->devices_kset);
bus_devices_fail:
	bus_remove_file(bus, &bus_attr_uevent);
bus_uevent_fail:
	kset_unregister(&bus->p->subsys);
out:
	kfree(bus->p);
	bus->p = NULL;
	return retval;
}

1.2 注销

void bus_unregister(struct bus_type *bus)
{
	pr_debug("bus: '%s': unregistering\n", bus->name);
	bus_remove_attrs(bus);
	remove_probe_files(bus);
	kset_unregister(bus->p->drivers_kset);
	kset_unregister(bus->p->devices_kset);
	bus_remove_file(bus, &bus_attr_uevent);
	kset_unregister(&bus->p->subsys);
	kfree(bus->p);
	bus->p = NULL;
}

2.设备注册与注销

2.1 注册

int device_register(struct device *dev)
{
	device_initialize(dev);
	return device_add(dev);
}

2.1.1 device_initialize

void device_initialize(struct device *dev)
{
	dev->kobj.kset = devices_kset;    //devices_kset --> /sys/devices	
        	kobject_init(&dev->kobj, &device_ktype);
	INIT_LIST_HEAD(&dev->dma_pools);
	mutex_init(&dev->mutex);
	lockdep_set_novalidate_class(&dev->mutex);
	spin_lock_init(&dev->devres_lock);
	INIT_LIST_HEAD(&dev->devres_head);
	device_pm_init(dev);
	set_dev_node(dev, -1);
}

2.1.2 device_add

int device_add(struct device *dev)
{
	struct device *parent = NULL;
	struct class_interface *class_intf;
	int error = -EINVAL;
	dev = get_device(dev);
	if (!dev)
		goto done;

	if (!dev->p) {
		error = device_private_init(dev);
		if (error)
			goto done;
	}

	if (dev->init_name) {
		dev_set_name(dev, "%s", dev->init_name);
		dev->init_name = NULL;
	}

	if (!dev_name(dev)) {
		error = -EINVAL;
		goto name_error;
	}

	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
	parent = get_device(dev->parent);
	setup_parent(dev, parent);
	if (parent)
		set_dev_node(dev, dev_to_node(parent));
	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
	if (error)
		goto Error;
	if (platform_notify)
		platform_notify(dev);
	error = device_create_file(dev, &uevent_attr);
	if (error)
		goto attrError;
	if (MAJOR(dev->devt)) {
		error = device_create_file(dev, &devt_attr);
		if (error)
			goto ueventattrError;
		error = device_create_sys_dev_entry(dev);	//创建"/sys/dev/char/xxx"或"/sys/dev/block/xxx"
		if (error)
			goto devtattrError;
		devtmpfs_create_node(dev);	//创建节点文件
	}
	error = device_add_class_symlinks(dev);		
        	if (error)
		goto SymlinkError;
	error = device_add_attrs(dev);
	if (error)
		goto AttrsError;
	error = bus_add_device(dev);	//将设备添加进总线
	if (error)
		goto BusError;
	error = dpm_sysfs_add(dev);
	if (error)
		goto DPMError;
	device_pm_add(dev);
	if (dev->bus)
		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_ADD_DEVICE, dev);	//通知链发送通知

	kobject_uevent(&dev->kobj, KOBJ_ADD);
	bus_probe_device(dev);	//设备尝试匹配驱动并调用其probe方法
	if (parent)
		klist_add_tail(&dev->p->knode_parent,&parent->p->klist_children);

	if (dev->class) {
		mutex_lock(&dev->class->p->class_mutex);
		/* tie the class to the device */
		klist_add_tail(&dev->knode_class,&dev->class->p->class_devices);

		/* notify any interfaces that the device is here */
		list_for_each_entry(class_intf,&dev->class->p->class_interfaces, node)
			if (class_intf->add_dev)
				class_intf->add_dev(dev, class_intf);
		mutex_unlock(&dev->class->p->class_mutex);
	}
done:
	put_device(dev);
	return error;
 DPMError:
	bus_remove_device(dev);
 BusError:
	device_remove_attrs(dev);
 AttrsError:
	device_remove_class_symlinks(dev);
 SymlinkError:
	if (MAJOR(dev->devt))
		devtmpfs_delete_node(dev);
	if (MAJOR(dev->devt))
		device_remove_sys_dev_entry(dev);
 devtattrError:
	if (MAJOR(dev->devt))
		device_remove_file(dev, &devt_attr);
 ueventattrError:
	device_remove_file(dev, &uevent_attr);
 attrError:
	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
	kobject_del(&dev->kobj);
 Error:
	cleanup_device_parent(dev);
	if (parent)
		put_device(parent);
name_error:
	kfree(dev->p);
	dev->p = NULL;
	goto done;
}

2.1.2.1 device_create_sys_dev_entry 创建设备入口

static int device_create_sys_dev_entry(struct device *dev)
{
	struct kobject *kobj = device_to_dev_kobj(dev);
	int error = 0;
	char devt_str[15];
	if (kobj) {
		format_dev_t(devt_str, dev->devt);	//devt_srt=主设备号:次设备号
		error = sysfs_create_link(kobj, &dev->kobj, devt_str);
	}
	return error;
}

创建"/sys/dev/char[block]/主设备号:次设备号"
2.1.2.2 bus_add_device

int bus_add_device(struct device *dev)
{
	struct bus_type *bus = bus_get(dev->bus);
	int error = 0;

	if (bus) {
		pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
		error = device_add_attrs(bus, dev);
		if (error)
			goto out_put;
		error = sysfs_create_link(&bus->p->devices_kset->kobj,&dev->kobj, dev_name(dev));
		if (error)
			goto out_id;
		error = sysfs_create_link(&dev->kobj,&dev->bus->p->subsys.kobj, "subsystem");
		if (error)
			goto out_subsys;
		klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);	//将设备添加至总线的设备链表
	}
	return 0;

out_subsys:
	sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
out_id:
	device_remove_attrs(bus, dev);
out_put:
	bus_put(dev->bus);
	return error;
}

2,2 注销

void device_unregister(struct device *dev)
{
	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
	device_del(dev);
	put_device(dev);
}

3. 驱动注册与注销

3.1 注册

int driver_register(struct device_driver *drv)
{
	int ret;
	struct device_driver *other;

	BUG_ON(!drv->bus->p);
	//判断驱动的方法与总线是否匹配
	if ((drv->bus->probe && drv->probe) ||(drv->bus->remove && drv->remove) ||(drv->bus->shutdown && drv->shutdown))
		printk(KERN_WARNING "Driver '%s' needs updating - please use bus_type methods\n", drv->name);
	other = driver_find(drv->name, drv->bus);	//根据总线类型和驱动设备名查找设备
	if (other) {
		put_driver(other);
		printk(KERN_ERR "Error: Driver '%s' is already registered,aborting...\n", drv->name);
		return -EBUSY;
	}
	ret = bus_add_driver(drv);		//总线添加设备驱动
	if (ret)
		return ret;
	ret = driver_add_groups(drv, drv->groups);
	if (ret)
		bus_remove_driver(drv);
	return ret;
}

3.1.1 bus_add_driver

int bus_add_driver(struct device_driver *drv)
{
	struct bus_type *bus;
	struct driver_private *priv;
	int error = 0;

	bus = bus_get(drv->bus);	//获取驱动总线类型
	if (!bus)
		return -EINVAL;

	pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);	//分配设备驱动私有数据结构体
	if (!priv) {
		error = -ENOMEM;
		goto out_put_bus;
	}
	klist_init(&priv->klist_devices, NULL, NULL);
	priv->driver = drv;
	drv->p = priv;
	priv->kobj.kset = bus->p->drivers_kset;
	error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,"%s", drv->name);	//创建"/sys/bus/xxx/drivers"
	if (error)
		goto out_unregister;

	if (drv->bus->p->drivers_autoprobe) {
		error = driver_attach(drv);		//驱动匹配设备,并调用probe方法
		if (error)
			goto out_unregister;
	}
	klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);	//添加设备驱动到总线驱动链表
	module_add_driver(drv->owner, drv);
	error = driver_create_file(drv, &driver_attr_uevent);
	if (error) {
		printk(KERN_ERR "%s: uevent attr (%s) failed\n",__func__, drv->name);
	}
	error = driver_add_attrs(bus, drv);
	if (error) {
		printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",__func__, drv->name);
	}

	if (!drv->suppress_bind_attrs) {
		error = add_bind_files(drv);
		if (error) {
			printk(KERN_ERR "%s: add_bind_files(%s) failed\n",__func__, drv->name);
		}
	}
	kobject_uevent(&priv->kobj, KOBJ_ADD);
	return 0;
out_unregister:
	kobject_put(&priv->kobj);
	kfree(drv->p);
	drv->p = NULL;
out_put_bus:
	bus_put(bus);
	return error;
}

3.1.1.1 driver_attach 设备驱动匹配

int driver_attach(struct device_driver *drv)
{
	return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}

3.1.1.1.1 __driver_attach

static int __driver_attach(struct device *dev, void *data)
{
	struct device_driver *drv = data;
	if (!driver_match_device(drv, dev))	//设备与设备驱动的匹配
		return 0;
	if (dev->parent)	/* Needed for USB */
		device_lock(dev->parent);
	device_lock(dev);
	if (!dev->driver)	//存在设备驱动
		driver_probe_device(drv, dev);
	device_unlock(dev);
	if (dev->parent)
		device_unlock(dev->parent);
	return 0;
}

3.1.1.1.1.1driver_match_device

static inline int driver_match_device(struct device_driver *drv,struct device *dev)
{
	return drv->bus->match ? drv->bus->match(dev, drv) : 1;	//若总线存在match方法调用总线的match方法
}

3.1.1.1.1.2 driver_probe_device

int driver_probe_device(struct device_driver *drv, struct device *dev)
{
	int ret = 0;

	if (!device_is_registered(dev))
		return -ENODEV;

	pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
		 drv->bus->name, __func__, dev_name(dev), drv->name);

	pm_runtime_get_noresume(dev);
	pm_runtime_barrier(dev);
	ret = really_probe(dev, drv);
	pm_runtime_put_sync(dev);

	return ret;
}

3.1.1.1.1.2.1 really_probe函数

static int really_probe(struct device *dev, struct device_driver *drv)
{
	int ret = 0;
	atomic_inc(&probe_count);
	pr_debug("bus: '%s': %s: probing driver %s with device %s\n",drv->bus->name, __func__, drv->name, dev_name(dev));
	WARN_ON(!list_empty(&dev->devres_head));
	dev->driver = drv;
	if (driver_sysfs_add(dev)) {
		printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",__func__, dev_name(dev));
		goto probe_failed;
	}
	if (dev->bus->probe) {	//总线存在probe方法
		ret = dev->bus->probe(dev);	//则调用去probe方法
		if (ret)
			goto probe_failed;
	} else if (drv->probe) {	//驱动存在probe方法
		ret = drv->probe(dev);	//则调用设备驱动的probe方法 
		if (ret)
			goto probe_failed;
	}
	driver_bound(dev);	//捆绑设备文件,会调用总线的通知链回调函数
	ret = 1;
	pr_debug("bus: '%s': %s: bound device %s to driver %s\n",drv->bus->name, __func__, dev_name(dev), drv->name);
	goto done;

probe_failed:
	devres_release_all(dev);
	driver_sysfs_remove(dev);
	dev->driver = NULL;
	if (ret != -ENODEV && ret != -ENXIO) {
		printk(KERN_WARNING"%s: probe of %s failed with error %d\n",drv->name, dev_name(dev), ret);
	}
	ret = 0;
done:
	atomic_dec(&probe_count);
	wake_up(&probe_waitqueue);
	return ret;
}

3.2 注销

void driver_unregister(struct device_driver *drv)
{
	if (!drv || !drv->p) {
		WARN(1, "Unexpected driver unregister!\n");
		return;
	}
	driver_remove_groups(drv, drv->groups);
	bus_remove_driver(drv);
}

4. 类的注册与注销

4.1 注册

#define class_register(class)			\
({						\
	static struct lock_class_key __key;	\
	__class_register(class, &__key);	\
})

int __class_register(struct class *cls, struct lock_class_key *key)
{
	struct class_private *cp;
	int error;

	pr_debug("device class '%s': registering\n", cls->name);

	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
	if (!cp)
		return -ENOMEM;
	klist_init(&cp->class_devices, klist_class_dev_get, klist_class_dev_put);
	INIT_LIST_HEAD(&cp->class_interfaces);
	kset_init(&cp->class_dirs);
	__mutex_init(&cp->class_mutex, "struct class mutex", key);
	error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);
	if (error) {
		kfree(cp);
		return error;
	}

	/* set the default /sys/dev directory for devices of this class */
	if (!cls->dev_kobj)
		cls->dev_kobj = sysfs_dev_char_kobj;		//sysfs_dev_char_kobj --> /sys/dev/char
#if defined(CONFIG_BLOCK)
	/* let the block class directory show up in the root of sysfs */
	if (!sysfs_deprecated || cls != &block_class)		//创建"/sys/block"
		cp->class_subsys.kobj.kset = class_kset;
#else
	cp->class_subsys.kobj.kset = class_kset;	//class_kset --> /sys/class
#endif
	cp->class_subsys.kobj.ktype = &class_ktype;
	cp->class = cls;
	cls->p = cp;

	error = kset_register(&cp->class_subsys);
	if (error) {
		kfree(cp);
		return error;
	}
	error = add_class_attrs(class_get(cls));
	class_put(cls);
	return error;
}

4.2 注销

void class_unregister(struct class *cls)
{
	pr_debug("device class '%s': unregistering\n", cls->name);
	remove_class_attrs(cls);
	kset_unregister(&cls->p->class_subsys);
}

4.3 驱动中注册与注销类的另一种方式

4.3.1 注册类 class_create

#define class_create(owner, name)		\	//创建"/sys/(name)"
({					\
	static struct lock_class_key __key;	\
	__class_create(owner, name, &__key);	\
})

struct class *__class_create(struct module *owner, const char *name,struct lock_class_key *key)
{
	struct class *cls;
	int retval;

	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
	if (!cls) {
		retval = -ENOMEM;
		goto error;
	}

	cls->name = name;
	cls->owner = owner;
	cls->class_release = class_create_release;

	retval = __class_register(cls, key);		//实质上也是调用了__class_register函数
	if (retval)
		goto error;

	return cls;

error:
	kfree(cls);
	return ERR_PTR(retval);
}

4.3.2 注销类 class_destroy

void class_destroy(struct class *cls)
{
	if ((cls == NULL) || (IS_ERR(cls)))
		return;

	class_unregister(cls);
}

四. 总线设备驱动类框架的搭建(eg:platform)
1.定义总线类型结构体

struct bus_type platform_bus_type = {  
    .name       = "platform",       //总线名   
    .dev_attrs  = platform_dev_attrs,   //设备属性   
    .match      = platform_match,       //匹配函数   
    .uevent     = platform_uevent,      //事件函数   
    .pm     = &platform_dev_pm_ops, //电源管理函数集   
};

2.定义总线作为设备的设备结构体--总线本身也是一个设备

struct device platform_bus = {
	.init_name	= "platform",
};

3.注册作为设备的总线设备

platform_bus_init()-->device_register(&platform_bus)
4.注册总线

platform_bus_init()-->bus_register(&platform_bus_type)

5.这里可以是设备注册或者设备驱动注册(以设备注册先为例)

5.1 定义总线下的设备结构体

static struct platform_device platform_device_1 = {  
    .name   = "paltform_1",  
    .id = -1,               //设备id一般都设置为-1   
};

5.1.1 注册设备

platform_device_register(&platform_device_1); //-->platform_device_add-->device_add(&pdev->dev)

6.定义设备驱动

static struct platform_driver platform_1_driver = {
	.driver = {
		.name = "platform_1",
		.owner = THIS_MODULE,
	},
	.probe = platform_1_probe,
	.remove = platform_1_remove,
};

7.注册设备驱动

platform_driver_register(&platform_1_driver);	//-->driver_register(&drv->driver)

8. 至于类的添加

class_create(THIS_MODULES,"platfrom_1");

gjy938815

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
总线、设备、驱动、类 .

分类： linux设备驱动 2012-12-18 21:40 353人阅读评论(0)收藏举报一. 总线、设备、驱动、类各自的相关结构体 1.总线 1.1 总线类型结构体struct bus_type { const char *name; //总线类型名 struct bus_attribute *bus_attrs; //总线属性
复制链接

扫一扫