Linux中pinctrl子系统驱动

「爱情、让人受尽委屈。」 2022-10-16 13:21 209阅读 0赞

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

*  1、背景
 *  2、pinctrl 子系统的作用
 *  3、I.MX6ULL 的 pinctrl 子系统驱动
 *   *  3.1、PIN 配置信息详解
     *  3.2、PIN 驱动程序

# 1、背景 #

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

# 2、pinctrl 子系统的作用 #

①、获取设备树中 pin 信息。  
②、根据获取到的 pin 信息来设置 pin 的复用功能  
③、根据获取到的 pin 信息来设置 pin 的电气特性，比如上/下拉、速度、驱动能力等。

于我们使用者来讲，只需要在设备树里面设置好某个 pin 的相关属性即可，其他的初始化工作均由 pinctrl 子系统来完成， pinctrl 子系统源码目录为 drivers/pinctrl。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70]

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

## 3.1、PIN 配置信息详解 ##

要使用 pinctrl 子系统，我们需要在设备树里面设置 PIN 的配置信息，毕竟 pinctrl 子系统要根据你提供的信息来配置 PIN 功能，一般会在设备树里面创建一个节点来描述 PIN 的配置信息。打开 imx6ull.dtsi 文件，找到一个叫做 iomuxc 的节点，如下所示：

iomuxc: iomuxc@020e0000 { 
    				compatible = "fsl,imx6ul-iomuxc";
    				reg = <0x020e0000 0x4000>;
    			};

iomuxc 节点就是 I.MX6ULL 的 IOMUXC 外设对应的节点

打开 imx6ull-alientek-emmc.dts，找到如下所示内容：

&iomuxc { 
    	pinctrl-names = "default";
    	pinctrl-0 = <&pinctrl_hog_1>;
    	imx6ul-evk { 
    		pinctrl_hog_1: hoggrp-1 { 
    			fsl,pins = <
    				MX6UL_PAD_UART1_RTS_B__GPIO1_IO19	0x17059 /* SD1 CD */
    				MX6UL_PAD_GPIO1_IO05__USDHC1_VSELECT	0x17059 /* SD1 VSELECT */
    				MX6UL_PAD_GPIO1_IO09__GPIO1_IO09        0x17059 /* SD1 RESET */
    			>;
    		};
    		/*qingmu 2020/11/22*/
    		pinctrl_gpioled: ledgrp{ 
    			fsl,pins = <
    				MX6UL_PAD_GPIO1_IO03__GPIO1_IO03  0x10b0
    			>;
    		};
    		/*qingmu 2020/11/22*/
    		pinctrl_key: keygrp{ 
    			fsl,pins = <
    				MX6UL_PAD_UART1_CTS_B__GPIO1_IO18  0xF080
    			>;
    		};
    
    		pinctrl_csi1: csi1grp { 
    			fsl,pins = <
    				MX6UL_PAD_CSI_MCLK__CSI_MCLK		0x1b088
    				MX6UL_PAD_CSI_PIXCLK__CSI_PIXCLK	0x1b088
    				MX6UL_PAD_CSI_VSYNC__CSI_VSYNC		0x1b088
    				MX6UL_PAD_CSI_HSYNC__CSI_HSYNC		0x1b088
    				MX6UL_PAD_CSI_DATA00__CSI_DATA02	0x1b088
    				MX6UL_PAD_CSI_DATA01__CSI_DATA03	0x1b088
    				MX6UL_PAD_CSI_DATA02__CSI_DATA04	0x1b088
    				MX6UL_PAD_CSI_DATA03__CSI_DATA05	0x1b088
    				MX6UL_PAD_CSI_DATA04__CSI_DATA06	0x1b088
    				MX6UL_PAD_CSI_DATA05__CSI_DATA07	0x1b088
    				MX6UL_PAD_CSI_DATA06__CSI_DATA08	0x1b088
    				MX6UL_PAD_CSI_DATA07__CSI_DATA09	0x1b088
    			>;
    		};
    
    	
    
    		pinctrl_flexcan1: flexcan1grp{ 
    			fsl,pins = <
    				MX6UL_PAD_UART3_RTS_B__FLEXCAN1_RX	0x1b020
    				MX6UL_PAD_UART3_CTS_B__FLEXCAN1_TX	0x1b020
    			>;
    		};
    
    		pinctrl_flexcan2: flexcan2grp{ 
    			fsl,pins = <
    				MX6UL_PAD_UART2_RTS_B__FLEXCAN2_RX	0x1b020
    				MX6UL_PAD_UART2_CTS_B__FLEXCAN2_TX	0x1b020
    			>;
    		};
    
    		pinctrl_i2c1: i2c1grp { 
    			fsl,pins = <
    				MX6UL_PAD_UART4_TX_DATA__I2C1_SCL 0x4001b8b0
    				MX6UL_PAD_UART4_RX_DATA__I2C1_SDA 0x4001b8b0
    			>;
    		};
    
    		pinctrl_i2c2: i2c2grp { 
    			fsl,pins = <
    				MX6UL_PAD_UART5_TX_DATA__I2C2_SCL 0x4001b8b0
    				MX6UL_PAD_UART5_RX_DATA__I2C2_SDA 0x4001b8b0
    			>;
    		};
    
     	 ......
     	 ......
      	 ......
      	 
    	};
    };

