linux 一个简单的字符设备驱动例子

先包含这些头文件
#include linux/module.h>
#include linux/types.h>
#include linux/fs.h>
#include linux/errno.h>
#include linux/mm.h>
#include linux/sched.h>
#include linux/init.h>
#include linux/cdev.h>
#include asm/io.h>
#include asm/system.h>
#include asm/uaccess.h>

#define BUFFERSIZE 200
#define DEVICE_MAJOR 250 /*设置一个主设备号*/

static int device_major = DEVICE_MAJOR;
定义一个与字符设备对应的结构体
struct my_cdev
{
struct cdev cdev; /*cdev结构体，与字符设备对应*/

/*下面可以定义一些与字符设备相关的数据*/
usigned char mem[BUFFERSIZE];
};

struct my_cdev *my_cdevp; /*设备结构体指针*/

int my_cdev_open( struct inode *node, struct file *filp )
{
/*将设备结构体指针赋给文件私有数据指针*/
filp->private_data = my_cdevp /*这样可以通过文件私有数据指针得到设备结构体*/
return 0;
}

int my_cdev_release( struct inode *node, struct file *filp )
{
return 0;
}

static size_t my_cdev_read( struct file *filp, char __user *buf, size_t size, loff_t *ppos )
{
unsigned long p = *ppos; /*文件当前位置*/
unsigned int count = size; /*要读取的长度*/
int ret = 0;

struct my_cdev *dev = filp->private_data; /*通过文件私有数据指针得到设备结构体，和前面的open对应*/

if ( p >= BUFFERSIZE )
return count ? -ENXIO:0;
if ( count > BUFFERSIZE - p )
count = BUFFERSIZE - p;

/*内核空间->用户空间*/
if ( copy_to_user(buf, (void *)(dev->mem + p), count) )
{
ret = -EFAULT;
}
else
{
*ppos += count;
ret = count;
}

return ret;
}

static size_t my_cdev_write( struct file *filp, const char __user *buf, size_t size, loff_t *ppos )
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;

struce my_cdev *dev = filp->private_data;

if( p >= BUFFERSIZE )
return count ? -ENIX : 0;
if (count > BUFFERSIZE - p )
count = BUFFERSIZE - p;

if ( copy_from_user( dev->mem + p, buf, count))
{
ret = -EFAULT;
}
else
{
*ppos += count;
ret = count;
}

return ret
}

static loff_t my_cdev_llseek(struct file *filp, loff_t offset, int orig)
{
loff_t ret = 0;
switch (orig)
{
case 0:
if ( offset 0 )
{
ret = -EINVAL;
break;
}
if (offset > BUFFERSIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = fips->f_pos;
break;
default:
ret = -EINVAL;
break;
}

return ret;
}

/*文件操作结构体*/
static const struct file_operstions my_cdev_fops =
{
.owner = THIS_MODULE,
.open = my_cdev_open,
.release = my_cdev_release,
.read = my_cdev_read,
.write = my_cdev_write,
.llseek = my_cdev_llseek,
};

/*初始化并注册cdev,就是注册我们自己的字符设备*/
static void my_cdev_setup( struct my_cdev *dev, int index )
{
int err;
dev_t devno = MKDEV(DEVICE_MAJOR, index);

cdev_init( dev->cdev, my_cdev_fops );
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = my_cdev_fops; /*我认为在cdev_init里应该做过赋值，应该可以不用写*/
err = cdev_add( dev->cdev, devno, 1 );
if (err)
printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}

static int __init my_cdev_init(void)
{
int result;
dev_t devno = MKDEV(DEVICE_MAJOR, index);

/*申请设备号*/
if ( device_major )
{
result = register_chrdev_region(devno, 1, "my_cdev");
}
else
{
result = alloc_chrdev_region( devno, 0, 1, "my_cdev");
device_major = MAJOR(devno);
}
if ( result 0 )
{
return result;
}

my_cdevp = kmalloc(sizeof(struct my_cdev), GFP_KERNEL);
if ( !my_cdevp )
{
result = -ENOMEM;
goto fail_malloc;
}
memset(my_cdevp, 0, sizeof(struct my_cdev));

my_cdev_setup(my_cdevp, 0);
return 0;

fail_malloc:
unregister_chrdev_region(devno, 1);
return result;
}

static void __exit my_cdev_exit(void)
{
cdev_del(my_cdevp->cdev);
kfree(my_cdevp);
unregister_chrdev_region(MKDEV(device_major, 0), 1);
}

MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");

module_init(my_cdev_init);
module_exit(my_cdev_exit);

*********************************************************************************
然后可以写一个简单的内核模块的Makefile,编译make后生成mycdev.ko文件，insmod mycdev.ko，
装上我们自己的驱动，注意有可能在装的时候提示说device busy什么的，这就是我们前面指定的主设备号现在
有设备在用，我们就在重新指定一个在编译。
那怎么看有那些设备呢？可以用cat /proc/devices,就可以查看已经有哪些主设备号已被占用。

然后就可以自己先创建一个虚拟的字符设备mknod /dev/mycdev c 250 0

******************************************************
下面就可以自己写一个应用程序来看我们自己的字符设备驱动是否OK。

#include stdio.h>
#include fctl.h>
#include string.h>
#include sys/stat.h>

#define BUFFERSIZE 200

int main( void )
{
int fp = 0 ;
char str[BUFFERSIZE];

fp = open( "/dev/mycdev", O_RDWR, S_IRUSR|S_IWUSR );
if ( !fp )
{
printf("Open device failedn");
return -1;
}

write( fp, "Hello, my devices", strlen("Hello, my devices") );

lseek( fp, 0, 0 );/*修改字符设备里字符数组的位置，将字符数据位置设到开始的位置，不然下面的read操作将读不到数据*/

read( fp, str, BUFFERSIZE );

printf("Read content: %sn", str );

close(fp);
}

gcc -o sample sample.c

最后运行./sample

应该会输出：Read content: Hello, my devices

总结一下，我个人觉得字符设备驱动相关的API和数据结构。
1. struct cdev 一个设备对应一个这个的数据结构，结构体是重要的两个字段ops 和dev(设备号)
2. struct file_opertions 文件操作结构体
3. cdev_init(struct cdev *, struct file_opertions *) 主要就是把字符设备和对这个设备的文件操作结构体对应起来
4. cdev_add(struct cdev *, dev_t, unsigned) 注册设备
5. register_chrdev_region(dev_t, unsigned, const char *name)/alloc_chrdev_region() 申请设备号，为注册设备（cdev_add()）准备
6. 就是内核空间的数据和用户空间的数据交换

本文有粤嵌教育（www.gec-edu.org）嵌入式培训机构提供。