linux字符设备驱动课程设计报告.docx

linux字符设备驱动课程设计报告

24
2020年4月19日
文档仅供参考

一、 课程设计目的
Linux 系统的开源性使其在嵌入式系统的开发中得到了越来越广泛的应用，但其本身并没有对种类繁多的硬件设备都提供现成的驱动程序，特别是由于工程应用中的灵活性，其驱动程序更是难以统一，这时就需开发一套适合于自己产品的设备驱动。对用户而言，设备驱动程序隐藏了设备的具体细节，对各种不同设备提供了一致的接口，一般来说是把设备映射为一个特殊的设备文件，用户程序能够像对其它文件一样对此设备文件进行操作。
经过这次课程设计能够了解linux的模块机制，懂得如何加载模块和卸载模块，进一步熟悉模块的相关操作。加深对驱动程序定义和设计的了解，了解linux驱动的编写过程，提高自己的动手能力。
二、 课程设计内容与要求
字符设备驱动程序
1、设计目的：掌握设备驱动程序的编写、编译和装载、卸载方法，了解设备文件的创立，并知道如何编写测试程序测试自己的驱动程序是否能够正常工作
2、设计要求：
1) 编写一个简单的字符设备驱动程序，该字符设备包括打开、读、写、I\O控制与释放五个基本操作。
2) 编写一个测试程序，测试字符设备驱动程序的正确性。
3) 要求在实验报告中列出Linux内核的版本与内核模块加载过程。
三、 系统分析与设计
1、系统分析
系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序能够象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:
1、对设备初始化和释放；
2、把数据从内核传送到硬件和从硬件读取数据；
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据；
4、检测和处理设备出现的错误。
字符设备提供给应用程序的是一个流控制接口，主要包括op e n、clo s e（或r ele as e）、r e ad、w r i t e、i o c t l、p o l l和m m a p等。在系统中添加一个字符设备驱动程序，实际上就是给上述操作添加对应的代码。对于字符设备和块设备，L i n u x内核对这些操作进行了统一的抽象，把它们定义在结构体fi le_operations中。
2、系统设计：
2.1、模块设计：

打开设备
读操作
写操作
I/O控制
释放设备
字符设备驱动

2.2数据结构说明
字符设备驱动主要应用了三种数据结构：①file_operations结构，这是设备驱动程序所提供的一组用一个结构向系统进行说明的入口点；②file结构，主要用于与文件系统对应的设备驱动程序。代表一个打开的文件，它由内核在open时创立，并传递给在该文件上进行操作的所有函数，直到碰到最后的close函数。在文件的所有实例都被关闭之后，内核会释放这个数据结构；③ inode结构，提供了关于特殊设备文件/dev/mydev的信息。
各个结构的定义如下：
（1）file_operations结构：
static const struct file_operations my_fops ={
.owner = THIS_MODULE,
.llseek = my_llseek,
.read = my_read,
.write = my_write,
.open = my_open,
.release = my_release,
.unlocked_ioctl = ioctl,
};
（2）file结构：
1）读
static ssize_t my_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
2）写
static ssize_t my_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
3）seek文件定位
static loff_t my_llseek(struct file *filp, loff_t offset, int whence)
4）I\O控制
static int ioctl (struct file *file, unsigned int cmd, unsigned long arg)
（3）inode结构：
1） 打开
int my_open(struct inode *inode, struct file *filp)
2） 释放
int my_release(struct inode *inode, struct file *filp)
2.3、算法流程图：
结束
文件释放函数
ly_release()
设备驱动模块卸载函数
mydev_exit()
开始
设备驱动模块加载函数
ly_init()
文件打开函数
ly_open()
读函数
ly_read()
写函数
ly_write()
Seek文件定位函数
ly_llseek()
I\O控制函数
Ioctl()

四、系统测试与调试分析
4.1 系统测试
4.1.1启动超级管理员模式并输入密码
命令：sudo su
4.1.2对源程序进行编译
命令：make

4.1.3加载驱动程序并查看
命令：insmod lydev.ko和lsmod

4.1.4显示主设备号
命令：cat /proc/devices
4.1.5创立节点并查看
命令：mknod /dev/lydev 55 0和cd /dev

4.1.6编译测试程序
命令：gcc –o t test.c

4.1.7运行测试函数
命令：./t
4.1.8进行打开设备操作
命令：1

4.1.9进行写操作并输入hello
命令：2

4.1.10进行读操作
命令：3

4.1.11进行I/O控制
命令：4

4.1.12进行释放设备操作
命令：5

4.1.13进行退出操作
命令：6
4.1.14卸载驱动程序
命令：rmmod lydev
4.1.15查看日志
命令：dmesg
4.1.16删除节点并查看
命令：rm lydev和ls

