linux字符设备驱动程序设计概述

 

   字符设备
　　字符设备是指在I/O传输过程中以字符为单位进行传输的设备，例如键盘，打印机等。请注意，以字符为单位并不一定意味着是以字节为单位，因为有的编码规则规定，1个字符占16比特，合2个字节。
　　在UNIX系统中，字符设备以特别文件方式在文件目录树中占据位置并拥有相应的i结点。i结点中的文件类型指明该文件是字符设备文件。可以使用与普通文件相同的文件操作命令对字符设备文件进行操作，例如打开、关闭、读、写等

   字符设备是最基本、最常用的设备。概括的说，字符设备驱动主要要做三件事：1、定义一个结构体static struct file_operations变量，其内定义一些设备的打开、关闭、读、写、控制函数；2、在结构体外分别实现结构体中定义的这些函数；3、向内核中注册或删除驱动模块。具体如下：

   字符设备提供给应用程序流控制接口有：open/close/read/write/ioctl，添加一个字符设备驱动程序，实际上是给上述操作添加对应的代码，Linux对这些操作统一做了抽象
struct file_operations
file_operations结构体的例子如下
       static struct file_operations myDriver_fops = {
       owner: THIS_MODULE,
       write: myDriver_write,
       read:  myDriver_read,
       ioctl: myDriver_ioctl,
       open:  myDriver_open,
       release: myDriver_release,
};
该结构体规定了驱动程序向应用程序提供的操作接口：
实现write操作
从应用程序接收数据送到硬件。例：
static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
{
       size_t fill_size = count;
       PRINTK("myDriver write called!\n");
       PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);

       if(*f_pos >= sizeof(myDriver_Buffer))
       {
              PRINTK("[myDriver write]Buffer Overlap\n");
              *f_pos = sizeof(myDriver_Buffer);
              return 0;
       }

       if((count + *f_pos) > sizeof(myDriver_Buffer))
       {
              PRINTK("count + f_pos > sizeof buffer\n");
              fill_size = sizeof(myDriver_Buffer) - *f_pos;
       }
       copy_from_user(&myDriver_Buffer[*f_pos], buf, fill_size);
       *f_pos += fill_size;
       return fill_size;
}
其中的关键函数
   u_long copy_from_user(void *to, const void *from, u_long len);
把用户态的数据拷到内核态，实现数据的传送。
实现read操作
从硬件读取数据并交给应用程序。例：
static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
       size_t read_size = count;
       PRINTK("myDriver read called!\n");
       PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);

       if(*f_pos >= sizeof(myDriver_Buffer))
       {
              PRINTK("[myDriver read]Buffer Overlap\n");
              *f_pos = sizeof(myDriver_Buffer);
              return 0;
       }

       if((count + *f_pos) > sizeof(myDriver_Buffer))
       {
              PRINTK("count + f_pos > sizeof buffer\n");
              read_size = sizeof(myDriver_Buffer) - *f_pos;
       }
       copy_to_user(buf, &myDriver_Buffer[*f_pos], read_size);
       *f_pos += read_size;
       return read_size;
}
其中的关键函数
    u_long copy_to_user(void * to, const void *from, u_long len);
该函数实现把内核态的数据拷到用户态下。
   实现ioctl操作
