rk3588 gpio分析-凯发app官方网站

1.简介
gpio是可编程的通用i/o外设。如下图所示，rk3588 gpio控制器包含3个部分；apb接口模块和soc内部的apb总线连接，负责与soc交换数据，位宽为32位；i/o port接口模块管理外部的引脚，引脚的输入和输出都要经过该模块；中断探测模块负责gpio控制器的中断上报与处理。




rk3588 gpio控制器的特性如下：


32bits apb总线位宽
每个中断控制器32个gpio引脚
每个gpio引脚软件可控制
中断引脚可配置防抖
中断模式可配置
独立的控制寄存器支持两个虚拟的os
在两个虚拟的os模式中，每个os都有独立的中断
非虚拟的os模式中，支持设置两种中断极性
2.gpio驱动框架
linux内核gpio驱动框架如下图所示。{banned}最佳上层是gpio使用者驱动，如led driver、key driver等，gpio硬件由使用者控制。接下来是gpio的抽象层-gpio库，实现位于内核drivers\gpio\gpiolib.c文件中，gpio库向上给gpio使用者提供访问gpio硬件的接口，向下将所有不同的gpio controller统一管理起来。gpio控制器驱动负责驱动具体的gpio控制器。{banned}最佳下层是gpio控制器硬件。






2.1.数据结构
数据结构的关系图如下所示。一个gpio控制器对应一个gpio_device、rockchip_pin_bank、irq_chip_generic，一个gpio引脚对应于一个gpio_desc。所有的gpio_device放到gpio_devices链表中，由内核统一管理。






2.2.gpio控制器驱动接口
gpio控制器驱动需要提供一个gpio_chip结构体，并将其初始化。gpio_chip结构体主要的成员如下。内核使用gpio_irq_chip实现gpio控制器的中断功能。


[include/linux/gpio/driver.h]
struct gpio_chip {
const char*label;
// 每个gpio控制器都有一个gpio_device
struct gpio_device*gpiodev;
// 请求gpio，gpio_request调用该函数
int(*request)(struct gpio_chip *gc, unsigned int offset);
// 释放gpio，gpio_free调用该函数
void (*free)(struct gpio_chip *gc, unsigned int offset);
// 获取gpio方向，gpiod_get_direction调用该函数
int(*get_direction)(struct gpio_chip *gc, unsigned int offset);
// 设置gpio为输入，gpio_direction_input或gpiod_direction_input调用该函数
int(*direction_input)(struct gpio_chip *gc, unsigned int offset);
// 设置gpio为输出，gpio_direction_output或gpiod_direction_output调用该函数
int(*direction_output)(struct gpio_chip *gc,
unsigned int offset, int value);
// 获取gpio值，gpio_get_value或gpiod_get_value调用该函数
int(*get)(struct gpio_chip *gc, unsigned int offset);
// 获取多个gpio值
int(*get_multiple)(struct gpio_chip *gc,
unsigned long *mask, unsigned long *bits);
// 设置gpio值，gpio_set_value或gpiod_set_value调用该函数
void (*set)(struct gpio_chip *gc, unsigned int offset, int value);
// 设置多个gpio值
void (*set_multiple)(struct gpio_chip *gc, unsigned long *mask, unsigned long *bits);
// 设置gpio防抖功能，gpio_set_debounce或gpiod_set_debounce调用该函数
int(*set_config)(struct gpio_chip *gc, unsigned int offset,
unsigned long config);
// 获取gpio引脚虚拟中断号，gpio_to_irq或gpiod_to_irq调用该函数
int(*to_irq)(struct gpio_chip *gc, unsigned int offset);
......
// gpio range功能
int(*add_pin_ranges)(struct gpio_chip *gc);
intbase;  // 该gpio控制器的基础编号
u16ngpio; // gpio引脚数量
#if is_enabled(config_gpio_generic)
// 读gpio寄存器
unsigned long (*read_reg)(void __iomem *reg);
// 写gpio寄存器
void (*write_reg)(void __iomem *reg, unsigned long data);;
void __iomem *reg_dat;  // data (in) register for generic gpio
void __iomem *reg_set;  // output set register (out=high) for generic gpio
void __iomem *reg_clr;  // output clear register (out=low) for generic gpio
// direction out setting register for generic gpio
void __iomem *reg_dir_out;
// direction in setting register for generic gpio
void __iomem *reg_dir_in;
#endif /* config_gpio_generic */


#ifdef config_gpiolib_irqchip
/**
* integrates interrupt chip functionality with the gpio chip. can be
* used to handle irqs for most practical cases.
*/
struct gpio_irq_chip irq;
#endif /* config_gpiolib_irqchip */
......
};
// gpio中断功能
struct gpio_irq_chip {
/* gpio irq chip implementation, provided by gpio driver. */
struct irq_chip *chip;
/**
* interrupt translation domain; responsible for mapping between gpio
* hwirq number and linux irq number.
*/
struct irq_domain *domain;  // 用于gpio中断号映射
/* table of interrupt domain operations for this irq chip. */
const struct irq_domain_ops *domain_ops;
/**
* the irq handler to use (often a predefined irq core function) for
* gpio irqs, provided by gpio driver.
*/
// gpio控制器中断处理函数，该函数会调用使用者注册的具体pin的中断处理函数
irq_flow_handler_t handler;
/**
* default irq triggering type applied during gpio driver
* initialization, provided by gpio driver.
*/
unsigned int default_type;
/**
* the interrupt handler for the gpio chip's parent interrupts, may be
* null if the parent interrupts are nested rather than cascaded.
*/
irq_flow_handler_t parent_handler;
/**
* @init_hw: optional routine to initialize hardware before
* an irq chip will be added. this is quite useful when
* a particular driver wants to clear irq related registers
* in order to avoid undesired events.
*/
int (*init_hw)(struct gpio_chip *gc);
/**
* required for static irq allocation. if set, irq_domain_add_simple()
* will allocate and map all irqs during initialization.
*/
unsigned int first;
/* store old irq_chip irq_enable callback */
void(*irq_enable)(struct irq_data *data);
/* store old irq_chip irq_disable callback */
void(*irq_disable)(struct irq_data *data);
/* store old irq_chip irq_unmask callback */
void(*irq_unmask)(struct irq_data *data);
/* store old irq_chip irq_mask callback */
void(*irq_mask)(struct irq_data *data);
};