4.2调试分析
最开始的时候没有启用sudo模式，导致很多命令不能执行，启用模式的时候需要输入密码，可是输入密码的时候是不显示东西的以为出错，查阅资料之后才知道是应有的现象。
程序测试一遍之后再次测试很多命令不能执行，原因是第一次测试之后产生的各种文件没有删除，再次测试会显示已存在。
有一次测试程序，不能卸载驱动，用lsmod查看有两个进程使用，后来强制关机才能正常使用，原因不明，以后要加强学习。
五、程序清单
1.主程序

#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 <linux/slab.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include "lydev.h"
#define SCULL_IOC_MAGIC 'k'
#define SCULL_IOCRESET _IO(SCULL_IOC_MAGIC, 0)
#define SCULL_IOCSQUANTUM _IOW(SCULL_IOC_MAGIC, 1, int)
#define SCULL_IOCSQSET _IOW(SCULL_IOC_MAGIC, 2, int)
#define SCULL_IOCTQUANTUM _IO(SCULL_IOC_MAGIC, 3)
#define SCULL_IOCTQSET _IO(SCULL_IOC_MAGIC, 4)
#define SCULL_IOCGQUANTUM _IOR(SCULL_IOC_MAGIC, 5, int)
#define SCULL_IOCGQSET _IOR(SCULL_IOC_MAGIC, 6, int)
#define SCULL_IOCQQUANTUM _IO(SCULL_IOC_MAGIC, 7)
#define SCULL_IOCQQSET _IO(SCULL_IOC_MAGIC, 8)
#define SCULL_IOCXQUANTUM _IOWR(SCULL_IOC_MAGIC, 9, int)
#define SCULL_IOCXQSET _IOWR(SCULL_IOC_MAGIC,10, int)
#define SCULL_IOCHQUANTUM _IO(SCULL_IOC_MAGIC, 11)
#define SCULL_IOCHQSET _IO(SCULL_IOC_MAGIC, 12)
#define SCULL_IOC_MAXNR 14
static int ly_major = 55;
module_param(ly_major, int, S_IRUGO);
struct ly_dev *ly_devp; /*设备结构体指针*/
struct cdev cdev;
static int ioctl (struct file *file, unsigned int cmd, unsigned long arg);
/*文件打开函数*/
int ly_open(struct inode *inode, struct file *filp)
{
struct ly_dev *dev;
/*获取次设备号*/
int num = MINOR(inode->i_rdev);
if (num >= MYDEV_NR_DEVS)
return -ENODEV;
dev = &ly_devp[num];
/*将设备描述结构指针赋值给文件私有数据指针*/
filp->private_data = dev;
return 0;
}
/*文件释放函数*/
int ly_release(struct inode *inode, struct file *filp)
{
return 0;
}
/*读函数*/
static ssize_t ly_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 ly_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*判断读位置是否有效*/
if (p >= MYDEV_SIZE)
return 0;
if (count > MYDEV_SIZE - p)
count = MYDEV_SIZE - p;
/*读数据到用户空间*/
if (copy_to_user(buf, (void*)(dev->data + p), count))
{
ret = - EFAULT;
}
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "read %d bytes(s) from %lx\n", count, p);
}
return ret;
}
/*写函数*/
static ssize_t ly_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;
struct ly_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*分析和获取有效的写长度*/
if (p >= MYDEV_SIZE)
return 0;
if (count > MYDEV_SIZE - p)
count = MYDEV_SIZE - p;
/*从用户空间写入数据*/
if (copy_from_user(dev->data + p, buf, count))
ret = - EFAULT;
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "written %d bytes(s) from %lx\n", count, p);
}
return ret;
}
/*I\O控制函数*/
static int ioctl (struct file *file, unsigned int cmd, unsigned long arg)
{
if(_IOC_TYPE(cmd)!=SCULL_IOC_MAGIC)
{
return -EFAULT;
}
if(_IOC_NR(cmd)>SCULL_IOC_MAXNR)
{
return -EFAULT;
}
switch(cmd)
{
case SCULL_IOCRESET:
printk("SCULL_IOCRESET + %lx",arg);
break;
case SCULL_IOCSQUANTUM: /* Set: arg points to the value */
printk("SCULL_IOCSQUANTUM + %lx",arg);
break;
case SCULL_IOCTQUANTUM: /* Tell: arg is the value */
printk("SCULL_IOCTQUANTUM + %lx",arg);
break;

case SCULL_IOCGQUANTUM: /* Get: arg is pointer to result */
printk("SCULL_IOCGQUANTUM + %lx",arg);
break;
case SCULL_IOCQQUANTUM: /* Query: return it (it's positive) */
printk("SCULL_IOCQQUANTUM + %lx",arg);
break;
case SCULL_IOCXQUANTUM: /* eXchange: use arg as pointer */
printk("SCULL_IOCXQUANTUM + %lx",arg);
break;
case SCULL_IOCHQUANTUM: /* sHift: like Tell + Query */
printk("SCULL_IOCHQUANTUM + %lx",arg);
break;
}
return 0;

}
/* seek文件定位函数 */
static loff_t ly_llseek(struct file *filp, loff_t offset, int whence)
{
loff_t newpos;
switch(whence) {
case 0: /* SEEK_SET */
newpos = offset;
break;
case 1: /* SEEK_CUR */
newpos = filp->f_pos + offset;
break;
case 2: /* SEEK_END */
newpos = MYDEV_SIZE -1 + offset;
break;
default: /* can't happen */
return -EINVAL;
}
if ((newpos<0) || (newpos>MYDEV_SIZE))
return -EINVAL;
filp->f_pos = newpos;
return newpos;
}
/*文件操作结构体*/
static const struct file_operations ly_fops =
{
.owner = THIS_MODULE,
.llseek = ly_llseek,
.read = ly_read,
.write = ly_write,
.open = ly_open,
.release = ly_release,
.unlocked_ioctl = ioctl,
};
/*设备驱动模块加载函数*/
static int lydev_init(void)
{
int result;
int i;
dev_t devno = MKDEV(ly_major, 0);
/* 静态申请设备号*/
if (ly_major)
result = register_chrdev_region(devno, 2, "lydev");
else /* 动态分配设备号 */
{
result = alloc_chrdev_region(&devno, 0, 2, "lydev");
ly_major = MAJOR(devno);
}
if (result < 0)
return result;
/*初始化cdev结构*/
cdev_init(&cdev, &ly_fops);
cdev.owner = THIS_MODULE;
cdev.ops = &ly_fops;
/* 注册字符设备 */
cdev_add(&cdev, MKDEV(ly_major, 0), MYDEV_NR_DEVS);

/* 为设备描述结构分配内存*/
ly_devp = kmalloc(MYDEV_NR_DEVS * sizeof(struct ly_dev), GFP_KERNEL);
if (!ly_devp) /*申请失败*/
{
result = - ENOMEM;
goto fail_malloc;
}
memset(ly_devp, 0, sizeof(struct ly_dev));
/*为设备分配内存*/
for (i=0; i < MYDEV_NR_DEVS; i++)
{
ly_devp[i].size = MYDEV_SIZE;
ly_devp[i].data = kmalloc(MYDEV_SIZE, GFP_KERNEL);
memset(ly_devp[i].data, 0, MYDEV_SIZE);
}
printk("模块加载成功！\n");
return 0;
fail_malloc:
unregister_chrdev_region(devno, 1);
return result;
}
/*模块卸载函数*/
static void lydev_exit(void)
{
cdev_del(&cdev); /*注销设备*/
kfree(ly_devp); /*释放设备结构体内存*/ unregister_chrdev_region(MKDEV(ly_major, 0), 2); /*释放设备号*/
printk("模块卸载成功！\n");
}
MODULE_LICENSE("GPL");
module_init(lydev_init);
module_exit(lydev_exit);

