新字符设备驱动示例

简介

新的字符设备驱动已经不再使用register_chrdev和unregister_chrdev这两个函数来注册或者注销字符设备，而是使用Linux内核推荐的新字符驱动API函数。新的字符驱动可以不用手动添加设备节点

函数

设备号分配示例

新字符设备驱动下，设备号分配示例代码如下：

int major;		//主设备号
int minor;		//次设备号
dev_t devid;	//设备号

if(major){
	devid = MKDEV(major,0);					//定义了主设备号
	register_chrdev_region(devid,1,"test");	//大部分驱动次设备号都选择0
}else{										//没有定义主设备号
	alloc_chrdev_region(&devid,0,1,"test");	//申请设备号
	major = MAJOR(devid);					//获取分配号的主设备号
	minor = MINOR(devid);					//获取分配号的次设备号
}

注销设备号

如果要注销设备号的话，使用如下代码即可：

unregister_chrdev_region(devid, 1); 		/* 注销设备号 */

注册方法

字符驱动结构体

struct cdev { 
 	struct kobject kobj; 
 	struct module *owner; 
 	const struct file_operations *ops; 
 	struct list_head list; 
 	dev_t dev; 
 	unsigned int count; 
 };

cdev_init函数

使用cdev_init函数对已经定义的cdev结构体变量进行初始化，示例如下：

struct cdev testcdev;

//设备操作函数
static struct file_operations test_fops= {
	.owner = THIS_MODULE,
	/*其他具体的初始项*/
}

testcdev.owner = THIS_MODULE;
cdev_init(&testcdev, &test_fops);	//初始化cdev结构体变量

cdev_add 函数

用于向Linux系统添加字符设备（cdev结构体变量），示例如下

struct cdev testcdev;

//设备操作函数
static struct file_operations test_fops= {
	.owner = THIS_MODULE,
	/*其他具体的初始项*/
}

testcdev.owner = THIS_MODULE;
cdev_init(&testcdev, &test_fops);	//初始化cdev结构体变量
cdev_add(&testcdev, devid, 1); 		//添加字符设备 

cdev_del函数

卸载驱动的时候一定要奖Linux内核中删除相应的字符设备

cdev_del(&testcdev); 			/* 删除 cdev 

自动创建节点

创建和删除类

自动创建设备节点是在驱动程序的入口函数完成的，一般在cdev_add函数后面添加自动创建设备节点相关代码。

//创建一个class类
struct class *class_create (struct module *owner, const char *name); 	//
void class_destroy(struct class *cls); 									//类删除函数

创建设备

创建完一个类之后，需要创建一个设备

/*
@description:该函数是在已经创建的类下面 创建一个设备
@pararm-class:设备要创建哪个类下面
@pararm-parent:父设备，一般为NULL
@pararm-devt:设备号
@pararm-drvdata:设备可能会使用的一些数据，一般为NULL
@pararm-fmt:设备名字，设置的名字会直接在/dev/下生成对应名称的设备
*/

struct device *device_create(	struct class *class, 
								struct device *parent,
								dev_t devt, 
								void *drvdata, 
								const char *fmt, ...);
    
//卸载驱动的时候需要删除创建的设备
void device_destroy(struct class *class, dev_t devt);

整体示例

LED驱动

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define NEWCHRLED_CNT   1
#define NEWCHRLED_NAME  "newchrled"

#define LEDOFF 0
#define LEDON  1

#define CCM_CCGR1_BASE          (0x020C406C)
#define SW_MUX_GPIO1_IO03_BASE  (0X020E0068)
#define SW_PAD_GPIO1_IO03_BASE  (0X020E02F4)
#define GPIO1_DR_BASE           (0X0209C000)
#define GPIO1_GDIR_BASE         (0X0209C004)

//映射后的寄存器虚拟地址指针
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

/*newchrled 设备结构体*/
struct newchrled_dev
{
    dev_t devid;                //设备号
    struct cdev cdev;           //cdev 字符设备
    struct class *class;        //类
    struct device *device;      //设备
    int major;                  //主设备号
    int minor;                  //次设备号
};

struct newchrled_dev newchrled;

void led_switch(u8 sta)
{
    u32 val = 0;
    if(sta == LEDON){
        val = readl(GPIO1_DR);
        val &= ~(1 << 3);
        writel(val,GPIO1_DR);
    }else if(sta == LEDOFF){
        val =readl(GPIO1_DR);
        val |=(1 << 3);
        writel(val,GPIO1_DR);
    }

}