上述代码 就是向 iomuxc 节点追加数据，不同的外设使用的 PIN 不同、其配置也不同，因此一个萝卜一个坑，将某个外设所使用的所有 PIN 都组织在一个子节点里面。上述代码 中 pinctrl\_hog\_1 子节点就是和热插拔有关的 PIN 集合，比如 USB OTG 的 ID 引脚。pinctrl\_flexcan1 子节点是 flexcan1 这个外设所使用的 PIN， pinctrl\_wdog 子节点是 wdog 外设所使用的 PIN。如果需要在 iomuxc 中添加我们自定义外设的 PIN，那么需要新建一个子节点，然后将这个自定义外设的所有 PIN 配置信息都放到这个子节点中。

将上述两端代码结合起来分析可以得到完整的 iomuxc 节点，如下所示：

1 	 iomuxc: iomuxc@020e0000 { 
    2			compatible = "fsl,imx6ul-iomuxc";
    3			reg = <0x020e0000 0x4000>;
    4		};
    5    &iomuxc { 
    6		pinctrl-names = "default";
    7		pinctrl-0 = <&pinctrl_hog_1>;
    8		imx6ul-evk { 
    9			pinctrl_hog_1: hoggrp-1 { 
    10				fsl,pins = <
    11					MX6UL_PAD_UART1_RTS_B__GPIO1_IO19	0x17059 /* SD1 CD */
    12					MX6UL_PAD_GPIO1_IO05__USDHC1_VSELECT	0x17059 /* SD1 VSELECT */
    13					MX6UL_PAD_GPIO1_IO09__GPIO1_IO09        0x17059 /* SD1 RESET */
    14				>;
    15			};
    16		};

**我们从pinctrl\_hog\_1这个节点完整的分析一下pinctrl子系统驱动**、

首先第二行的compatible 属性值为：“fsl,imx6ul-iomuxc”。Linux内核会根据这个属性值查找对应的驱动文件。我们在Linux内核中找到这个SOC的 pinctrl 驱动文件（pinctrl-imx6ul.c）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 1]  
11~13行pinctrl\_hog\_1 子节点所使用的 PIN 配置信息，我们以第11行的MX6UL\_PAD\_UART1\_RTS\_B\_\_GPIO1\_IO19 为例看一下如何添加 PIN 的配置信息UART1\_RTS\_B 的配置信息如下：

MX6UL_PAD_UART1_RTS_B__GPIO1_IO19	0x17059 /* SD1 CD */

首先说明一下， UART1\_RTS\_B 这个 PIN 是作为 SD 卡的检测引脚，也就是通过此 PIN 就可 以 检 测 到 SD 卡 是 否 有 插 入 。 UART1\_RTS\_B 的 配 置 信 息 分 为 两 部 分 ：MX6UL\_PAD\_UART1\_RTS\_B\_\_GPIO1\_IO19 和 0x17059

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 的宏定义内容如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 2]

#define MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x0090 0x031C 0x0000 0x5 0x0

MX6UL\_PAD\_UART1\_RTS\_B\_\_GPIO1\_IO19 表 示 将UART1\_RTS\_B 这个 IO 复用为 GPIO1\_IO19。此宏定义后面跟着 5 个数字，也就是这个宏定义的具体值及其含义，如下所示：

0x0090 		0x031C 		0x0000 			0x5			 0x0
      <mux_reg 	   conf_reg 	input_reg 	   mux_mode     input_val>

**mux\_reg（0x0090 ）** ：是MX6UL\_PAD\_UART1\_RTS\_B寄存器的地址的偏移值。  
设备树中的 iomuxc 节点就是 IOMUXC 外设对应的节点 ， 根 据 其 reg 属 性 可 知 IOMUXC 外 设 寄 存 器 起 始 地 址 为 0x020e0000（上述代码pinctrl\_hog\_1 的第一行得到iomuxc的起始地址） 。 因 此0x020e0000+0x0090=0x020e0090， IOMUXC\_SW\_MUX\_CTL\_PAD\_UART1\_RTS\_B 寄存器地址正 好 是 0x020e0090。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 3]  
因此可知， 0x020e0000+mux\_reg 就是 PIN 的复用寄存器地址。

