字符设备驱动程序编写基础

《字符设备驱动程序编写基础》

本文档的Copyleft归rosetta所有，使用GPL发布，可以自由拷贝、转载，转载时请保持文档的完整性。

参考资料：《Linux设备驱动程序 第三版》，scull源码，Linux内核源码

来源：http://blog.csdn.net/rosetta/article/details/7563606

本文写了字符设备驱动编写的基础知识，以自己学习过程来记录，写的内容比较具体，也可以说是《Linux设备驱动程序》第三章字符设备驱动程序的读书笔记。

主要写怎么生成字符设备文件？字符设备文件怎么和内核模块挂钩？怎么编写一个简单的字符设备模块插入内核？怎么访问字符设备模块注册的函数？

适合入门级新手。

使用代码示例源于scull源码。

1、基本概念

*对字符设备的访问是通过文件系统的设备名称进行的，文件系统内的设备名称可通过ls /dev -l命令查看，第一列用"c"标识的为字符设备文件，

即访问字符设备是通过访问字符设备驱动的设备文件达到的。

*主设备号和次设备号

ls /dev -al

crw-r----- 1 root kmem 1, 1 04-29 11:57 mem

crw-rw---- 1 root audio 14, 2 04-29 11:58 midi

crw-rw---- 1 root audio 14, 0 04-29 11:58 mixer

crw-r--r-- 1 root root 252, 0 04-29 12:19 my_module

crw-r--r-- 1 root root 260, 1 04-29 12:20 my_module1

其中的1,14,252,260为主设备号，1, 2, 0为次设备号。

主设备号用来标识设备对应的驱动程序。

而这些设备文件可由自行创建，以上的my_module使用252号驱动程序及my_module1使用260号驱动都是由我自己添加的（当然现我在这个驱动是假使的，是不存在的）

添加字符设备文件命令：mknod /dev/my_module1 c 260 1（添加后没有任何作用，需要注册后才和驱动挂钩起作用，一会会有实例）

当前系统有哪些驱动程序可通过

[root@xxx scull]# cat /proc/devices

Character devices:

1 mem

4 /dev/vc/0

4 tty

4 ttyS

5 /dev/tty

5 /dev/console

5 /dev/ptmx

6 lp

7 vcs

10 misc

13 input

14 sound

21 sg

29 fb

116 alsa

128 ptm

136 pts

162 raw

180 usb

189 usb_device

253 scull //register_chrdev_region注册的。

253 scullp

253 sculla

次设备号由内核使用，用于正确确定设备文件所指的设备，因为多个设备文件可使用同一驱动，但需要通过次设备号来区别，这样通过次设备号可以获得一个指向内核设备的指针，

也可以理解为数组的索引，指针的偏移量。（次设备号具体有什么作用，没接触过这方面的代码，所以没什么体会）

2，在建立字符设备前，驱动程序需要首先获得设备号，可以指定一个未使用的设备号，也可以动态分配。

当驱动程序获得了一个设备号后，怎么和设备文件联系起来呢？比如当前驱动程序获得的设备号为252

那么可以使用类似mknod /dev/my_module c 252 0 来建立一个设备文件，驱动程序把此主设备号的设备文件向内核注册后即可使用。



下面看实例：

首先创建设备文件：

mknod /dev/scull0 c 253 0 (scull源码目录下的scull/scull_load可自动生成)

分配主从设备号

int result, i;

dev_t dev = 0;

if (scull_major) {//主动指定主设备号

dev = MKDEV(scull_major, scull_minor);//把主从设备号转换成dev_t类型

result = register_chrdev_region(dev, scull_nr_devs, "scull");//最后一个参数“scull"就是cat /proc/devices显示的，如上面显示。

} else {//如果不指定，则由内核自动分配主从设备号

result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,

"scull");

scull_major = MAJOR(dev);

}

if (result < 0) {

printk(KERN_WARNING "scull: can't get major %d\n", scull_major);

return result;

}

分配了主从设备号后，怎么和刚才建立的设备文件/dev/scull0关联起来呢？那就需要向内核注册了

注册的时候需要一个关键的结构体struct cdev，最关键的一个成员ops,cdev结构可以封闭在自已定义

的结构体中，也可以直接就申请一个此结构体。看scull源码：

struct scull_dev *scull_devices //他的这个scull_dev就是自己定义的，里面包含有cdev结构体

scull_setup_cdev(&scull_devices[i], i)

static void scull_setup_cdev(struct scull_dev *dev, int index)

{

int err, devno = MKDEV(scull_major, scull_minor + index);



cdev_init(&dev->cdev, &scull_fops);

dev->cdev.owner = THIS_MODULE;//默认

dev->cdev.ops = &scull_fops;//cdev结构体的ops在此初始化。

err = cdev_add (&dev->cdev, devno, 1);//真正告诉内核我初始化化完成，即向内核注册。devno

//对就的函数cdev_del从系统中移除一个设备。

/* Fail gracefully if need be */

if (err)

printk(KERN_NOTICE "Error %d adding scull%d", err, index);

}