为应用程序提供对硬件行为的控制。例：
static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    PRINTK("myDriver ioctl called(%d)!\n", cmd);
    if(_IOC_TYPE(cmd) != TSTDRV_MAGIC)
    {
        return -ENOTTY;
    }
    if(_IOC_NR(cmd) >= TSTDRV_MAXNR)
    {
        return -ENOTTY;
    }
    switch(cmd)
    {
       case MYDRV_IOCTL0:
            PRINTK("IOCTRL 0 called(0x%lx)!\n", arg);
            break;
       case MYDRV_IOCTL1:
            PRINTK("IOCTRL 1 called(0x%lx)!\n", arg);
            break;
       case MYDRV_IOCTL2:
            PRINTK("IOCTRL 2 called(0x%lx)!\n", arg);
            break;
       case MYDRV_IOCTL3:
            PRINTK("IOCTRL 3 called(0x%lx)!\n", arg);
            break;
       }
       return 0;
}
实现open操作
当应用程序打开设备时对设备进行初始化，使用MOD_INC_USE_COUNT增加驱动程序的使用次数。例：
static int myDriver_open(struct inode *inode, struct file *filp)
{
       MOD_INC_USE_COUNT;
       PRINTK("myDriver open called!\n");
       return 0;
}
实现release操作
当应用程序关闭设备时处理设备的关闭操作。使用MOD_DEC_USE_COUNT增加驱动程序的使用次数。例：
static int myDriver_release(struct inode *inode, struct file *filp)
{
       MOD_DEC_USE_COUNT;
       PRINTK("myDriver release called!\n");
       return 0;
}
驱动程序初始化函数
Linux在加载内核模块时会调用初始化函数，初始化驱动程序本身使用register_chrdev向内核注册驱动程序，该函数的第三个指向包含有驱动程序接口函数信息的file_operations结构体。
例：
/* Module Init & Exit function */
#ifdef CONFIG_DEVFS_FS
devfs_handle_t devfs_myDriver_dir;
devfs_handle_t devfs_myDriver_raw;
#endif
static int __init myModule_init(void)
{
       /* Module init code */
       PRINTK("myModule_init\n");
       /* Driver register */
       myDriver_Major = register_chrdev0,DRIVER_NAME,&myDriver_fops);
       if(myDriver_Major < 0)
       {
              PRINTK("register char device fail!\n");
              return myDriver_Major;
       }
       PRINTK("register myDriver OK! Major = %d\n", myDriver_Major);
#ifdef CONFIG_DEVFS_FS
       devfs_myDriver_dir = devfs_mk_dir(NULL, "myDriver", NULL);
       devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myDriver_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myDriver_fops, NULL);
       PRINTK("add dev file to devfs OK!\n");
#endif
       return 0;
}
其中，关键函数
module_init()
向内核声明当前模块的初始化函数
驱动程序退出函数
Linux在卸载内核模块时会调用退出函数释放驱动程序使用的资源，使用unregister_chrdev从内核中卸载驱动程序。将驱动程序模块注册到内核，内核需要知道模块的初始化函数和退出函数，才能将模块放入自己的管理队列中。
例：
static void __exit myModule_exit(void)
{
       /* Module exit code */
       PRINTK("myModule_exit\n");
       /* Driver unregister */
       if(myDriver_Major > 0)
       {
          #ifdef CONFIG_DEVFS_FS
          devfs_unregister(devfs_myDriver_raw);
          devfs_unregister(devfs_myDriver_dir);
          #endif
          unregister_chrdev(myDriver_Major, DRIVER_NAME);
       }
       return;
}
 其中，关键函数
module_exit()
向内核声明当前模块的退出函数。
关于devfs的操作
在devfs中建立一个目录（/dev下）
 devfs_handle_t devfs_mk_dir (devfs_handle_t dir, const char *name, void *info);
在devfs中注册一个设备文件节点
 devfs_handle_t devfs_register(devfs_handle_t dir, const char *name,
unsigned int flags,
unsigned int major, unsigned int minor,
umode_t mode, void *ops, void *info);
在devfs中删除一个设备文件节点
 void devfs_unregister(devfs_handle_t de);