gpio_chip结构体初始化完成之后，调用gpiochip_add_data或devm_gpiochip_add_data函数进行注册，注册成功之后，gpio使用者就可以通过gpio驱动访问gpio硬件。调用gpiochip_add_data注册的gpio控制器需要调用gpiochip_remove释放，使用devm_gpiochip_add_data无需手动释放。


[include/linux/gpio/driver.h]
gpiochip_add_data(gc, data);
devm_gpiochip_add_data(dev, gc, data);
void gpiochip_remove(struct gpio_chip *gc);
1

2.3.gpio消费者驱动接口
内核中有两套接口可供gpio使用者调用。{banned}中国第一套是内核推荐的接口，其基于描述符gpio_desc，以gpiod开头。第二套是传统的接口，基于gpio number，以gpio开头。两种接口的对比如下表所示。



基于描述符的gpio接口和基于整数的gpio接口主要的区别在于获取gpio。基于描述符获取gpio接口如下所示。


[include/linux/gpio/consumer.h]
#define gpiod_flags_bit_dir_set           bit(0)  // 设置方向，默认输入
#define gpiod_flags_bit_dir_out           bit(1)  // 输出方向
#define gpiod_flags_bit_dir_val           bit(2)  // 设置值，默认低电平
#define gpiod_flags_bit_open_drain        bit(3)  // 开漏
#define gpiod_flags_bit_nonexclusive      bit(4)
/**
 * optional flags that can be passed to one of gpiod_* to configure direction
 * and output value. these values cannot be or'd.
 */
enum gpiod_flags {
    gpiod_asis = 0,
    gpiod_in = gpiod_flags_bit_dir_set,  // 输入
    // 输出-低电平
    gpiod_out_low = gpiod_flags_bit_dir_set | gpiod_flags_bit_dir_out,
    // 输出-高电平
    gpiod_out_high = gpiod_flags_bit_dir_set | gpiod_flags_bit_dir_out | 
                     gpiod_flags_bit_dir_val,
    // 输出-低电平-开漏
    gpiod_out_low_open_drain = gpiod_out_low | gpiod_flags_bit_open_drain,
    // 输出-高电平-开漏
    gpiod_out_high_open_drain = gpiod_out_high | gpiod_flags_bit_open_drain,
};
/**
 * gpiod_get - 获取gpio描述符
 * @dev: gpio consumer设备结构体指针
 * @con_id: gpio consumer引用gpio的属性前缀，如uart_rts_gpios，前缀为uart_rts
 * @flags: 可选的gpio初始化标志
 */
