~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,10 +1,6 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* Copyright (C) 2016 IBM Corp.
3		- *
4		- * This program is free software; you can redistribute it and/or modify
5		- * it under the terms of the GNU General Public License as published by
6		- * the Free Software Foundation; either version 2 of the License, or
7		- * (at your option) any later version.
8	4	*/
9	5	#include <linux/bitops.h>
10	6	#include <linux/init.h>
..	..	@@ -22,7 +18,40 @@
22	18
23	19	#include "../core.h"
24	20	#include "../pinctrl-utils.h"
	21	+#include "pinmux-aspeed.h"
25	22	#include "pinctrl-aspeed.h"
	23	+
	24	+/* Wrap some of the common macros for clarity */
	25	+#define SIG_EXPR_DECL_SINGLE(sig, func, ...) \
	26	+ SIG_EXPR_DECL(sig, func, func, __VA_ARGS__)
	27	+
	28	+#define SIG_EXPR_LIST_DECL_SINGLE SIG_EXPR_LIST_DECL_SESG
	29	+#define SIG_EXPR_LIST_DECL_DUAL SIG_EXPR_LIST_DECL_DESG
	30	+
	31	+/*
	32	+ * The "Multi-function Pins Mapping and Control" table in the SoC datasheet
	33	+ * references registers by the device/offset mnemonic. The register macros
	34	+ * below are named the same way to ease transcription and verification (as
	35	+ * opposed to naming them e.g. PINMUX_CTRL_[0-9]). Further, signal expressions
	36	+ * reference registers beyond those dedicated to pinmux, such as the system
	37	+ * reset control and MAC clock configuration registers.
	38	+ */
	39	+#define SCU2C 0x2C /* Misc. Control Register */
	40	+#define SCU3C 0x3C /* System Reset Control/Status Register */
	41	+#define SCU48 0x48 /* MAC Interface Clock Delay Setting */
	42	+#define HW_STRAP1 0x70 /* AST2400 strapping is 33 bits, is split */
	43	+#define HW_REVISION_ID 0x7C /* Silicon revision ID register */
	44	+#define SCU80 0x80 /* Multi-function Pin Control #1 */
	45	+#define SCU84 0x84 /* Multi-function Pin Control #2 */
	46	+#define SCU88 0x88 /* Multi-function Pin Control #3 */
	47	+#define SCU8C 0x8C /* Multi-function Pin Control #4 */
	48	+#define SCU90 0x90 /* Multi-function Pin Control #5 */
	49	+#define SCU94 0x94 /* Multi-function Pin Control #6 */
	50	+#define SCUA0 0xA0 /* Multi-function Pin Control #7 */
	51	+#define SCUA4 0xA4 /* Multi-function Pin Control #8 */
	52	+#define SCUA8 0xA8 /* Multi-function Pin Control #9 */
	53	+#define SCUAC 0xAC /* Multi-function Pin Control #10 */
	54	+#define HW_STRAP2 0xD0 /* Strapping */
