linux 字符驱动简单实例

 

在Linux字符驱动模板的一篇中，我们简单的书写的Linux字符设备驱动模块的模板，这个模板具有一定的通用性，但是对我们初学者来说，最好能有一个实例来增加我们的理解。通过对《Linux设备驱动开发详解》这本书的学习，有一个例子在很多的驱动开发教程成都有讲解，可见这个例子的功效了，因此，在这儿我们再一次的理解这个例子（globalmem）。

这个例子是一个抽象的设备，这个设备主要功能是在内存中申请了4KB的内存，并对其进行读写操作。我们通用字符设备驱动模板来看看其中的实现。

/*globalmen设备结构体和宏*/
//头文件包含 
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define GLOBALMEM_SIZE 0x1000  // 字符设备的内存大小
#define MEM_CLEAR 0x1    //clear 内存
#define GLOBALMEM_MAJOR 230  // 主设备号

static int globalmem_major = GLOBALMEM_MAJOR;   // 设备号
module_param(globalmem_major, int, S_IRUGO);   // 模块传参数，这个在模块加载的过程中可以传设备号

// 定义的设备结构体，除字符设备结构体外还有其他数据内存，封装在了一起。
struct globalmem_dev {
    struct cdev cdev;
    unsigned char mem[GLOBALMEM_SIZE];
};

struct globalmem_dev *globalmem_devp;

下面我们来写globalmem 的设备加载和卸载函数：

static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)  // index 是设备的数量
{
     int err, devno = MKDEV(globalmem_major, index); // 设备号的生成函数

     cdev_init(&dev->cdev, &globalmem_fops);     //设备和驱动操作结构体的绑定，初始化
     dev->cdev.owner = THIS_MODULE;
     err = cdev_add(&dev->cdev, devno, 1);      // 设备的注册、加载
    if (err)
        printk(KERN_NOTICE "Error %d adding globalmem%d", err, index);
}
// 模块加载函数
static int __init globalmem_init(void)
{
    int ret;
    dev_t devno = MKDEV(globalmem_major, 0);  //设备号
   //分配设备号
    if (globalmem_major)
     ret = register_chrdev_region(devno, 1, "globalmem");
    else {
     ret = alloc_chrdev_region(&devno, 0, 1, "globalmem");
    globalmem_major = MAJOR(devno);
    }
    if (ret < 0)
    return ret;
    // 设备申请内存，失败跳到fail_malloc处
    globalmem_devp = kzalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
    if (!globalmem_devp) {
         ret = -ENOMEM;
         goto fail_malloc;
    }

    globalmem_setup_cdev(globalmem_devp, 0);
    return 0;
    // 
    fail_malloc:
    unregister_chrdev_region(devno, 1);
    return ret;
}

module_init(globalmem_init);

现在要实现的是globalmen设备驱动的文件操作结构体

static const struct file_operations globalmem_fops = {
    .owner = THIS_MODULE,
    .llseek = globalmem_llseek,
    .read = globalmem_read,
    .write = globalmem_write,
    .unlocked_ioctl = globalmem_ioctl,
    .open = globalmem_open,
    .release = globalmem_release,
};

file_operations 中具体的操作函数在下面：

/*读函数
* size 是读数据的大小，*ppos是相对于开头的位置指针
*/
static ssize_t globalmem_read(struct file *filp, char __user * buf, size_t size,
loff_t * ppos)
{
     unsigned long p = *ppos;
     unsigned int count = size;
     int ret = 0;
    // 私有数据一般指向设备结构体本身
     struct globalmem_dev *dev = filp->private_data;
    // 如果读的大小超越了内存实际的大小，则修改读的大小变量
    if (p >= GLOBALMEM_SIZE)
     return 0;
     if (count > GLOBALMEM_SIZE - p)
     count = GLOBALMEM_SIZE - p;

     if (copy_to_user(buf, dev->mem + p, count)) {
     ret = -EFAULT;
    } else {
     *ppos += count;
     ret = count;

     printk(KERN_INFO "read %u bytes(s) from %lu\n", count, p);
 }

 return ret;
}