struct gpio_desc *gpiod_get(struct device *dev, const char *con_id, enum gpiod_flags flags);
/**
 * gpiod_get - 获取指定的gpio描述符
 * @dev: gpio consumer设备结构体指针
 * @con_id: gpio consumer引用gpio的属性前缀，如uart_rts_gpios，前缀为uart_rts
 * @idx: gpio consumer引用gpio的属性索引，uart_rts_gpios只有一个属性
 * @flags: 可选的gpio初始化标志
 */
struct gpio_desc *gpiod_get_index(struct device *dev, const char *con_id, unsigned int idx, enum gpiod_flags flags);
// 获取指定的gpio所有描述符，得到的是一个gpio数组
static inline struct gpio_descs *gpiod_get_array(struct device *dev, const char *con_id, enum gpiod_flags flags)


3.gpio消费者驱动示例
gpio使用者驱动wireless_bluetooth的设备树如下所示，其引用了gpio3控制器的的编号为4的引脚（gpio引脚编号定义在include/dt-bindings/pinctrl/rockchip.h头文件中），低电平有效，即gpiod_set_value/gpio_set_value设置0时有效。wireless_bluetooth引用了uart8_gpios的pinctrl设备节点，uart8_gpios节点将gpio3控制器的编号为4的引脚复用为gpio功能。gpio使用者驱动中gpio属性名称的命名规则为"[-]gpios"，name表明该gpio的用途，新的内核推荐使用该命名规则。当然也可以使用之前的规则，即使用gpios和[-]gpio"作为属性名称。


[arch/arm64/boot/dts/rockchip/rk3588s-evb4-lp4x.dtsi]
wireless_bluetooth: wireless-bluetooth {
compatible = "bluetooth-platdata";
clocks = <&hym8563>;
clock-names = "ext_clock";
// gpio3控制器，4号引脚，低电平有效
uart_rts_gpios = <&gpio3 rk_pa4 gpio_active_low>;
pinctrl-names = "default", "rts_gpio";
pinctrl-0 = <&uart8m1_rtsn>, <&bt_reset_gpio>, <&bt_wake_gpio>, <&bt_wake_host_irq>;
pinctrl-1 = <&uart8_gpios>;  // 引用uart_rts_gpios引脚的pinctrl结点
bt,reset_gpio    = <&gpio3 rk_pb7 gpio_active_high>;
bt,wake_gpio     = <&gpio3 rk_pc1 gpio_active_high>;
bt,wake_host_irq = <&gpio3 rk_pc0 gpio_active_high>;
status = "okay";
};


[arch/arm64/boot/dts/rockchip/rk3588s-evb4-lp4x.dtsi]
&pinctrl {
......
wireless-bluetooth {
uart8_gpios: uart8-gpios {
// gpio3控制器，4号引脚，引脚复用为gpio功能，不配置上下拉
rockchip,pins = <3 rk_pa4 rk_func_gpio &pcfg_pull_none>;
};
......
bt_wake_gpio: bt-wake-gpio {
rockchip,pins = <3 rk_pc1 rk_func_gpio &pcfg_pull_none>;
};
};
......
};


[arch/arm64/boot/dts/rockchip/rockchip-pinconf.dtsi]
&pinctrl {
......
/omit-if-no-ref/
pcfg_pull_none: pcfg-pull-none {
// 该属性定义在drivers/pinctrl/pinconf-generic.c文件中
bias-disable;
};
......
};


[arch/arm64/boot/dts/rockchip/rk3588s.dtsi]
pinctrl: pinctrl {
......
// gpio3控制器设备树节点
gpio3: gpio@fec40000 {
compatible = "rockchip,gpio-bank";
reg = <0x0 0xfec40000 0x0 0x100>;
// 整个gpio3控制器使用gic的280 32=312号中断，高电平触发
interrupts = ;
clocks = <&cru pclk_gpio3>, <&cru dbclk_gpio3>;
gpio-controller;  // gpio控制器
#gpio-cells = <2>;
gpio-ranges = <&pinctrl 0 96 32>;
interrupt-controller; // gpio控制器也是一个中断控制器
#interrupt-cells = <2>;
};
......
};



