欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

字符设备驱动

程序员文章站 2022-07-14 17:38:09
...

1.字符设备驱动框架

先来一张网上盗来的图,整个框架一目了然
字符设备驱动

2.驱动初始化

2.1分配cdev

cdev结构体,其中的module和file_operations都是在在cdev_init中初始化
struct cdev {
    struct kobject kobj;
    struct module *owner; /*通常为THIS_MODULE*/
    struct file_operations *ops; /*在cdev_init()这个函数里面与  cdev结构联系起来*/
    struct list_head list;
    dev_t dev; /*设备号*/
    unsigned int count;
 };

分配cdev主要就是分配一个cdev结构体和设备号,以下是代码示例:

/* 定义cdev*/
 struct cdev btn_cdev;
/* 申请设备号*/
  if(major){
      //静态
      dev_id = MKDEV(major, 0);
      register_chrdev_region(dev_id, 1, "button");
 } else {
     //动态
     alloc_chardev_region(&dev_id, 0, 1, "button");
     major = MAJOR(dev_id);
}

1). linux内核中,用dev_t描述设备号

typedef u_long dev_t;

高12位表示主设备号,地20位表示次设备号,可以使用下列宏将dev_t得到主次设备号

MAJOR(dev_t dev);      //主设备号                 
MINOR(dev_t dev);      //次设备号   
MKDEV(int major,int minor);//设备号

2). 申请设备号
静态:

int register_chrdev_region(dev_t first, unsigned int count, const char *name); 

first:要分配的设备编号范围的起始值
count:连续设备的编号的个数
name:和该设备编号范围关联的设备名称,他将出现在/proc/devices和 sysfs中。此函数成功返回0,失败返回负的错误码。
适用于已经知道主设备号的情况

动态:

int alloc_chrdev_region(dev_t *dev, unsigned int  firstminor, unsigned int count, const char *name) 

dev :申请到的设备编号
firstminor:要使用的第一个此设备编号,一般为0
count:是连续设备的编号的个数,一般为1;name同上
适用于不知道主设备号的情况

3). 在不用的时候需要释放掉设备号,对应的释放函数为:

unregister_chrdev_region(dev_t dev, unsigned int count); 
/*例:*/
unregister_chrdev_region(MKDEV(major, 0), 1); 

2.2初始化cdev

void cdev_init(struct cdev *, struct file_operations *);

cdev_init()函数用于初始化 cdev 的成员,并建立 cdev 和 file_operations 之间的连接。

/*常用设备操作集合*/
 static struct file_operations btn_fops = {
.owner = THIS_MODULE,
.open = button_open,
.release = button_close,
.read = button_read
};

2.3注册cdev

int cdev_add(struct cdev *, dev_t, unsigned);

向系统注册一个cdev

3.自动创建设备节点
包含头文件#include <linux/device.h>
以前是在驱动模块加载之后,调用mknod创建设备节点,这种方式基本已经被抛弃,现在使用以下的方法创建设备节点:

1).

struct class *class_create(struct module *owner, const char *name)
owner : 一般为 THIS_MODULE
name : 创建的class类名

对应是在/sys/class/下创建类目录

2 ).

 struct class_device *device_create(struct class   *cls,
                            struct class_device *parent,
                            dev_t               devt,
                            void        *drvdata,
                            const char          *fmt, ...)
struct class : class_create()返回值,必须在本函数调用之前先被创建
parent :父节点指针
devt :设备号,如果devt不为0,创建设备文件
drvdata :被添加到该设备回调的数据
fmt :设备名称

对应是在/dev/下创建设备节点
例子:
device_create(batman_class, NULL, MKDEV(tmp_major, 0), NULL, "batman-adv");

注意:在删除模块的时候要使用以下两个函数删除创建的文件

device_destroy(struct class *cls, dev_t devt);
class_destroy(struct class *cls);

注意两个函数的调用顺序

4.创建sysfs属性节点

int device_create_file(struct device *dev,  const struct device_attribute *attr)

注意:第一个参数为device型,不是cdev,这个参数一般使用device_create()的返回值
device_attribute : 使用DEVICE_ATTR(_name, _mode, _show, _store)初始化,注意name的形式

DEVICE_ATTR(_name, _mode, _show, _store)

_name:名称,也就是将在sysfs中生成的文件名称。
_mode:上述文件的访问权限,与普通文件相同,UGO的格式。只读0444,只写0222,或者读写都行的0666。
_show:显示函数,cat该文件时,此函数被调用。
_store:写函数,echo内容到该文件时,此函数被调用

代码实例:


