Android中字符设备驱动和应用实例(一) 驱动部分

Android中字符设备驱动和应用实例(一)——驱动部分

 

下面介绍创建Android设备对应的字符设备驱动

1 字符驱动

在此示例中，我们将字符驱动添加到drivers/char目录下。

（1）字符驱动的路径如下：

drivers/char/class_reg_unreg.c

 

（2）字符驱动的内容如下：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/moduleparam.h>
#include <linux/pci.h>
#include <asm/unistd.h>
#include <linux/device.h>


#define    MEM_MALLOC_SIZE    4096
#define    MEM_MAJOR        246
#define    MEM_MINOR        0

static char *mem_spvm;
static struct class *mem_class;
static struct cdev *mem_cdev;
static int devno; 

static int __init class_reg_unreg_init(void);
static void __exit class_reg_unreg_exit(void);
static int mem_open (struct inode *inode, struct file *filp);
static int mem_release (struct inode *inode, struct file *filp);
static ssize_t mem_read (struct file *filp, char __user *buf, size_t count, loff_t *f_pos);
static ssize_t mem_write (struct file *filp, const char __user *buf, size_t count, loff_t *f_pos);

static void class_create_release (struct class *cls);

static void class_create_release (struct class *cls)
{
    printk("%s\n", __func__ );
    kfree(cls);
}

struct file_operations mem_fops = 
{
    .open = mem_open,
    .release = mem_release,
    .read = mem_read,
    .write = mem_write,
};


int mem_open (struct inode *inode, struct file *filp)
{
    printk("mem open\n" );
    // 模块引用计数器子加
    try_module_get(THIS_MODULE);
    return 0;
}

int mem_release (struct inode *inode, struct file *filp)
{
    printk("%s\n", __func__);
    // 模块引用计数器子加
    module_put(THIS_MODULE);
    return 0;
}

ssize_t mem_read (struct file *filp, char __user *buf, size_t count,
                        loff_t *f_pos)
{
    int res = -1;
    char *tmp;

    printk("%s\n", __func__);
    
    tmp = mem_spvm;
    if (tmp == NULL) 
    {
        return 0;
        printk("%s error: empty pointer!\n", __func__);
    }

    if (count > MEM_MALLOC_SIZE)
    {
        count = MEM_MALLOC_SIZE;
        printk("%s size too large, resize to max size\n", __func__);
    }
    
    res = copy_to_user(buf, tmp, count);
    if (res == 0)
    {
        printk("<0> copy to user data success\n");
        return count;
    }
    printk("<0> copy to user data failed: res=%d\n", res);

    return 0;
}

ssize_t mem_write (struct file *filp, const char __user *buf, size_t count,
                        loff_t *f_pos)
{
    int res = -1;
    char *tmp;

    printk("%s\n", __func__);

    tmp = mem_spvm;
    if (tmp == NULL) 
    {
        return 0;
        printk("%s error: empty pointer!\n", __func__);
    }

    if (count > MEM_MALLOC_SIZE)
    {
        count = MEM_MALLOC_SIZE;
        printk("%s size too large, resize to max size\n", __func__);
    }

    res = copy_from_user(tmp, buf, count);
    if (res == 0)
    {
        printk("<0> copy from user data success\n");
        return count;
    }
    printk("<0> copy from user data fail: res=%d\n", res);

    return 0;
}


