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

已于 2023-03-22 21:39:47 修改
阅读量167 收藏
点赞数
文章标签： linux
于 2023-03-22 21:21:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44849419/article/details/129719598
版权

1、作业需求

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

2、实现过程

1）myled.h文件

#ifndef __MYLED_H__
#define __MYLED_H__

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;

//RCC基地址
#define PHY_RCC_1 0x50000A28
#define PHY_RCC_2 0x54000210

#define PHY_GPIOE_ADDR 0x50006000	//GPIOE基地址
#define PHY_GPIOF_ADDR 0x50007000	//GPIOF基地址
#define PHY_GPIOZ_ADDR 0x54004000	//GPIOZ基地址

#define LED_ON _IOW('a',1,int)
#define LED_OFF _IOW('a',0,int)
enum{
	LED1,
	LED2,
	LED3,
	LED4,
	LED5,
	LED6,
};

#endif

2）myled.c文件

#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 <linux/io.h>
#include "myled.h"

#define CNAME "myled"
struct cdev *cdev;
dev_t devno;
unsigned int minor=0;

#if 1
unsigned int major=0;  //动态申请主设备号
#else
unsigned int major=500; //静态指定主设备号
#endif
struct class *cls;
struct device *dev;

int i;
char kbuf[128] = {0};
gpio_t* virt_gpioe = NULL;
gpio_t* virt_gpiof = NULL;
gpio_t* virt_gpioz = NULL;
unsigned int* virt_rcc_1 = NULL;
unsigned int* virt_rcc_2 = NULL;

#define LED1_ON  (virt_gpioe->ODR |= (0x1 << 10))
#define LED1_OFF (virt_gpioe->ODR &= (~(0x1 << 10)))
#define LED2_ON  (virt_gpiof->ODR |= (0x1 << 10))
#define LED2_OFF (virt_gpiof->ODR &= (~(0x1 << 10)))
#define LED3_ON  (virt_gpioe->ODR |= (0x1 << 8))
#define LED3_OFF (virt_gpioe->ODR &= (~(0x1 << 8)))

#define LED4_ON  (virt_gpioe->ODR |= (0x1 << 5))
#define LED4_OFF (virt_gpioe->ODR &= (~(0x1 << 5)))
#define LED5_ON  (virt_gpiof->ODR |= (0x1 << 6))
#define LED5_OFF (virt_gpiof->ODR &= (~(0x1 << 6)))
#define LED6_ON  (virt_gpioe->ODR |= (0x1 << 7))
#define LED6_OFF (virt_gpioe->ODR &= (~(0x1 << 7)))

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

//read
ssize_t mycdev_read (struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //1.校验传输数据的大小，如果用户空间写的数据比内核空间数据大小大，需要更正大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    //2.将数据从用户空间拷贝到内核空间
    ret = copy_to_user(ubuf,kbuf,size);
    if(ret) //3.判断是否错误
    {
        printk("copy to user is error\n");
        return -EIO;
    }
    return size; //5.返回拷贝数据大小
}

//write
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //1.校验传输数据的大小，如果用户空间写的数据比内核空间数据大小大，需要更正大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    //2.将数据从用户空间拷贝到内核空间
    ret = copy_from_user(kbuf,ubuf,size);
    if(ret) //3.判断是否错误
    {
        printk("copy from user is error\n");
        return -EIO;
    }
    //4.打印传递数据内容
    printk("copy from user kbuf:%s\n",kbuf);
    //kbuf[0]:代表操作的是那一盏灯，kbuf[0] = 0  kbuf[0] = 1 kbuf[0] = 2
    //kbuf[1]:代表led灯的状态   kbuf[1] = 0  kbuf[1] = 1
    switch(kbuf[0])
    {
    case 0:
        kbuf[1]?LED1_ON:LED1_OFF;
        break;
    case 1:
        kbuf[1]?LED2_ON:LED2_OFF;
        break;
    case 2:
        kbuf[1]?LED3_ON:LED3_OFF;
        break;
    case 3:
        kbuf[1]?LED4_ON:LED4_OFF;
        break;
    case 4:
        kbuf[1]?LED5_ON:LED5_OFF;
        break;
    case 5:
        kbuf[1]?LED6_ON:LED6_OFF;
        break;
    }
    return size; //5.返回拷贝数据大小
}

