虚拟字符设备驱动的编写

这是基于老罗的书《Android系统源代码情景分析》一书中关于虚拟字符设备驱动的来写的

以下是freg.h中的代码

#ifndef _FAKE_REG_H_
#define _FAKE_REG_H_

#include <linux/cdev.h>         //支持字符设备的头文件
#include <linux/semaphore.h>    //支持信号量的头文件

#define FREG_DEVICE_NODE_NAME "freg"
#define FREG_DEVICE_FILE_NAME "freg"
#define FREG_DEVICE_PROC_NAME "freg"
#define FREG_DEVICE_CLASS_NAME "freg"

struct fake_reg_dev {
int val;
struct semaphore sem;
struct cdev dev;
};

#endif

以下是freg.c中的代码

#include <linux/init.h>         //用于标记函数的宏，如__init,__exit
#include <linux/module.h>       //将内核模块加载到内核中的核心头文件，个人认为module_init,module_exit与之相关
#include <linux/types.h>
#include <linux/fs.h>           //支持linux文件系统的文件
#include <linux/proc_fs.h>
#include <linux/device.h>       //支持内核驱动模型的头文件
#include <asm/uaccess.h>        //复制用户用户空间函数需要的头文件

#include "freg.h"

static int freg_major = 0;  //主设备号
static int freg_minor = 0;  //从设备号

static struct class* freg_class = NULL; //设备类别
static struct fake_reg_dev* freg_dev = NULL;    //设备

//传统设备文件操作方法
static int freg_open(struct inode* inode, struct file* filp);
static int freg_release(struct inode* inode, struct file* filp);
static ssize_t freg_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);
static ssize_t freg_write(struct file* filp,const char __user *buf,size_t count,loff_t* f_pos);

// /dev/freg设备节点的操作方法
static struct file_operations freg_fops = {
.owner = THIS_MODULE,
.open = freg_open,
.release = freg_release,
.read = freg_read,
.write = freg_write,
};

/*devfs文件系统的设备属性操作方法*/
static ssize_t freg_val_show(struct device* dev,struct device_attribute* attr, char* buf);
static ssize_t freg_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);

/*devfs文件系统的设备属性*/
static DEVICE_ATTR(val,S_IRUGO | S_IWUSR,freg_val_show,freg_val_store);

/*打开设备方法*/
static int freg_open(struct inode* inode, struct file* filp){
printk(KERN_ALERT"freg device open.\n");
struct fake_reg_dev* dev;

/*将自定义设备结构题保存在文件指针的私有数据域中，以便访问设备时可以直接拿来用*/
dev = container_of(inode->i_cdev,struct fake_reg_dev, dev);
filp->private_data = dev;

return 0;
}

/*设备文件释放时调用，空实现*/
static int freg_release(struct inode* inode, struct file* filp){
printk(KERN_ALERT"freg device release.\n");
return 0;
}

/*读取设备的寄存器val的值*/
static ssize_t freg_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos){
printk(KERN_ALERT"freg device read.\n");
ssize_t err = 0;
struct fake_reg_dev* dev = filp->private_data;

/*同步访问*/
if(down_interruptible(&(dev->sem))){
return -ERESTARTSYS;
}

if(count < sizeof(dev->val)){
goto out;
}

/*将寄存器val的值拷贝到用户提供的缓存区中*/
if(copy_to_user(buf,&(dev->val),sizeof(dev->val))){
err = -EFAULT;
goto out;
}
err = sizeof(dev->val);

out:
up(&(dev->sem));
return err;
}

/*写设备的寄存器val的值*/
static ssize_t freg_write(struct file* filp,const char __user *buf,size_t count,loff_t* f_pos){
printk(KERN_ALERT"freg device write.\n");
struct fake_reg_dev* dev = filp->private_data;
ssize_t err = 0;

/*同步访问*/
if(down_interruptible(&(dev->sem))){
return -ERESTARTSYS;
}

if(count != sizeof(dev->val)){
goto out;
}
if(copy_from_user(&(dev->val),buf,count)){
err = -EFAULT;
goto out;
}

err = sizeof(dev->val);
out:
up(&(dev->sem));
return err;
}

