如何写字符设备驱动程序
1. 字符型设备驱动如何编译
字符设备驱动程序框架
1、写出open、write函数
2、告诉内核
1）、定义一个struct file_operations结构并填充好
static struct file_operations first_drv_fops = {
.owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_mole变量 */
.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）、入口函数须使用内核宏来修饰
mole_init(first_drv_init);
mole_init会定义一个结构体，这个结构体里面有一个函数指针指向first_drv_init这个函数，当我们加载或安装一个驱动时，内核会自动找到这个结构体，然后调用里面的函数指针，这个函数指针指向first_drv_init这个函数，first_drv_init这个函数就是把struct file_operations结构体告诉内核
6）、有入口函数就有出口函数
mole_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 mole *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_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
#include
#include
#include
#include
#include
#include
#include
#include
#include
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");
_from_user(&val, buf, count); // _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_mole变量 */
.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);
}
mole_init(first_drv_init);
mole_exit(first_drv_exit);
MODULE_LICENSE("GPL");
编译用Makefile文件
KERN_DIR = /work/system/linux-2.6.22.6
all:
make -C $(KERN_DIR) M=`pwd` moles
clean:
make -C $(KERN_DIR) M=`pwd` moles clean
rm -rf moles.order
obj-m += first_drv.o
测试程序：
#include
#include
#include
#include
/* 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 \n", argv[0]);
return 0;
}
if (strcmp(argv[1], "on") == 0)
{
val = 1;
}
else
{
val = 0;
}
write(fd, &val, 4);
return 0;
}
2. linux字符设备驱动程序怎么写
这是linux的设备驱动开发，最好是自己找一些linux驱动开发的专业资料来学习一下。不是一句两句就说明白的。
3. 怎么正确的注册字符设备的驱动程序
下载 virtualbox 下载一个 linux iso
用virtualbox 建立虚拟系统 配置好 加载iso 启动安装
VMware安装完毕后，利用它可以专建属立多个虚拟机，每新建一个虚拟机，就会要求你建立一个配置文件。这个配置文件实际上相当于新电脑的“硬件配置”，你可以在配置文件中决定虚拟机的硬盘如何配置，内存多大．准备运行哪种操作系统，是否有网络等。配置Linux虚拟机的步骤如下。
(1)选择File菜单下的“New Virtual Machine”出现新虚拟机向导后单击“下一步”，选择“Typical”典型安装。
(2)再单击“下一步”，在选择操作系统界面的“Guest Operation System”中选择 “Linux”，然后单击Version对应的下拉菜单选择具体的Linux版本， 此处我们选择“Red Hat LinuX”。
4. 编写一个简单的字符设备驱动程序。要求该字符设备包括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；
}
_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；
_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
5. 如何写一个简单的字符设备驱动
下载 virtualbox 下载一个 linux iso
用virtualbox 建立虚拟系统 配置好 加载iso 启动安装
VMware安装完毕后，利用它可内以建立多个容虚拟机，每新建一个虚拟机，就会要求你建立一个配置文件。这个配置文件实际上相当于新电脑的“硬件配置”，你可以在配置文件中决定虚拟机的硬盘如何配置，内存多大．准备运行哪种操作系统，是否有网络等。配置Linux虚拟机的步骤如下。
(1)选择File菜单下的“New Virtual Machine”出现新虚拟机向导后单击“下一步”，选择“Typical”典型安装。
(2)再单击“下一步”，在选择操作系统界面的“Guest Operation System”中选择 “Linux”，然后单击Version对应的下拉菜单选择具体的Linux版本， 此处我们选择“Red Hat LinuX”。
6. 如何编写一个简单的linux内核模块和设备驱动程序
如何编写Linux设备驱动程序
回想学习Linux操作系统已经有近一年的时间了，前前后后，零零碎碎的一路学习过来，也该试着写的东西了。也算是给自己能留下一点记忆和回忆吧！由于完全是自学的，以下内容若有不当之处，还请大家多指教。
Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。
以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux a-z，还有清华bbs上的有关device driver的一些资料。
一、Linux device driver 的概念
系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:
1、对设备初始化和释放。
2、把数据从内核传送到硬件和从硬件读取数据。
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据。
4、检测和处理设备出现的错误。
在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。
已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。
最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。
读/写时，它首先察看缓冲区的内容，如果缓冲区的数据未被处理，则先处理其中的内容。
如何编写Linux操作系统下的设备驱动程序
二、实例剖析
我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。
#define __NO_VERSION__
#include <linux/moles.h>
#include <linux/version.h>
char kernel_version [] = UTS_RELEASE;
这一段定义了一些版本信息，虽然用处不是很大，但也必不可少。Johnsonm说所有的驱动程序的开头都要包含<linux/config.h>，一般来讲最好使用。
由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：
struct file_operations
{
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}
这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。
下面就开始写子程序。
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include<linux/config.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *node，struct file *file，char *buf，int count)
{
int left;
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}
这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf 是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考robert著的《Linux内核设计与实现》（第二版）。然而，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。
static int write_tibet(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_tibet(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT;
return 0;
}
static void release_tibet(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}
这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。
struct file_operations test_fops = {
NULL，
read_test，
write_test，
NULL， /* test_readdir */
NULL，
NULL， /* test_ioctl */
NULL， /* test_mmap */
open_test，
release_test，
NULL， /* test_fsync */
NULL， /* test_fasync */
/* nothing more， fill with NULLs */
};
这样，设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(moles)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops);
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}
在用insmod命令将编译好的模块调入内存时，init_mole 函数被调用。在这里，init_mole只做了一件事，就是向系统的字符设备表登记了一个字符设备。register_chrdev需要三个参数，参数一是希望获得的设备号，如果是零的话，系统将选择一个没有被占用的设备号返回。参数二是设备文件名，参数三用来登记驱动程序实际执行操作的函数的指针。
如果登记成功，返回设备的主设备号，不成功，返回一个负值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸载模块时，cleanup_mole函数被调用，它释放字符设备test在系统字符设备表中占有的表项。
一个极其简单的字符设备可以说写好了，文件名就叫test.c吧。
下面编译 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c
得到文件test.o就是一个设备驱动程序。
如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后
ld -r file1.o file2.o -o molename。
驱动程序已经编译好了，现在把它安装到系统中去。
$ insmod –f test.o
如果安装成功，在/proc/devices文件中就可以看到设备test，并可以看到它的主设备号。要卸载的话，运行 :
$ rmmod test
下一步要创建设备文件。
mknod /dev/test c major minor
c 是指字符设备，major是主设备号，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以获得主设备号，可以把上面的命令行加入你的shell script中去。
minor是从设备号，设置成0就可以了。
我们现在可以通过设备文件来访问我们的驱动程序。写一个小小的测试程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}
编译运行，看看是不是打印出全1 ？
以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，dma，I/O port等问题。这些才是真正的难点。请看下节，实际情况的处理。
如何编写Linux操作系统下的设备驱动程序
三、设备驱动程序中的一些具体问题
1。 I/O Port。
和硬件打交道离不开I/O Port，老的isa设备经常是占用实际的I/O端口，在linux下，操作系统没有对I/O口屏蔽，也就是说，任何驱动程序都可对任意的I/O口操作，这样就很容易引起混乱。每个驱动程序应该自己避免误用端口。
有两个重要的kernel函数可以保证驱动程序做到这一点。
1）check_region(int io_port， int off_set)
这个函数察看系统的I/O表，看是否有别的驱动程序占用某一段I/O口。
参数1：I/O端口的基地址，
参数2：I/O端口占用的范围。
返回值：0 没有占用， 非0，已经被占用。
2）request_region(int io_port， int off_set，char *devname)
如果这段I/O端口没有被占用，在我们的驱动程序中就可以使用它。在使用之前，必须向系统登记，以防止被其他程序占用。登记后，在/proc/ioports文件中可以看到你登记的I/O口。
参数1：io端口的基地址。
参数2：io端口占用的范围。
参数3：使用这段io地址的设备名。
在对I/O口登记后，就可以放心地用inb()， outb()之类的函来访问了。
在一些pci设备中，I/O端口被映射到一段内存中去，要访问这些端口就相当于访问一段内存。经常性的，我们要获得一块内存的物理地址。
2。内存操作
在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages。 请注意，kmalloc等函数返回的是物理地址！
注意，kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。
内存映射的I/O口，寄存器或者是硬件设备的ram(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址。
另外，很多硬件需要一块比较大的连续内存用作dma传送。这块程序需要一直驻留在内存，不能被交换到文件中去。但是kmalloc最多只能开辟128k的内存。
这可以通过牺牲一些系统内存的方法来解决。
3。中断处理
同处理I/O端口一样，要使用一个中断，必须先向系统登记。
int request_irq(unsigned int irq ，void(*handle)(int，void *，struct pt_regs *)，
unsigned int long flags， const char *device);
irq: 是要申请的中断。
handle：中断处理函数指针。
flags：SA_INTERRUPT 请求一个快速中断，0 正常中断。
device：设备名。
如果登记成功，返回0，这时在/proc/interrupts文件中可以看你请求的中断。
4。一些常见的问题。
对硬件操作，有时时序很重要（关于时序的具体问题就要参考具体的设备芯片手册啦！比如网卡芯片RTL8139）。但是如果用C语言写一些低级的硬件操作的话，gcc往往会对你的程序进行优化，这样时序会发生错误。如果用汇编写呢，gcc同样会对汇编代码进行优化，除非用volatile关键字修饰。最保险的办法是禁止优化。这当然只能对一部分你自己编写的代码。如果对所有的代码都不优化，你会发现驱动程序根本无法装载。这是因为在编译驱动程序时要用到gcc的一些扩展特性，而这些扩展特性必须在加了优化选项之后才能体现出来。
写在后面：学习Linux确实不是一件容易的事情，因为要付出很多精力，也必须具备很好的C语言基础；但是，学习Linux也是一件非常有趣的事情，它里面包含了许多高手的智慧和“幽默”，这些都需要自己亲自动手才能体会到，O(∩_∩)O~哈哈！
7. 如何编写驱动程序
代码：
#include<linux/mole.h>
#include<linux/kernel.h>
#include<asm/io.h>
#include<linux/miscdevice.h>
#include<linux/fs.h>
#include<asm/uaccess.h>
//流水灯代码
#define GPM4CON 0x110002e0
#define GPM4DAT 0x110002e4
static unsigned long*ledcon=NULL;
static unsigned long*leddat=NULL;
//自定义write文件操作(不自定义的话，内核有默认的一套文件操作函数)
static ssize_t test_write(struct file*filp,const char __user*buff,size_t count,loff_t*offset)
{
int value=0;
int ret=0;
ret=_from_user(&value,buff,4);
//底层驱动只定义基本操作动作，不定义功能
if(value==1)
{
*leddat|=0x0f;
*leddat&=0xfe;
}
if(value==2)
{
*leddat|=0x0f;
*leddat&=0xfd;
}
if(value==3)
{
*leddat|=0x0f;
*leddat&=0xfb;
}
if(value==4)
{
*leddat|=0x0f;
*leddat&=0xf7;
}
return 0;
}
//文件操作结构体初始化
static struct file_operations g_tfops={
.owner=THIS_MODULE,
.write=test_write,
};
//杂设备信息结构体初始化
static struct miscdevice g_tmisc={
.minor=MISC_DYNAMIC_MINOR,
.name="test_led",
.fops=&g_tfops,
};
//驱动入口函数杂设备初始化
static int __init test_misc_init(void)
{
//IO地址空间映射到内核的虚拟地址空间
ledcon=ioremap(GPM4CON,4);
leddat=ioremap(GPM4DAT,4);
//初始化led
*ledcon&=0xffff0000;
*ledcon|=0x00001111;
*leddat|=0x0f;
//杂设备注册函数
misc_register(&g_tmisc);
return 0;
}
//驱动出口函数
static void __exit test_misc_exit(void)
{
//释放地址映射
iounmap(ledcon);
iounmap(leddat);
}
//指定模块的出入口函数
mole_init(test_misc_init);
mole_exit(test_misc_exit);
MODULE_LICENSE("GPL");
(7)如何写字符设备驱动程序扩展阅读：
include用法：
#include命令预处理命令的一种，预处理命令可以将别的源代码内容插入到所指定的位置；可以标识出只有在特定条件下才会被编译的某一段程序代码；可以定义类似标识符功能的宏，在编译时，预处理器会用别的文本取代该宏。
插入头文件的内容
#include命令告诉预处理器将指定头文件的内容插入到预处理器命令的相应位置。有两种方式可以指定插入头文件：
1、#include<文件名>
2、#include"文件名"
如果需要包含标准库头文件或者实现版本所提供的头文件，应该使用第一种格式。如下例所示：
#include<math.h>//一些数学函数的原型，以及相关的类型和宏
如果需要包含针对程序所开发的源文件，则应该使用第二种格式。
采用#include命令所插入的文件，通常文件扩展名是.h，文件包括函数原型、宏定义和类型定义。只要使用#include命令，这些定义就可被任何源文件使用。如下例所示：
#include"myproject.h"//用在当前项目中的函数原型、类型定义和宏
你可以在#include命令中使用宏。如果使用宏，该宏的取代结果必须确保生成正确的#include命令。例1展示了这样的#include命令。
【例1】在#include命令中的宏
#ifdef _DEBUG_
#define MY_HEADER"myProject_dbg.h"
#else
#define MY_HEADER"myProject.h"
#endif
#include MY_HEADER
当上述程序代码进入预处理时，如果_DEBUG_宏已被定义，那么预处理器会插入myProject_dbg.h的内容；如果还没定义，则插入myProject.h的内容。
8. 如何描述linux 字符设备驱动程序的框架
一、Linux device driver 的概念系统调用是操作系统内核和应用程序之间的接口,设备驱动程序是操作系统内核和机器硬件之间的接口.设备驱动程序为应用程序屏蔽了硬件的细节,这样在应用程序看来,硬件设备只是一个设备文件,应用程序可以象操作普通文件一样对硬件设备进行操作.设备驱动程序是内核的一部分,它完成以下的功能:
1、对设备初始化和释放；
2、把数据从内核传送到硬件和从硬件读取数据；
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据；
4、检测和处理设备出现的错误.
在Linux操作系统下有三类主要的设备文件类型,一是字符设备,二是块设备,三是网络设备.字符设备和块设备的主要区别是:在对字符设备发出读/写请求时,实际的硬件I/O一般就紧接着发生了,块设备则不然,它利用一块系统内存作缓冲区,当用户进程对设备请求能满足用户的要求,就返回请求的数据,如果不能,就调用请求函数来进行实际的I/O操作.块设备是主要针对磁盘等慢速设备设计的,以免耗费过多的CPU时间来等待.
已经提到,用户进程是通过设备文件来与实际的硬件打交道.每个设备文件都都有其文件属性(c/b),表示是字符设备还是块设备?另外每个文件都有两个设备号,第一个是主设备号,标识驱动程序,第二个是从设备号,标识使用同一个设备驱动程序的不同的硬件设备,比如有两个软盘,就可以用从设备号来区分他们.设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致,否则用户进程将无法访问到驱动程序.
最后必须提到的是,在用户进程调用驱动程序时,系统进入核心态,这时不再是抢先式调度.也就是说,系统必须在你的驱动程序的子函数返回后才能进行其他的工作.如果你的驱动程序陷入死循环,不幸的是你只有重新启动机器了,然后就是漫长的fsck.
二、实例剖析
我们来写一个最简单的字符设备驱动程序.虽然它什么也不做,但是通过它可以了解Linux的设备驱动程序的工作原理.把下面的C代码输入机器,你就会获得一个真正的设备驱动程序.
由于用户进程是通过设备文件同硬件打交道,对设备文件的操作方式不外乎就是一些系统调用,如 open,read,write,close…, 注意,不是fopen, fread,但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：
STruct file_operatiONs {
int (*seek) (struct inode * ,struct file *, off_t ,int);
int (*read) (struct inode * ,struct file *, char ,int);
int (*write) (struct inode * ,struct file *, off_t ,int);
int (*readdir) (struct inode * ,struct file *, struct dirent * ,int);
int (*select) (struct inode * ,struct file *, int ,select_table *);
int (*ioctl) (struct inode * ,struct file *, unsined int ,unsigned long);
int (*mmap) (struct inode * ,struct file *, struct vm_area_struct *);
int (*open) (struct inode * ,struct file *);
int (*release) (struct inode * ,struct file *);
int (*fsync) (struct inode * ,struct file *);
int (*fasync) (struct inode * ,struct file *,int);
int (*check_media_change) (struct inode * ,struct file *);
int (*revalidate) (dev_t dev);
}
这个结构的每一个成员的名字都对应着一个系统调用.用户进程利用系统调用在对设备文件进行诸如read/write操作时,系统调用通过设备文件的主设备号找到相应的设备驱动程序,然后读取这个数据结构相应的函数指针,接着把控制权交给该函数.这是linux的设备驱动程序工作的基本原理.既然是这样,则编写设备驱动程序的主要工作就是编写子函数,并填充file_operations的各个域.
下面就开始写子程序.
#include
9. 如何写一个字符驱动
file_operations结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。
2.简单驱动程序的编写：
(1)包含一些基本的头文件。
(2)编写一些功能函数，比如read()，write()等。这些函数被调用时系统进入核心态。
(3)定义struct file_operations结构的对象，填充结构体。结构体中功能的顺序不能改变，若一些功能没有实现就用NULL填充，已经实现的功能如read()、write()分别添加到对应的位置。这步实现的是函数的注册。到这里驱动程序的主体可以说是写好了。现在需要把驱动程序嵌入内核。
(4)注册设备驱动程序，使用register_chrdev注册字符型设备。函数原型为：int register_chrdev(0, "test_name", &test_file_operations)函数返回主设备号，若注册成功返回值大于0。第一个参数：主设备号。第二个参数：注册的设备名。第三个参数：结构体名（设备相关操作方式，驱动程序实际执行操作的函数的指针）。这个函数由int init_mole(void)函数调用，这个函数在系统启动时注册到内核时调用。
(5)在用rmmod卸载模块时，cleanup_mole函数被调用，执行unregister_chrdev()释放字符设备在系统字符设备表中占有的表项，到这里基本就编写完成了。一个简单的字符设备可以说写好了。
3.编译$ gcc -O2 -DMODULE -D__KERNEL__ -c test.o test.c
得到文件test.o就是一个设备驱动程序。
如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后
ld -r file1.o file2.o -o molename
驱动程序已经编译好了，现在把它安装到系统中去。
$ insmod -f test.o
安装成功在/proc/devices文件中就可以看到设备test，并可以看到主设备号。要卸载运行：
$ rmmod test
4.创建设备节点