wireless_bluetooth驱动如下所示，在probe函数中先使用of_get_named_gpio_flags函数获取gpio（整数），然后调用devm_gpio_request请求gpio，在remove函数中调用gpio_free释放gpio。wireless_bluetooth驱动使用的是基于整数的gpio接口，可以使用基于描述符的gpio接口，如of_get_named_gpiod_flags、devm_gpiod_put。


[net/rfkill/rfkill-bt.c]
static int rfkill_rk_probe(struct platform_device *pdev)
{
......
ret = bluetooth_platdata_parse_dt(&pdev->dev, pdata);
......
ret = rfkill_rk_setup_gpio(pdev, &pdata->rts_gpio, rfkill->pdata->name,
   "rts");
......
ret = rfkill_rk_setup_gpio(pdev, &pdata->wake_gpio, pdata->name,
   "wake");
......
}


static int bluetooth_platdata_parse_dt(struct device *dev,
struct rfkill_rk_platform_data *data)
{
......
// 获取gpio
gpio = of_get_named_gpio_flags(node, "uart_rts_gpios", 0, &flags);
......
// 获取gpio
gpio = of_get_named_gpio_flags(node, "bt,wake_gpio", 0, &flags);;
......
}


static int rfkill_rk_setup_gpio(struct platform_device *pdev,
struct rfkill_rk_gpio *gpio, const char *prefix,
const char *name)
{
......
// 请求gpio
ret = devm_gpio_request(&pdev->dev, gpio->io, gpio->name);
......
}


static int rfkill_rk_remove(struct platform_device *pdev)
{
......
// 判断gpio是否有效
if (gpio_is_valid(rfkill->pdata->rts_gpio.io))
gpio_free(rfkill->pdata->rts_gpio.io);  // 释放gpio
......
if (gpio_is_valid(rfkill->pdata->wake_gpio.io))
gpio_free(rfkill->pdata->wake_gpio.io);
......
}


可以利用sys文件系统在用户空间操作gpio，具体如下所示。


echo 400 >  /sys/class/gpio/export    // 导出gpio
echo 400 >  /sys/class/gpio/unexport  // 不导出gpio


cat /sys/class/gpio/gpio400/direction // 查看gpio方向
# gpio方向默认输出低电平
echo in/out > /sys/class/gpio/gpio400/direction  // 设置gpio方向


cat /sys/class/gpio/gpio400/value
# 非0值-高电平，0-低电平，若配置为中断引脚，则可在此文件上调用poll轮询
echo 非0值/0 > /sys/class/gpio/gpio400/value


cat /sys/class/gpio/gpio400/edge
# 中断输入引脚有效
echo none/falling/rising/both > /sys/class/gpio/gpio400/edge


cat /sys/class/gpio/gpio400/active_low
# 写入非零值，真假反转
echo 1 > /sys/class/gpio/gpio400/active_low


cat /sys/kernel/debug/gpio # 查看gpio的编号和使用情况



4.驱动分析
rk3588 gpio驱动由pinctrl驱动调用of_platform_populate匹配。匹配成功后，rockchip_gpio_probe函数就会被调用。


[drivers/gpio/gpio-rockchip.c]
static const struct of_device_id rockchip_gpio_match[] = {
{ .compatible = "rockchip,gpio-bank", },
{ .compatible = "rockchip,rk3188-gpio-bank0" },
{ },
};
static struct platform_driver rockchip_gpio_driver = {
.probe= rockchip_gpio_probe,
.remove= rockchip_gpio_remove,
.driver= {
.name= "rockchip-gpio",
.of_match_table = rockchip_gpio_match,
},
};

rk3588驱动的执行流程如下，主要的工作有：


