2023年7月5日 星期三 Linux驱动作业

于 2023-07-05 18:43:23 发布
阅读量95 收藏
点赞数 1
分类专栏： 驱动 ARM C语言 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76789768/article/details/131561937
版权
C语言 同时被 3 个专栏收录
42 篇文章 0 订阅
订阅专栏
ARM
8 篇文章 0 订阅
订阅专栏
驱动
6 篇文章 0 订阅
订阅专栏
该代码实现了一个Linux内核驱动程序，通过ioctl函数控制GPIO来开关LED、风扇、马达和蜂鸣器。应用程序通过打开设备文件，使用ioctl系统调用来发送自定义命令给驱动，从而实现硬件的控制。驱动程序分别对LED、风扇、马达和蜂鸣器进行了初始化，并映射了相应的GPIO寄存器进行操作。
摘要由CSDN通过智能技术生成

通过ioctl函数选择不同硬件的控制，LED 蜂鸣器 马达 风扇

头文件


#ifndef __HEAD_H__
#define __HEAD_H__
 
//定义寄存器组织结构体
typedef struct{
    unsigned int moder;
    unsigned int otyper;
    unsigned int ospeedr;
    unsigned int pupdr;
    unsigned int idr;
    unsigned int odr;
}gpio_t;
//定义GPIOE和GPIOF
#define GPIOE 0X50006000
#define GPIOF 0X50007000
#define GPIOB 0X50003000
#define RCC 0X50000A28

#define LED_ON _IOW('l',1,int)
#define LED_OFF _IOW('l',0,int)
#define FAN_ON _IO('f',1)
#define FAN_OFF _IO('f',0)
#define MOTOR_ON _IO('m',1)
#define MOTOR_OFF _IO('m',0)
#define BEE_ON _IO('b',1)
#define BEE_OFF _IO('b',0)
#endif

应用程序


#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include "head.h"
int main(int argc, char const *argv[])
{
    int a, b, c, d, e;
    char buf[128] = {0};
    int fd_led = open("/dev/led0", O_RDWR);
    if (fd_led < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_fan = open("/dev/fan", O_RDWR);
    if (fd_fan < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_motor = open("/dev/motor", O_RDWR);
    if (fd_motor < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_bee = open("/dev/bee", O_RDWR);
    if (fd_bee < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }

    while (1)
    {
        // 从终端读取
        printf("请选择灯功能\n");
        printf("0(关灯) 1(开灯)>");
        scanf("%d", &a);
        printf("请输入要控制的灯\n");
        printf("1(LED1) 2(LED2) 3(LED3)>");
        scanf("%d", &b);
        if (a == 1) // 开灯
        {
            ioctl(fd_led, LED_ON, &b);
        }
        else if (a == 0) // 关灯
        {
            ioctl(fd_led, LED_OFF, &b);
        }
        printf("请选择风扇的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &c);
        if (c == 1) // 开风扇
        {
            ioctl(fd_fan, FAN_ON);
        }
        else if (c == 0) // 关风扇
        {
            ioctl(fd_fan, FAN_OFF);
        }
        printf("请选择马达的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &e);
        if (e == 1) // 开马达
        {
            ioctl(fd_motor, MOTOR_ON);
        }
        else if (e == 0) // 关马达
        {
            ioctl(fd_motor, MOTOR_OFF);
        }
        printf("请选择蜂鸣器的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &d);
        if (d == 1) // 开蜂鸣器
        {
            ioctl(fd_bee, BEE_ON);
        }
        else if (d == 0) // 关蜂鸣器
        {
            ioctl(fd_bee, BEE_OFF);
        }
    }
    close(fd_led);
    close(fd_fan);
    close(fd_motor);
    close(fd_bee);
    return 0;
}

驱动程序-led.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int which;
    int ret = copy_from_user(&which, (void *)arg, 4);
    if (ret)
    {
        printk("拷贝用户空间数据失败\n");
        return -EIO;
    }
    // 功能控制
    switch (cmd)
    {
    case LED_ON:
        switch (which)
        {
        case 1:
            vir_gpioe->odr |= (0x1 << 10);
            break;
        case 2:
            vir_gpiof->odr |= (0x1 << 10);
            break;
        case 3:
            vir_gpioe->odr |= (0x1 << 8);
            break;
        }
        break;
    case LED_OFF:
        switch (which)
        {
        case 1:
            vir_gpioe->odr &= (~(0x1 << 10));
            break;
        case 2:
            vir_gpiof->odr &= (~(0x1 << 10));
            break;
        case 3:
            vir_gpioe->odr &= (~(0x1 << 8));
            break;
        }
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    int i;
    // 字符设备驱动注册
    major = register_chrdev(0, "led", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "led");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "led%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交节点信息失败\n");
            return -PTR_ERR(dev);
        }
    }
    // 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }
    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");
    (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化led1
    vir_gpioe->moder &= (~(0x3 << 20));
    vir_gpioe->moder |= (0x1 << 20);
    vir_gpioe->odr &= (~(0x1 << 10));
    // 寄存器初始化led2
    vir_gpiof->moder &= (~(0x3 << 20));
    vir_gpiof->moder |= (0x1 << 20);
    vir_gpiof->odr &= (~(0x1 << 10));
    // 寄存器初始化led3
    vir_gpioe->moder &= (~(0x3 << 16));
    vir_gpioe->moder |= (0x1 << 16);
    vir_gpioe->odr &= (~(0x1 << 8));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "led");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

驱动程序-fan.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case FAN_ON: // 开风扇
        vir_gpioe->odr |= (0x1 << 9);
        break;
    case FAN_OFF: // 关风扇
        vir_gpioe->odr &= (~(0x1 << 9));
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "fan", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "fan");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "fan");
    if (IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }
    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");
    (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化fan
    vir_gpioe->moder &= (~(0x3 << 18));
    vir_gpioe->moder |= (0x1 << 18);
    vir_gpioe->odr &= (~(0x1 << 9));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "fan");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

驱动程序-motor.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case MOTOR_ON: // 开马达
        vir_gpiof->odr |= (0x1 << 6);
        break;
    case MOTOR_OFF: // 关马达
        vir_gpiof->odr &= (~(0x1 << 6));
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "motor", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "motor");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "motor");
    if (IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }
    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");
    (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化fan
    vir_gpiof->moder &= (~(0x3 << 12));
    vir_gpiof->moder |= (0x1 << 12);
    vir_gpiof->odr &= (~(0x1 << 6));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "motor");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

驱动程序-bee.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
gpio_t *vir_gpiob;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case BEE_ON: // 开蜂鸣器
        vir_gpiob->odr |= (0x1 << 6);
        break;
    case FAN_OFF: // 关蜂鸣器
        vir_gpiob->odr &= (~(0x1 << 6));
        break;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .unlocked_ioctl = mycdev_ioctl,
        .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "bee", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "bee");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "bee");
    if (IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    vir_gpiob = ioremap(GPIOB, sizeof(gpio_t));
    if (vir_gpiob == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }
    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");
    (*vir_rcc) |= (0x3 << 4);
    (*vir_rcc) |= (0x1 << 1);
    // 寄存器初始化bee
    vir_gpiob->moder &= (~(0x3 << 12));
    vir_gpiob->moder |= (0x1 << 12);
    vir_gpioe->odr &= (~(0x1 << 6));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    iounmap(vir_gpiob);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "bee");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");
Cheng_桑
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值