GPIO子系统

最新推荐文章于 2024-04-13 01:18:13 发布
最新推荐文章于 2024-04-13 01:18:13 发布
阅读量159 收藏
点赞数
文章标签： 嵌入式硬件 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yg118/article/details/131668323
版权

在内核模块中启用定时器，让LED1亮1s灭1s

实验效果

在这里插入图片描述
在这里插入图片描述

驱动程序

#include <linux/init.h>
#include <linux/module.h>
#include<linux/of.h>
#include<linux/gpio.h>
#include<linux/of_gpio.h>
#include <linux/timer.h>
/*
   myleds{
       led1=<&gpioe 10 0>;    
       led2=<&gpiof 10 0>; 
       led3=<&gpioe 8 0>;  
    };
*/
struct device_node *dnode;
struct gpio_desc *gpiono;
//分配定时器对象
struct timer_list mytimer;
//定时器处理函数
void mytimer_func(struct timer_list *timer)
{
    //LED1亮1秒灭1秒
    gpiod_set_value(gpiono,!gpiod_get_value(gpiono));
    //再次启用定时器
    mod_timer(timer,jiffies+HZ);
}
static int __init mycdev_init(void)
{
    //初始化定时器对象
    mytimer.expires=jiffies+HZ;//设置定时1S的阈值
    timer_setup(&mytimer,mytimer_func,0);
    //将定时器注册进内核
    add_timer(&mytimer);
    
    //解析led灯的设备树节点
    dnode=of_find_node_by_path("/myleds");
    if(dnode==NULL)
    {
    printk("解析设备树节点失败\n");
    return -ENXIO;
    }
    printk("解析设备树节点成功\n");
      //根据设备树节点解析led1gpio编号
    gpiono=gpiod_get_from_of_node(dnode,"led1",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono))
    {
        printk("gpio编号解析失败\n");
        return -PTR_ERR(gpiono);
    }
    printk("解析gpio编号成功\n");
 
    return 0;
}
static void __exit mycdev_exit(void)
{
    //灭灯
    gpiod_set_value(gpiono,0);
    //释放gpio编号
    gpiod_put(gpiono);
    del_timer(&mytimer);
 
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

基于GPIO子系统完成LED驱动的注册，应用程序测试

实验效果

在这里插入图片描述

驱动程序

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/timer.h>
#include <linux/uaccess.h>
#define LED_ON _IOW('l',1,int)  //开灯
#define LED_OFF _IOW('l',0,int)//关灯

struct cdev *cdev;
unsigned int major = 500;
unsigned int minor = 0;
dev_t devno;
struct class *cls;
struct device *dev;
char kbuf[128] = {0};
struct device_node *dnode;
struct gpio_desc *gpiono1;
struct gpio_desc *gpiono2;
struct gpio_desc *gpiono3;

//封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    unsigned int aaa=MINOR(inode->i_rdev);//得到打开的文件对应的设备号
    file->private_data=(void *)aaa;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int which,ret;
    ret = copy_from_user(&which,(void *)arg,4);
    if(ret)
    {
        printk("Copy to user failed\n");
        return -EIO;
    }
    printk("Copy to user successful\n");

    switch(cmd)
    {
        case LED_ON:
        switch (which)
        {
        case 1:     //亮灯
            gpiod_set_value(gpiono1,1);
            break;
        case 2:     //亮灯
            gpiod_set_value(gpiono2,1);
            break;
        case 3:     //亮灯
            gpiod_set_value(gpiono3,1);
            break;
        default:
            break;
        }
        break;
        case LED_OFF:
        switch(which)
        {
            case 1:
                gpiod_set_value(gpiono1,0);
                break;
            case 2:
                gpiod_set_value(gpiono2,0);
                break;
            case 3:
                gpiod_set_value(gpiono3,0);
                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 ret, i;
    // 1.分配字符设备驱动对象空间  cdev_alloc
    cdev = cdev_alloc();
    if (cdev == NULL)
    {
        printk("申请字符设备驱动对象空间失败\n");
        ret = -EFAULT;
        goto out1;
    }
    printk("字符设备驱动对象申请成功\n");
    // 2.字符设备驱动对象部分初始化  cdev_init
    cdev_init(cdev, &fops);
    // 3.申请设备号  register_chrdev_region/alloc_chrdev_region
    if (major > 0) // 静态申请设备号
    {
        ret = register_chrdev_region(MKDEV(major, minor), 3, "myled");
        if (ret)
        {
            printk("静态指定设备号失败\n");
            goto out2;
        }
    }
    else // 动态申请设备号
    {
        ret = alloc_chrdev_region(&devno, minor, 3, "myled");
        if (ret)
        {
            printk("动态申请设备号失败\n");
            goto out2;
        }
        major = MAJOR(devno); // 根据设备号得到主设备号
        minor = MINOR(devno); // 根据设备号得到次设备号
    }
    printk("申请设备号成功\n");
    // 4.注册字符设备驱动对象  cdev_add()
    ret = cdev_add(cdev, MKDEV(major, minor), 3);
    if (ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto out3;
    }
    printk("注册字符设备驱动对象成功\n");
    // 5.向上提交目录
    cls = class_create(THIS_MODULE, "myled");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret = -PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");
    // 6.向上提交设备节点
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交节点信息失败\n");
            ret = -PTR_ERR(dev);
            goto out5;
        }
    }
    printk("向上提交设备节点信息成功\n");
    // 解析led灯的设备树节点
    dnode = of_find_node_by_name(NULL, "myleds");
    if (dnode == NULL)
    {
        printk("解析设备树节点失败\n");
    }
    printk("解析设备树节点成功\n");
    // 根据设备树节点解析led1gpio编号
    gpiono1 = gpiod_get_from_of_node(dnode,"led1",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono1))
    {
        printk("gpio编号解析失败\n");
        return -PTR_ERR(gpiono1);
    }
    printk("解析gpio1编号成功gpiono1\n");
    // 根据设备树节点解析led2gpio编号
    gpiono2 = gpiod_get_from_of_node(dnode,"led2",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono2))
    {
        printk("gpio编号解析失败\n");
        return -PTR_ERR(gpiono2);
    }
    printk("解析gpio2编号成功gpiono2\n");
    // 根据设备树节点解析led3gpio编号
    gpiono3 = gpiod_get_from_of_node(dnode,"led3",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono3))
    {
        printk("gpio编号解析失败\n");
        return -PTR_ERR(gpiono3);
    }
    printk("解析gpio3编号成功gpiono3\n");
    // 亮灯
    gpiod_set_value(gpiono1, 1);
    // 亮灯
    gpiod_set_value(gpiono2, 1);
    // 亮灯
    gpiod_set_value(gpiono3, 1);
    return 0;