获取设备树中的gpio信息并进行处理，gpio的bank信息定义在pinctrl驱动中
注册gpio控制器，即将rockchip_gpiolib_chip注册到内核中，每个gpio_chip都对应一个gpio_device，每个gpio bank中的gpio pin都有一个gpio_desc，pin的编号由gpio_desc距数组开头的偏移值决定，{banned}最佳后设置gpio的linux编号，初始化gpio sys，具体路劲为/sys/class/gpio。
注册gpio中断。gpio也是一个中断控制器，串联到gic中断控制器下面，当gpio中断发生后，gpio控制器会将中断上报到gic，gic在将中断报告给cpu。gpio中断的处理过程则正常相反，cpu首先调用gic提供的中断函数，再调用gpio驱动的中断处理函数，{banned}最佳后调用gpio消费者驱动注册中断处理函数。
rockchip_gpio_probe
of_pinctrl_get          // 获取节点的别名
// 获取rockchip_pin_bank，该数据定义在pinctrl驱动中
rockchip_gpio_find_bank
// 获取该gpio控制器的信息
rockchip_get_bank_data
devm_ioremap_resource  // 映射寄存器地址
irq_of_parse_and_map   // 获取gpio控制器的虚拟中断号
clk_prepare_enable     // 使能时钟
bank->gpio_regs = &gpio_regs_v2  // 获取gpio寄存器偏移地址
rockchip_gpiolib_register
bank->gpio_chip = rockchip_gpiolib_chip  // 设置gpio_chip
gc->base = bank->pin_base;  // gpio控制器编号
gc->ngpio = bank->nr_pins;  // gpio控制器中pin的数量
gc->label = bank->name;     // gpio控制器名称
gpiochip_add_data
// 分配gpio_device
gdev = kzalloc(sizeof(*gdev), gfp_kernel)
// 分配ngpio个gpio_desc，每个gpio对应一个
gdev->descs = kcalloc(gc->ngpio, sizeof(gdev->descs[0]...))
// 若驱动未设置linux gpio编号，则内核会查找设置
// bank0 = 512 - 32，bank1 = 512 - 2 * 32...
gpiochip_find_base(gc->ngpio)
// 若设备树定义了gpio-ranges属性，还需要建立
// gpio linux编号和pinctrl的映射关系
gpiochip_add_pin_range
// 初始化gpio sys，这样用户空间可以利用sys文件系统操作gpio
gpiochip_setup_dev(struct gpio_device *gdev)
rockchip_interrupts_register  // 注册gpio控制器中断
// 创建一个线性映射中断的irq_domain，{banned}最佳大映射32个中断
// 映射方法由irq_generic_chip_ops决定
irq_domain_add_linear(..., 32, &irq_generic_chip_ops, null)
// 分配irq_domain_chip_generic，有32个中断，一个irq_chip_generic
// 该chip上的所有中断的默认处理函数为handle_level_irq
irq_alloc_domain_generic_chips(bank->domain, 32, 1,
"rockchip_gpio_irq", handle_level_irq, clr, 0, 0);
irq_get_domain_generic_chip // 获取上面分配的irq_chip_generic
// 设置gpio中断相关寄存器读写函数
gc->reg_writel = gpio_writel_v2;
gc->reg_readl = gpio_readl_v2;
// gpio作为中断控制器，也应该有中断响应、屏蔽、使能、设置中断类型等函数
gc->chip_types[0].chip.irq_ack = irq_gc_ack_set_bit;
gc->chip_types[0].chip.irq_mask = irq_gc_mask_set_bit;
gc->chip_types[0].chip.irq_unmask = irq_gc_mask_clr_bit;
gc->chip_types[0].chip.irq_enable = rockchip_irq_enable;
gc->chip_types[0].chip.irq_disable = rockchip_irq_disable;
gc->chip_types[0].chip.irq_set_wake = irq_gc_set_wake;
gc->chip_types[0].chip.irq_suspend = rockchip_irq_suspend;
gc->chip_types[0].chip.irq_resume = rockchip_irq_resume;
gc->chip_types[0].chip.irq_set_type = rockchip_irq_set_type;
// 设置gpio bank的链式中断处理函数，当该gpio bank中的gpio发生中断时，gic
// 的中断处理函数会调用该函数
irq_set_chained_handler_and_data(...rockchip_irq_demux...);

gpio初始化的过程中用到的数据结构如下所示。