**mux\_mode（0x5 ）**：这个是复用寄存器的值，也就是设置具体复用为什么功能的值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 4]  
这里可以看出我们想复用为GPIO1\_IO19，所以寄存器的值就为0101，也就是5.

**conf\_reg （0x031C）**：conf\_reg 寄存器偏移地址，和 mux\_reg 一样， 0x020e0000+0x031c=0x020e031c，这个就是寄存器 IOMUXC\_SW\_PAD\_CTL\_PAD\_UART1\_RTS\_B 的地址。也就是设置电气属性的寄存器地址。那么有了设置电气属性寄存器的地址，那么值呢？很明显这个我们设备树中这里有两部分“MX6UL\_PAD\_UART1\_RTS\_B\_\_GPIO1\_IO19 0x17059”，后方的0x17059就是其电气属性的值了（比如上/下拉、速度、驱动能力等）。

**input\_reg（0x0000）**:nput\_reg 寄存器偏移地址，有些外设有 input\_reg 寄存器，有 input\_reg 寄存器的外设需要配置 input\_reg 寄存器。没有的话就不需要设置， UART1\_RTS\_B 这个 PIN 在做GPIO1\_IO19 的时候是没有 input\_reg 寄存器，因此这里 intput\_reg 是无效的。

**input\_val(0x0)**:很明显，这个就是设置input\_reg 寄存器的具体的值的。因为 intput\_reg 是无效的，所以这里也没有值。

**总结下来：**

#define MX6UL_PAD_UART1_RTS_B__GPIO1_IO19 0x0090 0x031C 0x0000 0x5 0x0

就是设备树中PIN信息的具体含义就是设置其复用功能以及电气特性。

## 3.2、PIN 驱动程序 ##

iomuxc 节点中 compatible 属性的值为“fsl,imx6ul-iomuxc”，Linux内核会根据这个属性值查找对应的驱动文件。我们在Linux内核中找到这个SOC的 pinctrl 驱动文件（pinctrl-imx6ul.c）。

并且通过fsl,imx6ul-iomuxc，我们可以在pinctrl-imx6ul.c找到如下信息：

static struct of_device_id imx6ul_pinctrl_of_match[] = { 
    	{  .compatible = "fsl,imx6ul-iomuxc", .data = &imx6ul_pinctrl_info, },
    	{  .compatible = "fsl,imx6ull-iomuxc-snvs", .data = &imx6ull_snvs_pinctrl_info, },
    	{  /* sentinel */ }
    };

其次，在这个驱动文件中首先执行的就是probe函数，也就是：

static int imx6ul_pinctrl_probe(struct platform_device *pdev)
    { 
    	const struct of_device_id *match;
    	struct imx_pinctrl_soc_info *pinctrl_info;
    
    	match = of_match_device(imx6ul_pinctrl_of_match, &pdev->dev);
    
    	if (!match)
    		return -ENODEV;
    
    	pinctrl_info = (struct imx_pinctrl_soc_info *) match->data;
    
    	return imx_pinctrl_probe(pdev, pinctrl_info);
    }

此函数调用imx\_pinctrl\_probe函数：