加载驱动程序
在终端下，输入以下命令可以对模块进行相关的操作。
insmod 内核模块文件名
rmmod 内核模块文件名
lsmod 列举出当前全部的加载模块文件名
建立设备文件
mknod 文件路径 c [主设备号] [从设备号]
应用程序接口函数
可以使用标准C的文件操作函数来完成。
应用程序接口函数：
int open(const char *path, int oflag,…);
打开名为path的文件或设备
成功打开后返回文件句柄
常用oflag：O_RDONLY, O_WRONLY, O_RDWR
int close(int fd);
关闭之前被打开的文件或设备
成功关闭返回0，否则返回错误代号
ssize_t read(int fd, void *buffer, size_t count);
从已经打开的文件或设备中读取数据
buffer表示应用程序缓冲区
count表示应用程序希望读取的数据长度
成功读取后返回读取的字节数，否则返回-1
ssize_t write(int fd, void *buffer, size_t count);
向已经打开的文件或设备中写入数据
buffer表示应用程序缓冲区
count表示应用程序希望写入的数据长度
成功写入后返回写入的字节数，否则返回-1
int ioctl(int fd, unsigned long int cmd,…);
向驱动程序发送控制命令
cmd需是唯一值
type：又称幻数，8bit，一般表示cmd所属模块
number：cmd序号，8bit，一般表示实际的命令
direction：数据传输方向，2bit
size：数据大小，位数与体系结构有关（ARM:12bit）
sizeof(int)-(sizeof(type)+sizeof(number)+sizeof(direction))
使用_IO宏可快速合成cmd：_IO(MAGIC, num)

附：完整的示例驱动程序
 // tst-driver.h
#ifndef __TST_DRIVER_H__
#define __TST_DRIVER_H__
#define TSTDRV_MAGIC 0xd0
#define MYDRV_IOCTL0 _IO(TSTDRV_MAGIC, 0)
#define MYDRV_IOCTL1 _IO(TSTDRV_MAGIC, 1)
#define MYDRV_IOCTL2 _IO(TSTDRV_MAGIC, 2)
#define MYDRV_IOCTL3 _IO(TSTDRV_MAGIC, 3)
#define TSTDRV_MAXNR 4
#endif //#ifndef __TST_DRIVER_H__
// tst-driver.c
#ifndef __KERNEL__
    #define __KERNEL__
#endif
#ifndef MODULE
    #define MODULE
