2018-2019-1 20165223-20165218 实验四外设驱动程序设计

最新推荐文章于 2021-05-05 06:27:23 发布

weixin_30807779

最新推荐文章于 2021-05-05 06:27:23 发布

阅读量192

点赞数

文章标签：操作系统嵌入式驱动开发

原文链接：http://www.cnblogs.com/moddy13162201/p/10050285.html

版权

实验成员：20165223 20165218

实验名称：外设驱动程序设计

目录

一、实验目的

二、实验内容

任务一：用康奈尔笔记法学习嵌入式Linux设备驱动开发课程
任务二：在Ubuntu中动手完成教程中的test实验

一、实验目的

（1）学习并掌握康奈尔笔记法，能有效提高自学的效率

（2）自主学习嵌入式Linux设备驱动开发课程，熟悉环境并掌握以下内容

Linux设备驱动的基本概念
Linux设备驱动程序的基本功能
Linux设备驱动的运作过程
常见设备驱动接口函数
掌握LCD设备驱动程序编写步骤
掌握键盘设备驱动程序编写步骤

（3）完成教材最后的test实验

二、实验内容

任务一：用康奈尔笔记法学习嵌入式Linux设备驱动开发课程

（一）实验要求

1．学习资源中全课中的“hqyj.嵌入式Linux应用程序开发标准教程.pdf”中的第十一章
2．提交康奈尔笔记的照片（可以多张）
3．参考资料：hqyj.嵌入式Linux应用程序开发标准教程.pdf

（二）康奈尔截图

返回目录

任务二：在Ubuntu中动手完成教程中的test实验

（一）实验要求

1．在Ubuntu完成资源中全课中的“hqyj.嵌入式Linux应用程序开发标准教程.pdf”中的第十一章的test实验
2．提交编译，加载模块，卸载模块，测试运行的截图（要多张，全屏，体现学号信息）
3．参考资料：hqyj.嵌入式Linux应用程序开发标准教程.pdf

（二）实验步骤

（1）test实验的目的与内容

实验目的
该实验是编写最简单的字符驱动程序，这里的设备也就是一段内存，实现简单的读写功能，并列出常用格式的Makefile 以及驱动的加载和加载脚本。读者可以熟悉字符设备驱动的整个编写流程。
实验内容
该实验要求实现对虚拟设备（一段内存）的打开、关闭、读写的操作，并要通过编写测试程序来测试虚拟设备及其驱动运行是否正常。

（2）编写实验代码

完整代码：码云代码：实验四外设驱动程序设计

1. 编写源代码

驱动程序的源代码

//test_drv.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#define TEST_DEVICE_NAME "test_dev"
#define BUFF_SZ 1024
/*全局变量*/
static struct cdev test_dev;
unsigned int major =0;
static char *data = NULL;
/*读函数*/
static ssize_t test_read(struct file *file,
char *buf, size_t count, loff_t *f_pos)
{
    int len;
    if (count < 0 )
    {
        return -EINVAL;
    }
    len = strlen(data);
    count = (len > count)?count:len;
    if (copy_to_user(buf, data, count))
    {
        return -EFAULT;
    }
    return count;
}
/*写函数*/
static ssize_t test_write(struct file *file, const char *buffer,
size_t count, loff_t *f_pos)
{
    if(count < 0)
    {
        return -EINVAL;
    }
    memset(data, 0, BUFF_SZ);
    count = (BUFF_SZ > count)?count:BUFF_SZ;
    if (copy_from_user(data, buffer, count)) /* 将用户缓冲的数据复制到内核空间*/
    {
        return -EFAULT;
    }
    return count;
}
/*打开函数*/
static int test_open(struct inode *inode, struct file *file)
{
    printk("This is open operation\n");
    /* 分配并初始化缓冲区*/
    data = (char*)kmalloc(sizeof(char) * BUFF_SZ, GFP_KERNEL);
    if (!data)
    {
        return -ENOMEM;
    }
    memset(data, 0, BUFF_SZ);
    return 0;
}
/*关闭函数*/
static int test_release(struct inode *inode,struct file *file)
{
    printk("This is release operation\n");
    if (data)
    {
        kfree(data); /* 释放缓冲区*/
        data = NULL; /* 防止出现野指针*/
    }
    return 0;
}
/* 创建、初始化字符设备，并且注册到系统*/
static void test_setup_cdev(struct cdev *dev, int minor,
struct file_operations *fops)
{
    int err, devno = MKDEV(major, minor);
    cdev_init(dev, fops);
    dev->owner = THIS_MODULE;
    dev->ops = fops;
    err = cdev_add (dev, devno, 1);
    if (err)
    {
        printk (KERN_NOTICE "Error %d adding test %d", err, minor);
    }
}
/* 虚拟设备的 file_operations 结构 */
static struct file_operations test_fops =
{
    .owner = THIS_MODULE,
    .read = test_read,
    .write = test_write,
    .open = test_open,
    .release = test_release,
};
/*模块注册入口*/
int init_module(void)
{
    int result;
    dev_t dev = MKDEV(major, 0);
    if (major)
    {
    /* 静态注册一个设备，设备号先前指定好，并设定设备名，用cat /proc/devices 来查看 */
        result = register_chrdev_region(dev, 1, TEST_DEVICE_NAME);
    }
    else
    {
        result = alloc_chrdev_region(&dev, 0, 1, TEST_DEVICE_NAME);
    }
    if (result < 0)
    {
        printk(KERN_WARNING "Test device: unable to get major %d\n", major);
        return result;
    }
    test_setup_cdev(&test_dev, 0, &test_fops);
    printk("The major of the test device is %d\n", major);
    return 0;
}
/*卸载模块*/
void cleanup_module(void)
{
    cdev_del(&test_dev);
    unregister_chrdev_region(MKDEV(major, 0), 1);
    printk("Test device uninstalled\n");
}

