字符设备驱动的实现2-LED灯

已于 2023-08-03 14:23:00 修改
阅读量69 收藏
点赞数
文章标签： linux 驱动开发
于 2023-08-03 11:17:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45192798/article/details/132050717
版权
文章讲述了LED字符设备驱动的实现，涉及地址映射（在open和init中的区别）、GPIO控制以及驱动的初始化过程。介绍了ioremap和iounmap函数在驱动中的使用，以及如何根据调用频率选择在init还是open中进行操作以节省资源。
摘要由CSDN通过智能技术生成

LED的字符设备驱动

RCC_MP_AHB4ENSETR 0x50000a28 [4] 1 GPIOE时钟使能

GPIOx_MODER 0x50006000 [21:20] 01 输出

GPIOx_ODR 0x50006014 [10] 1 LED1亮 0 LED1灭

思考：地址映射和灯的初始化应该放在哪来做？
地址映射可以在open 也可以在init 区别是：
init ：安装的时候地址已经映射完了，灯也初始化好了，卸载的时候地址才会被释放。
open ：当调用open接口的时候才会被映射和初始化，调用close的时候被取消。
驱动调用的频率很低 的情况下在open映射和初始化，节省资源 。
驱动调用的频率很高 的情况下在init映射和初始化。

LED1亮灭相关驱动

myled.h

#ifndef __MYLED_H__
#define __MYLED_H__

#define RCC_ENB 0x50000a28
#define GPIOE_MODER 0x50006000
#define GPIOE_ODR 0x50006014

#endif

myled.c

#include "myled.h"
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#define CNAME "myled"
int major;
char kbuf[128] = { 0 };
unsigned int *rcc, *moder, *odr;
int myled_open(struct inode* inode, struct file* file)
{
    // 1.地址映射
    rcc = ioremap(RCC_ENB, 4);
    if (rcc == NULL) {
        printk("ioremap rcc error\n");
        return -ENOMEM;
    }
    moder = ioremap(GPIOE_MODER, 4);
    if (moder == NULL) {
        printk("ioremap moder error\n");
        return -ENOMEM;
    }
    odr = ioremap(GPIOE_ODR, 4);
    if (moder == NULL) {
        printk("ioremap odr error\n");
        return -ENOMEM;
    }
    // 2.LED1的初始化
    *rcc |= (1 << 4); // gpioe 时钟使能
    *moder &= ~(3 << 20);
    *moder |= (1 << 20); // gpioe10 输出
    *odr &= ~(1 << 10); // gpioe10输出低电平
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t myled_read(struct file* file,
    char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) {
        printk("copy to user error\n");
        return -EIO;
    }
    return size;
}

ssize_t myled_write(struct file* file,
    const char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret) {
        printk("copy from user error\n");
        return -EIO;
    }
    // 通过用户传递的数据控制LED1亮灭
    // kbuf[0]=1 LED1亮   kbuf[0]=0 LED1熄灭
    kbuf[0] == 1 ? (*odr |= (1 << 10)) : (*odr &= ~(1 << 10));
    return size;
}
int myled_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    iounmap(odr);
    iounmap(moder);
    iounmap(rcc);
    return 0;
}
const struct file_operations fops = {
    .open = myled_open,
    .read = myled_read,
    .write = myled_write,
    .release = myled_close,
};
static int __init myled_init(void)
{
    // 1.注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register_chrdev error\n");
        return -EAGAIN;
    }

    printk("register chrdev success,major = %d\n", major);
    return 0;
}
static void __exit myled_exit(void)
{
    // 2.注销字符设备驱动
    unregister_chrdev(major, CNAME);
}
module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");

test.c

#include <head.h>

int main(int argc, const char* argv[])
{
    int fd;
    char buf[1] = { 0 };
    if ((fd = open("/dev/myled", O_RDWR)) == -1)
        PRINT_ERR("open error");
    while (1) {
        buf[0] = !buf[0];
        write(fd, buf, sizeof(buf));
        sleep(1);
    }

    close(fd);
    return 0;
}

测试

make arch=arm modname=myled
arm-linux-gnueabihf-gcc test.c

