Linux中GPIO子系统驱动

怼烎@ 2022-10-16 14:21 223阅读 0赞

### Linux中GPIO子系统驱动 ###

*  1、背景
 *  2、GPIO子系统的作用
 *  3、I.MX6ULL 的 gpio 子系统驱动
 *   *  3.1、设备树中的 gpio 信息
     *  3.2、GPIO 驱动程序简介
     *  3.3、gpio 子系统 API 函数

# 1、背景 #

本篇文章是基于Linux4.1.5内核下编写的，开发板是I.MX6ULL。

# 2、GPIO子系统的作用 #

gpio 子系统顾名思义，就是用于初始化 GPIO 并且提供相应的 API 函数，比如设置 GPIO为输入输出，读取 GPIO 的值等。 gpio 子系统的主要目的就是方便驱动开发者使用 gpio，驱动开发者在设备树中添加 gpio 相关信息，然后就可以在驱动程序中使用 gpio 子系统提供的 API函数来操作 GPIO， Linux 内核向驱动开发者屏蔽掉了 GPIO 的设置过程，极大的方便了驱动开发者使用 GPIO。

# 3、I.MX6ULL 的 gpio 子系统驱动 #

## 3.1、设备树中的 gpio 信息 ##

在上一篇文章[pinctrl子系统驱动][pinctrl]中，我们以UART1\_RTS\_B做为 SD 卡的检测引脚， UART1\_RTS\_B 复用为 GPIO1\_IO19，通过读取这个 GPIO 的高低电平就可以知道 SD 卡有没有插入首先肯定是将 UART1\_RTS\_B 这个 PIN 复用为 GPIO1\_IO19，并且设置电气属性，也就是上篇文章讲的pinctrl 节点。这个节点的pinctrl节点如下：

pinctrl_hog_1: hoggrp-1 { 
    			fsl,pins = <
    				MX6UL_PAD_UART1_RTS_B__GPIO1_IO19	0x17059 /* SD1 CD */
    				......
    			>;
    		};

pinctrl 配置好以后就是设置 gpio 了， SD 卡驱动程序通过读取 GPIO1\_IO19 的值来判断 SD卡有没有插入，但是 SD 卡驱动程序怎么知道 CD 引脚连接的 GPIO1\_IO19 呢？肯定是需要设备树告诉驱动啊！在设备树中 SD 卡节点下添加一个属性来描述 SD 卡的 CD 引脚就行了， SD卡驱动直接读取这个属性值就知道 SD 卡的 CD 引脚使用的是哪个 GPIO 了。 SD 卡连接在I.MX6ULL 的 usdhc1 接口上，在 imx6ull-alientek-emmc.dts 中找到名为“usdhc1”的节点，这个节点就是 SD 卡设备节点，如下所示：

&usdhc1 { 
    	pinctrl-names = "default", "state_100mhz", "state_200mhz";
    	pinctrl-0 = <&pinctrl_usdhc1>;
    	pinctrl-1 = <&pinctrl_usdhc1_100mhz>;
    	pinctrl-2 = <&pinctrl_usdhc1_200mhz>;
    	cd-gpios = <&gpio1 19 GPIO_ACTIVE_LOW>;
    	keep-power-in-suspend;
    	enable-sdio-wakeup;
    	vmmc-supply = <&reg_sd1_vmmc>;
    	status = "okay";
    };

在这里我们着重关注：

cd-gpios = <&gpio1 19 GPIO_ACTIVE_LOW>;

属性“cd-gpios”描述了 SD 卡的 CD 引脚使用的哪个 IO。属性值一共有三个，我们来看一下这三个属性值的含义:

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;gpio1</td> 
   <td>表示 CD 引脚所使用的 IO 属于 GPIO1 组</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td>表示 GPIO1 组的第 19 号 IO</td> 
  </tr> 
  <tr> 
   <td>GPIO_ACTIVE_LOW</td> 
   <td>表示低电平有效</td> 
  </tr> 
 </tbody> 
</table>

根据上面这些信息， SD 卡驱动程序就可以使用 GPIO1\_IO19 来检测 SD 卡的 CD 信号了，接着我们找到GPIO1的信息：

gpio1: gpio@0209c000 { 
    				compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
    				reg = <0x0209c000 0x4000>;
    				interrupts = <GIC_SPI 66 IRQ_TYPE_LEVEL_HIGH>,
    					     <GIC_SPI 67 IRQ_TYPE_LEVEL_HIGH>;
    				gpio-controller;
    				#gpio-cells = <2>;
    				interrupt-controller;
    				#interrupt-cells = <2>;
    			};