int imx_pinctrl_probe(struct platform_device *pdev,
    		      struct imx_pinctrl_soc_info *info)
    { 
    	struct device_node *dev_np = pdev->dev.of_node;
    	struct device_node *np;
    	struct imx_pinctrl *ipctl;
    	struct resource *res;
    	struct pinctrl_desc *imx_pinctrl_desc;
    	int ret, i;
    
    	if (!info || !info->pins || !info->npins) { 
    		dev_err(&pdev->dev, "wrong pinctrl info\n");
    		return -EINVAL;
    	}
    	info->dev = &pdev->dev;
    
    	imx_pinctrl_desc = devm_kzalloc(&pdev->dev, sizeof(*imx_pinctrl_desc),
    					GFP_KERNEL);
    	if (!imx_pinctrl_desc)
    		return -ENOMEM;
    
    	/* Create state holders etc for this driver */
    	ipctl = devm_kzalloc(&pdev->dev, sizeof(*ipctl), GFP_KERNEL);
    	if (!ipctl)
    		return -ENOMEM;
    
    	info->pin_regs = devm_kmalloc(&pdev->dev, sizeof(*info->pin_regs) *
    				      info->npins, GFP_KERNEL);
    	if (!info->pin_regs)
    		return -ENOMEM;
    
    	for (i = 0; i < info->npins; i++) { 
    		info->pin_regs[i].mux_reg = -1;
    		info->pin_regs[i].conf_reg = -1;
    	}
    
    	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    	ipctl->base = devm_ioremap_resource(&pdev->dev, res);
    	if (IS_ERR(ipctl->base))
    		return PTR_ERR(ipctl->base);
    
    	if (of_property_read_bool(dev_np, "fsl,input-sel")) { 
    		np = of_parse_phandle(dev_np, "fsl,input-sel", 0);
    		if (np) { 
    			ipctl->input_sel_base = of_iomap(np, 0);
    			if (IS_ERR(ipctl->input_sel_base)) { 
    				of_node_put(np);
    				dev_err(&pdev->dev,
    					"iomuxc input select base address not found\n");
    				return PTR_ERR(ipctl->input_sel_base);
    			}
    		} else { 
    			dev_err(&pdev->dev, "iomuxc fsl,input-sel property not found\n");
    			return -EINVAL;
    		}
    		of_node_put(np);
    	}
    
    	imx_pinctrl_desc->name = dev_name(&pdev->dev);
    	imx_pinctrl_desc->pins = info->pins;
    	imx_pinctrl_desc->npins = info->npins;
    	imx_pinctrl_desc->pctlops = &imx_pctrl_ops;
    	imx_pinctrl_desc->pmxops = &imx_pmx_ops;
    	imx_pinctrl_desc->confops = &imx_pinconf_ops;
    	imx_pinctrl_desc->owner = THIS_MODULE;
    
    	ret = imx_pinctrl_probe_dt(pdev, info);
    	if (ret) { 
    		dev_err(&pdev->dev, "fail to probe dt properties\n");
    		return ret;
    	}
    
    	ipctl->info = info;
    	ipctl->dev = info->dev;
    	platform_set_drvdata(pdev, ipctl);
    	ipctl->pctl = pinctrl_register(imx_pinctrl_desc, &pdev->dev, ipctl);
    	if (!ipctl->pctl) { 
    		dev_err(&pdev->dev, "could not register IMX pinctrl driver\n");
    		return -EINVAL;
    	}
    
    	dev_info(&pdev->dev, "initialized IMX pinctrl driver\n");
    
    	return 0;
    }

在这个函数中会初始化imx\_pinctrl\_desc结构体，重点是一下几个操作函数集（类似于file\_operations）  
这三个结构体下的所有函数就是 I.MX6ULL 的 PIN 配置函数

imx_pinctrl_desc->pctlops = &imx_pctrl_ops;
    	imx_pinctrl_desc->pmxops = &imx_pmx_ops;
    	imx_pinctrl_desc->confops = &imx_pinconf_ops;

最终会调用pinctrl\_register(imx\_pinctrl\_desc, &pdev->dev, ipctl);函数向系统注册注册imx\_pinctrl\_desc。

在此之前会调用imx\_pinctrl\_probe\_dt函数：

static int imx_pinctrl_probe_dt(struct platform_device *pdev,
    				struct imx_pinctrl_soc_info *info)
    { 
    	struct device_node *np = pdev->dev.of_node;
    	struct device_node *child;
    	u32 nfuncs = 0;
    	u32 i = 0;
    
    	if (!np)
    		return -ENODEV;
    
    	nfuncs = of_get_child_count(np);
    	if (nfuncs <= 0) { 
    		dev_err(&pdev->dev, "no functions defined\n");
    		return -EINVAL;
    	}
    
    	info->nfunctions = nfuncs;
    	info->functions = devm_kzalloc(&pdev->dev, nfuncs * sizeof(struct imx_pmx_func),
    					GFP_KERNEL);
    	if (!info->functions)
    		return -ENOMEM;
    
    	info->ngroups = 0;
    	for_each_child_of_node(np, child)
    		info->ngroups += of_get_child_count(child);
    	info->groups = devm_kzalloc(&pdev->dev, info->ngroups * sizeof(struct imx_pin_group),
    					GFP_KERNEL);
    	if (!info->groups)
    		return -ENOMEM;
    
    	for_each_child_of_node(np, child)
    		imx_pinctrl_parse_functions(child, info, i++);
    
    	return 0;
    }

此函数又会调用imx\_pinctrl\_parse\_functions(child, info, i++)函数,imx\_pinctrl\_parse\_functions调用imx\_pinctrl\_parse\_groups函数

