Linux字符设备驱动基础（三）

- 日理万妓 2022-01-22 10:13 268阅读 0赞

# Linux字符设备驱动基础（三） #

## 6 创建设备节点 ##

### 6.1 手动创建设备节点 ###

查看申请的设备名及主设备号：

cat /proc/devices
    # cat /proc/devices
    Character devices:
      1 mem
      2 pty
      3 ttyp
      4 /dev/vc/0
      4 tty
      5 /dev/tty
      5 /dev/console
      5 /dev/ptmx
      7 vcs
     10 misc
     11 module_test
    
    Block devices:
      8 sd
    93 spinor
    259 blkext

Mknod用法：

# mknod
    BusyBox v1.27.1 (2018-10-22 13:38:05 CST) multi-call binary.
    
    Usage: mknod [-m MODE] NAME TYPE MAJOR MINOR
    
    Create a special file (block, character, or pipe)
    
            -m MODE Creation mode (default a=rw)
    TYPE:
            b       Block device
            c or u  Character device
            p       Named pipe (MAJOR and MINOR are ignored)
    如：mknod module_test b 11 0

### 6.2 自动创建设备节点 ###

利用udev（mdev）来实现设备文件的自动创建，首先应保证支持udev（mdev），由busybox配置。

在驱动用加入对udev 的支持主要做的就是：在驱动初始化的代码里调用class\_create(…)为该设备创建一个class，再为每个设备调用device\_create(…)创建对应的设备。

内核中定义的struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class\_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用 device\_create(…)函数来在/dev目录下创建相应的设备节点。

这样，加载模块的时候，用户空间中的udev会自动响应 device\_create()函数，去/sysfs下寻找对应的类从而创建设备节点。  
第一步：创建class类

Struct class chardev_test_class = class_create(THIS_MODULE, CHARDEV_DRV_NAME);

源码如下：

/* This is a #define to keep the compiler from merging different
     * instances of the __key variable */
    #define class_create(owner, name)		\
    ({						\
    	static struct lock_class_key __key;	\
    	__class_create(owner, name, &__key);	\
    })
    参数：
    -Owner：THIS_MODULE；
    -Name：class name。
    
    /**
     * class_create - create a struct class structure
     * @owner: pointer to the module that is to "own" this struct class
     * @name: pointer to a string for the name of this class.
     * @key: the lock_class_key for this class; used by mutex lock debugging
     *
     * This is used to create a struct class pointer that can then be used
     * in calls to device_create().
     *
     * Returns &struct class pointer on success, or ERR_PTR() on error.
     *
     * Note, the pointer created here is to be destroyed when finished by
     * making a call to class_destroy().
     */
    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);
    	if (retval)
    		goto error;
    
    	return cls;
    
    error:
    	kfree(cls);
    	return ERR_PTR(retval);
    }

class销毁函数：

/**
     * class_destroy - destroys a struct class structure
     * @cls: pointer to the struct class that is to be destroyed
     *
     * Note, the pointer to be destroyed must have been created with a call
     * to class_create().
     */
    void class_destroy(struct class *cls)
    {
    	if ((cls == NULL) || (IS_ERR(cls)))
    		return;
    
    	class_unregister(cls);
    }

第二步：创建device

Struct device *dev = device_create(chardev_test_class, &pdev->dev,
    				     MKDEV(major, minor), NULL,
    				     CHARDEV_DRV_NAME);
    参数：
    	-class：该设备需绑定的class类；
    	-parent：该设备的父设备；
    	-devt：该设备的设备号；
    	-drvdata：设备私有参数；
    	-fmt：	设备名
    
    /**
     * device_create - creates a device and registers it with sysfs
     * @class: pointer to the struct class that this device should be registered to
     * @parent: pointer to the parent struct device of this new device, if any
     * @devt: the dev_t for the char device to be added
     * @drvdata: the data to be added to the device for callbacks
     * @fmt: string for the device's name
     *
     * This function can be used by char device classes.  A struct device
     * will be created in sysfs, registered to the specified class.
     *
     * A "dev" file will be created, showing the dev_t for the device, if
     * the dev_t is not 0,0.
     * If a pointer to a parent struct device is passed in, the newly created
     * struct device will be a child of that device in sysfs.
     * The pointer to the struct device will be returned from the call.
     * Any further sysfs files that might be required can be created using this
     * pointer.
     *
     * Returns &struct device pointer on success, or ERR_PTR() on error.
     *
     * Note: the struct class passed to this function must have previously
     * been created with a call to class_create().
     */
    struct device *device_create(struct class *class, struct device *parent,
    			     dev_t devt, void *drvdata, const char *fmt, ...)
    {
    	va_list vargs;
    	struct device *dev;
    
    	va_start(vargs, fmt);
    	dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
    	va_end(vargs);
    	return dev;
    }

设备销毁函数：

/**
     * device_destroy - removes a device that was created with device_create()
     * @class: pointer to the struct class that this device was registered with
     * @devt: the dev_t of the device that was previously registered
     *
     * This call unregisters and cleans up a device that was created with a
     * call to device_create().
     */
    void device_destroy(struct class *class, dev_t devt)
    {
    	struct device *dev;
    
    	dev = class_find_device(class, NULL, &devt, __match_devt);
    	if (dev) {
    		put_device(dev);
    		device_unregister(dev);
    	}
    }