struct file_operations scull_fops = {//这个结构体中的东西才是核心啊！

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

.ioctl = scull_ioctl,

.open = scull_open,

.release = scull_release,

};

因为单位历史因素，从一开始的2.4内核搞到现的2.6内核，所以还在延续使用老一设备接口，他们是：

register_chrdev()

和unregister_chrdev()

3,到目前为止一个简单的设备驱动模块就已经完成(完整源码请参考scull)。那么我们怎么对其操作和使用呢？

可以直接到scull/scull/ make 再执行./scull_load，进行简单的测试



读，通过cat /dev/scull进行

写，可以通过ls -al > /dev/scull

下面再写一个测试程序，演示用户层和内核层的读、写、ioctl操作。

//其中的test.h是由scull.h改过来的。

#include <stdio.h>

#include <string.h>

#include <stdlib.h>



#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <linux/sysctl.h>



#define TESTFILE "/dev/scull"

#include "test.h"



int main(int argc, char *argv[])

{

int fd = -1;

fd = open(TESTFILE, O_RDWR);

if(fd < 0)

{

printf("open error.\n");

return -1;

}



char buf[30];

if(strncmp(argv[1], "write", 5) == 0)//读和写都是比较简单的，也是容易理解。ioctl费了点神。

{

printf("write.\n");

write(fd, "hello scull.\n", 20);

}else if(strncmp(argv[1], "read", 4) == 0)

{

printf("read.\n");

read(fd, buf, 20);

printf("read buf:%s\n", buf);

}else if(strncmp(argv[1], "ioctl", 4) == 0)

{

printf("ioctl.\n");

int tmp = 111;//题外话，现在喜欢用这种风格，如果把局部变量都一起定义在开头固然整洁，但不方便看代码，还是什么时候用什么定义好。

int ret = -1;

if(ret = ioctl(fd, SCULL_IOCQQUANTUM, &tmp) < 0)//执行这个就是掉了内核里的scull_ioctl(),SCULL_IOCQQUANTUM

{

printf("ioctl error\n");

return -1;

}

printf("ret:%d, tmp:x0%0x, %d\n", ret, &tmp, tmp);//可以在ko模块中把对应的值打出来对比

}



close(fd);



return 0;

}

[root@xxx scull]# gcc test.c -Wall -g -o app

//内核层ioctl，用户层的ioctl传进来时，cmd = SCULL_IOCQQUANTUM, arg = tmp（地址相同）;

int scull_ioctl(struct inode *inode, struct file *filp,

unsigned int cmd, unsigned long arg)



//截取部分内核层ioctl

switch(cmd) {

case SCULL_IOCRESET:

scull_quantum = SCULL_QUANTUM;

scull_qset = SCULL_QSET;

break;

case SCULL_IOCSQUANTUM: /* Set: arg points to the value */

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

retval = __get_user(scull_quantum, (int __user *)arg);

break;

case SCULL_IOCTQUANTUM: /* Tell: arg is the value */

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

scull_quantum = arg;

break;

case SCULL_IOCGQUANTUM: /* Get: arg is pointer to result */

retval = __put_user(scull_quantum, (int __user *)arg);

break;

case SCULL_IOCQQUANTUM: /* Query: return it (it's positive) */

{//自己改了下这个case分析。

printk("SCULL_IOCQQUANTUM\n");//打印了此字符串。

retval = __put_user(200, (int __user *)arg);//再把arg设为200.

//return scull_quantum;

return retval;

}

下面再帖一段调试结果：

[root@xxx scull]# ./app write

write.

[root@xxx scull]# ./app read

read.

read buf:hello scull.



[root@xxx scull]# ./app ioctl

ioctl.

ret:0, tmp:x0bfd01af0, 200

[root@xxx scull]# dmesg

in func:scull_open

buf:hello scull.



in func:scull_release

in func:scull_open

kernel read buf:hello scull.



in func:scull_release

in func:scull_open

in func:scull_ioctl

cmd :27399

arg:0xbfd01af0

_IOC_TYPE(cmd):107

SCULL_IOC_MAGIC:107

SCULL_IOCQQUANTUM

in func:scull_release

[root@panlimin scull]#



本人暂时也只能理解到这么多，至于ioctl能干什么？可以从内核获得一些数据这是必然的，

看书上说还可以对其进行一系列的控制，这当然肯定可以，这么多case分支，用户层选择适合自己

的cmd就可以完成对应的操作。除了这些，它还能干吗？或者说ioctl的用法？ 除了read、write、

ioctl外，其它的比如mmap、poll操作实现等，内存共享、异步等原理的学习理解等都需要进一步

去研究学习。