static int led_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &newchrled;
    return 0;
}

static ssize_t led_read(struct file *filp ,char __user *buf,size_t cnt,loff_t *offt)
{
    return 0;
}

static ssize_t led_write(struct file *filp,const char __user *buf,size_t cnt ,loff_t *offt){
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;

    retvalue = copy_from_user(databuf ,buf ,cnt); //将buf的内容复制到databuf
    if(retvalue < 0){
        printk("kernel write failed\r\n");
        return -EFAULT;
    }

    ledstat = databuf[0];   //获取写入的灯的状态

    if(ledstat == LEDON){
        led_switch(LEDON); //打开
    }else if(ledstat == LEDOFF){
        led_switch(LEDOFF); //关闭
    }
    return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
    return 0;
}
//设备操作函数
static struct file_operations newchrled_fops = {
    .owner = THIS_MODULE,
    .open =led_open,
    .read =led_read,
    .write = led_write,
    .release= led_release,
};
//驱动入口
static int __init led_init(void){

    u32 val =0;
    //寄存器地址映射
    IMX6U_CCM_CCGR1=ioremap(CCM_CCGR1_BASE, 4);
    SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
    SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
    GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
    GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);
    //使能GPIO1时钟
    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26);
    val |= (3 << 26);
    writel(val,IMX6U_CCM_CCGR1);


    writel(5, SW_MUX_GPIO1_IO03);


    writel(0x10B0, SW_PAD_GPIO1_IO03);


    val = readl(GPIO1_GDIR);
    val &= ~(1 << 3);
    val |= (1 << 3);
    writel(val, GPIO1_GDIR);


    val = readl(GPIO1_DR);
    val |= (1 << 3);
    writel(val, GPIO1_DR);

    /*注册字符设备驱动*/
    /*创建设备号*/
    if(newchrled.major){ 
        newchrled.devid = MKDEV(newchrled.major,0);
        register_chrdev_region(newchrled.devid,NEWCHRLED_CNT,NEWCHRLED_NAME);
    }else{
        alloc_chrdev_region(&newchrled.devid, 0 , NEWCHRLED_CNT,NEWCHRLED_NAME);
        newchrled.major = MAJOR(newchrled.devid);
        newchrled.minor = MINOR(newchrled.devid);
    }
    
    printk("newcheled major=%d,minor=%d\r\n",newchrled.major,newchrled.minor);

    newchrled.cdev.owner = THIS_MODULE;
    cdev_init(&newchrled.cdev,&newchrled_fops);
    
    cdev_add(&newchrled.cdev,newchrled.devid,NEWCHRLED_CNT);

    newchrled.class = class_create(THIS_MODULE, NEWCHRLED_NAME);
    if(IS_ERR(newchrled.class)){
        return PTR_ERR(newchrled.class);
    }

    //创建设备
    newchrled.device = device_create(newchrled.class , NULL,newchrled.devid,NULL,NEWCHRLED_NAME);
    if(IS_ERR(newchrled.device)){
        return PTR_ERR(newchrled.device);
    }

    return 0;

}

//驱动出口
static void __exit led_exit(void){
    iounmap(IMX6U_CCM_CCGR1);
    iounmap(SW_MUX_GPIO1_IO03);
    iounmap(SW_PAD_GPIO1_IO03);
    iounmap(GPIO1_DR);
    iounmap(GPIO1_GDIR);

    /* 注销字符设备 */
    cdev_del(&newchrled.cdev);/* 删除 cdev */
    unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);
    
    device_destroy(newchrled.class, newchrled.devid);
    class_destroy(newchrled.class);

}

module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("heihei");

LED驱动测试APP

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#define LEDOFF 	0
#define LEDON 	1

int main(int argc, char *argv[])
{
	int fd, retvalue;
	char *filename;
	unsigned char databuf[1];
	
	if(argc != 3){
		printf("Error Usage!\r\n");
		return -1;
	}

	filename = argv[1];

	
	fd = open(filename, O_RDWR);
	if(fd < 0){
		printf("file %s open failed!\r\n", argv[1]);
		return -1;
	}

	databuf[0] = atoi(argv[2]);	

	retvalue = write(fd, databuf, sizeof(databuf));
	if(retvalue < 0){
		printf("LED Control Failed!\r\n");
		close(fd);
		return -1;
	}

	retvalue = close(fd); 
	if(retvalue < 0){
		printf("file %s close failed!\r\n", argv[1]);
		return -1;
	}
	return 0;
}

参考

《【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.6》