/*初始化并注册cdev*/  
static void cdevdemo_setup_cdev(struct cdevdemo_dev *dev, int index)  
{  
    printk(KERN_NOTICE "======== cdevdemo_setup_cdev 1");     
    int err, devno = MKDEV(cdevdemo_major, index);  
    printk(KERN_NOTICE "======== cdevdemo_setup_cdev 2");  

    /*初始化一个字符设备,设备所支持的操作在cdevdemo_fops中*/     
    cdev_init(&dev->cdev, &cdevdemo_fops);  
    printk(KERN_NOTICE "======== cdevdemo_setup_cdev 3");     
    dev->cdev.owner = THIS_MODULE;  
    dev->cdev.ops = &cdevdemo_fops;  
    printk(KERN_NOTICE "======== cdevdemo_setup_cdev 4");     
    err = cdev_add(&dev->cdev, devno, 1);  
    printk(KERN_NOTICE "======== cdevdemo_setup_cdev 5");  
    if(err)  
    {  
        printk(KERN_NOTICE "Error %d add cdevdemo %d", err, index);   
    }  
}  

static ssize_t cdevrw_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    sprintf(buf,"read,demo temp is %d/n",temp);
    return 0;
}

static ssize_t cdevrw_store(struct device *dev, struct device_attribute *attr,
                                   const char *buf, size_t size)
{
    sscanf(buf, "%d", &temp);

    printk(KERN_NOTICE "write,demo temp is %d/n",temp);
    return size;
}

static DEVICE_ATTR(cdevrw, (S_IRUGO | S_IWUSR | S_IWGRP),
                               cdevrw_show,
                               cdevrw_store);

static DEVICE_ATTR(cdevrw1, (S_IRUGO | S_IWUSR | S_IWGRP),cdevrw_show,cdevrw_store);
static DEVICE_ATTR(cdevrw2, (S_IRUGO | S_IWUSR | S_IWGRP),cdevrw_show,cdevrw_store);

static struct attribute *cdev_attrs[] = {
    &dev_attr_cdevrw.attr,
    &dev_attr_cdevrw1.attr,
    &dev_attr_cdevrw2.attr,
    NULL,
};

static const struct attribute_group cdev_attr_grp = {
    .attrs = cdev_attrs,
};

int cdevdemo_init(void)  
{  
    printk(KERN_NOTICE "======== cdevdemo_init ");    
    int ret;  
    dev_t devno = MKDEV(cdevdemo_major, 0);  

    struct device *devdemo;
    /*申请设备号,如果申请失败采用动态申请方式*/  
    if(cdevdemo_major)  
    {  
        printk(KERN_NOTICE "======== cdevdemo_init 1");  
        ret = register_chrdev_region(devno, 1, "cdevdemo");  
    }else  
    {  
        printk(KERN_NOTICE "======== cdevdemo_init 2");  
        ret = alloc_chrdev_region(&devno,0,1,"cdevdemo");  
        cdevdemo_major = MAJOR(devno);  
    }  
    if(ret < 0)  
    {  
        printk(KERN_NOTICE "======== cdevdemo_init 3");  
        return ret;  
    }  
    /*动态申请设备结构体内存*/  
    cdevdemo_devp = kmalloc(sizeof(struct cdevdemo_dev), GFP_KERNEL);  
    if(!cdevdemo_devp)  /*申请失败*/  
    {  
        ret = -ENOMEM;  
        printk(KERN_NOTICE "Error add cdevdemo");     
        goto fail_malloc;  
    }  

    memset(cdevdemo_devp,0,sizeof(struct cdevdemo_dev));  
    printk(KERN_NOTICE "======== cdevdemo_init 3");  
    cdevdemo_setup_cdev(cdevdemo_devp, 0);  

    /*下面两行是创建了一个总线类型,会在/sys/class下生成cdevdemo目录 
      这里的还有一个主要作用是执行device_create后会在/dev/下自动生成 
      cdevdemo设备节点。而如果不调用此函数,如果想通过设备节点访问设备 
      需要手动mknod来创建设备节点后再访问。*/  
    cdevdemo_class = class_create(THIS_MODULE, "cdevdemo");  
    devdemo = device_create(cdevdemo_class, NULL, MKDEV(cdevdemo_major, 0), NULL, "cdevdemo");  

    //device_create_file(devdemo,&dev_attr_cdevdemo);
    sysfs_create_group(&devdemo->kobj,&cdev_attr_grp);

    printk(KERN_NOTICE "======== cdevdemo_init 4");  
    return 0;  

    fail_malloc:  
        unregister_chrdev_region(devno,1);  
}  

void cdevdemo_exit(void)    /*模块卸载*/  
{  
    printk(KERN_NOTICE "End cdevdemo");   
    device_destroy(cdevdemo_class,MKDEV(cdevdemo_major,0));
    class_destroy(cdevdemo_class);

    cdev_del(&cdevdemo_devp->cdev);  /*注销cdev*/  
    kfree(cdevdemo_devp);       /*释放设备结构体内存*/  
    unregister_chrdev_region(MKDEV(cdevdemo_major,0),1);    //释放设备号  
}  

MODULE_LICENSE("Dual BSD/GPL");  
module_param(cdevdemo_major, int, S_IRUGO);  
module_init(cdevdemo_init);  
module_exit(cdevdemo_exit);