2. 编写编译代码

虚拟设备的驱动程序

//Makefile

ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
modules_install:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
.PHONY: modules modules_install clean
else
    obj-m := test_drv.o
endif

加载模块脚本

//test_drv_load

#!/bin/sh
# 驱动模块名称
module="test_drv"
# 设备名称。在/proc/devices 中出现
device="test_dev"
# 设备文件的输性
mode="664"
group="david"
# 删除已存在的设备节点
rm -f /dev/${device}
# 加载驱动模块
/sbin/insmod -f ./$module.ko $* || exit 1
# 查到设备的主设备号
major=`cat /proc/devices | awk "\\$2==\"$device\" {print \\$1}"`
# 创建设备文件节点
mknod /dev/${device} c $major 0
# 设置设备文件属性
chgrp $group /dev/${device}
chmod $mode /dev/${device}

卸载模块脚本

//test_drv_unload

#!/bin/sh
module="test_drv"
device="test_dev"
# 卸载驱动模块
/sbin/rmmod $module $* || exit 1
# 删除设备文件
rm -f /dev/${device}
exit 0

3. 编写测试代码

测试代码

//test.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#define TEST_DEVICE_FILENAME "/dev/test_dev" /* 设备文件名*/
#define BUFF_SZ 1024 /* 缓冲大小 */
int main()
{
    int fd, nwrite, nread;
    char buff[BUFF_SZ]; /*缓冲区*/
    /* 打开设备文件 */
    fd = open(TEST_DEVICE_FILENAME, O_RDWR);
    if (fd < 0)
    {
        perror("open");
        exit(1);
    }
    do
    {
        printf("Input some words to kernel:");
        memset(buff, 0, BUFF_SZ);
        if (fgets(buff, BUFF_SZ, stdin) == NULL)
        {
            perror("fgets");
            break;
        }
        buff[strlen(buff) - 1] = '\0';
        if (write(fd, buff, strlen(buff)) < 0) /* 向设备写入数据 */
        {
            perror("write");
            break;
        }
        if (read(fd, buff, BUFF_SZ) < 0) /* 从设备读取数据 */
        {
            perror("read");
            break;
        }
        else
        {
            printf("The read string is from kernel:%s\n", buff);
        }
    }while(strncmp(buff, "quit", 4));
    close(fd);
    exit(0);
}

（3）实验过程与截图

1．首先在虚拟设备驱动源码目录下编译驱动模块

 $ su
 密码：
 $ make clean
 $ make

2．直接加载驱动模块 test_drv_load

 $ chmod +x test_drv_load
 $ ./test_drv_load

此时已经产生了加载过的驱动设备 test_drv ，进入目录 /proc 可查看到

 $ cd /proc
 $ cat devices

查看一下该设备的详细信息

3．接着编译并运行测试程序 test.c

 $ gcc test.c -o test
 $ ./test

4．卸载驱动程序

 $ chmod +x test_drv_unload
 $ ./test_drv_unload

5．通过 demsg 命令查看内核打印信息

返回目录

三、实验总结

（一）遇到的问题

（1）加载模块的时候遇到权限不够的问题

如图所示

解决方法：用命令 chmod +x test_drv_load 增加权限

（2）make 的时候报错失败

如图所示

解决方法：Makefile 文件中只能使用 tab 而不能使用空格，将空格的地方全部改用 tab 就成功了

（3）加载运行驱动脚本程序的时候报错

如图所示

解决方法：用 su 命令切换到 root 用户，再重新加载即可

（4）加载运行驱动脚本程序的时候出现

如图所示

解决方法：emmmm不知道怎么解决，但可以直接继续做下去

（二）分析与总结

掌握了新的记笔记方法——康奈尔笔记法，更简练，更集中，也更方便背记知识点。
通过教材，自学了嵌入式Linux设备驱动程序的开发。了解了字符设备驱动程序的编写流程、相关的重要数据结构和函数、设备驱动程序的主要组成以及 proc 文件系统。
还学习了块设备驱动程序的编写，主要包括块设备驱动程序的描述符和块设备驱动程序的编写流程。
实践了教材最后的 test 实验，一个简单的虚拟设备驱动程序的编写与测试。
实验中遇到了许多 make 编译时出现的错误，最终一一排除错误达到编译效果。

（三）参考资料

返回目录

转载于:https://www.cnblogs.com/moddy13162201/p/10050285.html

weixin_30807779

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2018-2019-1 20165223-20165218 实验四外设驱动程序设计

实验成员：20165223 20165218实验名称：外设驱动程序设计目录一、实验目的二、实验内容任务一：用康奈尔笔记法学习嵌入式Linux设备驱动开发课程任务二：在Ubuntu中动手完成教程中的test实验三、实验总结（一）遇到的问题（二）分析与总结（三）参考资料一、实验目的（1）学习并掌握康奈尔笔记法，能有效提高自学的效率（2）自主学习嵌...
复制链接

扫一扫