gpio1 节点信息描述了 GPIO1 控制器的所有信息，重点就是 GPIO1 外设寄存器基地址以及兼 容 属 性 。

**compatible**： 设置 gpio1 节点的 compatible 属性有两个，分别为“fsl,imx6ul-gpio”和“fsl,imx35-gpio”，在 Linux 内核中搜索这两个字符串就可以找到 I.MX6UL 的 GPIO 驱动程序。

\*\*reg:\*\*在gpio1的节点中，我们发现GPIO1的基地址为：0x0209c000 大小为：0x4000  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70]  
**interrupts** ：表示中断信息

**“gpio-controller”**：表示 gpio1 节点是个 GPIO 控制器。

**\#gpio-cells**：“\#gpio-cells”属性和“\#address-cells”类似， \#gpio-cells 应该为 2，表示一共有  
两个 cell，第一个 cell 为 GPIO 编号，比如“&gpio1 3”就表示 GPIO1\_IO03。第二个 cell 表示  
GPIO 极 性 ， 如 果 为 0(GPIO\_ACTIVE\_HIGH) 的 话 表 示 高 电 平 有 效 ， 如 果 为  
1(GPIO\_ACTIVE\_LOW)的话表示低电平有效。

## 3.2、GPIO 驱动程序简介 ##

gpio1 节点的 compatible 属性描述了兼容性，在 Linux 内核中搜索“fsl,imx6ul-gpio”和“fsl,imx35-gpio”这两个字符串，查找 GPIO 驱动文件。 drivers/gpio/gpio-mxc.c 就是 I.MX6ULL的 GPIO 驱动文件，在此文件中有如下所示 of\_device\_id 匹配表：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 1]  
平台的gpio的driver如下：

static struct platform_driver mxc_gpio_driver = { 
    	.driver		= { 
    		.name	= "gpio-mxc",
    		.of_match_table = mxc_gpio_dt_ids,
    	},
    	.probe		= mxc_gpio_probe,
    	.id_table	= mxc_gpio_devtype,
    };

和pinctrl一样，可以看出 GPIO 驱动也是个平台设备驱动，因此当设备树中的设备节点与驱动的  
of\_device\_id 匹配以后 probe 函数就会执行，在这里就是 mxc\_gpio\_probe 函数，这个函数就是  
I.MX6ULL 的 GPIO 驱动入口函数:

static int mxc_gpio_probe(struct platform_device *pdev)
    { 
    	struct device_node *np = pdev->dev.of_node;
    	struct mxc_gpio_port *port;
    	struct resource *iores;
    	int irq_base;
    	int err;
    
    	mxc_gpio_get_hw(pdev);
    
    	port = devm_kzalloc(&pdev->dev, sizeof(*port), GFP_KERNEL);
    	if (!port)
    		return -ENOMEM;
    
    	iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    	port->base = devm_ioremap_resource(&pdev->dev, iores);
    	if (IS_ERR(port->base))
    		return PTR_ERR(port->base);
    
    	port->irq_high = platform_get_irq(pdev, 1);
    	port->irq = platform_get_irq(pdev, 0);
    	if (port->irq < 0)
    		return port->irq;
    
    	/* disable the interrupt and clear the status */
    	writel(0, port->base + GPIO_IMR);
    	writel(~0, port->base + GPIO_ISR);
    
    	if (mxc_gpio_hwtype == IMX21_GPIO) { 
    		/* * Setup one handler for all GPIO interrupts. Actually setting * the handler is needed only once, but doing it for every port * is more robust and easier. */
    		irq_set_chained_handler(port->irq, mx2_gpio_irq_handler);
    	} else { 
    		/* setup one handler for each entry */
    		irq_set_chained_handler(port->irq, mx3_gpio_irq_handler);
    		irq_set_handler_data(port->irq, port);
    		if (port->irq_high > 0) { 
    			/* setup handler for GPIO 16 to 31 */
    			irq_set_chained_handler(port->irq_high,
    						mx3_gpio_irq_handler);
    			irq_set_handler_data(port->irq_high, port);
    		}
    	}
    
    	err = bgpio_init(&port->bgc, &pdev->dev, 4,
    			 port->base + GPIO_PSR,
    			 port->base + GPIO_DR, NULL,
    			 port->base + GPIO_GDIR, NULL, 0);
    	if (err)
    		goto out_bgio;
    
    	port->bgc.gc.to_irq = mxc_gpio_to_irq;
    	port->bgc.gc.base = (pdev->id < 0) ? of_alias_get_id(np, "gpio") * 32 :
    					     pdev->id * 32;
    
    	err = gpiochip_add(&port->bgc.gc);
    	if (err)
    		goto out_bgpio_remove;
    
    	irq_base = irq_alloc_descs(-1, 0, 32, numa_node_id());
    	if (irq_base < 0) { 
    		err = irq_base;
    		goto out_gpiochip_remove;
    	}
    
    	port->domain = irq_domain_add_legacy(np, 32, irq_base, 0,
    					     &irq_domain_simple_ops, NULL);
    	if (!port->domain) { 
    		err = -ENODEV;
    		goto out_irqdesc_free;
    	}
    
    	/* gpio-mxc can be a generic irq chip */
    	mxc_gpio_init_gc(port, irq_base);
    
    	list_add_tail(&port->node, &mxc_gpio_ports);
    
    	return 0;
    
    out_irqdesc_free:
    	irq_free_descs(irq_base, 32);
    out_gpiochip_remove:
    	gpiochip_remove(&port->bgc.gc);
    out_bgpio_remove:
    	bgpio_remove(&port->bgc);
    out_bgio:
    	dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
    	return err;
    }

