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"); // 協議

字符設備的主要設備驅動函數的編寫內容就這些，要根據具體的設備內容進行具體的操作，上面的例子是簡單的設備驅動流程，具有通用性。