2.测试程序

#include <stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<linux/rtc.h>
#include<linux/ioctl.h>
#include <string.h>
#include <stdlib.h>
#define MAXBUF 20
#define SCULL_IOC_MAGIC 'k'
#define SCULL_IOCRESET _IO(SCULL_IOC_MAGIC, 0)
#define SCULL_IOCSQUANTUM _IOW(SCULL_IOC_MAGIC, 1, int)
#define SCULL_IOCSQSET _IOW(SCULL_IOC_MAGIC, 2, int)
#define SCULL_IOCTQUANTUM _IO(SCULL_IOC_MAGIC, 3)
#define SCULL_IOCTQSET _IO(SCULL_IOC_MAGIC, 4)
#define SCULL_IOCGQUANTUM _IOR(SCULL_IOC_MAGIC, 5, int)
#define SCULL_IOCGQSET _IOR(SCULL_IOC_MAGIC, 6, int)
#define SCULL_IOCQQUANTUM _IO(SCULL_IOC_MAGIC, 7)
#define SCULL_IOCQQSET _IO(SCULL_IOC_MAGIC, 8)
#define SCULL_IOCXQUANTUM _IOWR(SCULL_IOC_MAGIC, 9, int)
#define SCULL_IOCXQSET _IOWR(SCULL_IOC_MAGIC,10, int)
#define SCULL_IOCHQUANTUM _IO(SCULL_IOC_MAGIC, 11)
#define SCULL_IOCHQSET _IO(SCULL_IOC_MAGIC, 12)
#define SCULL_IOC_MAXNR 14
int main()
{
int testdev;
int i,flag = 1,t,len = -1;
char sel;
char buf[MAXBUF],tmp[MAXBUF];
printf("1、打开设备\n2、写操作\n3、读操作\n4、I/O控制\n5、释放设备\n6、退出\n");
while(1) {
printf("请输入要执行的操作：");
sel = getchar();
getchar();
switch(sel) {
case '1':testdev = open("/dev/lydev",O_RDWR);
if ( testdev < 0 ) {
printf("设备打开失败 \n");
break;
}
flag = 0;
printf("设备打开成功！\n"
break;
/*case '2':if (flag) {
printf("请先打开设备！\n");
break;
}
printf("请输入写入的字符串:");
gets(tmp);
len = strlen(tmp);
printf("len = %d\n",len);
t = write(testdev,tmp,len);
if (t < 0) {
printf("写操作失败！\n");
break;
}
printf("%s字符串写入成功！\n",tmp);
break;
case '3':if (flag) {
printf("请先打开设备！\n");
break;
}
if (len < 0) {
printf("请先进行写操作！\n");
break;
}
t = read(testdev,buf,len);
if (t < 0) {
printf("读操作失败！\n");
break;
}
printf("读操作成功!结果为:%s\n",buf);
break;*/
case '2':if (flag) {
printf("请先打开设备！\n");
continue;
}
printf("请输入要写入的字符串：");
gets(tmp);
len = sizeof(tmp);//strlen(tmp);
t = write(testdev,tmp,len);
if(t < 0) {
perror("写操作失败！\n");
exit(-1);
}
printf("字符串:%s写入成功！\n",tmp);
break;
case '3':if (flag) {
printf("请先打开设备！\n");
continue;
}
lseek(testdev,0,SEEK_SET);
t = read(testdev,buf,len);
if(t < 0) {
perror("读操作失败！\n");
exit(-1);
}
printf("读操作成功!结果为:%s\n",buf);
break;
case '4':if (flag) {
printf("请先打开设备！\n");
break;
}
t = ioctl(testdev,SCULL_IOCTQUANTUM,3);
if(t < 0) {
printf("IO控制失败\n");
} else {
printf("IO控制成功\n");
}
break;
case '5':if (flag) {
printf("请先打开设备！\n");
break;
}
//release(testdev);
close(testdev);
printf("设备释放成功！\n");
flag = 1;
break;
case '6':close(testdev);
exit(0);
default:printf("输入有误!\n");
break;
}
}
}
六、体会与自我评价
在这次课程设计之前从没有接触过Linux系统，Linux系统这个词作为计算机系的学生都不会陌生，多多少少也知道些它的历史，知道它是开放的免费的操作系统，支持开源软件的开发，可是，Linux系统到底是怎样的一个系统，甚至对它的界面都从未见过。这次课程设计使我接触并了解了Linux系统，见识了它的界面以及种种与Windos系统不同之处，增长了见识。
驱动相较于Linux系统是更加熟悉的一个名词，每次重装系统都要安装各种各样的驱动，不然计算机就不能正常运行，各个硬件就不能发挥作用，经过这次课程设计，对Linux系统的驱动有了比较深入的认识：。Linux下的设备驱动程序分为字符设备驱动、快设备驱动和网络设备驱动程序。驱动程序在硬件和软件之间起纽带的作用，用户进程是经过设备文件来与实际的硬件打交道.每个设备文件都有其文件属性(c/b)，表示是字符设备还块设备。另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备。
这次的课程设计提高了自己的自我学习能力和交流能力，Linux系统是以前学习从未接触到的东西，为了完成设计，需要自己查询各种资料，而且与同学交流学习心得，讨论程序运行的细节，完善自己的程序。
这次课程设计使我反省很多，无论Linux还是驱动程序都是挂在嘴边的东西，可是对于这些自己并没有进行过深入的了解，导致这次课程设计一切都要从头开始，进行的并不顺利，以后对于一些经常提起，在将来有可能用的到的东西要未雨绸缪，先做了解，将来的时候才能轻松应对，事半功倍。
七、参考文献
[1] 汤子瀛 编著，《计算机操作系统（修订版）》，西安电子科技大学出版社，
[2] Alessandro Rubini.Linux设备驱动程序[M].魏永明,耿兵,钟书毅,译.北京:中国电力出版社, .
[3] Sreekrishnan ,《精通Linux设备驱动程序开发》，人民邮电出版社，
[4]Arm Corporation.ARM920T Technical Reference Manual. .
[5] Atmel Corporation.AT91RM9200 datasheet. .