arm-linux-gnueabihf- 编译器的路径中需要包含test.c中的头文件<head.h>

扩展：
我们在应用层的时候，把<head.h>放在了<stdio.h>头文件的路径下，因为预处理阶段可以自动找到<stdio.h>并展开头文件。我们把<head.h>放在同路径下一定也可以被识别并展开，不会报错。

此时编译器报错是因为在arm-linux-gnueabihf- 中找不到test.c中的头文件<head.h>，
同理我们需要找到<stdio.h>的头文件路径，并且把<head.h>放到同一路径在即可。
我们把arm-linux-gnueabihf- 编译器安装在了 家目录下的toolchain文件
所以需要在 cd ~/toolchain 这个路径下找<stdio.h>的头文件路径

linux@ubuntu:~/toolchain$ find -name stdio.h
./gcc-7.5.0/lib/gcc/arm-linux-gnueabihf/7.5.0/include/ssp/stdio.h
./gcc-7.5.0/arm-linux-gnueabihf/include/c++/7.5.0/tr1/stdio.h
./gcc-7.5.0/arm-linux-gnueabihf/libc/usr/include/bits/stdio.h
./gcc-7.5.0/arm-linux-gnueabihf/libc/usr/include/stdio.h

明显看到 /usr/include/这个路径是我们要找的路径
所以把 head.h 放到 ./gcc-7.5.0/arm-linux-gnueabihf/libc/usr/include/ 路径下即可

linux@ubuntu:~$ cp /usr/include/head.h .
linux@ubuntu:~$ cd toolchain/
linux@ubuntu:~/toolchain$ cd ./gcc-7.5.0/arm-linux-gnueabihf/libc/usr/include/
linux@ubuntu:~/toolchain/gcc-7.5.0/arm-linux-gnueabihf/libc/usr/include$ mv ~/head.h .

以上就把<head.h>头文件放到了可展开的交叉编译器头文件路径下 编译就不会报错了。

测试

cp *.ko a.out ~/rootfs

连接开发板 看现象

在串口工具中

 insmod myled.ko    //安装模块 
 mknod /dev/myled  c 240 0    // 安装结点
 ./a.out

练习：编写字符设备驱动控制三盏亮灭

myled.h

#ifndef __MYLED_H__
#define __MYLED_H__
//c语言中寄存器的封装方式

#define RCC_MP_AHB4ENSETR  0x50000a28
typedef struct
{
    volatile unsigned int MODER;
    volatile unsigned int OTYPER;
    volatile unsigned int OSPEEDR;
    volatile unsigned int PUPDR;
    volatile unsigned int IDR;
    volatile unsigned int ODR;
} gpio_t;
// #define GPIOE ((gpio_t *)0x50006000)   这是一个结构体指针ioremap第一个参数需要的是地址才行
// #define GPIOF ((gpio_t *)0x50007000)
#define GPIOE (0x50006000)
#define GPIOF (0x50007000)

enum leds{   //枚举  循环
    LED1,
    LED2,
    LED3
};
enum led_status{  //开关
    OFF,
    ON
};
#endif

myled.c

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

