通过字符设备驱动分布操作进行6个灯的操作

已于 2023-03-22 19:52:09 修改
阅读量88 收藏
点赞数
文章标签： linux 单片机 运维 Powered by 金山文档
于 2023-03-22 19:51:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljiijo/article/details/129717876
版权

需求：

代码编写：

头文件

#ifndef __MYCDEV_H__
#define __MYCDEV_H__

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

#define CNAME "myled"

//GPIOx组控制器结构体
typedef struct {
    volatile unsigned int MODER;   // 0x00
    volatile unsigned int OTYPER;  // 0x04
    volatile unsigned int OSPEEDR; // 0x08
    volatile unsigned int PUPDR;   // 0x0C
    volatile unsigned int IDR;     // 0x10
    volatile unsigned int ODR;     // 0x14
    volatile unsigned int BSRR;    // 0x18
    volatile unsigned int LCKR;    // 0x1C 
    volatile unsigned int AFRL;    // 0x20 
    volatile unsigned int AFRH;    // 0x24
    volatile unsigned int BRR;     // 0x28
    volatile unsigned int res;
    volatile unsigned int SECCFGR; // 0x30
}gpio_t;

char kbuf[128] = {0};
//初始化rcc、GPIOE、GPIOF、GPIOZ组控制器
unsigned int* AHB4_virt_rcc;
unsigned int* AHB5_virt_rcc;
gpio_t* virt_gpioe;
gpio_t* virt_gpiof;
gpio_t* virt_gpioz;
struct class* c;
struct device* d;

//指定GPIOE组基地址
#define  PHY_GPIOE_ADDR  0x50006000
//指定GPIOF组基地址
#define  PHY_GPIOF_ADDR  0x50007000
//指定GPIOZ组基地址
#define  PHY_GPIOZ_ADDR  0x54004000
//AHB4_RCC基地址：0x50000A28
#define PHY_RCC_AHB4 0x50000A28
//AHB5_RCC基地址：0x50000A28
#define PHY_RCC_AHB5 0x54000210

//LED点亮命令码
#define LED_ON _IOW('a',1,int)
//LED熄灭命令码
#define LED_OFF _IOW('a',0,int)
//LED翻转命令码
#define LED_TOGGLE _IOW('a',2,int)

//LED1~6翻转
#define LED1_TOGGLE (virt_gpioe->ODR ^= (0x1 << 10))
#define LED2_TOGGLE (virt_gpiof->ODR ^= (0x1 << 10))
#define LED3_TOGGLE (virt_gpioe->ODR ^= (0x1 << 8))
#define LED4_TOGGLE (virt_gpioz->ODR ^= (0x1 << 5))
#define LED5_TOGGLE (virt_gpioz->ODR ^= (0x1 << 6))
#define LED6_TOGGLE (virt_gpioz->ODR ^= (0x1 << 7))

//LED1亮
#define LED1_ON (virt_gpioe->ODR |= (0x1 << 10))
//LED1灭
#define LED1_OFF (virt_gpioe->ODR &= (~(0x1 << 10)))
//LED2亮
#define LED2_ON (virt_gpiof->ODR |= (0x1 << 10))
//LED2灭
#define LED2_OFF (virt_gpiof->ODR &= (~(0x1 << 10)))
//LED3亮
#define LED3_ON (virt_gpioe->ODR |= (0x1 << 8))
//LED3灭
#define LED3_OFF (virt_gpioe->ODR &= (~(0x1 << 8)))
//LED4亮
#define LED4_ON (virt_gpioz->ODR |= (0x1 << 5))
//LED4灭
#define LED4_OFF (virt_gpioz->ODR &= (~(0x1 << 5)))
//LED5亮
#define LED5_ON (virt_gpioz->ODR |= (0x1 << 6))
//LED5灭
#define LED5_OFF (virt_gpioz->ODR &= (~(0x1 << 6)))
//LED6亮
#define LED6_ON (virt_gpioz->ODR |= (0x1 << 7))
//LED6灭
#define LED6_OFF (virt_gpioz->ODR &= (~(0x1 << 7)))

enum{
    LED1,
    LED2,
    LED3,
    LED4,
    LED5,
    LED6,
};

#endif

源文件

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include "mycdev.h"

struct cdev* cdev;
dev_t devno;
#if 0
unsigned int major = 0;
#else 
unsigned int major = 500;
#endif
unsigned int minor = 0;
struct class* cls;
struct device* dev;