26	55
27	56	/*
28	57	* Uses undefined macros for symbol naming and references, eg GPIOA0, MAC1LINK,
..	..	@@ -58,16 +87,16 @@
58	87	#define I2C9_DESC SIG_DESC_SET(SCU90, 22)
59	88
60	89	#define C5 4
61		-SIG_EXPR_LIST_DECL_SINGLE(SCL9, I2C9, I2C9_DESC);
62		-SIG_EXPR_LIST_DECL_SINGLE(TIMER5, TIMER5, SIG_DESC_SET(SCU80, 4));
63		-MS_PIN_DECL(C5, GPIOA4, SCL9, TIMER5);
	90	+SIG_EXPR_LIST_DECL_SINGLE(C5, SCL9, I2C9, I2C9_DESC);
	91	+SIG_EXPR_LIST_DECL_SINGLE(C5, TIMER5, TIMER5, SIG_DESC_SET(SCU80, 4));
	92	+PIN_DECL_2(C5, GPIOA4, SCL9, TIMER5);
64	93
65	94	FUNC_GROUP_DECL(TIMER5, C5);
66	95
67	96	#define B4 5
68		-SIG_EXPR_LIST_DECL_SINGLE(SDA9, I2C9, I2C9_DESC);
69		-SIG_EXPR_LIST_DECL_SINGLE(TIMER6, TIMER6, SIG_DESC_SET(SCU80, 5));
70		-MS_PIN_DECL(B4, GPIOA5, SDA9, TIMER6);
	97	+SIG_EXPR_LIST_DECL_SINGLE(B4, SDA9, I2C9, I2C9_DESC);
	98	+SIG_EXPR_LIST_DECL_SINGLE(B4, TIMER6, TIMER6, SIG_DESC_SET(SCU80, 5));
	99	+PIN_DECL_2(B4, GPIOA5, SDA9, TIMER6);
71	100
72	101	FUNC_GROUP_DECL(TIMER6, B4);
73	102	FUNC_GROUP_DECL(I2C9, C5, B4);
..	..	@@ -75,16 +104,16 @@
75	104	#define MDIO2_DESC SIG_DESC_SET(SCU90, 2)
76	105
77	106	#define A3 6
78		-SIG_EXPR_LIST_DECL_SINGLE(MDC2, MDIO2, MDIO2_DESC);
79		-SIG_EXPR_LIST_DECL_SINGLE(TIMER7, TIMER7, SIG_DESC_SET(SCU80, 6));
80		-MS_PIN_DECL(A3, GPIOA6, MDC2, TIMER7);
	107	+SIG_EXPR_LIST_DECL_SINGLE(A3, MDC2, MDIO2, MDIO2_DESC);
	108	+SIG_EXPR_LIST_DECL_SINGLE(A3, TIMER7, TIMER7, SIG_DESC_SET(SCU80, 6));
	109	+PIN_DECL_2(A3, GPIOA6, MDC2, TIMER7);
81	110
82	111	FUNC_GROUP_DECL(TIMER7, A3);
83	112
84	113	#define D5 7
85		-SIG_EXPR_LIST_DECL_SINGLE(MDIO2, MDIO2, MDIO2_DESC);
86		-SIG_EXPR_LIST_DECL_SINGLE(TIMER8, TIMER8, SIG_DESC_SET(SCU80, 7));
87		-MS_PIN_DECL(D5, GPIOA7, MDIO2, TIMER8);
	114	+SIG_EXPR_LIST_DECL_SINGLE(D5, MDIO2, MDIO2, MDIO2_DESC);
	115	+SIG_EXPR_LIST_DECL_SINGLE(D5, TIMER8, TIMER8, SIG_DESC_SET(SCU80, 7));
	116	+PIN_DECL_2(D5, GPIOA7, MDIO2, TIMER8);
88	117
89	118	FUNC_GROUP_DECL(TIMER8, D5);
90	119	FUNC_GROUP_DECL(MDIO2, A3, D5);
..	..	@@ -102,18 +131,18 @@
102	131	SSSF_PIN_DECL(F18, GPIOB3, SALT4, SIG_DESC_SET(SCU80, 11));
103	132
104	133	#define E19 12
105		-SIG_EXPR_DECL(LPCRST, LPCRST, SIG_DESC_SET(SCU80, 12));
106		-SIG_EXPR_DECL(LPCRST, LPCRSTS, SIG_DESC_SET(HW_STRAP1, 14));
107		-SIG_EXPR_LIST_DECL_DUAL(LPCRST, LPCRST, LPCRSTS);
108		-SS_PIN_DECL(E19, GPIOB4, LPCRST);
	134	+SIG_EXPR_DECL_SINGLE(LPCRST, LPCRST, SIG_DESC_SET(SCU80, 12));
	135	+SIG_EXPR_DECL_SINGLE(LPCRST, LPCRSTS, SIG_DESC_SET(HW_STRAP1, 14));
	136	+SIG_EXPR_LIST_DECL_DUAL(E19, LPCRST, LPCRST, LPCRSTS);
	137	+PIN_DECL_1(E19, GPIOB4, LPCRST);
109	138
110	139	FUNC_GROUP_DECL(LPCRST, E19);
111	140
112	141	#define H19 13
113	142	#define H19_DESC SIG_DESC_SET(SCU80, 13)
114		-SIG_EXPR_LIST_DECL_SINGLE(LPCPD, LPCPD, H19_DESC);
115		-SIG_EXPR_LIST_DECL_SINGLE(LPCSMI, LPCSMI, H19_DESC);
116		-MS_PIN_DECL(H19, GPIOB5, LPCPD, LPCSMI);
	143	+SIG_EXPR_LIST_DECL_SINGLE(H19, LPCPD, LPCPD, H19_DESC);
	144	+SIG_EXPR_LIST_DECL_SINGLE(H19, LPCSMI, LPCSMI, H19_DESC);
	145	+PIN_DECL_2(H19, GPIOB5, LPCPD, LPCSMI);
117	146
118	147	FUNC_GROUP_DECL(LPCPD, H19);
119	148	FUNC_GROUP_DECL(LPCSMI, H19);
..	..	@@ -122,14 +151,14 @@
122	151	SSSF_PIN_DECL(H20, GPIOB6, LPCPME, SIG_DESC_SET(SCU80, 14));
123	152
124	153	#define E18 15
125		-SIG_EXPR_LIST_DECL_SINGLE(EXTRST, EXTRST,
	154	+SIG_EXPR_LIST_DECL_SINGLE(E18, EXTRST, EXTRST,
126	155	SIG_DESC_SET(SCU80, 15),
127	156	SIG_DESC_BIT(SCU90, 31, 0),
128	157	SIG_DESC_SET(SCU3C, 3));
129		-SIG_EXPR_LIST_DECL_SINGLE(SPICS1, SPICS1,
	158	+SIG_EXPR_LIST_DECL_SINGLE(E18, SPICS1, SPICS1,
130	159	SIG_DESC_SET(SCU80, 15),
131	160	SIG_DESC_SET(SCU90, 31));
132		-MS_PIN_DECL(E18, GPIOB7, EXTRST, SPICS1);
	161	+PIN_DECL_2(E18, GPIOB7, EXTRST, SPICS1);
133	162
134	163	FUNC_GROUP_DECL(EXTRST, E18);
135	164	FUNC_GROUP_DECL(SPICS1, E18);
..	..	@@ -138,56 +167,56 @@
138	167	#define I2C10_DESC SIG_DESC_SET(SCU90, 23)
139	168
140	169	#define C4 16
141		-SIG_EXPR_LIST_DECL_SINGLE(SD1CLK, SD1, SD1_DESC);
142		-SIG_EXPR_LIST_DECL_SINGLE(SCL10, I2C10, I2C10_DESC);
143		-MS_PIN_DECL(C4, GPIOC0, SD1CLK, SCL10);
	170	+SIG_EXPR_LIST_DECL_SINGLE(C4, SD1CLK, SD1, SD1_DESC);
	171	+SIG_EXPR_LIST_DECL_SINGLE(C4, SCL10, I2C10, I2C10_DESC);
	172	+PIN_DECL_2(C4, GPIOC0, SD1CLK, SCL10);
144	173
145	174	#define B3 17
146		-SIG_EXPR_LIST_DECL_SINGLE(SD1CMD, SD1, SD1_DESC);
147		-SIG_EXPR_LIST_DECL_SINGLE(SDA10, I2C10, I2C10_DESC);
148		-MS_PIN_DECL(B3, GPIOC1, SD1CMD, SDA10);
	175	+SIG_EXPR_LIST_DECL_SINGLE(B3, SD1CMD, SD1, SD1_DESC);
	176	+SIG_EXPR_LIST_DECL_SINGLE(B3, SDA10, I2C10, I2C10_DESC);
	177	+PIN_DECL_2(B3, GPIOC1, SD1CMD, SDA10);
149	178
150	179	FUNC_GROUP_DECL(I2C10, C4, B3);
151	180
152	181	#define I2C11_DESC SIG_DESC_SET(SCU90, 24)
153	182
154	183	#define A2 18
155		-SIG_EXPR_LIST_DECL_SINGLE(SD1DAT0, SD1, SD1_DESC);
156		-SIG_EXPR_LIST_DECL_SINGLE(SCL11, I2C11, I2C11_DESC);
157		-MS_PIN_DECL(A2, GPIOC2, SD1DAT0, SCL11);
	184	+SIG_EXPR_LIST_DECL_SINGLE(A2, SD1DAT0, SD1, SD1_DESC);
	185	+SIG_EXPR_LIST_DECL_SINGLE(A2, SCL11, I2C11, I2C11_DESC);
	186	+PIN_DECL_2(A2, GPIOC2, SD1DAT0, SCL11);
158	187
159	188	#define E5 19
160		-SIG_EXPR_LIST_DECL_SINGLE(SD1DAT1, SD1, SD1_DESC);
161		-SIG_EXPR_LIST_DECL_SINGLE(SDA11, I2C11, I2C11_DESC);
162		-MS_PIN_DECL(E5, GPIOC3, SD1DAT1, SDA11);
	189	+SIG_EXPR_LIST_DECL_SINGLE(E5, SD1DAT1, SD1, SD1_DESC);
	190	+SIG_EXPR_LIST_DECL_SINGLE(E5, SDA11, I2C11, I2C11_DESC);
	191	+PIN_DECL_2(E5, GPIOC3, SD1DAT1, SDA11);
163	192
164	193	FUNC_GROUP_DECL(I2C11, A2, E5);
165	194
166	195	#define I2C12_DESC SIG_DESC_SET(SCU90, 25)
167	196
168	197	#define D4 20
169		-SIG_EXPR_LIST_DECL_SINGLE(SD1DAT2, SD1, SD1_DESC);
170		-SIG_EXPR_LIST_DECL_SINGLE(SCL12, I2C12, I2C12_DESC);
171		-MS_PIN_DECL(D4, GPIOC4, SD1DAT2, SCL12);
	198	+SIG_EXPR_LIST_DECL_SINGLE(D4, SD1DAT2, SD1, SD1_DESC);
	199	+SIG_EXPR_LIST_DECL_SINGLE(D4, SCL12, I2C12, I2C12_DESC);
	200	+PIN_DECL_2(D4, GPIOC4, SD1DAT2, SCL12);
172	201
173	202	#define C3 21
174		-SIG_EXPR_LIST_DECL_SINGLE(SD1DAT3, SD1, SD1_DESC);
175		-SIG_EXPR_LIST_DECL_SINGLE(SDA12, I2C12, I2C12_DESC);
176		-MS_PIN_DECL(C3, GPIOC5, SD1DAT3, SDA12);
	203	+SIG_EXPR_LIST_DECL_SINGLE(C3, SD1DAT3, SD1, SD1_DESC);
	204	+SIG_EXPR_LIST_DECL_SINGLE(C3, SDA12, I2C12, I2C12_DESC);
	205	+PIN_DECL_2(C3, GPIOC5, SD1DAT3, SDA12);
177	206
178	207	FUNC_GROUP_DECL(I2C12, D4, C3);
179	208
180	209	#define I2C13_DESC SIG_DESC_SET(SCU90, 26)
181	210
182	211	#define B2 22
183		-SIG_EXPR_LIST_DECL_SINGLE(SD1CD, SD1, SD1_DESC);
184		-SIG_EXPR_LIST_DECL_SINGLE(SCL13, I2C13, I2C13_DESC);
185		-MS_PIN_DECL(B2, GPIOC6, SD1CD, SCL13);
	212	+SIG_EXPR_LIST_DECL_SINGLE(B2, SD1CD, SD1, SD1_DESC);
	213	+SIG_EXPR_LIST_DECL_SINGLE(B2, SCL13, I2C13, I2C13_DESC);
	214	+PIN_DECL_2(B2, GPIOC6, SD1CD, SCL13);
186	215
187	216	#define A1 23
188		-SIG_EXPR_LIST_DECL_SINGLE(SD1WP, SD1, SD1_DESC);
189		-SIG_EXPR_LIST_DECL_SINGLE(SDA13, I2C13, I2C13_DESC);
190		-MS_PIN_DECL(A1, GPIOC7, SD1WP, SDA13);
	217	+SIG_EXPR_LIST_DECL_SINGLE(A1, SD1WP, SD1, SD1_DESC);
	218	+SIG_EXPR_LIST_DECL_SINGLE(A1, SDA13, I2C13, I2C13_DESC);
	219	+PIN_DECL_2(A1, GPIOC7, SD1WP, SDA13);
191	220
192	221	FUNC_GROUP_DECL(I2C13, B2, A1);
193	222	FUNC_GROUP_DECL(SD1, C4, B3, A2, E5, D4, C3, B2, A1);
..	..	@@ -197,72 +226,72 @@
197	226	#define GPID0_DESC SIG_DESC_SET(SCU8C, 8)
198	227
199	228	#define A18 24
200		-SIG_EXPR_LIST_DECL_SINGLE(SD2CLK, SD2, SD2_DESC);
201		-SIG_EXPR_DECL(GPID0IN, GPID0, GPID0_DESC);
202		-SIG_EXPR_DECL(GPID0IN, GPID, GPID_DESC);
203		-SIG_EXPR_LIST_DECL_DUAL(GPID0IN, GPID0, GPID);
204		-MS_PIN_DECL(A18, GPIOD0, SD2CLK, GPID0IN);
	229	+SIG_EXPR_LIST_DECL_SINGLE(A18, SD2CLK, SD2, SD2_DESC);
	230	+SIG_EXPR_DECL_SINGLE(GPID0IN, GPID0, GPID0_DESC);
	231	+SIG_EXPR_DECL_SINGLE(GPID0IN, GPID, GPID_DESC);
	232	+SIG_EXPR_LIST_DECL_DUAL(A18, GPID0IN, GPID0, GPID);
	233	+PIN_DECL_2(A18, GPIOD0, SD2CLK, GPID0IN);
205	234
206	235	#define D16 25
207		-SIG_EXPR_LIST_DECL_SINGLE(SD2CMD, SD2, SD2_DESC);
208		-SIG_EXPR_DECL(GPID0OUT, GPID0, GPID0_DESC);
209		-SIG_EXPR_DECL(GPID0OUT, GPID, GPID_DESC);
210		-SIG_EXPR_LIST_DECL_DUAL(GPID0OUT, GPID0, GPID);
211		-MS_PIN_DECL(D16, GPIOD1, SD2CMD, GPID0OUT);
	236	+SIG_EXPR_LIST_DECL_SINGLE(D16, SD2CMD, SD2, SD2_DESC);
	237	+SIG_EXPR_DECL_SINGLE(GPID0OUT, GPID0, GPID0_DESC);
	238	+SIG_EXPR_DECL_SINGLE(GPID0OUT, GPID, GPID_DESC);
	239	+SIG_EXPR_LIST_DECL_DUAL(D16, GPID0OUT, GPID0, GPID);
	240	+PIN_DECL_2(D16, GPIOD1, SD2CMD, GPID0OUT);
212	241
213	242	FUNC_GROUP_DECL(GPID0, A18, D16);
214	243
215	244	#define GPID2_DESC SIG_DESC_SET(SCU8C, 9)
216	245
217	246	#define B17 26
218		-SIG_EXPR_LIST_DECL_SINGLE(SD2DAT0, SD2, SD2_DESC);
219		-SIG_EXPR_DECL(GPID2IN, GPID2, GPID2_DESC);
220		-SIG_EXPR_DECL(GPID2IN, GPID, GPID_DESC);
221		-SIG_EXPR_LIST_DECL_DUAL(GPID2IN, GPID2, GPID);
222		-MS_PIN_DECL(B17, GPIOD2, SD2DAT0, GPID2IN);
	247	+SIG_EXPR_LIST_DECL_SINGLE(B17, SD2DAT0, SD2, SD2_DESC);
	248	+SIG_EXPR_DECL_SINGLE(GPID2IN, GPID2, GPID2_DESC);
	249	+SIG_EXPR_DECL_SINGLE(GPID2IN, GPID, GPID_DESC);
	250	+SIG_EXPR_LIST_DECL_DUAL(B17, GPID2IN, GPID2, GPID);
	251	+PIN_DECL_2(B17, GPIOD2, SD2DAT0, GPID2IN);
223	252
224	253	#define A17 27
225		-SIG_EXPR_LIST_DECL_SINGLE(SD2DAT1, SD2, SD2_DESC);
226		-SIG_EXPR_DECL(GPID2OUT, GPID2, GPID2_DESC);
227		-SIG_EXPR_DECL(GPID2OUT, GPID, GPID_DESC);
228		-SIG_EXPR_LIST_DECL_DUAL(GPID2OUT, GPID2, GPID);
229		-MS_PIN_DECL(A17, GPIOD3, SD2DAT1, GPID2OUT);
	254	+SIG_EXPR_LIST_DECL_SINGLE(A17, SD2DAT1, SD2, SD2_DESC);
	255	+SIG_EXPR_DECL_SINGLE(GPID2OUT, GPID2, GPID2_DESC);
	256	+SIG_EXPR_DECL_SINGLE(GPID2OUT, GPID, GPID_DESC);
	257	+SIG_EXPR_LIST_DECL_DUAL(A17, GPID2OUT, GPID2, GPID);
	258	+PIN_DECL_2(A17, GPIOD3, SD2DAT1, GPID2OUT);
230	259
231	260	FUNC_GROUP_DECL(GPID2, B17, A17);
232	261
233	262	#define GPID4_DESC SIG_DESC_SET(SCU8C, 10)
234	263
235	264	#define C16 28
236		-SIG_EXPR_LIST_DECL_SINGLE(SD2DAT2, SD2, SD2_DESC);
237		-SIG_EXPR_DECL(GPID4IN, GPID4, GPID4_DESC);
238		-SIG_EXPR_DECL(GPID4IN, GPID, GPID_DESC);
239		-SIG_EXPR_LIST_DECL_DUAL(GPID4IN, GPID4, GPID);
240		-MS_PIN_DECL(C16, GPIOD4, SD2DAT2, GPID4IN);
	265	+SIG_EXPR_LIST_DECL_SINGLE(C16, SD2DAT2, SD2, SD2_DESC);
	266	+SIG_EXPR_DECL_SINGLE(GPID4IN, GPID4, GPID4_DESC);
	267	+SIG_EXPR_DECL_SINGLE(GPID4IN, GPID, GPID_DESC);
	268	+SIG_EXPR_LIST_DECL_DUAL(C16, GPID4IN, GPID4, GPID);
	269	+PIN_DECL_2(C16, GPIOD4, SD2DAT2, GPID4IN);
241	270
242	271	#define B16 29
243		-SIG_EXPR_LIST_DECL_SINGLE(SD2DAT3, SD2, SD2_DESC);
244		-SIG_EXPR_DECL(GPID4OUT, GPID4, GPID4_DESC);
245		-SIG_EXPR_DECL(GPID4OUT, GPID, GPID_DESC);
246		-SIG_EXPR_LIST_DECL_DUAL(GPID4OUT, GPID4, GPID);
247		-MS_PIN_DECL(B16, GPIOD5, SD2DAT3, GPID4OUT);
	272	+SIG_EXPR_LIST_DECL_SINGLE(B16, SD2DAT3, SD2, SD2_DESC);
	273	+SIG_EXPR_DECL_SINGLE(GPID4OUT, GPID4, GPID4_DESC);
	274	+SIG_EXPR_DECL_SINGLE(GPID4OUT, GPID, GPID_DESC);
	275	+SIG_EXPR_LIST_DECL_DUAL(B16, GPID4OUT, GPID4, GPID);
	276	+PIN_DECL_2(B16, GPIOD5, SD2DAT3, GPID4OUT);
248	277
249	278	FUNC_GROUP_DECL(GPID4, C16, B16);
250	279
251	280	#define GPID6_DESC SIG_DESC_SET(SCU8C, 11)
252	281
253	282	#define A16 30
254		-SIG_EXPR_LIST_DECL_SINGLE(SD2CD, SD2, SD2_DESC);
255		-SIG_EXPR_DECL(GPID6IN, GPID6, GPID6_DESC);
256		-SIG_EXPR_DECL(GPID6IN, GPID, GPID_DESC);
257		-SIG_EXPR_LIST_DECL_DUAL(GPID6IN, GPID6, GPID);
258		-MS_PIN_DECL(A16, GPIOD6, SD2CD, GPID6IN);
	283	+SIG_EXPR_LIST_DECL_SINGLE(A16, SD2CD, SD2, SD2_DESC);
	284	+SIG_EXPR_DECL_SINGLE(GPID6IN, GPID6, GPID6_DESC);
	285	+SIG_EXPR_DECL_SINGLE(GPID6IN, GPID, GPID_DESC);
	286	+SIG_EXPR_LIST_DECL_DUAL(A16, GPID6IN, GPID6, GPID);
	287	+PIN_DECL_2(A16, GPIOD6, SD2CD, GPID6IN);
259	288
260	289	#define E15 31
261		-SIG_EXPR_LIST_DECL_SINGLE(SD2WP, SD2, SD2_DESC);
262		-SIG_EXPR_DECL(GPID6OUT, GPID6, GPID6_DESC);
263		-SIG_EXPR_DECL(GPID6OUT, GPID, GPID_DESC);
264		-SIG_EXPR_LIST_DECL_DUAL(GPID6OUT, GPID6, GPID);
265		-MS_PIN_DECL(E15, GPIOD7, SD2WP, GPID6OUT);
	290	+SIG_EXPR_LIST_DECL_SINGLE(E15, SD2WP, SD2, SD2_DESC);
	291	+SIG_EXPR_DECL_SINGLE(GPID6OUT, GPID6, GPID6_DESC);
	292	+SIG_EXPR_DECL_SINGLE(GPID6OUT, GPID, GPID_DESC);
	293	+SIG_EXPR_LIST_DECL_DUAL(E15, GPID6OUT, GPID6, GPID);
	294	+PIN_DECL_2(E15, GPIOD7, SD2WP, GPID6OUT);
266	295
267	296	FUNC_GROUP_DECL(GPID6, A16, E15);
268	297	FUNC_GROUP_DECL(SD2, A18, D16, B17, A17, C16, B16, A16, E15);
..	..	@@ -275,77 +304,77 @@
275	304	#define GPIE6_DESC SIG_DESC_SET(SCU8C, 15)
276	305
277	306	#define D15 32
278		-SIG_EXPR_LIST_DECL_SINGLE(NCTS3, NCTS3, SIG_DESC_SET(SCU80, 16));
279		-SIG_EXPR_DECL(GPIE0IN, GPIE0, GPIE0_DESC);
280		-SIG_EXPR_DECL(GPIE0IN, GPIE, GPIE_DESC);
281		-SIG_EXPR_LIST_DECL_DUAL(GPIE0IN, GPIE0, GPIE);
282		-MS_PIN_DECL(D15, GPIOE0, NCTS3, GPIE0IN);
	307	+SIG_EXPR_LIST_DECL_SINGLE(D15, NCTS3, NCTS3, SIG_DESC_SET(SCU80, 16));
	308	+SIG_EXPR_DECL_SINGLE(GPIE0IN, GPIE0, GPIE0_DESC);
	309	+SIG_EXPR_DECL_SINGLE(GPIE0IN, GPIE, GPIE_DESC);
	310	+SIG_EXPR_LIST_DECL_DUAL(D15, GPIE0IN, GPIE0, GPIE);
	311	+PIN_DECL_2(D15, GPIOE0, NCTS3, GPIE0IN);
283	312
284	313	FUNC_GROUP_DECL(NCTS3, D15);
285	314
286	315	#define C15 33
287		-SIG_EXPR_LIST_DECL_SINGLE(NDCD3, NDCD3, SIG_DESC_SET(SCU80, 17));
288		-SIG_EXPR_DECL(GPIE0OUT, GPIE0, GPIE0_DESC);
289		-SIG_EXPR_DECL(GPIE0OUT, GPIE, GPIE_DESC);
290		-SIG_EXPR_LIST_DECL_DUAL(GPIE0OUT, GPIE0, GPIE);
291		-MS_PIN_DECL(C15, GPIOE1, NDCD3, GPIE0OUT);
	316	+SIG_EXPR_LIST_DECL_SINGLE(C15, NDCD3, NDCD3, SIG_DESC_SET(SCU80, 17));
	317	+SIG_EXPR_DECL_SINGLE(GPIE0OUT, GPIE0, GPIE0_DESC);
	318	+SIG_EXPR_DECL_SINGLE(GPIE0OUT, GPIE, GPIE_DESC);
	319	+SIG_EXPR_LIST_DECL_DUAL(C15, GPIE0OUT, GPIE0, GPIE);
	320	+PIN_DECL_2(C15, GPIOE1, NDCD3, GPIE0OUT);
292	321
293	322	FUNC_GROUP_DECL(NDCD3, C15);
294	323	FUNC_GROUP_DECL(GPIE0, D15, C15);
295	324
296	325	#define B15 34
297		-SIG_EXPR_LIST_DECL_SINGLE(NDSR3, NDSR3, SIG_DESC_SET(SCU80, 18));
298		-SIG_EXPR_DECL(GPIE2IN, GPIE2, GPIE2_DESC);
299		-SIG_EXPR_DECL(GPIE2IN, GPIE, GPIE_DESC);
300		-SIG_EXPR_LIST_DECL_DUAL(GPIE2IN, GPIE2, GPIE);
301		-MS_PIN_DECL(B15, GPIOE2, NDSR3, GPIE2IN);
	326	+SIG_EXPR_LIST_DECL_SINGLE(B15, NDSR3, NDSR3, SIG_DESC_SET(SCU80, 18));
	327	+SIG_EXPR_DECL_SINGLE(GPIE2IN, GPIE2, GPIE2_DESC);
	328	+SIG_EXPR_DECL_SINGLE(GPIE2IN, GPIE, GPIE_DESC);
	329	+SIG_EXPR_LIST_DECL_DUAL(B15, GPIE2IN, GPIE2, GPIE);
	330	+PIN_DECL_2(B15, GPIOE2, NDSR3, GPIE2IN);
302	331
303	332	FUNC_GROUP_DECL(NDSR3, B15);
304	333
305	334	#define A15 35
306		-SIG_EXPR_LIST_DECL_SINGLE(NRI3, NRI3, SIG_DESC_SET(SCU80, 19));
307		-SIG_EXPR_DECL(GPIE2OUT, GPIE2, GPIE2_DESC);
308		-SIG_EXPR_DECL(GPIE2OUT, GPIE, GPIE_DESC);
309		-SIG_EXPR_LIST_DECL_DUAL(GPIE2OUT, GPIE2, GPIE);
310		-MS_PIN_DECL(A15, GPIOE3, NRI3, GPIE2OUT);
	335	+SIG_EXPR_LIST_DECL_SINGLE(A15, NRI3, NRI3, SIG_DESC_SET(SCU80, 19));
	336	+SIG_EXPR_DECL_SINGLE(GPIE2OUT, GPIE2, GPIE2_DESC);
	337	+SIG_EXPR_DECL_SINGLE(GPIE2OUT, GPIE, GPIE_DESC);
	338	+SIG_EXPR_LIST_DECL_DUAL(A15, GPIE2OUT, GPIE2, GPIE);
	339	+PIN_DECL_2(A15, GPIOE3, NRI3, GPIE2OUT);
311	340
312	341	FUNC_GROUP_DECL(NRI3, A15);
313	342	FUNC_GROUP_DECL(GPIE2, B15, A15);
314	343
315	344	#define E14 36
316		-SIG_EXPR_LIST_DECL_SINGLE(NDTR3, NDTR3, SIG_DESC_SET(SCU80, 20));
317		-SIG_EXPR_DECL(GPIE4IN, GPIE4, GPIE4_DESC);
318		-SIG_EXPR_DECL(GPIE4IN, GPIE, GPIE_DESC);
319		-SIG_EXPR_LIST_DECL_DUAL(GPIE4IN, GPIE4, GPIE);
320		-MS_PIN_DECL(E14, GPIOE4, NDTR3, GPIE4IN);
	345	+SIG_EXPR_LIST_DECL_SINGLE(E14, NDTR3, NDTR3, SIG_DESC_SET(SCU80, 20));
	346	+SIG_EXPR_DECL_SINGLE(GPIE4IN, GPIE4, GPIE4_DESC);
	347	+SIG_EXPR_DECL_SINGLE(GPIE4IN, GPIE, GPIE_DESC);
	348	+SIG_EXPR_LIST_DECL_DUAL(E14, GPIE4IN, GPIE4, GPIE);
	349	+PIN_DECL_2(E14, GPIOE4, NDTR3, GPIE4IN);
321	350
322	351	FUNC_GROUP_DECL(NDTR3, E14);
323	352
324	353	#define D14 37
325		-SIG_EXPR_LIST_DECL_SINGLE(NRTS3, NRTS3, SIG_DESC_SET(SCU80, 21));
326		-SIG_EXPR_DECL(GPIE4OUT, GPIE4, GPIE4_DESC);
327		-SIG_EXPR_DECL(GPIE4OUT, GPIE, GPIE_DESC);
328		-SIG_EXPR_LIST_DECL_DUAL(GPIE4OUT, GPIE4, GPIE);
329		-MS_PIN_DECL(D14, GPIOE5, NRTS3, GPIE4OUT);
	354	+SIG_EXPR_LIST_DECL_SINGLE(D14, NRTS3, NRTS3, SIG_DESC_SET(SCU80, 21));
	355	+SIG_EXPR_DECL_SINGLE(GPIE4OUT, GPIE4, GPIE4_DESC);
	356	+SIG_EXPR_DECL_SINGLE(GPIE4OUT, GPIE, GPIE_DESC);
	357	+SIG_EXPR_LIST_DECL_DUAL(D14, GPIE4OUT, GPIE4, GPIE);
	358	+PIN_DECL_2(D14, GPIOE5, NRTS3, GPIE4OUT);
330	359
331	360	FUNC_GROUP_DECL(NRTS3, D14);
332	361	FUNC_GROUP_DECL(GPIE4, E14, D14);
333	362
334	363	#define C14 38
335		-SIG_EXPR_LIST_DECL_SINGLE(TXD3, TXD3, SIG_DESC_SET(SCU80, 22));
336		-SIG_EXPR_DECL(GPIE6IN, GPIE6, GPIE6_DESC);
337		-SIG_EXPR_DECL(GPIE6IN, GPIE, GPIE_DESC);
338		-SIG_EXPR_LIST_DECL_DUAL(GPIE6IN, GPIE6, GPIE);
339		-MS_PIN_DECL(C14, GPIOE6, TXD3, GPIE6IN);
	364	+SIG_EXPR_LIST_DECL_SINGLE(C14, TXD3, TXD3, SIG_DESC_SET(SCU80, 22));
	365	+SIG_EXPR_DECL_SINGLE(GPIE6IN, GPIE6, GPIE6_DESC);
	366	+SIG_EXPR_DECL_SINGLE(GPIE6IN, GPIE, GPIE_DESC);
	367	+SIG_EXPR_LIST_DECL_DUAL(C14, GPIE6IN, GPIE6, GPIE);
	368	+PIN_DECL_2(C14, GPIOE6, TXD3, GPIE6IN);
340	369
341	370	FUNC_GROUP_DECL(TXD3, C14);
342	371
343	372	#define B14 39
344		-SIG_EXPR_LIST_DECL_SINGLE(RXD3, RXD3, SIG_DESC_SET(SCU80, 23));
345		-SIG_EXPR_DECL(GPIE6OUT, GPIE6, GPIE6_DESC);
346		-SIG_EXPR_DECL(GPIE6OUT, GPIE, GPIE_DESC);
347		-SIG_EXPR_LIST_DECL_DUAL(GPIE6OUT, GPIE6, GPIE);
348		-MS_PIN_DECL(B14, GPIOE7, RXD3, GPIE6OUT);
	373	+SIG_EXPR_LIST_DECL_SINGLE(B14, RXD3, RXD3, SIG_DESC_SET(SCU80, 23));
	374	+SIG_EXPR_DECL_SINGLE(GPIE6OUT, GPIE6, GPIE6_DESC);
	375	+SIG_EXPR_DECL_SINGLE(GPIE6OUT, GPIE, GPIE_DESC);
	376	+SIG_EXPR_LIST_DECL_DUAL(B14, GPIE6OUT, GPIE6, GPIE);
	377	+PIN_DECL_2(B14, GPIOE7, RXD3, GPIE6OUT);
349	378
350	379	FUNC_GROUP_DECL(RXD3, B14);
351	380	FUNC_GROUP_DECL(GPIE6, C14, B14);
..	..	@@ -356,29 +385,29 @@
356	385	#define ACPI_DESC SIG_DESC_BIT(HW_STRAP1, 19, 0)
357	386
358	387	#define B19 41
359		-SIG_EXPR_LIST_DECL_SINGLE(NDCD4, NDCD4, SIG_DESC_SET(SCU80, 25));
360		-SIG_EXPR_DECL(SIOPBI, SIOPBI, SIG_DESC_SET(SCUA4, 12));
361		-SIG_EXPR_DECL(SIOPBI, ACPI, ACPI_DESC);
362		-SIG_EXPR_LIST_DECL_DUAL(SIOPBI, SIOPBI, ACPI);
363		-MS_PIN_DECL(B19, GPIOF1, NDCD4, SIOPBI);
	388	+SIG_EXPR_LIST_DECL_SINGLE(B19, NDCD4, NDCD4, SIG_DESC_SET(SCU80, 25));
	389	+SIG_EXPR_DECL_SINGLE(SIOPBI, SIOPBI, SIG_DESC_SET(SCUA4, 12));
	390	+SIG_EXPR_DECL_SINGLE(SIOPBI, ACPI, ACPI_DESC);
	391	+SIG_EXPR_LIST_DECL_DUAL(B19, SIOPBI, SIOPBI, ACPI);
	392	+PIN_DECL_2(B19, GPIOF1, NDCD4, SIOPBI);
364	393	FUNC_GROUP_DECL(NDCD4, B19);
365	394	FUNC_GROUP_DECL(SIOPBI, B19);
366	395
367	396	#define A20 42
368		-SIG_EXPR_LIST_DECL_SINGLE(NDSR4, NDSR4, SIG_DESC_SET(SCU80, 26));
369		-SIG_EXPR_DECL(SIOPWRGD, SIOPWRGD, SIG_DESC_SET(SCUA4, 12));
370		-SIG_EXPR_DECL(SIOPWRGD, ACPI, ACPI_DESC);
371		-SIG_EXPR_LIST_DECL_DUAL(SIOPWRGD, SIOPWRGD, ACPI);
372		-MS_PIN_DECL(A20, GPIOF2, NDSR4, SIOPWRGD);
	397	+SIG_EXPR_LIST_DECL_SINGLE(A20, NDSR4, NDSR4, SIG_DESC_SET(SCU80, 26));
	398	+SIG_EXPR_DECL_SINGLE(SIOPWRGD, SIOPWRGD, SIG_DESC_SET(SCUA4, 12));
	399	+SIG_EXPR_DECL_SINGLE(SIOPWRGD, ACPI, ACPI_DESC);
	400	+SIG_EXPR_LIST_DECL_DUAL(A20, SIOPWRGD, SIOPWRGD, ACPI);
	401	+PIN_DECL_2(A20, GPIOF2, NDSR4, SIOPWRGD);
373	402	FUNC_GROUP_DECL(NDSR4, A20);
374	403	FUNC_GROUP_DECL(SIOPWRGD, A20);
375	404
376	405	#define D17 43
377		-SIG_EXPR_LIST_DECL_SINGLE(NRI4, NRI4, SIG_DESC_SET(SCU80, 27));
378		-SIG_EXPR_DECL(SIOPBO, SIOPBO, SIG_DESC_SET(SCUA4, 14));
379		-SIG_EXPR_DECL(SIOPBO, ACPI, ACPI_DESC);
380		-SIG_EXPR_LIST_DECL_DUAL(SIOPBO, SIOPBO, ACPI);
381		-MS_PIN_DECL(D17, GPIOF3, NRI4, SIOPBO);
	406	+SIG_EXPR_LIST_DECL_SINGLE(D17, NRI4, NRI4, SIG_DESC_SET(SCU80, 27));
	407	+SIG_EXPR_DECL_SINGLE(SIOPBO, SIOPBO, SIG_DESC_SET(SCUA4, 14));
	408	+SIG_EXPR_DECL_SINGLE(SIOPBO, ACPI, ACPI_DESC);
	409	+SIG_EXPR_LIST_DECL_DUAL(D17, SIOPBO, SIOPBO, ACPI);
	410	+PIN_DECL_2(D17, GPIOF3, NRI4, SIOPBO);
382	411	FUNC_GROUP_DECL(NRI4, D17);
383	412	FUNC_GROUP_DECL(SIOPBO, D17);
384	413
..	..	@@ -386,11 +415,11 @@
386	415	SSSF_PIN_DECL(B18, GPIOF4, NDTR4, SIG_DESC_SET(SCU80, 28));
387	416
388	417	#define A19 45
389		-SIG_EXPR_LIST_DECL_SINGLE(NDTS4, NDTS4, SIG_DESC_SET(SCU80, 29));
390		-SIG_EXPR_DECL(SIOSCI, SIOSCI, SIG_DESC_SET(SCUA4, 15));
391		-SIG_EXPR_DECL(SIOSCI, ACPI, ACPI_DESC);
392		-SIG_EXPR_LIST_DECL_DUAL(SIOSCI, SIOSCI, ACPI);
393		-MS_PIN_DECL(A19, GPIOF5, NDTS4, SIOSCI);
	418	+SIG_EXPR_LIST_DECL_SINGLE(A19, NDTS4, NDTS4, SIG_DESC_SET(SCU80, 29));
	419	+SIG_EXPR_DECL_SINGLE(SIOSCI, SIOSCI, SIG_DESC_SET(SCUA4, 15));
	420	+SIG_EXPR_DECL_SINGLE(SIOSCI, ACPI, ACPI_DESC);
	421	+SIG_EXPR_LIST_DECL_DUAL(A19, SIOSCI, SIOSCI, ACPI);
	422	+PIN_DECL_2(A19, GPIOF5, NDTS4, SIOSCI);
394	423	FUNC_GROUP_DECL(NDTS4, A19);
395	424	FUNC_GROUP_DECL(SIOSCI, A19);
396	425
..	..	@@ -413,17 +442,17 @@
413	442	SSSF_PIN_DECL(C13, GPIOG3, SGPSI1, SIG_DESC_SET(SCU84, 3));
414	443
415	444	#define B13 52
416		-SIG_EXPR_LIST_DECL_SINGLE(OSCCLK, OSCCLK, SIG_DESC_SET(SCU2C, 1));
417		-SIG_EXPR_LIST_DECL_SINGLE(WDTRST1, WDTRST1, SIG_DESC_SET(SCU84, 4));
418		-MS_PIN_DECL(B13, GPIOG4, OSCCLK, WDTRST1);
	445	+SIG_EXPR_LIST_DECL_SINGLE(B13, OSCCLK, OSCCLK, SIG_DESC_SET(SCU2C, 1));
	446	+SIG_EXPR_LIST_DECL_SINGLE(B13, WDTRST1, WDTRST1, SIG_DESC_SET(SCU84, 4));
	447	+PIN_DECL_2(B13, GPIOG4, OSCCLK, WDTRST1);
419	448
420	449	FUNC_GROUP_DECL(OSCCLK, B13);
421	450	FUNC_GROUP_DECL(WDTRST1, B13);
422	451
423	452	#define Y21 53
424		-SIG_EXPR_LIST_DECL_SINGLE(USBCKI, USBCKI, SIG_DESC_SET(HW_STRAP1, 23));
425		-SIG_EXPR_LIST_DECL_SINGLE(WDTRST2, WDTRST2, SIG_DESC_SET(SCU84, 5));
426		-MS_PIN_DECL(Y21, GPIOG5, USBCKI, WDTRST2);
	453	+SIG_EXPR_LIST_DECL_SINGLE(Y21, USBCKI, USBCKI, SIG_DESC_SET(HW_STRAP1, 23));
	454	+SIG_EXPR_LIST_DECL_SINGLE(Y21, WDTRST2, WDTRST2, SIG_DESC_SET(SCU84, 5));
	455	+PIN_DECL_2(Y21, GPIOG5, USBCKI, WDTRST2);
427	456
428	457	FUNC_GROUP_DECL(USBCKI, Y21);
429	458	FUNC_GROUP_DECL(WDTRST2, Y21);
..	..	@@ -440,60 +469,60 @@
440	469	#define BOOT_SRC_NOR { ASPEED_IP_SCU, HW_STRAP1, GENMASK(1, 0), 0, 0 }
441	470
442	471	#define A8 56
443		-SIG_EXPR_DECL(ROMD8, ROM16, ROM16_DESC);
444		-SIG_EXPR_DECL(ROMD8, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
445		-SIG_EXPR_LIST_DECL_DUAL(ROMD8, ROM16, ROM16S);
446		-SIG_EXPR_LIST_DECL_SINGLE(NCTS6, NCTS6, UART6_DESC);
447		-MS_PIN_DECL(A8, GPIOH0, ROMD8, NCTS6);
	472	+SIG_EXPR_DECL_SINGLE(ROMD8, ROM16, ROM16_DESC);
	473	+SIG_EXPR_DECL_SINGLE(ROMD8, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	474	+SIG_EXPR_LIST_DECL_DUAL(A8, ROMD8, ROM16, ROM16S);
	475	+SIG_EXPR_LIST_DECL_SINGLE(A8, NCTS6, NCTS6, UART6_DESC);
	476	+PIN_DECL_2(A8, GPIOH0, ROMD8, NCTS6);
448	477
449	478	#define C7 57
450		-SIG_EXPR_DECL(ROMD9, ROM16, ROM16_DESC);
451		-SIG_EXPR_DECL(ROMD9, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
452		-SIG_EXPR_LIST_DECL_DUAL(ROMD9, ROM16, ROM16S);
453		-SIG_EXPR_LIST_DECL_SINGLE(NDCD6, NDCD6, UART6_DESC);
454		-MS_PIN_DECL(C7, GPIOH1, ROMD9, NDCD6);
	479	+SIG_EXPR_DECL_SINGLE(ROMD9, ROM16, ROM16_DESC);
	480	+SIG_EXPR_DECL_SINGLE(ROMD9, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	481	+SIG_EXPR_LIST_DECL_DUAL(C7, ROMD9, ROM16, ROM16S);
	482	+SIG_EXPR_LIST_DECL_SINGLE(C7, NDCD6, NDCD6, UART6_DESC);
	483	+PIN_DECL_2(C7, GPIOH1, ROMD9, NDCD6);
455	484
456	485	#define B7 58
457		-SIG_EXPR_DECL(ROMD10, ROM16, ROM16_DESC);
458		-SIG_EXPR_DECL(ROMD10, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
459		-SIG_EXPR_LIST_DECL_DUAL(ROMD10, ROM16, ROM16S);
460		-SIG_EXPR_LIST_DECL_SINGLE(NDSR6, NDSR6, UART6_DESC);
461		-MS_PIN_DECL(B7, GPIOH2, ROMD10, NDSR6);
	486	+SIG_EXPR_DECL_SINGLE(ROMD10, ROM16, ROM16_DESC);
	487	+SIG_EXPR_DECL_SINGLE(ROMD10, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	488	+SIG_EXPR_LIST_DECL_DUAL(B7, ROMD10, ROM16, ROM16S);
	489	+SIG_EXPR_LIST_DECL_SINGLE(B7, NDSR6, NDSR6, UART6_DESC);
	490	+PIN_DECL_2(B7, GPIOH2, ROMD10, NDSR6);
462	491
463	492	#define A7 59
464		-SIG_EXPR_DECL(ROMD11, ROM16, ROM16_DESC);
465		-SIG_EXPR_DECL(ROMD11, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
466		-SIG_EXPR_LIST_DECL_DUAL(ROMD11, ROM16, ROM16S);
467		-SIG_EXPR_LIST_DECL_SINGLE(NRI6, NRI6, UART6_DESC);
468		-MS_PIN_DECL(A7, GPIOH3, ROMD11, NRI6);
	493	+SIG_EXPR_DECL_SINGLE(ROMD11, ROM16, ROM16_DESC);
	494	+SIG_EXPR_DECL_SINGLE(ROMD11, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	495	+SIG_EXPR_LIST_DECL_DUAL(A7, ROMD11, ROM16, ROM16S);
	496	+SIG_EXPR_LIST_DECL_SINGLE(A7, NRI6, NRI6, UART6_DESC);
	497	+PIN_DECL_2(A7, GPIOH3, ROMD11, NRI6);
469	498
470	499	#define D7 60
471		-SIG_EXPR_DECL(ROMD12, ROM16, ROM16_DESC);
472		-SIG_EXPR_DECL(ROMD12, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
473		-SIG_EXPR_LIST_DECL_DUAL(ROMD12, ROM16, ROM16S);
474		-SIG_EXPR_LIST_DECL_SINGLE(NDTR6, NDTR6, UART6_DESC);
475		-MS_PIN_DECL(D7, GPIOH4, ROMD12, NDTR6);
	500	+SIG_EXPR_DECL_SINGLE(ROMD12, ROM16, ROM16_DESC);
	501	+SIG_EXPR_DECL_SINGLE(ROMD12, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	502	+SIG_EXPR_LIST_DECL_DUAL(D7, ROMD12, ROM16, ROM16S);
	503	+SIG_EXPR_LIST_DECL_SINGLE(D7, NDTR6, NDTR6, UART6_DESC);
	504	+PIN_DECL_2(D7, GPIOH4, ROMD12, NDTR6);
476	505
477	506	#define B6 61
478		-SIG_EXPR_DECL(ROMD13, ROM16, ROM16_DESC);
479		-SIG_EXPR_DECL(ROMD13, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
480		-SIG_EXPR_LIST_DECL_DUAL(ROMD13, ROM16, ROM16S);
481		-SIG_EXPR_LIST_DECL_SINGLE(NRTS6, NRTS6, UART6_DESC);
482		-MS_PIN_DECL(B6, GPIOH5, ROMD13, NRTS6);
	507	+SIG_EXPR_DECL_SINGLE(ROMD13, ROM16, ROM16_DESC);
	508	+SIG_EXPR_DECL_SINGLE(ROMD13, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	509	+SIG_EXPR_LIST_DECL_DUAL(B6, ROMD13, ROM16, ROM16S);
	510	+SIG_EXPR_LIST_DECL_SINGLE(B6, NRTS6, NRTS6, UART6_DESC);
	511	+PIN_DECL_2(B6, GPIOH5, ROMD13, NRTS6);
483	512
484	513	#define A6 62
485		-SIG_EXPR_DECL(ROMD14, ROM16, ROM16_DESC);
486		-SIG_EXPR_DECL(ROMD14, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
487		-SIG_EXPR_LIST_DECL_DUAL(ROMD14, ROM16, ROM16S);
488		-SIG_EXPR_LIST_DECL_SINGLE(TXD6, TXD6, UART6_DESC);
489		-MS_PIN_DECL(A6, GPIOH6, ROMD14, TXD6);
	514	+SIG_EXPR_DECL_SINGLE(ROMD14, ROM16, ROM16_DESC);
	515	+SIG_EXPR_DECL_SINGLE(ROMD14, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	516	+SIG_EXPR_LIST_DECL_DUAL(A6, ROMD14, ROM16, ROM16S);
	517	+SIG_EXPR_LIST_DECL_SINGLE(A6, TXD6, TXD6, UART6_DESC);
	518	+PIN_DECL_2(A6, GPIOH6, ROMD14, TXD6);
490	519
491	520	#define E7 63
492		-SIG_EXPR_DECL(ROMD15, ROM16, ROM16_DESC);
493		-SIG_EXPR_DECL(ROMD15, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
494		-SIG_EXPR_LIST_DECL_DUAL(ROMD15, ROM16, ROM16S);
495		-SIG_EXPR_LIST_DECL_SINGLE(RXD6, RXD6, UART6_DESC);
496		-MS_PIN_DECL(E7, GPIOH7, ROMD15, RXD6);
	521	+SIG_EXPR_DECL_SINGLE(ROMD15, ROM16, ROM16_DESC);
	522	+SIG_EXPR_DECL_SINGLE(ROMD15, ROM16S, FLASH_WIDE, BOOT_SRC_NOR);
	523	+SIG_EXPR_LIST_DECL_DUAL(E7, ROMD15, ROM16, ROM16S);
	524	+SIG_EXPR_LIST_DECL_SINGLE(E7, RXD6, RXD6, UART6_DESC);
	525	+PIN_DECL_2(E7, GPIOH7, ROMD15, RXD6);
497	526
498	527	FUNC_GROUP_DECL(UART6, A8, C7, B7, A7, D7, B6, A6, E7);
499	528
..	..	@@ -505,70 +534,78 @@
505	534	{ ASPEED_IP_SCU, HW_STRAP1, GENMASK(13, 12), 3, 0 }
506	535
507	536	#define C22 64
508		-SIG_EXPR_DECL(SYSCS, SPI1DEBUG, SPI1DEBUG_DESC);
509		-SIG_EXPR_DECL(SYSCS, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
510		-SIG_EXPR_LIST_DECL_DUAL(SYSCS, SPI1DEBUG, SPI1PASSTHRU);
511		-SS_PIN_DECL(C22, GPIOI0, SYSCS);
	537	+SIG_EXPR_DECL_SINGLE(SYSCS, SPI1DEBUG, SPI1DEBUG_DESC);
	538	+SIG_EXPR_DECL_SINGLE(SYSCS, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	539	+SIG_EXPR_LIST_DECL_DUAL(C22, SYSCS, SPI1DEBUG, SPI1PASSTHRU);
	540	+PIN_DECL_1(C22, GPIOI0, SYSCS);
512	541
513	542	#define G18 65
514		-SIG_EXPR_DECL(SYSCK, SPI1DEBUG, SPI1DEBUG_DESC);
515		-SIG_EXPR_DECL(SYSCK, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
516		-SIG_EXPR_LIST_DECL_DUAL(SYSCK, SPI1DEBUG, SPI1PASSTHRU);
517		-SS_PIN_DECL(G18, GPIOI1, SYSCK);
	543	+SIG_EXPR_DECL_SINGLE(SYSCK, SPI1DEBUG, SPI1DEBUG_DESC);
	544	+SIG_EXPR_DECL_SINGLE(SYSCK, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	545	+SIG_EXPR_LIST_DECL_DUAL(G18, SYSCK, SPI1DEBUG, SPI1PASSTHRU);
	546	+PIN_DECL_1(G18, GPIOI1, SYSCK);
518	547
519	548	#define D19 66
520		-SIG_EXPR_DECL(SYSDO, SPI1DEBUG, SPI1DEBUG_DESC);
521		-SIG_EXPR_DECL(SYSDO, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
522		-SIG_EXPR_LIST_DECL_DUAL(SYSDO, SPI1DEBUG, SPI1PASSTHRU);
523		-SS_PIN_DECL(D19, GPIOI2, SYSDO);
	549	+SIG_EXPR_DECL_SINGLE(SYSDO, SPI1DEBUG, SPI1DEBUG_DESC);
	550	+SIG_EXPR_DECL_SINGLE(SYSDO, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	551	+SIG_EXPR_LIST_DECL_DUAL(D19, SYSDO, SPI1DEBUG, SPI1PASSTHRU);
	552	+PIN_DECL_1(D19, GPIOI2, SYSDO);
524	553
525	554	#define C20 67
526		-SIG_EXPR_DECL(SYSDI, SPI1DEBUG, SPI1DEBUG_DESC);
527		-SIG_EXPR_DECL(SYSDI, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
528		-SIG_EXPR_LIST_DECL_DUAL(SYSDI, SPI1DEBUG, SPI1PASSTHRU);
529		-SS_PIN_DECL(C20, GPIOI3, SYSDI);
	555	+SIG_EXPR_DECL_SINGLE(SYSDI, SPI1DEBUG, SPI1DEBUG_DESC);
	556	+SIG_EXPR_DECL_SINGLE(SYSDI, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	557	+SIG_EXPR_LIST_DECL_DUAL(C20, SYSDI, SPI1DEBUG, SPI1PASSTHRU);
	558	+PIN_DECL_1(C20, GPIOI3, SYSDI);
530	559
531	560	#define VB_DESC SIG_DESC_SET(HW_STRAP1, 5)
532	561
533	562	#define B22 68
534		-SIG_EXPR_DECL(SPI1CS0, SPI1, SPI1_DESC);
535		-SIG_EXPR_DECL(SPI1CS0, SPI1DEBUG, SPI1DEBUG_DESC);
536		-SIG_EXPR_DECL(SPI1CS0, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
537		-SIG_EXPR_LIST_DECL(SPI1CS0, SIG_EXPR_PTR(SPI1CS0, SPI1),
	563	+SIG_EXPR_DECL_SINGLE(SPI1CS0, SPI1, SPI1_DESC);
	564	+SIG_EXPR_DECL_SINGLE(SPI1CS0, SPI1DEBUG, SPI1DEBUG_DESC);
	565	+SIG_EXPR_DECL_SINGLE(SPI1CS0, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	566	+SIG_EXPR_LIST_DECL(SPI1CS0, SPI1,
	567	+ SIG_EXPR_PTR(SPI1CS0, SPI1),
538	568	SIG_EXPR_PTR(SPI1CS0, SPI1DEBUG),
539	569	SIG_EXPR_PTR(SPI1CS0, SPI1PASSTHRU));
540		-SIG_EXPR_LIST_DECL_SINGLE(VBCS, VGABIOS_ROM, VB_DESC);
541		-MS_PIN_DECL(B22, GPIOI4, SPI1CS0, VBCS);
	570	+SIG_EXPR_LIST_ALIAS(B22, SPI1CS0, SPI1);
	571	+SIG_EXPR_LIST_DECL_SINGLE(B22, VBCS, VGABIOS_ROM, VB_DESC);
	572	+PIN_DECL_2(B22, GPIOI4, SPI1CS0, VBCS);
542	573
543	574	#define G19 69
544		-SIG_EXPR_DECL(SPI1CK, SPI1, SPI1_DESC);
545		-SIG_EXPR_DECL(SPI1CK, SPI1DEBUG, SPI1DEBUG_DESC);
546		-SIG_EXPR_DECL(SPI1CK, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
547		-SIG_EXPR_LIST_DECL(SPI1CK, SIG_EXPR_PTR(SPI1CK, SPI1),
	575	+SIG_EXPR_DECL_SINGLE(SPI1CK, SPI1, SPI1_DESC);
	576	+SIG_EXPR_DECL_SINGLE(SPI1CK, SPI1DEBUG, SPI1DEBUG_DESC);
	577	+SIG_EXPR_DECL_SINGLE(SPI1CK, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	578	+SIG_EXPR_LIST_DECL(SPI1CK, SPI1,
	579	+ SIG_EXPR_PTR(SPI1CK, SPI1),
548	580	SIG_EXPR_PTR(SPI1CK, SPI1DEBUG),
549	581	SIG_EXPR_PTR(SPI1CK, SPI1PASSTHRU));
550		-SIG_EXPR_LIST_DECL_SINGLE(VBCK, VGABIOS_ROM, VB_DESC);
551		-MS_PIN_DECL(G19, GPIOI5, SPI1CK, VBCK);
	582	+SIG_EXPR_LIST_ALIAS(G19, SPI1CK, SPI1);
	583	+SIG_EXPR_LIST_DECL_SINGLE(G19, VBCK, VGABIOS_ROM, VB_DESC);
	584	+PIN_DECL_2(G19, GPIOI5, SPI1CK, VBCK);
552	585
553	586	#define C18 70
554		-SIG_EXPR_DECL(SPI1DO, SPI1, SPI1_DESC);
555		-SIG_EXPR_DECL(SPI1DO, SPI1DEBUG, SPI1DEBUG_DESC);
556		-SIG_EXPR_DECL(SPI1DO, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
557		-SIG_EXPR_LIST_DECL(SPI1DO, SIG_EXPR_PTR(SPI1DO, SPI1),
	587	+SIG_EXPR_DECL_SINGLE(SPI1DO, SPI1, SPI1_DESC);
	588	+SIG_EXPR_DECL_SINGLE(SPI1DO, SPI1DEBUG, SPI1DEBUG_DESC);
	589	+SIG_EXPR_DECL_SINGLE(SPI1DO, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	590	+SIG_EXPR_LIST_DECL(SPI1DO, SPI1,
	591	+ SIG_EXPR_PTR(SPI1DO, SPI1),
558	592	SIG_EXPR_PTR(SPI1DO, SPI1DEBUG),
559	593	SIG_EXPR_PTR(SPI1DO, SPI1PASSTHRU));
560		-SIG_EXPR_LIST_DECL_SINGLE(VBDO, VGABIOS_ROM, VB_DESC);
561		-MS_PIN_DECL(C18, GPIOI6, SPI1DO, VBDO);
	594	+SIG_EXPR_LIST_ALIAS(C18, SPI1DO, SPI1);
	595	+SIG_EXPR_LIST_DECL_SINGLE(C18, VBDO, VGABIOS_ROM, VB_DESC);
	596	+PIN_DECL_2(C18, GPIOI6, SPI1DO, VBDO);
562	597
563	598	#define E20 71
564		-SIG_EXPR_DECL(SPI1DI, SPI1, SPI1_DESC);
565		-SIG_EXPR_DECL(SPI1DI, SPI1DEBUG, SPI1DEBUG_DESC);
566		-SIG_EXPR_DECL(SPI1DI, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
567		-SIG_EXPR_LIST_DECL(SPI1DI, SIG_EXPR_PTR(SPI1DI, SPI1),
	599	+SIG_EXPR_DECL_SINGLE(SPI1DI, SPI1, SPI1_DESC);
	600	+SIG_EXPR_DECL_SINGLE(SPI1DI, SPI1DEBUG, SPI1DEBUG_DESC);
	601	+SIG_EXPR_DECL_SINGLE(SPI1DI, SPI1PASSTHRU, SPI1PASSTHRU_DESC);
	602	+SIG_EXPR_LIST_DECL(SPI1DI, SPI1,
	603	+ SIG_EXPR_PTR(SPI1DI, SPI1),
568	604	SIG_EXPR_PTR(SPI1DI, SPI1DEBUG),
569	605	SIG_EXPR_PTR(SPI1DI, SPI1PASSTHRU));
570		-SIG_EXPR_LIST_DECL_SINGLE(VBDI, VGABIOS_ROM, VB_DESC);
571		-MS_PIN_DECL(E20, GPIOI7, SPI1DI, VBDI);
	606	+SIG_EXPR_LIST_ALIAS(E20, SPI1DI, SPI1);
	607	+SIG_EXPR_LIST_DECL_SINGLE(E20, VBDI, VGABIOS_ROM, VB_DESC);
	608	+PIN_DECL_2(E20, GPIOI7, SPI1DI, VBDI);
572	609
573	610	FUNC_GROUP_DECL(SPI1, B22, G19, C18, E20);
574	611	FUNC_GROUP_DECL(SPI1DEBUG, C22, G18, D19, C20, B22, G19, C18, E20);
..	..	@@ -602,48 +639,48 @@
602	639	#define I2C5_DESC SIG_DESC_SET(SCU90, 18)
603	640
604	641	#define E3 80
605		-SIG_EXPR_LIST_DECL_SINGLE(SCL5, I2C5, I2C5_DESC);
606		-SS_PIN_DECL(E3, GPIOK0, SCL5);
	642	+SIG_EXPR_LIST_DECL_SINGLE(E3, SCL5, I2C5, I2C5_DESC);
	643	+PIN_DECL_1(E3, GPIOK0, SCL5);
607	644
608	645	#define D2 81
609		-SIG_EXPR_LIST_DECL_SINGLE(SDA5, I2C5, I2C5_DESC);
610		-SS_PIN_DECL(D2, GPIOK1, SDA5);
	646	+SIG_EXPR_LIST_DECL_SINGLE(D2, SDA5, I2C5, I2C5_DESC);
	647	+PIN_DECL_1(D2, GPIOK1, SDA5);
611	648
612	649	FUNC_GROUP_DECL(I2C5, E3, D2);
613	650
614	651	#define I2C6_DESC SIG_DESC_SET(SCU90, 19)
615	652
616	653	#define C1 82
617		-SIG_EXPR_LIST_DECL_SINGLE(SCL6, I2C6, I2C6_DESC);
618		-SS_PIN_DECL(C1, GPIOK2, SCL6);
	654	+SIG_EXPR_LIST_DECL_SINGLE(C1, SCL6, I2C6, I2C6_DESC);
	655	+PIN_DECL_1(C1, GPIOK2, SCL6);
619	656
620	657	#define F4 83
621		-SIG_EXPR_LIST_DECL_SINGLE(SDA6, I2C6, I2C6_DESC);
622		-SS_PIN_DECL(F4, GPIOK3, SDA6);
	658	+SIG_EXPR_LIST_DECL_SINGLE(F4, SDA6, I2C6, I2C6_DESC);
	659	+PIN_DECL_1(F4, GPIOK3, SDA6);
623	660
624	661	FUNC_GROUP_DECL(I2C6, C1, F4);
625	662
626	663	#define I2C7_DESC SIG_DESC_SET(SCU90, 20)
627	664
628	665	#define E2 84
629		-SIG_EXPR_LIST_DECL_SINGLE(SCL7, I2C7, I2C7_DESC);
630		-SS_PIN_DECL(E2, GPIOK4, SCL7);
	666	+SIG_EXPR_LIST_DECL_SINGLE(E2, SCL7, I2C7, I2C7_DESC);
	667	+PIN_DECL_1(E2, GPIOK4, SCL7);
631	668
632	669	#define D1 85
633		-SIG_EXPR_LIST_DECL_SINGLE(SDA7, I2C7, I2C7_DESC);
634		-SS_PIN_DECL(D1, GPIOK5, SDA7);
	670	+SIG_EXPR_LIST_DECL_SINGLE(D1, SDA7, I2C7, I2C7_DESC);
	671	+PIN_DECL_1(D1, GPIOK5, SDA7);
635	672
636	673	FUNC_GROUP_DECL(I2C7, E2, D1);
637	674
638	675	#define I2C8_DESC SIG_DESC_SET(SCU90, 21)
639	676
640	677	#define G5 86
641		-SIG_EXPR_LIST_DECL_SINGLE(SCL8, I2C8, I2C8_DESC);
642		-SS_PIN_DECL(G5, GPIOK6, SCL8);
	678	+SIG_EXPR_LIST_DECL_SINGLE(G5, SCL8, I2C8, I2C8_DESC);
	679	+PIN_DECL_1(G5, GPIOK6, SCL8);
643	680
644	681	#define F3 87
645		-SIG_EXPR_LIST_DECL_SINGLE(SDA8, I2C8, I2C8_DESC);
646		-SS_PIN_DECL(F3, GPIOK7, SDA8);
	682	+SIG_EXPR_LIST_DECL_SINGLE(F3, SDA8, I2C8, I2C8_DESC);
	683	+PIN_DECL_1(F3, GPIOK7, SDA8);
647	684
648	685	FUNC_GROUP_DECL(I2C8, G5, F3);
649	686
..	..	@@ -656,297 +693,341 @@
656	693
657	694	#define T5 89
658	695	#define T5_DESC SIG_DESC_SET(SCU84, 17)
659		-SIG_EXPR_DECL(VPIDE, VPI18, VPI18_DESC, T5_DESC);
660		-SIG_EXPR_DECL(VPIDE, VPI24, VPI24_DESC, T5_DESC);
661		-SIG_EXPR_DECL(VPIDE, VPI30, VPI30_DESC, T5_DESC);
662		-SIG_EXPR_LIST_DECL(VPIDE, SIG_EXPR_PTR(VPIDE, VPI18),
663		- SIG_EXPR_PTR(VPIDE, VPI24),
664		- SIG_EXPR_PTR(VPIDE, VPI30));
665		-SIG_EXPR_LIST_DECL_SINGLE(NDCD1, NDCD1, T5_DESC);
666		-MS_PIN_DECL(T5, GPIOL1, VPIDE, NDCD1);
	696	+SIG_EXPR_DECL_SINGLE(VPIDE, VPI18, VPI18_DESC, T5_DESC);
	697	+SIG_EXPR_DECL_SINGLE(VPIDE, VPI24, VPI24_DESC, T5_DESC);
	698	+SIG_EXPR_DECL_SINGLE(VPIDE, VPI30, VPI30_DESC, T5_DESC);
	699	+SIG_EXPR_LIST_DECL(VPIDE, VPI,
	700	+ SIG_EXPR_PTR(VPIDE, VPI18),
	701	+ SIG_EXPR_PTR(VPIDE, VPI24),
	702	+ SIG_EXPR_PTR(VPIDE, VPI30));
	703	+SIG_EXPR_LIST_ALIAS(T5, VPIDE, VPI);
	704	+SIG_EXPR_LIST_DECL_SINGLE(T5, NDCD1, NDCD1, T5_DESC);
	705	+PIN_DECL_2(T5, GPIOL1, VPIDE, NDCD1);
667	706	FUNC_GROUP_DECL(NDCD1, T5);
668	707
669	708	#define U3 90
670	709	#define U3_DESC SIG_DESC_SET(SCU84, 18)
671		-SIG_EXPR_DECL(VPIODD, VPI18, VPI18_DESC, U3_DESC);
672		-SIG_EXPR_DECL(VPIODD, VPI24, VPI24_DESC, U3_DESC);
673		-SIG_EXPR_DECL(VPIODD, VPI30, VPI30_DESC, U3_DESC);
674		-SIG_EXPR_LIST_DECL(VPIODD, SIG_EXPR_PTR(VPIODD, VPI18),
	710	+SIG_EXPR_DECL_SINGLE(VPIODD, VPI18, VPI18_DESC, U3_DESC);
	711	+SIG_EXPR_DECL_SINGLE(VPIODD, VPI24, VPI24_DESC, U3_DESC);
	712	+SIG_EXPR_DECL_SINGLE(VPIODD, VPI30, VPI30_DESC, U3_DESC);
	713	+SIG_EXPR_LIST_DECL(VPIODD, VPI,
	714	+ SIG_EXPR_PTR(VPIODD, VPI18),
675	715	SIG_EXPR_PTR(VPIODD, VPI24),
676	716	SIG_EXPR_PTR(VPIODD, VPI30));
677		-SIG_EXPR_LIST_DECL_SINGLE(NDSR1, NDSR1, U3_DESC);
678		-MS_PIN_DECL(U3, GPIOL2, VPIODD, NDSR1);
	717	+SIG_EXPR_LIST_ALIAS(U3, VPIODD, VPI);
	718	+SIG_EXPR_LIST_DECL_SINGLE(U3, NDSR1, NDSR1, U3_DESC);
	719	+PIN_DECL_2(U3, GPIOL2, VPIODD, NDSR1);
679	720	FUNC_GROUP_DECL(NDSR1, U3);
680	721
681	722	#define V1 91
682	723	#define V1_DESC SIG_DESC_SET(SCU84, 19)
683		-SIG_EXPR_DECL(VPIHS, VPI18, VPI18_DESC, V1_DESC);
684		-SIG_EXPR_DECL(VPIHS, VPI24, VPI24_DESC, V1_DESC);
685		-SIG_EXPR_DECL(VPIHS, VPI30, VPI30_DESC, V1_DESC);
686		-SIG_EXPR_LIST_DECL(VPIHS, SIG_EXPR_PTR(VPIHS, VPI18),
	724	+SIG_EXPR_DECL_SINGLE(VPIHS, VPI18, VPI18_DESC, V1_DESC);
	725	+SIG_EXPR_DECL_SINGLE(VPIHS, VPI24, VPI24_DESC, V1_DESC);
	726	+SIG_EXPR_DECL_SINGLE(VPIHS, VPI30, VPI30_DESC, V1_DESC);
	727	+SIG_EXPR_LIST_DECL(VPIHS, VPI,
	728	+ SIG_EXPR_PTR(VPIHS, VPI18),
687	729	SIG_EXPR_PTR(VPIHS, VPI24),
688	730	SIG_EXPR_PTR(VPIHS, VPI30));
689		-SIG_EXPR_LIST_DECL_SINGLE(NRI1, NRI1, V1_DESC);
690		-MS_PIN_DECL(V1, GPIOL3, VPIHS, NRI1);
	731	+SIG_EXPR_LIST_ALIAS(V1, VPIHS, VPI);
	732	+SIG_EXPR_LIST_DECL_SINGLE(V1, NRI1, NRI1, V1_DESC);
	733	+PIN_DECL_2(V1, GPIOL3, VPIHS, NRI1);
691	734	FUNC_GROUP_DECL(NRI1, V1);
692	735
693	736	#define U4 92
694	737	#define U4_DESC SIG_DESC_SET(SCU84, 20)
695		-SIG_EXPR_DECL(VPIVS, VPI18, VPI18_DESC, U4_DESC);
696		-SIG_EXPR_DECL(VPIVS, VPI24, VPI24_DESC, U4_DESC);
697		-SIG_EXPR_DECL(VPIVS, VPI30, VPI30_DESC, U4_DESC);
698		-SIG_EXPR_LIST_DECL(VPIVS, SIG_EXPR_PTR(VPIVS, VPI18),
	738	+SIG_EXPR_DECL_SINGLE(VPIVS, VPI18, VPI18_DESC, U4_DESC);
	739	+SIG_EXPR_DECL_SINGLE(VPIVS, VPI24, VPI24_DESC, U4_DESC);
	740	+SIG_EXPR_DECL_SINGLE(VPIVS, VPI30, VPI30_DESC, U4_DESC);
	741	+SIG_EXPR_LIST_DECL(VPIVS, VPI,
	742	+ SIG_EXPR_PTR(VPIVS, VPI18),
699	743	SIG_EXPR_PTR(VPIVS, VPI24),
700	744	SIG_EXPR_PTR(VPIVS, VPI30));
701		-SIG_EXPR_LIST_DECL_SINGLE(NDTR1, NDTR1, U4_DESC);
702		-MS_PIN_DECL(U4, GPIOL4, VPIVS, NDTR1);
	745	+SIG_EXPR_LIST_ALIAS(U4, VPIVS, VPI);
	746	+SIG_EXPR_LIST_DECL_SINGLE(U4, NDTR1, NDTR1, U4_DESC);
	747	+PIN_DECL_2(U4, GPIOL4, VPIVS, NDTR1);
703	748	FUNC_GROUP_DECL(NDTR1, U4);
704	749
705	750	#define V2 93
706	751	#define V2_DESC SIG_DESC_SET(SCU84, 21)
707		-SIG_EXPR_DECL(VPICLK, VPI18, VPI18_DESC, V2_DESC);
708		-SIG_EXPR_DECL(VPICLK, VPI24, VPI24_DESC, V2_DESC);
709		-SIG_EXPR_DECL(VPICLK, VPI30, VPI30_DESC, V2_DESC);
710		-SIG_EXPR_LIST_DECL(VPICLK, SIG_EXPR_PTR(VPICLK, VPI18),
	752	+SIG_EXPR_DECL_SINGLE(VPICLK, VPI18, VPI18_DESC, V2_DESC);
	753	+SIG_EXPR_DECL_SINGLE(VPICLK, VPI24, VPI24_DESC, V2_DESC);
	754	+SIG_EXPR_DECL_SINGLE(VPICLK, VPI30, VPI30_DESC, V2_DESC);
	755	+SIG_EXPR_LIST_DECL(VPICLK, VPI,
	756	+ SIG_EXPR_PTR(VPICLK, VPI18),
711	757	SIG_EXPR_PTR(VPICLK, VPI24),
712	758	SIG_EXPR_PTR(VPICLK, VPI30));
713		-SIG_EXPR_LIST_DECL_SINGLE(NRTS1, NRTS1, V2_DESC);
714		-MS_PIN_DECL(V2, GPIOL5, VPICLK, NRTS1);
	759	+SIG_EXPR_LIST_ALIAS(V2, VPICLK, VPI);
	760	+SIG_EXPR_LIST_DECL_SINGLE(V2, NRTS1, NRTS1, V2_DESC);
	761	+PIN_DECL_2(V2, GPIOL5, VPICLK, NRTS1);
715	762	FUNC_GROUP_DECL(NRTS1, V2);
716	763
717	764	#define W1 94
718	765	#define W1_DESC SIG_DESC_SET(SCU84, 22)
719		-SIG_EXPR_LIST_DECL_SINGLE(VPIB0, VPI30, VPI30_DESC, W1_DESC);
720		-SIG_EXPR_LIST_DECL_SINGLE(TXD1, TXD1, W1_DESC);
721		-MS_PIN_DECL(W1, GPIOL6, VPIB0, TXD1);
	766	+SIG_EXPR_LIST_DECL_SINGLE(W1, VPIB0, VPI30, VPI30_DESC, W1_DESC);
	767	+SIG_EXPR_LIST_DECL_SINGLE(W1, TXD1, TXD1, W1_DESC);
	768	+PIN_DECL_2(W1, GPIOL6, VPIB0, TXD1);
722	769	FUNC_GROUP_DECL(TXD1, W1);
723	770
724	771	#define U5 95
725	772	#define U5_DESC SIG_DESC_SET(SCU84, 23)
726		-SIG_EXPR_LIST_DECL_SINGLE(VPIB1, VPI30, VPI30_DESC, U5_DESC);
727		-SIG_EXPR_LIST_DECL_SINGLE(RXD1, RXD1, U5_DESC);
728		-MS_PIN_DECL(U5, GPIOL7, VPIB1, RXD1);
	773	+SIG_EXPR_LIST_DECL_SINGLE(U5, VPIB1, VPI30, VPI30_DESC, U5_DESC);
	774	+SIG_EXPR_LIST_DECL_SINGLE(U5, RXD1, RXD1, U5_DESC);
	775	+PIN_DECL_2(U5, GPIOL7, VPIB1, RXD1);
729	776	FUNC_GROUP_DECL(RXD1, U5);
730	777
731	778	#define V3 96
732	779	#define V3_DESC SIG_DESC_SET(SCU84, 24)
733		-SIG_EXPR_DECL(VPIOB2, VPI18, VPI18_DESC, V3_DESC);
734		-SIG_EXPR_DECL(VPIOB2, VPI24, VPI24_DESC, V3_DESC);
735		-SIG_EXPR_DECL(VPIOB2, VPI30, VPI30_DESC, V3_DESC);
736		-SIG_EXPR_LIST_DECL(VPIOB2, SIG_EXPR_PTR(VPIOB2, VPI18),
	780	+SIG_EXPR_DECL_SINGLE(VPIOB2, VPI18, VPI18_DESC, V3_DESC);
	781	+SIG_EXPR_DECL_SINGLE(VPIOB2, VPI24, VPI24_DESC, V3_DESC);
	782	+SIG_EXPR_DECL_SINGLE(VPIOB2, VPI30, VPI30_DESC, V3_DESC);
	783	+SIG_EXPR_LIST_DECL(VPIOB2, VPI,
	784	+ SIG_EXPR_PTR(VPIOB2, VPI18),
737	785	SIG_EXPR_PTR(VPIOB2, VPI24),
738	786	SIG_EXPR_PTR(VPIOB2, VPI30));
739		-SIG_EXPR_LIST_DECL_SINGLE(NCTS2, NCTS2, V3_DESC);
740		-MS_PIN_DECL(V3, GPIOM0, VPIOB2, NCTS2);
	787	+SIG_EXPR_LIST_ALIAS(V3, VPIOB2, VPI);
	788	+SIG_EXPR_LIST_DECL_SINGLE(V3, NCTS2, NCTS2, V3_DESC);
	789	+PIN_DECL_2(V3, GPIOM0, VPIOB2, NCTS2);
741	790	FUNC_GROUP_DECL(NCTS2, V3);
742	791
743	792	#define W2 97
744	793	#define W2_DESC SIG_DESC_SET(SCU84, 25)
745		-SIG_EXPR_DECL(VPIOB3, VPI18, VPI18_DESC, W2_DESC);
746		-SIG_EXPR_DECL(VPIOB3, VPI24, VPI24_DESC, W2_DESC);
747		-SIG_EXPR_DECL(VPIOB3, VPI30, VPI30_DESC, W2_DESC);
748		-SIG_EXPR_LIST_DECL(VPIOB3, SIG_EXPR_PTR(VPIOB3, VPI18),
	794	+SIG_EXPR_DECL_SINGLE(VPIOB3, VPI18, VPI18_DESC, W2_DESC);
	795	+SIG_EXPR_DECL_SINGLE(VPIOB3, VPI24, VPI24_DESC, W2_DESC);
	796	+SIG_EXPR_DECL_SINGLE(VPIOB3, VPI30, VPI30_DESC, W2_DESC);
	797	+SIG_EXPR_LIST_DECL(VPIOB3, VPI,
	798	+ SIG_EXPR_PTR(VPIOB3, VPI18),
749	799	SIG_EXPR_PTR(VPIOB3, VPI24),
750	800	SIG_EXPR_PTR(VPIOB3, VPI30));
751		-SIG_EXPR_LIST_DECL_SINGLE(NDCD2, NDCD2, W2_DESC);
752		-MS_PIN_DECL(W2, GPIOM1, VPIOB3, NDCD2);
	801	+SIG_EXPR_LIST_ALIAS(W2, VPIOB3, VPI);
	802	+SIG_EXPR_LIST_DECL_SINGLE(W2, NDCD2, NDCD2, W2_DESC);
	803	+PIN_DECL_2(W2, GPIOM1, VPIOB3, NDCD2);
753	804	FUNC_GROUP_DECL(NDCD2, W2);
754	805
755	806	#define Y1 98
756	807	#define Y1_DESC SIG_DESC_SET(SCU84, 26)
757		-SIG_EXPR_DECL(VPIOB4, VPI18, VPI18_DESC, Y1_DESC);
758		-SIG_EXPR_DECL(VPIOB4, VPI24, VPI24_DESC, Y1_DESC);
759		-SIG_EXPR_DECL(VPIOB4, VPI30, VPI30_DESC, Y1_DESC);
760		-SIG_EXPR_LIST_DECL(VPIOB4, SIG_EXPR_PTR(VPIOB4, VPI18),
	808	+SIG_EXPR_DECL_SINGLE(VPIOB4, VPI18, VPI18_DESC, Y1_DESC);
	809	+SIG_EXPR_DECL_SINGLE(VPIOB4, VPI24, VPI24_DESC, Y1_DESC);
	810	+SIG_EXPR_DECL_SINGLE(VPIOB4, VPI30, VPI30_DESC, Y1_DESC);
	811	+SIG_EXPR_LIST_DECL(VPIOB4, VPI,
	812	+ SIG_EXPR_PTR(VPIOB4, VPI18),
761	813	SIG_EXPR_PTR(VPIOB4, VPI24),
762	814	SIG_EXPR_PTR(VPIOB4, VPI30));
763		-SIG_EXPR_LIST_DECL_SINGLE(NDSR2, NDSR2, Y1_DESC);
764		-MS_PIN_DECL(Y1, GPIOM2, VPIOB4, NDSR2);
	815	+SIG_EXPR_LIST_ALIAS(Y1, VPIOB4, VPI);
	816	+SIG_EXPR_LIST_DECL_SINGLE(Y1, NDSR2, NDSR2, Y1_DESC);
	817	+PIN_DECL_2(Y1, GPIOM2, VPIOB4, NDSR2);
765	818	FUNC_GROUP_DECL(NDSR2, Y1);
766	819
767	820	#define V4 99
768	821	#define V4_DESC SIG_DESC_SET(SCU84, 27)
769		-SIG_EXPR_DECL(VPIOB5, VPI18, VPI18_DESC, V4_DESC);
770		-SIG_EXPR_DECL(VPIOB5, VPI24, VPI24_DESC, V4_DESC);
771		-SIG_EXPR_DECL(VPIOB5, VPI30, VPI30_DESC, V4_DESC);
772		-SIG_EXPR_LIST_DECL(VPIOB5, SIG_EXPR_PTR(VPIOB5, VPI18),
	822	+SIG_EXPR_DECL_SINGLE(VPIOB5, VPI18, VPI18_DESC, V4_DESC);
	823	+SIG_EXPR_DECL_SINGLE(VPIOB5, VPI24, VPI24_DESC, V4_DESC);
	824	+SIG_EXPR_DECL_SINGLE(VPIOB5, VPI30, VPI30_DESC, V4_DESC);
	825	+SIG_EXPR_LIST_DECL(VPIOB5, VPI,
	826	+ SIG_EXPR_PTR(VPIOB5, VPI18),
773	827	SIG_EXPR_PTR(VPIOB5, VPI24),
774	828	SIG_EXPR_PTR(VPIOB5, VPI30));
775		-SIG_EXPR_LIST_DECL_SINGLE(NRI2, NRI2, V4_DESC);
776		-MS_PIN_DECL(V4, GPIOM3, VPIOB5, NRI2);
	829	+SIG_EXPR_LIST_ALIAS(V4, VPIOB5, VPI);
	830	+SIG_EXPR_LIST_DECL_SINGLE(V4, NRI2, NRI2, V4_DESC);
	831	+PIN_DECL_2(V4, GPIOM3, VPIOB5, NRI2);
777	832	FUNC_GROUP_DECL(NRI2, V4);
778	833
779	834	#define W3 100
780	835	#define W3_DESC SIG_DESC_SET(SCU84, 28)
781		-SIG_EXPR_DECL(VPIOB6, VPI18, VPI18_DESC, W3_DESC);
782		-SIG_EXPR_DECL(VPIOB6, VPI24, VPI24_DESC, W3_DESC);
783		-SIG_EXPR_DECL(VPIOB6, VPI30, VPI30_DESC, W3_DESC);
784		-SIG_EXPR_LIST_DECL(VPIOB6, SIG_EXPR_PTR(VPIOB6, VPI18),
	836	+SIG_EXPR_DECL_SINGLE(VPIOB6, VPI18, VPI18_DESC, W3_DESC);
	837	+SIG_EXPR_DECL_SINGLE(VPIOB6, VPI24, VPI24_DESC, W3_DESC);
	838	+SIG_EXPR_DECL_SINGLE(VPIOB6, VPI30, VPI30_DESC, W3_DESC);
	839	+SIG_EXPR_LIST_DECL(VPIOB6, VPI,
	840	+ SIG_EXPR_PTR(VPIOB6, VPI18),
785	841	SIG_EXPR_PTR(VPIOB6, VPI24),
786	842	SIG_EXPR_PTR(VPIOB6, VPI30));
787		-SIG_EXPR_LIST_DECL_SINGLE(NDTR2, NDTR2, W3_DESC);
788		-MS_PIN_DECL(W3, GPIOM4, VPIOB6, NDTR2);
	843	+SIG_EXPR_LIST_ALIAS(W3, VPIOB6, VPI);
	844	+SIG_EXPR_LIST_DECL_SINGLE(W3, NDTR2, NDTR2, W3_DESC);
	845	+PIN_DECL_2(W3, GPIOM4, VPIOB6, NDTR2);
789	846	FUNC_GROUP_DECL(NDTR2, W3);
790	847
791	848	#define Y2 101
792	849	#define Y2_DESC SIG_DESC_SET(SCU84, 29)
793		-SIG_EXPR_DECL(VPIOB7, VPI18, VPI18_DESC, Y2_DESC);
794		-SIG_EXPR_DECL(VPIOB7, VPI24, VPI24_DESC, Y2_DESC);
795		-SIG_EXPR_DECL(VPIOB7, VPI30, VPI30_DESC, Y2_DESC);
796		-SIG_EXPR_LIST_DECL(VPIOB7, SIG_EXPR_PTR(VPIOB7, VPI18),
	850	+SIG_EXPR_DECL_SINGLE(VPIOB7, VPI18, VPI18_DESC, Y2_DESC);
	851	+SIG_EXPR_DECL_SINGLE(VPIOB7, VPI24, VPI24_DESC, Y2_DESC);
	852	+SIG_EXPR_DECL_SINGLE(VPIOB7, VPI30, VPI30_DESC, Y2_DESC);
	853	+SIG_EXPR_LIST_DECL(VPIOB7, VPI,
	854	+ SIG_EXPR_PTR(VPIOB7, VPI18),
797	855	SIG_EXPR_PTR(VPIOB7, VPI24),
798	856	SIG_EXPR_PTR(VPIOB7, VPI30));
799		-SIG_EXPR_LIST_DECL_SINGLE(NRTS2, NRTS2, Y2_DESC);
800		-MS_PIN_DECL(Y2, GPIOM5, VPIOB7, NRTS2);
	857	+SIG_EXPR_LIST_ALIAS(Y2, VPIOB7, VPI);
	858	+SIG_EXPR_LIST_DECL_SINGLE(Y2, NRTS2, NRTS2, Y2_DESC);
	859	+PIN_DECL_2(Y2, GPIOM5, VPIOB7, NRTS2);
801	860	FUNC_GROUP_DECL(NRTS2, Y2);
802	861
803	862	#define AA1 102
804	863	#define AA1_DESC SIG_DESC_SET(SCU84, 30)
805		-SIG_EXPR_DECL(VPIOB8, VPI18, VPI18_DESC, AA1_DESC);
806		-SIG_EXPR_DECL(VPIOB8, VPI24, VPI24_DESC, AA1_DESC);
807		-SIG_EXPR_DECL(VPIOB8, VPI30, VPI30_DESC, AA1_DESC);
808		-SIG_EXPR_LIST_DECL(VPIOB8, SIG_EXPR_PTR(VPIOB8, VPI18),
	864	+SIG_EXPR_DECL_SINGLE(VPIOB8, VPI18, VPI18_DESC, AA1_DESC);
	865	+SIG_EXPR_DECL_SINGLE(VPIOB8, VPI24, VPI24_DESC, AA1_DESC);
	866	+SIG_EXPR_DECL_SINGLE(VPIOB8, VPI30, VPI30_DESC, AA1_DESC);
	867	+SIG_EXPR_LIST_DECL(VPIOB8, VPI,
	868	+ SIG_EXPR_PTR(VPIOB8, VPI18),
809	869	SIG_EXPR_PTR(VPIOB8, VPI24),
810	870	SIG_EXPR_PTR(VPIOB8, VPI30));
811		-SIG_EXPR_LIST_DECL_SINGLE(TXD2, TXD2, AA1_DESC);
812		-MS_PIN_DECL(AA1, GPIOM6, VPIOB8, TXD2);
	871	+SIG_EXPR_LIST_ALIAS(AA1, VPIOB8, VPI);
	872	+SIG_EXPR_LIST_DECL_SINGLE(AA1, TXD2, TXD2, AA1_DESC);
	873	+PIN_DECL_2(AA1, GPIOM6, VPIOB8, TXD2);
813	874	FUNC_GROUP_DECL(TXD2, AA1);
814	875
815	876	#define V5 103
816	877	#define V5_DESC SIG_DESC_SET(SCU84, 31)
817		-SIG_EXPR_DECL(VPIOB9, VPI18, VPI18_DESC, V5_DESC);
818		-SIG_EXPR_DECL(VPIOB9, VPI24, VPI24_DESC, V5_DESC);
819		-SIG_EXPR_DECL(VPIOB9, VPI30, VPI30_DESC, V5_DESC);
820		-SIG_EXPR_LIST_DECL(VPIOB9, SIG_EXPR_PTR(VPIOB9, VPI18),
	878	+SIG_EXPR_DECL_SINGLE(VPIOB9, VPI18, VPI18_DESC, V5_DESC);
	879	+SIG_EXPR_DECL_SINGLE(VPIOB9, VPI24, VPI24_DESC, V5_DESC);
	880	+SIG_EXPR_DECL_SINGLE(VPIOB9, VPI30, VPI30_DESC, V5_DESC);
	881	+SIG_EXPR_LIST_DECL(VPIOB9, VPI,
	882	+ SIG_EXPR_PTR(VPIOB9, VPI18),
821	883	SIG_EXPR_PTR(VPIOB9, VPI24),
822	884	SIG_EXPR_PTR(VPIOB9, VPI30));
823		-SIG_EXPR_LIST_DECL_SINGLE(RXD2, RXD2, V5_DESC);
824		-MS_PIN_DECL(V5, GPIOM7, VPIOB9, RXD2);
	885	+SIG_EXPR_LIST_ALIAS(V5, VPIOB9, VPI);
	886	+SIG_EXPR_LIST_DECL_SINGLE(V5, RXD2, RXD2, V5_DESC);
	887	+PIN_DECL_2(V5, GPIOM7, VPIOB9, RXD2);
825	888	FUNC_GROUP_DECL(RXD2, V5);
826	889
827	890	#define W4 104
828	891	#define W4_DESC SIG_DESC_SET(SCU88, 0)
829		-SIG_EXPR_LIST_DECL_SINGLE(VPIG0, VPI30, VPI30_DESC, W4_DESC);
830		-SIG_EXPR_LIST_DECL_SINGLE(PWM0, PWM0, W4_DESC);
831		-MS_PIN_DECL(W4, GPION0, VPIG0, PWM0);
	892	+SIG_EXPR_LIST_DECL_SINGLE(W4, VPIG0, VPI30, VPI30_DESC, W4_DESC);
	893	+SIG_EXPR_LIST_DECL_SINGLE(W4, PWM0, PWM0, W4_DESC);
	894	+PIN_DECL_2(W4, GPION0, VPIG0, PWM0);
832	895	FUNC_GROUP_DECL(PWM0, W4);
833	896
834	897	#define Y3 105
835	898	#define Y3_DESC SIG_DESC_SET(SCU88, 1)
836		-SIG_EXPR_LIST_DECL_SINGLE(VPIG1, VPI30, VPI30_DESC, Y3_DESC);
837		-SIG_EXPR_LIST_DECL_SINGLE(PWM1, PWM1, Y3_DESC);
838		-MS_PIN_DECL(Y3, GPION1, VPIG1, PWM1);
	899	+SIG_EXPR_LIST_DECL_SINGLE(Y3, VPIG1, VPI30, VPI30_DESC, Y3_DESC);
	900	+SIG_EXPR_LIST_DECL_SINGLE(Y3, PWM1, PWM1, Y3_DESC);
	901	+PIN_DECL_2(Y3, GPION1, VPIG1, PWM1);
839	902	FUNC_GROUP_DECL(PWM1, Y3);
840	903
841	904	#define AA2 106
842	905	#define AA2_DESC SIG_DESC_SET(SCU88, 2)
843		-SIG_EXPR_DECL(VPIG2, VPI18, VPI18_DESC, AA2_DESC);
844		-SIG_EXPR_DECL(VPIG2, VPI24, VPI24_DESC, AA2_DESC);
845		-SIG_EXPR_DECL(VPIG2, VPI30, VPI30_DESC, AA2_DESC);
846		-SIG_EXPR_LIST_DECL(VPIG2, SIG_EXPR_PTR(VPIG2, VPI18),
	906	+SIG_EXPR_DECL_SINGLE(VPIG2, VPI18, VPI18_DESC, AA2_DESC);
	907	+SIG_EXPR_DECL_SINGLE(VPIG2, VPI24, VPI24_DESC, AA2_DESC);
	908	+SIG_EXPR_DECL_SINGLE(VPIG2, VPI30, VPI30_DESC, AA2_DESC);
	909	+SIG_EXPR_LIST_DECL(VPIG2, VPI,
	910	+ SIG_EXPR_PTR(VPIG2, VPI18),
847	911	SIG_EXPR_PTR(VPIG2, VPI24),
848	912	SIG_EXPR_PTR(VPIG2, VPI30));
849		-SIG_EXPR_LIST_DECL_SINGLE(PWM2, PWM2, AA2_DESC);
850		-MS_PIN_DECL(AA2, GPION2, VPIG2, PWM2);
	913	+SIG_EXPR_LIST_ALIAS(AA2, VPIG2, VPI);
	914	+SIG_EXPR_LIST_DECL_SINGLE(AA2, PWM2, PWM2, AA2_DESC);
	915	+PIN_DECL_2(AA2, GPION2, VPIG2, PWM2);
851	916	FUNC_GROUP_DECL(PWM2, AA2);
852	917
853	918	#define AB1 107
854	919	#define AB1_DESC SIG_DESC_SET(SCU88, 3)
855		-SIG_EXPR_DECL(VPIG3, VPI18, VPI18_DESC, AB1_DESC);
856		-SIG_EXPR_DECL(VPIG3, VPI24, VPI24_DESC, AB1_DESC);
857		-SIG_EXPR_DECL(VPIG3, VPI30, VPI30_DESC, AB1_DESC);
858		-SIG_EXPR_LIST_DECL(VPIG3, SIG_EXPR_PTR(VPIG3, VPI18),
	920	+SIG_EXPR_DECL_SINGLE(VPIG3, VPI18, VPI18_DESC, AB1_DESC);
	921	+SIG_EXPR_DECL_SINGLE(VPIG3, VPI24, VPI24_DESC, AB1_DESC);
	922	+SIG_EXPR_DECL_SINGLE(VPIG3, VPI30, VPI30_DESC, AB1_DESC);
	923	+SIG_EXPR_LIST_DECL(VPIG3, VPI,
	924	+ SIG_EXPR_PTR(VPIG3, VPI18),
859	925	SIG_EXPR_PTR(VPIG3, VPI24),
860	926	SIG_EXPR_PTR(VPIG3, VPI30));
861		-SIG_EXPR_LIST_DECL_SINGLE(PWM3, PWM3, AB1_DESC);
862		-MS_PIN_DECL(AB1, GPION3, VPIG3, PWM3);
	927	+SIG_EXPR_LIST_ALIAS(AB1, VPIG3, VPI);
	928	+SIG_EXPR_LIST_DECL_SINGLE(AB1, PWM3, PWM3, AB1_DESC);
	929	+PIN_DECL_2(AB1, GPION3, VPIG3, PWM3);
863	930	FUNC_GROUP_DECL(PWM3, AB1);
864	931
865	932	#define W5 108
866	933	#define W5_DESC SIG_DESC_SET(SCU88, 4)
867		-SIG_EXPR_DECL(VPIG4, VPI18, VPI18_DESC, W5_DESC);
868		-SIG_EXPR_DECL(VPIG4, VPI24, VPI24_DESC, W5_DESC);
869		-SIG_EXPR_DECL(VPIG4, VPI30, VPI30_DESC, W5_DESC);
870		-SIG_EXPR_LIST_DECL(VPIG4, SIG_EXPR_PTR(VPIG4, VPI18),
	934	+SIG_EXPR_DECL_SINGLE(VPIG4, VPI18, VPI18_DESC, W5_DESC);
	935	+SIG_EXPR_DECL_SINGLE(VPIG4, VPI24, VPI24_DESC, W5_DESC);
	936	+SIG_EXPR_DECL_SINGLE(VPIG4, VPI30, VPI30_DESC, W5_DESC);
	937	+SIG_EXPR_LIST_DECL(VPIG4, VPI,
	938	+ SIG_EXPR_PTR(VPIG4, VPI18),
871	939	SIG_EXPR_PTR(VPIG4, VPI24),
872	940	SIG_EXPR_PTR(VPIG4, VPI30));
873		-SIG_EXPR_LIST_DECL_SINGLE(PWM4, PWM4, W5_DESC);
874		-MS_PIN_DECL(W5, GPION4, VPIG4, PWM4);
	941	+SIG_EXPR_LIST_ALIAS(W5, VPIG4, VPI);
	942	+SIG_EXPR_LIST_DECL_SINGLE(W5, PWM4, PWM4, W5_DESC);
	943	+PIN_DECL_2(W5, GPION4, VPIG4, PWM4);
875	944	FUNC_GROUP_DECL(PWM4, W5);
876	945
877	946	#define Y4 109
878	947	#define Y4_DESC SIG_DESC_SET(SCU88, 5)
879		-SIG_EXPR_DECL(VPIG5, VPI18, VPI18_DESC, Y4_DESC);
880		-SIG_EXPR_DECL(VPIG5, VPI24, VPI24_DESC, Y4_DESC);
881		-SIG_EXPR_DECL(VPIG5, VPI30, VPI30_DESC, Y4_DESC);
882		-SIG_EXPR_LIST_DECL(VPIG5, SIG_EXPR_PTR(VPIG5, VPI18),
	948	+SIG_EXPR_DECL_SINGLE(VPIG5, VPI18, VPI18_DESC, Y4_DESC);
	949	+SIG_EXPR_DECL_SINGLE(VPIG5, VPI24, VPI24_DESC, Y4_DESC);
	950	+SIG_EXPR_DECL_SINGLE(VPIG5, VPI30, VPI30_DESC, Y4_DESC);
	951	+SIG_EXPR_LIST_DECL(VPIG5, VPI,
	952	+ SIG_EXPR_PTR(VPIG5, VPI18),
883	953	SIG_EXPR_PTR(VPIG5, VPI24),
884	954	SIG_EXPR_PTR(VPIG5, VPI30));
885		-SIG_EXPR_LIST_DECL_SINGLE(PWM5, PWM5, Y4_DESC);
886		-MS_PIN_DECL(Y4, GPION5, VPIG5, PWM5);
	955	+SIG_EXPR_LIST_ALIAS(Y4, VPIG5, VPI);
	956	+SIG_EXPR_LIST_DECL_SINGLE(Y4, PWM5, PWM5, Y4_DESC);
	957	+PIN_DECL_2(Y4, GPION5, VPIG5, PWM5);
887	958	FUNC_GROUP_DECL(PWM5, Y4);
888	959
889	960	#define AA3 110
890	961	#define AA3_DESC SIG_DESC_SET(SCU88, 6)
891		-SIG_EXPR_LIST_DECL_SINGLE(VPIG6, VPI30, VPI30_DESC, AA3_DESC);
892		-SIG_EXPR_LIST_DECL_SINGLE(PWM6, PWM6, AA3_DESC);
893		-MS_PIN_DECL(AA3, GPION6, VPIG6, PWM6);
	962	+SIG_EXPR_LIST_DECL_SINGLE(AA3, VPIG6, VPI30, VPI30_DESC, AA3_DESC);
	963	+SIG_EXPR_LIST_DECL_SINGLE(AA3, PWM6, PWM6, AA3_DESC);
	964	+PIN_DECL_2(AA3, GPION6, VPIG6, PWM6);
894	965	FUNC_GROUP_DECL(PWM6, AA3);
895	966
896	967	#define AB2 111
897	968	#define AB2_DESC SIG_DESC_SET(SCU88, 7)
898		-SIG_EXPR_LIST_DECL_SINGLE(VPIG7, VPI30, VPI30_DESC, AB2_DESC);
899		-SIG_EXPR_LIST_DECL_SINGLE(PWM7, PWM7, AB2_DESC);
900		-MS_PIN_DECL(AB2, GPION7, VPIG7, PWM7);
	969	+SIG_EXPR_LIST_DECL_SINGLE(AB2, VPIG7, VPI30, VPI30_DESC, AB2_DESC);
	970	+SIG_EXPR_LIST_DECL_SINGLE(AB2, PWM7, PWM7, AB2_DESC);
	971	+PIN_DECL_2(AB2, GPION7, VPIG7, PWM7);
901	972	FUNC_GROUP_DECL(PWM7, AB2);
902	973
903	974	#define V6 112
904		-SIG_EXPR_LIST_DECL_SINGLE(VPIG8, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 8));
905		-SS_PIN_DECL(V6, GPIOO0, VPIG8);
	975	+SIG_EXPR_LIST_DECL_SINGLE(V6, VPIG8, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 8));
	976	+PIN_DECL_1(V6, GPIOO0, VPIG8);
906	977
907	978	#define Y5 113
908		-SIG_EXPR_LIST_DECL_SINGLE(VPIG9, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 9));
909		-SS_PIN_DECL(Y5, GPIOO1, VPIG9);
	979	+SIG_EXPR_LIST_DECL_SINGLE(Y5, VPIG9, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 9));
	980	+PIN_DECL_1(Y5, GPIOO1, VPIG9);
910	981
911	982	#define AA4 114
912		-SIG_EXPR_LIST_DECL_SINGLE(VPIR0, VPI30, VPI30_DESC, SIG_DESC_SET(SCU88, 10));
913		-SS_PIN_DECL(AA4, GPIOO2, VPIR0);
	983	+SIG_EXPR_LIST_DECL_SINGLE(AA4, VPIR0, VPI30, VPI30_DESC,
	984	+ SIG_DESC_SET(SCU88, 10));
	985	+PIN_DECL_1(AA4, GPIOO2, VPIR0);
914	986
915	987	#define AB3 115
916		-SIG_EXPR_LIST_DECL_SINGLE(VPIR1, VPI30, VPI30_DESC, SIG_DESC_SET(SCU88, 11));
917		-SS_PIN_DECL(AB3, GPIOO3, VPIR1);
	988	+SIG_EXPR_LIST_DECL_SINGLE(AB3, VPIR1, VPI30, VPI30_DESC,
	989	+ SIG_DESC_SET(SCU88, 11));
	990	+PIN_DECL_1(AB3, GPIOO3, VPIR1);
918	991
919	992	#define W6 116
920		-SIG_EXPR_LIST_DECL_SINGLE(VPIR2, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 12));
921		-SS_PIN_DECL(W6, GPIOO4, VPIR2);
	993	+SIG_EXPR_LIST_DECL_SINGLE(W6, VPIR2, VPI24, VPI24_DESC,
	994	+ SIG_DESC_SET(SCU88, 12));
	995	+PIN_DECL_1(W6, GPIOO4, VPIR2);
922	996
923	997	#define AA5 117
924		-SIG_EXPR_LIST_DECL_SINGLE(VPIR3, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 13));
925		-SS_PIN_DECL(AA5, GPIOO5, VPIR3);
	998	+SIG_EXPR_LIST_DECL_SINGLE(AA5, VPIR3, VPI24, VPI24_DESC,
	999	+ SIG_DESC_SET(SCU88, 13));
	1000	+PIN_DECL_1(AA5, GPIOO5, VPIR3);
926	1001
927	1002	#define AB4 118
928		-SIG_EXPR_LIST_DECL_SINGLE(VPIR4, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 14));
929		-SS_PIN_DECL(AB4, GPIOO6, VPIR4);
	1003	+SIG_EXPR_LIST_DECL_SINGLE(AB4, VPIR4, VPI24, VPI24_DESC,
	1004	+ SIG_DESC_SET(SCU88, 14));
	1005	+PIN_DECL_1(AB4, GPIOO6, VPIR4);
930	1006
931	1007	#define V7 119
932		-SIG_EXPR_LIST_DECL_SINGLE(VPIR5, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 15));
933		-SS_PIN_DECL(V7, GPIOO7, VPIR5);
	1008	+SIG_EXPR_LIST_DECL_SINGLE(V7, VPIR5, VPI24, VPI24_DESC,
	1009	+ SIG_DESC_SET(SCU88, 15));
	1010	+PIN_DECL_1(V7, GPIOO7, VPIR5);
934	1011
935	1012	#define Y6 120
936		-SIG_EXPR_LIST_DECL_SINGLE(VPIR6, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 16));
937		-SS_PIN_DECL(Y6, GPIOP0, VPIR6);
	1013	+SIG_EXPR_LIST_DECL_SINGLE(Y6, VPIR6, VPI24, VPI24_DESC,
	1014	+ SIG_DESC_SET(SCU88, 16));
	1015	+PIN_DECL_1(Y6, GPIOP0, VPIR6);
938	1016
939	1017	#define AB5 121
940		-SIG_EXPR_LIST_DECL_SINGLE(VPIR7, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 17));
941		-SS_PIN_DECL(AB5, GPIOP1, VPIR7);
	1018	+SIG_EXPR_LIST_DECL_SINGLE(AB5, VPIR7, VPI24, VPI24_DESC,
	1019	+ SIG_DESC_SET(SCU88, 17));
	1020	+PIN_DECL_1(AB5, GPIOP1, VPIR7);
942	1021
943	1022	#define W7 122
944		-SIG_EXPR_LIST_DECL_SINGLE(VPIR8, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 18));
945		-SS_PIN_DECL(W7, GPIOP2, VPIR8);
	1023	+SIG_EXPR_LIST_DECL_SINGLE(W7, VPIR8, VPI24, VPI24_DESC,
	1024	+ SIG_DESC_SET(SCU88, 18));
	1025	+PIN_DECL_1(W7, GPIOP2, VPIR8);
946	1026
947	1027	#define AA6 123
948		-SIG_EXPR_LIST_DECL_SINGLE(VPIR9, VPI24, VPI24_DESC, SIG_DESC_SET(SCU88, 19));
949		-SS_PIN_DECL(AA6, GPIOP3, VPIR9);
	1028	+SIG_EXPR_LIST_DECL_SINGLE(AA6, VPIR9, VPI24, VPI24_DESC,
	1029	+ SIG_DESC_SET(SCU88, 19));
	1030	+PIN_DECL_1(AA6, GPIOP3, VPIR9);
950	1031
951	1032	FUNC_GROUP_DECL(VPI18, T5, U3, V1, U4, V2, V3, W2, Y1, V4, W3, Y2, AA1, V5,
952	1033	AA22, W5, Y4, AA3, AB2);
..	..	@@ -957,12 +1038,12 @@
957	1038	V5, W4, Y3, AA22, W5, Y4, AA3, AB2, AA4, AB3);
958	1039
959	1040	#define AB6 124
960		-SIG_EXPR_LIST_DECL_SINGLE(GPIOP4, GPIOP4);
961		-MS_PIN_DECL_(AB6, SIG_EXPR_LIST_PTR(GPIOP4));
	1041	+SIG_EXPR_LIST_DECL_SINGLE(AB6, GPIOP4, GPIOP4);
	1042	+PIN_DECL_(AB6, SIG_EXPR_LIST_PTR(AB6, GPIOP4));
962	1043
963	1044	#define Y7 125
964		-SIG_EXPR_LIST_DECL_SINGLE(GPIOP5, GPIOP5);
965		-MS_PIN_DECL_(Y7, SIG_EXPR_LIST_PTR(GPIOP5));
	1045	+SIG_EXPR_LIST_DECL_SINGLE(Y7, GPIOP5, GPIOP5);
	1046	+PIN_DECL_(Y7, SIG_EXPR_LIST_PTR(Y7, GPIOP5));
966	1047
967	1048	#define AA7 126
968	1049	SSSF_PIN_DECL(AA7, GPIOP6, BMCINT, SIG_DESC_SET(SCU88, 22));
..	..	@@ -973,36 +1054,36 @@
973	1054	#define I2C3_DESC SIG_DESC_SET(SCU90, 16)
974	1055
975	1056	#define D3 128
976		-SIG_EXPR_LIST_DECL_SINGLE(SCL3, I2C3, I2C3_DESC);
977		-SS_PIN_DECL(D3, GPIOQ0, SCL3);
	1057	+SIG_EXPR_LIST_DECL_SINGLE(D3, SCL3, I2C3, I2C3_DESC);
	1058	+PIN_DECL_1(D3, GPIOQ0, SCL3);
978	1059
979	1060	#define C2 129
980		-SIG_EXPR_LIST_DECL_SINGLE(SDA3, I2C3, I2C3_DESC);
981		-SS_PIN_DECL(C2, GPIOQ1, SDA3);
	1061	+SIG_EXPR_LIST_DECL_SINGLE(C2, SDA3, I2C3, I2C3_DESC);
	1062	+PIN_DECL_1(C2, GPIOQ1, SDA3);
982	1063
983	1064	FUNC_GROUP_DECL(I2C3, D3, C2);
984	1065
985	1066	#define I2C4_DESC SIG_DESC_SET(SCU90, 17)
986	1067
987	1068	#define B1 130
988		-SIG_EXPR_LIST_DECL_SINGLE(SCL4, I2C4, I2C4_DESC);
989		-SS_PIN_DECL(B1, GPIOQ2, SCL4);
	1069	+SIG_EXPR_LIST_DECL_SINGLE(B1, SCL4, I2C4, I2C4_DESC);
	1070	+PIN_DECL_1(B1, GPIOQ2, SCL4);
990	1071
991	1072	#define F5 131
992		-SIG_EXPR_LIST_DECL_SINGLE(SDA4, I2C4, I2C4_DESC);
993		-SS_PIN_DECL(F5, GPIOQ3, SDA4);
	1073	+SIG_EXPR_LIST_DECL_SINGLE(F5, SDA4, I2C4, I2C4_DESC);
	1074	+PIN_DECL_1(F5, GPIOQ3, SDA4);
994	1075
995	1076	FUNC_GROUP_DECL(I2C4, B1, F5);
996	1077
997	1078	#define I2C14_DESC SIG_DESC_SET(SCU90, 27)
998	1079
999	1080	#define H4 132
1000		-SIG_EXPR_LIST_DECL_SINGLE(SCL14, I2C14, I2C14_DESC);
1001		-SS_PIN_DECL(H4, GPIOQ4, SCL14);
	1081	+SIG_EXPR_LIST_DECL_SINGLE(H4, SCL14, I2C14, I2C14_DESC);
	1082	+PIN_DECL_1(H4, GPIOQ4, SCL14);
1002	1083
1003	1084	#define H3 133
1004		-SIG_EXPR_LIST_DECL_SINGLE(SDA14, I2C14, I2C14_DESC);
1005		-SS_PIN_DECL(H3, GPIOQ5, SDA14);
	1085	+SIG_EXPR_LIST_DECL_SINGLE(H3, SDA14, I2C14, I2C14_DESC);
	1086	+PIN_DECL_1(H3, GPIOQ5, SDA14);
1006	1087
1007	1088	FUNC_GROUP_DECL(I2C14, H4, H3);
1008	1089
..	..	@@ -1017,12 +1098,12 @@
1017	1098	#define USB11H3_DESC SIG_DESC_SET(SCU90, 28)
1018	1099
1019	1100	#define H2 134
1020		-SIG_EXPR_LIST_DECL_SINGLE(USB11HDP3, USB11H3, USB11H3_DESC);
1021		-SS_PIN_DECL(H2, GPIOQ6, USB11HDP3);
	1101	+SIG_EXPR_LIST_DECL_SINGLE(H2, USB11HDP3, USB11H3, USB11H3_DESC);
	1102	+PIN_DECL_1(H2, GPIOQ6, USB11HDP3);
1022	1103
1023	1104	#define H1 135
1024		-SIG_EXPR_LIST_DECL_SINGLE(USB11HDN3, USB11H3, USB11H3_DESC);
1025		-SS_PIN_DECL(H1, GPIOQ7, USB11HDN3);
	1105	+SIG_EXPR_LIST_DECL_SINGLE(H1, USB11HDN3, USB11H3, USB11H3_DESC);
	1106	+PIN_DECL_1(H1, GPIOQ7, USB11HDN3);
1026	1107
1027	1108	#define V20 136
1028	1109	SSSF_PIN_DECL(V20, GPIOR0, ROMCS1, SIG_DESC_SET(SCU88, 24));
..	..	@@ -1045,303 +1126,333 @@
1045	1126
1046	1127	#define V21 140
1047	1128	#define V21_DESC SIG_DESC_SET(SCU88, 28)
1048		-SIG_EXPR_DECL(ROMA24, ROM8, V21_DESC, VPO_OFF_12);
1049		-SIG_EXPR_DECL(ROMA24, ROM16, V21_DESC, VPO_OFF_12);
1050		-SIG_EXPR_DECL(ROMA24, ROM16S, V21_DESC, VPO_OFF_12);
1051		-SIG_EXPR_LIST_DECL(ROMA24, SIG_EXPR_PTR(ROMA24, ROM8),
	1129	+SIG_EXPR_DECL_SINGLE(ROMA24, ROM8, V21_DESC, VPO_OFF_12);
	1130	+SIG_EXPR_DECL_SINGLE(ROMA24, ROM16, V21_DESC, VPO_OFF_12);
	1131	+SIG_EXPR_DECL_SINGLE(ROMA24, ROM16S, V21_DESC, VPO_OFF_12);
	1132	+SIG_EXPR_LIST_DECL(ROMA24, ROM,
	1133	+ SIG_EXPR_PTR(ROMA24, ROM8),
1052	1134	SIG_EXPR_PTR(ROMA24, ROM16),
1053	1135	SIG_EXPR_PTR(ROMA24, ROM16S));
1054		-SIG_EXPR_LIST_DECL_SINGLE(VPOR6, VPO24, V21_DESC, VPO_24_OFF);
1055		-MS_PIN_DECL(V21, GPIOR4, ROMA24, VPOR6);
	1136	+SIG_EXPR_LIST_ALIAS(V21, ROMA24, ROM);
	1137	+SIG_EXPR_LIST_DECL_SINGLE(V21, VPOR6, VPO24, V21_DESC, VPO_24_OFF);
	1138	+PIN_DECL_2(V21, GPIOR4, ROMA24, VPOR6);
1056	1139
1057	1140	#define W22 141
1058	1141	#define W22_DESC SIG_DESC_SET(SCU88, 29)
1059		-SIG_EXPR_DECL(ROMA25, ROM8, W22_DESC, VPO_OFF_12);
1060		-SIG_EXPR_DECL(ROMA25, ROM16, W22_DESC, VPO_OFF_12);
1061		-SIG_EXPR_DECL(ROMA25, ROM16S, W22_DESC, VPO_OFF_12);
1062		-SIG_EXPR_LIST_DECL(ROMA25, SIG_EXPR_PTR(ROMA25, ROM8),
	1142	+SIG_EXPR_DECL_SINGLE(ROMA25, ROM8, W22_DESC, VPO_OFF_12);
	1143	+SIG_EXPR_DECL_SINGLE(ROMA25, ROM16, W22_DESC, VPO_OFF_12);
	1144	+SIG_EXPR_DECL_SINGLE(ROMA25, ROM16S, W22_DESC, VPO_OFF_12);
	1145	+SIG_EXPR_LIST_DECL(ROMA25, ROM,
	1146	+ SIG_EXPR_PTR(ROMA25, ROM8),
1063	1147	SIG_EXPR_PTR(ROMA25, ROM16),
1064	1148	SIG_EXPR_PTR(ROMA25, ROM16S));
1065		-SIG_EXPR_LIST_DECL_SINGLE(VPOR7, VPO24, W22_DESC, VPO_24_OFF);
1066		-MS_PIN_DECL(W22, GPIOR5, ROMA25, VPOR7);
	1149	+SIG_EXPR_LIST_ALIAS(W22, ROMA25, ROM);
	1150	+SIG_EXPR_LIST_DECL_SINGLE(W22, VPOR7, VPO24, W22_DESC, VPO_24_OFF);
	1151	+PIN_DECL_2(W22, GPIOR5, ROMA25, VPOR7);
1067	1152
1068	1153	#define C6 142
1069		-SIG_EXPR_LIST_DECL_SINGLE(MDC1, MDIO1, SIG_DESC_SET(SCU88, 30));
1070		-SS_PIN_DECL(C6, GPIOR6, MDC1);
	1154	+SIG_EXPR_LIST_DECL_SINGLE(C6, MDC1, MDIO1, SIG_DESC_SET(SCU88, 30));
	1155	+PIN_DECL_1(C6, GPIOR6, MDC1);
1071	1156
1072	1157	#define A5 143
1073		-SIG_EXPR_LIST_DECL_SINGLE(MDIO1, MDIO1, SIG_DESC_SET(SCU88, 31));
1074		-SS_PIN_DECL(A5, GPIOR7, MDIO1);
	1158	+SIG_EXPR_LIST_DECL_SINGLE(A5, MDIO1, MDIO1, SIG_DESC_SET(SCU88, 31));
	1159	+PIN_DECL_1(A5, GPIOR7, MDIO1);
1075	1160
1076	1161	FUNC_GROUP_DECL(MDIO1, C6, A5);
1077	1162
1078	1163	#define U21 144
1079	1164	#define U21_DESC SIG_DESC_SET(SCU8C, 0)
1080		-SIG_EXPR_DECL(ROMD4, ROM8, U21_DESC, VPOOFF0_DESC);
1081		-SIG_EXPR_DECL(ROMD4, ROM16, U21_DESC, VPOOFF0_DESC);
1082		-SIG_EXPR_DECL(ROMD4, ROM16S, U21_DESC, VPOOFF0_DESC);
1083		-SIG_EXPR_LIST_DECL(ROMD4, SIG_EXPR_PTR(ROMD4, ROM8),
	1165	+SIG_EXPR_DECL_SINGLE(ROMD4, ROM8, U21_DESC, VPOOFF0_DESC);
	1166	+SIG_EXPR_DECL_SINGLE(ROMD4, ROM16, U21_DESC, VPOOFF0_DESC);
	1167	+SIG_EXPR_DECL_SINGLE(ROMD4, ROM16S, U21_DESC, VPOOFF0_DESC);
	1168	+SIG_EXPR_LIST_DECL(ROMD4, ROM,
	1169	+ SIG_EXPR_PTR(ROMD4, ROM8),
1084	1170	SIG_EXPR_PTR(ROMD4, ROM16),
1085	1171	SIG_EXPR_PTR(ROMD4, ROM16S));
1086		-SIG_EXPR_DECL(VPODE, VPO12, U21_DESC, VPO12_DESC);
1087		-SIG_EXPR_DECL(VPODE, VPO24, U21_DESC, VPO12_DESC);
1088		-SIG_EXPR_LIST_DECL_DUAL(VPODE, VPO12, VPO24);
1089		-MS_PIN_DECL(U21, GPIOS0, ROMD4, VPODE);
	1172	+SIG_EXPR_LIST_ALIAS(U21, ROMD4, ROM);
	1173	+SIG_EXPR_DECL_SINGLE(VPODE, VPO12, U21_DESC, VPO12_DESC);
	1174	+SIG_EXPR_DECL_SINGLE(VPODE, VPO24, U21_DESC, VPO12_DESC);
	1175	+SIG_EXPR_LIST_DECL_DUAL(U21, VPODE, VPO12, VPO24);
	1176	+PIN_DECL_2(U21, GPIOS0, ROMD4, VPODE);
1090	1177
1091	1178	#define T19 145
1092	1179	#define T19_DESC SIG_DESC_SET(SCU8C, 1)
1093		-SIG_EXPR_DECL(ROMD5, ROM8, T19_DESC, VPOOFF0_DESC);
1094		-SIG_EXPR_DECL(ROMD5, ROM16, T19_DESC, VPOOFF0_DESC);
1095		-SIG_EXPR_DECL(ROMD5, ROM16S, T19_DESC, VPOOFF0_DESC);
1096		-SIG_EXPR_LIST_DECL(ROMD5, SIG_EXPR_PTR(ROMD5, ROM8),
	1180	+SIG_EXPR_DECL_SINGLE(ROMD5, ROM8, T19_DESC, VPOOFF0_DESC);
	1181	+SIG_EXPR_DECL_SINGLE(ROMD5, ROM16, T19_DESC, VPOOFF0_DESC);
	1182	+SIG_EXPR_DECL_SINGLE(ROMD5, ROM16S, T19_DESC, VPOOFF0_DESC);
	1183	+SIG_EXPR_LIST_DECL(ROMD5, ROM,
	1184	+ SIG_EXPR_PTR(ROMD5, ROM8),
1097	1185	SIG_EXPR_PTR(ROMD5, ROM16),
1098	1186	SIG_EXPR_PTR(ROMD5, ROM16S));
1099		-SIG_EXPR_DECL(VPOHS, VPO12, T19_DESC, VPO12_DESC);
1100		-SIG_EXPR_DECL(VPOHS, VPO24, T19_DESC, VPO24_DESC);
1101		-SIG_EXPR_LIST_DECL_DUAL(VPOHS, VPO12, VPO24);
1102		-MS_PIN_DECL(T19, GPIOS1, ROMD5, VPOHS);
	1187	+SIG_EXPR_LIST_ALIAS(T19, ROMD5, ROM);
	1188	+SIG_EXPR_DECL_SINGLE(VPOHS, VPO12, T19_DESC, VPO12_DESC);
	1189	+SIG_EXPR_DECL_SINGLE(VPOHS, VPO24, T19_DESC, VPO24_DESC);
	1190	+SIG_EXPR_LIST_DECL_DUAL(T19, VPOHS, VPO12, VPO24);
	1191	+PIN_DECL_2(T19, GPIOS1, ROMD5, VPOHS);
1103	1192
1104	1193	#define V22 146
1105	1194	#define V22_DESC SIG_DESC_SET(SCU8C, 2)
1106		-SIG_EXPR_DECL(ROMD6, ROM8, V22_DESC, VPOOFF0_DESC);
1107		-SIG_EXPR_DECL(ROMD6, ROM16, V22_DESC, VPOOFF0_DESC);
1108		-SIG_EXPR_DECL(ROMD6, ROM16S, V22_DESC, VPOOFF0_DESC);
1109		-SIG_EXPR_LIST_DECL(ROMD6, SIG_EXPR_PTR(ROMD6, ROM8),
	1195	+SIG_EXPR_DECL_SINGLE(ROMD6, ROM8, V22_DESC, VPOOFF0_DESC);
	1196	+SIG_EXPR_DECL_SINGLE(ROMD6, ROM16, V22_DESC, VPOOFF0_DESC);
	1197	+SIG_EXPR_DECL_SINGLE(ROMD6, ROM16S, V22_DESC, VPOOFF0_DESC);
	1198	+SIG_EXPR_LIST_DECL(ROMD6, ROM,
	1199	+ SIG_EXPR_PTR(ROMD6, ROM8),
1110	1200	SIG_EXPR_PTR(ROMD6, ROM16),
1111	1201	SIG_EXPR_PTR(ROMD6, ROM16S));
1112		-SIG_EXPR_DECL(VPOVS, VPO12, V22_DESC, VPO12_DESC);
1113		-SIG_EXPR_DECL(VPOVS, VPO24, V22_DESC, VPO24_DESC);
1114		-SIG_EXPR_LIST_DECL_DUAL(VPOVS, VPO12, VPO24);
1115		-MS_PIN_DECL(V22, GPIOS2, ROMD6, VPOVS);
	1202	+SIG_EXPR_LIST_ALIAS(V22, ROMD6, ROM);
	1203	+SIG_EXPR_DECL_SINGLE(VPOVS, VPO12, V22_DESC, VPO12_DESC);
	1204	+SIG_EXPR_DECL_SINGLE(VPOVS, VPO24, V22_DESC, VPO24_DESC);
	1205	+SIG_EXPR_LIST_DECL_DUAL(V22, VPOVS, VPO12, VPO24);
	1206	+PIN_DECL_2(V22, GPIOS2, ROMD6, VPOVS);
1116	1207
1117	1208	#define U20 147
1118	1209	#define U20_DESC SIG_DESC_SET(SCU8C, 3)
1119		-SIG_EXPR_DECL(ROMD7, ROM8, U20_DESC, VPOOFF0_DESC);
1120		-SIG_EXPR_DECL(ROMD7, ROM16, U20_DESC, VPOOFF0_DESC);
1121		-SIG_EXPR_DECL(ROMD7, ROM16S, U20_DESC, VPOOFF0_DESC);
1122		-SIG_EXPR_LIST_DECL(ROMD7, SIG_EXPR_PTR(ROMD7, ROM8),
	1210	+SIG_EXPR_DECL_SINGLE(ROMD7, ROM8, U20_DESC, VPOOFF0_DESC);
	1211	+SIG_EXPR_DECL_SINGLE(ROMD7, ROM16, U20_DESC, VPOOFF0_DESC);
	1212	+SIG_EXPR_DECL_SINGLE(ROMD7, ROM16S, U20_DESC, VPOOFF0_DESC);
	1213	+SIG_EXPR_LIST_DECL(ROMD7, ROM,
	1214	+ SIG_EXPR_PTR(ROMD7, ROM8),
1123	1215	SIG_EXPR_PTR(ROMD7, ROM16),
1124	1216	SIG_EXPR_PTR(ROMD7, ROM16S));
1125		-SIG_EXPR_DECL(VPOCLK, VPO12, U20_DESC, VPO12_DESC);
1126		-SIG_EXPR_DECL(VPOCLK, VPO24, U20_DESC, VPO24_DESC);
1127		-SIG_EXPR_LIST_DECL_DUAL(VPOCLK, VPO12, VPO24);
1128		-MS_PIN_DECL(U20, GPIOS3, ROMD7, VPOCLK);
	1217	+SIG_EXPR_LIST_ALIAS(U20, ROMD7, ROM);
	1218	+SIG_EXPR_DECL_SINGLE(VPOCLK, VPO12, U20_DESC, VPO12_DESC);
	1219	+SIG_EXPR_DECL_SINGLE(VPOCLK, VPO24, U20_DESC, VPO24_DESC);
	1220	+SIG_EXPR_LIST_DECL_DUAL(U20, VPOCLK, VPO12, VPO24);
	1221	+PIN_DECL_2(U20, GPIOS3, ROMD7, VPOCLK);
1129	1222
1130	1223	#define R18 148
1131	1224	#define ROMOE_DESC SIG_DESC_SET(SCU8C, 4)
1132		-SIG_EXPR_LIST_DECL_SINGLE(GPIOS4, GPIOS4);
1133		-SIG_EXPR_DECL(ROMOE, ROM8, ROMOE_DESC);
1134		-SIG_EXPR_DECL(ROMOE, ROM16, ROMOE_DESC);
1135		-SIG_EXPR_DECL(ROMOE, ROM16S, ROMOE_DESC);
1136		-SIG_EXPR_LIST_DECL(ROMOE, SIG_EXPR_PTR(ROMOE, ROM8),
	1225	+SIG_EXPR_LIST_DECL_SINGLE(R18, GPIOS4, GPIOS4);
	1226	+SIG_EXPR_DECL_SINGLE(ROMOE, ROM8, ROMOE_DESC);
	1227	+SIG_EXPR_DECL_SINGLE(ROMOE, ROM16, ROMOE_DESC);
	1228	+SIG_EXPR_DECL_SINGLE(ROMOE, ROM16S, ROMOE_DESC);
	1229	+SIG_EXPR_LIST_DECL(ROMOE, ROM,
	1230	+ SIG_EXPR_PTR(ROMOE, ROM8),
1137	1231	SIG_EXPR_PTR(ROMOE, ROM16),
1138	1232	SIG_EXPR_PTR(ROMOE, ROM16S));
1139		-MS_PIN_DECL_(R18, SIG_EXPR_LIST_PTR(ROMOE), SIG_EXPR_LIST_PTR(GPIOS4));
	1233	+SIG_EXPR_LIST_ALIAS(R18, ROMOE, ROM);
	1234	+PIN_DECL_(R18, SIG_EXPR_LIST_PTR(R18, ROMOE), SIG_EXPR_LIST_PTR(R18, GPIOS4));
1140	1235
1141	1236	#define N21 149
1142	1237	#define ROMWE_DESC SIG_DESC_SET(SCU8C, 5)
1143		-SIG_EXPR_LIST_DECL_SINGLE(GPIOS5, GPIOS5);
1144		-SIG_EXPR_DECL(ROMWE, ROM8, ROMWE_DESC);
1145		-SIG_EXPR_DECL(ROMWE, ROM16, ROMWE_DESC);
1146		-SIG_EXPR_DECL(ROMWE, ROM16S, ROMWE_DESC);
1147		-SIG_EXPR_LIST_DECL(ROMWE, SIG_EXPR_PTR(ROMWE, ROM8),
	1238	+SIG_EXPR_LIST_DECL_SINGLE(N21, GPIOS5, GPIOS5);
	1239	+SIG_EXPR_DECL_SINGLE(ROMWE, ROM8, ROMWE_DESC);
	1240	+SIG_EXPR_DECL_SINGLE(ROMWE, ROM16, ROMWE_DESC);
	1241	+SIG_EXPR_DECL_SINGLE(ROMWE, ROM16S, ROMWE_DESC);
	1242	+SIG_EXPR_LIST_DECL(ROMWE, ROM,
	1243	+ SIG_EXPR_PTR(ROMWE, ROM8),
1148	1244	SIG_EXPR_PTR(ROMWE, ROM16),
1149	1245	SIG_EXPR_PTR(ROMWE, ROM16S));
1150		-MS_PIN_DECL_(N21, SIG_EXPR_LIST_PTR(ROMWE), SIG_EXPR_LIST_PTR(GPIOS5));
	1246	+SIG_EXPR_LIST_ALIAS(N21, ROMWE, ROM);
	1247	+PIN_DECL_(N21, SIG_EXPR_LIST_PTR(N21, ROMWE), SIG_EXPR_LIST_PTR(N21, GPIOS5));
1151	1248
1152	1249	#define L22 150
1153	1250	#define L22_DESC SIG_DESC_SET(SCU8C, 6)
1154		-SIG_EXPR_DECL(ROMA22, ROM8, L22_DESC, VPO_OFF_12);
1155		-SIG_EXPR_DECL(ROMA22, ROM16, L22_DESC, VPO_OFF_12);
1156		-SIG_EXPR_DECL(ROMA22, ROM16S, L22_DESC, VPO_OFF_12);
1157		-SIG_EXPR_LIST_DECL(ROMA22, SIG_EXPR_PTR(ROMA22, ROM8),
	1251	+SIG_EXPR_DECL_SINGLE(ROMA22, ROM8, L22_DESC, VPO_OFF_12);
	1252	+SIG_EXPR_DECL_SINGLE(ROMA22, ROM16, L22_DESC, VPO_OFF_12);
	1253	+SIG_EXPR_DECL_SINGLE(ROMA22, ROM16S, L22_DESC, VPO_OFF_12);
	1254	+SIG_EXPR_LIST_DECL(ROMA22, ROM,
	1255	+ SIG_EXPR_PTR(ROMA22, ROM8),
1158	1256	SIG_EXPR_PTR(ROMA22, ROM16),
1159	1257	SIG_EXPR_PTR(ROMA22, ROM16S));
1160		-SIG_EXPR_LIST_DECL_SINGLE(VPOR4, VPO24, L22_DESC, VPO_24_OFF);
1161		-MS_PIN_DECL(L22, GPIOS6, ROMA22, VPOR4);
	1258	+SIG_EXPR_LIST_ALIAS(L22, ROMA22, ROM);
	1259	+SIG_EXPR_LIST_DECL_SINGLE(L22, VPOR4, VPO24, L22_DESC, VPO_24_OFF);
	1260	+PIN_DECL_2(L22, GPIOS6, ROMA22, VPOR4);
1162	1261
1163	1262	#define K18 151
1164	1263	#define K18_DESC SIG_DESC_SET(SCU8C, 7)
1165		-SIG_EXPR_DECL(ROMA23, ROM8, K18_DESC, VPO_OFF_12);
1166		-SIG_EXPR_DECL(ROMA23, ROM16, K18_DESC, VPO_OFF_12);
1167		-SIG_EXPR_DECL(ROMA23, ROM16S, K18_DESC, VPO_OFF_12);
1168		-SIG_EXPR_LIST_DECL(ROMA23, SIG_EXPR_PTR(ROMA23, ROM8),
	1264	+SIG_EXPR_DECL_SINGLE(ROMA23, ROM8, K18_DESC, VPO_OFF_12);
	1265	+SIG_EXPR_DECL_SINGLE(ROMA23, ROM16, K18_DESC, VPO_OFF_12);
	1266	+SIG_EXPR_DECL_SINGLE(ROMA23, ROM16S, K18_DESC, VPO_OFF_12);
	1267	+SIG_EXPR_LIST_DECL(ROMA23, ROM,
	1268	+ SIG_EXPR_PTR(ROMA23, ROM8),
1169	1269	SIG_EXPR_PTR(ROMA23, ROM16),
1170	1270	SIG_EXPR_PTR(ROMA23, ROM16S));
1171		-SIG_EXPR_LIST_DECL_SINGLE(VPOR5, VPO24, K18_DESC, VPO_24_OFF);
1172		-MS_PIN_DECL(K18, GPIOS7, ROMA23, VPOR5);
	1271	+SIG_EXPR_LIST_ALIAS(K18, ROMA23, ROM);
	1272	+SIG_EXPR_LIST_DECL_SINGLE(K18, VPOR5, VPO24, K18_DESC, VPO_24_OFF);
	1273	+PIN_DECL_2(K18, GPIOS7, ROMA23, VPOR5);
1173	1274
1174	1275	#define RMII1_DESC SIG_DESC_BIT(HW_STRAP1, 6, 0)
1175	1276
1176	1277	#define A12 152
1177		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT0, GPIOT0, SIG_DESC_SET(SCUA0, 0));
1178		-SIG_EXPR_LIST_DECL_SINGLE(RMII1TXEN, RMII1, RMII1_DESC);
1179		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1TXCK, RGMII1);
1180		-MS_PIN_DECL_(A12, SIG_EXPR_LIST_PTR(GPIOT0), SIG_EXPR_LIST_PTR(RMII1TXEN),
1181		- SIG_EXPR_LIST_PTR(RGMII1TXCK));
	1278	+SIG_EXPR_LIST_DECL_SINGLE(A12, GPIOT0, GPIOT0, SIG_DESC_SET(SCUA0, 0));
	1279	+SIG_EXPR_LIST_DECL_SINGLE(A12, RMII1TXEN, RMII1, RMII1_DESC);
	1280	+SIG_EXPR_LIST_DECL_SINGLE(A12, RGMII1TXCK, RGMII1);
	1281	+PIN_DECL_(A12, SIG_EXPR_LIST_PTR(A12, GPIOT0),
	1282	+ SIG_EXPR_LIST_PTR(A12, RMII1TXEN),
	1283	+ SIG_EXPR_LIST_PTR(A12, RGMII1TXCK));
1182	1284
1183	1285	#define B12 153
1184		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT1, GPIOT1, SIG_DESC_SET(SCUA0, 1));
1185		-SIG_EXPR_LIST_DECL_SINGLE(DASHB12, RMII1, RMII1_DESC);
1186		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1TXCTL, RGMII1);
1187		-MS_PIN_DECL_(B12, SIG_EXPR_LIST_PTR(GPIOT1), SIG_EXPR_LIST_PTR(DASHB12),
1188		- SIG_EXPR_LIST_PTR(RGMII1TXCTL));
	1286	+SIG_EXPR_LIST_DECL_SINGLE(B12, GPIOT1, GPIOT1, SIG_DESC_SET(SCUA0, 1));
	1287	+SIG_EXPR_LIST_DECL_SINGLE(B12, DASHB12, RMII1, RMII1_DESC);
	1288	+SIG_EXPR_LIST_DECL_SINGLE(B12, RGMII1TXCTL, RGMII1);
	1289	+PIN_DECL_(B12, SIG_EXPR_LIST_PTR(B12, GPIOT1), SIG_EXPR_LIST_PTR(B12, DASHB12),
	1290	+ SIG_EXPR_LIST_PTR(B12, RGMII1TXCTL));
1189	1291
1190	1292	#define C12 154
1191		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT2, GPIOT2, SIG_DESC_SET(SCUA0, 2));
1192		-SIG_EXPR_LIST_DECL_SINGLE(RMII1TXD0, RMII1, RMII1_DESC);
1193		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1TXD0, RGMII1);
1194		-MS_PIN_DECL_(C12, SIG_EXPR_LIST_PTR(GPIOT2), SIG_EXPR_LIST_PTR(RMII1TXD0),
1195		- SIG_EXPR_LIST_PTR(RGMII1TXD0));
	1293	+SIG_EXPR_LIST_DECL_SINGLE(C12, GPIOT2, GPIOT2, SIG_DESC_SET(SCUA0, 2));
	1294	+SIG_EXPR_LIST_DECL_SINGLE(C12, RMII1TXD0, RMII1, RMII1_DESC);
	1295	+SIG_EXPR_LIST_DECL_SINGLE(C12, RGMII1TXD0, RGMII1);
	1296	+PIN_DECL_(C12, SIG_EXPR_LIST_PTR(C12, GPIOT2),
	1297	+ SIG_EXPR_LIST_PTR(C12, RMII1TXD0),
	1298	+ SIG_EXPR_LIST_PTR(C12, RGMII1TXD0));
1196	1299
1197	1300	#define D12 155
1198		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT3, GPIOT3, SIG_DESC_SET(SCUA0, 3));
1199		-SIG_EXPR_LIST_DECL_SINGLE(RMII1TXD1, RMII1, RMII1_DESC);
1200		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1TXD1, RGMII1);
1201		-MS_PIN_DECL_(D12, SIG_EXPR_LIST_PTR(GPIOT3), SIG_EXPR_LIST_PTR(RMII1TXD1),
1202		- SIG_EXPR_LIST_PTR(RGMII1TXD1));
	1301	+SIG_EXPR_LIST_DECL_SINGLE(D12, GPIOT3, GPIOT3, SIG_DESC_SET(SCUA0, 3));
	1302	+SIG_EXPR_LIST_DECL_SINGLE(D12, RMII1TXD1, RMII1, RMII1_DESC);
	1303	+SIG_EXPR_LIST_DECL_SINGLE(D12, RGMII1TXD1, RGMII1);
	1304	+PIN_DECL_(D12, SIG_EXPR_LIST_PTR(D12, GPIOT3),
	1305	+ SIG_EXPR_LIST_PTR(D12, RMII1TXD1),
	1306	+ SIG_EXPR_LIST_PTR(D12, RGMII1TXD1));
1203	1307
1204	1308	#define E12 156
1205		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT4, GPIOT4, SIG_DESC_SET(SCUA0, 4));
1206		-SIG_EXPR_LIST_DECL_SINGLE(DASHE12, RMII1, RMII1_DESC);
1207		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1TXD2, RGMII1);
1208		-MS_PIN_DECL_(E12, SIG_EXPR_LIST_PTR(GPIOT4), SIG_EXPR_LIST_PTR(DASHE12),
1209		- SIG_EXPR_LIST_PTR(RGMII1TXD2));
	1309	+SIG_EXPR_LIST_DECL_SINGLE(E12, GPIOT4, GPIOT4, SIG_DESC_SET(SCUA0, 4));
	1310	+SIG_EXPR_LIST_DECL_SINGLE(E12, DASHE12, RMII1, RMII1_DESC);
	1311	+SIG_EXPR_LIST_DECL_SINGLE(E12, RGMII1TXD2, RGMII1);
	1312	+PIN_DECL_(E12, SIG_EXPR_LIST_PTR(E12, GPIOT4), SIG_EXPR_LIST_PTR(E12, DASHE12),
	1313	+ SIG_EXPR_LIST_PTR(E12, RGMII1TXD2));
1210	1314
1211	1315	#define A13 157
1212		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT5, GPIOT5, SIG_DESC_SET(SCUA0, 5));
1213		-SIG_EXPR_LIST_DECL_SINGLE(DASHA13, RMII1, RMII1_DESC);
1214		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1TXD3, RGMII1);
1215		-MS_PIN_DECL_(A13, SIG_EXPR_LIST_PTR(GPIOT5), SIG_EXPR_LIST_PTR(DASHA13),
1216		- SIG_EXPR_LIST_PTR(RGMII1TXD3));
	1316	+SIG_EXPR_LIST_DECL_SINGLE(A13, GPIOT5, GPIOT5, SIG_DESC_SET(SCUA0, 5));
	1317	+SIG_EXPR_LIST_DECL_SINGLE(A13, DASHA13, RMII1, RMII1_DESC);
	1318	+SIG_EXPR_LIST_DECL_SINGLE(A13, RGMII1TXD3, RGMII1);
	1319	+PIN_DECL_(A13, SIG_EXPR_LIST_PTR(A13, GPIOT5), SIG_EXPR_LIST_PTR(A13, DASHA13),
	1320	+ SIG_EXPR_LIST_PTR(A13, RGMII1TXD3));
1217	1321
1218	1322	#define RMII2_DESC SIG_DESC_BIT(HW_STRAP1, 7, 0)
1219	1323
1220	1324	#define D9 158
1221		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT6, GPIOT6, SIG_DESC_SET(SCUA0, 6));
1222		-SIG_EXPR_LIST_DECL_SINGLE(RMII2TXEN, RMII2, RMII2_DESC);
1223		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2TXCK, RGMII2);
1224		-MS_PIN_DECL_(D9, SIG_EXPR_LIST_PTR(GPIOT6), SIG_EXPR_LIST_PTR(RMII2TXEN),
1225		- SIG_EXPR_LIST_PTR(RGMII2TXCK));
	1325	+SIG_EXPR_LIST_DECL_SINGLE(D9, GPIOT6, GPIOT6, SIG_DESC_SET(SCUA0, 6));
	1326	+SIG_EXPR_LIST_DECL_SINGLE(D9, RMII2TXEN, RMII2, RMII2_DESC);
	1327	+SIG_EXPR_LIST_DECL_SINGLE(D9, RGMII2TXCK, RGMII2);
	1328	+PIN_DECL_(D9, SIG_EXPR_LIST_PTR(D9, GPIOT6), SIG_EXPR_LIST_PTR(D9, RMII2TXEN),
	1329	+ SIG_EXPR_LIST_PTR(D9, RGMII2TXCK));
1226	1330
1227	1331	#define E9 159
1228		-SIG_EXPR_LIST_DECL_SINGLE(GPIOT7, GPIOT7, SIG_DESC_SET(SCUA0, 7));
1229		-SIG_EXPR_LIST_DECL_SINGLE(DASHE9, RMII2, RMII2_DESC);
1230		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2TXCTL, RGMII2);
1231		-MS_PIN_DECL_(E9, SIG_EXPR_LIST_PTR(GPIOT7), SIG_EXPR_LIST_PTR(DASHE9),
1232		- SIG_EXPR_LIST_PTR(RGMII2TXCTL));
	1332	+SIG_EXPR_LIST_DECL_SINGLE(E9, GPIOT7, GPIOT7, SIG_DESC_SET(SCUA0, 7));
	1333	+SIG_EXPR_LIST_DECL_SINGLE(E9, DASHE9, RMII2, RMII2_DESC);
	1334	+SIG_EXPR_LIST_DECL_SINGLE(E9, RGMII2TXCTL, RGMII2);
	1335	+PIN_DECL_(E9, SIG_EXPR_LIST_PTR(E9, GPIOT7), SIG_EXPR_LIST_PTR(E9, DASHE9),
	1336	+ SIG_EXPR_LIST_PTR(E9, RGMII2TXCTL));
1233	1337
1234	1338	#define A10 160
1235		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU0, GPIOU0, SIG_DESC_SET(SCUA0, 8));
1236		-SIG_EXPR_LIST_DECL_SINGLE(RMII2TXD0, RMII2, RMII2_DESC);
1237		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2TXD0, RGMII2);
1238		-MS_PIN_DECL_(A10, SIG_EXPR_LIST_PTR(GPIOU0), SIG_EXPR_LIST_PTR(RMII2TXD0),
1239		- SIG_EXPR_LIST_PTR(RGMII2TXD0));
	1339	+SIG_EXPR_LIST_DECL_SINGLE(A10, GPIOU0, GPIOU0, SIG_DESC_SET(SCUA0, 8));
	1340	+SIG_EXPR_LIST_DECL_SINGLE(A10, RMII2TXD0, RMII2, RMII2_DESC);
	1341	+SIG_EXPR_LIST_DECL_SINGLE(A10, RGMII2TXD0, RGMII2);
	1342	+PIN_DECL_(A10, SIG_EXPR_LIST_PTR(A10, GPIOU0),
	1343	+ SIG_EXPR_LIST_PTR(A10, RMII2TXD0),
	1344	+ SIG_EXPR_LIST_PTR(A10, RGMII2TXD0));
1240	1345
1241	1346	#define B10 161
1242		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU1, GPIOU1, SIG_DESC_SET(SCUA0, 9));
1243		-SIG_EXPR_LIST_DECL_SINGLE(RMII2TXD1, RMII2, RMII2_DESC);
1244		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2TXD1, RGMII2);
1245		-MS_PIN_DECL_(B10, SIG_EXPR_LIST_PTR(GPIOU1), SIG_EXPR_LIST_PTR(RMII2TXD1),
1246		- SIG_EXPR_LIST_PTR(RGMII2TXD1));
	1347	+SIG_EXPR_LIST_DECL_SINGLE(B10, GPIOU1, GPIOU1, SIG_DESC_SET(SCUA0, 9));
	1348	+SIG_EXPR_LIST_DECL_SINGLE(B10, RMII2TXD1, RMII2, RMII2_DESC);
	1349	+SIG_EXPR_LIST_DECL_SINGLE(B10, RGMII2TXD1, RGMII2);
	1350	+PIN_DECL_(B10, SIG_EXPR_LIST_PTR(B10, GPIOU1),
	1351	+ SIG_EXPR_LIST_PTR(B10, RMII2TXD1),
	1352	+ SIG_EXPR_LIST_PTR(B10, RGMII2TXD1));
1247	1353
1248	1354	#define C10 162
1249		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU2, GPIOU2, SIG_DESC_SET(SCUA0, 10));
1250		-SIG_EXPR_LIST_DECL_SINGLE(DASHC10, RMII2, RMII2_DESC);
1251		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2TXD2, RGMII2);
1252		-MS_PIN_DECL_(C10, SIG_EXPR_LIST_PTR(GPIOU2), SIG_EXPR_LIST_PTR(DASHC10),
1253		- SIG_EXPR_LIST_PTR(RGMII2TXD2));
	1355	+SIG_EXPR_LIST_DECL_SINGLE(C10, GPIOU2, GPIOU2, SIG_DESC_SET(SCUA0, 10));
	1356	+SIG_EXPR_LIST_DECL_SINGLE(C10, DASHC10, RMII2, RMII2_DESC);
	1357	+SIG_EXPR_LIST_DECL_SINGLE(C10, RGMII2TXD2, RGMII2);
	1358	+PIN_DECL_(C10, SIG_EXPR_LIST_PTR(C10, GPIOU2), SIG_EXPR_LIST_PTR(C10, DASHC10),
	1359	+ SIG_EXPR_LIST_PTR(C10, RGMII2TXD2));
1254	1360
1255	1361	#define D10 163
1256		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU3, GPIOU3, SIG_DESC_SET(SCUA0, 11));
1257		-SIG_EXPR_LIST_DECL_SINGLE(DASHD10, RMII2, RMII2_DESC);
1258		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2TXD3, RGMII2);
1259		-MS_PIN_DECL_(D10, SIG_EXPR_LIST_PTR(GPIOU3), SIG_EXPR_LIST_PTR(DASHD10),
1260		- SIG_EXPR_LIST_PTR(RGMII2TXD3));
	1362	+SIG_EXPR_LIST_DECL_SINGLE(D10, GPIOU3, GPIOU3, SIG_DESC_SET(SCUA0, 11));
	1363	+SIG_EXPR_LIST_DECL_SINGLE(D10, DASHD10, RMII2, RMII2_DESC);
	1364	+SIG_EXPR_LIST_DECL_SINGLE(D10, RGMII2TXD3, RGMII2);
	1365	+PIN_DECL_(D10, SIG_EXPR_LIST_PTR(D10, GPIOU3), SIG_EXPR_LIST_PTR(D10, DASHD10),
	1366	+ SIG_EXPR_LIST_PTR(D10, RGMII2TXD3));
1261	1367
1262	1368	#define E11 164
1263		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU4, GPIOU4, SIG_DESC_SET(SCUA0, 12));
1264		-SIG_EXPR_LIST_DECL_SINGLE(RMII1RCLK, RMII1, RMII1_DESC);
1265		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1RXCK, RGMII1);
1266		-MS_PIN_DECL_(E11, SIG_EXPR_LIST_PTR(GPIOU4), SIG_EXPR_LIST_PTR(RMII1RCLK),
1267		- SIG_EXPR_LIST_PTR(RGMII1RXCK));
	1369	+SIG_EXPR_LIST_DECL_SINGLE(E11, GPIOU4, GPIOU4, SIG_DESC_SET(SCUA0, 12));
	1370	+SIG_EXPR_LIST_DECL_SINGLE(E11, RMII1RCLK, RMII1, RMII1_DESC);
	1371	+SIG_EXPR_LIST_DECL_SINGLE(E11, RGMII1RXCK, RGMII1);
	1372	+PIN_DECL_(E11, SIG_EXPR_LIST_PTR(E11, GPIOU4),
	1373	+ SIG_EXPR_LIST_PTR(E11, RMII1RCLK),
	1374	+ SIG_EXPR_LIST_PTR(E11, RGMII1RXCK));
1268	1375
1269	1376	#define D11 165
1270		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU5, GPIOU5, SIG_DESC_SET(SCUA0, 13));
1271		-SIG_EXPR_LIST_DECL_SINGLE(DASHD11, RMII1, RMII1_DESC);
1272		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1RXCTL, RGMII1);
1273		-MS_PIN_DECL_(D11, SIG_EXPR_LIST_PTR(GPIOU5), SIG_EXPR_LIST_PTR(DASHD11),
1274		- SIG_EXPR_LIST_PTR(RGMII1RXCTL));
	1377	+SIG_EXPR_LIST_DECL_SINGLE(D11, GPIOU5, GPIOU5, SIG_DESC_SET(SCUA0, 13));
	1378	+SIG_EXPR_LIST_DECL_SINGLE(D11, DASHD11, RMII1, RMII1_DESC);
	1379	+SIG_EXPR_LIST_DECL_SINGLE(D11, RGMII1RXCTL, RGMII1);
	1380	+PIN_DECL_(D11, SIG_EXPR_LIST_PTR(D11, GPIOU5), SIG_EXPR_LIST_PTR(D11, DASHD11),
	1381	+ SIG_EXPR_LIST_PTR(D11, RGMII1RXCTL));
1275	1382
1276	1383	#define C11 166
1277		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU6, GPIOU6, SIG_DESC_SET(SCUA0, 14));
1278		-SIG_EXPR_LIST_DECL_SINGLE(RMII1RXD0, RMII1, RMII1_DESC);
1279		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1RXD0, RGMII1);
1280		-MS_PIN_DECL_(C11, SIG_EXPR_LIST_PTR(GPIOU6), SIG_EXPR_LIST_PTR(RMII1RXD0),
1281		- SIG_EXPR_LIST_PTR(RGMII1RXD0));
	1384	+SIG_EXPR_LIST_DECL_SINGLE(C11, GPIOU6, GPIOU6, SIG_DESC_SET(SCUA0, 14));
	1385	+SIG_EXPR_LIST_DECL_SINGLE(C11, RMII1RXD0, RMII1, RMII1_DESC);
	1386	+SIG_EXPR_LIST_DECL_SINGLE(C11, RGMII1RXD0, RGMII1);
	1387	+PIN_DECL_(C11, SIG_EXPR_LIST_PTR(C11, GPIOU6),
	1388	+ SIG_EXPR_LIST_PTR(C11, RMII1RXD0),
	1389	+ SIG_EXPR_LIST_PTR(C11, RGMII1RXD0));
1282	1390
1283	1391	#define B11 167
1284		-SIG_EXPR_LIST_DECL_SINGLE(GPIOU7, GPIOU7, SIG_DESC_SET(SCUA0, 15));
1285		-SIG_EXPR_LIST_DECL_SINGLE(RMII1RXD1, RMII1, RMII1_DESC);
1286		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1RXD1, RGMII1);
1287		-MS_PIN_DECL_(B11, SIG_EXPR_LIST_PTR(GPIOU7), SIG_EXPR_LIST_PTR(RMII1RXD1),
1288		- SIG_EXPR_LIST_PTR(RGMII1RXD1));
	1392	+SIG_EXPR_LIST_DECL_SINGLE(B11, GPIOU7, GPIOU7, SIG_DESC_SET(SCUA0, 15));
	1393	+SIG_EXPR_LIST_DECL_SINGLE(B11, RMII1RXD1, RMII1, RMII1_DESC);
	1394	+SIG_EXPR_LIST_DECL_SINGLE(B11, RGMII1RXD1, RGMII1);
	1395	+PIN_DECL_(B11, SIG_EXPR_LIST_PTR(B11, GPIOU7),
	1396	+ SIG_EXPR_LIST_PTR(B11, RMII1RXD1),
	1397	+ SIG_EXPR_LIST_PTR(B11, RGMII1RXD1));
1289	1398
1290	1399	#define A11 168
1291		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV0, GPIOV0, SIG_DESC_SET(SCUA0, 16));
1292		-SIG_EXPR_LIST_DECL_SINGLE(RMII1CRSDV, RMII1, RMII1_DESC);
1293		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1RXD2, RGMII1);
1294		-MS_PIN_DECL_(A11, SIG_EXPR_LIST_PTR(GPIOV0), SIG_EXPR_LIST_PTR(RMII1CRSDV),
1295		- SIG_EXPR_LIST_PTR(RGMII1RXD2));
	1400	+SIG_EXPR_LIST_DECL_SINGLE(A11, GPIOV0, GPIOV0, SIG_DESC_SET(SCUA0, 16));
	1401	+SIG_EXPR_LIST_DECL_SINGLE(A11, RMII1CRSDV, RMII1, RMII1_DESC);
	1402	+SIG_EXPR_LIST_DECL_SINGLE(A11, RGMII1RXD2, RGMII1);
	1403	+PIN_DECL_(A11, SIG_EXPR_LIST_PTR(A11, GPIOV0),
	1404	+ SIG_EXPR_LIST_PTR(A11, RMII1CRSDV),
	1405	+ SIG_EXPR_LIST_PTR(A11, RGMII1RXD2));
1296	1406
1297	1407	#define E10 169
1298		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV1, GPIOV1, SIG_DESC_SET(SCUA0, 17));
1299		-SIG_EXPR_LIST_DECL_SINGLE(RMII1RXER, RMII1, RMII1_DESC);
1300		-SIG_EXPR_LIST_DECL_SINGLE(RGMII1RXD3, RGMII1);
1301		-MS_PIN_DECL_(E10, SIG_EXPR_LIST_PTR(GPIOV1), SIG_EXPR_LIST_PTR(RMII1RXER),
1302		- SIG_EXPR_LIST_PTR(RGMII1RXD3));
	1408	+SIG_EXPR_LIST_DECL_SINGLE(E10, GPIOV1, GPIOV1, SIG_DESC_SET(SCUA0, 17));
	1409	+SIG_EXPR_LIST_DECL_SINGLE(E10, RMII1RXER, RMII1, RMII1_DESC);
	1410	+SIG_EXPR_LIST_DECL_SINGLE(E10, RGMII1RXD3, RGMII1);
	1411	+PIN_DECL_(E10, SIG_EXPR_LIST_PTR(E10, GPIOV1),
	1412	+ SIG_EXPR_LIST_PTR(E10, RMII1RXER),
	1413	+ SIG_EXPR_LIST_PTR(E10, RGMII1RXD3));
1303	1414
1304	1415	#define C9 170
1305		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV2, GPIOV2, SIG_DESC_SET(SCUA0, 18));
1306		-SIG_EXPR_LIST_DECL_SINGLE(RMII2RCLK, RMII2, RMII2_DESC);
1307		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2RXCK, RGMII2);
1308		-MS_PIN_DECL_(C9, SIG_EXPR_LIST_PTR(GPIOV2), SIG_EXPR_LIST_PTR(RMII2RCLK),
1309		- SIG_EXPR_LIST_PTR(RGMII2RXCK));
	1416	+SIG_EXPR_LIST_DECL_SINGLE(C9, GPIOV2, GPIOV2, SIG_DESC_SET(SCUA0, 18));
	1417	+SIG_EXPR_LIST_DECL_SINGLE(C9, RMII2RCLK, RMII2, RMII2_DESC);
	1418	+SIG_EXPR_LIST_DECL_SINGLE(C9, RGMII2RXCK, RGMII2);
	1419	+PIN_DECL_(C9, SIG_EXPR_LIST_PTR(C9, GPIOV2), SIG_EXPR_LIST_PTR(C9, RMII2RCLK),
	1420	+ SIG_EXPR_LIST_PTR(C9, RGMII2RXCK));
1310	1421
1311	1422	#define B9 171
1312		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV3, GPIOV3, SIG_DESC_SET(SCUA0, 19));
1313		-SIG_EXPR_LIST_DECL_SINGLE(DASHB9, RMII2, RMII2_DESC);
1314		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2RXCTL, RGMII2);
1315		-MS_PIN_DECL_(B9, SIG_EXPR_LIST_PTR(GPIOV3), SIG_EXPR_LIST_PTR(DASHB9),
1316		- SIG_EXPR_LIST_PTR(RGMII2RXCTL));
	1423	+SIG_EXPR_LIST_DECL_SINGLE(B9, GPIOV3, GPIOV3, SIG_DESC_SET(SCUA0, 19));
	1424	+SIG_EXPR_LIST_DECL_SINGLE(B9, DASHB9, RMII2, RMII2_DESC);
	1425	+SIG_EXPR_LIST_DECL_SINGLE(B9, RGMII2RXCTL, RGMII2);
	1426	+PIN_DECL_(B9, SIG_EXPR_LIST_PTR(B9, GPIOV3), SIG_EXPR_LIST_PTR(B9, DASHB9),
	1427	+ SIG_EXPR_LIST_PTR(B9, RGMII2RXCTL));
1317	1428
1318	1429	#define A9 172
1319		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV4, GPIOV4, SIG_DESC_SET(SCUA0, 20));
1320		-SIG_EXPR_LIST_DECL_SINGLE(RMII2RXD0, RMII2, RMII2_DESC);
1321		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2RXD0, RGMII2);
1322		-MS_PIN_DECL_(A9, SIG_EXPR_LIST_PTR(GPIOV4), SIG_EXPR_LIST_PTR(RMII2RXD0),
1323		- SIG_EXPR_LIST_PTR(RGMII2RXD0));
	1430	+SIG_EXPR_LIST_DECL_SINGLE(A9, GPIOV4, GPIOV4, SIG_DESC_SET(SCUA0, 20));
	1431	+SIG_EXPR_LIST_DECL_SINGLE(A9, RMII2RXD0, RMII2, RMII2_DESC);
	1432	+SIG_EXPR_LIST_DECL_SINGLE(A9, RGMII2RXD0, RGMII2);
	1433	+PIN_DECL_(A9, SIG_EXPR_LIST_PTR(A9, GPIOV4), SIG_EXPR_LIST_PTR(A9, RMII2RXD0),
	1434	+ SIG_EXPR_LIST_PTR(A9, RGMII2RXD0));
1324	1435
1325	1436	#define E8 173
1326		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV5, GPIOV5, SIG_DESC_SET(SCUA0, 21));
1327		-SIG_EXPR_LIST_DECL_SINGLE(RMII2RXD1, RMII2, RMII2_DESC);
1328		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2RXD1, RGMII2);
1329		-MS_PIN_DECL_(E8, SIG_EXPR_LIST_PTR(GPIOV5), SIG_EXPR_LIST_PTR(RMII2RXD1),
1330		- SIG_EXPR_LIST_PTR(RGMII2RXD1));
	1437	+SIG_EXPR_LIST_DECL_SINGLE(E8, GPIOV5, GPIOV5, SIG_DESC_SET(SCUA0, 21));
	1438	+SIG_EXPR_LIST_DECL_SINGLE(E8, RMII2RXD1, RMII2, RMII2_DESC);
	1439	+SIG_EXPR_LIST_DECL_SINGLE(E8, RGMII2RXD1, RGMII2);
	1440	+PIN_DECL_(E8, SIG_EXPR_LIST_PTR(E8, GPIOV5), SIG_EXPR_LIST_PTR(E8, RMII2RXD1),
	1441	+ SIG_EXPR_LIST_PTR(E8, RGMII2RXD1));
1331	1442
1332	1443	#define D8 174
1333		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV6, GPIOV6, SIG_DESC_SET(SCUA0, 22));
1334		-SIG_EXPR_LIST_DECL_SINGLE(RMII2CRSDV, RMII2, RMII2_DESC);
1335		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2RXD2, RGMII2);
1336		-MS_PIN_DECL_(D8, SIG_EXPR_LIST_PTR(GPIOV6), SIG_EXPR_LIST_PTR(RMII2CRSDV),
1337		- SIG_EXPR_LIST_PTR(RGMII2RXD2));
	1444	+SIG_EXPR_LIST_DECL_SINGLE(D8, GPIOV6, GPIOV6, SIG_DESC_SET(SCUA0, 22));
	1445	+SIG_EXPR_LIST_DECL_SINGLE(D8, RMII2CRSDV, RMII2, RMII2_DESC);
	1446	+SIG_EXPR_LIST_DECL_SINGLE(D8, RGMII2RXD2, RGMII2);
	1447	+PIN_DECL_(D8, SIG_EXPR_LIST_PTR(D8, GPIOV6), SIG_EXPR_LIST_PTR(D8, RMII2CRSDV),
	1448	+ SIG_EXPR_LIST_PTR(D8, RGMII2RXD2));
1338	1449
1339	1450	#define C8 175
1340		-SIG_EXPR_LIST_DECL_SINGLE(GPIOV7, GPIOV7, SIG_DESC_SET(SCUA0, 23));
1341		-SIG_EXPR_LIST_DECL_SINGLE(RMII2RXER, RMII2, RMII2_DESC);
1342		-SIG_EXPR_LIST_DECL_SINGLE(RGMII2RXD3, RGMII2);
1343		-MS_PIN_DECL_(C8, SIG_EXPR_LIST_PTR(GPIOV7), SIG_EXPR_LIST_PTR(RMII2RXER),
1344		- SIG_EXPR_LIST_PTR(RGMII2RXD3));
	1451	+SIG_EXPR_LIST_DECL_SINGLE(C8, GPIOV7, GPIOV7, SIG_DESC_SET(SCUA0, 23));
	1452	+SIG_EXPR_LIST_DECL_SINGLE(C8, RMII2RXER, RMII2, RMII2_DESC);
	1453	+SIG_EXPR_LIST_DECL_SINGLE(C8, RGMII2RXD3, RGMII2);
	1454	+PIN_DECL_(C8, SIG_EXPR_LIST_PTR(C8, GPIOV7), SIG_EXPR_LIST_PTR(C8, RMII2RXER),
	1455	+ SIG_EXPR_LIST_PTR(C8, RGMII2RXD3));
1345	1456
1346	1457	FUNC_GROUP_DECL(RMII1, A12, B12, C12, D12, E12, A13, E11, D11, C11, B11, A11,
1347	1458	E10);
..	..	@@ -1352,354 +1463,390 @@
1352	1463	FUNC_GROUP_DECL(RGMII2, D9, E9, A10, B10, C10, D10, C9, B9, A9, E8, D8, C8);
1353	1464
1354	1465	#define L5 176
1355		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW0, GPIOW0, SIG_DESC_SET(SCUA0, 24));
1356		-SIG_EXPR_LIST_DECL_SINGLE(ADC0, ADC0);
1357		-MS_PIN_DECL_(L5, SIG_EXPR_LIST_PTR(GPIOW0), SIG_EXPR_LIST_PTR(ADC0));
	1466	+SIG_EXPR_LIST_DECL_SINGLE(L5, GPIOW0, GPIOW0, SIG_DESC_SET(SCUA0, 24));
	1467	+SIG_EXPR_LIST_DECL_SINGLE(L5, ADC0, ADC0);
	1468	+PIN_DECL_(L5, SIG_EXPR_LIST_PTR(L5, GPIOW0), SIG_EXPR_LIST_PTR(L5, ADC0));
1358	1469	FUNC_GROUP_DECL(ADC0, L5);
1359	1470
1360	1471	#define L4 177
1361		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW1, GPIOW1, SIG_DESC_SET(SCUA0, 25));
1362		-SIG_EXPR_LIST_DECL_SINGLE(ADC1, ADC1);
1363		-MS_PIN_DECL_(L4, SIG_EXPR_LIST_PTR(GPIOW1), SIG_EXPR_LIST_PTR(ADC1));
	1472	+SIG_EXPR_LIST_DECL_SINGLE(L4, GPIOW1, GPIOW1, SIG_DESC_SET(SCUA0, 25));
	1473	+SIG_EXPR_LIST_DECL_SINGLE(L4, ADC1, ADC1);
	1474	+PIN_DECL_(L4, SIG_EXPR_LIST_PTR(L4, GPIOW1), SIG_EXPR_LIST_PTR(L4, ADC1));
1364	1475	FUNC_GROUP_DECL(ADC1, L4);
1365	1476
1366	1477	#define L3 178
1367		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW2, GPIOW2, SIG_DESC_SET(SCUA0, 26));
1368		-SIG_EXPR_LIST_DECL_SINGLE(ADC2, ADC2);
1369		-MS_PIN_DECL_(L3, SIG_EXPR_LIST_PTR(GPIOW2), SIG_EXPR_LIST_PTR(ADC2));
	1478	+SIG_EXPR_LIST_DECL_SINGLE(L3, GPIOW2, GPIOW2, SIG_DESC_SET(SCUA0, 26));
	1479	+SIG_EXPR_LIST_DECL_SINGLE(L3, ADC2, ADC2);
	1480	+PIN_DECL_(L3, SIG_EXPR_LIST_PTR(L3, GPIOW2), SIG_EXPR_LIST_PTR(L3, ADC2));
1370	1481	FUNC_GROUP_DECL(ADC2, L3);
1371	1482
1372	1483	#define L2 179
1373		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW3, GPIOW3, SIG_DESC_SET(SCUA0, 27));
1374		-SIG_EXPR_LIST_DECL_SINGLE(ADC3, ADC3);
1375		-MS_PIN_DECL_(L2, SIG_EXPR_LIST_PTR(GPIOW3), SIG_EXPR_LIST_PTR(ADC3));
	1484	+SIG_EXPR_LIST_DECL_SINGLE(L2, GPIOW3, GPIOW3, SIG_DESC_SET(SCUA0, 27));
	1485	+SIG_EXPR_LIST_DECL_SINGLE(L2, ADC3, ADC3);
	1486	+PIN_DECL_(L2, SIG_EXPR_LIST_PTR(L2, GPIOW3), SIG_EXPR_LIST_PTR(L2, ADC3));
1376	1487	FUNC_GROUP_DECL(ADC3, L2);
1377	1488
1378	1489	#define L1 180
1379		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW4, GPIOW4, SIG_DESC_SET(SCUA0, 28));
1380		-SIG_EXPR_LIST_DECL_SINGLE(ADC4, ADC4);
1381		-MS_PIN_DECL_(L1, SIG_EXPR_LIST_PTR(GPIOW4), SIG_EXPR_LIST_PTR(ADC4));
	1490	+SIG_EXPR_LIST_DECL_SINGLE(L1, GPIOW4, GPIOW4, SIG_DESC_SET(SCUA0, 28));
	1491	+SIG_EXPR_LIST_DECL_SINGLE(L1, ADC4, ADC4);
	1492	+PIN_DECL_(L1, SIG_EXPR_LIST_PTR(L1, GPIOW4), SIG_EXPR_LIST_PTR(L1, ADC4));
1382	1493	FUNC_GROUP_DECL(ADC4, L1);
1383	1494
1384	1495	#define M5 181
1385		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW5, GPIOW5, SIG_DESC_SET(SCUA0, 29));
1386		-SIG_EXPR_LIST_DECL_SINGLE(ADC5, ADC5);
1387		-MS_PIN_DECL_(M5, SIG_EXPR_LIST_PTR(GPIOW5), SIG_EXPR_LIST_PTR(ADC5));
	1496	+SIG_EXPR_LIST_DECL_SINGLE(M5, GPIOW5, GPIOW5, SIG_DESC_SET(SCUA0, 29));
	1497	+SIG_EXPR_LIST_DECL_SINGLE(M5, ADC5, ADC5);
	1498	+PIN_DECL_(M5, SIG_EXPR_LIST_PTR(M5, GPIOW5), SIG_EXPR_LIST_PTR(M5, ADC5));
1388	1499	FUNC_GROUP_DECL(ADC5, M5);
1389	1500
1390	1501	#define M4 182
1391		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW6, GPIOW6, SIG_DESC_SET(SCUA0, 30));
1392		-SIG_EXPR_LIST_DECL_SINGLE(ADC6, ADC6);
1393		-MS_PIN_DECL_(M4, SIG_EXPR_LIST_PTR(GPIOW6), SIG_EXPR_LIST_PTR(ADC6));
	1502	+SIG_EXPR_LIST_DECL_SINGLE(M4, GPIOW6, GPIOW6, SIG_DESC_SET(SCUA0, 30));
	1503	+SIG_EXPR_LIST_DECL_SINGLE(M4, ADC6, ADC6);
	1504	+PIN_DECL_(M4, SIG_EXPR_LIST_PTR(M4, GPIOW6), SIG_EXPR_LIST_PTR(M4, ADC6));
1394	1505	FUNC_GROUP_DECL(ADC6, M4);
1395	1506
1396	1507	#define M3 183
1397		-SIG_EXPR_LIST_DECL_SINGLE(GPIOW7, GPIOW7, SIG_DESC_SET(SCUA0, 31));
1398		-SIG_EXPR_LIST_DECL_SINGLE(ADC7, ADC7);
1399		-MS_PIN_DECL_(M3, SIG_EXPR_LIST_PTR(GPIOW7), SIG_EXPR_LIST_PTR(ADC7));
	1508	+SIG_EXPR_LIST_DECL_SINGLE(M3, GPIOW7, GPIOW7, SIG_DESC_SET(SCUA0, 31));
	1509	+SIG_EXPR_LIST_DECL_SINGLE(M3, ADC7, ADC7);
	1510	+PIN_DECL_(M3, SIG_EXPR_LIST_PTR(M3, GPIOW7), SIG_EXPR_LIST_PTR(M3, ADC7));
1400	1511	FUNC_GROUP_DECL(ADC7, M3);
1401	1512
1402	1513	#define M2 184
1403		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX0, GPIOX0, SIG_DESC_SET(SCUA4, 0));
1404		-SIG_EXPR_LIST_DECL_SINGLE(ADC8, ADC8);
1405		-MS_PIN_DECL_(M2, SIG_EXPR_LIST_PTR(GPIOX0), SIG_EXPR_LIST_PTR(ADC8));
	1514	+SIG_EXPR_LIST_DECL_SINGLE(M2, GPIOX0, GPIOX0, SIG_DESC_SET(SCUA4, 0));
	1515	+SIG_EXPR_LIST_DECL_SINGLE(M2, ADC8, ADC8);
	1516	+PIN_DECL_(M2, SIG_EXPR_LIST_PTR(M2, GPIOX0), SIG_EXPR_LIST_PTR(M2, ADC8));
1406	1517	FUNC_GROUP_DECL(ADC8, M2);
1407	1518
1408	1519	#define M1 185
1409		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX1, GPIOX1, SIG_DESC_SET(SCUA4, 1));
1410		-SIG_EXPR_LIST_DECL_SINGLE(ADC9, ADC9);
1411		-MS_PIN_DECL_(M1, SIG_EXPR_LIST_PTR(GPIOX1), SIG_EXPR_LIST_PTR(ADC9));
	1520	+SIG_EXPR_LIST_DECL_SINGLE(M1, GPIOX1, GPIOX1, SIG_DESC_SET(SCUA4, 1));
	1521	+SIG_EXPR_LIST_DECL_SINGLE(M1, ADC9, ADC9);
	1522	+PIN_DECL_(M1, SIG_EXPR_LIST_PTR(M1, GPIOX1), SIG_EXPR_LIST_PTR(M1, ADC9));
1412	1523	FUNC_GROUP_DECL(ADC9, M1);
1413	1524
1414	1525	#define N5 186
1415		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX2, GPIOX2, SIG_DESC_SET(SCUA4, 2));
1416		-SIG_EXPR_LIST_DECL_SINGLE(ADC10, ADC10);
1417		-MS_PIN_DECL_(N5, SIG_EXPR_LIST_PTR(GPIOX2), SIG_EXPR_LIST_PTR(ADC10));
	1526	+SIG_EXPR_LIST_DECL_SINGLE(N5, GPIOX2, GPIOX2, SIG_DESC_SET(SCUA4, 2));
	1527	+SIG_EXPR_LIST_DECL_SINGLE(N5, ADC10, ADC10);
	1528	+PIN_DECL_(N5, SIG_EXPR_LIST_PTR(N5, GPIOX2), SIG_EXPR_LIST_PTR(N5, ADC10));
1418	1529	FUNC_GROUP_DECL(ADC10, N5);
1419	1530
1420	1531	#define N4 187
1421		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX3, GPIOX3, SIG_DESC_SET(SCUA4, 3));
1422		-SIG_EXPR_LIST_DECL_SINGLE(ADC11, ADC11);
1423		-MS_PIN_DECL_(N4, SIG_EXPR_LIST_PTR(GPIOX3), SIG_EXPR_LIST_PTR(ADC11));
	1532	+SIG_EXPR_LIST_DECL_SINGLE(N4, GPIOX3, GPIOX3, SIG_DESC_SET(SCUA4, 3));
	1533	+SIG_EXPR_LIST_DECL_SINGLE(N4, ADC11, ADC11);
	1534	+PIN_DECL_(N4, SIG_EXPR_LIST_PTR(N4, GPIOX3), SIG_EXPR_LIST_PTR(N4, ADC11));
1424	1535	FUNC_GROUP_DECL(ADC11, N4);
1425	1536
1426	1537	#define N3 188
1427		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX4, GPIOX4, SIG_DESC_SET(SCUA4, 4));
1428		-SIG_EXPR_LIST_DECL_SINGLE(ADC12, ADC12);
1429		-MS_PIN_DECL_(N3, SIG_EXPR_LIST_PTR(GPIOX4), SIG_EXPR_LIST_PTR(ADC12));
	1538	+SIG_EXPR_LIST_DECL_SINGLE(N3, GPIOX4, GPIOX4, SIG_DESC_SET(SCUA4, 4));
	1539	+SIG_EXPR_LIST_DECL_SINGLE(N3, ADC12, ADC12);
	1540	+PIN_DECL_(N3, SIG_EXPR_LIST_PTR(N3, GPIOX4), SIG_EXPR_LIST_PTR(N3, ADC12));
1430	1541	FUNC_GROUP_DECL(ADC12, N3);
1431	1542
1432	1543	#define N2 189
1433		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX5, GPIOX5, SIG_DESC_SET(SCUA4, 5));
1434		-SIG_EXPR_LIST_DECL_SINGLE(ADC13, ADC13);
1435		-MS_PIN_DECL_(N2, SIG_EXPR_LIST_PTR(GPIOX5), SIG_EXPR_LIST_PTR(ADC13));
	1544	+SIG_EXPR_LIST_DECL_SINGLE(N2, GPIOX5, GPIOX5, SIG_DESC_SET(SCUA4, 5));
	1545	+SIG_EXPR_LIST_DECL_SINGLE(N2, ADC13, ADC13);
	1546	+PIN_DECL_(N2, SIG_EXPR_LIST_PTR(N2, GPIOX5), SIG_EXPR_LIST_PTR(N2, ADC13));
1436	1547	FUNC_GROUP_DECL(ADC13, N2);
1437	1548
1438	1549	#define N1 190
1439		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX6, GPIOX6, SIG_DESC_SET(SCUA4, 6));
1440		-SIG_EXPR_LIST_DECL_SINGLE(ADC14, ADC14);
1441		-MS_PIN_DECL_(N1, SIG_EXPR_LIST_PTR(GPIOX6), SIG_EXPR_LIST_PTR(ADC14));
	1550	+SIG_EXPR_LIST_DECL_SINGLE(N1, GPIOX6, GPIOX6, SIG_DESC_SET(SCUA4, 6));
	1551	+SIG_EXPR_LIST_DECL_SINGLE(N1, ADC14, ADC14);
	1552	+PIN_DECL_(N1, SIG_EXPR_LIST_PTR(N1, GPIOX6), SIG_EXPR_LIST_PTR(N1, ADC14));
1442	1553	FUNC_GROUP_DECL(ADC14, N1);
1443	1554
1444	1555	#define P5 191
1445		-SIG_EXPR_LIST_DECL_SINGLE(GPIOX7, GPIOX7, SIG_DESC_SET(SCUA4, 7));
1446		-SIG_EXPR_LIST_DECL_SINGLE(ADC15, ADC15);
1447		-MS_PIN_DECL_(P5, SIG_EXPR_LIST_PTR(GPIOX7), SIG_EXPR_LIST_PTR(ADC15));
	1556	+SIG_EXPR_LIST_DECL_SINGLE(P5, GPIOX7, GPIOX7, SIG_DESC_SET(SCUA4, 7));
	1557	+SIG_EXPR_LIST_DECL_SINGLE(P5, ADC15, ADC15);
	1558	+PIN_DECL_(P5, SIG_EXPR_LIST_PTR(P5, GPIOX7), SIG_EXPR_LIST_PTR(P5, ADC15));
1448	1559	FUNC_GROUP_DECL(ADC15, P5);
1449	1560
1450	1561	#define C21 192
1451		-SIG_EXPR_DECL(SIOS3, SIOS3, SIG_DESC_SET(SCUA4, 8));
1452		-SIG_EXPR_DECL(SIOS3, ACPI, ACPI_DESC);
1453		-SIG_EXPR_LIST_DECL_DUAL(SIOS3, SIOS3, ACPI);
1454		-SS_PIN_DECL(C21, GPIOY0, SIOS3);
	1562	+SIG_EXPR_DECL_SINGLE(SIOS3, SIOS3, SIG_DESC_SET(SCUA4, 8));
	1563	+SIG_EXPR_DECL_SINGLE(SIOS3, ACPI, ACPI_DESC);
	1564	+SIG_EXPR_LIST_DECL_DUAL(C21, SIOS3, SIOS3, ACPI);
	1565	+PIN_DECL_1(C21, GPIOY0, SIOS3);
1455	1566	FUNC_GROUP_DECL(SIOS3, C21);
1456	1567
1457	1568	#define F20 193
1458		-SIG_EXPR_DECL(SIOS5, SIOS5, SIG_DESC_SET(SCUA4, 9));
1459		-SIG_EXPR_DECL(SIOS5, ACPI, ACPI_DESC);
1460		-SIG_EXPR_LIST_DECL_DUAL(SIOS5, SIOS5, ACPI);
1461		-SS_PIN_DECL(F20, GPIOY1, SIOS5);
	1569	+SIG_EXPR_DECL_SINGLE(SIOS5, SIOS5, SIG_DESC_SET(SCUA4, 9));
	1570	+SIG_EXPR_DECL_SINGLE(SIOS5, ACPI, ACPI_DESC);
	1571	+SIG_EXPR_LIST_DECL_DUAL(F20, SIOS5, SIOS5, ACPI);
	1572	+PIN_DECL_1(F20, GPIOY1, SIOS5);
1462	1573	FUNC_GROUP_DECL(SIOS5, F20);
1463	1574
1464	1575	#define G20 194
1465		-SIG_EXPR_DECL(SIOPWREQ, SIOPWREQ, SIG_DESC_SET(SCUA4, 10));
1466		-SIG_EXPR_DECL(SIOPWREQ, ACPI, ACPI_DESC);
1467		-SIG_EXPR_LIST_DECL_DUAL(SIOPWREQ, SIOPWREQ, ACPI);
1468		-SS_PIN_DECL(G20, GPIOY2, SIOPWREQ);
	1576	+SIG_EXPR_DECL_SINGLE(SIOPWREQ, SIOPWREQ, SIG_DESC_SET(SCUA4, 10));
	1577	+SIG_EXPR_DECL_SINGLE(SIOPWREQ, ACPI, ACPI_DESC);
	1578	+SIG_EXPR_LIST_DECL_DUAL(G20, SIOPWREQ, SIOPWREQ, ACPI);
	1579	+PIN_DECL_1(G20, GPIOY2, SIOPWREQ);
1469	1580	FUNC_GROUP_DECL(SIOPWREQ, G20);
1470	1581
1471	1582	#define K20 195
1472		-SIG_EXPR_DECL(SIOONCTRL, SIOONCTRL, SIG_DESC_SET(SCUA4, 11));
1473		-SIG_EXPR_DECL(SIOONCTRL, ACPI, ACPI_DESC);
1474		-SIG_EXPR_LIST_DECL_DUAL(SIOONCTRL, SIOONCTRL, ACPI);
1475		-SS_PIN_DECL(K20, GPIOY3, SIOONCTRL);
	1583	+SIG_EXPR_DECL_SINGLE(SIOONCTRL, SIOONCTRL, SIG_DESC_SET(SCUA4, 11));
	1584	+SIG_EXPR_DECL_SINGLE(SIOONCTRL, ACPI, ACPI_DESC);
	1585	+SIG_EXPR_LIST_DECL_DUAL(K20, SIOONCTRL, SIOONCTRL, ACPI);
	1586	+PIN_DECL_1(K20, GPIOY3, SIOONCTRL);
1476	1587	FUNC_GROUP_DECL(SIOONCTRL, K20);
1477	1588
1478	1589	FUNC_GROUP_DECL(ACPI, B19, A20, D17, A19, C21, F20, G20, K20);
1479	1590
1480	1591	#define R22 200
1481	1592	#define R22_DESC SIG_DESC_SET(SCUA4, 16)
1482		-SIG_EXPR_DECL(ROMA2, ROM8, R22_DESC, VPOOFF0_DESC);
1483		-SIG_EXPR_DECL(ROMA2, ROM16, R22_DESC, VPOOFF0_DESC);
1484		-SIG_EXPR_LIST_DECL_DUAL(ROMA2, ROM8, ROM16);
1485		-SIG_EXPR_DECL(VPOB0, VPO12, R22_DESC, VPO12_DESC);
1486		-SIG_EXPR_DECL(VPOB0, VPO24, R22_DESC, VPO24_DESC);
1487		-SIG_EXPR_DECL(VPOB0, VPOOFF1, R22_DESC, VPOOFF1_DESC);
1488		-SIG_EXPR_LIST_DECL(VPOB0, SIG_EXPR_PTR(VPOB0, VPO12),
1489		- SIG_EXPR_PTR(VPOB0, VPO24), SIG_EXPR_PTR(VPOB0, VPOOFF1));
1490		-MS_PIN_DECL(R22, GPIOZ0, ROMA2, VPOB0);
	1593	+SIG_EXPR_DECL_SINGLE(ROMA2, ROM8, R22_DESC, VPOOFF0_DESC);
	1594	+SIG_EXPR_DECL_SINGLE(ROMA2, ROM16, R22_DESC, VPOOFF0_DESC);
	1595	+SIG_EXPR_LIST_DECL_DUAL(R22, ROMA2, ROM8, ROM16);
	1596	+SIG_EXPR_DECL_SINGLE(VPOB0, VPO12, R22_DESC, VPO12_DESC);
	1597	+SIG_EXPR_DECL_SINGLE(VPOB0, VPO24, R22_DESC, VPO24_DESC);
	1598	+SIG_EXPR_DECL_SINGLE(VPOB0, VPOOFF1, R22_DESC, VPOOFF1_DESC);
	1599	+SIG_EXPR_LIST_DECL(VPOB0, VPO,
	1600	+ SIG_EXPR_PTR(VPOB0, VPO12),
	1601	+ SIG_EXPR_PTR(VPOB0, VPO24),
	1602	+ SIG_EXPR_PTR(VPOB0, VPOOFF1));
	1603	+SIG_EXPR_LIST_ALIAS(R22, VPOB0, VPO);
	1604	+PIN_DECL_2(R22, GPIOZ0, ROMA2, VPOB0);
1491	1605
1492	1606	#define P18 201
1493	1607	#define P18_DESC SIG_DESC_SET(SCUA4, 17)
1494		-SIG_EXPR_DECL(ROMA3, ROM8, P18_DESC, VPOOFF0_DESC);
1495		-SIG_EXPR_DECL(ROMA3, ROM16, P18_DESC, VPOOFF0_DESC);
1496		-SIG_EXPR_LIST_DECL_DUAL(ROMA3, ROM8, ROM16);
1497		-SIG_EXPR_DECL(VPOB1, VPO12, P18_DESC, VPO12_DESC);
1498		-SIG_EXPR_DECL(VPOB1, VPO24, P18_DESC, VPO24_DESC);
1499		-SIG_EXPR_DECL(VPOB1, VPOOFF1, P18_DESC, VPOOFF1_DESC);
1500		-SIG_EXPR_LIST_DECL(VPOB1, SIG_EXPR_PTR(VPOB1, VPO12),
1501		- SIG_EXPR_PTR(VPOB1, VPO24), SIG_EXPR_PTR(VPOB1, VPOOFF1));
1502		-MS_PIN_DECL(P18, GPIOZ1, ROMA3, VPOB1);
	1608	+SIG_EXPR_DECL_SINGLE(ROMA3, ROM8, P18_DESC, VPOOFF0_DESC);
	1609	+SIG_EXPR_DECL_SINGLE(ROMA3, ROM16, P18_DESC, VPOOFF0_DESC);
	1610	+SIG_EXPR_LIST_DECL_DUAL(P18, ROMA3, ROM8, ROM16);
	1611	+SIG_EXPR_DECL_SINGLE(VPOB1, VPO12, P18_DESC, VPO12_DESC);
	1612	+SIG_EXPR_DECL_SINGLE(VPOB1, VPO24, P18_DESC, VPO24_DESC);
	1613	+SIG_EXPR_DECL_SINGLE(VPOB1, VPOOFF1, P18_DESC, VPOOFF1_DESC);
	1614	+SIG_EXPR_LIST_DECL(VPOB1, VPO,
	1615	+ SIG_EXPR_PTR(VPOB1, VPO12),
	1616	+ SIG_EXPR_PTR(VPOB1, VPO24),
	1617	+ SIG_EXPR_PTR(VPOB1, VPOOFF1));
	1618	+SIG_EXPR_LIST_ALIAS(P18, VPOB1, VPO);
	1619	+PIN_DECL_2(P18, GPIOZ1, ROMA3, VPOB1);
1503	1620
1504	1621	#define P19 202
1505	1622	#define P19_DESC SIG_DESC_SET(SCUA4, 18)
1506		-SIG_EXPR_DECL(ROMA4, ROM8, P19_DESC, VPOOFF0_DESC);
1507		-SIG_EXPR_DECL(ROMA4, ROM16, P19_DESC, VPOOFF0_DESC);
1508		-SIG_EXPR_LIST_DECL_DUAL(ROMA4, ROM8, ROM16);
1509		-SIG_EXPR_DECL(VPOB2, VPO12, P19_DESC, VPO12_DESC);
1510		-SIG_EXPR_DECL(VPOB2, VPO24, P19_DESC, VPO24_DESC);
1511		-SIG_EXPR_DECL(VPOB2, VPOOFF1, P19_DESC, VPOOFF1_DESC);
1512		-SIG_EXPR_LIST_DECL(VPOB2, SIG_EXPR_PTR(VPOB2, VPO12),
1513		- SIG_EXPR_PTR(VPOB2, VPO24), SIG_EXPR_PTR(VPOB2, VPOOFF1));
1514		-MS_PIN_DECL(P19, GPIOZ2, ROMA4, VPOB2);
	1623	+SIG_EXPR_DECL_SINGLE(ROMA4, ROM8, P19_DESC, VPOOFF0_DESC);
	1624	+SIG_EXPR_DECL_SINGLE(ROMA4, ROM16, P19_DESC, VPOOFF0_DESC);
	1625	+SIG_EXPR_LIST_DECL_DUAL(P19, ROMA4, ROM8, ROM16);
	1626	+SIG_EXPR_DECL_SINGLE(VPOB2, VPO12, P19_DESC, VPO12_DESC);
	1627	+SIG_EXPR_DECL_SINGLE(VPOB2, VPO24, P19_DESC, VPO24_DESC);
	1628	+SIG_EXPR_DECL_SINGLE(VPOB2, VPOOFF1, P19_DESC, VPOOFF1_DESC);
	1629	+SIG_EXPR_LIST_DECL(VPOB2, VPO,
	1630	+ SIG_EXPR_PTR(VPOB2, VPO12),
	1631	+ SIG_EXPR_PTR(VPOB2, VPO24),
	1632	+ SIG_EXPR_PTR(VPOB2, VPOOFF1));
	1633	+SIG_EXPR_LIST_ALIAS(P19, VPOB2, VPO);
	1634	+PIN_DECL_2(P19, GPIOZ2, ROMA4, VPOB2);
1515	1635
1516	1636	#define P20 203
1517	1637	#define P20_DESC SIG_DESC_SET(SCUA4, 19)
1518		-SIG_EXPR_DECL(ROMA5, ROM8, P20_DESC, VPOOFF0_DESC);
1519		-SIG_EXPR_DECL(ROMA5, ROM16, P20_DESC, VPOOFF0_DESC);
1520		-SIG_EXPR_LIST_DECL_DUAL(ROMA5, ROM8, ROM16);
1521		-SIG_EXPR_DECL(VPOB3, VPO12, P20_DESC, VPO12_DESC);
1522		-SIG_EXPR_DECL(VPOB3, VPO24, P20_DESC, VPO24_DESC);
1523		-SIG_EXPR_DECL(VPOB3, VPOOFF1, P20_DESC, VPOOFF1_DESC);
1524		-SIG_EXPR_LIST_DECL(VPOB3, SIG_EXPR_PTR(VPOB3, VPO12),
1525		- SIG_EXPR_PTR(VPOB3, VPO24), SIG_EXPR_PTR(VPOB3, VPOOFF1));
1526		-MS_PIN_DECL(P20, GPIOZ3, ROMA5, VPOB3);
	1638	+SIG_EXPR_DECL_SINGLE(ROMA5, ROM8, P20_DESC, VPOOFF0_DESC);
	1639	+SIG_EXPR_DECL_SINGLE(ROMA5, ROM16, P20_DESC, VPOOFF0_DESC);
	1640	+SIG_EXPR_LIST_DECL_DUAL(P20, ROMA5, ROM8, ROM16);
	1641	+SIG_EXPR_DECL_SINGLE(VPOB3, VPO12, P20_DESC, VPO12_DESC);
	1642	+SIG_EXPR_DECL_SINGLE(VPOB3, VPO24, P20_DESC, VPO24_DESC);
	1643	+SIG_EXPR_DECL_SINGLE(VPOB3, VPOOFF1, P20_DESC, VPOOFF1_DESC);
	1644	+SIG_EXPR_LIST_DECL(VPOB3, VPO,
	1645	+ SIG_EXPR_PTR(VPOB3, VPO12),
	1646	+ SIG_EXPR_PTR(VPOB3, VPO24),
	1647	+ SIG_EXPR_PTR(VPOB3, VPOOFF1));
	1648	+SIG_EXPR_LIST_ALIAS(P20, VPOB3, VPO);
	1649	+PIN_DECL_2(P20, GPIOZ3, ROMA5, VPOB3);
1527	1650
1528	1651	#define P21 204
1529	1652	#define P21_DESC SIG_DESC_SET(SCUA4, 20)
1530		-SIG_EXPR_DECL(ROMA6, ROM8, P21_DESC, VPOOFF0_DESC);
1531		-SIG_EXPR_DECL(ROMA6, ROM16, P21_DESC, VPOOFF0_DESC);
1532		-SIG_EXPR_LIST_DECL_DUAL(ROMA6, ROM8, ROM16);
1533		-SIG_EXPR_DECL(VPOB4, VPO12, P21_DESC, VPO12_DESC);
1534		-SIG_EXPR_DECL(VPOB4, VPO24, P21_DESC, VPO24_DESC);
1535		-SIG_EXPR_DECL(VPOB4, VPOOFF1, P21_DESC, VPOOFF1_DESC);
1536		-SIG_EXPR_LIST_DECL(VPOB4, SIG_EXPR_PTR(VPOB4, VPO12),
1537		- SIG_EXPR_PTR(VPOB4, VPO24), SIG_EXPR_PTR(VPOB4, VPOOFF1));
1538		-MS_PIN_DECL(P21, GPIOZ4, ROMA6, VPOB4);
	1653	+SIG_EXPR_DECL_SINGLE(ROMA6, ROM8, P21_DESC, VPOOFF0_DESC);
	1654	+SIG_EXPR_DECL_SINGLE(ROMA6, ROM16, P21_DESC, VPOOFF0_DESC);
	1655	+SIG_EXPR_LIST_DECL_DUAL(P21, ROMA6, ROM8, ROM16);
	1656	+SIG_EXPR_DECL_SINGLE(VPOB4, VPO12, P21_DESC, VPO12_DESC);
	1657	+SIG_EXPR_DECL_SINGLE(VPOB4, VPO24, P21_DESC, VPO24_DESC);
	1658	+SIG_EXPR_DECL_SINGLE(VPOB4, VPOOFF1, P21_DESC, VPOOFF1_DESC);
	1659	+SIG_EXPR_LIST_DECL(VPOB4, VPO,
	1660	+ SIG_EXPR_PTR(VPOB4, VPO12),
	1661	+ SIG_EXPR_PTR(VPOB4, VPO24),
	1662	+ SIG_EXPR_PTR(VPOB4, VPOOFF1));
	1663	+SIG_EXPR_LIST_ALIAS(P21, VPOB4, VPO);
	1664	+PIN_DECL_2(P21, GPIOZ4, ROMA6, VPOB4);
1539	1665
1540	1666	#define P22 205
1541	1667	#define P22_DESC SIG_DESC_SET(SCUA4, 21)
1542		-SIG_EXPR_DECL(ROMA7, ROM8, P22_DESC, VPOOFF0_DESC);
1543		-SIG_EXPR_DECL(ROMA7, ROM16, P22_DESC, VPOOFF0_DESC);
1544		-SIG_EXPR_LIST_DECL_DUAL(ROMA7, ROM8, ROM16);
1545		-SIG_EXPR_DECL(VPOB5, VPO12, P22_DESC, VPO12_DESC);
1546		-SIG_EXPR_DECL(VPOB5, VPO24, P22_DESC, VPO24_DESC);
1547		-SIG_EXPR_DECL(VPOB5, VPOOFF1, P22_DESC, VPOOFF1_DESC);
1548		-SIG_EXPR_LIST_DECL(VPOB5, SIG_EXPR_PTR(VPOB5, VPO12),
1549		- SIG_EXPR_PTR(VPOB5, VPO24), SIG_EXPR_PTR(VPOB5, VPOOFF1));
1550		-MS_PIN_DECL(P22, GPIOZ5, ROMA7, VPOB5);
	1668	+SIG_EXPR_DECL_SINGLE(ROMA7, ROM8, P22_DESC, VPOOFF0_DESC);
	1669	+SIG_EXPR_DECL_SINGLE(ROMA7, ROM16, P22_DESC, VPOOFF0_DESC);
	1670	+SIG_EXPR_LIST_DECL_DUAL(P22, ROMA7, ROM8, ROM16);
	1671	+SIG_EXPR_DECL_SINGLE(VPOB5, VPO12, P22_DESC, VPO12_DESC);
	1672	+SIG_EXPR_DECL_SINGLE(VPOB5, VPO24, P22_DESC, VPO24_DESC);
	1673	+SIG_EXPR_DECL_SINGLE(VPOB5, VPOOFF1, P22_DESC, VPOOFF1_DESC);
	1674	+SIG_EXPR_LIST_DECL(VPOB5, VPO,
	1675	+ SIG_EXPR_PTR(VPOB5, VPO12),
	1676	+ SIG_EXPR_PTR(VPOB5, VPO24),
	1677	+ SIG_EXPR_PTR(VPOB5, VPOOFF1));
	1678	+SIG_EXPR_LIST_ALIAS(P22, VPOB5, VPO);
	1679	+PIN_DECL_2(P22, GPIOZ5, ROMA7, VPOB5);
1551	1680
1552	1681	#define M19 206
1553	1682	#define M19_DESC SIG_DESC_SET(SCUA4, 22)
1554		-SIG_EXPR_DECL(ROMA8, ROM8, M19_DESC, VPOOFF0_DESC);
1555		-SIG_EXPR_DECL(ROMA8, ROM16, M19_DESC, VPOOFF0_DESC);
1556		-SIG_EXPR_LIST_DECL_DUAL(ROMA8, ROM8, ROM16);
1557		-SIG_EXPR_DECL(VPOB6, VPO12, M19_DESC, VPO12_DESC);
1558		-SIG_EXPR_DECL(VPOB6, VPO24, M19_DESC, VPO24_DESC);
1559		-SIG_EXPR_DECL(VPOB6, VPOOFF1, M19_DESC, VPOOFF1_DESC);
1560		-SIG_EXPR_LIST_DECL(VPOB6, SIG_EXPR_PTR(VPOB6, VPO12),
1561		- SIG_EXPR_PTR(VPOB6, VPO24), SIG_EXPR_PTR(VPOB6, VPOOFF1));
1562		-MS_PIN_DECL(M19, GPIOZ6, ROMA8, VPOB6);
	1683	+SIG_EXPR_DECL_SINGLE(ROMA8, ROM8, M19_DESC, VPOOFF0_DESC);
	1684	+SIG_EXPR_DECL_SINGLE(ROMA8, ROM16, M19_DESC, VPOOFF0_DESC);
	1685	+SIG_EXPR_LIST_DECL_DUAL(M19, ROMA8, ROM8, ROM16);
	1686	+SIG_EXPR_DECL_SINGLE(VPOB6, VPO12, M19_DESC, VPO12_DESC);
	1687	+SIG_EXPR_DECL_SINGLE(VPOB6, VPO24, M19_DESC, VPO24_DESC);
	1688	+SIG_EXPR_DECL_SINGLE(VPOB6, VPOOFF1, M19_DESC, VPOOFF1_DESC);
	1689	+SIG_EXPR_LIST_DECL(VPOB6, VPO,
	1690	+ SIG_EXPR_PTR(VPOB6, VPO12),
	1691	+ SIG_EXPR_PTR(VPOB6, VPO24),
	1692	+ SIG_EXPR_PTR(VPOB6, VPOOFF1));
	1693	+SIG_EXPR_LIST_ALIAS(M19, VPOB6, VPO);
	1694	+PIN_DECL_2(M19, GPIOZ6, ROMA8, VPOB6);
1563	1695
1564	1696	#define M20 207
1565	1697	#define M20_DESC SIG_DESC_SET(SCUA4, 23)
1566		-SIG_EXPR_DECL(ROMA9, ROM8, M20_DESC, VPOOFF0_DESC);
1567		-SIG_EXPR_DECL(ROMA9, ROM16, M20_DESC, VPOOFF0_DESC);
1568		-SIG_EXPR_LIST_DECL_DUAL(ROMA9, ROM8, ROM16);
1569		-SIG_EXPR_DECL(VPOB7, VPO12, M20_DESC, VPO12_DESC);
1570		-SIG_EXPR_DECL(VPOB7, VPO24, M20_DESC, VPO24_DESC);
1571		-SIG_EXPR_DECL(VPOB7, VPOOFF1, M20_DESC, VPOOFF1_DESC);
1572		-SIG_EXPR_LIST_DECL(VPOB7, SIG_EXPR_PTR(VPOB7, VPO12),
1573		- SIG_EXPR_PTR(VPOB7, VPO24), SIG_EXPR_PTR(VPOB7, VPOOFF1));
1574		-MS_PIN_DECL(M20, GPIOZ7, ROMA9, VPOB7);
	1698	+SIG_EXPR_DECL_SINGLE(ROMA9, ROM8, M20_DESC, VPOOFF0_DESC);
	1699	+SIG_EXPR_DECL_SINGLE(ROMA9, ROM16, M20_DESC, VPOOFF0_DESC);
	1700	+SIG_EXPR_LIST_DECL_DUAL(M20, ROMA9, ROM8, ROM16);
	1701	+SIG_EXPR_DECL_SINGLE(VPOB7, VPO12, M20_DESC, VPO12_DESC);
	1702	+SIG_EXPR_DECL_SINGLE(VPOB7, VPO24, M20_DESC, VPO24_DESC);
	1703	+SIG_EXPR_DECL_SINGLE(VPOB7, VPOOFF1, M20_DESC, VPOOFF1_DESC);
	1704	+SIG_EXPR_LIST_DECL(VPOB7, VPO,
	1705	+ SIG_EXPR_PTR(VPOB7, VPO12),
	1706	+ SIG_EXPR_PTR(VPOB7, VPO24),
	1707	+ SIG_EXPR_PTR(VPOB7, VPOOFF1));
	1708	+SIG_EXPR_LIST_ALIAS(M20, VPOB7, VPO);
	1709	+PIN_DECL_2(M20, GPIOZ7, ROMA9, VPOB7);
1575	1710
1576	1711	#define M21 208
1577	1712	#define M21_DESC SIG_DESC_SET(SCUA4, 24)
1578		-SIG_EXPR_DECL(ROMA10, ROM8, M21_DESC, VPOOFF0_DESC);
1579		-SIG_EXPR_DECL(ROMA10, ROM16, M21_DESC, VPOOFF0_DESC);
1580		-SIG_EXPR_LIST_DECL_DUAL(ROMA10, ROM8, ROM16);
1581		-SIG_EXPR_DECL(VPOG0, VPO12, M21_DESC, VPO12_DESC);
1582		-SIG_EXPR_DECL(VPOG0, VPO24, M21_DESC, VPO24_DESC);
1583		-SIG_EXPR_DECL(VPOG0, VPOOFF1, M21_DESC, VPOOFF1_DESC);
1584		-SIG_EXPR_LIST_DECL(VPOG0, SIG_EXPR_PTR(VPOG0, VPO12),
1585		- SIG_EXPR_PTR(VPOG0, VPO24), SIG_EXPR_PTR(VPOG0, VPOOFF1));
1586		-MS_PIN_DECL(M21, GPIOAA0, ROMA10, VPOG0);
	1713	+SIG_EXPR_DECL_SINGLE(ROMA10, ROM8, M21_DESC, VPOOFF0_DESC);
	1714	+SIG_EXPR_DECL_SINGLE(ROMA10, ROM16, M21_DESC, VPOOFF0_DESC);
	1715	+SIG_EXPR_LIST_DECL_DUAL(M21, ROMA10, ROM8, ROM16);
	1716	+SIG_EXPR_DECL_SINGLE(VPOG0, VPO12, M21_DESC, VPO12_DESC);
	1717	+SIG_EXPR_DECL_SINGLE(VPOG0, VPO24, M21_DESC, VPO24_DESC);
	1718	+SIG_EXPR_DECL_SINGLE(VPOG0, VPOOFF1, M21_DESC, VPOOFF1_DESC);
	1719	+SIG_EXPR_LIST_DECL(VPOG0, VPO,
	1720	+ SIG_EXPR_PTR(VPOG0, VPO12),
	1721	+ SIG_EXPR_PTR(VPOG0, VPO24),
	1722	+ SIG_EXPR_PTR(VPOG0, VPOOFF1));
	1723	+SIG_EXPR_LIST_ALIAS(M21, VPOG0, VPO);
	1724	+PIN_DECL_2(M21, GPIOAA0, ROMA10, VPOG0);
1587	1725
1588	1726	#define M22 209
1589	1727	#define M22_DESC SIG_DESC_SET(SCUA4, 25)
1590		-SIG_EXPR_DECL(ROMA11, ROM8, M22_DESC, VPOOFF0_DESC);
1591		-SIG_EXPR_DECL(ROMA11, ROM16, M22_DESC, VPOOFF0_DESC);
1592		-SIG_EXPR_LIST_DECL_DUAL(ROMA11, ROM8, ROM16);
1593		-SIG_EXPR_DECL(VPOG1, VPO12, M22_DESC, VPO12_DESC);
1594		-SIG_EXPR_DECL(VPOG1, VPO24, M22_DESC, VPO24_DESC);
1595		-SIG_EXPR_DECL(VPOG1, VPOOFF1, M22_DESC, VPOOFF1_DESC);
1596		-SIG_EXPR_LIST_DECL(VPOG1, SIG_EXPR_PTR(VPOG1, VPO12),
1597		- SIG_EXPR_PTR(VPOG1, VPO24), SIG_EXPR_PTR(VPOG1, VPOOFF1));
1598		-MS_PIN_DECL(M22, GPIOAA1, ROMA11, VPOG1);
	1728	+SIG_EXPR_DECL_SINGLE(ROMA11, ROM8, M22_DESC, VPOOFF0_DESC);
	1729	+SIG_EXPR_DECL_SINGLE(ROMA11, ROM16, M22_DESC, VPOOFF0_DESC);
	1730	+SIG_EXPR_LIST_DECL_DUAL(M22, ROMA11, ROM8, ROM16);
	1731	+SIG_EXPR_DECL_SINGLE(VPOG1, VPO12, M22_DESC, VPO12_DESC);
	1732	+SIG_EXPR_DECL_SINGLE(VPOG1, VPO24, M22_DESC, VPO24_DESC);
	1733	+SIG_EXPR_DECL_SINGLE(VPOG1, VPOOFF1, M22_DESC, VPOOFF1_DESC);
	1734	+SIG_EXPR_LIST_DECL(VPOG1, VPO,
	1735	+ SIG_EXPR_PTR(VPOG1, VPO12),
	1736	+ SIG_EXPR_PTR(VPOG1, VPO24),
	1737	+ SIG_EXPR_PTR(VPOG1, VPOOFF1));
	1738	+SIG_EXPR_LIST_ALIAS(M22, VPOG1, VPO);
	1739	+PIN_DECL_2(M22, GPIOAA1, ROMA11, VPOG1);
1599	1740
1600	1741	#define L18 210
1601	1742	#define L18_DESC SIG_DESC_SET(SCUA4, 26)
1602		-SIG_EXPR_DECL(ROMA12, ROM8, L18_DESC, VPOOFF0_DESC);
1603		-SIG_EXPR_DECL(ROMA12, ROM16, L18_DESC, VPOOFF0_DESC);
1604		-SIG_EXPR_LIST_DECL_DUAL(ROMA12, ROM8, ROM16);
1605		-SIG_EXPR_DECL(VPOG2, VPO12, L18_DESC, VPO12_DESC);
1606		-SIG_EXPR_DECL(VPOG2, VPO24, L18_DESC, VPO24_DESC);
1607		-SIG_EXPR_DECL(VPOG2, VPOOFF1, L18_DESC, VPOOFF1_DESC);
1608		-SIG_EXPR_LIST_DECL(VPOG2, SIG_EXPR_PTR(VPOG2, VPO12),
1609		- SIG_EXPR_PTR(VPOG2, VPO24), SIG_EXPR_PTR(VPOG2, VPOOFF1));
1610		-MS_PIN_DECL(L18, GPIOAA2, ROMA12, VPOG2);
	1743	+SIG_EXPR_DECL_SINGLE(ROMA12, ROM8, L18_DESC, VPOOFF0_DESC);
	1744	+SIG_EXPR_DECL_SINGLE(ROMA12, ROM16, L18_DESC, VPOOFF0_DESC);
	1745	+SIG_EXPR_LIST_DECL_DUAL(L18, ROMA12, ROM8, ROM16);
	1746	+SIG_EXPR_DECL_SINGLE(VPOG2, VPO12, L18_DESC, VPO12_DESC);
	1747	+SIG_EXPR_DECL_SINGLE(VPOG2, VPO24, L18_DESC, VPO24_DESC);
	1748	+SIG_EXPR_DECL_SINGLE(VPOG2, VPOOFF1, L18_DESC, VPOOFF1_DESC);
	1749	+SIG_EXPR_LIST_DECL(VPOG2, VPO,
	1750	+ SIG_EXPR_PTR(VPOG2, VPO12),
	1751	+ SIG_EXPR_PTR(VPOG2, VPO24),
	1752	+ SIG_EXPR_PTR(VPOG2, VPOOFF1));
	1753	+SIG_EXPR_LIST_ALIAS(L18, VPOG2, VPO);
	1754	+PIN_DECL_2(L18, GPIOAA2, ROMA12, VPOG2);
1611	1755
1612	1756	#define L19 211
1613	1757	#define L19_DESC SIG_DESC_SET(SCUA4, 27)
1614		-SIG_EXPR_DECL(ROMA13, ROM8, L19_DESC, VPOOFF0_DESC);
1615		-SIG_EXPR_DECL(ROMA13, ROM16, L19_DESC, VPOOFF0_DESC);
1616		-SIG_EXPR_LIST_DECL_DUAL(ROMA13, ROM8, ROM16);
1617		-SIG_EXPR_DECL(VPOG3, VPO12, L19_DESC, VPO12_DESC);
1618		-SIG_EXPR_DECL(VPOG3, VPO24, L19_DESC, VPO24_DESC);
1619		-SIG_EXPR_DECL(VPOG3, VPOOFF1, L19_DESC, VPOOFF1_DESC);
1620		-SIG_EXPR_LIST_DECL(VPOG3, SIG_EXPR_PTR(VPOG3, VPO12),
1621		- SIG_EXPR_PTR(VPOG3, VPO24), SIG_EXPR_PTR(VPOG3, VPOOFF1));
1622		-MS_PIN_DECL(L19, GPIOAA3, ROMA13, VPOG3);
	1758	+SIG_EXPR_DECL_SINGLE(ROMA13, ROM8, L19_DESC, VPOOFF0_DESC);
	1759	+SIG_EXPR_DECL_SINGLE(ROMA13, ROM16, L19_DESC, VPOOFF0_DESC);
	1760	+SIG_EXPR_LIST_DECL_DUAL(L19, ROMA13, ROM8, ROM16);
	1761	+SIG_EXPR_DECL_SINGLE(VPOG3, VPO12, L19_DESC, VPO12_DESC);
	1762	+SIG_EXPR_DECL_SINGLE(VPOG3, VPO24, L19_DESC, VPO24_DESC);
	1763	+SIG_EXPR_DECL_SINGLE(VPOG3, VPOOFF1, L19_DESC, VPOOFF1_DESC);
	1764	+SIG_EXPR_LIST_DECL(VPOG3, VPO,
	1765	+ SIG_EXPR_PTR(VPOG3, VPO12),
	1766	+ SIG_EXPR_PTR(VPOG3, VPO24),
	1767	+ SIG_EXPR_PTR(VPOG3, VPOOFF1));
	1768	+SIG_EXPR_LIST_ALIAS(L19, VPOG3, VPO);
	1769	+PIN_DECL_2(L19, GPIOAA3, ROMA13, VPOG3);
1623	1770
1624	1771	#define L20 212
1625	1772	#define L20_DESC SIG_DESC_SET(SCUA4, 28)
1626		-SIG_EXPR_DECL(ROMA14, ROM8, L20_DESC, VPO_OFF_12);
1627		-SIG_EXPR_DECL(ROMA14, ROM16, L20_DESC, VPO_OFF_12);
1628		-SIG_EXPR_LIST_DECL_DUAL(ROMA14, ROM8, ROM16);
1629		-SIG_EXPR_DECL(VPOG4, VPO24, L20_DESC, VPO24_DESC);
1630		-SIG_EXPR_DECL(VPOG4, VPOOFF1, L20_DESC, VPOOFF1_DESC);
1631		-SIG_EXPR_LIST_DECL_DUAL(VPOG4, VPO24, VPOOFF1);
1632		-MS_PIN_DECL(L20, GPIOAA4, ROMA14, VPOG4);
	1773	+SIG_EXPR_DECL_SINGLE(ROMA14, ROM8, L20_DESC, VPO_OFF_12);
	1774	+SIG_EXPR_DECL_SINGLE(ROMA14, ROM16, L20_DESC, VPO_OFF_12);
	1775	+SIG_EXPR_LIST_DECL_DUAL(L20, ROMA14, ROM8, ROM16);
	1776	+SIG_EXPR_DECL_SINGLE(VPOG4, VPO24, L20_DESC, VPO24_DESC);
	1777	+SIG_EXPR_DECL_SINGLE(VPOG4, VPOOFF1, L20_DESC, VPOOFF1_DESC);
	1778	+SIG_EXPR_LIST_DECL_DUAL(L20, VPOG4, VPO24, VPOOFF1);
	1779	+PIN_DECL_2(L20, GPIOAA4, ROMA14, VPOG4);
1633	1780
1634	1781	#define L21 213
1635	1782	#define L21_DESC SIG_DESC_SET(SCUA4, 29)
1636		-SIG_EXPR_DECL(ROMA15, ROM8, L21_DESC, VPO_OFF_12);
1637		-SIG_EXPR_DECL(ROMA15, ROM16, L21_DESC, VPO_OFF_12);
1638		-SIG_EXPR_LIST_DECL_DUAL(ROMA15, ROM8, ROM16);
1639		-SIG_EXPR_DECL(VPOG5, VPO24, L21_DESC, VPO24_DESC);
1640		-SIG_EXPR_DECL(VPOG5, VPOOFF1, L21_DESC, VPOOFF1_DESC);
1641		-SIG_EXPR_LIST_DECL_DUAL(VPOG5, VPO24, VPOOFF1);
1642		-MS_PIN_DECL(L21, GPIOAA5, ROMA15, VPOG5);
	1783	+SIG_EXPR_DECL_SINGLE(ROMA15, ROM8, L21_DESC, VPO_OFF_12);
	1784	+SIG_EXPR_DECL_SINGLE(ROMA15, ROM16, L21_DESC, VPO_OFF_12);
	1785	+SIG_EXPR_LIST_DECL_DUAL(L21, ROMA15, ROM8, ROM16);
	1786	+SIG_EXPR_DECL_SINGLE(VPOG5, VPO24, L21_DESC, VPO24_DESC);
	1787	+SIG_EXPR_DECL_SINGLE(VPOG5, VPOOFF1, L21_DESC, VPOOFF1_DESC);
	1788	+SIG_EXPR_LIST_DECL_DUAL(L21, VPOG5, VPO24, VPOOFF1);
	1789	+PIN_DECL_2(L21, GPIOAA5, ROMA15, VPOG5);
1643	1790
1644	1791	#define T18 214
1645	1792	#define T18_DESC SIG_DESC_SET(SCUA4, 30)
1646		-SIG_EXPR_DECL(ROMA16, ROM8, T18_DESC, VPO_OFF_12);
1647		-SIG_EXPR_DECL(ROMA16, ROM16, T18_DESC, VPO_OFF_12);
1648		-SIG_EXPR_LIST_DECL_DUAL(ROMA16, ROM8, ROM16);
1649		-SIG_EXPR_DECL(VPOG6, VPO24, T18_DESC, VPO24_DESC);
1650		-SIG_EXPR_DECL(VPOG6, VPOOFF1, T18_DESC, VPOOFF1_DESC);
1651		-SIG_EXPR_LIST_DECL_DUAL(VPOG6, VPO24, VPOOFF1);
1652		-MS_PIN_DECL(T18, GPIOAA6, ROMA16, VPOG6);
	1793	+SIG_EXPR_DECL_SINGLE(ROMA16, ROM8, T18_DESC, VPO_OFF_12);
	1794	+SIG_EXPR_DECL_SINGLE(ROMA16, ROM16, T18_DESC, VPO_OFF_12);
	1795	+SIG_EXPR_LIST_DECL_DUAL(T18, ROMA16, ROM8, ROM16);
	1796	+SIG_EXPR_DECL_SINGLE(VPOG6, VPO24, T18_DESC, VPO24_DESC);
	1797	+SIG_EXPR_DECL_SINGLE(VPOG6, VPOOFF1, T18_DESC, VPOOFF1_DESC);
	1798	+SIG_EXPR_LIST_DECL_DUAL(T18, VPOG6, VPO24, VPOOFF1);
	1799	+PIN_DECL_2(T18, GPIOAA6, ROMA16, VPOG6);
1653	1800
1654	1801	#define N18 215
1655	1802	#define N18_DESC SIG_DESC_SET(SCUA4, 31)
1656		-SIG_EXPR_DECL(ROMA17, ROM8, N18_DESC, VPO_OFF_12);
1657		-SIG_EXPR_DECL(ROMA17, ROM16, N18_DESC, VPO_OFF_12);
1658		-SIG_EXPR_LIST_DECL_DUAL(ROMA17, ROM8, ROM16);
1659		-SIG_EXPR_DECL(VPOG7, VPO24, N18_DESC, VPO24_DESC);
1660		-SIG_EXPR_DECL(VPOG7, VPOOFF1, N18_DESC, VPOOFF1_DESC);
1661		-SIG_EXPR_LIST_DECL_DUAL(VPOG7, VPO24, VPOOFF1);
1662		-MS_PIN_DECL(N18, GPIOAA7, ROMA17, VPOG7);
	1803	+SIG_EXPR_DECL_SINGLE(ROMA17, ROM8, N18_DESC, VPO_OFF_12);
	1804	+SIG_EXPR_DECL_SINGLE(ROMA17, ROM16, N18_DESC, VPO_OFF_12);
	1805	+SIG_EXPR_LIST_DECL_DUAL(N18, ROMA17, ROM8, ROM16);
	1806	+SIG_EXPR_DECL_SINGLE(VPOG7, VPO24, N18_DESC, VPO24_DESC);
	1807	+SIG_EXPR_DECL_SINGLE(VPOG7, VPOOFF1, N18_DESC, VPOOFF1_DESC);
	1808	+SIG_EXPR_LIST_DECL_DUAL(N18, VPOG7, VPO24, VPOOFF1);
	1809	+PIN_DECL_2(N18, GPIOAA7, ROMA17, VPOG7);
1663	1810
1664	1811	#define N19 216
1665	1812	#define N19_DESC SIG_DESC_SET(SCUA8, 0)
1666		-SIG_EXPR_DECL(ROMA18, ROM8, N19_DESC, VPO_OFF_12);
1667		-SIG_EXPR_DECL(ROMA18, ROM16, N19_DESC, VPO_OFF_12);
1668		-SIG_EXPR_LIST_DECL_DUAL(ROMA18, ROM8, ROM16);
1669		-SIG_EXPR_DECL(VPOR0, VPO24, N19_DESC, VPO24_DESC);
1670		-SIG_EXPR_DECL(VPOR0, VPOOFF1, N19_DESC, VPOOFF1_DESC);
1671		-SIG_EXPR_LIST_DECL_DUAL(VPOR0, VPO24, VPOOFF1);
1672		-MS_PIN_DECL(N19, GPIOAB0, ROMA18, VPOR0);
	1813	+SIG_EXPR_DECL_SINGLE(ROMA18, ROM8, N19_DESC, VPO_OFF_12);
	1814	+SIG_EXPR_DECL_SINGLE(ROMA18, ROM16, N19_DESC, VPO_OFF_12);
	1815	+SIG_EXPR_LIST_DECL_DUAL(N19, ROMA18, ROM8, ROM16);
	1816	+SIG_EXPR_DECL_SINGLE(VPOR0, VPO24, N19_DESC, VPO24_DESC);
	1817	+SIG_EXPR_DECL_SINGLE(VPOR0, VPOOFF1, N19_DESC, VPOOFF1_DESC);
	1818	+SIG_EXPR_LIST_DECL_DUAL(N19, VPOR0, VPO24, VPOOFF1);
	1819	+PIN_DECL_2(N19, GPIOAB0, ROMA18, VPOR0);
1673	1820
1674	1821	#define M18 217
1675	1822	#define M18_DESC SIG_DESC_SET(SCUA8, 1)
1676		-SIG_EXPR_DECL(ROMA19, ROM8, M18_DESC, VPO_OFF_12);
1677		-SIG_EXPR_DECL(ROMA19, ROM16, M18_DESC, VPO_OFF_12);
1678		-SIG_EXPR_LIST_DECL_DUAL(ROMA19, ROM8, ROM16);
1679		-SIG_EXPR_DECL(VPOR1, VPO24, M18_DESC, VPO24_DESC);
1680		-SIG_EXPR_DECL(VPOR1, VPOOFF1, M18_DESC, VPOOFF1_DESC);
1681		-SIG_EXPR_LIST_DECL_DUAL(VPOR1, VPO24, VPOOFF1);
1682		-MS_PIN_DECL(M18, GPIOAB1, ROMA19, VPOR1);
	1823	+SIG_EXPR_DECL_SINGLE(ROMA19, ROM8, M18_DESC, VPO_OFF_12);
	1824	+SIG_EXPR_DECL_SINGLE(ROMA19, ROM16, M18_DESC, VPO_OFF_12);
	1825	+SIG_EXPR_LIST_DECL_DUAL(M18, ROMA19, ROM8, ROM16);
	1826	+SIG_EXPR_DECL_SINGLE(VPOR1, VPO24, M18_DESC, VPO24_DESC);
	1827	+SIG_EXPR_DECL_SINGLE(VPOR1, VPOOFF1, M18_DESC, VPOOFF1_DESC);
	1828	+SIG_EXPR_LIST_DECL_DUAL(M18, VPOR1, VPO24, VPOOFF1);
	1829	+PIN_DECL_2(M18, GPIOAB1, ROMA19, VPOR1);
1683	1830
1684	1831	#define N22 218
1685	1832	#define N22_DESC SIG_DESC_SET(SCUA8, 2)
1686		-SIG_EXPR_DECL(ROMA20, ROM8, N22_DESC, VPO_OFF_12);
1687		-SIG_EXPR_DECL(ROMA20, ROM16, N22_DESC, VPO_OFF_12);
1688		-SIG_EXPR_LIST_DECL_DUAL(ROMA20, ROM8, ROM16);
1689		-SIG_EXPR_DECL(VPOR2, VPO24, N22_DESC, VPO24_DESC);
1690		-SIG_EXPR_DECL(VPOR2, VPOOFF1, N22_DESC, VPOOFF1_DESC);
1691		-SIG_EXPR_LIST_DECL_DUAL(VPOR2, VPO24, VPOOFF1);
1692		-MS_PIN_DECL(N22, GPIOAB2, ROMA20, VPOR2);
	1833	+SIG_EXPR_DECL_SINGLE(ROMA20, ROM8, N22_DESC, VPO_OFF_12);
	1834	+SIG_EXPR_DECL_SINGLE(ROMA20, ROM16, N22_DESC, VPO_OFF_12);
	1835	+SIG_EXPR_LIST_DECL_DUAL(N22, ROMA20, ROM8, ROM16);
	1836	+SIG_EXPR_DECL_SINGLE(VPOR2, VPO24, N22_DESC, VPO24_DESC);
	1837	+SIG_EXPR_DECL_SINGLE(VPOR2, VPOOFF1, N22_DESC, VPOOFF1_DESC);
	1838	+SIG_EXPR_LIST_DECL_DUAL(N22, VPOR2, VPO24, VPOOFF1);
	1839	+PIN_DECL_2(N22, GPIOAB2, ROMA20, VPOR2);
1693	1840
1694	1841	#define N20 219
1695	1842	#define N20_DESC SIG_DESC_SET(SCUA8, 3)
1696		-SIG_EXPR_DECL(ROMA21, ROM8, N20_DESC, VPO_OFF_12);
1697		-SIG_EXPR_DECL(ROMA21, ROM16, N20_DESC, VPO_OFF_12);
1698		-SIG_EXPR_LIST_DECL_DUAL(ROMA21, ROM8, ROM16);
1699		-SIG_EXPR_DECL(VPOR3, VPO24, N20_DESC, VPO24_DESC);
1700		-SIG_EXPR_DECL(VPOR3, VPOOFF1, N20_DESC, VPOOFF1_DESC);
1701		-SIG_EXPR_LIST_DECL_DUAL(VPOR3, VPO24, VPOOFF1);
1702		-MS_PIN_DECL(N20, GPIOAB3, ROMA21, VPOR3);
	1843	+SIG_EXPR_DECL_SINGLE(ROMA21, ROM8, N20_DESC, VPO_OFF_12);
	1844	+SIG_EXPR_DECL_SINGLE(ROMA21, ROM16, N20_DESC, VPO_OFF_12);
	1845	+SIG_EXPR_LIST_DECL_DUAL(N20, ROMA21, ROM8, ROM16);
	1846	+SIG_EXPR_DECL_SINGLE(VPOR3, VPO24, N20_DESC, VPO24_DESC);
	1847	+SIG_EXPR_DECL_SINGLE(VPOR3, VPOOFF1, N20_DESC, VPOOFF1_DESC);
	1848	+SIG_EXPR_LIST_DECL_DUAL(N20, VPOR3, VPO24, VPOOFF1);
	1849	+PIN_DECL_2(N20, GPIOAB3, ROMA21, VPOR3);
1703	1850
1704	1851	FUNC_GROUP_DECL(ROM8, V20, U21, T19, V22, U20, R18, N21, L22, K18, W21, Y22,
1705	1852	U19, R22, P18, P19, P20, P21, P22, M19, M20, M21, M22, L18,
..	..	@@ -1718,14 +1865,16 @@
1718	1865	#define USB11D1_DESC SIG_DESC_BIT(SCU90, 3, 0)
1719	1866
1720	1867	#define K4 220
1721		-SIG_EXPR_LIST_DECL_SINGLE(USB11HDP2, USB11H2, USB11H2_DESC);
1722		-SIG_EXPR_LIST_DECL_SINGLE(USB11DP1, USB11D1, USB11D1_DESC);
1723		-MS_PIN_DECL_(K4, SIG_EXPR_LIST_PTR(USB11HDP2), SIG_EXPR_LIST_PTR(USB11DP1));
	1868	+SIG_EXPR_LIST_DECL_SINGLE(K4, USB11HDP2, USB11H2, USB11H2_DESC);
	1869	+SIG_EXPR_LIST_DECL_SINGLE(K4, USB11DP1, USB11D1, USB11D1_DESC);
	1870	+PIN_DECL_(K4, SIG_EXPR_LIST_PTR(K4, USB11HDP2),
	1871	+ SIG_EXPR_LIST_PTR(K4, USB11DP1));
1724	1872
1725	1873	#define K3 221
1726		-SIG_EXPR_LIST_DECL_SINGLE(USB11HDN1, USB11H2, USB11H2_DESC);
1727		-SIG_EXPR_LIST_DECL_SINGLE(USB11DDN1, USB11D1, USB11D1_DESC);
1728		-MS_PIN_DECL_(K3, SIG_EXPR_LIST_PTR(USB11HDN1), SIG_EXPR_LIST_PTR(USB11DDN1));
	1874	+SIG_EXPR_LIST_DECL_SINGLE(K3, USB11HDN1, USB11H2, USB11H2_DESC);
	1875	+SIG_EXPR_LIST_DECL_SINGLE(K3, USB11DDN1, USB11D1, USB11D1_DESC);
	1876	+PIN_DECL_(K3, SIG_EXPR_LIST_PTR(K3, USB11HDN1),
	1877	+ SIG_EXPR_LIST_PTR(K3, USB11DDN1));
1729	1878
1730	1879	FUNC_GROUP_DECL(USB11H2, K4, K3);
1731	1880	FUNC_GROUP_DECL(USB11D1, K4, K3);
..	..	@@ -1734,14 +1883,16 @@
1734	1883	#define USB2D1_DESC SIG_DESC_BIT(SCU90, 29, 0)
1735	1884
1736	1885	#define AB21 222
1737		-SIG_EXPR_LIST_DECL_SINGLE(USB2HDP1, USB2H1, USB2H1_DESC);
1738		-SIG_EXPR_LIST_DECL_SINGLE(USB2DDP1, USB2D1, USB2D1_DESC);
1739		-MS_PIN_DECL_(AB21, SIG_EXPR_LIST_PTR(USB2HDP1), SIG_EXPR_LIST_PTR(USB2DDP1));
	1886	+SIG_EXPR_LIST_DECL_SINGLE(AB21, USB2HDP1, USB2H1, USB2H1_DESC);
	1887	+SIG_EXPR_LIST_DECL_SINGLE(AB21, USB2DDP1, USB2D1, USB2D1_DESC);
	1888	+PIN_DECL_(AB21, SIG_EXPR_LIST_PTR(AB21, USB2HDP1),
	1889	+ SIG_EXPR_LIST_PTR(AB21, USB2DDP1));
1740	1890
1741	1891	#define AB20 223
1742		-SIG_EXPR_LIST_DECL_SINGLE(USB2HDN1, USB2H1, USB2H1_DESC);
1743		-SIG_EXPR_LIST_DECL_SINGLE(USB2DDN1, USB2D1, USB2D1_DESC);
1744		-MS_PIN_DECL_(AB20, SIG_EXPR_LIST_PTR(USB2HDN1), SIG_EXPR_LIST_PTR(USB2DDN1));
	1892	+SIG_EXPR_LIST_DECL_SINGLE(AB20, USB2HDN1, USB2H1, USB2H1_DESC);
	1893	+SIG_EXPR_LIST_DECL_SINGLE(AB20, USB2DDN1, USB2D1, USB2D1_DESC);
	1894	+PIN_DECL_(AB20, SIG_EXPR_LIST_PTR(AB20, USB2HDN1),
	1895	+ SIG_EXPR_LIST_PTR(AB20, USB2DDN1));
1745	1896
1746	1897	FUNC_GROUP_DECL(USB2H1, AB21, AB20);
1747	1898	FUNC_GROUP_DECL(USB2D1, AB21, AB20);
..	..	@@ -2288,88 +2439,88 @@
2288	2439
2289	2440	static const struct aspeed_pin_config aspeed_g4_configs[] = {
2290	2441	/* GPIO banks ranges [A, B], [D, J], [M, R] */
2291		- { PIN_CONFIG_BIAS_PULL_DOWN, { D6, D5 }, SCU8C, 16 },
2292		- { PIN_CONFIG_BIAS_DISABLE, { D6, D5 }, SCU8C, 16 },
2293		- { PIN_CONFIG_BIAS_PULL_DOWN, { J21, E18 }, SCU8C, 17 },
2294		- { PIN_CONFIG_BIAS_DISABLE, { J21, E18 }, SCU8C, 17 },
2295		- { PIN_CONFIG_BIAS_PULL_DOWN, { A18, E15 }, SCU8C, 19 },
2296		- { PIN_CONFIG_BIAS_DISABLE, { A18, E15 }, SCU8C, 19 },
2297		- { PIN_CONFIG_BIAS_PULL_DOWN, { D15, B14 }, SCU8C, 20 },
2298		- { PIN_CONFIG_BIAS_DISABLE, { D15, B14 }, SCU8C, 20 },
2299		- { PIN_CONFIG_BIAS_PULL_DOWN, { D18, C17 }, SCU8C, 21 },
2300		- { PIN_CONFIG_BIAS_DISABLE, { D18, C17 }, SCU8C, 21 },
2301		- { PIN_CONFIG_BIAS_PULL_DOWN, { A14, U18 }, SCU8C, 22 },
2302		- { PIN_CONFIG_BIAS_DISABLE, { A14, U18 }, SCU8C, 22 },
2303		- { PIN_CONFIG_BIAS_PULL_DOWN, { A8, E7 }, SCU8C, 23 },
2304		- { PIN_CONFIG_BIAS_DISABLE, { A8, E7 }, SCU8C, 23 },
2305		- { PIN_CONFIG_BIAS_PULL_DOWN, { C22, E20 }, SCU8C, 24 },
2306		- { PIN_CONFIG_BIAS_DISABLE, { C22, E20 }, SCU8C, 24 },
2307		- { PIN_CONFIG_BIAS_PULL_DOWN, { J5, T1 }, SCU8C, 25 },
2308		- { PIN_CONFIG_BIAS_DISABLE, { J5, T1 }, SCU8C, 25 },
2309		- { PIN_CONFIG_BIAS_PULL_DOWN, { U1, U5 }, SCU8C, 26 },
2310		- { PIN_CONFIG_BIAS_DISABLE, { U1, U5 }, SCU8C, 26 },
2311		- { PIN_CONFIG_BIAS_PULL_DOWN, { V3, V5 }, SCU8C, 27 },
2312		- { PIN_CONFIG_BIAS_DISABLE, { V3, V5 }, SCU8C, 27 },
2313		- { PIN_CONFIG_BIAS_PULL_DOWN, { W4, AB2 }, SCU8C, 28 },
2314		- { PIN_CONFIG_BIAS_DISABLE, { W4, AB2 }, SCU8C, 28 },
2315		- { PIN_CONFIG_BIAS_PULL_DOWN, { V6, V7 }, SCU8C, 29 },
2316		- { PIN_CONFIG_BIAS_DISABLE, { V6, V7 }, SCU8C, 29 },
2317		- { PIN_CONFIG_BIAS_PULL_DOWN, { Y6, AB7 }, SCU8C, 30 },
2318		- { PIN_CONFIG_BIAS_DISABLE, { Y6, AB7 }, SCU8C, 30 },
2319		- { PIN_CONFIG_BIAS_PULL_DOWN, { V20, A5 }, SCU8C, 31 },
2320		- { PIN_CONFIG_BIAS_DISABLE, { V20, A5 }, SCU8C, 31 },
	2442	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, D6, D5, SCU8C, 16),
	2443	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, D6, D5, SCU8C, 16),
	2444	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, J21, E18, SCU8C, 17),
	2445	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, J21, E18, SCU8C, 17),
	2446	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, A18, E15, SCU8C, 19),
	2447	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, A18, E15, SCU8C, 19),
	2448	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, D15, B14, SCU8C, 20),
	2449	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, D15, B14, SCU8C, 20),
	2450	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, D18, C17, SCU8C, 21),
	2451	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, D18, C17, SCU8C, 21),
	2452	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, A14, U18, SCU8C, 22),
	2453	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, A14, U18, SCU8C, 22),
	2454	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, A8, E7, SCU8C, 23),
	2455	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, A8, E7, SCU8C, 23),
	2456	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, C22, E20, SCU8C, 24),
	2457	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, C22, E20, SCU8C, 24),
	2458	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, J5, T1, SCU8C, 25),
	2459	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, J5, T1, SCU8C, 25),
	2460	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, U1, U5, SCU8C, 26),
	2461	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, U1, U5, SCU8C, 26),
	2462	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, V3, V5, SCU8C, 27),
	2463	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, V3, V5, SCU8C, 27),
	2464	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, W4, AB2, SCU8C, 28),
	2465	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, W4, AB2, SCU8C, 28),
	2466	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, V6, V7, SCU8C, 29),
	2467	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, V6, V7, SCU8C, 29),
	2468	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, Y6, AB7, SCU8C, 30),
	2469	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, Y6, AB7, SCU8C, 30),
	2470	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, V20, A5, SCU8C, 31),
	2471	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, V20, A5, SCU8C, 31),
