Linux--字符设备驱动开发框架（二）

在Linux–字符设备驱动开发框架（一）中已经梳理了一下字符设备驱动开发的基本流程，但是其中所用的函数不太符合现在开发习惯，有一些缺点。比如：
1）设备号分配
在（1）中需要我们手动定义一个主设备号，但是没法指定次设备号，就默认为0—0~1048575(2^20-1)，完全被占用，造成极大浪费。除此之外，主设备号也不是我们随心所欲定义的，必须提前知道他有没有被占用。
2）设备节点
在（1）中设备节点还需要通过mknod手动创建加载，不人性化。
3）新的开发API
（1）分配设备号

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
			const char *name)
/* @dev: output parameter for first assigned number  即我们要创建的设备号
 * @baseminor: first of the requested range of minor numbers 次设备的申请起点（一般从0开始）
 * @count: the number of minor numbers required 连续申请的次设备个数（注意，主设备号一样）
 * @name: the name of the associated device or driver 设备名字
 * @Returns zero or a negative error code
 * /

（2）释放设备号

void unregister_chrdev_region(dev_t from, unsigned count)
//@from: the first in the range of numbers to unregister 直接就是前面申请的设备号
// @count: the number of device numbers to unregister    要释放的设备个数

举例

#define NEW_CHRDEV_NAME "new_chrdev"  //设备名字
#define DEV_COUNT //要申请的设备个数
dev_t devid;//dev_t 起始就是usigned int devid是设备号，包括了主设备号和次设备号
//申请设备号
alloc_chrdev_region(devid,0,DEV_COUNT,NEW_CHRDEV_NAME );
//我们可以取出来major，minor来看看
usigned int major;
usigned int minor;
major = MAJOR(devid);//取出主设备号
minor = MINOR(devid);//取出次设备号

//释放设备号
unregister_chrdev_region(devid,DEV_COUNT );

（3）新注册设备API

//需要用到以下两个函数配合使用
/*
初始化设备结构体
@cdev 要初始化的结构体
@fops 设备操作集合
*/
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;
}
/*
加载字符设备到系统中
@p 设备的cdev的结构体 在include/linux/cdev.h 
@dev 设备号
@count 申请的设备个数（次设备个数）
@失败时返回负值
*/
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
	int error;

	p->dev = dev;
	p->count = count;

	error = kobj_map(cdev_map, dev, count, NULL,
			 exact_match, exact_lock, p);
	if (error)
		return error;

	kobject_get(p->kobj.parent);

	return 0;
}
/*
卸载驱动的时候 从系统中移除设备
@p 指的就是cdev结构体
@dev 设备号
@count 要添加的设备数量
*/
void cdev_del(struct cdev *p)
{
	cdev_unmap(p->dev, p->count);
	kobject_put(&p->kobj);
}

（4）创建结构体

struct new_char_dev{
	struct cdev cdev;//上面初始化设备和加载时要用
	struct class *class; // 自动创建设备节点要用
	struct device *device;//自动创建设备节点要用
	dev_t devid;//设备号 
	usigned int major;
	usigned int minor;
}newchrdev;

//其中cdev结构体如下：
struct cdev {
	struct kobject kobj;
	struct module *owner;
	const struct file_operations *ops;
	struct list_head list;
	dev_t dev;
	unsigned int count;
};

（5）创建 file_operations

/*
字符设备操作集
里面的内容根据需要增添
*/
static const struct file_operations new_dev_fops = 
{
    .owner = THIS_MODULE,
    .write = led_write,
    .open = led_open,
    .release = led_release,
};

（6）自动创建设备节点

//第一步需要先创建一个class类，class是一个结构体
/*
@owner  THIS_MODULE
@name   设备名
&返回时一个class结构体
*/
#define class_create(owner, 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)
/*
卸载驱动的时候要删除加载时创建的类
*/
void class_destroy(struct class *cls)

/*
第二步创建设备
@class 前面创建的
@parent 一般写NULL
@devt 设备号
@drvdata 一般写NULL
@fmt 设备名字
*/
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;
}

/*
在卸载设备的时候 要删除设备节点
@class 创建的class
@devt 设备号
*/
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);
	}
}

整体举例

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h> 
#include <linux/ide.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/cdev.h>

