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

最新推荐文章于 2024-06-19 14:28:31 发布
最新推荐文章于 2024-06-19 14:28:31 发布
阅读量136 收藏
点赞数
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lsq111112/article/details/129718406
版权

头文件：

#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;

//GPIOE基地址
#define PHY_GPIOE_ADDR 0x50006000
#define PHY_GPIOF_ADDR 0x50007000

#define PHY_GPIOZ_ADDR 0x54004000
//RCC基地址：0x50000A28
#define PHY_RCC_LED1 0x50000A28
#define PHY_RCC_LED4 0x50000210

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

#endif

内核文件：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include<linux/fs.h>
#include<linux/uaccess.h>
#include<linux/slab.h>
#include <linux/io.h>
#include "mydev.h"
#define CNAME "myled"

char kbuf[128] = {0};
gpio_t* virt_gpioe = NULL;
gpio_t* virt_gpiof = NULL;
gpio_t* virt_gpioz = NULL;
unsigned int* virt_rcc = NULL;
unsigned int* virt_rcc4 = NULL;

struct cdev *cdev;
dev_t devno;
unsigned int minor=0;

#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_gpioz->ODR |= (0x1 << 5))
#define LED4_OFF  (virt_gpioz->ODR &= (~(0x1 << 5)))

#define LED5_ON  (virt_gpioz->ODR |= (0x1 << 6))
#define LED5_OFF  (virt_gpioz->ODR &= (~(0x1 << 6)))

#define LED6_ON  (virt_gpioz->ODR |= (0x1 << 7))
#define LED6_OFF  (virt_gpioz->ODR &= (~(0x1 << 7)))