#define CNAME "myled"
int major;
char kbuf[128]={0};
unsigned int *rcc;
gpio_t * gpioe;  //虚拟地址
gpio_t * gpiof;  //虚拟地址
int mycdev_open(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    //1.地址映射
    rcc=ioremap(RCC_MP_AHB4ENSETR,4);
    if(rcc == NULL){
        printk("ioremap rcc error\n");
        return -ENOMEM;
    }
    gpioe=ioremap(GPIOE,sizeof(gpio_t));
    if(gpioe==NULL){
        printk("ioremap gpioe error\n");
        return -ENOMEM;
    }
    gpiof=ioremap(GPIOF,sizeof(gpio_t));
    if(gpiof==NULL){
        printk("ioremap gpiof error\n");
        return -ENOMEM;
    }

    //2.led灯初始化
    *rcc |= (1<<4);  //gpioe时钟使能
    *rcc |= (1<<5);  //gpiof时钟使能
    gpioe->MODER &= ~(3<<20); //清零moder 21-20bit--led1  PE10
    gpioe->MODER |= (1<<20);  //将gpioe设置为输出---led1
    gpiof->MODER &= ~(3<<20); //清零moder 21-20bit--led2  PF10
    gpiof->MODER |= (1<<20);  //将gpioe设置为输出---led2
    gpioe->MODER &= ~(3<<16); //清零moder 21-20bit--led3  PE8
    gpioe->MODER |= (1<<16);  //将gpioe设置为输出---led3
  
    gpioe->ODR &= ~(1<<10);   //将led1熄灭
    gpiof->ODR &= ~(1<<10);   //将led2熄灭
    gpioe->ODR &= ~(1<<8);   //将led3熄灭
    return 0;
}
ssize_t mycdev_read(struct file*file,
    char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if(size>sizeof(kbuf))
        size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret){
        printk("copy_to_user error\n");
        return -EIO;
    }
    return size;  //如果成功的话返回size
}
ssize_t mycdev_write(struct file*file,
    const char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if(size>sizeof(kbuf))
        size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret){
        printk("copy_from_user error\n");
        return -EIO;
    }
    //写1 LED1亮 写0 LED1 灭
    //(*(int *)kbuf == 1)?(*odr |= (1<<10)):(*odr &= ~(1<<10));

    (kbuf[0]==LED1 && kbuf[1]==ON)?(gpioe->ODR |= (1<<10) ):(gpioe->ODR &= ~(1<<10));
    (kbuf[0]==LED2 && kbuf[1]==ON)?(gpiof->ODR |= (1<<10) ):(gpiof->ODR &= ~(1<<10));
    (kbuf[0]==LED3 && kbuf[1]==ON)?(gpioe->ODR |= (1<<8) ):(gpioe->ODR &= ~(1<<8));

    return size;
}
int mycdev_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    // 取消地址映射
    iounmap(rcc);
    iounmap(gpioe);
    iounmap(gpiof);
    return 0;
}
const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};
static int __init mycdev_init(void)
{
    // 1.注册字符设备驱动 register_chrdev
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register_chrdev error\n");
        return major;
    }
    printk("register char device driver success,major = %d\n", major);
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 2.注销字符设备驱动  unregister_chrdev
    unregister_chrdev(major, CNAME);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

test.c

#include <head.h>
#include "myled.h"
void led_blink(int fd, int which)
{
    char ubuf[2] = { which, ON };
    write(fd, ubuf, sizeof(ubuf));
    sleep(1);
    ubuf[1] = OFF;
    write(fd, ubuf, sizeof(ubuf));
    sleep(1);
}