\**struct device\_node np = pdev->dev.of\_node*：设备树节点指针。

\**struct mxc\_gpio\_port port*：定义一个结构体指针 port，结构体类型为 mxc\_gpio\_port。 gpio-mxc.c 的重点工作就是维护 mxc\_gpio\_port， mxc\_gpio\_port 就是对 I.MX6ULL GPIO 的抽象。

mxc\_gpio\_port 结构体定义如下：

struct mxc_gpio_port { 
    	struct list_head node;
    	void __iomem *base;
    	int irq;
    	int irq_high;
    	struct irq_domain *domain;
    	struct bgpio_chip bgc;
    	u32 both_edges;
    };

此结构体重bgc成员很重要，在probe函数中接下来就是对它的初始化。

**mxc\_gpio\_get\_hw(pdev)**：调用 mxc\_gpio\_get\_hw 函数获取 gpio 的硬件相关数据，其实就是 gpio 的寄存器组函数 mxc\_gpio\_get\_hw 里面有如下代码：

static void mxc_gpio_get_hw(struct platform_device *pdev)
    { 
    	const struct of_device_id *of_id =
    			of_match_device(mxc_gpio_dt_ids, &pdev->dev);
    	enum mxc_gpio_hwtype hwtype;
    
    	if (of_id)
    		pdev->id_entry = of_id->data;
    	hwtype = pdev->id_entry->driver_data;
    
    	if (mxc_gpio_hwtype) { 
    		/* * The driver works with a reasonable presupposition, * that is all gpio ports must be the same type when * running on one soc. */
    		BUG_ON(mxc_gpio_hwtype != hwtype);
    		return;
    	}
    
    	if (hwtype == IMX35_GPIO)
    		mxc_gpio_hwdata = &imx35_gpio_hwdata;
    	else if (hwtype == IMX31_GPIO)
    		mxc_gpio_hwdata = &imx31_gpio_hwdata;
    	else
    		mxc_gpio_hwdata = &imx1_imx21_gpio_hwdata;
    
    	mxc_gpio_hwtype = hwtype;
    }

mxc\_gpio\_hwdata 是个全局变量，如果硬件类型是 IMX35\_GPIO 的话设置mxc\_gpio\_hwdat 为 imx35\_gpio\_hwdata。对于 I.MX6ULL 而言，硬件类型就是 IMX35\_GPIO，imx35\_gpio\_hwdata 是个结构体变量，描述了 GPIO 寄存器组，内容如下：

static struct mxc_gpio_hwdata imx35_gpio_hwdata = { 
    	.dr_reg		= 0x00,
    	.gdir_reg	= 0x04,
    	.psr_reg	= 0x08,
    	.icr1_reg	= 0x0c,
    	.icr2_reg	= 0x10,
    	.imr_reg	= 0x14,
    	.isr_reg	= 0x18,
    	.edge_sel_reg	= 0x1c,
    	.low_level	= 0x00,
    	.high_level	= 0x01,
    	.rise_edge	= 0x02,
    	.fall_edge	= 0x03,
    };

