princtrl子系统为了便于代码编辑者阅读代码，把寄存器的地址编号直接命名可读性强的名字。
1.pinctrl子系统
Linux内核提供了pinctrl子系统用来管理不同芯片厂商的pin脚的管理方法。
pinctrl可以帮助驱动工程师完成如下：
(1)从设备树中获取pin脚信息
(2)设置pin脚的复用功能
(3)配置pin脚的电气特性
设备树示例：

第一行：

1. pinctrl0: pinctrl@700 {
    

pinctrl0:pinctrl@700节点，就是ZYNQ中pinctrl子系统的节点。pinctrl0的父节点为slcr@f8000000，700是相对f8000000的偏移，也就是说pin的寄存器起始地址为0xf8000700

第二、三、四行都是设置好的，不用去关心。
第五行
pinctrl_uart1_default: uart1-default {
子设备节点:uart1-default
第六、十、十五、十九行
mux:配置pin脚的复用功能，其它三个配置pin脚的电气性能
conf:设置通用特性
conf-rx:设置输入引脚
conf-tx:设置输出引脚
第七行
groups:选择复用功能pin脚，可选的值有

ethernet0_0_grp, ethernet1_0_grp, mdio0_0_grp, mdio1_0_grp, qspi0_0_grp, qspi1_0_grp, 
qspi_fbclk, qspi_cs1_grp, spi0_0_grp - spi0_2_grp, spi0_X_ssY (X=0..2, Y=0..2), spi1_0_grp -
spi1_3_grp, spi1_X_ssY (X=0..3, Y=0..2), sdio0_0_grp - sdio0_2_grp, sdio1_0_grp - sdio1_3_grp, 
sdio0_emio_wp, sdio0_emio_cd, sdio1_emio_wp, sdio1_emio_cd, smc0_nor, smc0_nor_cs1_grp, 
smc0_nor_addr25_grp, smc0_nand, can0_0_grp - can0_10_grp, can1_0_grp - can1_11_grp, 
uart0_0_grp - uart0_10_grp, uart1_0_grp - uart1_11_grp, i2c0_0_grp - i2c0_10_grp, i2c1_0_grp -
i2c1_10_grp, ttc0_0_grp - ttc0_2_grp, ttc1_0_grp - ttc1_2_grp, swdt0_0_grp - swdt0_4_grp, 
gpio0_0_grp - gpio0_53_grp, usb0_0_grp, usb1_0_grp

第八行
function:选择pin脚分组的复用功能。

ethernet0, ethernet1, mdio0, mdio1, qspi0, qspi1, qspi_fbclk, qspi_cs1, spi0, spi0_ss, spi1, 
spi1_ss, sdio0, sdio0_pc, sdio0_cd, sdio0_wp, sdio1, sdio1_pc, sdio1_cd, sdio1_wp, smc0_nor, 
smc0_nor_cs1, smc0_nor_addr25, smc0_nand, can0, can1, uart0, uart1, i2c0, i2c1, ttc0, ttc1, swdt0, 
gpio0, usb0, usb1

第十、十五、十九
conf节点可以分为很多组，因为复用功能的pin组里面每个pin的电气性能可能会不同。
例如，输出pin脚：设置为偏置
输入pin脚：设置为高阻
conf节点必须pin和group二选一，
group属性和mux节点中的一样，
pin可选的值为：MIO0~MIO53，
第十三行：io-standard设置io电平标准，可选的值为
1:LVCMOS18 1.8V
2:LVCMOS252.5V
3:LVCMOS333.3V
4:HSTL
slew-rate：设置转换速率，等于0为slow，等于1为fast
low-power-disable、low-power-enable使能低功耗模式，在对应的conf节点中包含所需的偏置属性。
2.pinctrl子系统的使用

device是客户设备的节点，是调用pinctrl的设备
pinctrl-0是必选属性，是这个设备对应pin的pinctrl节点应用列表，如果这个设备对应多个pin，那就增加属性pinctrl-0~n。
pinctrl-names是下面pinctrl0~n的名称列表。
3.gpio接口函数

1. of函数扩展

int of_get_named_gpio(struct device_node *np, const char *propname, int index);

np:设备节点。
propname:属性名称，从属性中获取gpio编号。
index:需要获取的gpio下标。
返回值：gpio编号；返回负值则获取失败。
2.gpio_request()
linux内核提供的接口,申请GPIO

int gpio_request(unsigned int gpio, const char *label);

gpio:需要申请的gpio标号，通过上面介绍的of_get_named_gpio函数获取。
**label：**申请到的gpio标签
返回值：0表示成功，其它表示失败
3.gpio_free()
释放gpio，与gpio_request()对应

void gpio_free(unsigned int gpio);

gpio:需要释放的gpio标号
4.gpio_direction_input()
设置gpio 为输入，函数原型：

int gpio_direction_input(unsigned gpio);

gpio:需要设置的gpio标号
返回值：0表示成功，负值表示失败

5. gpio_direction_output()
   设置gpio 为输出，函数原型：

int gpio_direction_output(unsigned gpio, int value);

gpio:需要设置的gpio标号
value:输出的默认电平
返回值：0表示成功，负值表示失败。
6) gpio_get_value()
读取gpio的电平，原型

int __gpio_get_value(unsigned gpio);

gpio:需要读取的gpio标号
返回值：读取到的电平，负值表示失败
7) gpio_set_value()
设置gpio的电平，原型

