驱动开发之字符设备框架

字符设备框架：

框架:

通用的接口(主体是由linux社区的内核维护者实现的，小部分由某些厂家实现的)

1.字符设备框架
每次读写数据都是按照字节的方式，对应的设备文件类型是c
常见的字符设备——鼠标、显示器、摄像头、按键、蜂鸣器、adc
2.块设备框架
每次读写是一个块的大小，每个块是512字节或者是大于512的2的n次方。
对应的设备文件类型是b
常见的块设备——硬盘，u盘，emmc，nandflash，norflash
3.网络设备框架

为什么需要使用框架？

当需要通过应用程序调用驱动，继而操作硬件，此时需要使用框架

mknod "/dev/设备文件" c 主设备号 次设备号
在/dev下产生设备文件，这个文件会和设备号绑定。

设备号本身是一个32位无符号整数，前12位是主设备号，后20位是次设备号。

主设备号一般代表一类设备，次设备号代表某类设备的具体设备。

驱动代码中必须要和设备号绑定。
所以一旦设备文件和设备号也绑定了，就可以说明通过设备文件找到驱动。
应用程序是可以打开文件的，一旦应用程序打开了一个设备文件进而可以让应用程序找到驱动。

设备号 = 主设备号 << 20 | 次设备号;

设备号 = MKDEV(主设备号，次设备号);

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

功能:将设备号注册到文件系统中（静态）
参数1:起始设备号
参数2:连续的设备的个数
参数3:以字符串的形式出现在/proc/devices文件中，用来和主设备号绑定。
注意:肯定不是设备文件名
只能保证驱动和设备文件可以匹配，但是驱动还未给应用程序提高交互接口。

void unregister_chrdev_region(dev_t from, unsigned count)
功能:注销设备号

在驱动中如何给应用程序提高交互接口？

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
功能：给cdev结构体初始化
struct cdev {在内核中专门用来描述字符设备的一个结构体
 struct kobject kobj;//见到kobject或者kset作用就是用来创建文件夹。
 struct module *owner;//只需要传递THIS_MODULE
 const struct file_operations *ops;
 struct list_head list;
 dev_t dev;//设备号
 unsigned int count; //设备个数 
 };

---

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
功能:在驱动层中封装接口
参数1:
参数2:起始设备号
参数3:连续的设备个数

void cdev_del(struct cdev *p)
功能:删除字符设备

struct inode 
{
　　unnion
　　{
　　　　struct cdev *i_cdev;——> 驱动中定义的cdev结构体
 6　　 };
};
在内核中每当创建出一个文件时就会在内核中产生一个inode结构体。专门用来描述文件的静态信息。



struct file 
{
　　 struct inode *f_inode;——》指向inode结构体
　　 const struct file_operations *f_op;——》驱动中的file_operations
};
只要打开一次文件在内核中就会产生一个新的file结构体，专门描述动态信息。

代码：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>

dev_t devno;
struct cdev cdev;

int demo_open(struct inode *inode,struct file *filp)
{
    printk("demo_open
");
    return 0;
}

struct file_operations fops = {
    .owner = THIS_MODULE,//当前模块
    .open = demo_open,
};
//fops.open = demo_open;

int demo_init(void)
{
    int ret;
    //让设备号和驱动绑定
    devno = MKDEV(500,0);    
    ret = register_chrdev_region(devno,1,"demo");

    cdev_init(&cdev,&fops);
    cdev_add(&cdev,devno,2);
    return 0;
}
module_init(demo_init);

void demo_exit(void)
{
    cdev_del(&cdev);
    unregister_chrdev_region(devno,1);
    return ;
}
module_exit(demo_exit);
MODULE_LICENSE("GPL");

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, const char *argv[])
{
    int fd;

    fd = open("/dev/demo",O_RDWR);
    if(fd == -1)
    {
        perror("open");
        return -1;
    }

    sleep(5);

    close(fd);
    return 0;
}

ifeq ($(KERNELRELEASE),)
PWD = $(shell pwd)
KERNEL_DIR = /home/linux/linux-3.14/
#KERNEL_DIR = /lib/modules/$(shell uname -r)/build/

#start:
modules:
    make -C $(KERNEL_DIR) M=$(PWD) modules

#end:
clean:
    make -C $(KERNEL_DIR) M=$(PWD) clean
else 
obj-m += demo3.o
endif

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)
参数1:
参数2:起始次设备号
参数3:次设备号个数
参数4:出现在/proc/devices文件中，用来和主设备号绑定。

static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)
功能:搭建字符设备框架(包含了动态或静态注册设备号，动态给cdev申请空间，cdev_init，cdev_add)
参数1:主设备号或者0
入果传递的是主设备号，那么会使用静态注册
如果传递的是0，会使用动态注册
参数2:出现在/proc/devices文件中，用来和主设备号绑定。
参数3:
返回值:如果参数1传递主设备号，正常返回0
如果参数1传递的是0，返回值为主设备号

static inline void unregister_chrdev(unsigned int major, const char *name)
功能:注销字符设备框架
参数1:主设备号 
参数2:/proc/devices文件中的名称

代码：

alloc_chrdev_region

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>

MODULE_LICENSE("GPL");

int major;

int demo_open(struct inode *inode,struct file *filp)
{
    return 0;
}

int demo_close(struct inode *inode,struct file *filp)
{
    return 0;
}
struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = demo_open,
    .release = demo_close,
};

int demo_init(void)
{
    major = register_chrdev(0,"demo",&fops);
    return 0;
}
module_init(demo_init);

