字符设备驱动程序框架

分手后的思念是犯贱 2022-03-26 17:20 256阅读 0赞

字符设备驱动程序框架  
  
1、写出open、write函数  
2、告诉内核  
1）、定义一个struct file\_operations结构并填充好

static struct file\_operations first\_drv\_fops = \{

.owner  =   THIS\_MODULE,    /\* 这是一个宏，推向编译模块时自动创建的\_\_this\_module变量 \*/

.open   =   first\_drv\_open,

.write  = first\_drv\_write,

\};  
2）、把struct file\_operations结构体告诉内核

major = register\_chrdev(0, "first\_drv", &first\_drv\_fops); // 注册, 告诉内核  
相关参数：第一个，设备号，0自动分配主设备号，否则为主设备号0－255  
第二个：设备名  
第二个：struct file\_operations结构体  
  
4）、register\_chrdev由谁调用（入口函数调用）  
static int first\_drv\_init(void)

5）、入口函数须使用内核宏来修饰  
module\_init(first\_drv\_init);  
module\_init会定义一个结构体，这个结构体里面有一个函数指针指向first\_drv\_init这个函数，当我们加载或安装一个驱动时，内核会自动找到这个结构体，然后调用里面的函数指针，这个函数指针指向first\_drv\_init这个函数，first\_drv\_init这个函数就是把struct file\_operations结构体告诉内核

6）、有入口函数就有出口函数

module\_exit(first\_drv\_exit);

最后加上协议

MODULE\_LICENSE("GPL");  
  
3、mdev根据系统信息自动创建设备节点：

每次写驱动都要手动创建设备文件过于麻烦，使用设备管理文件系统则方便很多。在2.6的内核以前一直使用的是devfs，但是它存在许多缺陷。它创建了大量的设备文件，其实这些设备更本不存在。而且设备与设备文件的映射具有不确定性，比如U盘即可能对应sda，又可能对应sdb。没有足够的主/辅设备号。2.6之后的内核引入了sysfs文件系统，它挂载在/sys上，配合udev使用，可以很好的完成devfs的功能，并弥补了那些缺点。（这里说一下，当今内核已经使用netlink了）。

udev是用户空间的一个应用程序，在嵌入式中用的是mdev，mdev在busybox中。mdev是udev的精简版。

首先在busybox中添加支持mdev的选项：

Linux System Utilities --->

\[\*\] mdev

\[\*\]   Support /etc/mdev.conf

\[\*\]     Support subdirs/symlinks

\[\*\]       Support regular expressions substitutions when renaming device

\[\*\]     Support command execution at device addition/removal

然后修改/etc/init.d/rcS:

echo /sbin/mdev > /proc/sys/kernel/hotplug

/sbin/mdev -s

执行mdev -s ：以‘-s’为参数调用位于 /sbin目录写的mdev（其实是个链接，作用是传递参数给/bin目录下的busybox程序并调用它），mdev扫描 /sys/class 和 /sys/block 中所有的类设备目录，如果在目录中含有名为“dev”的文件，且文件中包含的是设备号，则mdev就利用这些信息为这个设备在/dev 下创建设备节点文件。一般只在启动时才执行一次 “mdev -s”。

热插拔事件：由于启动时运行了命 令：echo /sbin/mdev > /proc/sys/kernel/hotplug ，那么当有热插拔事件产生时，内核就会调用位于 /sbin目录的mdev。这时mdev通过环境变量中的 ACTION 和 DEVPATH，来确定此次热插拔事件的动作以及影响了/sys中的那个目录。接着会看看这个目录中是否“dev”的属性文件，如果有就利用这些信息为 这个设备在/dev 下创建设备节点文件

重新打包文件系统，这样/sys目录，/dev目录就有东西了  
下面是create\_class的原型：

1.  \#define class\_create(owner, name)       /  
2.  (\{                      /  
3.      **static** **struct** lock\_class\_key \_\_key; /  
4.      \_\_class\_create(owner, name, &\_\_key);    /  
5.  \})  
6.  **extern** **struct** **class** \* \_\_must\_check \_\_class\_create(**struct** module \*owner,  
7.                            **const** **char** \*name,  
8.                            **struct** lock\_class\_key \*key);

class\_destroy的原型如下：  
**extern**   **void**  class\_destroy( **struct**   **class**  \*cls);    
device\_create的原型如下：

1.  **extern** **struct** device \*device\_create(**struct** **class** \*cls, **struct** device \*parent,  
2.                      dev\_t devt, **void** \*drvdata,  
3.                      **const** **char** \*fmt, ...)  
4.                      \_\_attribute\_\_((format(printf, 5, 6)));

device\_destroy的原型如下：  
**extern**   **void**  device\_destroy( **struct**   **class**  \*cls, dev\_t devt);    
具体使用如下，可参考后面的实例：  
static struct class \*firstdrv\_class;

static struct class\_device \*firstdrv\_class\_dev;

firstdrv\_class = class\_create(THIS\_MODULE, "firstdrv");

