Linux 内核提供了 pinctrl 和 gpio 子系统用于GPIO 驱动，
本章我们就来学习一下如何借助 pinctrl 和 gpio 子系统来简化 GPIO 驱动开发。
45.1 pinctrl 子系统
45.1.1 pinctrl 子系统简介
Linux 驱动讲究驱动分离与分层，pinctrl 和 gpio 子系统就是驱动分离与分层思想下的产物，
驱动分离与分层其实就是按照面向对象编程的设计思想而设计的设备驱动框架，关于驱动的分
离与分层我们后面会讲。本来 pinctrl 和 gpio 子系统应该放到驱动分离与分层章节后面讲解，但
是不管什么外设驱动， GPIO 驱动基本都是必须的，而 pinctrl 和 gpio 子系统又是 GPIO 驱动必
须使用的，所以就将 pintrcl 和 gpio 子系统这一章节提前了。
我们先来回顾一下上一章是怎么初始化 LED 灯所使用的 GPIO，步骤如下：
①、修改设备树，添加相应的节点，节点里面重点是设置 reg 属性， reg 属性包括了 GPIO
相关寄存器。
② 、 获 取 reg 属 性 中 IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03 和
(IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO03 这两个寄存器地址，并且初始化这两个寄存器，
这两个寄存器用于设置 GPIO1_IO03 这个 PIN 的复用功能、上下拉、速度等。
③、在②里面将 GPIO1_IO03 这个 PIN 复用为了 GPIO 功能，因此需要设置 GPIO1_IO03
这个 GPIO 相关的寄存器，也就是 GPIO1_DR 和 GPIO1_GDIR 这两个寄存器。
总结一下，②中完成对 GPIO1_IO03 这个 PIN 的初始化，设置这个 PIN 的复用功能、上下
拉等，比如将 GPIO_IO03 这个 PIN 设置为 GPIO 功能。③中完成对 GPIO 的初始化，设置 GPIO
为输入/输出等。如果使用过 STM32 的话应该都记得， STM32 也是要先设置某个 PIN 的复用功
能、速度、上下拉等，然后再设置 PIN 所对应的 GPIO。其实对于大多数的 32 位 SOC 而言，引
脚的设置基本都是这两方面，因此 Linux 内核针对 PIN 的配置推出了 pinctrl 子系统，对于 GPIO
的配置推出了 gpio 子系统。本节我们来学习 pinctrl 子系统，下一节再学习 gpio 子系统。
大多数 SOC 的 pin 都是支持复用的，比如 I.MX6ULL 的 GPIO1_IO03 既可以作为普通的
GPIO 使用，也可以作为 I2C1 的 SDA 等等。此外我们还需要配置 pin 的电气特性，比如上/下
拉、速度、驱动能力等等。传统的配置 pin 的方式就是直接操作相应的寄存器，但是这种配置
方式比较繁琐、而且容易出问题(比如 pin 功能冲突)。 pinctrl 子系统就是为了解决这个问题而引
入的， pinctrl 子系统主要工作内容如下：
①、获取设备树中 pin 信息。
②、根据获取到的 pin 信息来设置 pin 的复用功能
③、根据获取到的 pin 信息来设置 pin 的电气特性，比如上/下拉、速度、驱动能力等。
对于我们使用者来讲，只需要在设备树里面设置好某个 pin 的相关属性即可，其他的初始
化工作均由 pinctrl 子系统来完成， pinctrl 子系统源码目录为 drivers/pinctrl。
45.1.2 I.MX6ULL 的 pinctrl 子系统驱动
1、 PIN 配置信息详解
要使用 pinctrl 子系统，我们需要在设备树里面设置 PIN 的配置信息，毕竟 pinctrl 子系统要
根据你提供的信息来配置 PIN 功能，一般会在设备树里面创建一个节点来描述 PIN 的配置信
息。打开 imx6ull.dtsi 文件，找到一个叫做 iomuxc 的节点，如下所示：
示例代码 45.1.2.1 iomuxc 节点内容 1
756 iomuxc: iomuxc@020e0000 {
757 compatible = "fsl,imx6ul-iomuxc";
758 reg = <0x020e0000 0x4000>;
759 };
iomuxc 节点就是 I.MX6ULL 的 IOMUXC 外设对应的节点，看起来内容很少，没看出什么
跟 PIN 的配置有关的内容啊，别急！打开 imx6ull-alientek-emmc.dts，找到如下所示内容：
iomuxc 节点就是 I.MX6ULL 的 IOMUXC 外设对应的节点，看起来内容很少，没看出什么
跟 PIN 的配置有关的内容啊，别急！打开 imx6ull-alientek-emmc.dts，找到如下所示内容：
示例代码 45.1.2.2 iomuxc 节点内容 2
311 &iomuxc {
312 pinctrl-names = "default";
313 pinctrl-0 = <&pinctrl_hog_1>;
314 imx6ul-evk {
315 pinctrl_hog_1: hoggrp-1 {
316 fsl,pins = <
317 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x17059
318 MX6UL_PAD_GPIO1_IO05__USDHC1_VSELECT 0x17059
319 MX6UL_PAD_GPIO1_IO09__GPIO1_IO09 0x17059
320 MX6UL_PAD_GPIO1_IO00__ANATOP_OTG1_ID 0x13058
321 >;
322 };
......
371 pinctrl_flexcan1: flexcan1grp{
372 fsl,pins = <
373 MX6UL_PAD_UART3_RTS_B__FLEXCAN1_RX 0x1b020
374 MX6UL_PAD_UART3_CTS_B__FLEXCAN1_TX 0x1b020
375 >;
376 };
......
587 pinctrl_wdog: wdoggrp {
588 fsl,pins = <
589 MX6UL_PAD_LCD_RESET__WDOG1_WDOG_ANY 0x30b0
590 >;
591 };
592 };
593 };
示例代码 45.1.2.2 就是向 iomuxc 节点追加数据，不同的外设使用的 PIN 不同、其配置也不
同，因此一个萝卜一个坑，将某个外设所使用的所有 PIN 都组织在一个子节点里面。示例代码
45.1.2.2 中 pinctrl_hog_1 子节点就是和热插拔有关的 PIN 集合，比如 USB OTG 的 ID 引脚。
pinctrl_flexcan1 子节点是 flexcan1 这个外设所使用的 PIN， pinctrl_wdog 子节点是 wdog 外设所
使用的 PIN。如果需要在 iomuxc 中添加我们自定义外设的 PIN，那么需要新建一个子节点，然
后将这个自定义外设的所有 PIN 配置信息都放到这个子节点中。
将其与示例代码 45.1.2.1 结合起来就可以得到完成的 iomuxc 节点，如下所示：
示例代码 45.1.2.3 完整的 iomuxc 节点
1 iomuxc: iomuxc@020e0000 {
2 compatible = "fsl,imx6ul-iomuxc";
3 reg = <0x020e0000 0x4000>;
4 pinctrl-names = "default";
5 pinctrl-0 = <&pinctrl_hog_1>;
6 imx6ul-evk {
7 pinctrl_hog_1: hoggrp-1 {
8 fsl,pins = <
9 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x17059
10 MX6UL_PAD_GPIO1_IO05__USDHC1_VSELECT 0x17059
11 MX6UL_PAD_GPIO1_IO09__GPIO1_IO09 0x17059
12 MX6UL_PAD_GPIO1_IO00__ANATOP_OTG1_ID 0x13058
13 >;
......
16 };
17 };
18 };
第 2 行， compatible 属性值为“ fsl,imx6ul-iomuxc”，前面讲解设备树的时候说过， Linux 内
核会根据 compatbile 属性值来查找对应的驱动文件，所以我们在 Linux 内核源码中全局搜索字
符串“ fsl,imx6ul-iomuxc”就会找到 I.MX6ULL 这颗 SOC 的 pinctrl 驱动文件。稍后我们会讲解
这个 pinctrl 驱动文件。
第 9~12 行，pinctrl_hog_1 子节点所使用的 PIN 配置信息，我们就以第 9 行的 UART1_RTS_B
这个 PIN 为例，讲解一下如何添加 PIN 的配置信息， UART1_RTS_B 的配置信息如下：
MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x17059
首先说明一下， UART1_RTS_B 这个 PIN 是作为 SD 卡的检测引脚，也就是通过此 PIN 就
可 以 检 测 到 SD 卡 是 否 有 插 入 。 UART1_RTS_B 的 配 置 信 息 分 为 两 部 分 ：
MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 和 0x17059
我们重点来看一下这两部分是什么含义，前面说了，对于一个 PIN 的配置主要包括两方面，
一个是设置这个 PIN 的复用功能，另一个就是设置这个 PIN 的电气特性。所以我们可以大胆的
猜测 UART1_RTS_B 的这两部分配置信息一个是设置 UART1_RTS_B 的复用功能，一个是用来
设置 UART1_RTS_B 的电气特性。
首先来看一下 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19，这是一个宏定义，定义在文件
arch/arm/boot/dts/imx6ul-pinfunc.h 中， imx6ull.dtsi 会引用 imx6ull-pinfunc.h 这个头文件，而
imx6ull-pinfunc.h 又会引用 imx6ul-pinfunc.h 这个头文件（绕啊绕！）。从这里可以看出，可以在
设备树中引用 C 语言中.h 文件中的内容。 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 的宏定
义内容如下：
示例代码 45.1.2.4 UART1_RTS_B 引脚定义
190 #define MX6UL_PAD_UART1_RTS_B__UART1_DCE_RTS 0x0090 0x031C 0x0620 0x0 0x3
191 #define MX6UL_PAD_UART1_RTS_B__UART1_DTE_CTS 0x0090 0x031C 0x0000 0x0 0x0
192 #define MX6UL_PAD_UART1_RTS_B__ENET1_TX_ER 0x0090 0x031C 0x0000 0x1 0x0
193 #define MX6UL_PAD_UART1_RTS_B__USDHC1_CD_B 0x0090 0x031C 0x0668 0x2 0x1
194 #define MX6UL_PAD_UART1_RTS_B__CSI_DATA05 0x0090 0x031C 0x04CC 0x3 0x1
195 #define MX6UL_PAD_UART1_RTS_B__ENET2_1588_EVENT1_OUT 0x0090 0x031C 0x0000 0x4 0x0
196 #define MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x0090 0x031C 0x0000 0x5 0x0
197 #define MX6UL_PAD_UART1_RTS_B__USDHC2_CD_B 0x0090 0x031C 0x0674 0x8 0x2
示例代码 45.1.2.4 中一共有 8 个以“ MX6UL_PAD_UART1_RTS_B”开头的宏定义，大家
仔细观察应该就能发现，这 8 个宏定义分别对应 UART1_RTS_B 这个 PIN 的 8 个复用 IO。查
阅《 I.MX6ULL 参考手册》可以知 UART1_RTS_B 的可选复用 IO。
示 例 代 码 196 行 的 宏 定 义 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 表 示 将
UART1_RTS_B 这个 IO 复用为 GPIO1_IO19。此宏定义后面跟着 5 个数字，也就是这个宏定义
的具体值，如下所示：
0x0090 0x031C 0x0000 0x5 0x0
这 5 个值的含义如下所示：
<mux_reg conf_reg input_reg mux_mode input_val>
综上所述可知：
0x0090： mux_reg 寄存器偏移地址，设备树中的 iomuxc 节点就是 IOMUXC 外设对应的节
点 ， 根 据 其 reg 属 性 可 知 IOMUXC 外 设 寄 存 器 起 始 地 址 为 0x020e0000 。 因 此
0x020e0000+0x0090=0x020e0090， IOMUXC_SW_MUX_CTL_PAD_UART1_RTS_B 寄存器地址
正 好 是 0x020e0090 ， 大 家 可 以 在 《 IMX6ULL 参 考 手 册 》 中 找 到
IOMUXC_SW_MUX_CTL_PAD_UART1_RTS_B 这个寄存器的位域图。
因此可知， 0x020e0000+mux_reg 就是 PIN 的复用寄存器地址。
0x031C： conf_reg 寄存器偏移地址，和 mux_reg 一样， 0x020e0000+0x031c=0x020e031c，
这个就是寄存器 IOMUXC_SW_PAD_CTL_PAD_UART1_RTS_B 的地址。
0x0000： input_reg 寄存器偏移地址，有些外设有 input_reg 寄存器，有 input_reg 寄存器的
外设需要配置 input_reg 寄存器。没有的话就不需要设置， UART1_RTS_B 这个 PIN 在做
GPIO1_IO19 的时候是没有 input_reg 寄存器，因此这里 intput_reg 是无效的。
0x5 ： mux_reg 寄 存 器 值 ， 在 这 里 就 相 当 于 设 置
IOMUXC_SW_MUX_CTL_PAD_UART1_RTS_B 寄存器为 0x5，也即是设置 UART1_RTS_B 这
个 PIN 复用为 GPIO1_IO19。
0x0： input_reg 寄存器值，在这里无效。
这就是宏 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 的含义，看的比较仔细的同学应该
会发现并没有 conf_reg 寄存器的值， config_reg 寄存器是设置一个 PIN 的电气特性的，这么重
要的寄存器怎么没有值呢？回到示例代码 45.1.2.3 中，第 9 行的内容如下所示：
MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x17059
MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 我们上面已经分析了，就剩下了一个 0x17059，
反应快的同学应该已经猜出来了， 0x17059 就是 conf_reg 寄存器值！此值由用户自行设置，通
过此值来设置一个 IO 的上 /下拉、驱动能力和速度等。在这里就相当于设置寄存器
IOMUXC_SW_PAD_CTL_PAD_UART1_RTS_B 的值为 0x17059。
2、 PIN 驱动程序讲解
本小节会涉及到 Linux 驱动分层与分离、 平台设备驱动等还未讲解的知识，所以本小节教
程可以不用看，不会影响后续的实验。如果对 Linux 内核的 pinctrl 子系统实现原理感兴趣的话
可以看本小节。
所有的东西都已经准备好了，包括寄存器地址和寄存器值， Linux 内核相应的驱动文件就
会根据这些值来做相应的初始化。接下来就找一下哪个驱动文件来做这一件事情， iomuxc 节点
中 compatible 属性的值为“ fsl,imx6ul-iomuxc”，在 Linux 内核中全局搜索“ fsl,imx6ul-iomuxc”
字符串就会找到对应的驱动文件。在文件 drivers/pinctrl/freescale/pinctrl-imx6ul.c中有如下内容：
示例代码 45.1.2.5 pinctrl-imx6ul.c 文件代码段
326 static struct of_device_id imx6ul_pinctrl_of_match[] = {
327 { .compatible = "fsl,imx6ul-iomuxc", .data = &imx6ul_pinctrl_info, },
328 { .compatible = "fsl,imx6ull-iomuxc-snvs", .data = &imx6ull_snvs_pinctrl_info, },
329 { /* sentinel */ }
330 };
331
332 static int imx6ul_pinctrl_probe(struct platform_device *pdev)
333 {
334 const struct of_device_id *match;
335 struct imx_pinctrl_soc_info *pinctrl_info;
337 match = of_match_device(imx6ul_pinctrl_of_match, &pdev->dev);
339 if (!match)
340 return -ENODEV;
342 pinctrl_info = (struct imx_pinctrl_soc_info *) match->data;
344 return imx_pinctrl_probe(pdev, pinctrl_info);
345 }
346
347 static struct platform_driver imx6ul_pinctrl_driver = {
348 .driver = {
349 .name = "imx6ul-pinctrl",
350 .owner = THIS_MODULE,
351 .of_match_table = of_match_ptr(imx6ul_pinctrl_of_match),
352 },
353 .probe = imx6ul_pinctrl_probe,
354 .remove = imx_pinctrl_remove,
355 };
第 326~330 行，of_device_id 结构体数组，第四十三章讲解设备树的时候说过了，of_device_id
里面保存着这个驱动文件的兼容性值，设备树中的 compatible 属性值会和 of_device_id 中的所
有兼容性字符串比较，查看是否可以使用此驱动。 imx6ul_pinctrl_of_match 结构体数组一共有两
个兼容性字符串， 分别为“ fsl,imx6ul-iomuxc”和“ fsl,imx6ull-iomuxc-snvs”，因此 iomuxc 节点
与此驱动匹配，所以 pinctrl-imx6ul.c 会完成 I.MX6ULL 的 PIN 配置工作。
第 347~355 行， platform_driver 是平台设备驱动，这个是我们后面章节要讲解的内容，
platform_driver 是个结构体，有个 probe 成员变量。在这里大家只需要知道，当设备和驱动匹配
成功以后 platform_driver 的 probe 成员变量所代表的函数就会执行，在 353 行设置 probe 成员变
量为 imx6ul_pinctrl_probe 函数，因此在本章实验中 imx6ul_pinctrl_probe 这个函数就会执行，可
以认为 imx6ul_pinctrl_probe 函数就是 I.MX6ULL 这个 SOC 的 PIN 配置入口函数。以此为入口，
如图 45.1.2.3 所示的函数调用路径：
imx6ul_pinctrl_probe()-->imx_pinctrl_probe()-->imx_pinctrl_probe_dt()-->imx_pinctrl_parse_functions()-->imx_pinctrl_parse_groups()---解析设备树中关于PIN的配置信息，也就是6个u32类型的数据值。 也就是mux_reg、 conf_reg、input_reg、 mux_mode、 input_val和config值
|
-->pinctrl_register()---向Linux内核注册pinctrl
在图 45.1.2.3 中函数 imx_pinctrl_parse_groups 负责获取设备树中关于 PIN 的配置信息，也
就是我们前面分析的那 6 个 u32 类型的值。处理过程如下所示：
示例代码 45.1.2.6 imx_pinctrl_parse_groups 函数代码段
488 /*
489 * Each pin represented in fsl,pins consists of 5 u32 PIN_FUNC_ID
490 * and 1 u32 CONFIG, so 24 types in total for each pin.
491 */
492 #define FSL_PIN_SIZE 24
493 #define SHARE_FSL_PIN_SIZE 20
494
495 static int imx_pinctrl_parse_groups(struct device_node *np,
496 struct imx_pin_group *grp,
497 struct imx_pinctrl_soc_info *info,
498 u32 index)
499 {
500 int size, pin_size;
501 const __be32 *list;
502 int i;
503 u32 config;
......
537
538 for (i = 0; i < grp->npins; i++) {
539 u32 mux_reg = be32_to_cpu(*list++);
540 u32 conf_reg;
541 unsigned int pin_id;
542 struct imx_pin_reg *pin_reg;
543 struct imx_pin *pin = &grp->pins[i];
544
......
555
556 pin_id = (mux_reg != -1) ? mux_reg / 4 : conf_reg / 4;
557 pin_reg = &info->pin_regs[pin_id];
558 pin->pin = pin_id;
559 grp->pin_ids[i] = pin_id;
560 pin_reg->mux_reg = mux_reg;
561 pin_reg->conf_reg = conf_reg;
562 pin->input_reg = be32_to_cpu(*list++);
563 pin->mux_mode = be32_to_cpu(*list++);
564 pin->input_val = be32_to_cpu(*list++);
565
566 /* SION bit is in mux register */
567 config = be32_to_cpu(*list++);
568 if (config & IMX_PAD_SION)
569 pin->mux_mode |= IOMUXC_CONFIG_SION;
570 pin->config = config & ~IMX_PAD_SION;
......
574 }
575
576 return 0;
577 }
第 496 和 497 行，设备树中的 mux_reg 和 conf_reg 值会保存在 info 参数中， input_reg、
mux_mode、 input_val 和 config 值会保存在 grp 参数中。
第 560~564 行，获取 mux_reg、 conf_reg、 input_reg、 mux_mode 和 input_val 值。
第 570 行，获取 config 值。
接下来看一下函数 pinctrl_register，此函数用于向 Linux 内核注册一个 PIN 控制器，此函数
原型如下：
struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
struct device *dev,
void *driver_data)
参数 pctldesc 非常重要，因为此参数就是要注册的 PIN 控制器， PIN 控制器用于配置 SOC
的 PIN 复用功能和电气特性。参数 pctldesc 是 pinctrl_desc 结构体类型指针， pinctrl_desc 结构体
如下所示：
示例代码 45.1.2.7 pinctrl_desc 结构体
128 struct pinctrl_desc {
129 const char *name;
130 struct pinctrl_pin_desc const *pins;
131 unsigned int npins;
132 const struct pinctrl_ops *pctlops;
133 const struct pinmux_ops *pmxops;
134 const struct pinconf_ops *confops;
135 struct module *owner;
136 #ifdef CONFIG_GENERIC_PINCONF
137 unsigned int num_custom_params;
138 const struct pinconf_generic_params *custom_params;
139 const struct pin_config_item *custom_conf_items;
140 #endif
141 };
第 132~124 行，这三个“ _ops”结构体指针非常重要！！！因为这三个结构体就是 PIN 控制
器的“工具”，这三个结构体里面包含了很多操作函数，通过这些操作函数就可以完成对某一个
PIN 的配置。 pinctrl_desc 结构体需要由用户提供，结构体里面的成员变量也是用户提供的。但
是这个用户并不是我们这些使用芯片的程序员，而是半导体厂商，半导体厂商发布的 Linux 内
核源码中已经把这些工作做完了。比如在 imx_pinctrl_probe 函数中可以找到如下所示代码：
示例代码 45.1.2.8 imx_pinctrl_probe 函数代码段
648 int imx_pinctrl_probe(struct platform_device *pdev,
649 struct imx_pinctrl_soc_info *info)
650 {
651 struct device_node *dev_np = pdev->dev.of_node;
652 struct device_node *np;
653 struct imx_pinctrl *ipctl;
654 struct resource *res;
655 struct pinctrl_desc *imx_pinctrl_desc;
......
663
664 imx_pinctrl_desc = devm_kzalloc(&pdev->dev,sizeof(*imx_pinctrl_desc),GFP_KERNEL);
666 if (!imx_pinctrl_desc)
667 return -ENOMEM;
......
706 imx_pinctrl_desc->name = dev_name(&pdev->dev);
707 imx_pinctrl_desc->pins = info->pins;
708 imx_pinctrl_desc->npins = info->npins;
709 imx_pinctrl_desc->pctlops = &imx_pctrl_ops;
710 imx_pinctrl_desc->pmxops = &imx_pmx_ops;
711 imx_pinctrl_desc->confops = &imx_pinconf_ops;
712 imx_pinctrl_desc->owner = THIS_MODULE;
......
723 ipctl->pctl = pinctrl_register(imx_pinctrl_desc, &pdev->dev,ipctl);
......
732 }
第 655 行，定义结构体指针变量 imx_pinctrl_desc。
第 664 行，向指针变量 imx_pinctrl_desc 分配内存。
第 706~712 行，初始化 imx_pinctrl_desc 结构体指针变量，重点是 pctlops、pmxops 和 confops
这三个成员变量，分别对应 imx_pctrl_ops、 imx_pmx_ops 和 imx_pinconf_ops 这三个结构体。
第 723 行，调用函数 pinctrl_register 向 Linux 内核注册 imx_pinctrl_desc，注册以后 Linux 内
核就有了对 I.MX6ULL 的 PIN 进行配置的工具。
imx_pctrl_ops、 imx_pmx_ops 和 imx_pinconf_ops 这三个结构体定义如下：
示例代码 45.1.2.9 imx_pctrl_ops、 imx_pmx_ops 和 imx_pinconf_ops 结构体
174 static const struct pinctrl_ops imx_pctrl_ops = {
175 .get_groups_count = imx_get_groups_count,
176 .get_group_name = imx_get_group_name,
177 .get_group_pins = imx_get_group_pins,
178 .pin_dbg_show = imx_pin_dbg_show,
179 .dt_node_to_map = imx_dt_node_to_map,
180 .dt_free_map = imx_dt_free_map,
182 };
......
374 static const struct pinmux_ops imx_pmx_ops = {
375 .get_functions_count = imx_pmx_get_funcs_count,
376 .get_function_name = imx_pmx_get_func_name,
377 .get_function_groups = imx_pmx_get_groups,
378 .set_mux = imx_pmx_set,
379 .gpio_request_enable = imx_pmx_gpio_request_enable,
380 .gpio_set_direction = imx_pmx_gpio_set_direction,
381 };
......
481 static const struct pinconf_ops imx_pinconf_ops = {
482 .pin_config_get = imx_pinconf_get,
483 .pin_config_set = imx_pinconf_set,
484 .pin_config_dbg_show = imx_pinconf_dbg_show,
485 .pin_config_group_dbg_show = imx_pinconf_group_dbg_show,
486 };
示例代码 45.1.2.9 中这三个结构体下的所有函数就是 I.MX6ULL 的 PIN 配置函数，我们就
此打住，不再去分析这些函数了，否则本章就没完没了了，有兴趣的可以去看一下。
45.1.3 设备树中添加 pinctrl 节点模板
我们已经对 pinctrl 有了比较深入的了解，接下来我们学习一下如何在设备树中添加某个外
设 的 PIN 信 息 。 关 于 I.MX 系 列 SOC 的 pinctrl 设 备 树 绑 定 信 息 可 以 参 考 文 档
Documentation/devicetree/bindings/pinctrl/fsl,imx-pinctrl.txt。这里我们虚拟一个名为“ test”的设
备， test 使用了 GPIO1_IO00 这个 PIN 的 GPIO 功能， pinctrl 节点添加过程如下：
1、创建对应的节点
同一个外设的 PIN 都放到一个节点里面，打开 imx6ull-alientek-emmc.dts，在 iomuxc 节点
中的“ imx6ul-evk”子节点下添加“ pinctrl_test”节点，注意！节点前缀一定要为“ pinctrl_”。添
加完成以后如下所示：
示例代码 45.1.2.10 test 设备 pinctrl 节点
1 pinctrl_test: testgrp {
2 /* 具体的 PIN 信息 */
3 };
2、添加“ fsl,pins”属性
设备树是通过属性来保存信息的，因此我们需要添加一个属性，属性名字一定要为“ fsl,pins”，
因为对于 I.MX 系列 SOC 而言， pinctrl 驱动程序是通过读取“ fsl,pins”属性值来获取 PIN 的配
置信息，完成以后如下所示：
示例代码 45.1.2.11 添加"fsl,pins"属性
1 pinctrl_test: testgrp {
2 fsl,pins = <
3 /* 设备所使用的 PIN 配置信息 */
4 >;
5 };
3、在“ fsl,pins”属性中添加 PIN 配置信息
最后在“ fsl,pins”属性中添加具体的 PIN 配置信息，完成以后如下所示：
示例代码 45.1.2.13 完整的 test 设备 pinctrl 子节点
1 pinctrl_test: testgrp {
2 fsl,pins = <
3 MX6UL_PAD_GPIO1_IO00__GPIO1_IO00 config /*config 是具体设置值*/
4 >;
5 };
至此，我们已经在 imx6ull-alientek-emmc.dts 文件中添加好了 test 设备所使用的 PIN 配置信息。
45.2 gpio 子系统
45.2.1 gpio 子系统简介
上一小节讲解了 pinctrl 子系统， pinctrl 子系统重点是设置 PIN(有的 SOC 叫做 PAD)的复用
和电气属性，如果 pinctrl 子系统将一个 PIN 复用为 GPIO 的话，那么接下来就要用到 gpio 子系
统了。 gpio 子系统顾名思义，就是用于初始化 GPIO 并且提供相应的 API 函数，比如设置 GPIO
为输入输出，读取 GPIO 的值等。 gpio 子系统的主要目的就是方便驱动开发者使用 gpio，驱动
开发者在设备树中添加 gpio 相关信息，然后就可以在驱动程序中使用 gpio 子系统提供的 API
函数来操作 GPIO， Linux 内核向驱动开发者屏蔽掉了 GPIO 的设置过程，极大的方便了驱动开
发者使用 GPIO。
45.2.2 I.MX6ULL 的 gpio 子系统驱动
1、设备树中的 gpio 信息
I.MX6ULL-ALPHA 开发板上的 UART1_RTS_B 做为 SD 卡的检测引脚， UART1_RTS_B 复
用为 GPIO1_IO19，通过读取这个 GPIO 的高低电平就可以知道 SD 卡有没有插入。首先肯定是
将 UART1_RTS_B 这个 PIN 复用为 GPIO1_IO19，并且设置电气属性，也就是上一小节讲的
pinctrl 节点。打开 imx6ull-alientek-emmc.dts， UART1_RTS_B 这个 PIN 的 pincrtl 设置如下：
示例代码 45.2.2.1 SD 卡 CD 引脚 PIN 配置参数
316 pinctrl_hog_1: hoggrp-1 {
317 fsl,pins = <
318 MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x17059 /* SD1 CD */
......
322 >;
323 };
第 318 行，设置 UART1_RTS_B 这个 PIN 为 GPIO1_IO19。
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 卡设备节点，如下所示：
示例代码 45.2.2.2 设备树中 SD 卡节点
760 &usdhc1 {
761 pinctrl-names = "default", "state_100mhz", "state_200mhz";
762 pinctrl-0 = <&pinctrl_usdhc1>;
763 pinctrl-1 = <&pinctrl_usdhc1_100mhz>;
764 pinctrl-2 = <&pinctrl_usdhc1_200mhz>;
765 /* pinctrl-3 = <&pinctrl_hog_1>; */
766 cd-gpios = <&gpio1 19 GPIO_ACTIVE_LOW>;
767 keep-power-in-suspend;
768 enable-sdio-wakeup;
769 vmmc-supply = <®_sd1_vmmc>;
770 status = "okay";
771 };
第 765 行，此行本来没有，是作者添加的， usdhc1 节点作为 SD 卡设备总节点， usdhc1 节
点需要描述 SD 卡所有的信息，因为驱动要使用。本行就是描述 SD 卡的 CD 引脚 pinctrl 信息
所在的子节点，因为 SD 卡驱动需要根据 pincrtl 节点信息来设置 CD 引脚的复用功能等。762~764
行的 pinctrl-0~2 都是 SD 卡其他 PIN 的 pincrtl 节点信息。但是大家会发现，其实在 usdhc1 节点
中并没有“ pinctrl-3 = <&pinctrl_hog_1>”这一行，也就是说并没有指定 CD 引脚的 pinctrl 信息，
那么 SD 卡驱动就没法设置 CD 引脚的复用功能啊？这个不用担心，因为在“ iomuxc”节点下
引用了 pinctrl_hog_1 这个节点，所以 Linux 内核中的 iomuxc 驱动就会自动初始化 pinctrl_hog_1
节点下的所有 PIN。
第 766 行，属性“ cd-gpios”描述了 SD 卡的 CD 引脚使用的哪个 IO。属性值一共有三个，
我们来看一下这三个属性值的含义，“ &gpio1”表示 CD 引脚所使用的 IO 属于 GPIO1 组，“ 19”
表示 GPIO1 组的第 19 号 IO，通过这两个值 SD 卡驱动程序就知道 CD 引脚使用了 GPIO1_IO19
这 GPIO。“ GPIO_ACTIVE_LOW”表示低电平有效，如果改为“ GPIO_ACTIVE_HIGH”就表
示高电平有效。
根据上面这些信息， SD 卡驱动程序就可以使用 GPIO1_IO19 来检测 SD 卡的 CD 信号了，
打开 imx6ull.dtsi，在里面找到如下所示内容：
示例代码 45.2.2.2 gpio1 节点
504 gpio1: gpio@0209c000 {
505 compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
506 reg = <0x0209c000 0x4000>;
507 interrupts = <GIC_SPI 66 IRQ_TYPE_LEVEL_HIGH>,
508 <GIC_SPI 67 IRQ_TYPE_LEVEL_HIGH>;
509 gpio-controller;
510 #gpio-cells = <2>;
511 interrupt-controller;
512 #interrupt-cells = <2>;
513 };
gpio1 节点信息描述了 GPIO1 控制器的所有信息，重点就是 GPIO1 外设寄存器基地址以及
兼 容 属 性 。 关 于 I.MX 系 列 SOC 的 GPIO 控 制 器 绑 定 信 息 请 查 看 文 档
Documentation/devicetree/bindings/gpio/ fsl-imx-gpio.txt。
第 505 行，设置 gpio1 节点的 compatible 属性有两个，分别为“ fsl,imx6ul-gpio”和“ fsl,imx35-
gpio”，在 Linux 内核中搜索这两个字符串就可以找到 I.MX6UL 的 GPIO 驱动程序。
第 506 行，的 reg 属性设置了 GPIO1 控制器的寄存器基地址为 0X0209C000，大家可以打
开《 I.MX6ULL 参考手册》找到“ Chapter 28:General Purpose Input/Output(GPIO)”章节第 28.5 小
节，有如图 45.2.2.1 所示的寄存器地址表：
略
从图 45.2.2.1 可以看出， GPIO1 控制器的基地址就是 0X0209C000。
第 509 行，“ gpio-controller”表示 gpio1 节点是个 GPIO 控制器。
第 510 行，“ #gpio-cells”属性和“ #address-cells”类似， #gpio-cells 应该为 2，表示一共有
两个 cell，第一个 cell 为 GPIO 编号，比如“ &gpio1 3”就表示 GPIO1_IO03。第二个 cell 表示
GPIO 极 性 ， 如 果 为 0(GPIO_ACTIVE_HIGH) 的 话 表 示 高 电 平 有 效 ， 如 果 为
1(GPIO_ACTIVE_LOW)的话表示低电平有效。
2、 GPIO 驱动程序简介
本小节会涉及到 Linux 驱动分层与分离、平台设备驱动等还未讲解的知识，所以本小节教
程可以不用看，不会影响后续的实验。如果对 Linux 内核的 GPIO 子系统实现原理感兴趣的话
可以看本小节。
gpio1 节点的 compatible 属性描述了兼容性，在 Linux 内核中搜索“ fsl,imx6ul-gpio”和
“ fsl,imx35-gpio”这两个字符串，查找 GPIO 驱动文件。 drivers/gpio/gpio-mxc.c 就是 I.MX6ULL
的 GPIO 驱动文件，在此文件中有如下所示 of_device_id 匹配表：
示例代码 45.2.2.3 mxc_gpio_dt_ids 匹配表
152 static const struct of_device_id mxc_gpio_dt_ids[] = {
153 { .compatible = "fsl,imx1-gpio", .data = &mxc_gpio_devtype[IMX1_GPIO], },
154 { .compatible = "fsl,imx21-gpio", .data = &mxc_gpio_devtype[IMX21_GPIO], },
155 { .compatible = "fsl,imx31-gpio", .data = &mxc_gpio_devtype[IMX31_GPIO], },
156 { .compatible = "fsl,imx35-gpio", .data = &mxc_gpio_devtype[IMX35_GPIO], },
157 { /* sentinel */ }
158 };
第 156 行的 compatible 值为“ fsl,imx35-gpio”，和 gpio1 的 compatible 属性匹配，
因此 gpiomxc.c 就是 I.MX6ULL 的 GPIO 控制器驱动文件。 gpio-mxc.c 所在的目录为 drivers/gpio，
打开这个目录可以看到很多芯片的 gpio 驱动文件， “ gpiolib”开始的文件是 gpio 驱动的核心文件，
如图 45.2.2.2 所示：
gpiolib.c
gpiolib.h
gpiolib-acpi.c
gpiolib-legacy.c
gpiolib-of.c
gpiolib-sysfs.c
图 45.2.2.2 gpio 核心驱动文件
我们重点来看一下 gpio-mxc.c 这个文件，在 gpio-mxc.c 文件中有如下所示内容：
示例代码 45.2.2.4 mxc_gpio_driver 结构体
496 static struct platform_driver mxc_gpio_driver = {
497 .driver = {
498 .name = "gpio-mxc",
499 .of_match_table = mxc_gpio_dt_ids,
500 },
501 .probe = mxc_gpio_probe,
502 .id_table = mxc_gpio_devtype,
503 };
可以看出 GPIO 驱动也是个平台设备驱动，因此当设备树中的设备节点与驱动的
of_device_id 匹配以后 probe 函数就会执行，在这里就是 mxc_gpio_probe 函数，这个函数就是
I.MX6ULL 的 GPIO 驱动入口函数。我们简单来分析一下 mxc_gpio_probe 这个函数，函数内容
如下：
示例代码 45.2.2.5 mxc_gpio_probe 函数
403 static int mxc_gpio_probe(struct platform_device *pdev)
404 {
405 struct device_node *np = pdev->dev.of_node;
406 struct mxc_gpio_port *port;
407 struct resource *iores;
408 int irq_base;
409 int err;
411 mxc_gpio_get_hw(pdev);
413 port = devm_kzalloc(&pdev->dev, sizeof(*port), GFP_KERNEL);
414 if (!port) return -ENOMEM;
417 iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
418 port->base = devm_ioremap_resource(&pdev->dev, iores);
419 if (IS_ERR(port->base))
420 return PTR_ERR(port->base);
422 port->irq_high = platform_get_irq(pdev, 1);
423 port->irq = platform_get_irq(pdev, 0);
424 if (port->irq < 0)
425 return port->irq;
427 /* disable the interrupt and clear the status */
428 writel(0, port->base + GPIO_IMR);
429 writel(~0, port->base + GPIO_ISR);
431 if (mxc_gpio_hwtype == IMX21_GPIO) {
432 /*
433 * Setup one handler for all GPIO interrupts. Actually
434 * setting the handler is needed only once, but doing it for
435 * every port is more robust and easier.
436 */
437 irq_set_chained_handler(port->irq, mx2_gpio_irq_handler);
438 } else {
439 /* setup one handler for each entry */
440 irq_set_chained_handler(port->irq, mx3_gpio_irq_handler);
441 irq_set_handler_data(port->irq, port);
442 if (port->irq_high > 0) {
443 /* setup handler for GPIO 16 to 31 */
444 irq_set_chained_handler(port->irq_high,
445 mx3_gpio_irq_handler);
446 irq_set_handler_data(port->irq_high, port);
447 }
448 }
450 err = bgpio_init(&port->bgc, &pdev->dev, 4,
451 port->base + GPIO_PSR,
452 port->base + GPIO_DR, NULL,
453 port->base + GPIO_GDIR, NULL, 0);
454 if (err) goto out_bgio;
457 port->bgc.gc.to_irq = mxc_gpio_to_irq;
458 port->bgc.gc.base = (pdev->id < 0) ? of_alias_get_id(np, "gpio")
459 * 32 : pdev->id * 32;
461 err = gpiochip_add(&port->bgc.gc);
462 if (err)
463 goto out_bgpio_remove;
465 irq_base = irq_alloc_descs(-1, 0, 32, numa_node_id());
466 if (irq_base < 0) {
467 err = irq_base;
468 goto out_gpiochip_remove;
469 }
471 port->domain = irq_domain_add_legacy(np, 32, irq_base, 0,
472 &irq_domain_simple_ops, NULL);
473 if (!port->domain) {
474 err = -ENODEV;
475 goto out_irqdesc_free;
476 }
478 /* gpio-mxc can be a generic irq chip */
479 mxc_gpio_init_gc(port, irq_base);
481 list_add_tail(&port->node, &mxc_gpio_ports);
483 return 0;
......
494 }
第 405 行，设备树节点指针。
第 406 行，定义一个结构体指针 port，结构体类型为 mxc_gpio_port。 gpio-mxc.c 的重点工
作就是维护 mxc_gpio_port， mxc_gpio_port 就是对 I.MX6ULL GPIO 的抽象。 mxc_gpio_port 结
构体定义如下：
示例代码 45.2.2.6 mxc_gpio_port 结构体
61 struct mxc_gpio_port {
62 struct list_head node;
63 void __iomem *base;
64 int irq;
65 int irq_high;
66 struct irq_domain *domain;
67 struct bgpio_chip bgc;
68 u32 both_edges;
69 };
mxc_gpio_port 的 bgc 成员变量很重要，因为稍后的重点就是初始化 bgc。
继续回到 mxc_gpio_probe 函数函数，第 411 行调用 mxc_gpio_get_hw 函数获取 gpio 的硬
件相关数据，其实就是 gpio 的寄存器组，函数 mxc_gpio_get_hw 里面有如下代码：
示例代码 45.2.2.7 mxc_gpio_get_hw 函数
364 static void mxc_gpio_get_hw(struct platform_device *pdev)
365 {
366 const struct of_device_id *of_id =
367 of_match_device(mxc_gpio_dt_ids, &pdev->dev);
368 enum mxc_gpio_hwtype hwtype;
......
384 if (hwtype == IMX35_GPIO)
385 mxc_gpio_hwdata = &imx35_gpio_hwdata;
386 else if (hwtype == IMX31_GPIO)
387 mxc_gpio_hwdata = &imx31_gpio_hwdata;
388 else
389 mxc_gpio_hwdata = &imx1_imx21_gpio_hwdata;
391 mxc_gpio_hwtype = hwtype;
392 }
注意第 385 行， mxc_gpio_hwdata 是个全局变量，如果硬件类型是 IMX35_GPIO 的话设置
mxc_gpio_hwdat 为 imx35_gpio_hwdata。对于 I.MX6ULL 而言，硬件类型就是 IMX35_GPIO，
imx35_gpio_hwdata 是个结构体变量，描述了 GPIO 寄存器组，内容如下：
示例代码 45.2.2.8 imx35_gpio_hwdata 结构体
101 static struct mxc_gpio_hwdata imx35_gpio_hwdata = {
102 .dr_reg = 0x00,
103 .gdir_reg = 0x04,
104 .psr_reg = 0x08,
105 .icr1_reg = 0x0c,
106 .icr2_reg = 0x10,
107 .imr_reg = 0x14,
108 .isr_reg = 0x18,
109 .edge_sel_reg = 0x1c,
110 .low_level = 0x00,
111 .high_level = 0x01,
112 .rise_edge = 0x02,
113 .fall_edge = 0x03,
114 };
大家将 imx35_gpio_hwdata 中的各个成员变量和图 45.2.2.1 中的 GPIO 寄存器表对比就会发
现， imx35_gpio_hwdata 结构体就是 GPIO 寄存器组结构。这样我们后面就可以通过
mxc_gpio_hwdata 这个全局变量来访问 GPIO 的相应寄存器了。
继 续 回 到 示 例 代 码 45.2.2.5 的 mxc_gpio_probe 函 数 中 ， 第 417 行 ， 调 用 函 数
platform_get_resource 获取设备树中内存资源信息，也就是 reg 属性值。前面说了 reg 属性指定
了 GPIO1 控制器的寄存器基地址为 0X0209C000，在配合前面已经得到的 mxc_gpio_hwdata，
这样 Linux 内核就可以访问 gpio1 的所有寄存器了。
第 418 行，调用 devm_ioremap_resource 函数进行内存映射，得到 0x0209C000 在 Linux 内
核中的虚拟地址。
第 422、 423 行，通过 platform_get_irq 函数获取中断号，第 422 行获取高 16 位 GPIO 的中
断号，第 423 行获取底 16 位 GPIO 中断号。
第 428、 429 行，操作 GPIO1 的 IMR 和 ISR 这两个寄存器，关闭 GPIO1 所有 IO 中断，并
且清除状态寄存器。
第 438~448 行，设置对应 GPIO 的中断服务函数，不管是高 16 位还是低 16 位，中断服务
函数都是 mx3_gpio_irq_handler。
第 450~453 行， bgpio_init 函数第一个参数为 bgc，是 bgpio_chip 结构体指针。 bgpio_chip
结构体有个 gc 成员变量， gc 是个 gpio_chip 结构体类型的变量。 gpio_chip 结构体是抽象出来的
GPIO 控制器， gpio_chip 结构体如下所示(有缩减)：
示例代码 45.2.2.9 gpio_chip 结构体
74 struct gpio_chip {
75 const char *label;
76 struct device *dev;
77 struct module *owner;
78 struct list_head list;
80 int (*request)(struct gpio_chip *chip,unsigned offset);
82 void (*free)(struct gpio_chip *chip,unsigned offset);
84 int (*get_direction)(struct gpio_chip *chip,unsigned offset);
86 int (*direction_input)(struct gpio_chip *chip,unsigned offset);
88 int (*direction_output)(struct gpio_chip *chip,unsigned offset, int value);
90 int (*get)(struct gpio_chip *chip, unsigned offset);
92 void (*set)(struct gpio_chip *chip, unsigned offset, int value);
......
145 };
可以看出， gpio_chip 大量的成员都是函数，这些函数就是 GPIO 操作函数。 bgpio_init 函数
主 要 任 务 就 是 初 始 化 bgc->gc 。 bgpio_init 里 面 有 三 个 setup 函 数 ： bgpio_setup_io 、
bgpio_setup_accessors 和 bgpio_setup_direction。这三个函数就是初始化 bgc->gc 中的各种有关
GPIO 的操作，比如输出，输入等等。第 451~453 行的 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函数，第 461行调用函数 gpiochip_add向 Linux内核注册 gpio_chip，
也就是 port->bgc.gc。注册完成以后我们就可以在驱动中使用 gpiolib 提供的各个 API 函数。
45.2.3 gpio 子系统 API 函数
对于驱动开发人员，设置好设备树以后就可以使用 gpio 子系统提供的 API 函数来操作指定
的 GPIO， gpio 子系统向驱动开发人员屏蔽了具体的读写寄存器过程。这就是驱动分层与分离
的好处，大家各司其职，做好自己的本职工作即可。 gpio 子系统提供的常用的 API 函数有下面
几个：
1、 gpio_request 函数
gpio_request 函数用于申请一个 GPIO 管脚，在使用一个 GPIO 之前一定要使用 gpio_request
进行申请，函数原型如下：
int gpio_request(unsigned gpio, const char *label)
函数参数和返回值含义如下：
gpio：要申请的 gpio 标号，使用 of_get_named_gpio 函数从设备树获取指定 GPIO 属性信
息，此函数会返回这个 GPIO 的标号。
label：给 gpio 设置个名字。
返回值： 0，申请成功；其他值，申请失败。
2、 gpio_free 函数
如果不使用某个 GPIO 了，那么就可以调用 gpio_free 函数进行释放。函数原型如下：
void gpio_free(unsigned gpio)
函数参数和返回值含义如下：
gpio：要释放的 gpio 标号。
返回值： 无。
3、 gpio_direction_input 函数
此函数用于设置某个 GPIO 为输入，函数原型如下所示：
int gpio_direction_input(unsigned gpio)
函数参数和返回值含义如下：
gpio：要设置为输入的 GPIO 标号。
返回值： 0，设置成功；负值，设置失败。
4、 gpio_direction_output 函数
此函数用于设置某个 GPIO 为输出，并且设置默认输出值，函数原型如下：
int gpio_direction_output(unsigned gpio, int value)
函数参数和返回值含义如下：
gpio：要设置为输出的 GPIO 标号。
value： GPIO 默认输出值。
返回值： 0，设置成功；负值，设置失败。
5、 gpio_get_value 函数
此函数用于获取某个 GPIO 的值(0 或 1)，此函数是个宏，定义所示：
#define gpio_get_value __gpio_get_value
int __gpio_get_value(unsigned gpio)
函数参数和返回值含义如下：
gpio：要获取的 GPIO 标号。
返回值： 非负值，得到的 GPIO 值；负值，获取失败。
6、 gpio_set_value 函数
此函数用于设置某个 GPIO 的值，此函数是个宏，定义如下
#define gpio_set_value __gpio_set_value
void __gpio_set_value(unsigned gpio, int value)
函数参数和返回值含义如下：
gpio：要设置的 GPIO 标号。
value： 要设置的值。
返回值： 无
关于 gpio 子系统常用的 API 函数就讲这些，这些是我们用的最多的。
45.2.4 设备树中添加 gpio 节点模板
继续完成 45.1.3 中的 test 设备，在 45.1.3 中我们已经讲解了如何创建 test 设备的 pinctrl 节
点。本节我们来学习一下如何创建 test 设备的 GPIO 节点。
1、创建 test 设备节点
在根节点“ /”下创建 test 设备子节点，如下所示：
示例代码 45.2.4.1 test 设备节点
1 test {
2 /* 节点内容 */
3 };
2、添加 pinctrl 信息
在 45.1.3 中我们创建了 pinctrl_test 节点，此节点描述了 test 设备所使用的 GPIO1_IO00 这
个 PIN 的信息，我们要将这节点添加到 test 设备节点中，如下所示：
示例代码 45.2.4.2 向 test 节点添加 pinctrl 信息
1 test {
2 pinctrl-names = "default";
3 pinctrl-0 = <&pinctrl_test>;
4 /* 其他节点内容 */
5 };
第 2 行，添加 pinctrl-names 属性，此属性描述 pinctrl 名字为“ default”。
第 3 行，添加 pinctrl-0 节点，此节点引用 45.1.3 中创建的 pinctrl_test 节点，表示 tset 设备
的所使用的 PIN 信息保存在 pinctrl_test 节点中。
3、添加 GPIO 属性信息
我们最后需要在 test 节点中添加 GPIO 属性信息，表明 test 所使用的 GPIO 是哪个引脚，添
加完成以后如下所示：
示例代码 45.2.4.3 向 test 节点添加 gpio 属性
1 test {
2 pinctrl-names = "default";
3 pinctrl-0 = <&pinctrl_test>;
4 gpio = <&gpio1 0 GPIO_ACTIVE_LOW>;
5 };
第 4 行， test 设备所使用的 gpio。
关于 pinctrl 子系统和 gpio 子系统就讲解到这里，接下来就使用 pinctrl 和 gpio 子系统来驱
动 I.MX6ULL-ALPHA 开发板上的 LED 灯。
45.2.5 与 gpio 相关的 OF 函数
在示例代码 45.2.4.3 中，我们定义了一个名为“ gpio”的属性， gpio 属性描述了 test 这个设
备所使用的 GPIO。在驱动程序中需要读取 gpio 属性内容， Linux 内核提供了几个与 GPIO 有关
的 OF 函数，常用的几个 OF 函数如下所示：
1、 of_gpio_named_count 函数
of_gpio_named_count 函数用于获取设备树某个属性里面定义了几个 GPIO 信息，要注意的
是空的 GPIO 信息也会被统计到，比如：
gpios = <0
&gpio1 1 2
0
&gpio2 3 4>;
上述代码的“ gpios”节点一共定义了 4 个 GPIO，但是有 2 个是空的，没有实际的含义。
通过 of_gpio_named_count 函数统计出来的 GPIO 数量就是 4 个，此函数原型如下：
int of_gpio_named_count(struct device_node *np, const char *propname)
函数参数和返回值含义如下：
np：设备节点。
propname：要统计的 GPIO 属性。
返回值： 正值，统计到的 GPIO 数量；负值，失败。
2、 of_gpio_count 函数
和 of_gpio_named_count 函数一样，但是不同的地方在于，此函数统计的是“ gpios”这个属
性的 GPIO 数量，而 of_gpio_named_count 函数可以统计任意属性的 GPIO 信息，函数原型如下
所示：
int of_gpio_count(struct device_node *np)
函数参数和返回值含义如下：
np：设备节点。
返回值： 正值，统计到的 GPIO 数量；负值，失败。
3、 of_get_named_gpio 函数
此函数获取 GPIO 编号，因为 Linux 内核中关于 GPIO 的 API 函数都要使用 GPIO 编号，
此函数会将设备树中类似<&gpio5 7 GPIO_ACTIVE_LOW>的属性信息转换为对应的 GPIO 编
号，此函数在驱动中使用很频繁！函数原型如下：
int of_get_named_gpio(struct device_node *np,const char *propname,int index)
函数参数和返回值含义如下：
np：设备节点。
propname：包含要获取 GPIO 信息的属性名。
index： GPIO 索引，因为一个属性里面可能包含多个 GPIO，此参数指定要获取哪个 GPIO
的编号，如果只有一个 GPIO 信息的话此参数为 0。
返回值： 正值，获取到的 GPIO 编号；负值，失败。
45.4 实验程序编写
本实验对应的例程路径为： 开发板光盘-> 2、 Linux 驱动例程-> 5_gpioled。
本章实验我们继续研究 LED 灯，在第四十四章实验中我们通过设备树向 dtsled.c 文件传递
相应的寄存器物理地址，然后在驱动文件中配置寄存器。本章实验我们使用 pinctrl 和 gpio 子系
统来完成 LED 灯驱动。
45.4.1 修改设备树文件
1、添加 pinctrl 节点
I.MX6U-ALPHA 开发板上的 LED 灯使用了 GPIO1_IO03 这个 PIN，打开 imx6ull-alientekemmc.dts，在 iomuxc 节点的 imx6ul-evk 子节点下创建一个名为“ pinctrl_led”的子节点，节点
内容如下所示：
示例代码 45.4.1.1 GPIO1_IO03 pinctrl 节点
1 pinctrl_led: ledgrp {
2 fsl,pins = <
3 MX6UL_PAD_GPIO1_IO03__GPIO1_IO03 0x10B0 /* LED0 */
4 >;
5 };
第 3 行，将 GPIO1_IO03 这个 PIN 复用为 GPIO1_IO03，电气属性值为 0X10B0。
2、添加 LED 设备节点
在根节点“ /”下创建 LED 灯节点，节点名为“ gpioled”，节点内容如下：
示例代码 45.4.1.2 创建 LED 灯节点
1 gpioled {
2 #address-cells = <1>;
3 #size-cells = <1>;
4 compatible = "atkalpha-gpioled";
5 pinctrl-names = "default";
6 pinctrl-0 = <&pinctrl_led>;
7 led-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
8 status = "okay";
9 }
第 6 行， pinctrl-0 属性设置 LED 灯所使用的 PIN 对应的 pinctrl 节点。
第 7 行， led-gpio 属性指定了 LED 灯所使用的 GPIO，在这里就是 GPIO1 的 IO03，低电平
有效。稍后编写驱动程序的时候会获取 led-gpio 属性的内容来得到 GPIO 编号，因为 gpio 子系
统的 API 操作函数需要 GPIO 编号。
3、检查 PIN 是否被其他外设使用
这一点非常重要！！！
很多初次接触设备树的驱动开发人员很容易因为这个小问题栽了大跟头！因为我们所使用
的设备树基本都是在半导体厂商提供的设备树文件基础上修改而来的，而半导体厂商提供的设
备树是根据自己官方开发板编写的，很多 PIN 的配置和我们所使用的开发板不一样。比如 A 这
个引脚在官方开发板接的是 I2C 的 SDA，而我们所使用的硬件可能将 A 这个引脚接到了其他
的外设，比如 LED 灯上，接不同的外设， A 这个引脚的配置就不同。一个引脚一次只能实现一
个功能，如果 A 引脚在设备树中配置为了 I2C 的 SDA 信号，那么 A 引脚就不能再配置为 GPIO，
否则的话驱动程序在申请 GPIO 的时候就会失败。检查 PIN 有没有被其他外设使用包括两个方
面：
①、检查 pinctrl 设置。
②、如果这个 PIN 配置为 GPIO 的话，检查这个 GPIO 有没有被别的外设使用。
在本章实验中 LED 灯使用的 PIN 为 GPIO1_IO03，因此先检查 GPIO_IO03 这个 PIN 有没
有被其他的 pinctrl 节点使用，在 imx6ull-alientek-emmc.dts 中找到如下内容：
示例代码 45.4.1.3 pinctrl_tsc 节点
480 pinctrl_tsc: tscgrp {
481 fsl,pins = <
482 MX6UL_PAD_GPIO1_IO01__GPIO1_IO01 0xb0
483 MX6UL_PAD_GPIO1_IO02__GPIO1_IO02 0xb0
484 MX6UL_PAD_GPIO1_IO03__GPIO1_IO03 0xb0
485 MX6UL_PAD_GPIO1_IO04__GPIO1_IO04 0xb0
486 >;
487 };
pinctrl_tsc 节点是 TSC(电阻触摸屏接口)的 pinctrl 节点，从第 484 行可以看出，默认情况下
GPIO1_IO03 作为了 TSC 外设的 PIN。所以我们需要将第 484 行屏蔽掉！和 C 语言一样，在要
屏蔽的内容前后加上“ /*”和“ */”符号即可。其实在 I.MX6U-ALPHA 开发板上并没有用到 TSC
接口，所以第 482~485 行的内容可以全部屏蔽掉。
因为本章实验我们将 GPIO1_IO03 这个 PIN 配置为了 GPIO，所以还需要查找一下有没有
其他的外设使用了 GPIO1_IO03，在 imx6ull-alientek-emmc.dts 中搜索“ gpio1 3”，找到如下内
容：
示例代码 45.4.1.4 tsc 节点
723 &tsc {
724 pinctrl-names = "default";
725 pinctrl-0 = <&pinctrl_tsc>;
726 xnur-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
727 measure-delay-time = <0xffff>;
728 pre-charge-time = <0xfff>;
729 status = "okay";
730 };
tsc 是 TSC 的外设节点，从 726 行可以看出， tsc 外设也使用了 GPIO1_IO03，同样我们需
要将这一行屏蔽掉。然后在继续搜索“ gpio1 3”，看看除了本章的 LED 灯以外还有没有其他的
地方也使用了 GPIO1_IO03，找到一个屏蔽一个。
设备树编写完成以后使用“ make dtbs”命令重新编译设备树，然后使用新编译出来的
imx6ull-alientek-emmc.dtb 文件启动 Linux 系统。启动成功以后进入“ /proc/device-tree”目录中
查看“ gpioled”节点是否存在，如果存在的话就说明设备树基本修改成功。
45.4.2 LED 灯驱动程序编写
设备树准备好以后就可以编写驱动程序了，本章实验在第四十四章实验驱动文件 dtsled.c 的
基础上修改而来。新建名为“ 5_gpioled”文件夹，然后在 5_gpioled 文件夹里面创建 vscode 工
程，工作区命名为“ gpioled”。工程创建好以后新建 gpioled.c 文件，在 gpioled.c 里面输入如下
内容：
示例代码 45.4.2.1 gpioled.c 驱动文件代码
略
第 41 行，在设备结构体 gpioled_dev 中加入 led_gpio 这个成员变量，此成员变量保存 LED
等所使用的 GPIO 编号。
第 55 行，将设备结构体变量 gpioled 设置为 filp 的私有数据 private_data。
第 85 行，通过读取 filp 的 private_data 成员变量来得到设备结构体变量，也就是 gpioled。
这种将设备结构体设置为 filp 私有数据的方法在 Linux 内核驱动里面非常常见。
第 96、 97 行，直接调用 gpio_set_value 函数来向 GPIO 写入数据，实现开/关 LED 的效果。
不需要我们直接操作相应的寄存器。
第 133 行，获取节点“ /gpioled”。
第 142 行，通过函数 of_get_named_gpio 函数获取 LED 所使用的 LED 编号。相当于将
gpioled 节点中的“ led-gpio”属性值转换为对应的 LED 编号。
第 150 行，调用函数 gpio_direction_output 设置 GPIO1_IO03 这个 GPIO 为输出，并且默认
高电平，这样默认就会关闭 LED 灯。
可以看出 gpioled.c 文件中的内容和第四十四章的 dtsled.c 差不多，只是取消掉了配置寄存
器的过程，改为使用 Linux 内核提供的 API 函数。在 GPIO 操作上更加的规范化，符合 Linux
代码框架，而且也简化了 GPIO 驱动开发的难度，以后我们所有例程用到 GPIO 的地方都采用
此方法。
45.5 运行测试
45.5.1 编译驱动程序和测试 APP
1、编译驱动程序
编写 Makefile 文件，本章实验的 Makefile 文件和第四十章实验基本一样，只是将 obj-m 变
量的值改为 gpioled.o， Makefile 内容如下所示：
示例代码 45.5.1.1 Makefile 文件
1 KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek
......
4 obj-m := gpioled.o.o
......
11 clean:
12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第 4 行，设置 obj-m 变量的值为 gpioled.o。
输入如下命令编译出驱动模块文件：
make -j32
编译成功以后就会生成一个名为“ gpioled.ko”的驱动模块文件。
2、编译测试 APP
输入如下命令编译测试 ledApp.c 这个测试程序：
arm-linux-gnueabihf-gcc ledApp.c -o ledApp
编译成功以后就会生成 ledApp 这个应用程序。
45.5.2 运行测试
将上一小节编译出来的 gpioled.ko 和 ledApp 这两个文件拷贝到 rootfs/lib/modules/4.1.15 目
录中，重启开发板，进入到目录 lib/modules/4.1.15 中，输入如下命令加载 gpioled.ko 驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe gpioled.ko //加载驱动
驱动加载成功以后就可以使用 ledApp 软件来测试驱动是否工作正常，输入如下命令打开 LED灯：
./ledApp /dev/gpioled 1 //打开 LED 灯
在输入如下命令关闭 LED 灯：
./ledApp /dev/gpioled 0 //关闭 LED 灯
如果要卸载驱动的话输入如下命令即可：
rmmod gpioled.ko
参考文献
【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.3.pdf