断断续续学驱动，好不容易有空，做了段字符驱动的例子。主要还是跟书上学习在此记录下来，以后说不定能回过头来温故知新。
首先上驱动源码 gmem.c：
/*************************************************************************
> File Name: gmem.c
> Author: hailin.ma
> Mail: mhl2018@126.com
> Created Time: Fri 18 Dec 2015 05:08:51 PM CST
************************************************************************/ #include <linux/cdev.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h> #define GMEM_SIZE 0X1000
#define GMEM_CLEAR 0XFF
#define GMEN_MAJOR 250 static int gmem_major = GMEN_MAJOR; typedef struct gmem_dev{
struct cdev cdev;
unsigned char mem[GMEM_SIZE];
}*GMEM_DEVP; GMEM_DEVP gmem_devp = NULL; static ssize_t gmem_read(struct file *filp,char __user *buf,size_t count,loff_t *ppos)
{
unsigned long p = *ppos;
int ret = 0; GMEM_DEVP dev = filp->private_data;
if(p >= GMEM_SIZE)
return 0;
if(count > GMEM_SIZE - p)
count = GMEM_SIZE - p; if(copy_to_user(buf,(void*)(dev->mem + p),count))
ret = -EFAULT;
else{
*ppos += count;
ret = count;
printk(KERN_INFO"read %d byte(s) from %d\n",count,p);
} return ret;
} static ssize_t gmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
unsigned long p = *ppos;
int ret = 0; GMEM_DEVP dev = filp->private_data;
if(p >= GMEM_SIZE)
return 0; if(p > GMEM_SIZE - p)
count = GMEM_SIZE - p; if(copy_from_user(dev->mem + p,buf,count))
ret = -EFAULT;
else{
*ppos += count;
ret = count; printk(KERN_INFO"written %d byte(s) from %d\n",count,p);
}
} static loff_t gmem_llseek(struct file *filp,loff_t offset,int orig)
{
loff_t ret;
switch(orig){
case 0:
if(offset < 0){
ret = -EINVAL;
break;
}
if((unsigned int)offset > GMEM_SIZE){
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1:
if((filp->f_pos + offset) > GMEM_SIZE){
ret = -EINVAL;
break;
}
if((filp->f_pos + offset) < 0){
ret = -EINVAL;
break;
}
filp->f_pos += offset;
ret = filp->f_pos;
break;
default:
ret = -EINVAL;
}
return ret;
} static int gmem_ioctl(struct inode *inodep,struct file *filp,unsigned int cmd,unsigned long arg)
{
GMEM_DEVP dev = filp->private_data;
switch(cmd){
case GMEM_CLEAR:
memset(dev->mem,0,GMEM_SIZE);
printk(KERN_INFO"gmem is clear!\n");
break;
default:
return -EINVAL;
}
return 0;
} int gmem_open(struct inode *inode,struct file *filep)
{
filep->private_data = gmem_devp;
return 0;
} static const struct file_operations gmem_fops = {
.owner = THIS_MODULE,
.open = gmem_open,
.llseek = gmem_llseek,
.read = gmem_read,
.write = gmem_write,
.ioctl = gmem_ioctl,
}; void gmem_setup_cdev()
{
int err;
dev_t devno = MKDEV(gmem_major,0);
cdev_init(&gmem_devp->cdev,&gmem_fops);
gmem_devp->cdev.owner = THIS_MODULE;
err = cdev_add(&gmem_devp->cdev,devno,1);
if(err){
printk(KERN_NOTICE"Error %d adding gmem",err);
}
} static int __init gmem_init(void)
{
int result;
printk(KERN_INFO"Init gmem\n"); dev_t devno = MKDEV(gmem_major,0); //通过MKDEV宏生成设备号
if(gmem_major){
result = register_chrdev_region(devno,1,"gmem");
}
else{
result = alloc_chrdev_region(&devno,0,1,"gmem");
gmem_major = MAJOR(devno);
}
if(result < 0){
return result;
} gmem_devp = kmalloc(sizeof(struct gmem_dev),GFP_KERNEL);
if(!gmem_devp){
result = - ENOMEM;
goto fail_malloc;
} memset(gmem_devp,0,sizeof(struct gmem_dev)); gmem_setup_cdev();
return 0; fail_malloc:
unregister_chrdev_region(devno,0);
return result;
} static void __exit gmem_exit(void)
{
printk(KERN_INFO"exit gmem\n");
} module_init(gmem_init);
module_exit(gmem_exit);
module_param(gmem_major,int,S_IRUGO); MODULE_AUTHOR("malth <malth0988@163.com>");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("globle memory module");
MODULE_ALIAS("globle memory");
程序不算长，200行左右，下面进行具体分析。
在 Linux 2.6 内核中，使用 cdev 结构体描述一个字符设备， cdev 结构体的定义:
struct cdev {
struct kobject kobj; /* 内嵌的 kobject 对象 */
struct module *owner; /*所属模块*/
struct file_operations *ops; /*文件操作结构体*/
struct list_head list;
dev_t dev; /*设备号*/
unsigned int count;
};
cdev 结构体的 dev_t 成员定义了设备号，为 32 位，其中 12 位主设备号， 20 位次设备号。使
用下列宏可以从 dev_t 获得主设备号和次设备号：
MAJOR(dev_t dev)
MINOR(dev_t dev)
而使用下列宏则可以通过主设备号和次设备号生成 dev_t：
MKDEV(int major, int minor)
cdev 结构体的另一个重要成员 file_operations , 定义了字符设备驱动提供给虚拟文件系统的接口函数。
Linux 2.6 内核提供了一组函数用于操作 cdev 结构体：
void cdev_init(struct cdev *, struct file_operations *);
struct cdev *cdev_alloc(void);
void cdev_put(struct cdev *p);
int cdev_add(struct cdev *, dev_t, unsigned);
void cdev_del(struct cdev *);
cdev_init()函数用于初始化 cdev 的成员，并建立 cdev 和 file_operations 之间的连接，其源代
码:
void cdev_init(struct cdev *cdev, struct file_operations *fops)
{
memset(cdev, 0, sizeof *cdev);
INIT_LIST_HEAD(&cdev->list);
kobject_init(&cdev->kobj, &ktype_cdev_default);
cdev->ops = fops; /*将传入的文件操作结构体指针赋值给 cdev 的 ops*/
}
cdev_alloc()函数用于动态申请一个 cdev 内存，其源代码:
struct cdev *cdev_alloc(void)
{
struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
if (p) {
INIT_LIST_HEAD(&p->list);
kobject_init(&p->kobj, &ktype_cdev_dynamic);
}
return p;
}
cdev_add()函数和 cdev_del()函数分别向系统添加和删除一个 cdev，完成字符设备的注册和注
销。对 cdev_add()的调用通常发生在字符设备驱动模块加载函数中，而对 cdev_del()函数的调用则
通常发生在字符设备驱动模块卸载函数中。
在调用 cdev_add()函数向系统注册字符设备之前，应首先调用 register_chrdev_region()或
alloc_chrdev_region()函数向系统申请设备号，这两个函数的原型为：
int register_chrdev_region(dev_t from, unsigned count, const char *name); //用于已知起始设备的设备号的情况
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name); //用于设备号未知，向系统动态申请未被占用的设备号的情况
函数调用成功之后，会把得到的设备号放入第一个参数 dev 中。 alloc_chrdev_region()与 register_chrdev_region()对比的优点在于它会自动
避开设备号重复的冲突。
相反地，在调用 cdev_del()函数从系统注销字符设备之后， unregister_chrdev_region()应该被调
用以释放原先申请的设备号，这个函数的原型为：
void unregister_chrdev_region(dev_t from, unsigned count);
file_operations 结构体中的成员函数是字符设备驱动程序设计的主体内容，这些函数实际会在
应用程序进行 Linux 的 open()、 write()、 read()、 close()等系统调用时最终被调用。 file_operations
结构体目前已经比较庞大，它的定义:
struct file_operations {
struct module *owner;
/* 拥有该结构的模块的指针，一般为 THIS_MODULES */
loff_t(*llseek)(struct file *, loff_t, int);
/* 用来修改文件当前的读写位置 */
ssize_t(*read)(struct file *, char _ _user *, size_t, loff_t*);
/* 从设备中同步读取数据 */
ssize_t(*write)(struct file *, const char _ _user *, size_t, loff_t*);
/* 向设备发送数据*/
ssize_t(*aio_read)(struct kiocb *, char _ _user *, size_t, loff_t);
/* 初始化一个异步的读取操作*/
ssize_t(*aio_write)(struct kiocb *, const char _ _user *, size_t, loff_t);
/* 初始化一个异步的写入操作*/
int(*readdir)(struct file *, void *, filldir_t);
/* 仅用于读取目录，对于设备文件，该字段为 NULL */
unsigned int(*poll)(struct file *, struct poll_table_struct*);
/* 轮询函数，判断目前是否可以进行非阻塞的读取或写入*/
int(*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
/* 执行设备 I/O 控制命令*/
long(*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
/* 不使用 BLK 的文件系统，将使用此种函数指针代替 ioctl */
long(*compat_ioctl)(struct file *, unsigned int, unsigned long);
/* 在 64 位系统上， 32 位的 ioctl 调用，将使用此函数指针代替*/
int(*mmap)(struct file *, struct vm_area_struct*);
/* 用于请求将设备内存映射到进程地址空间*/
int(*open)(struct inode *, struct file*);
/* 打开 */
int(*flush)(struct file*);
int(*release)(struct inode *, struct file*);
/* 关闭*/
int (*fsync) (struct file *, struct dentry *, int datasync);
/* 刷新待处理的数据*/
int(*aio_fsync)(struct kiocb *, int datasync);
/* 异步 fsync */
int(*fasync)(int, struct file *, int);
/* 通知设备 FASYNC 标志发生变化*/
int(*lock)(struct file *, int, struct file_lock*);
ssize_t(*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int);
/* 通常为 NULL */
unsigned long(*get_unmapped_area)(struct file *,unsigned long, nsigned long,
unsigned long, unsigned long);
/* 在当前进程地址空间找到一个未映射的内存段 */
int(*check_flags)(int);
/* 允许模块检查传递给 fcntl(F_SETEL...)调用的标志 */
int(*dir_notify)(struct file *filp, unsigned long arg);
/* 对文件系统有效，驱动程序不必实现*/
int(*flock)(struct file *, int, struct file_lock*);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t,
unsigned int); /* 由 VFS 调用，将管道数据粘接到文件 */
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t,
unsigned int); /* 由 VFS 调用，将文件数据粘接到管道 */
int (*setlease)(struct file *, long, struct file_lock **);
};
下面我们对 file_operations 结构体中的主要成员进行分析。
llseek()函数用来修改一个文件的当前读写位置，并将新位置返回，在出错时，这个函数返回一个负值。
read()函数用来从设备中读取数据，成功时函数返回读取的字节数，出错时返回一个负值。
write()函数向设备发送数据，成功时该函数返回写入的字节数。如果此函数未被实现，当用户进行 write()系统调用时，将得到-EINVAL 返回值。
readdir()函数仅用于目录，设备节点不需要实现它。
ioctl()提供设备相关控制命令的实现（既不是读操作也不是写操作），当调用成功时，返回给调用程序一个非负值。
mmap()函数将设备内存映射到进程内存中，如果设备驱动未实现此函数，用户进行 mmap()系统调用时将获得-ENODEV 返回值。这个函数对于帧缓冲等设备特别有意义。
当用户空间调用 Linux API 函数 open()打开设备文件时，设备驱动的 open()函数最终被调用。
驱动程序可以不实现这个函数，在这种情况下，设备的打开操作永远成功。与 open()函数对应的是 release()函数。
poll()函数一般用于询问设备是否可被非阻塞地立即读写。当询问的条件未触发时，用户空间进行 select()和 poll()系统调用将引起进程的阻塞。
aio_read()和 aio_write()函数分别对与文件描述符对应的设备进行异步读、写操作。设备实现这两个函数后，用户空间可以对该设备文件描述符调用 aio_read()、 aio_write()等系统调用进行读写。
Linux字符设备驱动的组成
1．字符设备驱动模块加载与卸载函数
在字符设备驱动模块加载函数中应该实现设备号的申请和 cdev 的注册，而在卸载函数中应实现设备号的释放和 cdev 的注销。
/* 设备结构体*/
struct xxx_dev_t {
struct cdev cdev;
...
} xxx_dev;
/* 设备驱动模块加载函数
static int _ _init xxx_init(void)
{
...
cdev_init(&xxx_dev.cdev, &xxx_fops); /* 初始化 cdev */
xxx_dev.cdev.owner = THIS_MODULE;
/* 获取字符设备号*/
if (xxx_major) {
register_chrdev_region(xxx_dev_no, , DEV_NAME);
} else {
alloc_chrdev_region(&xxx_dev_no, , , DEV_NAME);
} ret = cdev_add(&xxx_dev.cdev, xxx_dev_no, ); /* 注册设备*/
...
}
/*设备驱动模块卸载函数*/
static void _ _exit xxx_exit(void)
{
unregister_chrdev_region(xxx_dev_no, ); /* 释放占用的设备号*/
cdev_del(&xxx_dev.cdev); /* 注销设备*/
...
}
2．字符设备驱动的 file_operations 结构体中成员函数
file_operations 结构体中成员函数是字符设备驱动与内核的接口，是用户空间对 Linux 进行系
统调用最终的落实者。大多数字符设备驱动会实现 read()、 write()和 ioctl()函数，常见的字符设备
驱动的这 3 个函数的形式如
/* 读设备*/
ssize_t xxx_read(struct file *filp, char __user *buf, size_t count,loff_t*f_pos)
{
...
copy_to_user(buf, ..., ...);
...
}
/* 写设备*/
ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
{
...
copy_from_user(..., buf, ...);
...
}
/* ioctl 函数 */
int xxx_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,unsigned long arg)
{
...
switch (cmd) {
case XXX_CMD1:
...
break;
case XXX_CMD2:
...
break;
default:
/* 不能支持的命令 */
return - ENOTTY;
}
return ;
}
设备驱动的读函数中， filp 是文件结构体指针， buf 是用户空间内存的地址，该地址在内核空间不能直接读写， count 是要读的字节数， f_pos 是读的位置相对于文件开头的偏移。
设备驱动的写函数中， filp 是文件结构体指针， buf 是用户空间内存的地址，该地址在内核空间不能直接读写， count 是要写的字节数， f_pos 是写的位置相对于文件开头的偏移。
由于内核空间与用户空间的内存不能直接互访，因此借助了函数 copy_from_user()完成用户空间到内核空间的拷贝，以及 copy_to_user()完成内核空间到用户空间的拷贝。
完成内核空间和用户空间内存拷贝的 copy_from_user()和 copy_to_user()的原型分别为：
unsigned long copy_from_user(void *to, const void _ _user *from, unsigned long count);
unsigned long copy_to_user(void _ _user *to, const void *from, unsigned long count);
上述函数均返回不能被复制的字节数，因此，如果完全复制成功，返回值为 0。
如果要复制的内存是简单类型，如 char、 int、 long 等，则可以使用简单的 put_user()和 get_user()，如：
int val; // 内核空间整型变量
...
get_user(val, (int *) arg); // 用户→内核， arg 是用户空间的地址 ...
put_user(val, (int *) arg); // 内核→用户， arg 是用户空间的地址
读和写函数中的_ _user 是一个宏，表明其后的指针指向用户空间，这个宏定义为：
#ifdef _ _CHECKER_ _
# define _ _user _ _attribute_ _((noderef, address_space()))
#else
# define _ _user
#endif
I/O 控制函数的 cmd 参数为事先定义的 I/O 控制命令，而 arg 为对应于该命令的参数。例如对于串行设备，如果 SET_BAUDRATE 是一道设置波特率的命令，那后面的 arg 就应该是
波特率值。
在字符设备驱动中，需要定义一个 file_operations 的实例，并将具体设备驱动的函数赋值给file_operations 的成员，如代码所示。
struct file_operations xxx_fops = {
.owner = THIS_MODULE,
.read = xxx_read,
.write = xxx_write,
.ioctl = xxx_ioctl,
...
};
xxx_fops 在 cdev_init(&xxx_dev.cdev, &xxx_fops)的语句中被建立与 cdev 的连接。
分析完了基本的函数，下面贴上Makefile文件：
#CFLAGS = -g
KVERS = $(shell uname -r) obj-m += gmem.o
mem-objs := gmem.o all:
make -C /lib/modules/$(KVERS)/build M=$(PWD) modules
@rm *.o clean:
make -C /lib/modules/$(KVERS)/build M=$(PWD) clean
@rm -f *.markers *.order
make之后生成gmem.ko文件，insmod gmem.ko gmem_major=303 加载驱动，303是指定主设备号， mknod /dev/gmem c 303 0 创建字符设备，主设备号303，次设备号0。
echo hello gmem! > /dev/gmem
cat /devgmem
通过上面两条命令可以向gmem写入数据和查看数据，这个方法比较方便，另外就是用open，read来查看了：
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h> int main()
{
int fd;
char* pathname = "/dev/gmem"; fd = open(pathname,O_RDWR);
if(fd == -)
{
printf("open error");
} char wrbuf[] = "gmem is good!\n";
write(fd,wrbuf,sizeof(wrbuf)); close(fd); return ;
}
上面代码简单的用文件来打开设备，然后向其中写入数据，程序可以继续拓展 read，ioctl之类的，时间原因，本文就更新到这里，后续可能会补充完善。