2321	2472
2322	2473	/* GPIOs T[0-5] (RGMII1 Tx pins) */
2323		- { PIN_CONFIG_DRIVE_STRENGTH, { A12, A13 }, SCU90, 9 },
2324		- { PIN_CONFIG_BIAS_PULL_DOWN, { A12, A13 }, SCU90, 12 },
2325		- { PIN_CONFIG_BIAS_DISABLE, { A12, A13 }, SCU90, 12 },
	2474	+ ASPEED_SB_PINCONF(PIN_CONFIG_DRIVE_STRENGTH, A12, A13, SCU90, 9),
	2475	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, A12, A13, SCU90, 12),
	2476	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, A12, A13, SCU90, 12),
2326	2477
2327	2478	/* GPIOs T[6-7], U[0-3] (RGMII2 TX pins) */
2328		- { PIN_CONFIG_DRIVE_STRENGTH, { D9, D10 }, SCU90, 11 },
2329		- { PIN_CONFIG_BIAS_PULL_DOWN, { D9, D10 }, SCU90, 14 },
2330		- { PIN_CONFIG_BIAS_DISABLE, { D9, D10 }, SCU90, 14 },
	2479	+ ASPEED_SB_PINCONF(PIN_CONFIG_DRIVE_STRENGTH, D9, D10, SCU90, 11),
	2480	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, D9, D10, SCU90, 14),
	2481	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, D9, D10, SCU90, 14),