int mycdev_open(struct inode* inode,struct file* file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t mycdev_read(struct file* file,char* ubuf,size_t size,loff_t *off)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t mycdev_write(struct file* file,const char* ubuf,size_t size,loff_t *off)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

int mycdev_close(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 args)
{
    //1.判断cmd switch(cmd)
    //2.判断操作那盏灯进行翻转 copy_from_user
    int whitch;
    int ret;
    switch(cmd)
    {
        //LED点亮
        case LED_ON:
        ret = copy_from_user(&whitch,(void*)args,sizeof(int));
        if(ret)
        {
            printk("copy_from_user failed\n");
            return -EIO;
        }
        switch(whitch)
        {
            case LED1:
                LED1_ON;
                break;
            case LED2:
                LED2_ON;
                break;
            case LED3:
                LED3_ON;
                break;
            case LED4:
                LED4_ON;
                break;
            case LED5:
                LED5_ON;
                break;
            case LED6:
                LED6_ON;
                break;
        }
        break;
        //LED熄灭
        case LED_OFF:
            ret = copy_from_user(&whitch,(void*)args,sizeof(int));
            if(ret)
            {
                printk("copy from user is error\n");
                return -EIO;
            }
            switch(whitch)
            {
                case LED1:
                    LED1_OFF;
                    break;
                case LED2:
                    LED2_OFF;
                    break;
                case LED3:
                    LED3_OFF;
                    break;
                case LED4:
                    LED4_OFF;
                    break;
                case LED5:
                    LED5_OFF;
                    break;
                case LED6:
                    LED6_OFF;
                    break;
            }
            break;
        //LED翻转
        case LED_TOGGLE:
            ret = copy_from_user(&whitch,(void*)args,sizeof(int));
            if(ret)
            {
                printk("copy from user is error\n");
                return -EIO;
            }
            switch(whitch)
            {
                case LED1:
                    LED1_TOGGLE;
                    break;
                case LED2:
                    LED2_TOGGLE;
                    break;
                case LED3:
                    LED3_TOGGLE;
                    break;
                case LED4:
                    LED4_TOGGLE;
                    break;
                case LED5:
                    LED5_TOGGLE;
                    break;
                case LED6:
                    LED6_TOGGLE;
                    break;
            }
    }
    return 0;
}

const struct file_operations fops = {
    .unlocked_ioctl = mycdev_ioctl,
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    int ret,i;
    //映射物理地址为虚拟地址
    AHB4_virt_rcc = ioremap(PHY_RCC_AHB4,4);
    if(NULL == AHB4_virt_rcc)
    {
        printk("rcc ioremap is failed\n");
        return -ENOMEM;
    }
    AHB5_virt_rcc = ioremap(PHY_RCC_AHB5,4);
    if(NULL == AHB5_virt_rcc)
    {
        printk("rcc ioremap is failed\n");
        return -ENOMEM;
    }
    virt_gpioe = ioremap(PHY_GPIOE_ADDR,sizeof(gpio_t));
    {
        if(NULL == virt_gpioe)
        {
            printk("gpioe ioremap is failed\n");
            return -ENOMEM;
        }
    }
    virt_gpiof = ioremap(PHY_GPIOF_ADDR,sizeof(gpio_t));
    {
        if(NULL == virt_gpiof)
        {
            printk("gpioe ioremap is failed\n");
            return -ENOMEM;
        }
    }
    virt_gpioz = ioremap(PHY_GPIOZ_ADDR,sizeof(gpio_t));
    {
        if(NULL == virt_gpioz)
        {
            printk("gpioz ioremap is failed\n");
            return -ENOMEM;
        }
    }
    //RCC使能GPIO E F Z
    *AHB4_virt_rcc |= (0x3 << 4);
    *AHB5_virt_rcc |= (0x1);
    //LED1 PE10
    virt_gpioe->MODER &= (~(0x3 << 20));
    virt_gpioe->MODER |= (0x1 << 20);
    virt_gpioe->ODR &= (~(0x1 << 10));
    //LED2 PF10
    virt_gpiof->MODER &= (~(0x3 << 20));
    virt_gpiof->MODER |= (0x1 << 20);
    virt_gpiof->ODR &= (~(0x1 << 10));
    //LED3 PE8
    virt_gpioe->MODER &= (~(0x3 << 16));
    virt_gpioe->MODER |= (0x1 << 16);
    virt_gpioe->ODR &= (~(0x1 << 8));
    // //LED4 PZ5
    virt_gpioz->MODER &= (~(0x3 << 10));
    virt_gpioz->MODER |= (0x1 << 10);
    virt_gpioz->ODR &= (~(0x1 << 5));
    //LED5 PZ6
    virt_gpioz->MODER &= (~(0x3 << 12));
    virt_gpioz->MODER |= (0x1 << 12);
    virt_gpioz->ODR &= (~(0x1 << 6));
    //LED6 PZ7
    virt_gpioz->MODER &= (~(0x3 << 14));
    virt_gpioz->MODER |= (0x1 << 14);
    virt_gpioz->ODR &= (~(0x1 << 7));
    /*
        1.分配对象
        2.对象初始化
        3.设备资源的申请（设备号）
        4.注册
        5.向上提交目录
        6.向上提交设备节点信息
    */
    //1.分配对象
    cdev = cdev_alloc();
    if(NULL == cdev)
    {
        printk("分配对象空间失败\n");
        ret=-ENOMEM;
        goto ERR1;
    }
    printk("分配对象空间成功\n");
    //2.初始化驱动对象
    cdev_init(cdev,&fops);
    //3.设备资源的申请（设备号）
    if(0 == major)
    {
        ret = alloc_chrdev_region(&devno,minor,3,"mycdev");
        if(ret)
        {
            printk("动态申请设备号失败\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
    }
    else if(major > 0)
    {
        ret = register_chrdev_region(MKDEV(major,minor),3,"mycdev");
        if(ret)
        {
            printk("静态申请设备号失败\n");
            goto ERR2;
        }
    }
    //4.注册对象
    ret = cdev_add(cdev,MKDEV(major,minor),3);
    if(ret)
    {
        printk("驱动对象注册进内核失败\n");
        goto ERR3;
    }
    printk("驱动对象注册进内核成功\n");
    //5.向上提交目录
    cls = class_create(THIS_MODULE,"mycdev");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        goto ERR4;
    }
    printk("向上提交目录成功\n");
    //6.向上提交设备节点信息
    for(i=0;i<3;i++)
    {
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
        if(IS_ERR(dev))
        {
            printk("向上提交结点信息失败\n");
            goto ERR5;
        }
        printk("向上提交结点信息成功\n");
    }
    printk("向上提交设备结点成功\n");
    printk("major = %d\n",major);
    return 0;
//根据ERR等级释放资源
ERR5:
    for(--i;i>=0;i--)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major,minor),3);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}