[drivers/pinctrl/pinctrl-rockchip.c]
// 3588 gpio信息，主要有gpio bank编号、pin数量、iomux配置宽度、输出类型
static struct rockchip_pin_bank rk3588_pin_banks[] = {
rk3588_pin_bank_flags(0, 32, "gpio0",
      iomux_width_4bit, pull_type_io_1v8_only),
rk3588_pin_bank_flags(1, 32, "gpio1",
      iomux_width_4bit, pull_type_io_1v8_only),
rk3588_pin_bank_flags(2, 32, "gpio2",
      iomux_width_4bit, pull_type_io_1v8_only),
rk3588_pin_bank_flags(3, 32, "gpio3",
      iomux_width_4bit, pull_type_io_1v8_only),
rk3588_pin_bank_flags(4, 32, "gpio4",
      iomux_width_4bit, pull_type_io_1v8_only),
};


[drivers/gpio/gpio-rockchip.c]
// gpio驱动定义的gpio_chip数据结构
static const struct gpio_chip rockchip_gpiolib_chip = {
.request = gpiochip_generic_request,
.free = gpiochip_generic_free,
.set = rockchip_gpio_set,
.get = rockchip_gpio_get,
// 获取方向
.get_direction= rockchip_gpio_get_direction,
// 输入
.direction_input = rockchip_gpio_direction_input,
// 输出
.direction_output = rockchip_gpio_direction_output,
.set_config = rockchip_gpio_set_config,
.to_irq = rockchip_gpio_to_irq,  // 获取gpio的中断号
.owner = this_module,
};


[kernel/irq/generic-chip.c]
// 获取gpio中断号并进行映射
struct irq_domain_ops irq_generic_chip_ops = {
.map= irq_map_generic_chip,
.unmap  = irq_unmap_generic_chip,
.xlate= irq_domain_xlate_onetwocell,
};


5.gpio中断号
gpio设备树中定义的是gpio bank的中断号，而每个gpio bank中的pin都有中断号（虚拟）。gpio消费者驱动使用gpiod_to_irq获取gpio pin的中断号（虚拟）。gpiod_to_irq内部会调用rockchip_gpio_to_irq，将gpio pin的引脚编号映射为虚拟中断号。


gpiod_to_irq
    offset = gpio_chip_hwgpio(desc);
        // 返回descs的偏移，表示gpio引脚的编号
        return desc - &desc->gdev->descs[0];
    gc->to_irq(gc, offset)
    rockchip_gpio_to_irq
        // gpio中断控制器irq_domain采用chained形式
        irq_create_mapping(domain, offset);
            // gpio引脚的编号offset就是hwirq，将hwirq映射为虚拟中断号
            irq_create_mapping_affinity(host, hwirq, null)
                // 检查该gpio硬件中断号是否被映射
                irq_find_mapping(domain, hwirq);
                    domain->linear_revmap[hwirq]  // 线性映射
                    radix_tree_lookup(&domain->revmap_tree, hwirq) // 非线性映射
                // 获取虚拟中断号，并分配irq_desc
                virq = irq_domain_alloc_descs(......);
                    __irq_alloc_descs
                        bitmap_find_next_zero_area // 从位图中找一个空闲的bit
                        alloc_descs
                            alloc_desc
                                desc = kzalloc_node(sizeof(*desc), ...)
                                irq_insert_desc(start i, desc)
                                    radix_tree_insert(&irq_desc_tree, irq, desc);
                                // 在位图中设置获取的虚拟中断号
                                bitmap_set(allocated_irqs, start, cnt);
                irq_domain_associate
                    irq_data->hwirq = hwirq;    // 保存gpio硬件中断号
                    irq_data->domain = domain;  // 保存gpio中断控制器irq_domain
                    domain->ops->map(domain, virq, hwirq)
                    gpiochip_irq_map
                        irq_set_chip_data(irq, gc);
                            // 保存私有数据
                            desc->irq_data.chip_data = data;
                        irq_set_chip_and_handler
                            // 将irq_chip设置到irq_data中
                            irq_set_chip(irq, chip)
                            // 设置中断处理函数，这里设置的handle_bad_irq
                            __irq_set_handler(irq, handle, 0, name)
                    irq_domain_set_mapping(domain, hwirq, irq_data);
                        // 线性映射
                        irq_domain_set_mapping(domain, hwirq, irq_data);
                        // 非线性映射
                        radix_tree_insert(&domain->revmap_tree, hwirq, irq_data);


6.gpio中断处理流程
gpio的中断处理流程如下所示，主要的工作流程如下：