2331	2482
2332	2483	/* GPIOs U[4-7], V[0-1] (RGMII1 Rx pins) */
2333		- { PIN_CONFIG_BIAS_PULL_DOWN, { E11, E10 }, SCU90, 13 },
2334		- { PIN_CONFIG_BIAS_DISABLE, { E11, E10 }, SCU90, 13 },
	2484	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, E11, E10, SCU90, 13),
	2485	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, E11, E10, SCU90, 13),
2335	2486
2336	2487	/* GPIOs V[2-7] (RGMII2 Rx pins) */
2337		- { PIN_CONFIG_BIAS_PULL_DOWN, { C9, C8 }, SCU90, 15 },
2338		- { PIN_CONFIG_BIAS_DISABLE, { C9, C8 }, SCU90, 15 },
	2488	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, C9, C8, SCU90, 15),
	2489	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, C9, C8, SCU90, 15),
2339	2490
2340	2491	/* ADC pull-downs (SCUA8[19:4]) */
2341		- { PIN_CONFIG_BIAS_PULL_DOWN, { L5, L5 }, SCUA8, 4 },
2342		- { PIN_CONFIG_BIAS_DISABLE, { L5, L5 }, SCUA8, 4 },
2343		- { PIN_CONFIG_BIAS_PULL_DOWN, { L4, L4 }, SCUA8, 5 },
2344		- { PIN_CONFIG_BIAS_DISABLE, { L4, L4 }, SCUA8, 5 },
2345		- { PIN_CONFIG_BIAS_PULL_DOWN, { L3, L3 }, SCUA8, 6 },
2346		- { PIN_CONFIG_BIAS_DISABLE, { L3, L3 }, SCUA8, 6 },
2347		- { PIN_CONFIG_BIAS_PULL_DOWN, { L2, L2 }, SCUA8, 7 },
2348		- { PIN_CONFIG_BIAS_DISABLE, { L2, L2 }, SCUA8, 7 },
2349		- { PIN_CONFIG_BIAS_PULL_DOWN, { L1, L1 }, SCUA8, 8 },
2350		- { PIN_CONFIG_BIAS_DISABLE, { L1, L1 }, SCUA8, 8 },
2351		- { PIN_CONFIG_BIAS_PULL_DOWN, { M5, M5 }, SCUA8, 9 },
2352		- { PIN_CONFIG_BIAS_DISABLE, { M5, M5 }, SCUA8, 9 },
2353		- { PIN_CONFIG_BIAS_PULL_DOWN, { M4, M4 }, SCUA8, 10 },
2354		- { PIN_CONFIG_BIAS_DISABLE, { M4, M4 }, SCUA8, 10 },
2355		- { PIN_CONFIG_BIAS_PULL_DOWN, { M3, M3 }, SCUA8, 11 },
2356		- { PIN_CONFIG_BIAS_DISABLE, { M3, M3 }, SCUA8, 11 },
2357		- { PIN_CONFIG_BIAS_PULL_DOWN, { M2, M2 }, SCUA8, 12 },
2358		- { PIN_CONFIG_BIAS_DISABLE, { M2, M2 }, SCUA8, 12 },
2359		- { PIN_CONFIG_BIAS_PULL_DOWN, { M1, M1 }, SCUA8, 13 },
2360		- { PIN_CONFIG_BIAS_DISABLE, { M1, M1 }, SCUA8, 13 },
2361		- { PIN_CONFIG_BIAS_PULL_DOWN, { N5, N5 }, SCUA8, 14 },
2362		- { PIN_CONFIG_BIAS_DISABLE, { N5, N5 }, SCUA8, 14 },
2363		- { PIN_CONFIG_BIAS_PULL_DOWN, { N4, N4 }, SCUA8, 15 },
2364		- { PIN_CONFIG_BIAS_DISABLE, { N4, N4 }, SCUA8, 15 },
2365		- { PIN_CONFIG_BIAS_PULL_DOWN, { N3, N3 }, SCUA8, 16 },
2366		- { PIN_CONFIG_BIAS_DISABLE, { N3, N3 }, SCUA8, 16 },
2367		- { PIN_CONFIG_BIAS_PULL_DOWN, { N2, N2 }, SCUA8, 17 },
2368		- { PIN_CONFIG_BIAS_DISABLE, { N2, N2 }, SCUA8, 17 },
2369		- { PIN_CONFIG_BIAS_PULL_DOWN, { N1, N1 }, SCUA8, 18 },
2370		- { PIN_CONFIG_BIAS_DISABLE, { N1, N1 }, SCUA8, 18 },
2371		- { PIN_CONFIG_BIAS_PULL_DOWN, { P5, P5 }, SCUA8, 19 },
2372		- { PIN_CONFIG_BIAS_DISABLE, { P5, P5 }, SCUA8, 19 },
	2492	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, L5, L5, SCUA8, 4),
	2493	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, L5, L5, SCUA8, 4),
	2494	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, L4, L4, SCUA8, 5),
	2495	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, L4, L4, SCUA8, 5),
	2496	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, L3, L3, SCUA8, 6),
	2497	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, L3, L3, SCUA8, 6),
	2498	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, L2, L2, SCUA8, 7),
	2499	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, L2, L2, SCUA8, 7),
	2500	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, L1, L1, SCUA8, 8),
	2501	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, L1, L1, SCUA8, 8),
	2502	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, M5, M5, SCUA8, 9),
	2503	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, M5, M5, SCUA8, 9),
	2504	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, M4, M4, SCUA8, 10),
	2505	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, M4, M4, SCUA8, 10),
	2506	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, M3, M3, SCUA8, 11),
	2507	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, M3, M3, SCUA8, 11),
	2508	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, M2, M2, SCUA8, 12),
	2509	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, M2, M2, SCUA8, 12),
	2510	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, M1, M1, SCUA8, 13),
	2511	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, M1, M1, SCUA8, 13),
	2512	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, N5, N5, SCUA8, 14),
	2513	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, N5, N5, SCUA8, 14),
	2514	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, N4, N4, SCUA8, 15),
	2515	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, N4, N4, SCUA8, 15),
	2516	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, N3, N3, SCUA8, 16),
	2517	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, N3, N3, SCUA8, 16),
	2518	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, N2, N2, SCUA8, 17),
	2519	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, N2, N2, SCUA8, 17),
	2520	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, N1, N1, SCUA8, 18),
	2521	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, N1, N1, SCUA8, 18),
	2522	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, P5, P5, SCUA8, 19),
	2523	+ ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, P5, P5, SCUA8, 19),