#if 0
unsigned int major =0;//动态申请主设备号
#else
unsigned int major=500;//静态态指定主设备号
#endif
struct class *cls;
struct device *dev;
//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 *ubuf, size_t size, loff_t *off)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
//write
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;
}
//close
int  mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

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;
}
struct file_operations fops=
{
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
    .unlocked_ioctl = myled_ioctl,


};
static int __init mycdev_init(void)
{
        int ret,i;
        // 1.分配对象
        cdev =cdev_alloc();
        if(cdev==NULL)
        {
            printk("分配对象失败\n");
            return -ENOMEM;
            goto ERR1;
        }
        printk("分配对象空间成功\n");
        //2.对象初始化
        cdev_init(cdev,&fops);
        //3.设备资源的申请（设备号）
        if(major==0)//动态申请
        {
            ret=alloc_chrdev_region(&devno,minor,6,"myled");
            if(ret)
            {
                printk("动态申请设备号失败\n");
                goto ERR2;
            }
            major=MAJOR(devno);//获取主设备号
            minor=MINOR(devno);//获取次设备号
        }
        else if(major>0)//静态指定主设备号
        {
            ret=register_chrdev_region(MKDEV(major,minor),6,"myled");
            if(ret)
            {
                printk("静态申请设备号失败\n");
                goto ERR2;
            }
        }
        //4.注册
        ret=cdev_add(cdev,MKDEV(major,minor),6);
        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<6;i++)
        {
            dev=device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
            if(IS_ERR(dev))
            {
                printk("向上提交节点信息失败\n");
                goto ERR5;
            }
        }
        printk("向上提交设备节点成功\n");

    //执行led操作
    //4.将物理地址映射为虚拟地址
    //4.1 将rcc地址映射
    virt_rcc = ioremap(PHY_RCC_LED1,4);    
    if(virt_rcc == NULL)
    {
        printk("rcc ioremap is error\n");
        return -ENOMEM;
    }

    virt_rcc4 = ioremap(PHY_RCC_LED4,4);
    if(virt_rcc4 == NULL)
    {
        printk("rcc4 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_gpiof ioremap is error\n");
        return -ENOMEM;
    }

    //5.对led1---->PE10引脚初始化  对led3---->PE8引脚初始化 
    *virt_rcc |= (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 |= (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,led5,led6---->PZ5,PZ6,PZ7引脚初始化

    virt_gpioz->MODER &= (~(0x3 << 10));//5.2 设置PE8引脚为输出模式 [17:16] = 01
    virt_gpioz->MODER |= (0x1 << 10);
    virt_gpioz->ODR &= (~(0x1 << 5)); //5.3 设置PE8引脚输出低电平

    virt_gpioz->MODER &= (~(0x3 << 12));//5.2 设置PE8引脚为输出模式 [17:16] = 01
    virt_gpioz->MODER |= (0x1 << 12);
    virt_gpioz->ODR &= (~(0x1 << 6)); //5.3 设置PE8引脚输出低电平

    virt_gpioz->MODER &= (~(0x3 << 14));//5.2 设置PE8引脚为输出模式 [17:16] = 01
    virt_gpioz->MODER |= (0x1 << 14);
    virt_gpioz->ODR &= (~(0x1 << 7)); //5.3 设置PE8引脚输出低电平

    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)
{
    int i;
    /*
        1.销毁设备节点
        2.销毁目录
        3.注销驱动对象
        4.释放设备资源（s设备号）
        5.释放对象空间
    */
   //2.取消地址映射
    iounmap(virt_rcc);
    iounmap(virt_rcc4);
    iounmap(virt_gpioe);
    iounmap(virt_gpiof);
    iounmap(virt_gpioz);
   
    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");

测试文件：

#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 "mydev.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;
}

工程管理文件：

ARCH ?=x86
modname ?= mydev
ifeq ($(ARCH),arm)
#定义一个变量，存放linux内核源码目录，arm架构
KERNEDIR:=/home/ubuntu/linux-5.10.61
#x86架构
else
KERNEDIR:=/lib/modules/$(shell uname -r)/build
#定义一个变量，开启一个终端，执行pwd命令
endif
PWD:=$(shell pwd)

all:
	@#-C:跳转到内核顶层目录下,读取内核顶层目录下的Makefile文件
	@#在内核源码顶层目录下执行:make M=$(shell pwd) modules
	@#M=$(shell pwd)：回到当前目录下，只编译当前目录下的文件
	@#make modules:采用模块化方式进行编译
	make -C $(KERNEDIR) M=$(shell pwd) modules

clean:
	make -C $(KERNEDIR) M=$(shell pwd) clean

#指定模块化方式编译的文件
obj-m:=$(modname).o

运行效果：

 

 

sq-l
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
通过字符设备驱动分布操作进行6个灯的操作(iocl)
Miki6789的博客
03-22 116
【代码】通过字符设备驱动分布操作进行6个灯的操作(iocl)
Linux设备驱动开发---字符设备驱动程序
qq_41683305的博客
04-26 3383
字符设备驱动程序1 主设备和次设备的概念设备号的注册和释放静态方法动态方法区别2 设备文件操作struct file_operations与struct file、struct inode关系3 分配和注册字符设备class_createcdev_adddevice_create4 字符设备驱动程序 字符设备通过字符（一个接一个的字符）以流方式向用户程序传递数据，就像串行端口那样。字符设备驱动通过/dev目录下的特殊文件公开设备的属性和功能，通过这个文件可以在设备和用户应用程序之间交换数据，也可以通过它来控
Linux字符设备驱动（设备文件，用户空间与内核空间进行数据交互，ioctl接口）
qq_53221728的博客
03-25 1852
设备文件的两种创建方式，用户空间怎么与内核空间进行数据交互，字符设备驱动ioctl接口是什么，本文一键搞定。
【5】字符设备ioctl操作
哈哈一笑
07-31 2741
字符设备的ioctl操作
字符设备驱动程序(ioctl)——开发步骤(6)
Soｌong
08-07 1285
字符设备驱动程序(ioctl) ioctl函数模型 int (*ioctl)(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg){} 返回值： ioctl函数的实现通常是根据命令执行的switch语句， 但是命令号不能匹配到任何一个设备时，通常返回-EINVAL(非法参数) 使用参数： 参数如果是一个整数，可以直接使用， 如果是一个指针，需要先确保用户地址的有效性，使用前需要做正确检查 需要检测的函数：
基于Linux操作系统字符设备驱动程序开发.pdf
09-05
file_operations结构中存储着对设备进行各种操作的函数指针，例如file_open()、file_allocate()、file_read()、file_write()、file_ioctl()、file_close()等。 本文详细介绍了基于Linux操作系统字符设备驱动程序...
Linux内核设备驱动之字符设备驱动笔记整理
09-15
总结来说，字符设备驱动是连接Linux内核与硬件设备的关键，通过设备文件、主次设备号以及相关的数据结构，实现了用户空间对硬件的抽象化操作。理解和掌握字符设备驱动的原理与实现，对于开发和调试Linux系统的硬件...
Linux内核设备驱动之高级字符设备驱动笔记整理
09-15
在Linux内核设备驱动开发中，高级字符设备驱动是一个重要的组成部分，它允许程序员与硬件进行更复杂的交互，提供了除基本读写操作之外的功能。本文主要围绕Linux内核设备驱动之高级字符设备驱动的几个关键知识点展开...
Linux 字符设备驱动框架详细介绍
01-10
字符设备是Linux三大设备之一(另外两种是块设备，网络设备)，字符设备就是字节流形式通讯的I/O设备,绝大部分设备都是字符设备，常见的字符设备包括鼠标、键盘、显示器、串口等等，当我们执行ls -l /dev的时候，就能...
基于Linux字符设备驱动程序的设计与实现.pdf
09-06
Linux字符设备驱动程序是操作系统内核与硬件设备之间的桥梁，它的主要任务是处理用户空间应用程序对硬件设备的访问请求，将这些请求转换为硬件能够理解的操作指令。在Linux系统中，驱动程序运行在内核态，与内核紧密...
Linux中文件查找相关命令比较
lurenyi168的专栏
06-16 361
Linux中与文件定位的命令有find、locate、whereis、which，type。
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 377
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
Linux——ansible里的变量
Xinan_____的博客
06-17 609
本身，ansible就是致力于，用尽可能“通用”的剧本，干所有场合的工作……反过来，主机已有的信息，在ansible看来，是否也可以用类似的方法？Linux系统，各种信息，如果手动获取，要使用不同多种命令、工具。5.2）客户机自己的信息，也可以被管理机获取，在变成变量。用ansible操作主机，其中用变量和层次化的变量，管理信息。如果一组变量，给一组特定的主机指定，不论执行的是什么剧本。4.上面的方式，都是简单指定变量，也可以指定很多变量。但是，上面的方式，结构简单，变量也没有层次化管理。
Linux构建本地时间同步ntp
weixin_72819498的博客
06-13 285
主机名IP地址系统发行版环境Node01Centos 7.4可联网、已关闭防火墙selinuxNode02Centos 7.4已关闭防火墙selinux。
Hvv--知攻善防应急响应靶机--Linux1
GDL1411983801的博客
06-12 640
所有靶机均来自知攻善防实验室官方WP：https://mp.weixin.qq.com/s/opj5dJK7htdawkmLbsSJiQ蓝队应急响应工具箱：夸克网盘：https://pan.quark.cn/s/6d7856efd1d1#/list/share百度云盘：https://pan.baidu.com/s/1ZyrDPH6Ji88w9IJMoFpANA?pwd=ilznhistory账号：defend密码：defend可在桌面看到题解题解提示需获取的内容1.攻击者IP地址。
Linux 命令大全
lly202406的博客
06-16 469
Linux是一个强大的操作系统，它通过命令行界面提供了丰富的功能和灵活性。了解和掌握各种Linux命令对于系统管理员和开发者来说至关重要。本文将为您提供一个全面的Linux命令大全，帮助您更好地理解和使用Linux系统。
【linux】【测试demo】device-driver 框架实例
过得精彩，无所谓好坏
06-12 213
linux driver device 测试框架实例
Linux mongodb安装及简单使用
最新发布
点点的博客
06-19 217
Linux mongodb安装
x86计算机的启动初期流程 Linux 启动流程
eloudy的专栏
06-15 768
x86计算机的启动初期流程。
linux驱动开发字符设备驱动框架
05-29
Linux字符设备驱动框架是Linux内核中的一个重要部分，用于管理字符设备驱动。Linux内核中的每个设备都由一个设备驱动程序来控制，设备驱动程序是一种软件模块，它向操作系统提供了与设备通信的方法。字符设备驱动程序是一种特殊的设备驱动程序，它处理基于字符的设备，如串口、终端等。下面是Linux驱动开发字符设备驱动框架的主要组成部分： 1. 设备注册 在驱动程序初始化时，需要向内核注册设备。注册设备可以使用register_chrdev()函数。 2. 设备打开 当用户打开设备文件时，内核会调用设备驱动程序中的open()函数。open()函数主要用于初始化设备，为后续的I/O操作做好准备。 3. 设备读写 内核会调用设备驱动程序中的read()和write()函数来读写设备数据。 4. 设备关闭 当用户关闭设备文件时，内核会调用设备驱动程序中的release()函数来释放设备资源。 5. 设备控制 设备驱动程序可以提供ioctl()函数来实现对设备的控制。 6. 设备驱动模块 设备驱动程序通常被编译成内核模块。在加载设备驱动模块时，需要使用insmod命令，卸载时使用rmmod命令。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值