int main(int argc,const char * argv[])
{
    int fd;
    if((fd = open("/dev/myled",O_RDWR))==-1)
        PRINT_ERR("open error");
    while(1){
        led_blink(fd,LED1);
        led_blink(fd,LED2);
        led_blink(fd,LED3);
    }
    
    close(fd);
    return 0;
}
LED_t
关注
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
本文将深入探讨一种特定类型的驱动——LED字符设备驱动，特别是基于平台驱动的实现，以及如何支持多个LED灯。 首先，我们要理解什么是Linux平台驱动。在Linux内核中，平台驱动是一种通用的驱动模型，用于处理那些...
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，体现Linux驱动的分层设计思想
03-04
整个驱动分为三个部分，板级驱动(led_dev.c)定义板级资源，芯片级驱动(led_imx6ull.c)定义了芯片相关的结构和操作，系统级驱动(leddrv.c)定义了字符设备相关的接口。更改硬件只需要替换led_dev.c，更换芯片需要替换...
字符设备驱动应用---LED设备驱动实现
终南樵夫
12-01 1119
编写基于字符设备的LED驱动，并且编写用户代码测试驱动
Linux -- 字符设备驱动--LED的驱动开发
qq_47258284的博客
04-07 997
有入口函数就应该有出口函数：卸载驱动程序时，出口函数调用 unregister_chrdev。驱动层访问硬件外设寄存器依靠的是 ioremap 函数去映射到寄存器地址，然后开始控制寄存器。引脚操作那么有规律，并且这是跟主芯片相关的，那可以针对该芯片写出比较通用的硬件操作代码。得有一个入口函数：安装驱动程序时，就会去调用这个入口函数；看主芯片手册，确定寄存器操作方法：哪些寄存器？ioremap 映射寄存器的物理地址得到虚拟地址，读写虚拟地址。中指定使用哪一个引脚即可。编写驱动：先写框架，再写硬件操作的代码。
字符设备驱动开发-注册-设备文件创建
m0_74937538的博客
12-22 1759
一、字符设备驱动linux系统中一切皆文件1、应用层： APP1 APP2 ...fd = open("led驱动的文件"，O_RDWR);read(fd);write();close();2、内核层：对灯写一个驱动//（close）cdev:设备号1 设备号2 设备号n设备驱动1 设备驱动2 ....设备驱动n设备号：32位，无符号数字高12位 ：主设备号 ：区分哪一类设备。
linux驱动-字符设备-imx6ull-led
weixin_46388080的博客
09-24 1656
将arch/arm/configs目 录 下 的 imx_v7_mfg_defconfig 重 新 复 制 一 份 , 命 名 为imx_alientek_emmc_defconfig。
字符设备驱动实例（LED、按键、input输入子系统）
qq_52479948的博客
08-17 871
本章综合前面的知识，实现了嵌入式系统的常见外设驱动，包括 LED、按键、ADC、PWM和RTC。本章从工程的角度、实用的角度探讨了某些驱动的实现。比如LED 只是编写了设备树节点，设备就能被正常驱动，按键驱动则分别讨论了基于中断的和基于输入子系统的，还特别讨论了按键的消抖处理。不仅如此，本章还引入了一些新的知识，比如内核统一 GPIO 接口、时钟子系统、pinctrl 子系统等。本章虽然叫“字符设备驱动实例”，但是有些设备并没有实现为字符设备，而是通过 sysfs 文件系统接口来操作的。
9.1 字符设备驱动开发
Toutiegongzhu的博客
12-14 1041
字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、 IIC、 SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。Linux 应用程序对驱动程序的调用：驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx” (xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。
【嵌入式环境下linux内核及驱动学习笔记-（3-字符设备驱动详解）】
weixin_45499326的博客
04-10 2180
项目说明语法功能将主设备号和次设备号转换成dev_t类型头文件参数major为主设备号，minor为次设备号宏定义返回值成功执行返回dev_t类型的设备编号变量用途说明设备号，标识设备的身份标号，可以解析出主设备号与次设备号创建于驱动加载之时，也存于cdev结构体内表示设备的结构体，将设备号与操作函数结构体file_operations关联起来创建于驱动加载之时，加载到内核的cdev链表中驱动实际操作的函数入口，是具体的设备驱动函数集合的入口。
Linux字符设备驱动编写流程-----附源码实例
chery_cwf的博客
08-11 2443
字符设备驱动模型 -------- 创建普通字符设备驱动模型 --------- ①定义一个字符设备------&amp;amp;gt;struct cdev ②定义并初始化一个文件操作集------&amp;amp;gt;struct file_operations ③为字符设备申请设备号 ③初始化字符设备------&amp;amp;gt;cdev_init(struct cdev*, struct file_operations*); ...
嵌入式Linux（7）： 字符设备LED驱动
weixin_44903006的博客
05-10 597
嵌入式Linux驱动开发（2）：字符设备LED驱动Linux 下 LED 灯驱动原理I/O 内存访问函数实验1、建立工程2、编写驱动程序led.c3、测试应用程序ledApp.c4、编译驱动程序和编译测试应用程序 Linux 下 LED 灯驱动原理 I.MX6U-ALPHA 开发板上的 LED 连接到 I.MX6ULL 的 GPIO1_IO03 这个引脚上，虚拟地址(VA,Virtual Address)、物理地址(PA， Physcical Address)。对于 32 位的处理器来说，虚拟地址范围是 2
基于树莓派4B的Linux驱动------点亮LED灯
qq_63231786的博客
04-24 2737
基于树莓派4B的Linux驱动------点亮LED灯 美好的一天从点灯开始 学好Linux驱动从点灯大师做起 本人也是接触Linux不久，可能有些问题也没考虑到，以下仅是个人观点，欢迎留言，共同进步，话不多说，直接步入正题。 一、实验说明 本次实验采用设备树编程 开发板基于树莓派4B linux内核版本：linux-rpi-5.15.y 开发平台：ubuntu交叉编译 LED为高电平点亮 二、修改设备树文件 为了方便，我是直接在根节点下添加一个ledtest节点，要不然放得太深不好找 首先在linux内核
一个最基本的Linux LED字符设备驱动，支持多个LED灯
03-02
在这个特定的案例中，我们关注的是一个基础的Linux LED字符设备驱动，它允许用户通过内核接口控制多个LED灯。下面我们将深入探讨这个驱动的核心概念、设计原则以及实现细节。 首先，字符设备驱动属于Linux设备驱动...
嵌入式Linux LED字符设备驱动，基于平台驱动实现，使用设备树定义LED灯资源，引入pinctrl和gpio子系统
03-15
本主题聚焦于LED字符设备驱动的实现，特别关注如何通过平台驱动、设备树、pinctrl和gpio子系统来控制LED灯。下面将详细阐述这些关键知识点。 **平台驱动（Platform Driver）** 平台驱动是Linux内核中的一种驱动模型...
混杂字符设备之LED设备驱动设计
08-10
主要工作集中在ioctl函数上，这里分为定义命令（如定义ioctl命令常量）和实现命令（根据接收到的命令执行相应的控制逻辑，如打开、关闭LED灯，改变亮度等）。 此外，CPU寄存器和虚拟内存映射分析在设备驱动中扮演着...
Linux编辑/etc/fstab文件不当，不使用快照；进入救援模式
feng68_的博客
11-14 650
如果遇到任何问题，您可能需要进一步的故障排除，比如检查文件系统的完整性或修复文件系统错误。1)当出现以下警告时不要慌，如果文件系统默认挂载为只读模式，将其重新挂载为读写模式就好了，应该是吧。您可以选择1继续，或者选择2以只读模式挂载文件系统，或者选择3跳过直接进入shell。后面加)， 把只读模式改成读写模式 ，然后ctrl+x重启。然后会出现一串红色的字，太快了，看不清，然后就重启成功了。如果您在虚拟控制台（VC）1或VC2中，可以使用。获取root权限，这样您就可以编辑。2）挂载根文件系统为读写模式。
【Linux】多线程（中）
Eristic0618的博客
11-14 1359
本篇文章围绕Linux中的多线程展开讲解，包含线程互斥的概念、互斥量mutex和相关API、互斥量原理、重入和线程安全、死锁、线程同步和条件变量等内容
【Linux】阿里云服务器搭建gradio实例
Explore_Zhou
11-13 1225
因为课程原因，需要做一个大模型相关的大作业，想到之前买的阿里云服务器，便想在服务器基于大模型API部署一个聊天机器人。因为是新手，特地做个记录，供初学者参考。从上面安装的几个软件来看，其实Linux端安装软件还是有规律可循的，主要就是那么几步：configure，make，make installlink1link2。
Linux从入门到精通
最新发布
qq_54384621的博客
11-16 366
Linux的图形化界面并不稳定，因此往往使用命令行去接触Linux操作系统在linux的terminal终端中输入指令ifconfig就可以获取到本机的ip地址了。然后通过finalshell配置好相关的信息连接上就可以直接使用了。拓展：WSL获取轻量化虚拟机WSL全称为windows subsystem for linux可以在windows中获取linux系统环境并完全直连计算机硬件，无需通过虚拟机的虚拟硬件，因此完全可以替换掉vmware打开方式:1右键开始找到应用与功能。
Linux字符设备驱动开发：LED灯控制编程
在嵌入式Linux系统中，字符设备驱动是操作系统与外部硬件通信的一个基础组件，它负责控制硬件设备如LED灯。字符设备与块设备不同，它在被访问时产生数据流，这些数据流被读取或写入而无需进行缓冲。在本压缩包中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值