GPIO子系统

于 2024-07-24 20:19:26 发布
阅读量469 收藏 11
点赞数 13
文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xace007/article/details/140644799
版权

1. GPIO子系统视频概述

1.1 GPIO子系统的作用

芯片内部有很多引脚，这些引脚可以接到GPIO模块，也可以接到I2C等模块。

通过Pinctrl子系统来选择引脚的功能(mux function)、配置引脚：

当一个引脚被复用为GPIO功能时，我们可以去设置它的方向、设置/读取它的值。

GPIO名为"General Purpose Input/Output"，通用目的输入/输出，就是常用的引脚。

GPIO可能是芯片自带的，也可能通过I2C、SPI接口扩展：

GPIO有一些通用功能、通用属性。

1.2 通用功能

  • 可以设为输出：让它输出高低电平；

  • 可以设为输入，读取引脚当前电平；

  • 可以用来触发中断

对于芯片自带的GPIO，它的访问时很快的，可以在获得spinlocks的情况下操作它。

但是，对于通过I2C、SPI等接口扩展的GPIO，访问它们时可能导致休眠，所以这些"GPIO Expander"就不能在获得spinlocks的情况下使用。

1.3 通用属性

  • Active-High and Active-Low

    以LED为例，需要设置GPIO电平。但是有些电路可能是高电平点亮LED，有些是低电平点亮LED。

    可以使用如下代码：

gpiod_set_value(gpio, 1);  // 输出高电平点亮LED
gpiod_set_value(gpio, 0);  // 输出低电平点亮LED

对应同一个目标：点亮LED，对于不同的LED，就需要不同的代码，原因在于上面的代码中1、0表示的是"物理值"。

如果能使用"逻辑值"，同样的逻辑值在不同的配置下输出对应的物理值，就可以保持代码一致，比如：

gpiod_set_value(gpio, 1);  // 输出逻辑1
                           // 在Active-High的情况下它会输出高电平
                           // 在Active-Low的情况下它会输出低电平

  • Open Drain and Open Source

    有多个GPIO驱动同时驱动一个电路时，就需要设置Open Drain或Open Source。

    • Open Drain：引脚被设置为低电平时才会驱动电路，典型场景是I2C接口。

    • Open Source：引脚被设置为高电平时才会驱动电路

1.4 GPIO子系统的作用

管理GPIO，既能支持芯片本身的GPIO，也能支持扩展的GPIO。

提供统一的、简便的访问接口，实现：输入、输出、中断。

2. GPIO子系统层次与数据结构

2.1 GPIO子系统的层次

2.1.1 层次

2.1.2 GPIOLIB向上提供的接口

概述：向上接口主要有几类：获得GPIO,设置方向，读值写值，释放GPIO;

在Linux内核中，GPIOLIB 是一个通用的 GPIO (通用输入输出) 抽象层，它提供了一组 API 供驱动程序和用户空间程序使用。以下是 GPIOLIB 向上提供的主要接口及其说明：

  1. gpio_request:

    • 请求一个GPIO引脚。如果成功，内核将保留该引脚供请求者使用，并返回一个唯一的GPIO编号。

  2. gpio_free:

    • 释放一个之前请求的GPIO引脚，使其可供其他驱动程序使用。

  3. gpio_direction_input:

    • 将GPIO引脚配置为输入模式。

  4. gpio_direction_output:

    • 将GPIO引脚配置为输出模式，并可选地设置初始输出值。

  5. gpio_get_value:

    • 读取GPIO引脚的输入值。

  6. gpio_set_value:

    • 写入GPIO引脚的输出值。

  7. gpio_get_value_cansleep:

    • 与gpio_get_value类似，但此函数可以在睡眠上下文中使用。

  8. gpio_set_value_cansleep:

    • 与gpio_set_value类似，但此函数可以在睡眠上下文中使用。

  9. gpio_cansleep:

    • 检查对GPIO引脚的操作是否可以在睡眠上下文中执行。

  10. gpio_to_irq:

    • 将GPIO引脚转换为中断号，以便可以请求中断。

  11. irq_to_gpio:

    • 将中断号转换回GPIO引脚。

  12. gpiochip_add:

    • 注册一个gpio_chip结构体，它描述了一组GPIO引脚及其操作函数。

  13. gpiochip_remove:

    • 移除之前注册的gpio_chip。

  14. gpiochip_line_config:

    • 配置gpio_chip中的特定引脚。

  15. gpiochip_request_own:

    • 请求对gpio_chip中的引脚的所有权。

  16. gpiochip_request_unown:

    • 释放对gpio_chip中的引脚的所有权。

  17. gpiochip_set:

    • 为gpio_chip中的多个引脚设置值。

  18. gpiochip_clear:

    • 清除gpio_chip中的多个引脚的值。

  19. gpiochip_set_direction:

    • 为gpio_chip中的多个引脚设置方向。

  20. gpiochip_get_direction:

    • 获取gpio_chip中引脚的方向。