#endif
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>  /* printk() */
#include <linux/init.h>    /* __init __exit */
#include <linux/types.h>   /* size_t */
#include <linux/fs.h>      /* file_operation */
//#include /* Error number */
//#include /* udelay */
#include <asm/uaccess.h>   /* copy_to_user, copy_from_user */
#include <asm/hardware.h>
#include "tst-driver.h"
#define DRIVER_NAME "myDriver"
//#undef CONFIG_DEVFS_FS
#ifdef DEBUG
#define PRINTK(fmt, arg...) printk(KERN_NOTICE fmt, ##arg)
#else
#define PRINTK(fmt, arg...)
#endif
/*     KERN_EMERG 用于紧急事件,一般是系统崩溃前的提示信息
       KERN_ALERT 用于需要立即采取动作的场合
       KERN_CRIT 临界状态,通常设计验证的硬件或软件操作失败
       KERN_ERR 用于报告错误状态.设备驱动程序通常会用它报告来自硬件的问题
       KERN_WARNING 就可能出现的问题提出警告.这些问题通常不会对系统造成严重破坏
       KERN_NOTICE 有必要提示的正常情况.许多安全相关的情况用这个级别汇报
       KERN_INFO 提示性信息.有很多驱动程序在启动时用这个级别打印相关信息
       KERN_DEBUG 用于调试的信息
*/
static int myDriver_Major = 0; /* Driver Major Number */
/* Vitual Driver Buffer */
static unsigned char myDriver_Buffer[1024*1024];
/* Driver Operation Functions */
static int myDriver_open(struct inode *inode, struct file *filp)
{
// int Minor = MINOR(inode->i_rdev);
// filp->private_data = 0;
       MOD_INC_USE_COUNT;
       PRINTK("myDriver open called!\n");
       return 0;
}
static int myDriver_release(struct inode *inode, struct file *filp)
{
// int Minor = MINOR(inode->i_rdev);
       MOD_DEC_USE_COUNT;
       PRINTK("myDriver release called!\n");
       return 0;
}
static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
       size_t read_size = count;
       PRINTK("myDriver read called!\n");
       PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);
       if(*f_pos >= sizeof(myDriver_Buffer))
       {
              PRINTK("[myDriver read]Buffer Overlap\n");
              *f_pos = sizeof(myDriver_Buffer);
              return 0;
       }
       if((count + *f_pos) > sizeof(myDriver_Buffer))
       {
              PRINTK("count + f_pos > sizeof buffer\n");
              read_size = sizeof(myDriver_Buffer) - *f_pos;
       }
       copy_to_user(buf, &myDriver_Buffer[*f_pos], read_size);
       *f_pos += read_size;
       return read_size;
}
static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
{
       size_t fill_size = count;
       PRINTK("myDriver write called!\n");
       PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);
       if(*f_pos >= sizeof(myDriver_Buffer))
       {
              PRINTK("[myDriver write]Buffer Overlap\n");
              *f_pos = sizeof(myDriver_Buffer);
              return 0;
       }
       if((count + *f_pos) > sizeof(myDriver_Buffer))
       {
              PRINTK("count + f_pos > sizeof buffer\n");
              fill_size = sizeof(myDriver_Buffer) - *f_pos;
       }
       copy_from_user(&myDriver_Buffer[*f_pos], buf, fill_size);
       *f_pos += fill_size;
       return fill_size;
}
static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    PRINTK("myDriver ioctl called(%d)!\n", cmd);
    if(_IOC_TYPE(cmd) != TSTDRV_MAGIC)
    {
        return -ENOTTY;
    }
    if(_IOC_NR(cmd) >= TSTDRV_MAXNR)
    {
        return -ENOTTY;
    }
    switch(cmd)
       {
         case MYDRV_IOCTL0:
              PRINTK("IOCTRL 0 called(0x%lx)!\n", arg);
              break;
         case MYDRV_IOCTL1:
              PRINTK("IOCTRL 1 called(0x%lx)!\n", arg);
              break;
         case MYDRV_IOCTL2:
              PRINTK("IOCTRL 2 called(0x%lx)!\n", arg);
              break;
         case MYDRV_IOCTL3:
              PRINTK("IOCTRL 3 called(0x%lx)!\n", arg);
              break;
       }
       return 0;
}
/* Driver Operation structure */
static struct file_operations myDriver_fops = {
       owner: THIS_MODULE,
       write: myDriver_write,
       read: myDriver_read,
       ioctl: myDriver_ioctl,
       open: myDriver_open,
       release: myDriver_release,
};
/* Module Init & Exit function */
#ifdef CONFIG_DEVFS_FS
devfs_handle_t devfs_myDriver_dir;
devfs_handle_t devfs_myDriver_raw;
#endif
static int __init myModule_init(void)
{
       /* Module init code */
       PRINTK("myModule_init\n");
       /* Driver register */
       myDriver_Major = register_chrdev(0, DRIVER_NAME, &myDriver_fops);
       if(myDriver_Major < 0)
       {
              PRINTK("register char device fail!\n");
              return myDriver_Major;
       }
       PRINTK("register myDriver OK! Major = %d\n", myDriver_Major);
#ifdef CONFIG_DEVFS_FS
       devfs_myDriver_dir = devfs_mk_dir(NULL, "myDriver", NULL);
       devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myDriver_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myDriver_fops, NULL);
       PRINTK("add dev file to devfs OK!\n");
#endif
       return 0;
}
static void __exit myModule_exit(void)
{
       /* Module exit code */
       PRINTK("myModule_exit\n");
       /* Driver unregister */
       if(myDriver_Major > 0)
       {
#ifdef CONFIG_DEVFS_FS
        devfs_unregister(devfs_myDriver_raw);
        devfs_unregister(devfs_myDriver_dir);
#endif
        unregister_chrdev(myDriver_Major, DRIVER_NAME);
       }
       return;
}
MODULE_AUTHOR("SXZ");
MODULE_LICENSE("Dual BSD/GPL");
module_init(myModule_init);
module_exit(myModule_exit);

注：小志整理