static void __exit mycdev_exit(void)
{
    /*
        1.销毁设备节点
        2.销毁目录
        3.注销驱动对象
        4.释放设备资源（设备号）
        5.释放对象空间
        6.取消映射
    */
    //1.销毁设备节点
    int i;
    for(i=0;i<3;i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    //2.销毁目录
    class_destroy(cls);
    //3.注销驱动对象
    cdev_del(cdev);
    //4.释放设备资源（设备号）
    unregister_chrdev_region(MKDEV(major,minor),3);
    //5.释放对象空间
    kfree(cdev);
    //6.取消映射
    iounmap(AHB4_virt_rcc);
    iounmap(AHB5_virt_rcc);
    iounmap(virt_gpioe);
    iounmap(virt_gpiof);
    iounmap(virt_gpioz);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

测试文件

#include <sys/ioctl.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#define LED_ON _IOW('a',1,int)
#define LED_OFF _IOW('a',0,int)
#define LED_TOGGLE _IOW('a',2,int)

enum{
    LED1,
    LED2,
    LED3,
    LED4,
    LED5,
    LED6,
};

void menu_set();
void menu_toggle();
void ioctl_cmd_set(int,int);
void ioctl_cmd_toggle(int,int);

int main(int argc,const char * argv[])
{
    char buf[128] = {0};
    int cmd;
    int fd = -1;
    fd = open("/dev/mycdev0",O_RDWR);
    if(fd == -1)
    {
        perror("open is error\n");
        return -1;
    }
    int whitch;
    while (1)
    {
        //menu_set();
        menu_toggle();  //打印命令列表
        fgets(buf,sizeof(buf),stdin);
        cmd = atoi(buf);
        printf("cmd = %d\n",cmd);
        //ioctl_cmd_set(fd,cmd);
        ioctl_cmd_toggle(fd,cmd);   //发送翻转命令
        system("clear");
    }
    close(fd);
    return 0;
}





void menu_set()
{
        printf("命令1：*********LED1亮*********\n");
        printf("命令2：*********LED1灭*********\n");
        printf("命令3：*********LED2亮*********\n");
        printf("命令4：*********LED2灭*********\n");
        printf("命令5：*********LED3亮*********\n");
        printf("命令6：*********LED3灭*********\n");
        printf("命令7：*********LED4亮*********\n");
        printf("命令8：*********LED4灭*********\n");
        printf("命令9：*********LED5亮*********\n");
        printf("命令10：*********LED5灭*********\n");
        printf("命令11：*********LED6亮*********\n");
        printf("命令12：*********LED6灭*********\n");
        printf("请输入命令>>>>>>>");
}

void menu_toggle()
{
        printf("命令1：*********LED1翻转*********\n");
        printf("命令2：*********LED2翻转*********\n");
        printf("命令3：*********LED3翻转*********\n");
        printf("命令4：*********LED4翻转*********\n");
        printf("命令5：*********LED5翻转*********\n");
        printf("命令6：*********LED6翻转*********\n");
        printf("请输入命令>>>>>>>");
}

void ioctl_cmd_toggle(int fd,int cmd)
{
    int whitch;
    switch (cmd)
    {
    case 1:
        whitch = LED1;
        ioctl(fd,LED_TOGGLE, &whitch);
        break;
    case 2:
        whitch = LED2;
        ioctl(fd,LED_TOGGLE, &whitch);
        break;
    case 3:
        whitch = LED3;
        ioctl(fd,LED_TOGGLE, &whitch);
        break;
    case 4:
        whitch = LED4;
        ioctl(fd,LED_TOGGLE, &whitch);
        break;
    case 5:
        whitch = LED5;
        ioctl(fd,LED_TOGGLE, &whitch);
        break;
    case 6:
        whitch = LED6;
        ioctl(fd,LED_TOGGLE, &whitch);
        break;
    }
}

void ioctl_cmd_set(int fd,int cmd)
{
    int whitch;
    switch(cmd)
    {
        case 1:
            whitch = LED1;
            ioctl(fd,LED_ON, &whitch);
            break;
        case 3:
            whitch = LED2;
            ioctl(fd,LED_ON,&whitch);
            break;
        case 5:
            whitch = LED3;
            ioctl(fd, LED_ON, &whitch);
            break;
        case 7:
            whitch = LED4;
            ioctl(fd, LED_ON, &whitch);
            break;
        case 9:
            whitch = LED5;
            ioctl(fd, LED_ON, &whitch);
            break;
        case 11:
            whitch = LED6;
            ioctl(fd, LED_ON, &whitch);
            break;

        case 2:
            whitch = LED1;
            ioctl(fd,LED_OFF,&whitch);
            break;
        case 4:
            whitch = LED2;
            ioctl(fd,LED_OFF,&whitch);
            break;
        case 6:
            whitch = LED3;
            ioctl(fd, LED_OFF, &whitch);
            break;
        case 8:
            whitch = LED4;
            ioctl(fd, LED_OFF, &whitch);
            break;
        case 10:
            whitch = LED5;
            ioctl(fd, LED_OFF, &whitch);
            break;
        case 12:
            whitch = LED6;
            ioctl(fd, LED_OFF, &whitch);
            break;
        }
}

代码实现：

糊钞梵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
通过字符设备驱动分布操作进行6个灯的操作(iocl)
qq_54344539的博客
03-22 107
通过字符设备驱动分布操作进行6个灯的操作(iocl)
通过字符设备驱动分布操作进行6个灯的操作（ioctl）
Vpipiguai的博客
03-22 119
入门嵌入式
通过字符设备驱动分布操作进行6个灯的操作( ioctl)
qq_44849419的博客
03-22 107
通过字符设备驱动分布操作进行6个灯的操作( ioctl)。
通过字符设备驱动分布操作进行6个灯的操作(ioctl)
weixin_46323325的博客
03-22 106
通过字符设备驱动分布操作进行6个灯的操作(ioctl)
通过字符设备驱动分布操作进行6个灯的操作（ioctl）(CSDN)
qq_64408853的博客
03-22 111
【代码】通过字符设备驱动分布操作进行6个灯的操作（ioctl）(CSDN)
//通过字符设备驱动分布操作进行6个灯的操作（ioctl） //通过字符设备驱动创建6个设备节点分别控制6盏灯（ioctl）
qq_53140444的博客
03-22 111
//通过字符设备驱动分布操作进行6个灯的操作（ioctl） //通过字符设备驱动创建6个设备节点分别控制6盏灯（ioctl）
2022/10/12——字符设备驱动的分布注册的练习
ad20001218的博客
10-12 106
字符设备驱动的分布注册的练习
字符设备驱动基础
小嵌同学的博客
08-21 856
目录一、开启驱动开发之路二、最简单的模块源码分析三、用开发板来调试模块四、字符设备驱动工作原理1、系统整体工作原理2、file_operations结构体（和文件操作有关）3、注册字符设备驱动4、register_chrdev详解(#include 一、开启驱动开发之路 1、驱动开发的准备工作 (1)正常运行linux系统的开发板。要求开发板中的linux的zImage必须是自己编译的，不能是别人编译的。因为需要一个内核源码树。 (2)内核源码树，其实就是一个经过了配置编译之后的内核源码。编译驱动时，需要用
二.字符设备驱动基础
Mr.Wang的博客
09-29 1688
目录 一.开启驱动开发之路 二.最简单的模块源码分析1 2.1、常用的模块操作命令 三.最简单的模块源码分析2 3.1、模块卸载 3.2、模块中常用宏 四.最简单的模块源码分析3 4.1、printk函数详解 4.2、关于驱动模块中的头文件 4.3、驱动编译的Makefile分析 五.用开发板来调试模块 5.1、设置bootcmd使开发板通过tftp下载自己建立的内...
linux 添加字符设备驱动程序及测试程序.zip
01-07
linux 添加字符设备驱动程序及测试程序,linux下采用模块方法，添加一个新的设备驱动程序。要求添加字符设备的驱动。另附一个应用程序，测试添加的驱动程序. int main(void) { int fd; char buf[MAX_SIZE]; char ...
字符设备驱动程序_操作系统OS_完整课程设计报告
03-28
字符设备驱动程序 操作系统OS的课程设计 附带完整课程设计报告
Linux字符设备驱动实验代码
01-08
简单的字符设备的驱动程序，并对所编写的设备驱动程序进行测试，了解Linux操作系统如何管理字符设备。由于网上许多资源不完整，本资源整合了许多内容。包括驱动程序memdev.c，memdev.h，app-mem.c，MakeFile文件。...
Linux字符设备驱动实现
11-06
编写一个字符设备驱动，并利用对字符设备的同步操作，设计实现一个聊天程序。可以有一个读，一个写进程共享该字符设备，进行聊天；也可以由多个读和多个写进程共享该字符设备，进行聊天
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
基于平台驱动的基本的LED字符设备驱动，支持多个LED灯，整个驱动分为两部分，一部分定义资源led_dev.c，一部分定义操作led_drv.c，未体现Linux驱动分层设计思想
Linux 三十六章
一怀明月的博客
05-17 985
信号量 sem_init sem_destroy sem_wait sem_post 基于环形队列的CP问题 环形队列的生产者消费者模型 线程池 localtime时间戳转化 mkdir系统调用 bind绑定成员函数 懒汉饿汉单例模式 懒汉模式： 饿汉模式： 懒汉和饿汉相同点： 线程池源码实现
【linux】linux中免交互命令expect原理与应用实战
最新发布
景天科技苑
05-20 1428
Expect 是基于 Tcl 的相对简单的一个免费的脚本编程工具语言，用来实现 自动和交互式任务程序进行通信，无需人的手工干预。比如 SSH、FTP 等，这些 程序正常情况都需要手工与它们进行交互，而使用 Expect 就可以模拟人手工交 互的过程，实现自动的和远程的程序交互，从而达到自动化运维的目的。
操作系统 实验13 批处理操作接口3：引用与命令替换
m0_63093530的博客
05-14 154
结果：第一个和第三个命令是错的，第二个和第四个命令是对的。echo "这是命令替换形式1...$date1"echo "$sv ++++加上另一些字符！2、输出字符串“China's panda”命令：echo China\'s panda。6、将命令date执行结果赋予变量date1。7、将命令date执行结果赋予变量date2。1、输出字符串“$Dollar”命令：echo \$Dollar。命令：date2=$(date)命令：date1=`date`
Linux：网络管理命令之ss
hhd1988的专栏
05-17 810
Linux：网络管理命令之ss
编写一个linux字符设备驱动
08-11
在驱动程序中，可以通过cdev结构体和相应函数来自动创建一个字符设备，并将该设备与上述方法进行关联。 4. 主设备号的分配与释放： 在模块初始化函数中，需要通过调用register_chrdev_region函数来分配一个独特的主...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值