linux设备驱动day3-驱动介绍，注册和加载实现

linux设备的分类：

字符设备：

串口、终端、触摸屏、键盘

查看方式：ls -l /dev 以c开头的文件都是字符设备文件。

块设备：

Flash、ramdisk(内存磁盘)、harddisk(硬盘)

查看方式：ls -l /dev 以b开头的文件

网络设备：

ifconfig -a

Linux抽象了对硬件的处理，所有的硬件设备都可以看作普通文件一样看待，可以使用和操作文件相同的，标准的系统调用接口来完成对设备的打开，关闭，读写和IO控制操作

字符设备和块设备是通过文件节点访问的，在Linux文件系统中，可以找到或者mknod创建设备对应的文件名，称为设备文件。

块设备和字符设备有两个数字分别是主设备号和次设备号，普通文件只有文件大小。

同一个驱动程序可以管理多个设备，依靠次设备号来区别。

主设备号标识该设备的种类，也标识了该设备所使用的驱动程序。

次设备号：标识使用同一设备驱动程序的不同硬件设备。次设备号只能在驱动程序内部使用，系统内核直接把次设备号传递给驱动程序，由驱动程序去管理。

设备驱动程序有三个接口：

（加载接口）系统引导接口：系统各设备初始化, 激活，运行驱动程序

（控制硬件接口）交互接口：驱动程序与具体设备间进行交互

（系统调用接口）实现接口：操作系统内核 通过数据结构file_operations实现具体的函数功能

软中断切换用户态进入内核态，地址空间不一样，不能直接对地址操作

Linux内核加载驱动程序：

1、系统启动时，通过代码自身加载模块，称为静态编译入内核，驱动程序开发完毕口一般这么使用

2、Linux系统启动后，通过insmod命令加载模块，称为动态加载。

驱动标识：文件节点，设备号

接口的实现：

编写驱动要遵守一定的协议：

MODULE_AUTHOR(” “);

MODULE_LICENSE(“GPL”); //这是必须的

MODULE_DESCRIPTION(” “);

MODULE_ALIAS(” “);

加载接口：int __init hello_init(void) （加载）、void __exit hello_exit(void)（卸载）(表示运行一次)

注册接口：module_init(hello_init);//模块加载函数

module_exit(hello_exit);//模块卸载函数

在内核里打印用printk，不能用printf函数

编译驱动程序要用Makefile来编译

生成的xxxx.ko文件放到板子上进行加载

加载命令：insmod xxxxx.ko 把内核模块加入到系统中， 会调用之前定义的init函数

查看动态加载的内核模块：lsmod 可以看到刚刚加载的内核模块

驱动程序打印的信息会打印到系统日志中 /var/log/syslog

卸载模块：rmmod xxxx， 会调用定义的exit函数

查看某个模块的信息：modinfo xxxxx.ko

申请设备号(在init时申请)：register_chrdev(arg1, arg2, arg3);//注册字符设备，返回设备号

arg1 = 0 表示由系统分配设备号，arg1 > 0 表示自己规定一个，但不能冲突

arg2 是一个字符串，表示设备的名字

arg3 是一个结构体指针，（struct file_operations）结构体成员是一系列函数指针， 要给成员函数赋值，定义出相关函数（系统调用相关接口）

定义出一系列的函数实际就是在实现系统调用接口（open, release, read, write）

释放设备号（在exit时释放）：unregister_chrdev(arg1, arg2);

arg1是要释放的主设备号

arg2 是出册时的设备名字

结构体的定义包含在头文件

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/slab.h>

MODULE_AUTHOR("CYW");
MODULE_LICENSE("GPL"); //必须要写的遵守协议
MODULE_DESCRIPTION("A simple test for kernel module");
MODULE_ALIAS("a simple module");

struct file_operations hello_fops = { //定义一个结构体
.open = hello_open,
.release = hello_release,
.read = hello_read,
.write = hello_write,
}; //部分成员初始化

#define DEVICE_NAME   "Hello_Driver" //注册成功会出现在/proc/devices中
int major;

static int __init hello_init(void) //加载驱动
{
printk(DEVICE_NAME":Hello world in kernel module\n"); //不能用printf

major = register_chrdev(0, DEVICE_NAME, &hello_fops);//向内核申请主设备号，需要结构体地址参数

if(major < 0){ //申请失败
printk(DEVICE_NAME":register %s fail\n", DEVICE_NAME);
return major;
}
printk(DEVICE_NAME":got major number: %d\n", major);
return 0;
}

static void __exit hello_exit(void) //卸载驱动
{
printk(DEVICE_NAME":Hello world in exit\n"); //不能用printf
unregister_chrdev(major, DEVICE_NAME); //释放资源，根据主设备号和名字
}

module_init(hello_init);//模块加载所用函数
module_exit(hello_exit);//模块卸载所用函数

int hello_open(struct inode *pinode, struct file *pfile) //打开驱动
{
printk(DEVICE_NAME":hello_open\n");
wr_pos = 0;
rd_pos = 0;
pbuff =(unsigned char *)kmalloc(BUFF_SIZE, 0);
if(pbuff == NULL){
printk(DEVICE_NAME":kmalloc fail\n");
return 1;
}
return 0;
}
int hello_release(struct inode *pinode, struct file *pfile) //释放驱动
{
printk(DEVICE_NAME":hello_release\n");
kfree(pbuff);
return 0;
}
/*
*__user *buff, 用户空间内存地址
*
*/

ssize_t hello_read(struct file *pfile, char __user *buff, size_t bufsize, loff_t *poffset) //读驱动
{
int i = 0;
for(i = 0; i < bufs
4000
ize && wr_pos - rd_pos > 0; i++){ //循环拷贝一个字节到用户空间
put_user(pbuff[rd_pos % BUFF_SIZE] , buff+i);
rd_pos++;
}
if(i >= 0)
return i;
#if 0
int len = wr_pos - rd_pos;
printk(DEVICE_NAME":hello_read\n");
if( len > 0){
int err = copy_to_user(buff, pbuff+(rd_pos % BUFF_SIZE), len > bufsize ? bufsize : len); //把内核空间的数据读到用户空间
rd_pos += len > bufsize ? bufsize : len;
if(!err)
return len > bufsize ? bufsize : len;
}
#endif
return -1;
}

ssize_t hello_write(struct file *pfile, const char __user *buff, size_t bufsize, loff_t *poffset) //写驱动
{
int i = 0;
for(i = 0; i < bufsize && free_size() > 0; i++){ //拷贝一个字节到内核空间
get_user(pbuff[wr_pos % BUFF_SIZE] , buff+i);
wr_pos++;
}
if(i >= bufsize)
return bufsize;

#if 0
int free_len = BUFF_SIZE - (wr_pos - rd_pos);
printk(DEVICE_NAME":hello_write\n");
if( free_len > bufsize){
int err = copy_from_user(pbuff+wr_pos % BUFF_SIZE, buff, bufsize);//把用户空间的数据写道内核空间
wr_pos += bufsize;
if(!err)
return bufsize;
}
#endif
return -1;
}