static int __init class_reg_unreg_init(void)
{
    int ret = 0;

    printk("%s\n", __func__);

    // 创建设备号
    devno = MKDEV(MEM_MAJOR, MEM_MINOR);

    // 申请字符设备号，并创建字符设备节点
    if (MEM_MAJOR)
    {
        // 静态申请设备号
        ret = register_chrdev_region(devno, 1, "my_char_dev");
    }
    else
       {
           // 动态分配设备号
        ret = alloc_chrdev_region(&devno, 0, 1, "my_char_dev");
    }  
    if (ret) 
    {
        printk("<0> register chrdev failed!\n");
        goto fail_register;    
    }
    printk("<0>register chrdev success, major, minor= (%d, %d)\n", MAJOR(devno), MINOR(devno));

    // 分配缓冲区
    mem_spvm = (char *)vmalloc(MEM_MALLOC_SIZE);
    if (mem_spvm == NULL)
    {
        ret = 1;
        printk("<0>vmalloc failed!\n");
        goto fail_vmalloc;
    }
    printk("<0>vmalloc success, addr=0x%x\n", (unsigned int)mem_spvm);

    // 动态分配一个字符设备对象
    mem_cdev = cdev_alloc();
    if (mem_cdev == NULL) 
    {
        printk("<0> cdev_alloc failed!\n");
        ret = 1;
        goto fail_cdev_alloc;
    } 
    printk("<0> cdev_alloc success, addr=0x%x\n", (unsigned int)mem_cdev);

    // 初始化字符设备对象
    cdev_init(mem_cdev, &mem_fops);
    // 初始化字符设备持有者
    mem_cdev->owner = THIS_MODULE;
    // 将字符设备添加到内核系统中
    ret = cdev_add(mem_cdev, devno, 1);
    if (ret) 
    {
        printk("<0> cdev_add failed!\n");
        goto fail_cdev_add;    
    }

    // 申请class结构体内存
    mem_class = kzalloc(sizeof(*mem_class), GFP_KERNEL);
    if (mem_class == NULL) 
    {
        printk("<0> create mem class failed!\n");
        ret = 1;
        goto fail_mem_class;
    }
    printk("<0> create mem class success\n");

    mem_class->name = "my_char_dev";
    mem_class->owner = THIS_MODULE;
    // 注销时class时的回调函数，在此回调函数中释放之前所分配的class结构体内存
    mem_class->class_release = class_create_release;

    // 将class注册到内核中，同时会在/sys/class/下创建class对应的节点
    int retval = class_register(mem_class);
    if (ret) 
    {
        printk("<0> class_register failed!\n");
        goto fail_class_reg;    
    }
    printk("<0> class_register success\n");

    // 在/dev/下创建与class对应的设备节点
    device_create(mem_class, NULL, devno, NULL, "my_char_dev");

    return 0;

fail_class_reg:

fail_mem_class:
    if (mem_class)
    {
        kfree(mem_class);
        mem_class = NULL;
    }

fail_cdev_add:
fail_cdev_alloc:
    if (mem_cdev)
    {
        kfree(mem_cdev);
        mem_cdev = NULL;
    }

fail_vmalloc:
    if (mem_spvm)
    {
        vfree(mem_spvm);
        mem_spvm = NULL;
    }

fail_register:
    unregister_chrdev_region(devno, 1);

    return ret;
}

static void __exit class_reg_unreg_exit(void)
{
    printk("%s\n", __func__);
    device_destroy(mem_class, devno);
    if (mem_class)
    {
        class_unregister(mem_class);
        //kfree(mem_class);
        mem_class = NULL;
    }

    if (mem_spvm)
    {
        vfree(mem_spvm);
        mem_spvm = NULL;
    }

    if (mem_cdev)
    {
        // 从内核中将设备删除
        cdev_del(mem_cdev);
        kfree(mem_cdev);
        mem_cdev = NULL;
    }

    // 注销字符设备
    unregister_chrdev_region(devno, 1);
}

module_init(class_reg_unreg_init);
module_exit(class_reg_unreg_exit);

MODULE_AUTHOR("skywang <wangkuiwu@gmail.com>");
MODULE_DESCRIPTION("class register unregister driver");
MODULE_LICENSE("GPL");

  

2 修改配置

（1）修改drivers/char/Kconfig，添加以下内容：

config SKYWANG_CLASS_REG_UNREG
     tristate "skywang class register and unregister driver"
     help
     add this to support skywang class register and unregister driver 

（2）修改drivers/char/Makefile，添加以下内容：

+obj-$(CONFIG_SKYWANG_CLASS_REG_UNREG) += class_reg_unreg.o 

 

3 编译

（1）执行make menuconfig生产字符设备模块文件，如下图：

（2）执行make编译生成模块文件，模块文件路径如下：

drivers/char/ class_reg_unreg.ko

 

4 装载/卸载到手机中

（1）将class_reg_unreg.ko导入到Android系统中，执行以下命令：

# adb push class_reg_unreg.ko /system/class_reg_unreg.ko

 

（2）装载模块文件，执行以下命令：

# cd /system/
# insmod class_reg_unreg.ko

执行insmod之后，坚持是否生成文件节点“/sys/class/my_char_dev”和“/dev/my_char_dev”。若生成文件节点，则代表装载驱动成功！

 

（3）若需要卸载模块文件，可以通过以下命令：

#rmmod class_reg_unreg.ko

 

关于该驱动的测试程序，请参考“Android中字符设备驱动和应用实例(二) 应用部分”