long myled_ioctl (struct file *file, unsigned int cmd, unsigned long args)
{
    //1.判断cmd switch(cmd)
    //2.判断操作哪盏灯进行点亮 copy_from_user
    int whitch;
    int ret;
    switch(cmd)
    {
    case LED_ON:
        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_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;
    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;    
    }
    return 0;
}

//close
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,
    .read=mycdev_read,
    .write=mycdev_write,
    .unlocked_ioctl = myled_ioctl,
    .release=mycdev_close,
};

static int __init mycdev_init(void)
{
    /*
        1.分配对象
        2.对象初始化
        3.设备资源的申请（设备号）
        4.注册
        5.向上提交目录
        6.向上提交设备节点信息
    */
   int ret;

   //1.分配对象
   cdev=cdev_alloc();
   if(cdev==NULL){
    printk("分配对象空间失败\n");
    ret=-ENOMEM;
    goto ERR1;
   }
   printk("分配对象空间成功\n");

   //2.初始化驱动对象
    cdev_init(cdev,&fops);

    //3.申请设备号
    if(major==0) {    //动态申请
        ret=alloc_chrdev_region(&devno,minor,3,CNAME);
        if(ret) {
            printk("动态申请设备号失败\n");
            goto ERR2;
        }
         major=MAJOR(devno);    //获取主设备号
         minor=MINOR(devno);    //获取次设备号
    }
    else if(major>0) {    //静态指定主设备号
        ret=register_chrdev_region(MKDEV(major,minor),3,CNAME);
        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,CNAME);
    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("register chrdev major=%d\n",major);

    //映射RCC1
    virt_rcc_1 = ioremap(PHY_RCC_1,4);
    if(virt_rcc_1 == NULL)
    {
        printk("rcc_1 ioremap is error\n");
        return -ENOMEM;
    }

    //映射RCC2
    virt_rcc_2 = ioremap(PHY_RCC_2,4);
    if(virt_rcc_2 == NULL)
    {
        printk("rcc_2 ioremap is error\n");
        return -ENOMEM;
    }

    //映射GPIOE地址
    virt_gpioe = ioremap(PHY_GPIOE_ADDR,sizeof(gpio_t));
    if(virt_gpioe== NULL)
    {
        printk("virt_gpioe ioremap is error\n");
        return -ENOMEM;
    }

    //映射GPIOF地址
    virt_gpiof = ioremap(PHY_GPIOF_ADDR,sizeof(gpio_t));
    if(virt_gpiof== NULL)
    {
        printk("virt_gpiof ioremap is error\n");
        return -ENOMEM;
    }

    //映射GPIOZ地址
    virt_gpioz = ioremap(PHY_GPIOZ_ADDR,sizeof(gpio_t));
    if(virt_gpioz== NULL)
    {
        printk("virt_gpioz ioremap is error\n");
        return -ENOMEM;
    }

    //5.对led1---->PE10引脚初始化  对led3---->PE8引脚初始化 
    *virt_rcc_1 |= (0x1 << 4);//5.1 使能GPIOE组时钟[4]=1
    virt_gpioe->MODER &= (~(0x3 << 20));//5.2 设置PE10引脚为输出模式 [21:20] = 01
    virt_gpioe->MODER |= (0x1 << 20);
    virt_gpioe->ODR &= (~(0x1 << 10)); //5.3 设置PE10引脚输出低电平

    //6. 对led2---->PF10引脚初始化
    *virt_rcc_1 |= (0x1 << 5);//5.1 使能GPIOF组时钟[5]=1
    virt_gpiof->MODER &= (~(0x3 << 20));//5.2 设置PF10引脚为输出模式 [21:20] = 01
    virt_gpiof->MODER |= (0x1 << 20);
    virt_gpiof->ODR &= (~(0x1 << 10)); //5.3 设置PF10引脚输出低电平 

    //7.对led3---->PE8引脚初始化 
    virt_gpioe->MODER &= (~(0x3 << 16));//5.2 设置PE8引脚为输出模式 [17:16] = 01
    virt_gpioe->MODER |= (0x1 << 16);
    virt_gpioe->ODR &= (~(0x1 << 8)); //5.3 设置PE8引脚输出低电平

    //8.对led4---->PZ5引脚初始化
    *virt_rcc_2 |= (0x1 << 0);//5.1 使能GPIOE组时钟[0]=1
    virt_gpioz->MODER &= (~(0x3 << 10));//5.2 设置PZ4引脚为输出模式 [11:10] = 01
    virt_gpioz->MODER |= (0x1 << 10);
    virt_gpioz->ODR &= (~(0x1 << 5)); //5.3 设置PZ4引脚输出低电平

    //9. 对led5---->PZ6引脚初始化
    virt_gpioz->MODER &= (~(0x3 << 12));//5.2 设置PZ5引脚为输出模式 [13:12] = 01
    virt_gpioz->MODER |= (0x1 << 12);
    virt_gpioz->ODR &= (~(0x1 << 6)); //5.3 设置PZ5引脚输出低电平 

    //10.对led6---->PZ7引脚初始化 
    virt_gpioz->MODER &= (~(0x3 << 14));//5.2 设置PZ6引脚为输出模式 [15:14] = 01
    virt_gpioz->MODER |= (0x1 << 14);
    virt_gpioz->ODR &= (~(0x1 << 7)); //5.3 设置PZ6引脚输出低电平

    return 0;
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)
{
    //取消地址映射
    iounmap(virt_rcc_1);
    iounmap(virt_rcc_2);
    iounmap(virt_gpioe);
    iounmap(virt_gpiof);
    iounmap(virt_gpioz);

    /*
        1.销毁设备节点
        2.销毁目录
        3.注销驱动对象
        4.释放设备资源（设备号）
        5.释放对象空间
    */

    for(i=0;i<3;i++) {
        device_destroy(cls,MKDEV(major,i));
    }

    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major,minor),3);
    kfree(cdev);
}