imx35\_gpio\_hwdata 结构体就是 GPIO 寄存器组结构。这样我们后面就可以通过mxc\_gpio\_hwdata 这个全局变量来访问 GPIO 的相应寄存器了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 2]  
**platform\_get\_resource**:platform\_get\_resource 获取设备树中内存资源信息，也就是 reg 属性值。前面说了 reg 属性指定了 GPIO1 控制器的寄存器基地址为 0X0209C000，在配合前面已经得到的 mxc\_gpio\_hwdata，这样 Linux 内核就可以访问 gpio1 的所有寄存器了。

**devm\_ioremap\_resource**:调用 devm\_ioremap\_resource 函数进行内存映射，得到 0x0209C000 在 Linux 内核中的虚拟地址

\*\*platform\_get\_irq \*\*:通过 platform\_get\_irq 函数获取中断号

**writel(0, port->base + GPIO\_IMR);writel(~0, port->base + GPIO\_ISR);**:操作 GPIO1 的 IMR 和 ISR 这两个寄存器，关闭 GPIO1 所有 IO 中断，并且清除状态寄存器。

**bgpio\_init**:bgpio\_init 函数第一个参数为 bgc，是 bgpio\_chip 结构体指针。 bgpio\_chip结构体有个 gc 成员变量，gc 是个 gpio\_chip 结构体类型的变量。 gpio\_chip 结构体是抽象出来的GPIO 控制器， gpio\_chip 结构体如下所示:

struct gpio_chip { 
    	const char		*label;
    	struct device		*dev;
    	struct module		*owner;
    	struct list_head        list;
    
    	int			(*request)(struct gpio_chip *chip,
    						unsigned offset);
    	void			(*free)(struct gpio_chip *chip,
    						unsigned offset);
    	int			(*get_direction)(struct gpio_chip *chip,
    						unsigned offset);
    	int			(*direction_input)(struct gpio_chip *chip,
    						unsigned offset);
    	int			(*direction_output)(struct gpio_chip *chip,
    						unsigned offset, int value);
    	int			(*get)(struct gpio_chip *chip,
    						unsigned offset);
    	void			(*set)(struct gpio_chip *chip,
    						unsigned offset, int value);
    	void			(*set_multiple)(struct gpio_chip *chip,
    						unsigned long *mask,
    						unsigned long *bits);
    	int			(*set_debounce)(struct gpio_chip *chip,
    						unsigned offset,
    						unsigned debounce);
    
    	int			(*to_irq)(struct gpio_chip *chip,
    						unsigned offset);
    
    	void			(*dbg_show)(struct seq_file *s,
    						struct gpio_chip *chip);
    	int			base;
    	u16			ngpio;
    	......
    	}

这个里面的内容很多，只展示部分内容。

可以看出， gpio\_chip 大量的成员都是函数，这些函数就是 GPIO 操作函数。 bgpio\_init 函数主 要 任 务 就 是 初 始 化 bgc->gc 。 bgpio\_init 里 面 有 三 个 setup 函 数 ： bgpio\_setup\_io 、bgpio\_setup\_accessors 和 bgpio\_setup\_direction。这三个函数就是初始化 bgc->gc 中的各种有关GPIO 的操作，比如输出，输入等等。第GPIO\_PSR、 GPIO\_DR 和 GPIO\_GDIR 都是 I.MX6ULL 的 GPIO 寄存器。这些寄存器地址会赋值给 bgc 参数的 reg\_dat、 reg\_set、 reg\_clr和 reg\_dir 这些成员变量。至此， bgc 既有了对 GPIO 的操作函数，又有了 I.MX6ULL 有关 GPIO的寄存器，那么只要得到 bgc 就可以对 I.MX6ULL 的 GPIO 进行操作。

继续回到mxc\_gpio\_probe函数，调用函数**gpiochip\_add**向Linux内核注册gpio\_chip，也就是 port->bgc.gc。注册完成以后我们就可以在驱动中使用 gpiolib 提供的各个 API 函数。

## 3.3、gpio 子系统 API 函数 ##

[gpio 子系统 API 函数][gpio _ API]

[pinctrl]: https://blog.csdn.net/weixin_45309916/article/details/117398570
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70]: /images/20221014/21a8c6bfadbe4709b3e6c615c792fe28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 1]: /images/20221014/4be66b674f1941e69ab30897de2109da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 2]: /images/20221014/5070d7bd74744ed79e5c41632b7a9100.png
[gpio _ API]: https://blog.csdn.net/weixin_45309916/article/details/109854987?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162238143716780269849899%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=162238143716780269849899&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-2-109854987.nonecase&utm_term=gpio&spm=1018.2226.3001.4450