这些接口为内核中的驱动程序提供了一种通用的方式来操作硬件GPIO引脚，同时隐藏了具体的硬件细节。此外，GPIOLIB 还提供了一些辅助函数，用于处理GPIO引脚的请求和释放，以及配置引脚的输入/输出模式。

2.1.3 GPIOLIB向下提供的接口

概述：获得引脚，释放引脚，配置引脚，读取\写入值，清除引脚，获取地址，获取标签（信息），配置中断

  1. chip.request:

    • 用于请求一个 GPIO 引脚。硬件驱动程序需要实现此函数来请求并分配一个 GPIO 引脚。

  2. chip.free:

    • 用于释放一个之前请求的 GPIO 引脚。硬件驱动程序需要实现此函数来释放并回收该引脚。

  3. chip.direction_input:

    • 配置 GPIO 引脚为输入模式。硬件驱动需要实现此函数来设置引脚方向。

  4. chip.direction_output:

    • 配置 GPIO 引脚为输出模式，并可设置初始输出值。硬件驱动需要实现此函数。

  5. chip.get:

    • 读取 GPIO 引脚的值。硬件驱动需要实现此函数来返回引脚的当前状态。

  6. chip.set:

    • 向 GPIO 引脚写入高电平。硬件驱动需要实现此函数来设置引脚状态。

  7. chip.clear:

    • 向 GPIO 引脚写入低电平。硬件驱动需要实现此函数来清除引脚状态。

  8. chip.set_config:

    • 配置 GPIO 引脚的参数，如上拉/下拉、驱动强度等。硬件驱动需要实现此函数。

  9. chip.to_irq:

    • 如果支持，将 GPIO 引脚转换为中断号。硬件驱动需要实现此函数。

  10. chip.dbg_show:

    • 用于调试目的，显示 GPIO 引脚的状态。硬件驱动可以提供此函数。

  11. chip.label:

    • 获取 GPIO 芯片的标签。硬件驱动需要提供此函数。

  12. chip.base:

    • 获取 GPIO 芯片的基地址，通常用于芯片注册。

  13. chip.ngpio:

    • 获取 GPIO 芯片支持的 GPIO 引脚数量。

  14. chip.parent:

    • 获取 GPIO 芯片的父设备，通常用于设备树集成。

  15. chip.of_node:

    • 获取 GPIO 芯片的设备树节点。

  16. chip.of_xlate:

    • 用于设备树中 GPIO 引脚的转换，硬件驱动需要实现此函数。

这些接口定义在 struct gpio_chip 结构体中，硬件平台的 GPIO 驱动程序需要填充这个结构体并实现相应的函数。这样，GPIOLIB 可以与底层硬件交互，而上层的驱动程序和应用程序则可以使用 GPIOLIB 提供的通用接口来操作 GPIO 引脚。

2.2 重要的3个核心数据结构

记住GPIO Controller的要素，这有助于理解它的驱动程序：

  • 一个GPIO Controller里有多少个引脚？有哪些引脚？

  • 需要提供函数，设置引脚方向、读取/设置数值

  • 需要提供函数，把引脚转换为中断

以Linux面向对象编程的思想，一个GPIO Controller必定会使用一个结构体来表示，这个结构体必定含有这些信息：

  • GPIO引脚信息

  • 控制引脚的函数

  • 中断相关的函数

2.2.1 gpio_device

每个GPIO Controller用一个gpio_device来表示：

  • 里面每一个gpio引脚用一个gpio_desc来表示

  • gpio引脚的函数(引脚控制、中断相关)，都放在gpio_chip里

2.2.2 gpio_chip