/*写操作和读操作基本差不多

*注意内存的偏移ppos和copy_from_user()函数*/
static ssize_t globalmem_write(struct file *filp, const char __user * buf,
 size_t size, loff_t * ppos)
{
     unsigned long p = *ppos;
     unsigned int count = size;
     int ret = 0;
     struct globalmem_dev *dev = filp->private_data;

     if (p >= GLOBALMEM_SIZE)
     return 0;
     if (count > GLOBALMEM_SIZE - p)
     count = GLOBALMEM_SIZE - p;

     if (copy_from_user(dev->mem + p, buf, count))
     ret = -EFAULT;
     else {
     *ppos += count;
     ret = count;

     printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
 }

23 return ret;
24}

 seek（）函数对文件定位的起始地址可以是文件开头（SEEK_SET，0）、当前位置（SEEK_CUR，1）和文件尾
（SEEK_END，2），假设globalmem支持从文件开头和当前位置的相对偏移。
在定位的时候，应该检查用户请求的合法性，若不合法，函数返回-EINVAL，合法时更新文件的当前位置并返
回该位置

/*seek 函数
*对于具有连续空间的操作很关键的函数
*/
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
     loff_t ret = 0;
     switch (orig) {
     case 0: /* 从文件开头位置 seek */
         if (offset< 0) {
             ret = -EINVAL;
             break;
         }
         if ((unsigned int)offset > GLOBALMEM_SIZE) {
             ret = -EINVAL;
             break;
          }
         filp->f_pos = (unsigned int)offset;
         ret = filp->f_pos;
     break;
     case 1: /* 从文件当前位置开始 seek */
        if ((filp->f_pos + offset) > GLOBALMEM_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;
            break;
    }
    return ret;

globalmem设备驱动的ioctl（）函数接受MEM_CLEAR命令，这个命令会将全局内存的有效数据长度清0，对于设
备不支持的命令，ioctl（）函数应该返回-EINVAL。

/*控制函数*/
static long globalmem_ioctl(struct file *filp, unsigned int cmd,
 unsigned long arg)
{
     struct globalmem_dev *dev = filp->private_data;

     switch (cmd) {
         case MEM_CLEAR: // 如果命令是MEM_CLEAR 把内存初始化
             memset(dev->mem, 0, GLOBALMEM_SIZE);
             printk(KERN_INFO "globalmem is set to zero\n");
             break;

         default:
             return -EINVAL;
 }

 return 0;
}

注意：（1）“文件操作函数中使用了struct globalmem_dev*dev=filp->private_data获取globalmem_dev的实例指针。实际
上，大多数Linux驱动遵循一个“潜规则”，那就是将文件的私有数据private_data指向设备结构体，再用read（）、
write（）、ioctl（）、llseek（）等函数通过private_data访问设备结构体。私有数据的概念在Linux驱动的各个子
系统中广泛存在，实际上体现了Linux的面向对象的设计思想。对于globalmem驱动而言，私有数据的设置是在
globalmem_open（）中完成的。” 引用参考书目。

（2）globalmem设备驱动的open（）函数中实现私有数据的赋值操作。

/*设备打开函数
*重要的是实现文件私有数据的赋值操作。
*/
static int globalmem_open(struct inode *inode, struct file *filp)
{
    filp->private_data = globalmem_devp;
    return 0;
}
/*
* 对应的open函数，相当于close（）函数
*/
static int globalmem_release(struct inode *inode, struct file *filp)
{
    return 0;
}

/*模块卸载的函数*/
static void __exit globalmem_exit(void)
{
     cdev_del(&globalmem_devp->cdev);
     kfree(globalmem_devp);
     unregister_chrdev_region(MKDEV(globalmem_major, 0), 1);
}


module_exit(globalmem_exit); // 模块卸载

MODULE_AUTHOR("作者");  // 作者
MODULE_LICENSE("GPL v2"); // 协议

字符设备的主要设备驱动函数的编写内容就这些，要根据具体的设备内容进行具体的操作，上面的例子是简单的设备驱动流程，具有通用性。