/*将寄存器val的值读取到缓存区buf中，内部使用*/
static ssize_t __freg_get_val(struct fake_reg_dev* dev, char* buf){
int val = 0;

/*同步访问*/
if(down_interruptible(&(dev->sem))){
return -ERESTARTSYS;
}
val = dev->val;
up(&(dev->sem));

return snprintf(buf,PAGE_SIZE,"%d\n",val);
}

/*把缓存区buf的值写到设备寄存器val中，内部使用*/
static ssize_t __freg_set_val(struct fake_reg_dev* dev,const char* buf, size_t count){
int val = 0;

/*将字符串转换成数字*/
val = simple_strtol(buf,NULL,10);

/*同步访问*/
if(down_interruptible(&(dev->sem))){
return -ERESTARTSYS;
}
dev->val = val;
up(&(dev->sem));

return count;
}
//读取/sys/class/freg/freg/val的方法
static ssize_t freg_val_show(struct device* dev,struct device_attribute* attr, char* buf){
struct fake_reg_dev* hdev = (struct fake_reg_dev*) dev_get_drvdata(dev);

printk(KERN_ALERT"get /sys/class/freg/freg/val.\n");
return __freg_get_val(hdev,buf);
}

//将值写入/sys/class/freg/freg/val的方法
static ssize_t freg_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count){
struct fake_reg_dev* hdev = (struct fake_reg_dev*) dev_get_drvdata(dev);

printk(KERN_ALERT"set /sys/class/freg/freg/val.\n");
return __freg_set_val(hdev,buf,count);
}

/*读取设备寄存器val的值，保存到page缓存区中*/
static ssize_t freg_proc_read(char* page, char** start, off_t off,int count,int* eof, void* data){
printk(KERN_ALERT"freg_proc_read.\n");
if(off>0){
*eof = 1;
return 0;
}
return __freg_get_val(freg_dev,page);
}

/*把缓存区的值buff保存到设备寄存器val中*/
static ssize_t freg_proc_write(struct file* filp, const char __user *buff, unsigned long len, void* data){
printk(KERN_ALERT"freg_proc_write.\n");
int err = 0;
char* page = NULL;

if(len >PAGE_SIZE){
printk(KERN_ALERT"The buff is too large: %lu. \n",len);
return -EFAULT;
}

page = (char*) __get_free_page(GFP_KERNEL);
if(!page) {
printk(KERN_ALERT"Failed to alloc page .\n");
return -ENOMEM;
}
/*先把用户提供的缓冲区的值拷贝到内核缓冲区中*/
if(copy_from_user(page,buff,len)){
printk(KERN_ALERT"Failed to copy buff from user. \n");
err = -EFAULT;
goto out;
}

err = __freg_set_val(freg_dev,page,len);

out:
free_page((unsigned long)page);
return err;
}

/*创建/proc/freg文件*/
//以及对应/proc/freg读写方法
static void freg_create_proc(void) {
printk(KERN_ALERT"freg_create_proc.\n");
struct proc_dir_entry* entry;

entry = create_proc_entry(FREG_DEVICE_PROC_NAME,0,NULL);
if(entry){
//entry->owner = THIS_MODULE;   //结构体中没有owner这个成员
entry->read_proc = freg_proc_read;
entry->write_proc = freg_proc_write;
}
}

/*删除/proc/freg文件*/
static void freg_remove_proc(void){
printk(KERN_ALERT"freg_remove_proc.\n");
remove_proc_entry(FREG_DEVICE_PROC_NAME,NULL);
}

/*初始化设备*/
static int __freg_setup_dev(struct fake_reg_dev* dev){
int err;
dev_t devno = MKDEV(freg_major,freg_minor);

memset(dev,0,sizeof(struct fake_reg_dev));

/*初始化字符设备*/
cdev_init(&(dev->dev),&freg_fops);
dev->dev.owner = THIS_MODULE;
dev->dev.ops = &freg_fops;

/*注册字符设备*/
err = cdev_add(&(dev->dev),devno,1);
if(err){
return err;
}

/*初始化信号量和寄存器val的值*/
//init_MUTEX(&(dev->sem));  //新版本linux中初始化信号量没有这个函数，用下面这个函数替代
sema_init(&(dev->sem),1);
dev->val = 0;

return 0;
}

