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

墨蓝 2022-01-22 10:11 335阅读 0赞

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

## 5 设备号相关操作 ##

设备号由主设备号和次设备号组成。主设备号用来标识与设备文件相连的驱动程序，用以反映设备类型；次设备号是用于驱动程序来辨别所操作的具体设备，用以区分同类型的设备。  
linux内核中，设备号用dev\_t来描述，Linux 4.14.14中定义如下：

typedef u_long dev_t;

在32位机中是4个字节，高12bit表示主设备号，低20bit表示设备号。  
1）从设备号中提取major和minor

MAJOR(dev_t dev);     MINOR(dev_t dev);

2）通过major和minor构建设备号

MKDEV(int major, int minor);

### 5.1 静态申请设备号 ###

static inline int register_chrdev(unsigned int major, const char *name,
    				  const struct file_operations *fops)
    {
    	return __register_chrdev(major, 0, 256, name, fops);
    }
    参数：
    -major：主设备号
    -name：设备名
    -fops： 文件操作集
    
    
    /**
     * __register_chrdev() - create and register a cdev occupying a range of minors
     * @major: major device number or 0 for dynamic allocation
     * @baseminor: first of the requested range of minor numbers
     * @count: the number of minor numbers required
     * @name: name of this range of devices
     * @fops: file operations associated with this devices
     *
     * If @major == 0 this functions will dynamically allocate a major and return
     * its number.
     *
     * If @major > 0 this function will attempt to reserve a device with the given
     * major number and will return zero on success.
     *
     * Returns a -ve errno on failure.
     *
     * The name of this device has nothing to do with the name of the device in
     * /dev. It only helps to keep track of the different owners of devices. If
     * your module name has only one type of devices it's ok to use e.g. the name
     * of the module here.
     */
    int __register_chrdev(unsigned int major, unsigned int baseminor,
    		      unsigned int count, const char *name,
    		      const struct file_operations *fops)
    {
    	struct char_device_struct *cd;
    	struct cdev *cdev;
    	int err = -ENOMEM;
    	//注册字符设备号
    	cd = __register_chrdev_region(major, baseminor, count, name);
    	if (IS_ERR(cd))
    		return PTR_ERR(cd);
    	//申请cdev结构体
    	cdev = cdev_alloc();
    	if (!cdev)
    		goto out2;
    
    	//初始化cdev结构体
    	cdev->owner = fops->owner;
    	cdev->ops = fops;
    	kobject_set_name(&cdev->kobj, "%s", name);
    
    	//添加字符设备
    	err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
    	if (err)
    		goto out;
    
    	cd->cdev = cdev;
    
    	return major ? 0 : cd->major;
    out:
    	kobject_put(&cdev->kobj);
    out2:
    	kfree(__unregister_chrdev_region(cd->major, baseminor, count));
    	return err;
    }

### 5.2 动态申请设备号 ###

/**
     * alloc_chrdev_region() - register a range of char device numbers
     * @dev: output parameter for first assigned number
     * @baseminor: first of the requested range of minor numbers
     * @count: the number of minor numbers required
     * @name: the name of the associated device or driver
     *
     * Allocates a range of char device numbers.  The major number will be
     * chosen dynamically, and returned (along with the first minor number)
     * in @dev.  Returns zero or a negative error code.
     */
    int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
    			const char *name)
    {
    	struct char_device_struct *cd;
    	//注册设备号
    	cd = __register_chrdev_region(0, baseminor, count, name);
    	if (IS_ERR(cd))
    		return PTR_ERR(cd);
    	*dev = MKDEV(cd->major, cd->baseminor);	//返回申请号的设备号
    	return 0;
    }
    参数：
    -dev：返回申请到的设备号
    -baseminor：第一个次设备号
    -count：申请设备数量
    -name：设备的名字

### 5.3 字符设备注册 ###

/*
     * Register a single major with a specified minor range.
     *
     * If major == 0 this functions will dynamically allocate a major and return
     * its number.
     *
     * If major > 0 this function will attempt to reserve the passed range of
     * minors and will return zero on success.
     *
     * Returns a -ve errno on failure.
     */
    static struct char_device_struct *
    __register_chrdev_region(unsigned int major, unsigned int baseminor,
    			   int minorct, const char *name)
    {
    	struct char_device_struct *cd, **cp;
    	int ret = 0;
    	int i;
    
    	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
    	if (cd == NULL)
    		return ERR_PTR(-ENOMEM);
    
    	mutex_lock(&chrdevs_lock);
    
    	if (major == 0) {	//动态注册设备
    		ret = find_dynamic_major();	//寻找最小可用的主设备号
    		if (ret < 0) {
    			pr_err("CHRDEV \"%s\" dynamic allocation region is full\n",
    			       name);
    			goto out;
    		}
    		major = ret;
    	}
    
    	//判断主设备号合法性， CHRDEV_MAJOR_MAX = 512
    	if (major >= CHRDEV_MAJOR_MAX) {
    		pr_err("CHRDEV \"%s\" major requested (%d) is greater than the maximum (%d)\n",
    		       name, major, CHRDEV_MAJOR_MAX);
    		ret = -EINVAL;
    		goto out;
    	}
    
    	cd->major = major;
    	cd->baseminor = baseminor;
    	cd->minorct = minorct;
    	strlcpy(cd->name, name, sizeof(cd->name));
    
    	i = major_to_index(major);
    
    	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
    		if ((*cp)->major > major ||
    		    ((*cp)->major == major &&
    		     (((*cp)->baseminor >= baseminor) ||
    		      ((*cp)->baseminor + (*cp)->minorct > baseminor))))
    			break;
    
    	/* Check for overlapping minor ranges.  */
    	if (*cp && (*cp)->major == major) {
    		int old_min = (*cp)->baseminor;
    		int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
    		int new_min = baseminor;
    		int new_max = baseminor + minorct - 1;
    
    		/* New driver overlaps from the left.  */
    		if (new_max >= old_min && new_max <= old_max) {
    			ret = -EBUSY;
    			goto out;
    		}
    
    		/* New driver overlaps from the right.  */
    		if (new_min <= old_max && new_min >= old_min) {
    			ret = -EBUSY;
    			goto out;
    		}
    	}
    
    	cd->next = *cp;
    	*cp = cd;
    	mutex_unlock(&chrdevs_lock);
    	return cd;
    out:
    	mutex_unlock(&chrdevs_lock);
    	kfree(cd);
    	return ERR_PTR(ret);
    }

### 5.4 注销设备号 ###

/**
     * unregister_chrdev_region() - unregister a range of device numbers
     * @from: the first in the range of numbers to unregister
     * @count: the number of device numbers to unregister
     *
     * This function will unregister a range of @count device numbers,
     * starting with @from.  The caller should normally be the one who
     * allocated those numbers in the first place...
     */
    void unregister_chrdev_region(dev_t from, unsigned count)
    {
    	dev_t to = from + count;
    	dev_t n, next;
    
    	for (n = from; n < to; n = next) {
    		next = MKDEV(MAJOR(n)+1, 0);
    		if (next > to)
    			next = to;
    		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
    	}
    }