#define NEW_CHRDEV_NAME "new_chrdev"  //设备名字
#define DEV_COUNT //要申请的设备个数

struct new_char_dev{
	struct cdev cdev;//上面初始化设备和加载时要用
	struct class *class; // 自动创建设备节点要用
	struct device *device;//自动创建设备节点要用
	dev_t devid;//设备号 
	usigned int major;
	usigned int minor;
}newchrdev;

static int newchrdev_open(struct inode *inode,struct file *filp)
{
    return 0;
}
static int newchrdev_release(struct inode *inode,struct file *filp)
{
    return 0;
}

static int newchrdev_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
       return 0;
}

/*字符设备操作集*/
static const struct file_operations led_new_dev_fops = 
{
    .owner = THIS_MODULE,
    .write = newchrdev_write,
    .open = newchrdev_open,
    .release = newchrdev_release,
};
/*入口*/
static int __init newchrdev_init(void)  //把初始化放在了入口函数，放在open也可以
{
	int ret;
	newchrdev.major = 0;
   //申请设备号
    if(newchrdev.major) //假设我们定义过设备号了
    {
        newchrdev.devid = MKDEV(newchrdev.major,0);//定义了主设备号 也就是将major 和minor(此处为0)组合成devid
        ret = register_chrdev_region(newchrdev.devid , DEV_COUNT  ,NEW_CHRDEV_NAME );//返回值为0成功，负值失败
    }else
    {
        ret = alloc_chrdev_region(&newchrdev.devid,0,DEV_COUNT ,NEW_CHRDEV_NAME );
        newchrdev.major = MAJOR(newchrdev.devid);//从devid中获取主设备号即高12位
        newchrdev.minor = MINOR(newchrdev.devid);//从devid中获取次设备号即低20位
    }
    printk("newdev_init\r\nnewdev major = %d, newdev minor = %d\r\n",newchrdev.major ,newchrdev.minor);
    if(ret < 0)
    {
        printk("register fail\r\n");
        return -EIO;//官方定义的错误标记
    }
     /*注册字符设备*/
    newchrdev.cdev.owner = THIS_MODULE;
    cdev_init(&newchrdev.cdev,&led_new_dev_fops);//初始化
    ret = cdev_add(&newchrdev.cdev,newchrdev.devid,1);//添加设备
    if(ret != 0)
        return  EIO;
    /*自动创建设备节点*/
    //1，创建类
    newchrdev.class = class_create(THIS_MODULE,NEW_CHRDEV_NAME );
    if(IS_ERR(newchrdev.class))
        return PTR_ERR(newchrdev.class);
    //2，创建设备
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEW_CHRDEV_NAME );
    if(IS_ERR(newchrdev.device))
        return PTR_ERR(newchrdev.device);
    return 0;
}

static void __exit newchrdev_exit(void)
{
     /*注销字符设备号及设备*/
    unregister_chrdev_region(newchrdev.devid, DEV_COUNT );
    //删除字符设备
    cdev_del(&newchrdev.cdev );
    //删除设备节点的类
    class_destroy(newchrdev.class);
    //删除设备
    device_destroy(newchrdev.class,newchrdev.devid);
    printk("exit\r\n");
}
/*函数出入口*/
module_init(newchrdev_init);
module_exit(newchrdev_exit);

/*协议和作者信息*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("name");

补充
1）设置文件私有数据

//往往在open函数中加入
file->private_data = &newchrdev;
//file指的是open函数的形参
//newchrdev指的是我们在前面创建的结构体变量名

通过私有数据，就可以在其他函数中使用

struct new_char_dev *dev = file -> private_data;
//就可以使用dev->.... 访问结构体成员变量了

举例

static int newchrdev_open(struct inode *inode,struct file *filp)
{
	file->private_data = &newchrdev;
    return 0;
}
static int newchrdev_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	struct new_char_dev *dev = file -> private_data;
	...
	return 0;
}

2）goto的用法
前面都是直接用return …进行操作
但是如果出现错误直接return 是不专业的
可以写相应的goto 函数对其进行处理
举例：

goto cs_release;
...
cs_release:
	cm4000_release(link);

就先写到这，有遗漏再补充
只为学习记录，有问题恳请各位老师批评指正
感激不尽