创建设备文件节点_使用device_create实例分析

最新推荐文章于 2024-10-15 13:19:39 发布

kunkliu

最新推荐文章于 2024-10-15 13:19:39 发布

阅读量2k

点赞数

分类专栏： linux-kernel

原文链接：https://blog.csdn.net/qq_30624591/article/details/85339304

版权

linux-kernel 专栏收录该内容

44 篇文章 6 订阅

订阅专栏

Linux 的设备管理是和文件系统紧密结合的，各种设备都以文件的形式存放在/dev 目录下，称为设备文件。应用程序可以打开、关闭和读写这些设备文件，完成对设备的操作，就像操作普通的数据文件一样。

查看/proc/devices 文件可以获知系统中注册的设备，第 1 列为主设备号，第 2 列为设备名，主设备号是与驱动对应的概念，同一类设备一般使用相同的主设备号，不同类的设备一般使用不同的主设备号（但是也不排除在同一主设备号下包含有一定差异的设备）。因为同一驱动可支持多个同类设备，因此用次设备号来描述使用该驱动的设备的序号，序号一般从0开始。

adb命令：cat /proc/devices 可以查看到主设备号和对应的设备
adb命令：cat /dev/ 可以查看到所有的设备节点

创建设备节点可以手动创建也可以自动创建。

一,手动创建：可以通过mknod命令手动创建。

mknod命令
命令的格式是：
mknod /dev/设备名设备类型(字符：c,块：b) 主设备号从设备号
其中，主设备号用来区分不同种类的设备，而次设备号用来区分同一类型的多个设备。
因此，想要创建设备节点，需要知道设备类型，及其主从设备号。
例如：mknod /dev/caizhongding c 244 10 就创建了一个caizhongding的字符设备节点，主设备号是244，次设备号是10
手动创建设备节点的缺点是容易导致设备号冲突。
二，自动创建：

利用udev（mdev）来实现设备文件的自动创建，首先应保证支持udev（mdev），由busybox配置。在驱动初始化代码里调用class_create为该设备创建一个class，再为每个设备调用device_create创建对应的设备。

驱动加载时完成如下工作：分配设备号-------------注册字符设备------------动态创建设备节点。
驱动卸载时完成如下工作：删除设备节点-------------取消字符设备的注册-----------删除设备号。

1、头文件的添加
#include xxxx
xxxx包含一些必要的头文件；

2、定义一个类和一个设备的结构指针，test_class 和test_class_dev 可随意命名；
static struct class *test_class = NULL;
static struct device *test_class_dev = NULL;

3、在入口函数（module_init）里添加
3.1 调用alloc_chrdev_region动态分配设备号，函数具体用法可以自己去linux kernel找原函数；

3.2 初始化设备，关联对应的file_operation，注册字符设备，具体用法可以参考Linux kernel里面的原函数：
int error;
dev_t devno = MKDEV(test_major, test_minor);

cdev_init (&cdev, &test_fops);
cdev.owner = THIS_MODULE;
cdev.ops = &test_fops;

/注册字符设备/
error = cdev_add (&cdev, devno, 1);
if(error)
printk(“Error %d adding test_setup_cdev”, error);

3.3 调用test_class = class_create(THIS_MODULE, “test_class”);会在sys/class目录下生成test_class文件夹，test_class可以随意命名；

3.4 调用test_class_dev = device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, “xxx”);会在/dev目录下生成xxx的设备文件，major是主设备号，可以在前面宏定义指定,也可以直接指定为0~254中的没被使用的一个。

4、在出口函数（module_exit）里添加删除字符设备（cdev_del），注销设备和设备类别（device_destroy和class_destroy），释放设备号（unregister_chrdev_region）：

dev_t devno = MKDEV (test_major, test_minor);

cdev_del(&cdev);
device_destroy(test_class, devno);
class_destroy(test_class);
unregister_chrdev_region (devno, number_of_devices);

这样就可以通过adb工具查看自动创建的设备节点文件和类文件：
root@inwatch_portal:/dev # ls -l
root@inwatch_portal:/sys/class # ls -l

对生成的节点进行读写操作：
C:\Users\asus>adb shell
root@inwatch_portal:/ # cd dev
cd dev
root@inwatch_portal:/dev # echo 11111 > test
echo 11111 > test
root@inwatch_portal:/dev # cat test
cat test
11111
root@inwatch_portal:/dev #

device_create动态创建设备节点具体实现代码如下：

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/ioctl.h>
#include <linux/uaccess.h>
#include <linux/string.h>
#include <linux/wait.h>
#include <linux/types.h>
#include <linux/proc_fs.h>