void __gpio_set_value(unsigned gpio, int value);

gpio:需要操作的gpio标号
value:需要写入的电平

实验

8）原理图

9)设备树

/** ===================================================== **
 *Author : ALINX Electronic Technology (Shanghai) Co., Ltd.
 *Website: http://www.alinx.com
 *Address: Room 202, building 18, 
           No.518 xinbrick Road, 
           Songjiang District, Shanghai
 *Created: 2020-3-2 
 *Version: 1.0
 ** ===================================================== **/


/include/ "system-conf.dtsi"
/ {
    
	model = "Zynq ALINX Development Board";
	compatible = "alinx,zynq", "xlnx,zynq-7000";

	aliases {
    
		ethernet0 = "&gem0";
		serial0 = "&uart1";
	};

	usb_phy0: usb_phy@0 {
    
		compatible = "ulpi-phy";
		#phy-cells = <0>;
		reg = <0xe0002000 0x1000>;
		view-port = <0x0170>;
		drv-vbus;
	};

	amba {
    
		gpio@e000a000 {
    
			compatible = "xlnx,zynq-gpio-1.0";
			#gpio-cells = <0x2>;
			clocks = <0x1 0x2a>;
			gpio-controller;
			interrupt-controller;
			#interrupt-cells = <0x2>;
			interrupt-parent = <0x4>;
			interrupts = <0x0 0x14 0x4>;
			reg = <0xe000a000 0x1000>;
		};
	
		slcr@f8000000 {
    
			pinctrl@700 {
    
				pinctrl_led_default: led-default {
      
	                mux {
      
	                    groups = "gpio0_0_grp";  
	                    function = "gpio0";  
	                };  
	
	                conf {
      
	                    pins = "MIO0"; 
	                    io-standard = <1>; 
	                    bias-disable;  
	                    slew-rate = <0>;  
	                };      
	            };
			};
		};
	};

	alinxled {
    
		compatible = "alinx-led";
		pinctrl-names = "default";
		pinctrl-0 = <&pinctrl_led_default>;
		alinxled-gpios = <&gpio0 0 0>;
	};
};

&i2c0 {
    
	clock-frequency = <100000>;
};

&usb0 {
    
	dr_mode = "host";
	usb-phy = <&usb_phy0>;
};

&sdhci0 {
    
	u-boot,dm-pre-reloc;
};

&uart1 {
    
	u-boot,dm-pre-reloc;
};

&flash0 {
    
	compatible = "micron,m25p80", "w25q256", "spi-flash";
};

&gem0 {
    
	phy-handle = <&ethernet_phy>;
	ethernet_phy: ethernet-phy@1 {
    
		reg = <1>;
		device_type = "ethernet-phy";
	};
};

&amba_pl {
    
	hdmi_encoder_0:hdmi_encoder {
    
		compatible = "digilent,drm-encoder";
		digilent,edid-i2c = <&i2c0>;
	};

	xilinx_drm {
    
		compatible = "xlnx,drm";
		xlnx,vtc = <&v_tc_0>;
		xlnx,connector-type = "HDMIA";
		xlnx,encoder-slave = <&hdmi_encoder_0>;
		clocks = <&axi_dynclk_0>;
		dglnt,edid-i2c = <&i2c0>;
		planes {
    
			xlnx,pixel-format = "rgb888";
			plane0 {
    
				dmas = <&axi_vdma_0 0>;
				dma-names = "dma";
			};
		};
	};
};

&axi_dynclk_0 {
    
	compatible = "digilent,axi-dynclk";
	#clock-cells = <0>;
	clocks = <&clkc 15>;
};

&v_tc_0 {
    
	compatible = "xlnx,v-tc-5.01.a";
};