firstdrv\_class\_dev = class\_device\_create(firstdrv\_class, NULL, MKDEV(major, 0), NULL, "xyz"); /\* /dev/xyz \*/

class\_device\_unregister(firstdrv\_class\_dev);

class\_destroy(firstdrv\_class);

下面再来看一下应用程序如何找到这个结构体的  
在应用程序中我们使用open打开一个设备：如：open(/dev/xxx, O\_RDWR);  
xxx有一个属性，如字符设备为c,后面为读写权限，还有主设备名、次设备名，我们注册时 通过register\_chrdev(0, "first\_drv", &first\_drv\_fops)（有主设备号，设备名，struct file\_operations结构体）将first\_drv\_fops结构体注册到内核数组chrdev中去的，结构体中有open,write函数，那么应用程序如何找到它的，事实上是根据打开的这个文件的属性中的设备类型及主设备号在内核数组chrdev里面找到我们注册的first\_drv\_fops，

实例代码：

\#include <linux/module.h>

\#include <linux/kernel.h>

\#include <linux/fs.h>

\#include <linux/init.h>

\#include <linux/delay.h>

\#include <asm/uaccess.h>

\#include <asm/irq.h>

\#include <asm/io.h>

\#include <asm/arch/regs-gpio.h>

\#include <asm/hardware.h>

static struct class \*firstdrv\_class;

static struct class\_device \*firstdrv\_class\_dev;

volatile unsigned long \*gpfcon = NULL;

volatile unsigned long \*gpfdat = NULL;

static int first\_drv\_open(struct inode \*inode, struct file \*file)

//printk("first\_drv\_open\\n");

/\* 配置GPF4,5,6为输出 \*/

\*gpfcon &= ~((0x3<<(4\*2)) | (0x3<<(5\*2)) | (0x3<<(6\*2)));

\*gpfcon |= ((0x1<<(4\*2)) | (0x1<<(5\*2)) | (0x1<<(6\*2)));

return 0;

static ssize\_t first\_drv\_write(struct file \*file, const char \_\_user \*buf, size\_t count, loff\_t \* ppos)

int val;

//printk("first\_drv\_write\\n");

copy\_from\_user(&val, buf, count); // copy\_to\_user();

if (val == 1)

// 点灯

\*gpfdat &= ~((1<<4) | (1<<5) | (1<<6));

else

// 灭灯

\*gpfdat |= (1<<4) | (1<<5) | (1<<6);

return 0;

static struct file\_operations first\_drv\_fops = \{

.owner  =   THIS\_MODULE,    /\* 这是一个宏，推向编译模块时自动创建的\_\_this\_module变量 \*/

.open   =   first\_drv\_open,

.write  = first\_drv\_write,

\};

int major;

static int first\_drv\_init(void)

major = register\_chrdev(0, "first\_drv", &first\_drv\_fops); // 注册, 告诉内核

firstdrv\_class = class\_create(THIS\_MODULE, "firstdrv");

firstdrv\_class\_dev = class\_device\_create(firstdrv\_class, NULL, MKDEV(major, 0), NULL, "xyz"); /\* /dev/xyz \*/

gpfcon = (volatile unsigned long \*)ioremap(0x56000050, 16);

gpfdat = gpfcon + 1;

return 0;

static void first\_drv\_exit(void)

unregister\_chrdev(major, "first\_drv"); // 卸载

class\_device\_unregister(firstdrv\_class\_dev);

class\_destroy(firstdrv\_class);

iounmap(gpfcon);

module\_init(first\_drv\_init);

module\_exit(first\_drv\_exit);

MODULE\_LICENSE("GPL");  
  
编译用Makefile文件

KERN\_DIR = /work/system/linux-2.6.22.6

all:

make -C $(KERN\_DIR) M=\`pwd\` modules

clean:

make -C $(KERN\_DIR) M=\`pwd\` modules clean

rm -rf modules.order

obj-m \+= first\_drv.o  
  
测试程序：

\#include <sys/types.h>

\#include <sys/stat.h>

\#include <fcntl.h>

\#include <stdio.h>

/\* firstdrvtest on

\* firstdrvtest off

\*/

int main(int argc, char \*\*argv)

int fd;

int val = 1;

fd = open("/dev/xyz", O\_RDWR);

if (fd < 0)

printf("can't open!\\n");

if (argc != 2)

printf("Usage :\\n");

printf("%s <on|off>\\n", argv\[0\]);

return 0;

if (strcmp(argv\[1\], "on") == 0)

val  = 1;

else

val = 0;

write(fd, &val, 4);

return 0;

字符设备驱动程序框架

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 1.字符设备驱动程序概念介绍

相关字符设备驱动程序

相关 LinuxPCI设备驱动程序基本框架

相关简单字符驱动设备

相关 Linux设备驱动程序——驱动程序基本框架

相关 Linux设备驱动程序——字符设备驱动编程

相关字符设备驱动程序框架

相关 Linux字符设备驱动——杂项设备驱动模型

相关 Linux字符设备驱动——Linux2.6标准字符设备驱动模型

相关字符设备驱动——申请设备号、注册字符设备