#define BUFSIZE 1024

/*主设备和从设备号变量*/
static int test_major = 0;
static int test_minor = 0;

/*设备类别和设备变量*/
static struct cdev cdev;
static struct class *test_class = NULL;
static struct device *test_class_dev = NULL;

int number_of_devices = 1;
dev_t dev = 0;
static char *buf;
static unsigned int len;

/*打开设备方法，空实现*/
static int test_open(struct inode *inode, struct file *filp) {

return 0;
}

/*设备文件释放时调用，空实现*/
static int test_release(struct inode *inode, struct file *filp) {

return 0;
}

/************************
* file_operations->read
* 函数原型：static ssize_t read(struct file *file, char *buf, size_t count, loff_t *ppos)
************************/

static ssize_t test_read(struct file *file, char __user *buffer,size_t count, loff_t *f_pos)
{
if(*f_pos > 0)
return 0;

printk("---start read---\n");
printk("the string is >>>>> %s\n", buf);

if(copy_to_user(buffer, buf, len))
return -EFAULT;
*f_pos = *f_pos + len;
return len;
}

/************************
* file_operations->write
* 函数原型：static ssize_t write(struct file *file, const char *buf, size_t count, loff_t *ppos)
************************/

static ssize_t test_write(struct file *file, const char __user *buffer,size_t count, loff_t *f_pos)
{

if(count <= 0)
return -EFAULT;
printk("---start write---\n");

len = count > BUFSIZE ? BUFSIZE : count;

// kfree memory by kmalloc before
if(buf != NULL)
   kfree(buf);
buf = (char*)kmalloc(len+1, GFP_KERNEL);
if(buf == NULL)
{
   printk("device_create kmalloc fail!\n");
   return -EFAULT;
}

//memset(buf, 0, sizeof(buf));
memset(buf, 0, len+1);

if(copy_from_user(buf, buffer, len))
return -EFAULT;
printk("device_create writing :%s",buf);
return len;
}

/*设备文件操作方法表*/
static struct file_operations test_fops = {
.owner = THIS_MODULE,
.open = test_open,
.release = test_release,
.read = test_read,
.write = test_write,
};

static void test_setup_cdev (void)
{
int error;
dev_t devno = MKDEV(test_major, test_minor);

cdev_init (&cdev, &test_fops);
cdev.owner = THIS_MODULE;
cdev.ops = &test_fops;

/*注册字符设备*/
error = cdev_add (&cdev, devno, 1);
if(error)
printk("Error %d adding test_setup_cdev", error);

}

static int __init test_init (void)
{
int err = -1;
dev_t dev = 0;

printk("---czd--- Initializing test device.\n");

/*动态分配主设备和从设备号*/
err = alloc_chrdev_region(&dev, 0, number_of_devices, "test");
if(err < 0) {
printk("Failed to alloc char dev region.\n");
return err;
}

test_major = MAJOR(dev);
test_minor = MINOR(dev);
printk("---czd--- test_major ==> %d ; test_minor ==> %d \n",test_major,test_minor);

/*初始化设备*/
test_setup_cdev();

/*在/sys/class/目录下创建设备类test_class别目录test*/
test_class = class_create(THIS_MODULE, "test_class");
if(IS_ERR(test_class))
{
printk("Err: failed in creating class.\n");
return -1;
}

/*
* device_create - creates a device and registers it with sysfs
* @class: pointer to the struct class that this device should be registered to
* @parent: pointer to the parent struct device of this new device, if any
* @devt: the dev_t for the char device to be added
* @drvdata: the data to be added to the device for callbacks
* @fmt: string for the device's name
*
* struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)
*
*/

/*在/dev/目录和/sys/class/test目录下分别创建设备文件test*/
test_class_dev = device_create(test_class, NULL, MKDEV(test_major, 0), NULL, "test");
if(IS_ERR(test_class_dev))
{
printk("Err: failed in creating device.\n");
return -1;
}

printk("---czd--- Succedded to initialize test device.\n");
return 0;

}

/*模块卸载方法*/
static void __exit test_exit (void)
{
dev_t devno = MKDEV (test_major, test_minor);

cdev_del(&cdev);
device_destroy(test_class, devno); //delete device node under /dev
class_destroy(test_class); //delete class created by us
unregister_chrdev_region (devno, number_of_devices);
printk ("Char driver test_exit.\n");

}

module_init (test_init);
module_exit (test_exit);

MODULE_AUTHOR("czd");
MODULE_DESCRIPTION("Device_create Driver");
MODULE_LICENSE("GPL");