static int imx_pinctrl_parse_groups(struct device_node *np,
    				    struct imx_pin_group *grp,
    				    struct imx_pinctrl_soc_info *info,
    				    u32 index)
    { 
    	int size, pin_size;
    	const __be32 *list;
    	int i;
    	u32 config;
    
    	dev_dbg(info->dev, "group(%d): %s\n", index, np->name);
    
    	if (info->flags & SHARE_MUX_CONF_REG)
    		pin_size = SHARE_FSL_PIN_SIZE;
    	else
    		pin_size = FSL_PIN_SIZE;
    	/* Initialise group */
    	grp->name = np->name;
    
    	/* * the binding format is fsl,pins = <PIN_FUNC_ID CONFIG ...>, * do sanity check and calculate pins number */
    	list = of_get_property(np, "fsl,pins", &size);
    	if (!list) { 
    		dev_err(info->dev, "no fsl,pins property in node %s\n", np->full_name);
    		return -EINVAL;
    	}
    
    	/* we do not check return since it's safe node passed down */
    	if (!size || size % pin_size) { 
    		dev_err(info->dev, "Invalid fsl,pins property in node %s\n", np->full_name);
    		return -EINVAL;
    	}
    
    	grp->npins = size / pin_size;
    	grp->pins = devm_kzalloc(info->dev, grp->npins * sizeof(struct imx_pin),
    				GFP_KERNEL);
    	grp->pin_ids = devm_kzalloc(info->dev, grp->npins * sizeof(unsigned int),
    				GFP_KERNEL);
    	if (!grp->pins || ! grp->pin_ids)
    		return -ENOMEM;
    
    	for (i = 0; i < grp->npins; i++) { 
    		u32 mux_reg = be32_to_cpu(*list++);
    		u32 conf_reg;
    		unsigned int pin_id;
    		struct imx_pin_reg *pin_reg;
    		struct imx_pin *pin = &grp->pins[i];
    
    		if (!(info->flags & ZERO_OFFSET_VALID) && !mux_reg)
    			mux_reg = -1;
    
    		if (info->flags & SHARE_MUX_CONF_REG) { 
    			conf_reg = mux_reg;
    		} else { 
    			conf_reg = be32_to_cpu(*list++);
    			if (!(info->flags & ZERO_OFFSET_VALID) && !conf_reg)
    				conf_reg = -1;
    		}
    
    		pin_id = (mux_reg != -1) ? mux_reg / 4 : conf_reg / 4;
    		pin_reg = &info->pin_regs[pin_id];
    		pin->pin = pin_id;
    		grp->pin_ids[i] = pin_id;
    		pin_reg->mux_reg = mux_reg;
    		pin_reg->conf_reg = conf_reg;
    		pin->input_reg = be32_to_cpu(*list++);
    		pin->mux_mode = be32_to_cpu(*list++);
    		pin->input_val = be32_to_cpu(*list++);
    
    		/* SION bit is in mux register */
    		config = be32_to_cpu(*list++);
    		if (config & IMX_PAD_SION)
    			pin->mux_mode |= IOMUXC_CONFIG_SION;
    		pin->config = config & ~IMX_PAD_SION;
    
    		dev_dbg(info->dev, "%s: 0x%x 0x%08lx", info->pins[pin_id].name,
    				pin->mux_mode, pin->config);
    	}
    
    	return 0;
    }

**此时重点来了：**

pin_id = (mux_reg != -1) ? mux_reg / 4 : conf_reg / 4;
    		pin_reg = &info->pin_regs[pin_id];
    		pin->pin = pin_id;
    		grp->pin_ids[i] = pin_id;
    		pin_reg->mux_reg = mux_reg;
    		pin_reg->conf_reg = conf_reg;
    		pin->input_reg = be32_to_cpu(*list++);
    		pin->mux_mode = be32_to_cpu(*list++);
    		pin->input_val = be32_to_cpu(*list++);

设备树中的 mux\_reg 和 conf\_reg 值会保存在 info 参数中， input\_reg、mux\_mode、 input\_val 和 config 值会保存在 grp 参数中。

接下来函数 pinctrl\_register，此函数用于向 Linux 内核注册一个 PIN 控制器。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70]: /images/20221014/868b9e4752e1437bb190649b0092e332.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 1]: /images/20221014/e42458447c7a485bbb21d68e3813a01c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 2]: /images/20221014/8570effc668944d8a3fc62ffc0f04e5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 3]: /images/20221014/60c19e0db4f5490f867ee94bc1701899.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70 4]: /images/20221014/fc7c52574c9d4759a9bbc5f0b0303d34.png