/*模块加载方法*/
static int __init freg_init(void){
int err = -1;
dev_t dev = 0;
struct device* temp = NULL;

printk(KERN_ALERT"Initializing freg device .\n");

/*动态分配主设备号和从设备号*/
err = alloc_chrdev_region(&dev,0,1,FREG_DEVICE_NODE_NAME);
if(err < 0){
printk(KERN_ALERT"Failed to alloc char dev region.\n");
goto fail;
}
//将动态分配到的设备的主设备号和从设备号保存
freg_major = MAJOR(dev);
freg_minor = MINOR(dev);

/*分配freg设备结构体*/
freg_dev = kmalloc(sizeof(struct fake_reg_dev),GFP_KERNEL);
if(!freg_dev){
err = -ENOMEM;
printk(KERN_ALERT"Failed to alloc freg device. \n");
goto unregister;
}

/*初始化设备*/
err = __freg_setup_dev(freg_dev);
if(err) {
printk(KERN_ALERT"Failed to setup freg device:%d .\n",err);
goto cleanup;
}

/*在/sys/class/目录下创建设备类别目录freg*/
freg_class = class_create(THIS_MODULE,FREG_DEVICE_CLASS_NAME);
if(IS_ERR(freg_class)){
err = PTR_ERR(freg_class);
printk(KERN_ALERT"Failed to create freg device class.\n");
goto destroy_cdev;
}

/*在/dev/目录和/sys/class/freg目录下分别创建设备文件freg*/
temp = device_create(freg_class,NULL,dev,NULL,"%s",FREG_DEVICE_FILE_NAME);
if(IS_ERR(temp)){
err = PTR_ERR(temp);
printk(KERN_ALERT"Failed to create freg device.\n");
goto destroy_class;
}
/*在/sys/class/freg/freg目录下创建属性文件val*/
err = device_create_file(temp,&dev_attr_val);
if(err < 0){
printk(KERN_ALERT"Failed to create attribute val of freg device.\n");
goto destroy_device;
}

//  static inline void *dev_get_drvdata(const struct device *dev)
//  {
//      return dev->driver_data;
//  }
//
//  static inline void dev_set_drvdata(struct device *dev, void *data)
//  {
//      dev->driver_data = data;
//  }
//  相当于将freg_dev这个指针保存到temp中
dev_set_drvdata(temp, freg_dev);

/*创建/proc/freg文件*/
freg_create_proc();

printk(KERN_ALERT"Succedded to initialize freg device.\n");

return 0;

destroy_device:
device_destroy(freg_class,dev);
destroy_class:
class_destroy(freg_class);
destroy_cdev:
cdev_del(&(freg_dev->dev));
cleanup:
kfree(freg_dev);
unregister:
unregister_chrdev_region(MKDEV(freg_major,freg_minor),1);
fail:
return err;
}

/*模块卸载方法*/
static void __exit freg_exit(void){
printk(KERN_ALERT"Destroy freg device.\n");
dev_t devno = MKDEV(freg_major, freg_minor);

/*删除/proc/freg文件*/
freg_remove_proc();

/*销毁设备类别和设备*/
if(freg_class){
device_destroy(freg_class,MKDEV(freg_major,freg_minor));
class_destroy(freg_class);
}

/*删除字符设备和释放设备内存*/
if(freg_dev){
cdev_del(&(freg_dev->dev));
kfree(freg_dev);
}
/*释放设备号资源*/
unregister_chrdev_region(devno,1);
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Fake Register Driver");

module_init(freg_init);
module_exit(freg_exit);

由于我和老罗的内核版本不一样所以修改了一点他的代码，完成来驱动的编译。经过测试驱动编写成功。代码的注释应该足够看懂了。

ll /dev/freg可以查看设备类型和主从设备号

/proc 为运行的内核信息映射

/sys 硬件设备的驱动程序信息

本程序可以通过/sys/class/freg/freg/val和/proc/freg来读写寄存器val的值