编写一个简单的字符设备驱动程序。要求该字符设备包括scull_open() scull_write() scull_read() scull_i

第一部分 字符设备驱动程序

1.1 函数scull_open()

int scull_open(struct inode *inode，struct file *filp) {

MOD_INC_USE_COUNT； // 增加该模块的用户数目

printk(“This chrdev is in open\n”)；

return 0；

}

1.2 函数scull_write()

int scull_write(struct inode *inode，struct file *filp，const char *buffer，int count) {

if(count <0)

return –EINVAL；

if(scull.usage || scull.new_msg)

return –EBUSY；

scull.usage = 1；

kfree(scull.data)；

data = kmalloc(sizeof(char)*(count+1)，GFP_KERNEL)；

if(!scull.data) {

return –ENOMEM；

}

copy_from_user(scull.data，buffer，count + 1)；

scull.usage = 0；

scull.new_msg = 1；

return count；

}

1.3 函数scull_read()

int scull_read(struct inode *inode，struct file *filp，char *buffer，int count) {

int length；

if(count <0)

return –EINVAL；

if(scull.usage)

return –EBUSY；

scull.usage = 1；

if(scull.data == 0)

return 0；

length = strlen(scull.data)；

if(length <count)

count = length；

copy_to_user(buf，scull.data，count + 1)；

scull.new_msg = 0；

scull.usage = 0；

return count；

}

1.4 函数scull_ioctl()

#include <linux/ioctl.h>

#define SCULL_MAJOR 0

#define SCULL_MAGIC SCULL_MAJOR

#define SCULL_RESET _IO(SCULL_MAGIC，0) // reset the data

#define SCULL_QUERY_NEW_MSG _IO(SCULL_MAGIC,1) // check for new message

#define SCULL_QUERY_MSG_LENGTH _IO(SCULL_MAGIC,2) //get message length

#define IOC_NEW_MSG 1

static int usage，new_msg； // control flags

static char *data；

int scull_ioctl(struct inode *inode，struct file *filp，unsigned long int cmd，unsigned long arg) {

int ret=0；

switch(cmd) {

case SCULL_RESET:

kfree(data)；

data = NULL；

usage = 0；

new_msg = 0；

break；

case SCULL_QUERY_NEW_MSG:

if(new_msg)

return IOC_NEW_MSG；

break；

case SCULL_QUERY_MSG_LENGTH:

if(data == NULL){

return 0；

}

else {

return strlen(data)；

}

break；

default:

return –ENOTTY；

}

return ret；

}

1.5 函数scull_release()

void scull_release(struct inode *inode，struct file *filp) {

MOD_DEC_USE_COUNT； // 该模块的用户数目减1

printk(“This chrdev is in release\n”)；

return 0；

#ifdef DEBUG

printk(“scull_release(%p,%p)\n”，inode，filp)；

#endif

}

1.6 测试函数

在该字符设备驱动程序编译加载后，再在/dev目录下创建字符设备文件chrdev，使用命令: #mknod /dev/chrdev c major minor ，其中“c”表示chrdev是字符设备，“major”是chrdev的主设备号。（该字符设备驱动程序编译加载后，可在/proc/devices文件中获得主设备号，或者使用命令: #cat /proc/devices | awk ”\\$2==”chrdev\”{ print\\$1}” 获得主设备号）

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/ioctl.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <unistd.h>

#include <errno.h>

#include “chardev.h”// 见后面定义

void write_proc(void)；

void read_proc(void)；

main(int argc，char **argv) {

if(argc == 1) {

puts(“syntax: testprog[write|read]\n”)；

exit(0)；

}

if(!strcmp(argv[1],“write”)) {

write_porc()；

}

else if(!strcmp(argv[1]，“read”)) {

read_proc()；

}

else {

puts(“testprog: invalid command!\n”)；

}

return 0；

}

void write_proc() {

int fd，len，quit = 0；

char buf[100]；

fd = open(“/dev/chrdev”,O_WRONLY)；

if(fd <= 0) {

printf(“Error opening device for writing!\n”)；

exit(1)；

}

while(!quit) {

printf(“\n Please write into：”)；

gets(buf)；

if(!strcmp(buf，“exit”))

quit = 1；

while(ioctl(fd，DYNCHAR_QUERY_NEW_MSG))

usleep(100)；

len = write(fd，buf，strlen(buf))；

if(len <0) {

printf(“Error writing to device!\n”)；

close(fd)；

exit(1)；

}

printf(“\n There are %d bytes written to device!\n”，len)；

}

close(fd)；

}

void read_proc() {

int fd，len，quit = 0；

char *buf = NULL；

fd=open(“/dev/chrdev”，O_RDONLY)；

if(fd <0) {

printf(“Error opening device for reading!\n”)；

exit(1)；

}

while(!quit) {

printf(“\n Please read out：”)；

while(!ioctl(fd，DYNCHAR_QUERY_NEW_MSG))

usleep(100)；

// get the msg length

len = ioctl(fd，DYNCHAR_QUERY_MSG_LENGTH，NULL)；

if(len) {

if(buf != NULL)

free(buf)；

buf = malloc(sizeof(char)*(len+1))；

len = read(fd，buf，len)；

if(len <0) {

printf(“Error reading from device!\n”)；

}

else {

if(!strcmp(buf，“exit”) {

ioctl(fd，DYNCHAR_RESET)； // reset

quit = 1；

}

else

printf(“%s\n”,buf)；

}

}

}

free(buf)；

close(fd)；

}

// 以下为chrdev.h定义

#ifndef _DYNCHAR_DEVICE_H

#define _DYNCHAR_DEVICE_H

#include <linux/ioctl.h>

#define DYNCHAR_MAJOR 42

#define DYNCHAR_MAGIC DYNCHAR_MAJOR

#define DYNCHAR_RESET _IO(DYNCHAR_MAGIC,0) // reset the data

#define DYNCHAR_QUERY_NEW_MSG _IO(DYNCHAR_MAGIC,1) // check for new message

#define DYNCHAR_QUERY_MSG_LENGTH _IO(DYNCHAR_MAGIC,2) // get message length

#define IOC_NEW_MSG 1

#endif

字符设备驱动程序框架 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的原型： #define class_create(owner, name) / ({ / static struct lock_class_key __key/ __class_create(owner, name, &__key)/ }) extern struct class * __must_check __class_create(struct module *owner, const char *name, struct lock_class_key *key)class_destroy的原型如下： extern void class_destroy(struct class *cls)device_create的原型如下： extern struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...) __attribute__((format(printf, 5, 6)))device_destroy的原型如下： extern void device_destroy(struct class *cls, dev_t devt)具体使用如下，可参考后面的实例： static struct class *firstdrv_classstatic struct class_device *firstdrv_class_devfirstdrv_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 #include #include #include #include #include #include #include #include #include static struct class *firstdrv_classstatic struct class_device *firstdrv_class_devvolatile unsigned long *gpfcon = NULLvolatile unsigned long *gpfdat = NULLstatic 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 majorstatic 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 + 1return 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 #include #include #include /* firstdrvtest on * firstdrvtest off */ int main(int argc, char **argv) { int fdint val = 1fd = open("/dev/xyz", O_RDWR)if (fd <0) { printf("can't open!\n")} if (argc != 2) { printf("Usage :\n")printf("%s \n", argv[0])return 0} if (strcmp(argv[1], "on") == 0) { val = 1} else { val = 0} write(fd, &val, 4)return 0}

---