内核驱动系列之字符设备驱动流程

内核模块基础：

1 可以通过编译进内核和动态加载内核模块来将驱动模块加载，调试过程中后者比较常用。

2 相关命令： insmod rmmod modinfo lsmod dmesg modinfo cat /proc/devices cat /proc/moduls

3 内核模块程序结构：

　　1 模块加载函数 --- module_init (initial_function) 其中initial_functon 常用__init修饰

　　2 模块卸载函数 --- module_exit (cleanup_function) 其中cleanup_functon 常用__exit修饰

　　3 模块许可声明 （必须) --- MODULE_LICENSE ("DUAL BSD/GPL");

　　4 模块参数（可选）--- module_param

　　5 模块导出符号 （可选）--- EXPORT_SYMBOL (add_interger);

　　6 模块作者等信息声明（可选）--- MODULE_AUTHOR MODULE_DEVICE_TABLE 等

4 内核模块的编译，Makefile简单示例如

##一定要注意内核版本与交叉编译工具链相一致，此处的内核目录是目标板的源码目录
obj-m += hello-ioctl.o
##多文件时加一句 modulename-objs := file1.o file2.o
ARCH ?= arm
CROSS_COMPILE ?= arm-linux-
KERNELDIR := /source/kernel/linux-2.6.35
all:
    make -C $(KERNELDIR) M=$(PWD) modules
clean:
    make -C $(KERNELDIR) M=$(PWD) clean

 

字符设备驱动：

一个字符设备驱动主要由驱动加载与卸载函数 和 file_operations结构体中成员函数组成。

加载模块中主要完成设备号的申请和cdev的注册，而在卸载函数中英实现设备号与cdev的注销。

file_operations结构体成员函数是字符设备驱动与内核的接口，大多数字符设备驱动都会实现

read(), write()和ioctl()函数。

下面使用一个虚拟的globalmem设备来说明字符设备驱动的编写过程：

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/slab.h>//for kfree
#include <linux/kernel.h>

#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
#define GLOBALMEM_MAJOR 250
#define GLOBALMEM_MAGIC 'j' //for the command of ioctl
#define MEM_CLEAN_IO (GLOBALMEM_MAGIC, 0)

static int globalmem_major = GLOBALMEM_MAJOR;
struct globalmem_dev {
    struct cdev cdev;
    unsigned char mem[GLOBALMEM_SIZE];
};
struct globalmem_dev *globalmem_devp;
//use the private_data for more than one device
int globalmem_open (struct inode *inode, struct file *filp)
{
    struct globalmem_dev *dev;
    dev = container_of (inode->i_cdev, struct globalmem_dev, cdev);
    filp->private_data = dev;
    return 0;
}
int globalmem_release (struct inode *inode, struct file *filp)
{
    return 0;
}
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, (void *) (dev->mem + p), count))
        ret = -EFAULT;
    else {
        *ppos += count;
        ret = count;
        printk (KERN_INFO "read %d bytes(s) from %ld\n", count, p);
    }

    return ret;
}
static ssize_t globalmem_write (struct file *filp, const char __user *buf,
        size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    size_t 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 %d bytes from %ld\n", count, p);
    }
    return ret;
}
static loff_t globalmem_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 > GLOBALMEM_SIZE) {
                ret = -EINVAL;
                break;
            }
            filp->f_pos = (unsigned int) offset;
            ret = filp->f_pos;
            break;
        case 1:
            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;
    }
    return ret;
}

static int globalmem_ioctl (struct inode *inodep, struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct globalmem_dev *dev = filp->private_data;
    switch (cmd) {
        case MEM_CLEAR:
            memset (dev->mem, 0, GLOBALMEM_SIZE);
            printk (KERN_INFO "globalmem is set to zero\n");
            break;
        default:
            return -EINVAL;
    }
    return 0;
}

static const struct file_operations globalmem_fops = {
    .owner = THIS_MODULE,
    .llseek = globalmem_llseek,
    .read = globalmem_read,
    .write = globalmem_write,
    .ioctl = globalmem_ioctl,
    .open = globalmem_open,
    .release = globalmem_release,
};
static void globalmem_setup_cdev (struct globalmem_dev *dev, int index)
{
    int err;
    int devno = MKDEV (globalmem_major, 0);

    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", err);
}
int globalmem_init (void)
{
    int result;
    dev_t devno = MKDEV (globalmem_major, 0);
    if (globalmem_major)
        result = register_chrdev_region (devno, 2, "globalmem");
    else {
        result = alloc_chrdev_region (&devno, 0, 2, "globalmem");
        globalmem_major = MAJOR (devno);
    }
    if (result < 0)
        return result;
    globalmem_devp = kmalloc (2 * sizeof (struct globalmem_dev),
            GFP_KERNEL);
    if (!globalmem_devp) {
        result = -ENOMEM;
        goto fail_malloc; //use goto for exception handling
    }
    memset (globalmem_devp, 0, 2 * sizeof (struct globalmem_dev));
    globalmem_setup_cdev (&globalmem_devp[0], 0);
    globalmem_setup_cdev (&globalmem_devp[1], 1);
    return 0;

fail_malloc: unregister_chrdev_region (devno, 1);
return result;
}

void globalmem_exit (void)
{
    cdev_del (&(globalmem_devp[0].cdev));
    cdev_del (&(globalmem_devp[1].cdev));
    kfree (globalmem_devp);
    unregister_chrdev_region (MKDEV (globalmem_major, 0), 2);
}

MODULE_AUTHOR ("cfm");
MODULE_LICENSE ("Dual BSD/GPL");
module_param (globalmem_major, int, S_IRUGO);
module_init (globalmem_init);
module_exit (globalmem_exit);