led,连接的io是MIO0，所在分组为gpio0_0_grp，功能就是gpio0转换速率slow，电平标准为1,8v，偏置使能，配置目标为’MIO0’

通过属性**pinctrl-0=<&pinctrl_led_default>调用pin节点
通过alinxled-gpios=<&gpio0 0 0>**来绑定gpio
10）驱动程序

/** ===================================================== **
 *Author : ALINX Electronic Technology (Shanghai) Co., Ltd.
 *Website: http://www.alinx.com
 *Address: Room 202, building 18, 
           No.518 xinbrick Road, 
           Songjiang District, Shanghai
 *Created: 2020-3-2 
 *Version: 1.0
 ** ===================================================== **/

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/fs.h>  
#include <linux/init.h>  
#include <linux/ide.h>  
#include <linux/types.h>  
#include <linux/errno.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <asm/uaccess.h>
#include <asm/mach/map.h>
#include <asm/io.h>
  
/* 设备节点名称 */  
#define DEVICE_NAME       "gpio_leds"
/* 设备号个数 */  
#define DEVID_COUNT       1
/* 驱动个数 */  
#define DRIVE_COUNT       1
/* 主设备号 */
#define MAJOR1
/* 次设备号 */
#define MINOR1            0
/* LED点亮时输入的值 */
#define ALINX_LED_ON      1
/* LED熄灭时输入的值 */
#define ALINX_LED_OFF     0

  
/* 把驱动代码中会用到的数据打包进设备结构体 */
struct alinx_char_dev{
    
	dev_t              devid;             //设备号
	struct cdev        cdev;              //字符设备
	struct class       *class;            //类
	struct device      *device;           //设备
	struct device_node *nd;               //设备树的设备节点
	int                alinx_led_gpio;    //gpio号
};
/* 声明设备结构体 */
static struct alinx_char_dev alinx_char = {
    
	.cdev = {
    
		.owner = THIS_MODULE,
	},
};

/* open函数实现, 对应到Linux系统调用函数的open函数 */  
static int gpio_leds_open(struct inode *inode_p, struct file *file_p)  
{
      
	/* 设置私有数据 */
	file_p->private_data = &alinx_char;
    printk("gpio_test module open\n");  
    return 0;  
}  
  
  
/* write函数实现, 对应到Linux系统调用函数的write函数 */  
static ssize_t gpio_leds_write(struct file *file_p, const char __user *buf, size_t len, loff_t *loff_t_p)  
{
      
    int retvalue;
    unsigned char databuf[1];  
	/* 获取私有数据 */
	struct alinx_char_dev *dev = file_p->private_data;
  
    retvalue = copy_from_user(databuf, buf, len);  
    if(retvalue < 0) 
    {
    
		printk("alinx led write failed\r\n");
		return -EFAULT;
    } 
      
    if(databuf[0] == ALINX_LED_ON)
    {
    
		gpio_set_value(dev->alinx_led_gpio, !!0);
    }
    else if(databuf[0] == ALINX_LED_OFF)
    {
    
		gpio_set_value(dev->alinx_led_gpio, !!1);
    }
    else
    {
    
		printk("gpio_test para err\n");
    }
	 
    return 0;  
}  
  
/* release函数实现, 对应到Linux系统调用函数的close函数 */  
static int gpio_leds_release(struct inode *inode_p, struct file *file_p)  
{
      
    printk("gpio_test module release\n");  
    return 0;  
}  
	  
/* file_operations结构体声明, 是上面open、write实现函数与系统调用函数对应的关键 */  
static struct file_operations ax_char_fops = {
      
    .owner   = THIS_MODULE,  
    .open    = gpio_leds_open,  
    .write   = gpio_leds_write,     
    .release = gpio_leds_release,   
};  
  