void demo_exit(void)
{
    unregister_chrdev(major,"demo");
    return;
}
module_exit(demo_exit);

如何自动创建设备文件？

struct class *class_create(struct module *owner, const char *name);
功能:在/sys/class目录下创建出一个文件夹(设备类)，文件夹名称就是参数2

struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)
功能:创建设备文件
参数1:class_create的返回值
参数2:父类设备，如果没有传递NULL
参数3:设备号 
参数4:给当前设备传递的参数
参数5:出现在/sys/class/demo目录下的一个软链接文件，同时固定了设备文件的名称
参数6:不可描述

代码：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>

MODULE_LICENSE("GPL");

int major;
struct class *cls;
struct device *devs;

int demo_open(struct inode *inode,struct file *filp)
{
    return 0;
}

int demo_close(struct inode *inode,struct file *filp)
{
    return 0;
}
struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = demo_open,
    .release = demo_close,
};

int demo_init(void)
{
//    int i;
    major = register_chrdev(0,"demo",&fops);
    cls = class_create(THIS_MODULE,"demo");
    devs = device_create(cls,NULL,MKDEV(major,0),NULL,"demo");

#if 0
    for(i = 0;i < 3;i ++)
    {
        device_create(cls,NULL,MKDEV(major,i),NULL,"demo%d",i);
    }
#endif
    return 0;
}
module_init(demo_init);

void demo_exit(void)
{
    device_destroy(cls,MKDEV(major,0));
    class_destroy(cls);
    unregister_chrdev(major,"demo");
    return;
}
module_exit(demo_exit);

系统移植的根文件系统移植中:

etc/fstab:
sysfs /sys sysfs defaults 0 0 

将sysfs文件系统挂载到/sys，在驱动中需要调用class_create在/sys目录下创建文件夹

etc/init.d/rcS:
echo /sbin/mdev > .../hotplug 支持热插拔(动态创建设备文件)

　　挂载根文件系统的过程中，mdev会被执行，切换工作路径到/dev，执行时会去检查/sys/class目录下的所有的子目录，会在所有的子目录中去寻找dev属性文件，为了读取出dev属性文件中的主次设备号。基于device_create提供的软链接名称(设备文件名)来调用mknod函数创建设备文件。

字符设备框架

1、为什么使用框架？
   通过应用程序访问驱动

2、框架的基本操作
    模块声明
    
    struct file_operations fops = {
        .open = demo_open,
        .release = demo_close,
    };
    
    加载函数
    {
        devno = MKDEV(主设备号，次设备号);
        register_chrdev_region(起始设备号，连续设备个数,名称);
                                 //静态注册设备号，让驱动和设备号绑定
                                 //mknod "/dev/设备文件" c 主设备号 次设备号;
                                 //让设备文件和设备号绑定
                                 //间接实现通过设备号让应用程序和驱动匹配。
        cdev_init(struct cdev *,&fops);
        cdev_add(struct cdev *,起始设备号,连续的设备个数);
        //对cdev结构体初始化
        //在驱动层中封装接口
                                 
    }
    
    卸载函数
    {
        cdev_del();
        unregister_chrdev_region();
    }
    
    
    
    模块声明
    struct cdev *p;
    struct file_operations fops = {
        .open = demo_open,
        .release = demo_close,
    };
    
    加载函数
    {
        alloc_chrdev_region(dev_t *,起始次设备号,连续的设备个数,名称);
        //动态申请并且注册设备号
        
        p = kzalloc(sizeof(struct cdev),GFP_KERNEL);
        
        cdev_init(p,&fops);
        cdev_add(p,起始设备号,连续的设备个数);
        //对cdev结构体初始化
        //在驱动层中封装接口
                                 
    }
    
    卸载函数
    {
        cdev_del();
        kfree();
        unregister_chrdev_region();
    }
    
    
    模块声明
    struct cdev *p;
    struct file_operations fops = {
        .open = demo_open,
        .release = demo_close,
    };
    
    加载函数
    {
        //主设备号 = register_chrdev(0,名称,&fops);//搭建字符设备框架，动态注册
        register_chrdev(主设备号,名称,&fops);//返回值为0，静态注册                     
    }
    
    卸载函数
    {
        unregister_chrdev(主设备号,名称);//注销字符设备框架
    }
    
如何自动创建设备文件？
根文件系统中:
etc/fstab文件:sysfs     /sys     sysfs     defaults     0     0
              将sysfs文件系统挂载到/sys目录下
              
              tmpfs     /dev     tmpfs     defaults     0     0
              
etc/init.d/rcS: echo /sbin/mdev > .../hotplug
                /sbin/mdev -s 
                用于动态创建设备文件

根文件系统会执行mdev程序，它的源码是busybox/util-linux/mdev.c 
这个源文件执行时会先将工作路径切换到/dev 
然后扫描/sys/class下的所有子目录，目的是寻找dev属性文件(包含了主次设备号)
最后调用mknod函数来创建设备文件
                
cls = class_create(THIS_MODULE,"demo");//名称出现在/sys/class/demo 
device_create(cls,NULL,设备号,NULL,"xxx");//出现在/sys/class/demo/xxx软链接，同时是设备文件名称

-1原码: 1  30个0  1
  反码: 1  30个1  0
  补码: 32个1  《==》 FFFFFFFF
  
-4096原码: 1     18个0    1 0000 0000 0000  
     反码: 1    18个1   0 1111 1111 1111 
     补码: 1    18个1   1 0000 0000 0000   FFFFF000

(FFFFF000,FFFFFFFF] 对于一个函数返回值是否出错，内核本质上在判断返回值是否在这个范围内。