如何编写字符设备驱动

0.包含必须的头文件

#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>            /*kfree ,kmalloc */
#include <linux/device.h>

1.编写字符设备函数

1.1、分配核心结构

struct cdev *cdev_alloc(void)

功能：分配一个核心结构。
返回值：成功，返回核心结构；失败：返回负数
说明：可以不用该函数分配，直接定义如下：

   struct cdev pcdev;

1.2、申请设备号的相关函数
1）静态申请设备号函数

int register_chrdev_region( dev_t from，unsigned count,const char *name )

功能：注册一个设备号范围。
参数：
from：起始设备号(主、次)
count：连续的次设备号数量
name：设备名，不需要和/dev/的设备文件名相同,是/proc/device文件的名字
返回值：成功，返回0；失败：返回负数
2）动态申请设备号函数

int alloc_chrdev_region(dev_t *dev,unsigned int baseminor,unsigned int count,const char *name)

功能：注册一个设备号范围。
参数：
dev：存放分配到的第一个设备(包含主次设备号)。
baseminor：要分配起始次设备号
count：连续的次设备号数量
name：设备名，不需要和/dev/的设备文件名相同
返回值：成功，返回0；失败：返回负数

1.3、初始化核心结构

void cdev_init(struct cdev *cdev, const struct file_operations *fops)

功能：初始化核心结构；具体做的是清0核心结构，初始化核心结构的list，kobj，ops成员。
参数：
cdev：需要初始化的核心结构指针。
fops：文件操作方法结构指针。

1.4、注册核心结构

int cdev_add( struct cdev *p, dev_t dev,unsigned int count)

功能注册一个cdev结构
参数
p：已经初始化的核心结构指针
dev：起始设备号(包含主次设备号在内)；前面申请设备号函数的返回值。
count：连续次设备号数量
返回值成功：返回0 ；失败：返回负数

1.5、注销核心结构

void cdev_del(struct cdev *p)

功能：注销一个cdev结构
参数：
p：前面注册的struct cdev结构指针

1.6、释放设备号

void unregister_chrdev_region(dev_t from, unsigned count)

功能：释放设备号
参数：
from：起始设备号(主、次)
count：连续的次设备号数量
1.7、释放核心结构空间
void kfree(struct cdev *p);
功能：注销一个cdev结构
参数：
p：前面注册的struct cdev结构指针

结构体struct cdev 已经在cdev.h定义好，具体如下：

struct cdev {struct kobject kobj;struct module *owner;const struct file_operations *ops;        /* 设备文件操作方法 */struct list_head list;dev_t dev;                                       /* 32位设备号，包含主和次 */unsigned int count;                            /* 占用多少个连续的次设备号 */
}

2.自动创建/dev/目录设备文件函数

2.1创建一个设备类

#define class_create(owner, name)        \
({                      \static struct lock_class_key __key;    \__class_create(owner, name, &__key);   \
})

功能：创建一个设备类
参数：
owner：类的所有者，固定是：THIS_MODULE
name：类名，随便，能有含义最好，不是 /dev/下设备的名字。
返回值：成功：返回有效 struct class *指针；失败：返回错误指针，可以使用 ERR_PTR()宏转换成错误代码。

2.2创建一个设备，报告设备信息

struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)

功能：创建一个设备
参数：
class：指定所要创建的设备所从属的类， class_create的返回值。
parent：这个设备的父设备，如果没有就指定为NULL
devt：设备号。
drvdata：设备信息，一般为NULL。
fmt：设备名称，而且是缓冲形式。

2.3删除一个设备
void device_destroy(struct class *class, dev_t devt)
功能：删除一个设备
参数：
class：指定所要创建的设备所从属的类， class_create的返回值。
devt：设备号。
2.4删除一个设备类
void class_destroy(struct class *cls)
功能：删除一个设备类
参数：
cls：指定所要创建的设备所从属的类， class_create的返回值。

代码例子：