module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

3）test.c测试文件

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

int main(int argc,const char * argv[])
{
    char buf[128] = {0};
    int whitch;
    int fd = -1;
    fd = open("/dev/mycdev0",O_RDWR);
    if(fd == -1)
    {
        perror("open is error\n");
        return -1;
    }

    while(1)
    {
        whitch = LED1;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED2;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED3;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED4;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED5;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);

        whitch = LED6;
        ioctl(fd,LED_ON,&whitch);
        sleep(1);
        ioctl(fd,LED_OFF,&whitch);
        sleep(1);
    }

    close(fd);
    return 0;
}

〆,矢ο○憶Ρｐy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
设备描述包含设备的属性，如地址、时钟频率等，而设备操作定义了对设备进行读写等操作的具体函数。 在这个“Linux LED字符设备驱动”中，驱动被分为两个文件：led_dev.c和led_drv.c。led_dev.c可能包含了LED设备的...
字符设备驱动程序_操作系统OS_完整课程设计报告
03-28
字符设备驱动程序是操作系统与硬件之间的重要桥梁，它负责管理和控制特定的硬件设备，特别是那些交互性强、数据传输速率变化大的设备，如键盘、鼠标、打印机等。在操作系统OS的课程设计中，深入理解并编写字符设备...
Linux字符设备驱动（设备文件，用户空间与内核空间进行数据交互，ioctl接口）
qq_53221728的博客
03-25 2045
设备文件的两种创建方式，用户空间怎么与内核空间进行数据交互，字符设备驱动ioctl接口是什么，本文一键搞定。
Linux设备驱动开发---字符设备驱动程序
qq_41683305的博客
04-26 3700
字符设备驱动程序1 主设备和次设备的概念设备号的注册和释放静态方法动态方法区别2 设备文件操作struct file_operations与struct file、struct inode关系3 分配和注册字符设备class_createcdev_adddevice_create4 字符设备驱动程序 字符设备通过字符（一个接一个的字符）以流方式向用户程序传递数据，就像串行端口那样。字符设备驱动通过/dev目录下的特殊文件公开设备的属性和功能，通过这个文件可以在设备和用户应用程序之间交换数据，也可以通过它来控
基于tiny4412开发板led灯字符设备ioctl驱动写法
z961968549的博客
11-13 1196
ioctl接口作用write：向设备写入数据，单独这个接口并不能满足现实设备控制的全部需求。例如一个LCD控制器：主要作用是驱动lcd屏，要显示就是通过write接口把显示数据发给lcd控制器指定的显存。而参数设置类参数通过write接口设置就可能回和普通的显示数据弄混了。为了解决这个问题，内核提供一个接口ioctl对设备进行控制（参数设置，参数查询等功能）。ioctl主要实现不太好实现的功能。io
【5】字符设备ioctl操作
哈哈一笑
07-31 2821
字符设备的ioctl操作
字符设备驱动程序(ioctl)——开发步骤(6)
Soｌong
08-07 1417
字符设备驱动程序(ioctl) ioctl函数模型 int (*ioctl)(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg){} 返回值： ioctl函数的实现通常是根据命令执行的switch语句， 但是命令号不能匹配到任何一个设备时，通常返回-EINVAL(非法参数) 使用参数： 参数如果是一个整数，可以直接使用， 如果是一个指针，需要先确保用户地址的有效性，使用前需要做正确检查 需要检测的函数：
【嵌入式Linux内核驱动】字符设备驱动 | 注册设备号 | 初始化字符设备 | 实现定制文件操作 | 实现读写文件操作
Hi
05-28 1595
【嵌入式Linux】字符设备驱动 | 注册设备号 | 初始化字符设备 | 实现定制文件操作 | 实现读写文件操作
字符设备ioctl接口详解
weixin_42031299的博客
05-04 1898
1、为什么要引入ioctl接口? (1)读写操作只是很基础的功能，有的设备需要支持另外的命令去控制；比如串口需要提供设置波特率、数据位、终止位等操作； (2)如果不同的命令操作，都在write和read中去做判断，对于支持命令比较多的设备，那write和read函数就会很大，不利于维护； (3）ioctl函数是专门用来处理上层发给驱动程序的命令，设备有需要就去实现，如果没有需要就不实现这个函数，将函数指针赋值为NULL； 2、应用层系统调用 #include <sys/ioctl.h> /
嵌入式驱动初级-字符设备驱动基础
weixin_44681745的博客
11-25 1364
字符设备驱动
Linux驱动开发——字符设备驱动开发
一切皆是定数的博客
07-28 1321
字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。Linux应用程序向下调用驱动程序流程如下：在Linux中，一切皆是文件，驱动加载成功之后，会在dev目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。
Linux 驱动学习笔记 ——（1）字符设备驱动
Super辉sir的博客
07-07 4098
字符设备是 Linux 驱动中最基本的一类设备驱动，字节设备就是按照字节流来读写的设备，常见的字符设备包括：LED、蜂鸣器、按键、I2C 以及 SPI 等。
操作系统课程设计-简单字符设备和块设备驱动程序
01-30
在Linux内核中，字符设备驱动通过注册到字符设备模型来实现，使用`struct cdev`结构体来定义设备，并通过`cdev_init`和`cdev_add`函数进行初始化和添加到系统。同时，还需要实现读写操作的回调函数，如`read`和`...
1_chrdevbase_IMX6ULL_weatherb6w_字符设备驱动例程_
09-30
在Linux系统中，字符设备驱动是操作系统与硬件交互的关键组件，它为应用程序提供了一种抽象接口，以便在用户空间和内核空间之间进行数据传输。本文将深入探讨标题"1_chrdevbase_IMX6ULL_weatherb6w_字符设备驱动例程...
Linux内核设备驱动之字符设备驱动笔记整理
09-15
总结来说，字符设备驱动是连接Linux内核与硬件设备的关键，通过设备文件、主次设备号以及相关的数据结构，实现了用户空间对硬件的抽象化操作。理解和掌握字符设备驱动的原理与实现，对于开发和调试Linux系统的硬件...
【运维监控】prometheus+node exporter+grafana 监控linux机器运行情况（2）
alanchanchn的专栏
09-03 1934
本示例是通过prometheus的node exporter收集主机的信息，然后在grafana的dashborad进行展示。本示例使用到的组件均是最新的，下文中会有具体版本说明，linux环境是centos。本示例分为四个部分，即prometheus、grafana、node exporter的部署和三者集成的监控linux。本文旨在说明三者如何使用，不涉及各自组件的介绍，如果需要使用到本文的，肯定都有了解。
Linux实用操作
最新发布
c1tenj2的博客
09-06 554
环境变量是操作系统（Windows、Linux、Mac）在运行的时候，记录的一些关键性信息，用以辅助系统运行。env命令即可查看当前系统中记录的环境变量环境变量是一种KeyValue型结构，即名称和值，如下图：HOME：/home，用户的HOME路径USER：root，当前的操作用户PWD：当前工作路径......我们知道使用的一系列命令其实本质上就是一个个的可执行程序。比如，cd命令的本体就是：/usr/bin/cd 这个程序文件。
＜Linux＞ 基础IO
prodigy623的博客
09-06 485
详解Linux基础IO：文件系统调用接口与C库文件函数的关系、重定向、数据缓冲区、文件系统、动静态库
【Linux修行路】线程安全和死锁
m0_68662723的博客
09-06 778
今天的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，您的支持就是我前进的动力！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值