我们并不需要自己创建gpio_device，编写驱动时要创建的是gpio_chip，里面提供了：

  • 控制引脚的函数

  • 中断相关的函数

  • 引脚信息：支持多少个引脚？各个引脚的名字？

（实现GPIOLIB向下提供的接口函数） 

 

2.2.3 gpio_desc 

我们去使用GPIO子系统时，首先是获得某个引脚对应的gpio_desc。

gpio_device表示一个GPIO Controller，里面支持多个GPIO。

在gpio_device中有一个gpio_desc数组，每一引脚有一项gpio_desc。

2.3  怎么编写GPIO Controller驱动程序

分配、设置、注册gpioc_chip结构体，示例：drivers\gpio\gpio-74x164.c

3. 编写一个虚拟GPIO控制器的驱动程序

概述：核心：分配/设置/注册一个gpio_chip结构体。

头文件支持，定义全局变量结构体指针chip（）

定义一个全局变量用于模拟GPIO的

#include <linux/module.h>      // 模块化编程支持
#include <linux/err.h>         // 错误处理
#include <linux/init.h>        // 模块初始化和清理宏
#include <linux/io.h>          // IO操作
#include <linux/mfd/syscon.h>  // 系统控制
#include <linux/of.h>          // 设备树操作
#include <linux/of_device.h>    // 设备树设备操作
#include <linux/of_address.h>  // 设备树地址解析
#include <linux/gpio/consumer.h> // GPIO消费者
#include <linux/gpio/driver.h>  // GPIO驱动
#include <linux/slab.h>        // 内存分配
#include <linux/regmap.h>      // 寄存器映射

static struct gpio_chip * g_virt_gpio; // 定义一个全局的gpio_chip指针
static int g_gpio_val = 0;             // 定义一个全局变量，用于模拟GPIO值

 定义设备树匹配表，设置GPIO属性->方向（输入和输出），获取GPIO的值，设置GPIO的值

// 设备树匹配表
static const struct of_device_id virtual_gpio_of_match[] = {
    { .compatible = "100ask,virtual_gpio", },
    { },
};

// 设置GPIO方向为输出
static int virt_gpio_direction_output(struct gpio_chip *gc,
        unsigned offset, int val)
{
    printk("set pin %d as output %s\n", offset, val ? "high" : "low");
    return 0;
}

// 设置GPIO方向为输入
static int virt_gpio_direction_input(struct gpio_chip *chip,
                unsigned offset)
{
    printk("set pin %d as input\n", offset);
    return 0;
}

// 获取GPIO值
static int virt_gpio_get_value(struct gpio_chip *gc, unsigned offset)
{
    return (g_gpio_val & (1<<offset)) ? 1 : 0;
}

// 设置GPIO值
static void virt_gpio_set_value(struct gpio_chip *gc,
        unsigned offset, int val)
{
    if (val)
        g_gpio_val |= (1 << offset);
    else
        g_gpio_val &= ~(1 << offset);
}

 平台驱动探测函数：分配，设置（设置函数，设置值），注册（在内核中添加身份信息）