#include <linux/kernel.h>
#include <linux/module.h>//包含必须的头文件
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>            /*kfree ,kmalloc */
#include <linux/device.h>//以下是文件操作方法的具体实现代码
static int xxx_open (struct inode *pinode, struct file *pfile)
{printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);return 0;
}
static ssize_t xxx_read (struct file *pfile,  char __user *buf,  size_t count,  loff_t *poff)
{printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);return count;
}
static ssize_t xxx_write (struct file *pfile, const char __user *buf, size_t count,  loff_t *poff)
{printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);return count;
}
static loff_t xxx_llseek (struct file *pfile, loff_t off, int whence)
{printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);return off;
}
static long xxx_unlocked_ioctl (struct file *pfile, unsigned int cmd, unsigned long args)
{printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);return 0;
}static int xxx_release (struct inode *pinode, struct file *pfile)
{printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);return 0;
}//文件操作方法集合指针
static const struct file_operations char_dev_fops={.open            =   xxx_open,.write           =   xxx_write,.read            =   xxx_read,.llseek          =   xxx_llseek,.unlocked_ioctl  =   xxx_unlocked_ioctl,.release         =   xxx_release,
};//定义核心数据结构
static struct cdev *p_cdv;
//定义第一个设备号(包含主和次)
static dev_t dev_no;
//定义设备主设备号
static unsigned int major=0;
//定义设备名
#define MYCHAR_DEV  "auto_linux26"#define CLASS_NAME  "chardev26"
static struct class *linux26_class = NULL;
static struct device *this_device = NULL;static int __init chrdev_test_init(void)
{int ret = -1;//1.使用cdev_alloc函数分配p_cdv空间p_cdv=cdev_alloc();if(p_cdv == NULL){printk("cdev_alloc error!\n");ret = -ENOMEM;/* 分配失败一般是内存不足导致的  */goto cdev_alloc_error;    }//2.申请设备号:动态或者静态ret = alloc_chrdev_region(&dev_no, 0, 2,MYCHAR_DEV);if(ret < 0){printk("alloc_chrdev_region error!\n");  goto alloc_chrdev_region_error;}//3.初始化p_cdv结构cdev_init(p_cdv, &char_dev_fops);//4.注册已经初始化好的c_dev结构ret = cdev_add(p_cdv, dev_no, 2);if ( ret < 0 ) {    printk(KERN_EMERG "cdev_add  error\n");goto cdev_add_error;}/* 增加自动创建设备文件功能 *///5.创建一个设备类// linux26_class = class_create(THIS_MODULE,MYCHAR_DEV);//可以和设备名相同linux26_class = class_create(THIS_MODULE, CLASS_NAME); //取一个不同于设备名的类名if ( IS_ERR(linux26_class) ) {   ret = PTR_ERR(linux26_class);goto class_create_err;}//6.创建一个设备,报告设备信息this_device =  device_create(linux26_class,NULL , dev_no,   NULL, "%s", MYCHAR_DEV);if ( IS_ERR(this_device) ) {ret = PTR_ERR(this_device);goto device_create_err;}major=MAJOR(dev_no);printk(KERN_EMERG "major = %d \n",major);return 0;device_create_err:class_destroy(linux26_class);class_create_err:cdev_del(p_cdv);cdev_add_error:unregister_chrdev_region(dev_no, 2);alloc_chrdev_region_error:kfree(p_cdv);/*释放p_cdv结构空间*/cdev_alloc_error:return ret;
}static void __exit chrdev_test_exit(void)
{device_destroy(linux26_class, dev_no);class_destroy(linux26_class);//1.注销p_cdv结构cdev_del(p_cdv);//2.释放设备号unregister_chrdev_region(dev_no, 2);//3.释放p_cdv结构空间kfree(p_cdv);//4.删除设备device_destroy(linux26_class, devnr);//5.删除设备类class_destroy(linux26_class);
}module_init(chrdev_test_init);
module_exit(chrdev_test_exit);MODULE_LICENSE("GPL");