out5:
    for (--i; i >= 0; i--)
    {
        // 销毁上面提交的设备信息
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
out4:
    cdev_del(cdev);
out3:
    unregister_chrdev_region(MKDEV(major, minor), 3);
out2:
    kfree(cdev);
out1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    // 1.销毁设备信息  device_destroy
    int i;
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 2.销毁目录  class_destroy
    class_destroy(cls);
    // 3.注销对象  cdev_del()
    cdev_del(cdev);
    // 4.释放设备号   unregister_chrdev_region()
    unregister_chrdev_region(MKDEV(major, minor), 3);
    // 5.释放对象空间  kfree()
    kfree(cdev);
    // 6.释放gpio编号
    gpiod_put(gpiono1);
    gpiod_put(gpiono2);
    gpiod_put(gpiono3);

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

test.c


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

#define LED_ON _IOW('l', 1, int)
#define LED_OFF _IOW('l', 0, int)

void LED_control()
{
    int a, b;
    char buf[128] = {0};
    int fd_led = open("/dev/myled0", O_RDWR);
    if (fd_led < 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);
        }
    }
    close(fd_led);
}

int main(int argc, char const *argv[])
{
    LED_control();
    return 0;
}
Rain_G_G
关注
zynq的linux驱动4-gpio子系统
01-20
在Zynq平台上，通过Linux驱动4-GPIO子系统，我们可以灵活地控制MIO（Multi-IO）引脚的电平状态，从而实现对硬件设备的控制，比如LED灯的开关。 GPIO驱动的基本工作原理是通过Linux内核的GPIO框架来抽象硬件的GPIO...
【Linux驱动开发】011 gpio子系统
kashine的博客
03-26 2573
上节讲解了 pinctrl 子系统，pinctrl 子系统重点是设置 PIN(有的 SOC 叫做 PAD)的复用和电气属性，如果 pinctrl 子系统将一个 PIN 复用为 GPIO 的话，那么接下来就要用到 gpio 子系统了。gpio 子系统顾名思义，就是用于初始化 GPIO 并且提供相应的 API 函数，比如设置 GPIO为输入输出，读取 GPIO 的值等gpio 子系统的主要目的是：方便驱动开发者使用 gpio，驱动开发者在。
gpio子系统
m0_74321665的博客
07-11 145
在内核模块中启用定时器，让led灯一秒亮，一秒灭。
gpio 子系统
qq_31057589的博客
04-27 1335
在remove函数中，我们使用platform_get_drvdata函数获取保存在platform_device中的GPIO编号，并使用gpio_free函数释放GPIO。在此示例程序中，我们使用了of_property_read_u32和 of_property_read_string函数从设备树节点中读取GPIO编号和方向属性的值。在这个代码中，我们使用了module_platform_driver宏，它自动将gpio_example_driver注册为平台驱动程序，并处理模块的加载和卸载。
GPIO子系统、Pinctrl子系统和Input子系统
蒋楼丶的博客
05-01 342
有gpio驱动程序，那必然也有pinctrl驱动程序，pinctrl驱动程序中实现了PIN的配置方法并，并注册到pinctrl子系统，所以pinctrl驱动程序就负责实现配置PIN的底层代码（主要就是寄存器控制），并注册到内核pinctrl子系统中由pinctrl子系统进行统一管理。Linux内核针对PIN的（复用）配置推出了pinctrl子系统，对于GPIO的配置推出了gpio子系统，所以说到这里就知道了，pinctrl子系统是内核中专门用于管理、配置PIN的一套子系统。Pinctrl子系统。
linux系统gpio子系统使用驱动源码
01-11
以下是对标题和描述中涉及的Linux GPIO子系统使用驱动源码的详细解释： 1. **/dev/gpio节点**： 在Linux中，GPIO接口通常通过虚拟设备文件`/dev/gpio*`提供给用户空间程序。这些设备文件允许用户通过标准文件操作...
4.pinctrl和gpio子系统1
08-03
总结来说，pinctrl子系统和GPIO子系统协同工作，使得在Linux内核中管理硬件资源变得简洁明了，降低了驱动开发的复杂度，同时也提高了代码的可读性和移植性。通过设备树，开发者能够集中精力于应用程序逻辑，而无需...
高通gpio子系统.docx
06-12
### 高通GPIO子系统详解 #### 一、GPIO控制器硬件功能分类 1. **Pin Controller**：这部分硬件主要负责管理引脚的功能设置与特性。软件可通过直接操作Pin Controller内部的寄存器来配置引脚的功能，例如设置引脚的...
ioremap_gpio子系统_中断
01-06
ioremap_gpio子系统_中断 【一】、ioremap void *ioremap(phys_addr_t offset, unsigned long size) 功能：物理地址到虚拟地址映射 参数： @offset 物理地址 @size 映射地址范围 返回值：成功返回映射后的虚拟...
MX6LL|GPIO子系统实战
m0_73731708的博客
09-18 205
GPIO（General Purpose Input/Output）子系统是嵌入式系统中的一个重要组件。它是操作系统内核提供的一个软件接口，用于控制和管理硬件上的通用输入输出引脚。GPIO子系统允许开发人员通过软件控制和配置硬件的输入和输出引脚。每个GPIO引脚可以用作输入或输出，可以用于读取外部设备的输入信号（例如按钮、传感器等）或控制外部设备的输出信号（例如LED、继电器等）。不同的操作系统和开发环境可能会提供不同的GPIO子系统接口和函数库。
【Linux】Linux驱动开发：gpio子系统
W__winter的博客
05-05 2898
在设备树中，“GPIO组”就是一个GPIO Controller，这通常都由芯片厂家设置好。我们要做的是找到它名字，比如“gpio1”，然后指定要用它里面的哪个引脚，比如。如果要操作GPIO引脚的话，需要先将所用引脚配置为GPIO功能，这需要通过Pinctrl子系统来实现。在Pinctrl子系统将引脚配置为GPIO功能后，就可以使用GPIO子系统来设置GPIO的方向等。表示这个节点是一个GPIO Controller，它下面有很多引脚。在根节点下写自己的节点。在根节点下写自己的节点。
Linux驱动之GPIO子系统
Android系统攻城狮
02-19 1253
这里要注意N-MOS管，当设定输出的值为高电平的时候，N-MOS管处于关闭状态，此时I/O口的电平就不会由输出的高低电平决定，而是由I/O口外部的上拉或者下拉决定；当设定输出的值为低电平的时候，N-MOS管处于开启状态，此时I/O口的电平就是低电平。硬件层之上是soc原厂提供的gpio controller驱动这部分提供了具体soc的pin脚的描述和控制接口，在这之上是gpiolib层为其他驱动程序提供统一的接口来配置和控制gpio，再往上就是其他驱动程序使用gpio的接口完成他们想要的工作。
概述gpio子系统工作原理
weixin_44586903的博客
03-08 716
gpio子系统工作原理
深入理解GPIO子系统 嵌入式开发
qq_37934722的博客
08-15 134
嵌入式开发中，与外界通信的关键就在于GPIO（General Purpose Input/Output）子系统。GPIO子系统将IO口抽象为数字I/O口，通过对输出电平电压和输入电平的读取和控制，实现硬件和应用程序的交互。通过GPIO子系统的学习，可以更好地理解嵌入式开发中硬件和软件交互的原理，并借助GPIO实现更丰富的功能。需要注意的是，对GPIO的直接操作需要root权限，否则会出现无法访问GPIO的错误。GPIO子系统的驱动位于内核中，使用内核的GPIO API进行控制和操作。
嵌入式驱动学习第七周——GPIO子系统
最新发布
qq_43419761的博客
04-13 931
gpio子系统用于同意便捷地访问输入输出中断等效果，通常搭配pinctrl子系统使用
Linux gpio 子系统
09-15
Linux的GPIO子系统是一种通过内核驱动来控制通用输入输出（GPIO）引脚的机制。GPIO引脚可以用于连接各种外部设备，如传感器、执行器和其他外设。 在Linux中，GPIO子系统通过提供一组API函数来与GPIO引脚进行交互。开发者可以使用这些API函数来配置引脚的输入输出模式、读取和写入引脚的状态，并注册中断处理程序来处理引脚状态变化时的事件。 GPIO子系统在内核中以驱动程序的形式存在，它通过抽象底层硬件的细节，提供一个统一的接口给用户空间应用程序使用。用户空间应用程序可以通过打开相应的GPIO设备文件，并使用标准的read和write系统调用来与GPIO引脚进行通信。 为了使用GPIO子系统，需要确保内核编译时已启用了相关的配置选项，并加载了相应的GPIO驱动程序。一些常见的GPIO驱动程序包括sysfs-gpio和gpiolib。 总之，Linux的GPIO子系统提供了一种方便和灵活地控制GPIO引脚的方法，使得开发者可以轻松地与外部硬件进行交互。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值