/* 模块加载时会调用的函数 */  
static int __init gpio_led_init(void)  
{
    
	/* 用于接受返回值 */
	u32 ret = 0;
	
	/* 获取设备节点 */
	alinx_char.nd = of_find_node_by_path("/alinxled");
	if(alinx_char.nd == NULL)
	{
    
		printk("alinx_char node not find\r\n");
		return -EINVAL;
	}
	else
	{
    
		printk("alinx_char node find\r\n");
	}
	
	/* 获取节点中gpio标号 */
	alinx_char.alinx_led_gpio = of_get_named_gpio(alinx_char.nd, "alinxled-gpios", 0);
	if(alinx_char.alinx_led_gpio < 0)
	{
    
		printk("can not get alinxled-gpios");
		return -EINVAL;
	}
	printk("alinxled-gpio num = %d\r\n", alinx_char.alinx_led_gpio);
	
	/* 申请gpio标号对应的引脚 */
	ret = gpio_request(alinx_char.alinx_led_gpio, "alinxled");
	if(ret != 0)
	{
    
		printk("can not request gpio\r\n");
	}
	
	/* 把这个io设置为输出 */
	ret = gpio_direction_output(alinx_char.alinx_led_gpio, 1);
	if(ret < 0)
	{
    
		printk("can not set gpio\r\n");
	}
	
	/* 注册设备号 */
	alloc_chrdev_region(&alinx_char.devid, MINOR1, DEVID_COUNT, DEVICE_NAME);
	
	/* 初始化字符设备结构体 */
	cdev_init(&alinx_char.cdev, &ax_char_fops);
	
	/* 注册字符设备 */
	cdev_add(&alinx_char.cdev, alinx_char.devid, DRIVE_COUNT);
	
	/* 创建类 */
	alinx_char.class = class_create(THIS_MODULE, DEVICE_NAME);
	if(IS_ERR(alinx_char.class)) 
	{
    
		return PTR_ERR(alinx_char.class);
	}
	
	/* 创建设备节点 */
	alinx_char.device = device_create(alinx_char.class, NULL, 
                                      alinx_char.devid, NULL, 
					                  DEVICE_NAME);
	if (IS_ERR(alinx_char.device)) 
	{
    
		return PTR_ERR(alinx_char.device);
	}
	
	return 0;  
}

/* 卸载模块 */  
static void __exit gpio_led_exit(void)  
{
      
    /* 释放gpio */
    gpio_free(alinx_char.alinx_led_gpio);

    /* 注销字符设备 */
    cdev_del(&alinx_char.cdev);
    
    /* 注销设备号 */
    unregister_chrdev_region(alinx_char.devid, DEVID_COUNT);
    
    /* 删除设备节点 */
    device_destroy(alinx_char.class, alinx_char.devid);
    
    /* 删除类 */
    class_destroy(alinx_char.class);
       
    printk("gpio_led_dev_exit_ok\n");  
}  
  
/* 标记加载、卸载函数 */  
module_init(gpio_led_init);  
module_exit(gpio_led_exit);  
  
/* 驱动描述信息 */  
MODULE_AUTHOR("Alinx");  
MODULE_ALIAS("gpio_led");  
MODULE_DESCRIPTION("PINCTRL AND GPIO LED driver");  
MODULE_VERSION("v1.0");  
MODULE_LICENSE("GPL");  

115行获取/alinxled节点

127行of_get_named_gpio函数，通过属性alinxled-gpios获取gpio标号

136行gpio_request函数申请标号对应的引脚

143行使用gpio_direction_outoput函数把gpio设置为输出

11.应用程序

/** ===================================================== **
 *Author : ALINX Electronic Technology (Shanghai) Co., Ltd.
 *Website: http://www.alinx.com
 *Address: Room 202, building 18, 
           No.518 xinbrick Road, 
           Songjiang District, Shanghai
 *Created: 2020-3-2 
 *Version: 1.0
 ** ===================================================== **/

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char **argv)
{
    
    int fd;
    char buf;

    /* 验证输入参数个数 */
    if(3 != argc)
    {
    
        printf("none para\n");
        return -1;
    }

    /* 打开输入的设备文件, 获取文件句柄 */
    fd = open(argv[1], O_RDWR);
    if(fd < 0)
    {
    
        /* 打开文件失败 */
        printf("Can't open file %s\r\n", argv[1]);
        return -1;
    }

    /* 判断输入参数, on就点亮led, off则熄灭led */
    if(!strcmp("on",argv[2]))
    {
    
        printf("ps_led1 on\n");
        buf = 1;
        write(fd, &buf, 1);
    }
    else if(!strcmp("off",argv[2]))
    {
    
        printf("ps_led1 off\n");
        buf = 0;
        write(fd, &buf, 1);
    }
    else
    {
    
        /* 输入参数错误 */
        printf("wrong para\n");
        return -2;
    }

    /* 操作结束后关闭文件 */
    close(fd);
    return 0;
}

12.7020开发板测试
命令

./axleddev_test /dev/gpio_leds on

PS-LED1被点亮

命令：

./axleddev test /dev/gpio leds off

设备树： io-standard = <1>; IO电压为1.8V,实际为1.3V

设备树： io-standard = <3>; IO电压为3.3V,实际为3.3V

在这里插入图片描述