2373	2524
2374	2525	/*
2375	2526	* Debounce settings for GPIOs D and E passthrough mode are in
..	..	@@ -2380,25 +2531,95 @@
2380	2531	* controller. Due to this tangle between GPIO and pinctrl we don't yet
2381	2532	* fully support pass-through debounce.
2382	2533	*/
2383		- { PIN_CONFIG_INPUT_DEBOUNCE, { A18, D16 }, SCUA8, 20 },
2384		- { PIN_CONFIG_INPUT_DEBOUNCE, { B17, A17 }, SCUA8, 21 },
2385		- { PIN_CONFIG_INPUT_DEBOUNCE, { C16, B16 }, SCUA8, 22 },
2386		- { PIN_CONFIG_INPUT_DEBOUNCE, { A16, E15 }, SCUA8, 23 },
2387		- { PIN_CONFIG_INPUT_DEBOUNCE, { D15, C15 }, SCUA8, 24 },
2388		- { PIN_CONFIG_INPUT_DEBOUNCE, { B15, A15 }, SCUA8, 25 },
2389		- { PIN_CONFIG_INPUT_DEBOUNCE, { E14, D14 }, SCUA8, 26 },
2390		- { PIN_CONFIG_INPUT_DEBOUNCE, { C14, B14 }, SCUA8, 27 },
	2534	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, A18, D16, SCUA8, 20),
	2535	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, B17, A17, SCUA8, 21),
	2536	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, C16, B16, SCUA8, 22),
	2537	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, A16, E15, SCUA8, 23),
	2538	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, D15, C15, SCUA8, 24),
	2539	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, B15, A15, SCUA8, 25),
	2540	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, E14, D14, SCUA8, 26),
	2541	+ ASPEED_SB_PINCONF(PIN_CONFIG_INPUT_DEBOUNCE, C14, B14, SCUA8, 27),
	2542	+};
	2543	+
	2544	+static int aspeed_g4_sig_expr_set(struct aspeed_pinmux_data *ctx,
	2545	+ const struct aspeed_sig_expr *expr,
	2546	+ bool enable)
	2547	+{
	2548	+ int ret;
	2549	+ int i;
	2550	+
	2551	+ for (i = 0; i < expr->ndescs; i++) {
	2552	+ const struct aspeed_sig_desc *desc = &expr->descs[i];
	2553	+ u32 pattern = enable ? desc->enable : desc->disable;
	2554	+ u32 val = (pattern << __ffs(desc->mask));
	2555	+
	2556	+ if (!ctx->maps[desc->ip])
	2557	+ return -ENODEV;
	2558	+
	2559	+ /*
	2560	+ * Strap registers are configured in hardware or by early-boot
	2561	+ * firmware. Treat them as read-only despite that we can write
	2562	+ * them. This may mean that certain functions cannot be
	2563	+ * deconfigured and is the reason we re-evaluate after writing
	2564	+ * all descriptor bits.
	2565	+ *
	2566	+ * Port D and port E GPIO loopback modes are the only exception
	2567	+ * as those are commonly used with front-panel buttons to allow
	2568	+ * normal operation of the host when the BMC is powered off or
	2569	+ * fails to boot. Once the BMC has booted, the loopback mode
	2570	+ * must be disabled for the BMC to control host power-on and
	2571	+ * reset.
	2572	+ */
	2573	+ if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP1 &&
	2574	+ !(desc->mask & (BIT(21) \| BIT(22))))
	2575	+ continue;
	2576	+
	2577	+ if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP2)
	2578	+ continue;
	2579	+
	2580	+ ret = regmap_update_bits(ctx->maps[desc->ip], desc->reg,
	2581	+ desc->mask, val);
	2582	+
	2583	+ if (ret)
	2584	+ return ret;
	2585	+ }
	2586	+
	2587	+ ret = aspeed_sig_expr_eval(ctx, expr, enable);
	2588	+ if (ret < 0)
	2589	+ return ret;
	2590	+
	2591	+ if (!ret)
	2592	+ return -EPERM;
	2593	+
	2594	+ return 0;
	2595	+}
	2596	+
	2597	+static const struct aspeed_pin_config_map aspeed_g4_pin_config_map[] = {
	2598	+ { PIN_CONFIG_BIAS_PULL_DOWN, 0, 1, BIT_MASK(0)},
	2599	+ { PIN_CONFIG_BIAS_PULL_DOWN, -1, 0, BIT_MASK(0)},
	2600	+ { PIN_CONFIG_BIAS_DISABLE, -1, 1, BIT_MASK(0)},
	2601	+ { PIN_CONFIG_DRIVE_STRENGTH, 8, 0, BIT_MASK(0)},
	2602	+ { PIN_CONFIG_DRIVE_STRENGTH, 16, 1, BIT_MASK(0)},
	2603	+};
	2604	+
	2605	+static const struct aspeed_pinmux_ops aspeed_g4_ops = {
	2606	+ .set = aspeed_g4_sig_expr_set,
2391	2607	};
2392	2608
2393	2609	static struct aspeed_pinctrl_data aspeed_g4_pinctrl_data = {
2394	2610	.pins = aspeed_g4_pins,
2395	2611	.npins = ARRAY_SIZE(aspeed_g4_pins),
2396		- .groups = aspeed_g4_groups,
2397		- .ngroups = ARRAY_SIZE(aspeed_g4_groups),
2398		- .functions = aspeed_g4_functions,
2399		- .nfunctions = ARRAY_SIZE(aspeed_g4_functions),
	2612	+ .pinmux = {
	2613	+ .ops = &aspeed_g4_ops,
	2614	+ .groups = aspeed_g4_groups,
	2615	+ .ngroups = ARRAY_SIZE(aspeed_g4_groups),
	2616	+ .functions = aspeed_g4_functions,
	2617	+ .nfunctions = ARRAY_SIZE(aspeed_g4_functions),
	2618	+ },
2400	2619	.configs = aspeed_g4_configs,
2401	2620	.nconfigs = ARRAY_SIZE(aspeed_g4_configs),
	2621	+ .confmaps = aspeed_g4_pin_config_map,
	2622	+ .nconfmaps = ARRAY_SIZE(aspeed_g4_pin_config_map),
2402	2623	};
2403	2624
2404	2625	static const struct pinmux_ops aspeed_g4_pinmux_ops = {
..	..	@@ -2449,6 +2670,10 @@
2449	2670
2450	2671	static const struct of_device_id aspeed_g4_pinctrl_of_match[] = {
2451	2672	{ .compatible = "aspeed,ast2400-pinctrl", },
	2673	+ /*
	2674	+ * The aspeed,g4-pinctrl compatible has been removed the from the
	2675	+ * bindings, but keep the match in case of old devicetrees.
	2676	+ */
2452	2677	{ .compatible = "aspeed,g4-pinctrl", },
2453	2678	{ },
2454	2679	};