// 平台设备探测函数
static int virtual_gpio_probe(struct platform_device *pdev)
{
    int ret;
    
    printk(KERN_INFO "%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    
    /* 1. 分配gpio_chip */
    g_virt_gpio = devm_kzalloc(&pdev->dev, sizeof(*g_virt_gpio), GFP_KERNEL);
    
    /* 2. 设置gpio_chip */
    
    /* 2.1 设置函数 */
    g_virt_gpio->label = pdev->name;
    g_virt_gpio->direction_output = virt_gpio_direction_output;
    g_virt_gpio->direction_input  = virt_gpio_direction_input;
    g_virt_gpio->get = virt_gpio_get_value;
    g_virt_gpio->set = virt_gpio_set_value;
    
    g_virt_gpio->parent = &pdev->dev;
    g_virt_gpio->owner = THIS_MODULE;
    
    /* 2.2 设置base、ngpio值 */
    g_virt_gpio->base = -1;
    ret = of_property_read_u32(pdev->dev.of_node, "ngpios", &g_virt_gpio->ngpio);
    
    /* 3. 注册gpio_chip */
    ret = devm_gpiochip_add_data(g_virt_gpio, NULL);
    
    return 0;
}

定义平台设备移除函数，定义虚拟GPIO驱动结构体，定义入口函数（注册平台驱动），出口函数（反注册平台驱动），

// 平台设备移除函数
static int virtual_gpio_remove(struct platform_device *pdev)
{
    printk(KERN_INFO "%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

// 虚拟GPIO驱动结构体
static struct platform_driver virtual_gpio_driver = {
    .probe = virtual_gpio_probe,
    .remove = virtual_gpio_remove,
    .driver = {
        .name = "100ask_virtual_gpio",
        .of_match_table = of_match_ptr(virtual_gpio_of_match),
    }
};

/* 1. 入口函数 */
static int __init virtual_gpio_init(void)
{    
    printk(KERN_INFO "%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    /* 1.1 注册一个platform_driver */
    return platform_driver_register(&virtual_gpio_driver);
}

/* 2. 出口函数 */
static void __exit virtual_gpio_exit(void)
{
    printk(KERN_INFO "%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    /* 2.1 反注册platform_driver */
    platform_driver_unregister(&virtual_gpio_driver);
}

module_init(virtual_gpio_init);
module_exit(virtual_gpio_exit);

MODULE_LICENSE("GPL");

4. GPIO子系统与Pinctrl子系统的交互

4.1 使用GPIO前应该设置Pinctrl

假设使用这个虚拟的GPIO Controller的pinA来控制LED：

要使用pinA来控制LED，首先要通过Pinctrl子系统把它设置为GPIO功能，然后才能设置它为输出引脚、设置它的输出值。

所以在设备树文件里，应该添加Pinctrl的内容：

virtual_pincontroller {
	compatible = "100ask,virtual_pinctrl";
	myled_pin: myled_pin {
			functions = "gpio";
			groups = "pin0";
			configs = <0x11223344>;
	};
};

gpio_virt: virtual_gpiocontroller {
	compatible = "100ask,virtual_gpio";
    gpio-controller;
    #gpio-cells = <2>;
    ngpios = <4>;
};

myled {
	compatible = "100ask,leddrv";
	led-gpios = <&gpio_virt 0 GPIO_ACTIVE_LOW>;
	pinctrl-names = "default";
	pinctrl-0 = <&myled_pin>;	
};

这段代码包含了三个主要部分，分别定义了三个不同的设备节点，它们在设备树（Device Tree）中用于描述硬件设备的配置和它们之间的关系。以下是对每个部分的解释：

  1. virtual_pincontroller 节点：

    • compatible 属性指定了设备的兼容字符串，用于确定使用哪个驱动程序。
    • myled_pin 是一个子节点，代表一个具体的引脚配置。
    • functions 属性定义了引脚的复用功能，这里是 "gpio"，表示该引脚被用作通用输入输出。
    • groups 属性指定了引脚组，这里是 "pin0"。
    • configs 属性提供了引脚的配置参数，这里使用了一个32位的十六进制数 0x11223344。

  2. gpio_virt 节点：

    • 同样使用 compatible 属性来指定驱动程序。
    • gpio-controller 表示这是一个GPIO控制器。
    • #gpio-cells 属性定义了每个GPIO引脚需要多少个单元来描述，这里是 <2>，通常表示一个单元用于GPIO号，另一个用于标志。
    • ngpios 属性定义了控制器拥有的GPIO引脚数量，这里是 <4>，表示有4个GPIO引脚。
    • 这个节点可能与 virtual_pincontroller 节点相关联，用于控制引脚的GPIO功能。

  3. myled 节点：

    • compatible 属性指定了LED驱动的兼容字符串。
    • led-gpios 属性定义了控制LED的GPIO引脚，格式为 <&gpio_virt 0 GPIO_ACTIVE_LOW>，表示使用 gpio_virt 控制器的第0号引脚，且为低电平有效。
    • pinctrl-names 和 pinctrl-0 属性用于指定引脚控制的名称和默认配置，这里引用了 myled_pin 节点。

设备树节点之间的关系：

  • gpio_virt 节点定义了一个GPIO控制器，它可能控制着一些物理或虚拟的GPIO引脚。
  • myled 节点定义了一个LED设备，它使用 gpio_virt 控制器的第0号引脚来控制LED的开关。
  • virtual_pincontroller 节点定义了一个虚拟的引脚控制器，它可能用于更复杂的引脚控制逻辑，比如配置引脚的复用功能、配置参数等。

代码作用：

  • 这段设备树配置告诉内核如何初始化和配置相关的硬件设备，特别是如何将特定的GPIO引脚配置为控制LED，并指定了引脚的其他配置参数。
  • 当内核启动时，它将解析设备树中的这些节点，并根据这些信息加载相应的驱动程序，初始化硬件设备。

在嵌入式Linux系统中，设备树是一种重要的机制，用于描述硬件设备的配置，特别是在没有BIOS或UEFI等传统固件的情况下。设备树允许内核以一种硬件无关的方式来初始化和控制硬件设备。

但是很多芯片，并不要求在设备树中把把引脚复用为GPIO功能。

比如STM32MP157，在它的设备树工具STM32CubeMX即使把引脚配置为GPIO功能，它也不会在设备树中出现。

原因在于：GPIO走了后门。

现实的芯片中，并没有Pinctrl这样的硬件，它的功能大部分是在GPIO模块中实现的。

Pinctrl是一个软件虚拟处理的概念，它的实现本来就跟GPIO密切相关。

甚至一些引脚默认就是GPIO功能。

按理说：

一个引脚可能被用作GPIO，也可能被用作I2C，GPIO和I2C这些功能时相同低位的。

要用作GPIO，需要先通过Pinctrl把引脚复用为GPIO功能。

但是Pinctrl和GPIO关系密切，当你使用gpiod_get获得GPIO引脚时，它就偷偷地通过Pinctrl把引脚复用为GPIO功能了。

4.2 GPIO和Pinctrl的映射关系

从上图可知：

  • 左边的Pinctrl支持8个引脚，在Pinctrl的内部编号为0~7

  • 图中有2个GPIO控制器

    • GPIO0内部引脚编号为0~3，假设在GPIO子系统中全局编号为100~103

    • GPIO1内部引脚编号为0~3，假设在GPIO子系统中全局编号为104~107

  • 假设我们要使用pin1_1，应该这样做：

    • 根据GPIO1的内部编号1，可以换算为Pinctrl子系统中的编号5

    • 使用Pinctrl的函数，把第5个引脚配置为GPIO功能

数据结构

 

4.3 GPIO调用Pinctrl的过程

GPIO子系统中的request函数，用来申请某个GPIO引脚，

它会导致Pinctrl子系统中的这2个函数之一被调用：pmxops->gpio_request_enable或pmxops->request

调用关系如下：

gpiod_get
    gpiod_get_index
    	desc = of_find_gpio(dev, con_id, idx, &lookupflags);
		ret = gpiod_request(desc, con_id ? con_id : devname);
					ret = gpiod_request_commit(desc, label);
								if (chip->request) {
                                    ret = chip->request(chip, offset);
                                }

这段代码片段是Linux内核中使用GPIO描述符（gpiod）API处理GPIO线的一部分。这个API用于以更抽象的方式处理GPIO，允许更好的硬件抽象，使跨不同硬件平台的GPIO操作变得更容易。以下是每个函数的作用详解：。

- `gpiod_get_index` 函数可能是获取特定索引GPIO线GPIO描述符的包装器或过程的一部分。
- `of_find_gpio` 函数使用设备树根据设备和连接ID找到GPIO描述符。
- `gpiod_request` 函数使用描述符请求GPIO线，并为GPIO线的使用请求一个标签。
- `gpiod_request_commit` 函数提交GPIO请求，使GPIO线准备好使用。
- 如果GPIO芯片有一个自定义的请求函数 (`chip->request`)，这里会调用它来执行任何必要的硬件特定设置。

这段代码片段是通常涉及配置GPIO线（例如，将其设置为输入或输出，配置上拉/下拉电阻等）并然后用于其预定目的（例如，从传感器读取输入，驱动LED等）的更大过程中的一部分。确切的实现细节可以根据硬件平台和正在使用的GPIO线的具体要求而有所不同。
 

我们编写GPIO驱动程序时，所设置chip->request函数，一般直接调用gpiochip_generic_request，它导致Pinctrl把引脚复用为GPIO功能。

gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
    pinctrl_request_gpio(chip->gpiodev->base + offset)
		ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range); // gpio是引脚的全局编号

		/* Convert to the pin controllers number space */
		pin = gpio_to_pin(range, gpio);
    	
		ret = pinmux_request_gpio(pctldev, range, pin, gpio);
					ret = pin_request(pctldev, pin, owner, range);

代码流程解释：

  • gpiochip_generic_request 函数被调用以请求一个GPIO。
  • pinctrl_request_gpio 函数使用设备的基地址和GPIO偏移量来计算全局GPIO编号。
  • pinctrl_get_device_gpio_range 函数根据全局GPIO编号获取引脚控制器设备和GPIO的编号范围。
  • 通过gpio_to_pin将全局GPIO编号转换为引脚控制器的编号空间。
  • pinmux_request_gpio 函数请求引脚复用，确保引脚可以被用作所需的功能。
  • pin_request 函数在引脚控制器中实际请求引脚，保留它并标记为已使用。

这个过程是Linux内核中处理GPIO请求的标准方式，确保了在不同硬件平台上对GPIO的请求是统一和一致的。通过这种方式，驱动程序可以请求和使用GPIO，而不必担心底层硬件的具体细节。

Pinctrl子系统中的pin_request函数就会把引脚配置为GPIO功能：

static int pin_request(struct pinctrl_dev *pctldev,
		       int pin, const char *owner,
		       struct pinctrl_gpio_range *gpio_range)
{
    const struct pinmux_ops *ops = pctldev->desc->pmxops;
    
	/*
	 * If there is no kind of request function for the pin we just assume
	 * we got it by default and proceed.
	 */
	if (gpio_range && ops->gpio_request_enable)
		/* This requests and enables a single GPIO pin */
		status = ops->gpio_request_enable(pctldev, gpio_range, pin);
	else if (ops->request)
		status = ops->request(pctldev, pin);
	else
		status = 0;
}

这段代码是一个名为 pin_request 的静态函数，它的作用是请求（reserve）一个特定的引脚（pin），以供驱动程序或其他用途使用。

这个 pin_request 函数是引脚控制子系统中的一个关键组件，它确保了对特定引脚的独占访问，防止多个驱动程序同时使用同一个引脚。这是嵌入式系统和硬件抽象中常见的需求，特别是在多个硬件设备可能需要使用相同物理引脚的情况下。

xace007
关注
  • 13
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
zynq的linux驱动4-gpio子系统
01-20
在Zynq平台上，通过Linux驱动4-GPIO子系统，我们可以灵活地控制MIO（Multi-IO）引脚的电平状态，从而实现对硬件设备的控制，比如LED灯的开关。 GPIO驱动的基本工作原理是通过Linux内核的GPIO框架来抽象硬件的GPIO...
linux系统gpio子系统使用驱动源码
01-11
以下是对标题和描述中涉及的Linux GPIO子系统使用驱动源码的详细解释： 1. **/dev/gpio节点**： 在Linux中，GPIO接口通常通过虚拟设备文件`/dev/gpio*`提供给用户空间程序。这些设备文件允许用户通过标准文件操作...
gpio 子系统
qq_31057589的博客
04-27 1222
在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注册为平台驱动程序，并处理模块的加载和卸载。
【Linux驱动】GPIO子系统
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
05-20 716
GPIO 子系统在之前的内核中也是存在的，但是 pinctrl 子系统的加入 GPIO 子系统也是有很大的改变。之前我们控制一个 GPIO 可以直接来操作我们的寄存器，还有一种方法是使用 SOC 厂家实现的配置函数，例如三星的配置函数为 s3c_gpio_cfgpin 等，这样带来的问题就是各家有各家的接口函数与实现方式，不但内核的代码复用率低而且开发者很难记住这么多的函数，如果要使用多种平台的话背函数都是很麻烦的，所以在引入设备树后对 GPIO 子系统进行了大的改造，使用设备树来实现并提供统一的接口。
gpio子系统
那可真是太开心了的博客
06-29 1503
gpio子系统简介 如果pinctrl子系统将一个PIN复用为GPIO的话，就要用到GPIO子系统。gpio 子系统顾名思义，就是用于初始化 GPIO 并且提供相应的 API 函数，比如设置 GPIO为输入输出，读取 GPIO 的值等。 gpio 子系统的主要目的就是方便驱动开发者使用 gpio，驱动开发者在设备树中添加 gpio 相关信息，然后就可以在驱动程序中使用 gpio 子系统提供的 API函数来操作 GPIO， Linux 内核向驱动开发者屏蔽掉了 GPIO 的设置过程，极大的方便了驱动开发者使用
pinctrl和gpio子系统
qq_39842609的博客
05-01 548
pinctrl和gpio子系统介绍和例程举例
4.pinctrl和gpio子系统1
08-03
总结来说，pinctrl子系统和GPIO子系统协同工作，使得在Linux内核中管理硬件资源变得简洁明了，降低了驱动开发的复杂度，同时也提高了代码的可读性和移植性。通过设备树，开发者能够集中精力于应用程序逻辑，而无需...
ioremap_gpio子系统_中断
01-06
ioremap_gpio子系统_中断 【一】、ioremap void *ioremap(phys_addr_t offset, unsigned long size) 功能：物理地址到虚拟地址映射 参数： @offset 物理地址 @size 映射地址范围 返回值：成功返回映射后的虚拟...
GPIO子系统框架.txt
12-15
GPIO子系统框架.txt
Linux网络命令
Xpccccc的博客
07-19 491
Linux网络命令
基于单片机的智能台灯设计
weixin_45905610的博客
07-17 403
随着电子产品智能化的发展，生活中人们使用的照明工具也逐渐智能化，功能也越来越丰富。 本文介绍了使用单片机进行可调光台灯系统的设计。 通过控制单片机输出高低电平的持续时间，从而改变 PWM 的占空比，实现台灯亮度的调节。
MCU常见相关术语缩写说明
GY3509
07-17 512
MCU常见相关术语缩写说明
灵动微单片机SPI LCD彩屏方案优势
EVERSPIN的博客
07-17 211
代理RAMSUN介绍使用灵动微MM32 MCU特殊的SPI控制技术，结合软件处理算法，能够实现高效的刷屏技术的SPI LCD彩屏参考方案。此方案基于MM32 MCU特殊的SPI控制技术，结合软件处理算法，实现方式灵活，外围电路易实现，控制简单，非常利于自动化生产测试，可以大大的缩短了产品样机调试的周期。•使用MM32 MCU特殊的SPI控制技术，结合软件处理算法，1个SPI接口的MCU也能实现高效刷屏效果。•支持所有3线/4线SPI接口的LCD彩屏，客户可根据LCD彩屏的驱动、显示分辨率选择适合的MCU。
51单片机嵌入式开发：14、STC89C52RC 之HX1838红外解码NEC+数码管+串口打印+LED显示
sinat_30943509的博客
07-21 2168
对于C51单片机的设计思路，你可以使用类似的步骤来实现红外解码、数码管显示和LED显示的功能。下面是一个简单的设计思路：（1） 连接HX1838红外解码器、数码管和LED到C51单片机。将HX1838的信号引脚连接到C51单片机的外部中断引脚（例如INT0），数码管的CLK引脚连接到C51单片机的某个IO口引脚，数码管的DIO引脚连接到C51单片机的另一个IO口引脚，LED连接到C51单片机的某个IO口引脚。（2） 在C51的程序中，定义并初始化所需的IO口和外部中断。
四、GD32 MCU 常见外设介绍 (6) ADC 模块介绍
最新发布
聚沃科技&GD32 MCU开发者社区
07-23 816
查询法采用的是转换单个通道，或者扫描一序列的通道，通过不断切换通道的方式去读取对应通道的ADC数值。12 位逐次逼近式模数转换器模块（ADC），可以采样来自于外部输入通道、内部输入通道的模拟信号，采样转换后，转换结果可以按照最低有效位对齐或最高有效位对齐的方式保存在相应的数据寄存器中。ADC时钟过高，ADC采样时钟高于ADC最高采样时钟获取到的数据不具有参考意义，需要手动分频到合适的ADC 要求的频率；ADC的查询法在获取ADC数值的时候，不允许重入，即不允许在同一时间调用ADC的数据读取函数；
USART串口理论知识总结
pythom_aaa的博客
07-18 663
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言USART串口print代码案例 前言 提示：这里可以添加本文要记录的大概内容： USART串口print代码案例 #include <stdint.h> #include <stdio.h> #include "gd32f30x.h" static void Usb2ComGpioInit(void) { rcu_periph_clock_enable(RCU_GPIOA); //配置TX引脚
中断和EXIT原理介绍
pythom_aaa的博客
07-20 601
EXTI（Extern Interrupt）外部中断。
ARM体系结构和接口技术（十）按键中断实验
weixin_44254079的博客
07-21 1080
ARM，异常处理
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、付费专栏及课程。

余额充值