1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Copyright (C) 2019 IBM Corp. */ 3 #include <linux/bitops.h> 4 #include <linux/init.h> 5 #include <linux/io.h> 6 #include <linux/kernel.h> 7 #include <linux/mod_devicetable.h> 8 #include <linux/platform_device.h> 9 #include <linux/pinctrl/pinctrl.h> 10 #include <linux/pinctrl/pinmux.h> 11 #include <linux/types.h> 12 13 #include "../core.h" 14 #include "../pinctrl-utils.h" 15 #include "pinctrl-aspeed.h" 16 17 #define SCU040 0x040 /* Reset Control Set 1 */ 18 #define SCU400 0x400 /* Multi-function Pin Control #1 */ 19 #define SCU404 0x404 /* Multi-function Pin Control #2 */ 20 #define SCU40C 0x40C /* Multi-function Pin Control #3 */ 21 #define SCU410 0x410 /* Multi-function Pin Control #4 */ 22 #define SCU414 0x414 /* Multi-function Pin Control #5 */ 23 #define SCU418 0x418 /* Multi-function Pin Control #6 */ 24 #define SCU41C 0x41C /* Multi-function Pin Control #7 */ 25 #define SCU430 0x430 /* Multi-function Pin Control #8 */ 26 #define SCU434 0x434 /* Multi-function Pin Control #9 */ 27 #define SCU438 0x438 /* Multi-function Pin Control #10 */ 28 #define SCU440 0x440 /* USB Multi-function Pin Control #12 */ 29 #define SCU450 0x450 /* Multi-function Pin Control #14 */ 30 #define SCU454 0x454 /* Multi-function Pin Control #15 */ 31 #define SCU458 0x458 /* Multi-function Pin Control #16 */ 32 #define SCU4B0 0x4B0 /* Multi-function Pin Control #17 */ 33 #define SCU4B4 0x4B4 /* Multi-function Pin Control #18 */ 34 #define SCU4B8 0x4B8 /* Multi-function Pin Control #19 */ 35 #define SCU4BC 0x4BC /* Multi-function Pin Control #20 */ 36 #define SCU4D4 0x4D4 /* Multi-function Pin Control #22 */ 37 #define SCU4D8 0x4D8 /* Multi-function Pin Control #23 */ 38 #define SCU500 0x500 /* Hardware Strap 1 */ 39 #define SCU510 0x510 /* Hardware Strap 2 */ 40 #define SCU610 0x610 /* Disable GPIO Internal Pull-Down #0 */ 41 #define SCU614 0x614 /* Disable GPIO Internal Pull-Down #1 */ 42 #define SCU618 0x618 /* Disable GPIO Internal Pull-Down #2 */ 43 #define SCU61C 0x61c /* Disable GPIO Internal Pull-Down #3 */ 44 #define SCU630 0x630 /* Disable GPIO Internal Pull-Down #4 */ 45 #define SCU634 0x634 /* Disable GPIO Internal Pull-Down #5 */ 46 #define SCU638 0x638 /* Disable GPIO Internal Pull-Down #6 */ 47 #define SCU690 0x690 /* Multi-function Pin Control #24 */ 48 #define SCU694 0x694 /* Multi-function Pin Control #25 */ 49 #define SCU69C 0x69C /* Multi-function Pin Control #27 */ 50 #define SCU6D0 0x6D0 /* Multi-function Pin Control #29 */ 51 #define SCUC20 0xC20 /* PCIE configuration Setting Control */ 52 53 #define ASPEED_G6_NR_PINS 258 54 55 #define M24 0 56 SIG_EXPR_LIST_DECL_SESG(M24, MDC3, MDIO3, SIG_DESC_SET(SCU410, 0)); 57 SIG_EXPR_LIST_DECL_SESG(M24, SCL11, I2C11, SIG_DESC_SET(SCU4B0, 0)); 58 PIN_DECL_2(M24, GPIOA0, MDC3, SCL11); 59 60 #define M25 1 61 SIG_EXPR_LIST_DECL_SESG(M25, MDIO3, MDIO3, SIG_DESC_SET(SCU410, 1)); 62 SIG_EXPR_LIST_DECL_SESG(M25, SDA11, I2C11, SIG_DESC_SET(SCU4B0, 1)); 63 PIN_DECL_2(M25, GPIOA1, MDIO3, SDA11); 64 65 FUNC_GROUP_DECL(MDIO3, M24, M25); 66 FUNC_GROUP_DECL(I2C11, M24, M25); 67 68 #define L26 2 69 SIG_EXPR_LIST_DECL_SESG(L26, MDC4, MDIO4, SIG_DESC_SET(SCU410, 2)); 70 SIG_EXPR_LIST_DECL_SESG(L26, SCL12, I2C12, SIG_DESC_SET(SCU4B0, 2)); 71 PIN_DECL_2(L26, GPIOA2, MDC4, SCL12); 72 73 #define K24 3 74 SIG_EXPR_LIST_DECL_SESG(K24, MDIO4, MDIO4, SIG_DESC_SET(SCU410, 3)); 75 SIG_EXPR_LIST_DECL_SESG(K24, SDA12, I2C12, SIG_DESC_SET(SCU4B0, 3)); 76 PIN_DECL_2(K24, GPIOA3, MDIO4, SDA12); 77 78 FUNC_GROUP_DECL(MDIO4, L26, K24); 79 FUNC_GROUP_DECL(I2C12, L26, K24); 80 81 #define K26 4 82 SIG_EXPR_LIST_DECL_SESG(K26, MACLINK1, MACLINK1, SIG_DESC_SET(SCU410, 4)); 83 SIG_EXPR_LIST_DECL_SESG(K26, SCL13, I2C13, SIG_DESC_SET(SCU4B0, 4)); 84 SIG_EXPR_LIST_DECL_SESG(K26, SGPS2CK, SGPS2, SIG_DESC_SET(SCU690, 4)); 85 SIG_EXPR_LIST_DECL_SESG(K26, SGPM2CLK, SGPM2, SIG_DESC_SET(SCU6D0, 4)); 86 PIN_DECL_4(K26, GPIOA4, MACLINK1, SCL13, SGPS2CK, SGPM2CLK); 87 FUNC_GROUP_DECL(MACLINK1, K26); 88 89 #define L24 5 90 SIG_EXPR_LIST_DECL_SESG(L24, MACLINK2, MACLINK2, SIG_DESC_SET(SCU410, 5)); 91 SIG_EXPR_LIST_DECL_SESG(L24, SDA13, I2C13, SIG_DESC_SET(SCU4B0, 5)); 92 SIG_EXPR_LIST_DECL_SESG(L24, SGPS2LD, SGPS2, SIG_DESC_SET(SCU690, 5)); 93 SIG_EXPR_LIST_DECL_SESG(L24, SGPM2LD, SGPM2, SIG_DESC_SET(SCU6D0, 5)); 94 PIN_DECL_4(L24, GPIOA5, MACLINK2, SDA13, SGPS2LD, SGPM2LD); 95 FUNC_GROUP_DECL(MACLINK2, L24); 96 97 FUNC_GROUP_DECL(I2C13, K26, L24); 98 99 #define L23 6 100 SIG_EXPR_LIST_DECL_SESG(L23, MACLINK3, MACLINK3, SIG_DESC_SET(SCU410, 6)); 101 SIG_EXPR_LIST_DECL_SESG(L23, SCL14, I2C14, SIG_DESC_SET(SCU4B0, 6)); 102 SIG_EXPR_LIST_DECL_SESG(L23, SGPS2O, SGPS2, SIG_DESC_SET(SCU690, 6)); 103 SIG_EXPR_LIST_DECL_SESG(L23, SGPM2O, SGPM2, SIG_DESC_SET(SCU6D0, 6)); 104 PIN_DECL_4(L23, GPIOA6, MACLINK3, SCL14, SGPS2O, SGPM2O); 105 FUNC_GROUP_DECL(MACLINK3, L23); 106 107 #define K25 7 108 SIG_EXPR_LIST_DECL_SESG(K25, MACLINK4, MACLINK4, SIG_DESC_SET(SCU410, 7)); 109 SIG_EXPR_LIST_DECL_SESG(K25, SDA14, I2C14, SIG_DESC_SET(SCU4B0, 7)); 110 SIG_EXPR_LIST_DECL_SESG(K25, SGPS2I, SGPS2, SIG_DESC_SET(SCU690, 7)); 111 SIG_EXPR_LIST_DECL_SESG(K25, SGPM2I, SGPM2, SIG_DESC_SET(SCU6D0, 7)); 112 PIN_DECL_4(K25, GPIOA7, MACLINK4, SDA14, SGPS2I, SGPM2I); 113 FUNC_GROUP_DECL(MACLINK4, K25); 114 115 FUNC_GROUP_DECL(I2C14, L23, K25); 116 FUNC_GROUP_DECL(SGPM2, K26, L24, L23, K25); 117 FUNC_GROUP_DECL(SGPS2, K26, L24, L23, K25); 118 119 #define J26 8 120 SIG_EXPR_LIST_DECL_SESG(J26, SALT1, SALT1, SIG_DESC_SET(SCU410, 8)); 121 SIG_EXPR_LIST_DECL_SESG(J26, LHAD0, LPCHC, SIG_DESC_SET(SCU4B0, 8)); 122 PIN_DECL_2(J26, GPIOB0, SALT1, LHAD0); 123 FUNC_GROUP_DECL(SALT1, J26); 124 125 #define K23 9 126 SIG_EXPR_LIST_DECL_SESG(K23, SALT2, SALT2, SIG_DESC_SET(SCU410, 9)); 127 SIG_EXPR_LIST_DECL_SESG(K23, LHAD1, LPCHC, SIG_DESC_SET(SCU4B0, 9)); 128 PIN_DECL_2(K23, GPIOB1, SALT2, LHAD1); 129 FUNC_GROUP_DECL(SALT2, K23); 130 131 #define H26 10 132 SIG_EXPR_LIST_DECL_SESG(H26, SALT3, SALT3, SIG_DESC_SET(SCU410, 10)); 133 SIG_EXPR_LIST_DECL_SESG(H26, LHAD2, LPCHC, SIG_DESC_SET(SCU4B0, 10)); 134 PIN_DECL_2(H26, GPIOB2, SALT3, LHAD2); 135 FUNC_GROUP_DECL(SALT3, H26); 136 137 #define J25 11 138 SIG_EXPR_LIST_DECL_SESG(J25, SALT4, SALT4, SIG_DESC_SET(SCU410, 11)); 139 SIG_EXPR_LIST_DECL_SESG(J25, LHAD3, LPCHC, SIG_DESC_SET(SCU4B0, 11)); 140 PIN_DECL_2(J25, GPIOB3, SALT4, LHAD3); 141 FUNC_GROUP_DECL(SALT4, J25); 142 143 #define J23 12 144 SIG_EXPR_LIST_DECL_SESG(J23, MDC2, MDIO2, SIG_DESC_SET(SCU410, 12)); 145 SIG_EXPR_LIST_DECL_SESG(J23, LHCLK, LPCHC, SIG_DESC_SET(SCU4B0, 12)); 146 PIN_DECL_2(J23, GPIOB4, MDC2, LHCLK); 147 148 #define G26 13 149 SIG_EXPR_LIST_DECL_SESG(G26, MDIO2, MDIO2, SIG_DESC_SET(SCU410, 13)); 150 SIG_EXPR_LIST_DECL_SESG(G26, LHFRAME, LPCHC, SIG_DESC_SET(SCU4B0, 13)); 151 PIN_DECL_2(G26, GPIOB5, MDIO2, LHFRAME); 152 153 FUNC_GROUP_DECL(MDIO2, J23, G26); 154 155 #define H25 14 156 SIG_EXPR_LIST_DECL_SESG(H25, TXD4, TXD4, SIG_DESC_SET(SCU410, 14)); 157 SIG_EXPR_LIST_DECL_SESG(H25, LHSIRQ, LHSIRQ, SIG_DESC_SET(SCU4B0, 14)); 158 PIN_DECL_2(H25, GPIOB6, TXD4, LHSIRQ); 159 FUNC_GROUP_DECL(TXD4, H25); 160 FUNC_GROUP_DECL(LHSIRQ, H25); 161 162 #define J24 15 163 SIG_EXPR_LIST_DECL_SESG(J24, RXD4, RXD4, SIG_DESC_SET(SCU410, 15)); 164 SIG_EXPR_LIST_DECL_SESG(J24, LHRST, LPCHC, SIG_DESC_SET(SCU4B0, 15)); 165 PIN_DECL_2(J24, GPIOB7, RXD4, LHRST); 166 FUNC_GROUP_DECL(RXD4, J24); 167 168 FUNC_GROUP_DECL(LPCHC, J26, K23, H26, J25, J23, G26, H25, J24); 169 170 #define H24 16 171 SIG_EXPR_LIST_DECL_SESG(H24, RGMII3TXCK, RGMII3, SIG_DESC_SET(SCU410, 16), 172 SIG_DESC_SET(SCU510, 0)); 173 SIG_EXPR_LIST_DECL_SESG(H24, RMII3RCLKO, RMII3, SIG_DESC_SET(SCU410, 16), 174 SIG_DESC_CLEAR(SCU510, 0)); 175 PIN_DECL_2(H24, GPIOC0, RGMII3TXCK, RMII3RCLKO); 176 177 #define J22 17 178 SIG_EXPR_LIST_DECL_SESG(J22, RGMII3TXCTL, RGMII3, SIG_DESC_SET(SCU410, 17), 179 SIG_DESC_SET(SCU510, 0)); 180 SIG_EXPR_LIST_DECL_SESG(J22, RMII3TXEN, RMII3, SIG_DESC_SET(SCU410, 17), 181 SIG_DESC_CLEAR(SCU510, 0)); 182 PIN_DECL_2(J22, GPIOC1, RGMII3TXCTL, RMII3TXEN); 183 184 #define H22 18 185 SIG_EXPR_LIST_DECL_SESG(H22, RGMII3TXD0, RGMII3, SIG_DESC_SET(SCU410, 18), 186 SIG_DESC_SET(SCU510, 0)); 187 SIG_EXPR_LIST_DECL_SESG(H22, RMII3TXD0, RMII3, SIG_DESC_SET(SCU410, 18), 188 SIG_DESC_CLEAR(SCU510, 0)); 189 PIN_DECL_2(H22, GPIOC2, RGMII3TXD0, RMII3TXD0); 190 191 #define H23 19 192 SIG_EXPR_LIST_DECL_SESG(H23, RGMII3TXD1, RGMII3, SIG_DESC_SET(SCU410, 19), 193 SIG_DESC_SET(SCU510, 0)); 194 SIG_EXPR_LIST_DECL_SESG(H23, RMII3TXD1, RMII3, SIG_DESC_SET(SCU410, 19), 195 SIG_DESC_CLEAR(SCU510, 0)); 196 PIN_DECL_2(H23, GPIOC3, RGMII3TXD1, RMII3TXD1); 197 198 #define G22 20 199 SIG_EXPR_LIST_DECL_SESG(G22, RGMII3TXD2, RGMII3, SIG_DESC_SET(SCU410, 20), 200 SIG_DESC_SET(SCU510, 0)); 201 PIN_DECL_1(G22, GPIOC4, RGMII3TXD2); 202 203 #define F22 21 204 SIG_EXPR_LIST_DECL_SESG(F22, RGMII3TXD3, RGMII3, SIG_DESC_SET(SCU410, 21), 205 SIG_DESC_SET(SCU510, 0)); 206 PIN_DECL_1(F22, GPIOC5, RGMII3TXD3); 207 208 #define G23 22 209 SIG_EXPR_LIST_DECL_SESG(G23, RGMII3RXCK, RGMII3, SIG_DESC_SET(SCU410, 22), 210 SIG_DESC_SET(SCU510, 0)); 211 SIG_EXPR_LIST_DECL_SESG(G23, RMII3RCLKI, RMII3, SIG_DESC_SET(SCU410, 22), 212 SIG_DESC_CLEAR(SCU510, 0)); 213 PIN_DECL_2(G23, GPIOC6, RGMII3RXCK, RMII3RCLKI); 214 215 #define G24 23 216 SIG_EXPR_LIST_DECL_SESG(G24, RGMII3RXCTL, RGMII3, SIG_DESC_SET(SCU410, 23), 217 SIG_DESC_SET(SCU510, 0)); 218 PIN_DECL_1(G24, GPIOC7, RGMII3RXCTL); 219 220 #define F23 24 221 SIG_EXPR_LIST_DECL_SESG(F23, RGMII3RXD0, RGMII3, SIG_DESC_SET(SCU410, 24), 222 SIG_DESC_SET(SCU510, 0)); 223 SIG_EXPR_LIST_DECL_SESG(F23, RMII3RXD0, RMII3, SIG_DESC_SET(SCU410, 24), 224 SIG_DESC_CLEAR(SCU510, 0)); 225 PIN_DECL_2(F23, GPIOD0, RGMII3RXD0, RMII3RXD0); 226 227 #define F26 25 228 SIG_EXPR_LIST_DECL_SESG(F26, RGMII3RXD1, RGMII3, SIG_DESC_SET(SCU410, 25), 229 SIG_DESC_SET(SCU510, 0)); 230 SIG_EXPR_LIST_DECL_SESG(F26, RMII3RXD1, RMII3, SIG_DESC_SET(SCU410, 25), 231 SIG_DESC_CLEAR(SCU510, 0)); 232 PIN_DECL_2(F26, GPIOD1, RGMII3RXD1, RMII3RXD1); 233 234 #define F25 26 235 SIG_EXPR_LIST_DECL_SESG(F25, RGMII3RXD2, RGMII3, SIG_DESC_SET(SCU410, 26), 236 SIG_DESC_SET(SCU510, 0)); 237 SIG_EXPR_LIST_DECL_SESG(F25, RMII3CRSDV, RMII3, SIG_DESC_SET(SCU410, 26), 238 SIG_DESC_CLEAR(SCU510, 0)); 239 PIN_DECL_2(F25, GPIOD2, RGMII3RXD2, RMII3CRSDV); 240 241 #define E26 27 242 SIG_EXPR_LIST_DECL_SESG(E26, RGMII3RXD3, RGMII3, SIG_DESC_SET(SCU410, 27), 243 SIG_DESC_SET(SCU510, 0)); 244 SIG_EXPR_LIST_DECL_SESG(E26, RMII3RXER, RMII3, SIG_DESC_SET(SCU410, 27), 245 SIG_DESC_CLEAR(SCU510, 0)); 246 PIN_DECL_2(E26, GPIOD3, RGMII3RXD3, RMII3RXER); 247 248 FUNC_GROUP_DECL(RGMII3, H24, J22, H22, H23, G22, F22, G23, G24, F23, F26, F25, 249 E26); 250 GROUP_DECL(RMII3, H24, J22, H22, H23, G23, F23, F26, F25, E26); 251 GROUP_DECL(NCSI3, J22, H22, H23, G23, F23, F26, F25, E26); 252 FUNC_DECL_2(RMII3, RMII3, NCSI3); 253 254 #define F24 28 255 SIG_EXPR_LIST_DECL_SESG(F24, NCTS3, NCTS3, SIG_DESC_SET(SCU410, 28)); 256 SIG_EXPR_LIST_DECL_SESG(F24, RGMII4TXCK, RGMII4, SIG_DESC_SET(SCU4B0, 28), 257 SIG_DESC_SET(SCU510, 1)); 258 SIG_EXPR_LIST_DECL_SESG(F24, RMII4RCLKO, RMII4, SIG_DESC_SET(SCU4B0, 28), 259 SIG_DESC_CLEAR(SCU510, 1)); 260 PIN_DECL_3(F24, GPIOD4, NCTS3, RGMII4TXCK, RMII4RCLKO); 261 FUNC_GROUP_DECL(NCTS3, F24); 262 263 #define E23 29 264 SIG_EXPR_LIST_DECL_SESG(E23, NDCD3, NDCD3, SIG_DESC_SET(SCU410, 29)); 265 SIG_EXPR_LIST_DECL_SESG(E23, RGMII4TXCTL, RGMII4, SIG_DESC_SET(SCU4B0, 29), 266 SIG_DESC_SET(SCU510, 1)); 267 SIG_EXPR_LIST_DECL_SESG(E23, RMII4TXEN, RMII4, SIG_DESC_SET(SCU4B0, 29), 268 SIG_DESC_CLEAR(SCU510, 1)); 269 PIN_DECL_3(E23, GPIOD5, NDCD3, RGMII4TXCTL, RMII4TXEN); 270 FUNC_GROUP_DECL(NDCD3, E23); 271 272 #define E24 30 273 SIG_EXPR_LIST_DECL_SESG(E24, NDSR3, NDSR3, SIG_DESC_SET(SCU410, 30)); 274 SIG_EXPR_LIST_DECL_SESG(E24, RGMII4TXD0, RGMII4, SIG_DESC_SET(SCU4B0, 30), 275 SIG_DESC_SET(SCU510, 1)); 276 SIG_EXPR_LIST_DECL_SESG(E24, RMII4TXD0, RMII4, SIG_DESC_SET(SCU4B0, 30), 277 SIG_DESC_CLEAR(SCU510, 1)); 278 PIN_DECL_3(E24, GPIOD6, NDSR3, RGMII4TXD0, RMII4TXD0); 279 FUNC_GROUP_DECL(NDSR3, E24); 280 281 #define E25 31 282 SIG_EXPR_LIST_DECL_SESG(E25, NRI3, NRI3, SIG_DESC_SET(SCU410, 31)); 283 SIG_EXPR_LIST_DECL_SESG(E25, RGMII4TXD1, RGMII4, SIG_DESC_SET(SCU4B0, 31), 284 SIG_DESC_SET(SCU510, 1)); 285 SIG_EXPR_LIST_DECL_SESG(E25, RMII4TXD1, RMII4, SIG_DESC_SET(SCU4B0, 31), 286 SIG_DESC_CLEAR(SCU510, 1)); 287 PIN_DECL_3(E25, GPIOD7, NRI3, RGMII4TXD1, RMII4TXD1); 288 FUNC_GROUP_DECL(NRI3, E25); 289 290 #define D26 32 291 SIG_EXPR_LIST_DECL_SESG(D26, NDTR3, NDTR3, SIG_DESC_SET(SCU414, 0)); 292 SIG_EXPR_LIST_DECL_SESG(D26, RGMII4TXD2, RGMII4, SIG_DESC_SET(SCU4B4, 0), 293 SIG_DESC_SET(SCU510, 1)); 294 PIN_DECL_2(D26, GPIOE0, NDTR3, RGMII4TXD2); 295 FUNC_GROUP_DECL(NDTR3, D26); 296 297 #define D24 33 298 SIG_EXPR_LIST_DECL_SESG(D24, NRTS3, NRTS3, SIG_DESC_SET(SCU414, 1)); 299 SIG_EXPR_LIST_DECL_SESG(D24, RGMII4TXD3, RGMII4, SIG_DESC_SET(SCU4B4, 1), 300 SIG_DESC_SET(SCU510, 1)); 301 PIN_DECL_2(D24, GPIOE1, NRTS3, RGMII4TXD3); 302 FUNC_GROUP_DECL(NRTS3, D24); 303 304 #define C25 34 305 SIG_EXPR_LIST_DECL_SESG(C25, NCTS4, NCTS4, SIG_DESC_SET(SCU414, 2)); 306 SIG_EXPR_LIST_DECL_SESG(C25, RGMII4RXCK, RGMII4, SIG_DESC_SET(SCU4B4, 2), 307 SIG_DESC_SET(SCU510, 1)); 308 SIG_EXPR_LIST_DECL_SESG(C25, RMII4RCLKI, RMII4, SIG_DESC_SET(SCU4B4, 2), 309 SIG_DESC_CLEAR(SCU510, 1)); 310 PIN_DECL_3(C25, GPIOE2, NCTS4, RGMII4RXCK, RMII4RCLKI); 311 FUNC_GROUP_DECL(NCTS4, C25); 312 313 #define C26 35 314 SIG_EXPR_LIST_DECL_SESG(C26, NDCD4, NDCD4, SIG_DESC_SET(SCU414, 3)); 315 SIG_EXPR_LIST_DECL_SESG(C26, RGMII4RXCTL, RGMII4, SIG_DESC_SET(SCU4B4, 3), 316 SIG_DESC_SET(SCU510, 1)); 317 PIN_DECL_2(C26, GPIOE3, NDCD4, RGMII4RXCTL); 318 FUNC_GROUP_DECL(NDCD4, C26); 319 320 #define C24 36 321 SIG_EXPR_LIST_DECL_SESG(C24, NDSR4, NDSR4, SIG_DESC_SET(SCU414, 4)); 322 SIG_EXPR_LIST_DECL_SESG(C24, RGMII4RXD0, RGMII4, SIG_DESC_SET(SCU4B4, 4), 323 SIG_DESC_SET(SCU510, 1)); 324 SIG_EXPR_LIST_DECL_SESG(C24, RMII4RXD0, RMII4, SIG_DESC_SET(SCU4B4, 4), 325 SIG_DESC_CLEAR(SCU510, 1)); 326 PIN_DECL_3(C24, GPIOE4, NDSR4, RGMII4RXD0, RMII4RXD0); 327 FUNC_GROUP_DECL(NDSR4, C24); 328 329 #define B26 37 330 SIG_EXPR_LIST_DECL_SESG(B26, NRI4, NRI4, SIG_DESC_SET(SCU414, 5)); 331 SIG_EXPR_LIST_DECL_SESG(B26, RGMII4RXD1, RGMII4, SIG_DESC_SET(SCU4B4, 5), 332 SIG_DESC_SET(SCU510, 1)); 333 SIG_EXPR_LIST_DECL_SESG(B26, RMII4RXD1, RMII4, SIG_DESC_SET(SCU4B4, 5), 334 SIG_DESC_CLEAR(SCU510, 1)); 335 PIN_DECL_3(B26, GPIOE5, NRI4, RGMII4RXD1, RMII4RXD1); 336 FUNC_GROUP_DECL(NRI4, B26); 337 338 #define B25 38 339 SIG_EXPR_LIST_DECL_SESG(B25, NDTR4, NDTR4, SIG_DESC_SET(SCU414, 6)); 340 SIG_EXPR_LIST_DECL_SESG(B25, RGMII4RXD2, RGMII4, SIG_DESC_SET(SCU4B4, 6), 341 SIG_DESC_SET(SCU510, 1)); 342 SIG_EXPR_LIST_DECL_SESG(B25, RMII4CRSDV, RMII4, SIG_DESC_SET(SCU4B4, 6), 343 SIG_DESC_CLEAR(SCU510, 1)); 344 PIN_DECL_3(B25, GPIOE6, NDTR4, RGMII4RXD2, RMII4CRSDV); 345 FUNC_GROUP_DECL(NDTR4, B25); 346 347 #define B24 39 348 SIG_EXPR_LIST_DECL_SESG(B24, NRTS4, NRTS4, SIG_DESC_SET(SCU414, 7)); 349 SIG_EXPR_LIST_DECL_SESG(B24, RGMII4RXD3, RGMII4, SIG_DESC_SET(SCU4B4, 7), 350 SIG_DESC_SET(SCU510, 1)); 351 SIG_EXPR_LIST_DECL_SESG(B24, RMII4RXER, RMII4, SIG_DESC_SET(SCU4B4, 7), 352 SIG_DESC_CLEAR(SCU510, 1)); 353 PIN_DECL_3(B24, GPIOE7, NRTS4, RGMII4RXD3, RMII4RXER); 354 FUNC_GROUP_DECL(NRTS4, B24); 355 356 FUNC_GROUP_DECL(RGMII4, F24, E23, E24, E25, D26, D24, C25, C26, C24, B26, B25, 357 B24); 358 GROUP_DECL(RMII4, F24, E23, E24, E25, C25, C24, B26, B25, B24); 359 GROUP_DECL(NCSI4, E23, E24, E25, C25, C24, B26, B25, B24); 360 FUNC_DECL_2(RMII4, RMII4, NCSI4); 361 362 #define D22 40 363 SIG_EXPR_LIST_DECL_SESG(D22, SD1CLK, SD1, SIG_DESC_SET(SCU414, 8)); 364 SIG_EXPR_LIST_DECL_SEMG(D22, PWM8, PWM8G0, PWM8, SIG_DESC_SET(SCU4B4, 8)); 365 PIN_DECL_2(D22, GPIOF0, SD1CLK, PWM8); 366 GROUP_DECL(PWM8G0, D22); 367 368 #define E22 41 369 SIG_EXPR_LIST_DECL_SESG(E22, SD1CMD, SD1, SIG_DESC_SET(SCU414, 9)); 370 SIG_EXPR_LIST_DECL_SEMG(E22, PWM9, PWM9G0, PWM9, SIG_DESC_SET(SCU4B4, 9)); 371 PIN_DECL_2(E22, GPIOF1, SD1CMD, PWM9); 372 GROUP_DECL(PWM9G0, E22); 373 374 #define D23 42 375 SIG_EXPR_LIST_DECL_SESG(D23, SD1DAT0, SD1, SIG_DESC_SET(SCU414, 10)); 376 SIG_EXPR_LIST_DECL_SEMG(D23, PWM10, PWM10G0, PWM10, SIG_DESC_SET(SCU4B4, 10)); 377 PIN_DECL_2(D23, GPIOF2, SD1DAT0, PWM10); 378 GROUP_DECL(PWM10G0, D23); 379 380 #define C23 43 381 SIG_EXPR_LIST_DECL_SESG(C23, SD1DAT1, SD1, SIG_DESC_SET(SCU414, 11)); 382 SIG_EXPR_LIST_DECL_SEMG(C23, PWM11, PWM11G0, PWM11, SIG_DESC_SET(SCU4B4, 11)); 383 PIN_DECL_2(C23, GPIOF3, SD1DAT1, PWM11); 384 GROUP_DECL(PWM11G0, C23); 385 386 #define C22 44 387 SIG_EXPR_LIST_DECL_SESG(C22, SD1DAT2, SD1, SIG_DESC_SET(SCU414, 12)); 388 SIG_EXPR_LIST_DECL_SEMG(C22, PWM12, PWM12G0, PWM12, SIG_DESC_SET(SCU4B4, 12)); 389 PIN_DECL_2(C22, GPIOF4, SD1DAT2, PWM12); 390 GROUP_DECL(PWM12G0, C22); 391 392 #define A25 45 393 SIG_EXPR_LIST_DECL_SESG(A25, SD1DAT3, SD1, SIG_DESC_SET(SCU414, 13)); 394 SIG_EXPR_LIST_DECL_SEMG(A25, PWM13, PWM13G0, PWM13, SIG_DESC_SET(SCU4B4, 13)); 395 PIN_DECL_2(A25, GPIOF5, SD1DAT3, PWM13); 396 GROUP_DECL(PWM13G0, A25); 397 398 #define A24 46 399 SIG_EXPR_LIST_DECL_SESG(A24, SD1CD, SD1, SIG_DESC_SET(SCU414, 14)); 400 SIG_EXPR_LIST_DECL_SEMG(A24, PWM14, PWM14G0, PWM14, SIG_DESC_SET(SCU4B4, 14)); 401 PIN_DECL_2(A24, GPIOF6, SD1CD, PWM14); 402 GROUP_DECL(PWM14G0, A24); 403 404 #define A23 47 405 SIG_EXPR_LIST_DECL_SESG(A23, SD1WP, SD1, SIG_DESC_SET(SCU414, 15)); 406 SIG_EXPR_LIST_DECL_SEMG(A23, PWM15, PWM15G0, PWM15, SIG_DESC_SET(SCU4B4, 15)); 407 PIN_DECL_2(A23, GPIOF7, SD1WP, PWM15); 408 GROUP_DECL(PWM15G0, A23); 409 410 FUNC_GROUP_DECL(SD1, D22, E22, D23, C23, C22, A25, A24, A23); 411 412 #define E21 48 413 SIG_EXPR_LIST_DECL_SESG(E21, TXD6, UART6, SIG_DESC_SET(SCU414, 16)); 414 SIG_EXPR_LIST_DECL_SESG(E21, SD2CLK, SD2, SIG_DESC_SET(SCU4B4, 16), 415 SIG_DESC_SET(SCU450, 1)); 416 SIG_EXPR_LIST_DECL_SEMG(E21, SALT9, SALT9G0, SALT9, SIG_DESC_SET(SCU694, 16)); 417 PIN_DECL_3(E21, GPIOG0, TXD6, SD2CLK, SALT9); 418 GROUP_DECL(SALT9G0, E21); 419 420 #define B22 49 421 SIG_EXPR_LIST_DECL_SESG(B22, RXD6, UART6, SIG_DESC_SET(SCU414, 17)); 422 SIG_EXPR_LIST_DECL_SESG(B22, SD2CMD, SD2, SIG_DESC_SET(SCU4B4, 17), 423 SIG_DESC_SET(SCU450, 1)); 424 SIG_EXPR_LIST_DECL_SEMG(B22, SALT10, SALT10G0, SALT10, 425 SIG_DESC_SET(SCU694, 17)); 426 PIN_DECL_3(B22, GPIOG1, RXD6, SD2CMD, SALT10); 427 GROUP_DECL(SALT10G0, B22); 428 429 FUNC_GROUP_DECL(UART6, E21, B22); 430 431 #define C21 50 432 SIG_EXPR_LIST_DECL_SESG(C21, TXD7, UART7, SIG_DESC_SET(SCU414, 18)); 433 SIG_EXPR_LIST_DECL_SESG(C21, SD2DAT0, SD2, SIG_DESC_SET(SCU4B4, 18), 434 SIG_DESC_SET(SCU450, 1)); 435 SIG_EXPR_LIST_DECL_SEMG(C21, SALT11, SALT11G0, SALT11, 436 SIG_DESC_SET(SCU694, 18)); 437 PIN_DECL_3(C21, GPIOG2, TXD7, SD2DAT0, SALT11); 438 GROUP_DECL(SALT11G0, C21); 439 440 #define A22 51 441 SIG_EXPR_LIST_DECL_SESG(A22, RXD7, UART7, SIG_DESC_SET(SCU414, 19)); 442 SIG_EXPR_LIST_DECL_SESG(A22, SD2DAT1, SD2, SIG_DESC_SET(SCU4B4, 19), 443 SIG_DESC_SET(SCU450, 1)); 444 SIG_EXPR_LIST_DECL_SEMG(A22, SALT12, SALT12G0, SALT12, 445 SIG_DESC_SET(SCU694, 19)); 446 PIN_DECL_3(A22, GPIOG3, RXD7, SD2DAT1, SALT12); 447 GROUP_DECL(SALT12G0, A22); 448 449 FUNC_GROUP_DECL(UART7, C21, A22); 450 451 #define A21 52 452 SIG_EXPR_LIST_DECL_SESG(A21, TXD8, UART8, SIG_DESC_SET(SCU414, 20)); 453 SIG_EXPR_LIST_DECL_SESG(A21, SD2DAT2, SD2, SIG_DESC_SET(SCU4B4, 20), 454 SIG_DESC_SET(SCU450, 1)); 455 SIG_EXPR_LIST_DECL_SEMG(A21, SALT13, SALT13G0, SALT13, 456 SIG_DESC_SET(SCU694, 20)); 457 PIN_DECL_3(A21, GPIOG4, TXD8, SD2DAT2, SALT13); 458 GROUP_DECL(SALT13G0, A21); 459 460 #define E20 53 461 SIG_EXPR_LIST_DECL_SESG(E20, RXD8, UART8, SIG_DESC_SET(SCU414, 21)); 462 SIG_EXPR_LIST_DECL_SESG(E20, SD2DAT3, SD2, SIG_DESC_SET(SCU4B4, 21), 463 SIG_DESC_SET(SCU450, 1)); 464 SIG_EXPR_LIST_DECL_SEMG(E20, SALT14, SALT14G0, SALT14, 465 SIG_DESC_SET(SCU694, 21)); 466 PIN_DECL_3(E20, GPIOG5, RXD8, SD2DAT3, SALT14); 467 GROUP_DECL(SALT14G0, E20); 468 469 FUNC_GROUP_DECL(UART8, A21, E20); 470 471 #define D21 54 472 SIG_EXPR_LIST_DECL_SESG(D21, TXD9, UART9, SIG_DESC_SET(SCU414, 22)); 473 SIG_EXPR_LIST_DECL_SESG(D21, SD2CD, SD2, SIG_DESC_SET(SCU4B4, 22), 474 SIG_DESC_SET(SCU450, 1)); 475 SIG_EXPR_LIST_DECL_SEMG(D21, SALT15, SALT15G0, SALT15, 476 SIG_DESC_SET(SCU694, 22)); 477 PIN_DECL_3(D21, GPIOG6, TXD9, SD2CD, SALT15); 478 GROUP_DECL(SALT15G0, D21); 479 480 #define B21 55 481 SIG_EXPR_LIST_DECL_SESG(B21, RXD9, UART9, SIG_DESC_SET(SCU414, 23)); 482 SIG_EXPR_LIST_DECL_SESG(B21, SD2WP, SD2, SIG_DESC_SET(SCU4B4, 23), 483 SIG_DESC_SET(SCU450, 1)); 484 SIG_EXPR_LIST_DECL_SEMG(B21, SALT16, SALT16G0, SALT16, 485 SIG_DESC_SET(SCU694, 23)); 486 PIN_DECL_3(B21, GPIOG7, RXD9, SD2WP, SALT16); 487 GROUP_DECL(SALT16G0, B21); 488 489 FUNC_GROUP_DECL(UART9, D21, B21); 490 491 FUNC_GROUP_DECL(SD2, E21, B22, C21, A22, A21, E20, D21, B21); 492 493 #define A18 56 494 SIG_EXPR_LIST_DECL_SESG(A18, SGPM1CLK, SGPM1, SIG_DESC_SET(SCU414, 24)); 495 PIN_DECL_1(A18, GPIOH0, SGPM1CLK); 496 497 #define B18 57 498 SIG_EXPR_LIST_DECL_SESG(B18, SGPM1LD, SGPM1, SIG_DESC_SET(SCU414, 25)); 499 PIN_DECL_1(B18, GPIOH1, SGPM1LD); 500 501 #define C18 58 502 SIG_EXPR_LIST_DECL_SESG(C18, SGPM1O, SGPM1, SIG_DESC_SET(SCU414, 26)); 503 PIN_DECL_1(C18, GPIOH2, SGPM1O); 504 505 #define A17 59 506 SIG_EXPR_LIST_DECL_SESG(A17, SGPM1I, SGPM1, SIG_DESC_SET(SCU414, 27)); 507 PIN_DECL_1(A17, GPIOH3, SGPM1I); 508 509 FUNC_GROUP_DECL(SGPM1, A18, B18, C18, A17); 510 511 #define D18 60 512 SIG_EXPR_LIST_DECL_SESG(D18, SGPS1CK, SGPS1, SIG_DESC_SET(SCU414, 28)); 513 SIG_EXPR_LIST_DECL_SESG(D18, SCL15, I2C15, SIG_DESC_SET(SCU4B4, 28)); 514 PIN_DECL_2(D18, GPIOH4, SGPS1CK, SCL15); 515 516 #define B17 61 517 SIG_EXPR_LIST_DECL_SESG(B17, SGPS1LD, SGPS1, SIG_DESC_SET(SCU414, 29)); 518 SIG_EXPR_LIST_DECL_SESG(B17, SDA15, I2C15, SIG_DESC_SET(SCU4B4, 29)); 519 PIN_DECL_2(B17, GPIOH5, SGPS1LD, SDA15); 520 521 FUNC_GROUP_DECL(I2C15, D18, B17); 522 523 #define C17 62 524 SIG_EXPR_LIST_DECL_SESG(C17, SGPS1O, SGPS1, SIG_DESC_SET(SCU414, 30)); 525 SIG_EXPR_LIST_DECL_SESG(C17, SCL16, I2C16, SIG_DESC_SET(SCU4B4, 30)); 526 PIN_DECL_2(C17, GPIOH6, SGPS1O, SCL16); 527 528 #define E18 63 529 SIG_EXPR_LIST_DECL_SESG(E18, SGPS1I, SGPS1, SIG_DESC_SET(SCU414, 31)); 530 SIG_EXPR_LIST_DECL_SESG(E18, SDA16, I2C16, SIG_DESC_SET(SCU4B4, 31)); 531 PIN_DECL_2(E18, GPIOH7, SGPS1I, SDA16); 532 533 FUNC_GROUP_DECL(I2C16, C17, E18); 534 FUNC_GROUP_DECL(SGPS1, D18, B17, C17, E18); 535 536 #define D17 64 537 SIG_EXPR_LIST_DECL_SESG(D17, MTRSTN, JTAGM, SIG_DESC_SET(SCU418, 0)); 538 SIG_EXPR_LIST_DECL_SEMG(D17, TXD12, UART12G0, UART12, SIG_DESC_SET(SCU4B8, 0)); 539 PIN_DECL_2(D17, GPIOI0, MTRSTN, TXD12); 540 541 #define A16 65 542 SIG_EXPR_LIST_DECL_SESG(A16, MTDI, JTAGM, SIG_DESC_SET(SCU418, 1)); 543 SIG_EXPR_LIST_DECL_SEMG(A16, RXD12, UART12G0, UART12, SIG_DESC_SET(SCU4B8, 1)); 544 PIN_DECL_2(A16, GPIOI1, MTDI, RXD12); 545 546 GROUP_DECL(UART12G0, D17, A16); 547 548 #define E17 66 549 SIG_EXPR_LIST_DECL_SESG(E17, MTCK, JTAGM, SIG_DESC_SET(SCU418, 2)); 550 SIG_EXPR_LIST_DECL_SEMG(E17, TXD13, UART13G0, UART13, SIG_DESC_SET(SCU4B8, 2)); 551 PIN_DECL_2(E17, GPIOI2, MTCK, TXD13); 552 553 #define D16 67 554 SIG_EXPR_LIST_DECL_SESG(D16, MTMS, JTAGM, SIG_DESC_SET(SCU418, 3)); 555 SIG_EXPR_LIST_DECL_SEMG(D16, RXD13, UART13G0, UART13, SIG_DESC_SET(SCU4B8, 3)); 556 PIN_DECL_2(D16, GPIOI3, MTMS, RXD13); 557 558 GROUP_DECL(UART13G0, E17, D16); 559 560 #define C16 68 561 SIG_EXPR_LIST_DECL_SESG(C16, MTDO, JTAGM, SIG_DESC_SET(SCU418, 4)); 562 PIN_DECL_1(C16, GPIOI4, MTDO); 563 564 FUNC_GROUP_DECL(JTAGM, D17, A16, E17, D16, C16); 565 566 #define E16 69 567 SIG_EXPR_LIST_DECL_SESG(E16, SIOPBO, SIOPBO, SIG_DESC_SET(SCU418, 5)); 568 PIN_DECL_1(E16, GPIOI5, SIOPBO); 569 FUNC_GROUP_DECL(SIOPBO, E16); 570 571 #define B16 70 572 SIG_EXPR_LIST_DECL_SESG(B16, SIOPBI, SIOPBI, SIG_DESC_SET(SCU418, 6)); 573 PIN_DECL_1(B16, GPIOI6, SIOPBI); 574 FUNC_GROUP_DECL(SIOPBI, B16); 575 576 #define A15 71 577 SIG_EXPR_LIST_DECL_SESG(A15, BMCINT, BMCINT, SIG_DESC_SET(SCU418, 7)); 578 SIG_EXPR_LIST_DECL_SESG(A15, SIOSCI, SIOSCI, SIG_DESC_SET(SCU4B8, 7)); 579 PIN_DECL_2(A15, GPIOI7, BMCINT, SIOSCI); 580 FUNC_GROUP_DECL(BMCINT, A15); 581 FUNC_GROUP_DECL(SIOSCI, A15); 582 583 #define B20 72 584 SIG_EXPR_LIST_DECL_SEMG(B20, I3C3SCL, HVI3C3, I3C3, SIG_DESC_SET(SCU418, 8)); 585 SIG_EXPR_LIST_DECL_SESG(B20, SCL1, I2C1, SIG_DESC_SET(SCU4B8, 8)); 586 PIN_DECL_2(B20, GPIOJ0, I3C3SCL, SCL1); 587 588 #define A20 73 589 SIG_EXPR_LIST_DECL_SEMG(A20, I3C3SDA, HVI3C3, I3C3, SIG_DESC_SET(SCU418, 9)); 590 SIG_EXPR_LIST_DECL_SESG(A20, SDA1, I2C1, SIG_DESC_SET(SCU4B8, 9)); 591 PIN_DECL_2(A20, GPIOJ1, I3C3SDA, SDA1); 592 593 GROUP_DECL(HVI3C3, B20, A20); 594 FUNC_GROUP_DECL(I2C1, B20, A20); 595 596 #define E19 74 597 SIG_EXPR_LIST_DECL_SEMG(E19, I3C4SCL, HVI3C4, I3C4, SIG_DESC_SET(SCU418, 10)); 598 SIG_EXPR_LIST_DECL_SESG(E19, SCL2, I2C2, SIG_DESC_SET(SCU4B8, 10)); 599 PIN_DECL_2(E19, GPIOJ2, I3C4SCL, SCL2); 600 601 #define D20 75 602 SIG_EXPR_LIST_DECL_SEMG(D20, I3C4SDA, HVI3C4, I3C4, SIG_DESC_SET(SCU418, 11)); 603 SIG_EXPR_LIST_DECL_SESG(D20, SDA2, I2C2, SIG_DESC_SET(SCU4B8, 11)); 604 PIN_DECL_2(D20, GPIOJ3, I3C4SDA, SDA2); 605 606 GROUP_DECL(HVI3C4, E19, D20); 607 FUNC_GROUP_DECL(I2C2, E19, D20); 608 609 #define C19 76 610 SIG_EXPR_LIST_DECL_SESG(C19, I3C5SCL, I3C5, SIG_DESC_SET(SCU418, 12)); 611 SIG_EXPR_LIST_DECL_SESG(C19, SCL3, I2C3, SIG_DESC_SET(SCU4B8, 12)); 612 PIN_DECL_2(C19, GPIOJ4, I3C5SCL, SCL3); 613 614 #define A19 77 615 SIG_EXPR_LIST_DECL_SESG(A19, I3C5SDA, I3C5, SIG_DESC_SET(SCU418, 13)); 616 SIG_EXPR_LIST_DECL_SESG(A19, SDA3, I2C3, SIG_DESC_SET(SCU4B8, 13)); 617 PIN_DECL_2(A19, GPIOJ5, I3C5SDA, SDA3); 618 619 FUNC_GROUP_DECL(I3C5, C19, A19); 620 FUNC_GROUP_DECL(I2C3, C19, A19); 621 622 #define C20 78 623 SIG_EXPR_LIST_DECL_SESG(C20, I3C6SCL, I3C6, SIG_DESC_SET(SCU418, 14)); 624 SIG_EXPR_LIST_DECL_SESG(C20, SCL4, I2C4, SIG_DESC_SET(SCU4B8, 14)); 625 PIN_DECL_2(C20, GPIOJ6, I3C6SCL, SCL4); 626 627 #define D19 79 628 SIG_EXPR_LIST_DECL_SESG(D19, I3C6SDA, I3C6, SIG_DESC_SET(SCU418, 15)); 629 SIG_EXPR_LIST_DECL_SESG(D19, SDA4, I2C4, SIG_DESC_SET(SCU4B8, 15)); 630 PIN_DECL_2(D19, GPIOJ7, I3C6SDA, SDA4); 631 632 FUNC_GROUP_DECL(I3C6, C20, D19); 633 FUNC_GROUP_DECL(I2C4, C20, D19); 634 635 #define A11 80 636 SIG_EXPR_LIST_DECL_SESG(A11, SCL5, I2C5, SIG_DESC_SET(SCU418, 16)); 637 PIN_DECL_1(A11, GPIOK0, SCL5); 638 639 #define C11 81 640 SIG_EXPR_LIST_DECL_SESG(C11, SDA5, I2C5, SIG_DESC_SET(SCU418, 17)); 641 PIN_DECL_1(C11, GPIOK1, SDA5); 642 643 FUNC_GROUP_DECL(I2C5, A11, C11); 644 645 #define D12 82 646 SIG_EXPR_LIST_DECL_SESG(D12, SCL6, I2C6, SIG_DESC_SET(SCU418, 18)); 647 PIN_DECL_1(D12, GPIOK2, SCL6); 648 649 #define E13 83 650 SIG_EXPR_LIST_DECL_SESG(E13, SDA6, I2C6, SIG_DESC_SET(SCU418, 19)); 651 PIN_DECL_1(E13, GPIOK3, SDA6); 652 653 FUNC_GROUP_DECL(I2C6, D12, E13); 654 655 #define D11 84 656 SIG_EXPR_LIST_DECL_SESG(D11, SCL7, I2C7, SIG_DESC_SET(SCU418, 20)); 657 PIN_DECL_1(D11, GPIOK4, SCL7); 658 659 #define E11 85 660 SIG_EXPR_LIST_DECL_SESG(E11, SDA7, I2C7, SIG_DESC_SET(SCU418, 21)); 661 PIN_DECL_1(E11, GPIOK5, SDA7); 662 663 FUNC_GROUP_DECL(I2C7, D11, E11); 664 665 #define F13 86 666 SIG_EXPR_LIST_DECL_SESG(F13, SCL8, I2C8, SIG_DESC_SET(SCU418, 22)); 667 PIN_DECL_1(F13, GPIOK6, SCL8); 668 669 #define E12 87 670 SIG_EXPR_LIST_DECL_SESG(E12, SDA8, I2C8, SIG_DESC_SET(SCU418, 23)); 671 PIN_DECL_1(E12, GPIOK7, SDA8); 672 673 FUNC_GROUP_DECL(I2C8, F13, E12); 674 675 #define D15 88 676 SIG_EXPR_LIST_DECL_SESG(D15, SCL9, I2C9, SIG_DESC_SET(SCU418, 24)); 677 PIN_DECL_1(D15, GPIOL0, SCL9); 678 679 #define A14 89 680 SIG_EXPR_LIST_DECL_SESG(A14, SDA9, I2C9, SIG_DESC_SET(SCU418, 25)); 681 PIN_DECL_1(A14, GPIOL1, SDA9); 682 683 FUNC_GROUP_DECL(I2C9, D15, A14); 684 685 #define E15 90 686 SIG_EXPR_LIST_DECL_SESG(E15, SCL10, I2C10, SIG_DESC_SET(SCU418, 26)); 687 PIN_DECL_1(E15, GPIOL2, SCL10); 688 689 #define A13 91 690 SIG_EXPR_LIST_DECL_SESG(A13, SDA10, I2C10, SIG_DESC_SET(SCU418, 27)); 691 PIN_DECL_1(A13, GPIOL3, SDA10); 692 693 FUNC_GROUP_DECL(I2C10, E15, A13); 694 695 #define C15 92 696 SSSF_PIN_DECL(C15, GPIOL4, TXD3, SIG_DESC_SET(SCU418, 28)); 697 698 #define F15 93 699 SSSF_PIN_DECL(F15, GPIOL5, RXD3, SIG_DESC_SET(SCU418, 29)); 700 701 #define B14 94 702 SSSF_PIN_DECL(B14, GPIOL6, VGAHS, SIG_DESC_SET(SCU418, 30)); 703 704 #define C14 95 705 SSSF_PIN_DECL(C14, GPIOL7, VGAVS, SIG_DESC_SET(SCU418, 31)); 706 707 #define D14 96 708 SSSF_PIN_DECL(D14, GPIOM0, NCTS1, SIG_DESC_SET(SCU41C, 0)); 709 710 #define B13 97 711 SSSF_PIN_DECL(B13, GPIOM1, NDCD1, SIG_DESC_SET(SCU41C, 1)); 712 713 #define A12 98 714 SSSF_PIN_DECL(A12, GPIOM2, NDSR1, SIG_DESC_SET(SCU41C, 2)); 715 716 #define E14 99 717 SSSF_PIN_DECL(E14, GPIOM3, NRI1, SIG_DESC_SET(SCU41C, 3)); 718 719 #define B12 100 720 SSSF_PIN_DECL(B12, GPIOM4, NDTR1, SIG_DESC_SET(SCU41C, 4)); 721 722 #define C12 101 723 SSSF_PIN_DECL(C12, GPIOM5, NRTS1, SIG_DESC_SET(SCU41C, 5)); 724 725 #define C13 102 726 SSSF_PIN_DECL(C13, GPIOM6, TXD1, SIG_DESC_SET(SCU41C, 6)); 727 728 #define D13 103 729 SSSF_PIN_DECL(D13, GPIOM7, RXD1, SIG_DESC_SET(SCU41C, 7)); 730 731 #define P25 104 732 SSSF_PIN_DECL(P25, GPION0, NCTS2, SIG_DESC_SET(SCU41C, 8)); 733 734 #define N23 105 735 SSSF_PIN_DECL(N23, GPION1, NDCD2, SIG_DESC_SET(SCU41C, 9)); 736 737 #define N25 106 738 SSSF_PIN_DECL(N25, GPION2, NDSR2, SIG_DESC_SET(SCU41C, 10)); 739 740 #define N24 107 741 SSSF_PIN_DECL(N24, GPION3, NRI2, SIG_DESC_SET(SCU41C, 11)); 742 743 #define P26 108 744 SSSF_PIN_DECL(P26, GPION4, NDTR2, SIG_DESC_SET(SCU41C, 12)); 745 746 #define M23 109 747 SSSF_PIN_DECL(M23, GPION5, NRTS2, SIG_DESC_SET(SCU41C, 13)); 748 749 #define N26 110 750 SSSF_PIN_DECL(N26, GPION6, TXD2, SIG_DESC_SET(SCU41C, 14)); 751 752 #define M26 111 753 SSSF_PIN_DECL(M26, GPION7, RXD2, SIG_DESC_SET(SCU41C, 15)); 754 755 #define AD26 112 756 SSSF_PIN_DECL(AD26, GPIOO0, PWM0, SIG_DESC_SET(SCU41C, 16)); 757 758 #define AD22 113 759 SSSF_PIN_DECL(AD22, GPIOO1, PWM1, SIG_DESC_SET(SCU41C, 17)); 760 761 #define AD23 114 762 SSSF_PIN_DECL(AD23, GPIOO2, PWM2, SIG_DESC_SET(SCU41C, 18)); 763 764 #define AD24 115 765 SSSF_PIN_DECL(AD24, GPIOO3, PWM3, SIG_DESC_SET(SCU41C, 19)); 766 767 #define AD25 116 768 SSSF_PIN_DECL(AD25, GPIOO4, PWM4, SIG_DESC_SET(SCU41C, 20)); 769 770 #define AC22 117 771 SSSF_PIN_DECL(AC22, GPIOO5, PWM5, SIG_DESC_SET(SCU41C, 21)); 772 773 #define AC24 118 774 SSSF_PIN_DECL(AC24, GPIOO6, PWM6, SIG_DESC_SET(SCU41C, 22)); 775 776 #define AC23 119 777 SSSF_PIN_DECL(AC23, GPIOO7, PWM7, SIG_DESC_SET(SCU41C, 23)); 778 779 #define AB22 120 780 SIG_EXPR_LIST_DECL_SEMG(AB22, PWM8, PWM8G1, PWM8, SIG_DESC_SET(SCU41C, 24)); 781 SIG_EXPR_LIST_DECL_SESG(AB22, THRUIN0, THRU0, SIG_DESC_SET(SCU4BC, 24)); 782 PIN_DECL_2(AB22, GPIOP0, PWM8, THRUIN0); 783 GROUP_DECL(PWM8G1, AB22); 784 FUNC_DECL_2(PWM8, PWM8G0, PWM8G1); 785 786 #define W24 121 787 SIG_EXPR_LIST_DECL_SEMG(W24, PWM9, PWM9G1, PWM9, SIG_DESC_SET(SCU41C, 25)); 788 SIG_EXPR_LIST_DECL_SESG(W24, THRUOUT0, THRU0, SIG_DESC_SET(SCU4BC, 25)); 789 PIN_DECL_2(W24, GPIOP1, PWM9, THRUOUT0); 790 791 FUNC_GROUP_DECL(THRU0, AB22, W24); 792 793 GROUP_DECL(PWM9G1, W24); 794 FUNC_DECL_2(PWM9, PWM9G0, PWM9G1); 795 796 #define AA23 122 797 SIG_EXPR_LIST_DECL_SEMG(AA23, PWM10, PWM10G1, PWM10, SIG_DESC_SET(SCU41C, 26)); 798 SIG_EXPR_LIST_DECL_SESG(AA23, THRUIN1, THRU1, SIG_DESC_SET(SCU4BC, 26)); 799 PIN_DECL_2(AA23, GPIOP2, PWM10, THRUIN1); 800 GROUP_DECL(PWM10G1, AA23); 801 FUNC_DECL_2(PWM10, PWM10G0, PWM10G1); 802 803 #define AA24 123 804 SIG_EXPR_LIST_DECL_SEMG(AA24, PWM11, PWM11G1, PWM11, SIG_DESC_SET(SCU41C, 27)); 805 SIG_EXPR_LIST_DECL_SESG(AA24, THRUOUT1, THRU1, SIG_DESC_SET(SCU4BC, 27)); 806 PIN_DECL_2(AA24, GPIOP3, PWM11, THRUOUT1); 807 GROUP_DECL(PWM11G1, AA24); 808 FUNC_DECL_2(PWM11, PWM11G0, PWM11G1); 809 810 FUNC_GROUP_DECL(THRU1, AA23, AA24); 811 812 #define W23 124 813 SIG_EXPR_LIST_DECL_SEMG(W23, PWM12, PWM12G1, PWM12, SIG_DESC_SET(SCU41C, 28)); 814 SIG_EXPR_LIST_DECL_SESG(W23, THRUIN2, THRU2, SIG_DESC_SET(SCU4BC, 28)); 815 PIN_DECL_2(W23, GPIOP4, PWM12, THRUIN2); 816 GROUP_DECL(PWM12G1, W23); 817 FUNC_DECL_2(PWM12, PWM12G0, PWM12G1); 818 819 #define AB23 125 820 SIG_EXPR_LIST_DECL_SEMG(AB23, PWM13, PWM13G1, PWM13, SIG_DESC_SET(SCU41C, 29)); 821 SIG_EXPR_LIST_DECL_SESG(AB23, THRUOUT2, THRU2, SIG_DESC_SET(SCU4BC, 29)); 822 PIN_DECL_2(AB23, GPIOP5, PWM13, THRUOUT2); 823 GROUP_DECL(PWM13G1, AB23); 824 FUNC_DECL_2(PWM13, PWM13G0, PWM13G1); 825 826 FUNC_GROUP_DECL(THRU2, W23, AB23); 827 828 #define AB24 126 829 SIG_EXPR_LIST_DECL_SEMG(AB24, PWM14, PWM14G1, PWM14, SIG_DESC_SET(SCU41C, 30)); 830 SIG_EXPR_LIST_DECL_SESG(AB24, THRUIN3, THRU3, SIG_DESC_SET(SCU4BC, 30)); 831 PIN_DECL_2(AB24, GPIOP6, PWM14, THRUIN3); 832 GROUP_DECL(PWM14G1, AB24); 833 FUNC_DECL_2(PWM14, PWM14G0, PWM14G1); 834 835 #define Y23 127 836 SIG_EXPR_LIST_DECL_SEMG(Y23, PWM15, PWM15G1, PWM15, SIG_DESC_SET(SCU41C, 31)); 837 SIG_EXPR_LIST_DECL_SESG(Y23, THRUOUT3, THRU3, SIG_DESC_SET(SCU4BC, 31)); 838 SIG_EXPR_LIST_DECL_SESG(Y23, HEARTBEAT, HEARTBEAT, SIG_DESC_SET(SCU69C, 31)); 839 PIN_DECL_3(Y23, GPIOP7, PWM15, THRUOUT3, HEARTBEAT); 840 GROUP_DECL(PWM15G1, Y23); 841 FUNC_DECL_2(PWM15, PWM15G0, PWM15G1); 842 843 FUNC_GROUP_DECL(THRU3, AB24, Y23); 844 FUNC_GROUP_DECL(HEARTBEAT, Y23); 845 846 #define AA25 128 847 SSSF_PIN_DECL(AA25, GPIOQ0, TACH0, SIG_DESC_SET(SCU430, 0)); 848 849 #define AB25 129 850 SSSF_PIN_DECL(AB25, GPIOQ1, TACH1, SIG_DESC_SET(SCU430, 1)); 851 852 #define Y24 130 853 SSSF_PIN_DECL(Y24, GPIOQ2, TACH2, SIG_DESC_SET(SCU430, 2)); 854 855 #define AB26 131 856 SSSF_PIN_DECL(AB26, GPIOQ3, TACH3, SIG_DESC_SET(SCU430, 3)); 857 858 #define Y26 132 859 SSSF_PIN_DECL(Y26, GPIOQ4, TACH4, SIG_DESC_SET(SCU430, 4)); 860 861 #define AC26 133 862 SSSF_PIN_DECL(AC26, GPIOQ5, TACH5, SIG_DESC_SET(SCU430, 5)); 863 864 #define Y25 134 865 SSSF_PIN_DECL(Y25, GPIOQ6, TACH6, SIG_DESC_SET(SCU430, 6)); 866 867 #define AA26 135 868 SSSF_PIN_DECL(AA26, GPIOQ7, TACH7, SIG_DESC_SET(SCU430, 7)); 869 870 #define V25 136 871 SSSF_PIN_DECL(V25, GPIOR0, TACH8, SIG_DESC_SET(SCU430, 8)); 872 873 #define U24 137 874 SSSF_PIN_DECL(U24, GPIOR1, TACH9, SIG_DESC_SET(SCU430, 9)); 875 876 #define V24 138 877 SSSF_PIN_DECL(V24, GPIOR2, TACH10, SIG_DESC_SET(SCU430, 10)); 878 879 #define V26 139 880 SSSF_PIN_DECL(V26, GPIOR3, TACH11, SIG_DESC_SET(SCU430, 11)); 881 882 #define U25 140 883 SSSF_PIN_DECL(U25, GPIOR4, TACH12, SIG_DESC_SET(SCU430, 12)); 884 885 #define T23 141 886 SSSF_PIN_DECL(T23, GPIOR5, TACH13, SIG_DESC_SET(SCU430, 13)); 887 888 #define W26 142 889 SSSF_PIN_DECL(W26, GPIOR6, TACH14, SIG_DESC_SET(SCU430, 14)); 890 891 #define U26 143 892 SSSF_PIN_DECL(U26, GPIOR7, TACH15, SIG_DESC_SET(SCU430, 15)); 893 894 #define R23 144 895 SIG_EXPR_LIST_DECL_SESG(R23, MDC1, MDIO1, SIG_DESC_SET(SCU430, 16)); 896 PIN_DECL_1(R23, GPIOS0, MDC1); 897 898 #define T25 145 899 SIG_EXPR_LIST_DECL_SESG(T25, MDIO1, MDIO1, SIG_DESC_SET(SCU430, 17)); 900 PIN_DECL_1(T25, GPIOS1, MDIO1); 901 902 FUNC_GROUP_DECL(MDIO1, R23, T25); 903 904 #define T26 146 905 SSSF_PIN_DECL(T26, GPIOS2, PEWAKE, SIG_DESC_SET(SCU430, 18)); 906 907 #define R24 147 908 SSSF_PIN_DECL(R24, GPIOS3, OSCCLK, SIG_DESC_SET(SCU430, 19)); 909 910 #define R26 148 911 SIG_EXPR_LIST_DECL_SESG(R26, TXD10, UART10, SIG_DESC_SET(SCU430, 20)); 912 PIN_DECL_1(R26, GPIOS4, TXD10); 913 914 #define P24 149 915 SIG_EXPR_LIST_DECL_SESG(P24, RXD10, UART10, SIG_DESC_SET(SCU430, 21)); 916 PIN_DECL_1(P24, GPIOS5, RXD10); 917 918 FUNC_GROUP_DECL(UART10, R26, P24); 919 920 #define P23 150 921 SIG_EXPR_LIST_DECL_SESG(P23, TXD11, UART11, SIG_DESC_SET(SCU430, 22)); 922 PIN_DECL_1(P23, GPIOS6, TXD11); 923 924 #define T24 151 925 SIG_EXPR_LIST_DECL_SESG(T24, RXD11, UART11, SIG_DESC_SET(SCU430, 23)); 926 PIN_DECL_1(T24, GPIOS7, RXD11); 927 928 FUNC_GROUP_DECL(UART11, P23, T24); 929 930 #define AD20 152 931 SIG_EXPR_LIST_DECL_SESG(AD20, GPIT0, GPIT0, SIG_DESC_SET(SCU430, 24)); 932 SIG_EXPR_LIST_DECL_SESG(AD20, ADC0, ADC0); 933 PIN_DECL_(AD20, SIG_EXPR_LIST_PTR(AD20, GPIT0), SIG_EXPR_LIST_PTR(AD20, ADC0)); 934 FUNC_GROUP_DECL(GPIT0, AD20); 935 FUNC_GROUP_DECL(ADC0, AD20); 936 937 #define AC18 153 938 SIG_EXPR_LIST_DECL_SESG(AC18, GPIT1, GPIT1, SIG_DESC_SET(SCU430, 25)); 939 SIG_EXPR_LIST_DECL_SESG(AC18, ADC1, ADC1); 940 PIN_DECL_(AC18, SIG_EXPR_LIST_PTR(AC18, GPIT1), SIG_EXPR_LIST_PTR(AC18, ADC1)); 941 FUNC_GROUP_DECL(GPIT1, AC18); 942 FUNC_GROUP_DECL(ADC1, AC18); 943 944 #define AE19 154 945 SIG_EXPR_LIST_DECL_SESG(AE19, GPIT2, GPIT2, SIG_DESC_SET(SCU430, 26)); 946 SIG_EXPR_LIST_DECL_SESG(AE19, ADC2, ADC2); 947 PIN_DECL_(AE19, SIG_EXPR_LIST_PTR(AE19, GPIT2), SIG_EXPR_LIST_PTR(AE19, ADC2)); 948 FUNC_GROUP_DECL(GPIT2, AE19); 949 FUNC_GROUP_DECL(ADC2, AE19); 950 951 #define AD19 155 952 SIG_EXPR_LIST_DECL_SESG(AD19, GPIT3, GPIT3, SIG_DESC_SET(SCU430, 27)); 953 SIG_EXPR_LIST_DECL_SESG(AD19, ADC3, ADC3); 954 PIN_DECL_(AD19, SIG_EXPR_LIST_PTR(AD19, GPIT3), SIG_EXPR_LIST_PTR(AD19, ADC3)); 955 FUNC_GROUP_DECL(GPIT3, AD19); 956 FUNC_GROUP_DECL(ADC3, AD19); 957 958 #define AC19 156 959 SIG_EXPR_LIST_DECL_SESG(AC19, GPIT4, GPIT4, SIG_DESC_SET(SCU430, 28)); 960 SIG_EXPR_LIST_DECL_SESG(AC19, ADC4, ADC4); 961 PIN_DECL_(AC19, SIG_EXPR_LIST_PTR(AC19, GPIT4), SIG_EXPR_LIST_PTR(AC19, ADC4)); 962 FUNC_GROUP_DECL(GPIT4, AC19); 963 FUNC_GROUP_DECL(ADC4, AC19); 964 965 #define AB19 157 966 SIG_EXPR_LIST_DECL_SESG(AB19, GPIT5, GPIT5, SIG_DESC_SET(SCU430, 29)); 967 SIG_EXPR_LIST_DECL_SESG(AB19, ADC5, ADC5); 968 PIN_DECL_(AB19, SIG_EXPR_LIST_PTR(AB19, GPIT5), SIG_EXPR_LIST_PTR(AB19, ADC5)); 969 FUNC_GROUP_DECL(GPIT5, AB19); 970 FUNC_GROUP_DECL(ADC5, AB19); 971 972 #define AB18 158 973 SIG_EXPR_LIST_DECL_SESG(AB18, GPIT6, GPIT6, SIG_DESC_SET(SCU430, 30)); 974 SIG_EXPR_LIST_DECL_SESG(AB18, ADC6, ADC6); 975 PIN_DECL_(AB18, SIG_EXPR_LIST_PTR(AB18, GPIT6), SIG_EXPR_LIST_PTR(AB18, ADC6)); 976 FUNC_GROUP_DECL(GPIT6, AB18); 977 FUNC_GROUP_DECL(ADC6, AB18); 978 979 #define AE18 159 980 SIG_EXPR_LIST_DECL_SESG(AE18, GPIT7, GPIT7, SIG_DESC_SET(SCU430, 31)); 981 SIG_EXPR_LIST_DECL_SESG(AE18, ADC7, ADC7); 982 PIN_DECL_(AE18, SIG_EXPR_LIST_PTR(AE18, GPIT7), SIG_EXPR_LIST_PTR(AE18, ADC7)); 983 FUNC_GROUP_DECL(GPIT7, AE18); 984 FUNC_GROUP_DECL(ADC7, AE18); 985 986 #define AB16 160 987 SIG_EXPR_LIST_DECL_SEMG(AB16, SALT9, SALT9G1, SALT9, SIG_DESC_SET(SCU434, 0), 988 SIG_DESC_CLEAR(SCU694, 16)); 989 SIG_EXPR_LIST_DECL_SESG(AB16, GPIU0, GPIU0, SIG_DESC_SET(SCU434, 0), 990 SIG_DESC_SET(SCU694, 16)); 991 SIG_EXPR_LIST_DECL_SESG(AB16, ADC8, ADC8); 992 PIN_DECL_(AB16, SIG_EXPR_LIST_PTR(AB16, SALT9), SIG_EXPR_LIST_PTR(AB16, GPIU0), 993 SIG_EXPR_LIST_PTR(AB16, ADC8)); 994 GROUP_DECL(SALT9G1, AB16); 995 FUNC_DECL_2(SALT9, SALT9G0, SALT9G1); 996 FUNC_GROUP_DECL(GPIU0, AB16); 997 FUNC_GROUP_DECL(ADC8, AB16); 998 999 #define AA17 161 1000 SIG_EXPR_LIST_DECL_SEMG(AA17, SALT10, SALT10G1, SALT10, SIG_DESC_SET(SCU434, 1), 1001 SIG_DESC_CLEAR(SCU694, 17)); 1002 SIG_EXPR_LIST_DECL_SESG(AA17, GPIU1, GPIU1, SIG_DESC_SET(SCU434, 1), 1003 SIG_DESC_SET(SCU694, 17)); 1004 SIG_EXPR_LIST_DECL_SESG(AA17, ADC9, ADC9); 1005 PIN_DECL_(AA17, SIG_EXPR_LIST_PTR(AA17, SALT10), SIG_EXPR_LIST_PTR(AA17, GPIU1), 1006 SIG_EXPR_LIST_PTR(AA17, ADC9)); 1007 GROUP_DECL(SALT10G1, AA17); 1008 FUNC_DECL_2(SALT10, SALT10G0, SALT10G1); 1009 FUNC_GROUP_DECL(GPIU1, AA17); 1010 FUNC_GROUP_DECL(ADC9, AA17); 1011 1012 #define AB17 162 1013 SIG_EXPR_LIST_DECL_SEMG(AB17, SALT11, SALT11G1, SALT11, SIG_DESC_SET(SCU434, 2), 1014 SIG_DESC_CLEAR(SCU694, 18)); 1015 SIG_EXPR_LIST_DECL_SESG(AB17, GPIU2, GPIU2, SIG_DESC_SET(SCU434, 2), 1016 SIG_DESC_SET(SCU694, 18)); 1017 SIG_EXPR_LIST_DECL_SESG(AB17, ADC10, ADC10); 1018 PIN_DECL_(AB17, SIG_EXPR_LIST_PTR(AB17, SALT11), SIG_EXPR_LIST_PTR(AB17, GPIU2), 1019 SIG_EXPR_LIST_PTR(AB17, ADC10)); 1020 GROUP_DECL(SALT11G1, AB17); 1021 FUNC_DECL_2(SALT11, SALT11G0, SALT11G1); 1022 FUNC_GROUP_DECL(GPIU2, AB17); 1023 FUNC_GROUP_DECL(ADC10, AB17); 1024 1025 #define AE16 163 1026 SIG_EXPR_LIST_DECL_SEMG(AE16, SALT12, SALT12G1, SALT12, SIG_DESC_SET(SCU434, 3), 1027 SIG_DESC_CLEAR(SCU694, 19)); 1028 SIG_EXPR_LIST_DECL_SESG(AE16, GPIU3, GPIU3, SIG_DESC_SET(SCU434, 3), 1029 SIG_DESC_SET(SCU694, 19)); 1030 SIG_EXPR_LIST_DECL_SESG(AE16, ADC11, ADC11); 1031 PIN_DECL_(AE16, SIG_EXPR_LIST_PTR(AE16, SALT12), SIG_EXPR_LIST_PTR(AE16, GPIU3), 1032 SIG_EXPR_LIST_PTR(AE16, ADC11)); 1033 GROUP_DECL(SALT12G1, AE16); 1034 FUNC_DECL_2(SALT12, SALT12G0, SALT12G1); 1035 FUNC_GROUP_DECL(GPIU3, AE16); 1036 FUNC_GROUP_DECL(ADC11, AE16); 1037 1038 #define AC16 164 1039 SIG_EXPR_LIST_DECL_SEMG(AC16, SALT13, SALT13G1, SALT13, SIG_DESC_SET(SCU434, 4), 1040 SIG_DESC_CLEAR(SCU694, 20)); 1041 SIG_EXPR_LIST_DECL_SESG(AC16, GPIU4, GPIU4, SIG_DESC_SET(SCU434, 4), 1042 SIG_DESC_SET(SCU694, 20)); 1043 SIG_EXPR_LIST_DECL_SESG(AC16, ADC12, ADC12); 1044 PIN_DECL_(AC16, SIG_EXPR_LIST_PTR(AC16, SALT13), SIG_EXPR_LIST_PTR(AC16, GPIU4), 1045 SIG_EXPR_LIST_PTR(AC16, ADC12)); 1046 GROUP_DECL(SALT13G1, AC16); 1047 FUNC_DECL_2(SALT13, SALT13G0, SALT13G1); 1048 FUNC_GROUP_DECL(GPIU4, AC16); 1049 FUNC_GROUP_DECL(ADC12, AC16); 1050 1051 #define AA16 165 1052 SIG_EXPR_LIST_DECL_SEMG(AA16, SALT14, SALT14G1, SALT14, SIG_DESC_SET(SCU434, 5), 1053 SIG_DESC_CLEAR(SCU694, 21)); 1054 SIG_EXPR_LIST_DECL_SESG(AA16, GPIU5, GPIU5, SIG_DESC_SET(SCU434, 5), 1055 SIG_DESC_SET(SCU694, 21)); 1056 SIG_EXPR_LIST_DECL_SESG(AA16, ADC13, ADC13); 1057 PIN_DECL_(AA16, SIG_EXPR_LIST_PTR(AA16, SALT14), SIG_EXPR_LIST_PTR(AA16, GPIU5), 1058 SIG_EXPR_LIST_PTR(AA16, ADC13)); 1059 GROUP_DECL(SALT14G1, AA16); 1060 FUNC_DECL_2(SALT14, SALT14G0, SALT14G1); 1061 FUNC_GROUP_DECL(GPIU5, AA16); 1062 FUNC_GROUP_DECL(ADC13, AA16); 1063 1064 #define AD16 166 1065 SIG_EXPR_LIST_DECL_SEMG(AD16, SALT15, SALT15G1, SALT15, SIG_DESC_SET(SCU434, 6), 1066 SIG_DESC_CLEAR(SCU694, 22)); 1067 SIG_EXPR_LIST_DECL_SESG(AD16, GPIU6, GPIU6, SIG_DESC_SET(SCU434, 6), 1068 SIG_DESC_SET(SCU694, 22)); 1069 SIG_EXPR_LIST_DECL_SESG(AD16, ADC14, ADC14); 1070 PIN_DECL_(AD16, SIG_EXPR_LIST_PTR(AD16, SALT15), SIG_EXPR_LIST_PTR(AD16, GPIU6), 1071 SIG_EXPR_LIST_PTR(AD16, ADC14)); 1072 GROUP_DECL(SALT15G1, AD16); 1073 FUNC_DECL_2(SALT15, SALT15G0, SALT15G1); 1074 FUNC_GROUP_DECL(GPIU6, AD16); 1075 FUNC_GROUP_DECL(ADC14, AD16); 1076 1077 #define AC17 167 1078 SIG_EXPR_LIST_DECL_SEMG(AC17, SALT16, SALT16G1, SALT16, SIG_DESC_SET(SCU434, 7), 1079 SIG_DESC_CLEAR(SCU694, 23)); 1080 SIG_EXPR_LIST_DECL_SESG(AC17, GPIU7, GPIU7, SIG_DESC_SET(SCU434, 7), 1081 SIG_DESC_SET(SCU694, 23)); 1082 SIG_EXPR_LIST_DECL_SESG(AC17, ADC15, ADC15); 1083 PIN_DECL_(AC17, SIG_EXPR_LIST_PTR(AC17, SALT16), SIG_EXPR_LIST_PTR(AC17, GPIU7), 1084 SIG_EXPR_LIST_PTR(AC17, ADC15)); 1085 GROUP_DECL(SALT16G1, AC17); 1086 FUNC_DECL_2(SALT16, SALT16G0, SALT16G1); 1087 FUNC_GROUP_DECL(GPIU7, AC17); 1088 FUNC_GROUP_DECL(ADC15, AC17); 1089 1090 #define AB15 168 1091 SSSF_PIN_DECL(AB15, GPIOV0, SIOS3, SIG_DESC_SET(SCU434, 8)); 1092 1093 #define AF14 169 1094 SSSF_PIN_DECL(AF14, GPIOV1, SIOS5, SIG_DESC_SET(SCU434, 9)); 1095 1096 #define AD14 170 1097 SSSF_PIN_DECL(AD14, GPIOV2, SIOPWREQ, SIG_DESC_SET(SCU434, 10)); 1098 1099 #define AC15 171 1100 SSSF_PIN_DECL(AC15, GPIOV3, SIOONCTRL, SIG_DESC_SET(SCU434, 11)); 1101 1102 #define AE15 172 1103 SSSF_PIN_DECL(AE15, GPIOV4, SIOPWRGD, SIG_DESC_SET(SCU434, 12)); 1104 1105 #define AE14 173 1106 SIG_EXPR_LIST_DECL_SESG(AE14, LPCPD, LPCPD, SIG_DESC_SET(SCU434, 13)); 1107 SIG_EXPR_LIST_DECL_SESG(AE14, LHPD, LHPD, SIG_DESC_SET(SCU4D4, 13)); 1108 PIN_DECL_2(AE14, GPIOV5, LPCPD, LHPD); 1109 FUNC_GROUP_DECL(LPCPD, AE14); 1110 FUNC_GROUP_DECL(LHPD, AE14); 1111 1112 #define AD15 174 1113 SSSF_PIN_DECL(AD15, GPIOV6, LPCPME, SIG_DESC_SET(SCU434, 14)); 1114 1115 #define AF15 175 1116 SSSF_PIN_DECL(AF15, GPIOV7, LPCSMI, SIG_DESC_SET(SCU434, 15)); 1117 1118 #define AB7 176 1119 SIG_EXPR_LIST_DECL_SESG(AB7, LAD0, LPC, SIG_DESC_SET(SCU434, 16), 1120 SIG_DESC_SET(SCU510, 6)); 1121 SIG_EXPR_LIST_DECL_SESG(AB7, ESPID0, ESPI, SIG_DESC_SET(SCU434, 16)); 1122 PIN_DECL_2(AB7, GPIOW0, LAD0, ESPID0); 1123 1124 #define AB8 177 1125 SIG_EXPR_LIST_DECL_SESG(AB8, LAD1, LPC, SIG_DESC_SET(SCU434, 17), 1126 SIG_DESC_SET(SCU510, 6)); 1127 SIG_EXPR_LIST_DECL_SESG(AB8, ESPID1, ESPI, SIG_DESC_SET(SCU434, 17)); 1128 PIN_DECL_2(AB8, GPIOW1, LAD1, ESPID1); 1129 1130 #define AC8 178 1131 SIG_EXPR_LIST_DECL_SESG(AC8, LAD2, LPC, SIG_DESC_SET(SCU434, 18), 1132 SIG_DESC_SET(SCU510, 6)); 1133 SIG_EXPR_LIST_DECL_SESG(AC8, ESPID2, ESPI, SIG_DESC_SET(SCU434, 18)); 1134 PIN_DECL_2(AC8, GPIOW2, LAD2, ESPID2); 1135 1136 #define AC7 179 1137 SIG_EXPR_LIST_DECL_SESG(AC7, LAD3, LPC, SIG_DESC_SET(SCU434, 19), 1138 SIG_DESC_SET(SCU510, 6)); 1139 SIG_EXPR_LIST_DECL_SESG(AC7, ESPID3, ESPI, SIG_DESC_SET(SCU434, 19)); 1140 PIN_DECL_2(AC7, GPIOW3, LAD3, ESPID3); 1141 1142 #define AE7 180 1143 SIG_EXPR_LIST_DECL_SESG(AE7, LCLK, LPC, SIG_DESC_SET(SCU434, 20), 1144 SIG_DESC_SET(SCU510, 6)); 1145 SIG_EXPR_LIST_DECL_SESG(AE7, ESPICK, ESPI, SIG_DESC_SET(SCU434, 20)); 1146 PIN_DECL_2(AE7, GPIOW4, LCLK, ESPICK); 1147 1148 #define AF7 181 1149 SIG_EXPR_LIST_DECL_SESG(AF7, LFRAME, LPC, SIG_DESC_SET(SCU434, 21), 1150 SIG_DESC_SET(SCU510, 6)); 1151 SIG_EXPR_LIST_DECL_SESG(AF7, ESPICS, ESPI, SIG_DESC_SET(SCU434, 21)); 1152 PIN_DECL_2(AF7, GPIOW5, LFRAME, ESPICS); 1153 1154 #define AD7 182 1155 SIG_EXPR_LIST_DECL_SESG(AD7, LSIRQ, LSIRQ, SIG_DESC_SET(SCU434, 22), 1156 SIG_DESC_SET(SCU510, 6)); 1157 SIG_EXPR_LIST_DECL_SESG(AD7, ESPIALT, ESPIALT, SIG_DESC_SET(SCU434, 22)); 1158 PIN_DECL_2(AD7, GPIOW6, LSIRQ, ESPIALT); 1159 FUNC_GROUP_DECL(LSIRQ, AD7); 1160 FUNC_GROUP_DECL(ESPIALT, AD7); 1161 1162 #define AD8 183 1163 SIG_EXPR_LIST_DECL_SESG(AD8, LPCRST, LPC, SIG_DESC_SET(SCU434, 23), 1164 SIG_DESC_SET(SCU510, 6)); 1165 SIG_EXPR_LIST_DECL_SESG(AD8, ESPIRST, ESPI, SIG_DESC_SET(SCU434, 23)); 1166 PIN_DECL_2(AD8, GPIOW7, LPCRST, ESPIRST); 1167 1168 FUNC_GROUP_DECL(LPC, AB7, AB8, AC8, AC7, AE7, AF7, AD8); 1169 FUNC_GROUP_DECL(ESPI, AB7, AB8, AC8, AC7, AE7, AF7, AD8); 1170 1171 #define AE8 184 1172 SIG_EXPR_LIST_DECL_SEMG(AE8, SPI2CS0, SPI2, SPI2, SIG_DESC_SET(SCU434, 24)); 1173 PIN_DECL_1(AE8, GPIOX0, SPI2CS0); 1174 1175 #define AA9 185 1176 SSSF_PIN_DECL(AA9, GPIOX1, SPI2CS1, SIG_DESC_SET(SCU434, 25)); 1177 1178 #define AC9 186 1179 SSSF_PIN_DECL(AC9, GPIOX2, SPI2CS2, SIG_DESC_SET(SCU434, 26)); 1180 1181 #define AF8 187 1182 SIG_EXPR_LIST_DECL_SEMG(AF8, SPI2CK, SPI2, SPI2, SIG_DESC_SET(SCU434, 27)); 1183 PIN_DECL_1(AF8, GPIOX3, SPI2CK); 1184 1185 #define AB9 188 1186 SIG_EXPR_LIST_DECL_SEMG(AB9, SPI2MOSI, SPI2, SPI2, SIG_DESC_SET(SCU434, 28)); 1187 PIN_DECL_1(AB9, GPIOX4, SPI2MOSI); 1188 1189 #define AD9 189 1190 SIG_EXPR_LIST_DECL_SEMG(AD9, SPI2MISO, SPI2, SPI2, SIG_DESC_SET(SCU434, 29)); 1191 PIN_DECL_1(AD9, GPIOX5, SPI2MISO); 1192 1193 GROUP_DECL(SPI2, AE8, AF8, AB9, AD9); 1194 1195 #define AF9 190 1196 SIG_EXPR_LIST_DECL_SEMG(AF9, SPI2DQ2, QSPI2, SPI2, SIG_DESC_SET(SCU434, 30)); 1197 SIG_EXPR_LIST_DECL_SEMG(AF9, TXD12, UART12G1, UART12, SIG_DESC_SET(SCU4D4, 30)); 1198 PIN_DECL_2(AF9, GPIOX6, SPI2DQ2, TXD12); 1199 1200 #define AB10 191 1201 SIG_EXPR_LIST_DECL_SEMG(AB10, SPI2DQ3, QSPI2, SPI2, SIG_DESC_SET(SCU434, 31)); 1202 SIG_EXPR_LIST_DECL_SEMG(AB10, RXD12, UART12G1, UART12, 1203 SIG_DESC_SET(SCU4D4, 31)); 1204 PIN_DECL_2(AB10, GPIOX7, SPI2DQ3, RXD12); 1205 1206 GROUP_DECL(QSPI2, AE8, AF8, AB9, AD9, AF9, AB10); 1207 FUNC_DECL_2(SPI2, SPI2, QSPI2); 1208 1209 GROUP_DECL(UART12G1, AF9, AB10); 1210 FUNC_DECL_2(UART12, UART12G0, UART12G1); 1211 1212 #define AF11 192 1213 SIG_EXPR_LIST_DECL_SESG(AF11, SALT5, SALT5, SIG_DESC_SET(SCU438, 0)); 1214 SIG_EXPR_LIST_DECL_SESG(AF11, WDTRST1, WDTRST1, SIG_DESC_SET(SCU4D8, 0)); 1215 PIN_DECL_2(AF11, GPIOY0, SALT5, WDTRST1); 1216 FUNC_GROUP_DECL(SALT5, AF11); 1217 FUNC_GROUP_DECL(WDTRST1, AF11); 1218 1219 #define AD12 193 1220 SIG_EXPR_LIST_DECL_SESG(AD12, SALT6, SALT6, SIG_DESC_SET(SCU438, 1)); 1221 SIG_EXPR_LIST_DECL_SESG(AD12, WDTRST2, WDTRST2, SIG_DESC_SET(SCU4D8, 1)); 1222 PIN_DECL_2(AD12, GPIOY1, SALT6, WDTRST2); 1223 FUNC_GROUP_DECL(SALT6, AD12); 1224 FUNC_GROUP_DECL(WDTRST2, AD12); 1225 1226 #define AE11 194 1227 SIG_EXPR_LIST_DECL_SESG(AE11, SALT7, SALT7, SIG_DESC_SET(SCU438, 2)); 1228 SIG_EXPR_LIST_DECL_SESG(AE11, WDTRST3, WDTRST3, SIG_DESC_SET(SCU4D8, 2)); 1229 PIN_DECL_2(AE11, GPIOY2, SALT7, WDTRST3); 1230 FUNC_GROUP_DECL(SALT7, AE11); 1231 FUNC_GROUP_DECL(WDTRST3, AE11); 1232 1233 #define AA12 195 1234 SIG_EXPR_LIST_DECL_SESG(AA12, SALT8, SALT8, SIG_DESC_SET(SCU438, 3)); 1235 SIG_EXPR_LIST_DECL_SESG(AA12, WDTRST4, WDTRST4, SIG_DESC_SET(SCU4D8, 3)); 1236 PIN_DECL_2(AA12, GPIOY3, SALT8, WDTRST4); 1237 FUNC_GROUP_DECL(SALT8, AA12); 1238 FUNC_GROUP_DECL(WDTRST4, AA12); 1239 1240 #define AE12 196 1241 SIG_EXPR_LIST_DECL_SESG(AE12, FWSPIQ2, FWQSPI, SIG_DESC_SET(SCU438, 4)); 1242 SIG_EXPR_LIST_DECL_SESG(AE12, GPIOY4, GPIOY4); 1243 PIN_DECL_(AE12, SIG_EXPR_LIST_PTR(AE12, FWSPIQ2), 1244 SIG_EXPR_LIST_PTR(AE12, GPIOY4)); 1245 1246 #define AF12 197 1247 SIG_EXPR_LIST_DECL_SESG(AF12, FWSPIQ3, FWQSPI, SIG_DESC_SET(SCU438, 5)); 1248 SIG_EXPR_LIST_DECL_SESG(AF12, GPIOY5, GPIOY5); 1249 PIN_DECL_(AF12, SIG_EXPR_LIST_PTR(AF12, FWSPIQ3), 1250 SIG_EXPR_LIST_PTR(AF12, GPIOY5)); 1251 FUNC_GROUP_DECL(FWQSPI, AE12, AF12); 1252 1253 #define AC12 198 1254 SSSF_PIN_DECL(AC12, GPIOY6, FWSPIABR, SIG_DESC_SET(SCU438, 6)); 1255 1256 #define AB12 199 1257 SSSF_PIN_DECL(AB12, GPIOY7, FWSPIWP, SIG_DESC_SET(SCU438, 7)); 1258 1259 #define AC10 200 1260 SSSF_PIN_DECL(AC10, GPIOZ0, SPI1CS1, SIG_DESC_SET(SCU438, 8)); 1261 1262 #define AD10 201 1263 SSSF_PIN_DECL(AD10, GPIOZ1, SPI1ABR, SIG_DESC_SET(SCU438, 9)); 1264 1265 #define AE10 202 1266 SSSF_PIN_DECL(AE10, GPIOZ2, SPI1WP, SIG_DESC_SET(SCU438, 10)); 1267 1268 #define AB11 203 1269 SIG_EXPR_LIST_DECL_SEMG(AB11, SPI1CK, SPI1, SPI1, SIG_DESC_SET(SCU438, 11)); 1270 PIN_DECL_1(AB11, GPIOZ3, SPI1CK); 1271 1272 #define AC11 204 1273 SIG_EXPR_LIST_DECL_SEMG(AC11, SPI1MOSI, SPI1, SPI1, SIG_DESC_SET(SCU438, 12)); 1274 PIN_DECL_1(AC11, GPIOZ4, SPI1MOSI); 1275 1276 #define AA11 205 1277 SIG_EXPR_LIST_DECL_SEMG(AA11, SPI1MISO, SPI1, SPI1, SIG_DESC_SET(SCU438, 13)); 1278 PIN_DECL_1(AA11, GPIOZ5, SPI1MISO); 1279 1280 GROUP_DECL(SPI1, AB11, AC11, AA11); 1281 1282 #define AD11 206 1283 SIG_EXPR_LIST_DECL_SEMG(AD11, SPI1DQ2, QSPI1, SPI1, SIG_DESC_SET(SCU438, 14)); 1284 SIG_EXPR_LIST_DECL_SEMG(AD11, TXD13, UART13G1, UART13, 1285 SIG_DESC_CLEAR(SCU4B8, 2), SIG_DESC_SET(SCU4D8, 14)); 1286 PIN_DECL_2(AD11, GPIOZ6, SPI1DQ2, TXD13); 1287 1288 #define AF10 207 1289 SIG_EXPR_LIST_DECL_SEMG(AF10, SPI1DQ3, QSPI1, SPI1, SIG_DESC_SET(SCU438, 15)); 1290 SIG_EXPR_LIST_DECL_SEMG(AF10, RXD13, UART13G1, UART13, 1291 SIG_DESC_CLEAR(SCU4B8, 3), SIG_DESC_SET(SCU4D8, 15)); 1292 PIN_DECL_2(AF10, GPIOZ7, SPI1DQ3, RXD13); 1293 1294 GROUP_DECL(QSPI1, AB11, AC11, AA11, AD11, AF10); 1295 FUNC_DECL_2(SPI1, SPI1, QSPI1); 1296 1297 GROUP_DECL(UART13G1, AD11, AF10); 1298 FUNC_DECL_2(UART13, UART13G0, UART13G1); 1299 1300 #define C6 208 1301 SIG_EXPR_LIST_DECL_SESG(C6, RGMII1TXCK, RGMII1, SIG_DESC_SET(SCU400, 0), 1302 SIG_DESC_SET(SCU500, 6)); 1303 SIG_EXPR_LIST_DECL_SESG(C6, RMII1RCLKO, RMII1, SIG_DESC_SET(SCU400, 0), 1304 SIG_DESC_CLEAR(SCU500, 6)); 1305 PIN_DECL_2(C6, GPIO18A0, RGMII1TXCK, RMII1RCLKO); 1306 1307 #define D6 209 1308 SIG_EXPR_LIST_DECL_SESG(D6, RGMII1TXCTL, RGMII1, SIG_DESC_SET(SCU400, 1), 1309 SIG_DESC_SET(SCU500, 6)); 1310 SIG_EXPR_LIST_DECL_SESG(D6, RMII1TXEN, RMII1, SIG_DESC_SET(SCU400, 1), 1311 SIG_DESC_CLEAR(SCU500, 6)); 1312 PIN_DECL_2(D6, GPIO18A1, RGMII1TXCTL, RMII1TXEN); 1313 1314 #define D5 210 1315 SIG_EXPR_LIST_DECL_SESG(D5, RGMII1TXD0, RGMII1, SIG_DESC_SET(SCU400, 2), 1316 SIG_DESC_SET(SCU500, 6)); 1317 SIG_EXPR_LIST_DECL_SESG(D5, RMII1TXD0, RMII1, SIG_DESC_SET(SCU400, 2), 1318 SIG_DESC_CLEAR(SCU500, 6)); 1319 PIN_DECL_2(D5, GPIO18A2, RGMII1TXD0, RMII1TXD0); 1320 1321 #define A3 211 1322 SIG_EXPR_LIST_DECL_SESG(A3, RGMII1TXD1, RGMII1, SIG_DESC_SET(SCU400, 3), 1323 SIG_DESC_SET(SCU500, 6)); 1324 SIG_EXPR_LIST_DECL_SESG(A3, RMII1TXD1, RMII1, SIG_DESC_SET(SCU400, 3), 1325 SIG_DESC_CLEAR(SCU500, 6)); 1326 PIN_DECL_2(A3, GPIO18A3, RGMII1TXD1, RMII1TXD1); 1327 1328 #define C5 212 1329 SIG_EXPR_LIST_DECL_SESG(C5, RGMII1TXD2, RGMII1, SIG_DESC_SET(SCU400, 4), 1330 SIG_DESC_SET(SCU500, 6)); 1331 PIN_DECL_1(C5, GPIO18A4, RGMII1TXD2); 1332 1333 #define E6 213 1334 SIG_EXPR_LIST_DECL_SESG(E6, RGMII1TXD3, RGMII1, SIG_DESC_SET(SCU400, 5), 1335 SIG_DESC_SET(SCU500, 6)); 1336 PIN_DECL_1(E6, GPIO18A5, RGMII1TXD3); 1337 1338 #define B3 214 1339 SIG_EXPR_LIST_DECL_SESG(B3, RGMII1RXCK, RGMII1, SIG_DESC_SET(SCU400, 6), 1340 SIG_DESC_SET(SCU500, 6)); 1341 SIG_EXPR_LIST_DECL_SESG(B3, RMII1RCLKI, RMII1, SIG_DESC_SET(SCU400, 6), 1342 SIG_DESC_CLEAR(SCU500, 6)); 1343 PIN_DECL_2(B3, GPIO18A6, RGMII1RXCK, RMII1RCLKI); 1344 1345 #define A2 215 1346 SIG_EXPR_LIST_DECL_SESG(A2, RGMII1RXCTL, RGMII1, SIG_DESC_SET(SCU400, 7), 1347 SIG_DESC_SET(SCU500, 6)); 1348 PIN_DECL_1(A2, GPIO18A7, RGMII1RXCTL); 1349 1350 #define B2 216 1351 SIG_EXPR_LIST_DECL_SESG(B2, RGMII1RXD0, RGMII1, SIG_DESC_SET(SCU400, 8), 1352 SIG_DESC_SET(SCU500, 6)); 1353 SIG_EXPR_LIST_DECL_SESG(B2, RMII1RXD0, RMII1, SIG_DESC_SET(SCU400, 8), 1354 SIG_DESC_CLEAR(SCU500, 6)); 1355 PIN_DECL_2(B2, GPIO18B0, RGMII1RXD0, RMII1RXD0); 1356 1357 #define B1 217 1358 SIG_EXPR_LIST_DECL_SESG(B1, RGMII1RXD1, RGMII1, SIG_DESC_SET(SCU400, 9), 1359 SIG_DESC_SET(SCU500, 6)); 1360 SIG_EXPR_LIST_DECL_SESG(B1, RMII1RXD1, RMII1, SIG_DESC_SET(SCU400, 9), 1361 SIG_DESC_CLEAR(SCU500, 6)); 1362 PIN_DECL_2(B1, GPIO18B1, RGMII1RXD1, RMII1RXD1); 1363 1364 #define C4 218 1365 SIG_EXPR_LIST_DECL_SESG(C4, RGMII1RXD2, RGMII1, SIG_DESC_SET(SCU400, 10), 1366 SIG_DESC_SET(SCU500, 6)); 1367 SIG_EXPR_LIST_DECL_SESG(C4, RMII1CRSDV, RMII1, SIG_DESC_SET(SCU400, 10), 1368 SIG_DESC_CLEAR(SCU500, 6)); 1369 PIN_DECL_2(C4, GPIO18B2, RGMII1RXD2, RMII1CRSDV); 1370 1371 #define E5 219 1372 SIG_EXPR_LIST_DECL_SESG(E5, RGMII1RXD3, RGMII1, SIG_DESC_SET(SCU400, 11), 1373 SIG_DESC_SET(SCU500, 6)); 1374 SIG_EXPR_LIST_DECL_SESG(E5, RMII1RXER, RMII1, SIG_DESC_SET(SCU400, 11), 1375 SIG_DESC_CLEAR(SCU500, 6)); 1376 PIN_DECL_2(E5, GPIO18B3, RGMII1RXD3, RMII1RXER); 1377 1378 FUNC_GROUP_DECL(RGMII1, C6, D6, D5, A3, C5, E6, B3, A2, B2, B1, C4, E5); 1379 FUNC_GROUP_DECL(RMII1, C6, D6, D5, A3, B3, B2, B1, C4, E5); 1380 1381 #define D4 220 1382 SIG_EXPR_LIST_DECL_SESG(D4, RGMII2TXCK, RGMII2, SIG_DESC_SET(SCU400, 12), 1383 SIG_DESC_SET(SCU500, 7)); 1384 SIG_EXPR_LIST_DECL_SESG(D4, RMII2RCLKO, RMII2, SIG_DESC_SET(SCU400, 12), 1385 SIG_DESC_CLEAR(SCU500, 7)); 1386 PIN_DECL_2(D4, GPIO18B4, RGMII2TXCK, RMII2RCLKO); 1387 1388 #define C2 221 1389 SIG_EXPR_LIST_DECL_SESG(C2, RGMII2TXCTL, RGMII2, SIG_DESC_SET(SCU400, 13), 1390 SIG_DESC_SET(SCU500, 7)); 1391 SIG_EXPR_LIST_DECL_SESG(C2, RMII2TXEN, RMII2, SIG_DESC_SET(SCU400, 13), 1392 SIG_DESC_CLEAR(SCU500, 7)); 1393 PIN_DECL_2(C2, GPIO18B5, RGMII2TXCTL, RMII2TXEN); 1394 1395 #define C1 222 1396 SIG_EXPR_LIST_DECL_SESG(C1, RGMII2TXD0, RGMII2, SIG_DESC_SET(SCU400, 14), 1397 SIG_DESC_SET(SCU500, 7)); 1398 SIG_EXPR_LIST_DECL_SESG(C1, RMII2TXD0, RMII2, SIG_DESC_SET(SCU400, 14), 1399 SIG_DESC_CLEAR(SCU500, 7)); 1400 PIN_DECL_2(C1, GPIO18B6, RGMII2TXD0, RMII2TXD0); 1401 1402 #define D3 223 1403 SIG_EXPR_LIST_DECL_SESG(D3, RGMII2TXD1, RGMII2, SIG_DESC_SET(SCU400, 15), 1404 SIG_DESC_SET(SCU500, 7)); 1405 SIG_EXPR_LIST_DECL_SESG(D3, RMII2TXD1, RMII2, SIG_DESC_SET(SCU400, 15), 1406 SIG_DESC_CLEAR(SCU500, 7)); 1407 PIN_DECL_2(D3, GPIO18B7, RGMII2TXD1, RMII2TXD1); 1408 1409 #define E4 224 1410 SIG_EXPR_LIST_DECL_SESG(E4, RGMII2TXD2, RGMII2, SIG_DESC_SET(SCU400, 16), 1411 SIG_DESC_SET(SCU500, 7)); 1412 PIN_DECL_1(E4, GPIO18C0, RGMII2TXD2); 1413 1414 #define F5 225 1415 SIG_EXPR_LIST_DECL_SESG(F5, RGMII2TXD3, RGMII2, SIG_DESC_SET(SCU400, 17), 1416 SIG_DESC_SET(SCU500, 7)); 1417 PIN_DECL_1(F5, GPIO18C1, RGMII2TXD3); 1418 1419 #define D2 226 1420 SIG_EXPR_LIST_DECL_SESG(D2, RGMII2RXCK, RGMII2, SIG_DESC_SET(SCU400, 18), 1421 SIG_DESC_SET(SCU500, 7)); 1422 SIG_EXPR_LIST_DECL_SESG(D2, RMII2RCLKI, RMII2, SIG_DESC_SET(SCU400, 18), 1423 SIG_DESC_CLEAR(SCU500, 7)); 1424 PIN_DECL_2(D2, GPIO18C2, RGMII2RXCK, RMII2RCLKI); 1425 1426 #define E3 227 1427 SIG_EXPR_LIST_DECL_SESG(E3, RGMII2RXCTL, RGMII2, SIG_DESC_SET(SCU400, 19), 1428 SIG_DESC_SET(SCU500, 7)); 1429 PIN_DECL_1(E3, GPIO18C3, RGMII2RXCTL); 1430 1431 #define D1 228 1432 SIG_EXPR_LIST_DECL_SESG(D1, RGMII2RXD0, RGMII2, SIG_DESC_SET(SCU400, 20), 1433 SIG_DESC_SET(SCU500, 7)); 1434 SIG_EXPR_LIST_DECL_SESG(D1, RMII2RXD0, RMII2, SIG_DESC_SET(SCU400, 20), 1435 SIG_DESC_CLEAR(SCU500, 7)); 1436 PIN_DECL_2(D1, GPIO18C4, RGMII2RXD0, RMII2RXD0); 1437 1438 #define F4 229 1439 SIG_EXPR_LIST_DECL_SESG(F4, RGMII2RXD1, RGMII2, SIG_DESC_SET(SCU400, 21), 1440 SIG_DESC_SET(SCU500, 7)); 1441 SIG_EXPR_LIST_DECL_SESG(F4, RMII2RXD1, RMII2, SIG_DESC_SET(SCU400, 21), 1442 SIG_DESC_CLEAR(SCU500, 7)); 1443 PIN_DECL_2(F4, GPIO18C5, RGMII2RXD1, RMII2RXD1); 1444 1445 #define E2 230 1446 SIG_EXPR_LIST_DECL_SESG(E2, RGMII2RXD2, RGMII2, SIG_DESC_SET(SCU400, 22), 1447 SIG_DESC_SET(SCU500, 7)); 1448 SIG_EXPR_LIST_DECL_SESG(E2, RMII2CRSDV, RMII2, SIG_DESC_SET(SCU400, 22), 1449 SIG_DESC_CLEAR(SCU500, 7)); 1450 PIN_DECL_2(E2, GPIO18C6, RGMII2RXD2, RMII2CRSDV); 1451 1452 #define E1 231 1453 SIG_EXPR_LIST_DECL_SESG(E1, RGMII2RXD3, RGMII2, SIG_DESC_SET(SCU400, 23), 1454 SIG_DESC_SET(SCU500, 7)); 1455 SIG_EXPR_LIST_DECL_SESG(E1, RMII2RXER, RMII2, SIG_DESC_SET(SCU400, 23), 1456 SIG_DESC_CLEAR(SCU500, 7)); 1457 PIN_DECL_2(E1, GPIO18C7, RGMII2RXD3, RMII2RXER); 1458 1459 FUNC_GROUP_DECL(RGMII2, D4, C2, C1, D3, E4, F5, D2, E3, D1, F4, E2, E1); 1460 FUNC_GROUP_DECL(RMII2, D4, C2, C1, D3, D2, D1, F4, E2, E1); 1461 1462 #define AB4 232 1463 SIG_EXPR_LIST_DECL_SEMG(AB4, EMMCCLK, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 24)); 1464 PIN_DECL_1(AB4, GPIO18D0, EMMCCLK); 1465 1466 #define AA4 233 1467 SIG_EXPR_LIST_DECL_SEMG(AA4, EMMCCMD, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 25)); 1468 PIN_DECL_1(AA4, GPIO18D1, EMMCCMD); 1469 1470 #define AC4 234 1471 SIG_EXPR_LIST_DECL_SEMG(AC4, EMMCDAT0, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 26)); 1472 PIN_DECL_1(AC4, GPIO18D2, EMMCDAT0); 1473 1474 #define AA5 235 1475 SIG_EXPR_LIST_DECL_SEMG(AA5, EMMCDAT1, EMMCG4, EMMC, SIG_DESC_SET(SCU400, 27)); 1476 PIN_DECL_1(AA5, GPIO18D3, EMMCDAT1); 1477 1478 #define Y5 236 1479 SIG_EXPR_LIST_DECL_SEMG(Y5, EMMCDAT2, EMMCG4, EMMC, SIG_DESC_SET(SCU400, 28)); 1480 PIN_DECL_1(Y5, GPIO18D4, EMMCDAT2); 1481 1482 #define AB5 237 1483 SIG_EXPR_LIST_DECL_SEMG(AB5, EMMCDAT3, EMMCG4, EMMC, SIG_DESC_SET(SCU400, 29)); 1484 PIN_DECL_1(AB5, GPIO18D5, EMMCDAT3); 1485 1486 #define AB6 238 1487 SIG_EXPR_LIST_DECL_SEMG(AB6, EMMCCD, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 30)); 1488 PIN_DECL_1(AB6, GPIO18D6, EMMCCD); 1489 1490 #define AC5 239 1491 SIG_EXPR_LIST_DECL_SEMG(AC5, EMMCWP, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 31)); 1492 PIN_DECL_1(AC5, GPIO18D7, EMMCWP); 1493 1494 GROUP_DECL(EMMCG1, AB4, AA4, AC4, AB6, AC5); 1495 GROUP_DECL(EMMCG4, AB4, AA4, AC4, AA5, Y5, AB5, AB6, AC5); 1496 1497 #define Y1 240 1498 SIG_EXPR_LIST_DECL_SEMG(Y1, FWSPIDCS, FWSPID, FWSPID, SIG_DESC_SET(SCU500, 3)); 1499 SIG_EXPR_LIST_DECL_SESG(Y1, VBCS, VB, SIG_DESC_SET(SCU500, 5)); 1500 SIG_EXPR_LIST_DECL_SEMG(Y1, EMMCDAT4, EMMCG8, EMMC, SIG_DESC_SET(SCU404, 0)); 1501 PIN_DECL_3(Y1, GPIO18E0, FWSPIDCS, VBCS, EMMCDAT4); 1502 1503 #define Y2 241 1504 SIG_EXPR_LIST_DECL_SEMG(Y2, FWSPIDCK, FWSPID, FWSPID, SIG_DESC_SET(SCU500, 3)); 1505 SIG_EXPR_LIST_DECL_SESG(Y2, VBCK, VB, SIG_DESC_SET(SCU500, 5)); 1506 SIG_EXPR_LIST_DECL_SEMG(Y2, EMMCDAT5, EMMCG8, EMMC, SIG_DESC_SET(SCU404, 1)); 1507 PIN_DECL_3(Y2, GPIO18E1, FWSPIDCK, VBCK, EMMCDAT5); 1508 1509 #define Y3 242 1510 SIG_EXPR_LIST_DECL_SEMG(Y3, FWSPIDMOSI, FWSPID, FWSPID, 1511 SIG_DESC_SET(SCU500, 3)); 1512 SIG_EXPR_LIST_DECL_SESG(Y3, VBMOSI, VB, SIG_DESC_SET(SCU500, 5)); 1513 SIG_EXPR_LIST_DECL_SEMG(Y3, EMMCDAT6, EMMCG8, EMMC, SIG_DESC_SET(SCU404, 2)); 1514 PIN_DECL_3(Y3, GPIO18E2, FWSPIDMOSI, VBMOSI, EMMCDAT6); 1515 1516 #define Y4 243 1517 SIG_EXPR_LIST_DECL_SEMG(Y4, FWSPIDMISO, FWSPID, FWSPID, 1518 SIG_DESC_SET(SCU500, 3)); 1519 SIG_EXPR_LIST_DECL_SESG(Y4, VBMISO, VB, SIG_DESC_SET(SCU500, 5)); 1520 SIG_EXPR_LIST_DECL_SEMG(Y4, EMMCDAT7, EMMCG8, EMMC, SIG_DESC_SET(SCU404, 3)); 1521 PIN_DECL_3(Y4, GPIO18E3, FWSPIDMISO, VBMISO, EMMCDAT7); 1522 1523 GROUP_DECL(FWSPID, Y1, Y2, Y3, Y4); 1524 GROUP_DECL(EMMCG8, AB4, AA4, AC4, AA5, Y5, AB5, AB6, AC5, Y1, Y2, Y3, Y4); 1525 FUNC_DECL_1(FWSPID, FWSPID); 1526 FUNC_GROUP_DECL(VB, Y1, Y2, Y3, Y4); 1527 FUNC_DECL_3(EMMC, EMMCG1, EMMCG4, EMMCG8); 1528 /* 1529 * FIXME: Confirm bits and priorities are the right way around for the 1530 * following 4 pins 1531 */ 1532 #define AF25 244 1533 SIG_EXPR_LIST_DECL_SEMG(AF25, I3C3SCL, I3C3, I3C3, SIG_DESC_SET(SCU438, 20)); 1534 SIG_EXPR_LIST_DECL_SESG(AF25, FSI1CLK, FSI1, SIG_DESC_SET(SCU4D8, 20)); 1535 PIN_DECL_(AF25, SIG_EXPR_LIST_PTR(AF25, I3C3SCL), 1536 SIG_EXPR_LIST_PTR(AF25, FSI1CLK)); 1537 1538 #define AE26 245 1539 SIG_EXPR_LIST_DECL_SEMG(AE26, I3C3SDA, I3C3, I3C3, SIG_DESC_SET(SCU438, 21)); 1540 SIG_EXPR_LIST_DECL_SESG(AE26, FSI1DATA, FSI1, SIG_DESC_SET(SCU4D8, 21)); 1541 PIN_DECL_(AE26, SIG_EXPR_LIST_PTR(AE26, I3C3SDA), 1542 SIG_EXPR_LIST_PTR(AE26, FSI1DATA)); 1543 1544 GROUP_DECL(I3C3, AF25, AE26); 1545 FUNC_DECL_2(I3C3, HVI3C3, I3C3); 1546 FUNC_GROUP_DECL(FSI1, AF25, AE26); 1547 1548 #define AE25 246 1549 SIG_EXPR_LIST_DECL_SEMG(AE25, I3C4SCL, I3C4, I3C4, SIG_DESC_SET(SCU438, 22)); 1550 SIG_EXPR_LIST_DECL_SESG(AE25, FSI2CLK, FSI2, SIG_DESC_SET(SCU4D8, 22)); 1551 PIN_DECL_(AE25, SIG_EXPR_LIST_PTR(AE25, I3C4SCL), 1552 SIG_EXPR_LIST_PTR(AE25, FSI2CLK)); 1553 1554 #define AF24 247 1555 SIG_EXPR_LIST_DECL_SEMG(AF24, I3C4SDA, I3C4, I3C4, SIG_DESC_SET(SCU438, 23)); 1556 SIG_EXPR_LIST_DECL_SESG(AF24, FSI2DATA, FSI2, SIG_DESC_SET(SCU4D8, 23)); 1557 PIN_DECL_(AF24, SIG_EXPR_LIST_PTR(AF24, I3C4SDA), 1558 SIG_EXPR_LIST_PTR(AF24, FSI2DATA)); 1559 1560 GROUP_DECL(I3C4, AE25, AF24); 1561 FUNC_DECL_2(I3C4, HVI3C4, I3C4); 1562 FUNC_GROUP_DECL(FSI2, AE25, AF24); 1563 1564 #define AF23 248 1565 SIG_EXPR_LIST_DECL_SESG(AF23, I3C1SCL, I3C1, SIG_DESC_SET(SCU438, 16)); 1566 PIN_DECL_(AF23, SIG_EXPR_LIST_PTR(AF23, I3C1SCL)); 1567 1568 #define AE24 249 1569 SIG_EXPR_LIST_DECL_SESG(AE24, I3C1SDA, I3C1, SIG_DESC_SET(SCU438, 17)); 1570 PIN_DECL_(AE24, SIG_EXPR_LIST_PTR(AE24, I3C1SDA)); 1571 1572 FUNC_GROUP_DECL(I3C1, AF23, AE24); 1573 1574 #define AF22 250 1575 SIG_EXPR_LIST_DECL_SESG(AF22, I3C2SCL, I3C2, SIG_DESC_SET(SCU438, 18)); 1576 PIN_DECL_(AF22, SIG_EXPR_LIST_PTR(AF22, I3C2SCL)); 1577 1578 #define AE22 251 1579 SIG_EXPR_LIST_DECL_SESG(AE22, I3C2SDA, I3C2, SIG_DESC_SET(SCU438, 19)); 1580 PIN_DECL_(AE22, SIG_EXPR_LIST_PTR(AE22, I3C2SDA)); 1581 1582 FUNC_GROUP_DECL(I3C2, AF22, AE22); 1583 1584 #define USB2ADP_DESC { ASPEED_IP_SCU, SCU440, GENMASK(25, 24), 0, 0 } 1585 #define USB2AD_DESC { ASPEED_IP_SCU, SCU440, GENMASK(25, 24), 1, 0 } 1586 #define USB2AH_DESC { ASPEED_IP_SCU, SCU440, GENMASK(25, 24), 2, 0 } 1587 #define USB2AHP_DESC { ASPEED_IP_SCU, SCU440, GENMASK(25, 24), 3, 0 } 1588 #define USB11BHID_DESC { ASPEED_IP_SCU, SCU440, GENMASK(29, 28), 0, 0 } 1589 #define USB2BD_DESC { ASPEED_IP_SCU, SCU440, GENMASK(29, 28), 1, 0 } 1590 #define USB2BH_DESC { ASPEED_IP_SCU, SCU440, GENMASK(29, 28), 2, 0 } 1591 1592 #define A4 252 1593 SIG_EXPR_LIST_DECL_SEMG(A4, USB2ADPDP, USBA, USB2ADP, USB2ADP_DESC, 1594 SIG_DESC_SET(SCUC20, 16)); 1595 SIG_EXPR_LIST_DECL_SEMG(A4, USB2ADDP, USBA, USB2AD, USB2AD_DESC); 1596 SIG_EXPR_LIST_DECL_SEMG(A4, USB2AHDP, USBA, USB2AH, USB2AH_DESC); 1597 SIG_EXPR_LIST_DECL_SEMG(A4, USB2AHPDP, USBA, USB2AHP, USB2AHP_DESC, 1598 SIG_DESC_SET(SCUC20, 16)); 1599 PIN_DECL_(A4, SIG_EXPR_LIST_PTR(A4, USB2ADPDP), SIG_EXPR_LIST_PTR(A4, USB2ADDP), 1600 SIG_EXPR_LIST_PTR(A4, USB2AHDP), SIG_EXPR_LIST_PTR(A4, USB2AHPDP)); 1601 1602 #define B4 253 1603 SIG_EXPR_LIST_DECL_SEMG(B4, USB2ADPDN, USBA, USB2ADP, USB2ADP_DESC); 1604 SIG_EXPR_LIST_DECL_SEMG(B4, USB2ADDN, USBA, USB2AD, USB2AD_DESC); 1605 SIG_EXPR_LIST_DECL_SEMG(B4, USB2AHDN, USBA, USB2AH, USB2AH_DESC); 1606 SIG_EXPR_LIST_DECL_SEMG(B4, USB2AHPDN, USBA, USB2AHP, USB2AHP_DESC); 1607 PIN_DECL_(B4, SIG_EXPR_LIST_PTR(B4, USB2ADPDN), SIG_EXPR_LIST_PTR(B4, USB2ADDN), 1608 SIG_EXPR_LIST_PTR(B4, USB2AHDN), SIG_EXPR_LIST_PTR(B4, USB2AHPDN)); 1609 1610 GROUP_DECL(USBA, A4, B4); 1611 1612 FUNC_DECL_1(USB2ADP, USBA); 1613 FUNC_DECL_1(USB2AD, USBA); 1614 FUNC_DECL_1(USB2AH, USBA); 1615 FUNC_DECL_1(USB2AHP, USBA); 1616 1617 #define A6 254 1618 SIG_EXPR_LIST_DECL_SEMG(A6, USB11BDP, USBB, USB11BHID, USB11BHID_DESC); 1619 SIG_EXPR_LIST_DECL_SEMG(A6, USB2BDDP, USBB, USB2BD, USB2BD_DESC); 1620 SIG_EXPR_LIST_DECL_SEMG(A6, USB2BHDP, USBB, USB2BH, USB2BH_DESC); 1621 PIN_DECL_(A6, SIG_EXPR_LIST_PTR(A6, USB11BDP), SIG_EXPR_LIST_PTR(A6, USB2BDDP), 1622 SIG_EXPR_LIST_PTR(A6, USB2BHDP)); 1623 1624 #define B6 255 1625 SIG_EXPR_LIST_DECL_SEMG(B6, USB11BDN, USBB, USB11BHID, USB11BHID_DESC); 1626 SIG_EXPR_LIST_DECL_SEMG(B6, USB2BDDN, USBB, USB2BD, USB2BD_DESC); 1627 SIG_EXPR_LIST_DECL_SEMG(B6, USB2BHDN, USBB, USB2BH, USB2BH_DESC); 1628 PIN_DECL_(B6, SIG_EXPR_LIST_PTR(B6, USB11BDN), SIG_EXPR_LIST_PTR(B6, USB2BDDN), 1629 SIG_EXPR_LIST_PTR(B6, USB2BHDN)); 1630 1631 GROUP_DECL(USBB, A6, B6); 1632 1633 FUNC_DECL_1(USB11BHID, USBB); 1634 FUNC_DECL_1(USB2BD, USBB); 1635 FUNC_DECL_1(USB2BH, USBB); 1636 1637 #define D7 257 1638 SIG_EXPR_LIST_DECL_SESG(D7, RCRST, PCIERC1, SIG_DESC_SET(SCU040, 19), 1639 SIG_DESC_SET(SCU500, 24)); 1640 PIN_DECL_(D7, SIG_EXPR_LIST_PTR(D7, RCRST)); 1641 FUNC_GROUP_DECL(PCIERC1, D7); 1642 1643 /* Pins, groups and functions are sort(1):ed alphabetically for sanity */ 1644 1645 static struct pinctrl_pin_desc aspeed_g6_pins[ASPEED_G6_NR_PINS] = { 1646 ASPEED_PINCTRL_PIN(A11), 1647 ASPEED_PINCTRL_PIN(A12), 1648 ASPEED_PINCTRL_PIN(A13), 1649 ASPEED_PINCTRL_PIN(A14), 1650 ASPEED_PINCTRL_PIN(A15), 1651 ASPEED_PINCTRL_PIN(A16), 1652 ASPEED_PINCTRL_PIN(A17), 1653 ASPEED_PINCTRL_PIN(A18), 1654 ASPEED_PINCTRL_PIN(A19), 1655 ASPEED_PINCTRL_PIN(A2), 1656 ASPEED_PINCTRL_PIN(A20), 1657 ASPEED_PINCTRL_PIN(A21), 1658 ASPEED_PINCTRL_PIN(A22), 1659 ASPEED_PINCTRL_PIN(A23), 1660 ASPEED_PINCTRL_PIN(A24), 1661 ASPEED_PINCTRL_PIN(A25), 1662 ASPEED_PINCTRL_PIN(A3), 1663 ASPEED_PINCTRL_PIN(A4), 1664 ASPEED_PINCTRL_PIN(A6), 1665 ASPEED_PINCTRL_PIN(AA11), 1666 ASPEED_PINCTRL_PIN(AA12), 1667 ASPEED_PINCTRL_PIN(AA16), 1668 ASPEED_PINCTRL_PIN(AA17), 1669 ASPEED_PINCTRL_PIN(AA23), 1670 ASPEED_PINCTRL_PIN(AA24), 1671 ASPEED_PINCTRL_PIN(AA25), 1672 ASPEED_PINCTRL_PIN(AA26), 1673 ASPEED_PINCTRL_PIN(AA4), 1674 ASPEED_PINCTRL_PIN(AA5), 1675 ASPEED_PINCTRL_PIN(AA9), 1676 ASPEED_PINCTRL_PIN(AB10), 1677 ASPEED_PINCTRL_PIN(AB11), 1678 ASPEED_PINCTRL_PIN(AB12), 1679 ASPEED_PINCTRL_PIN(AB15), 1680 ASPEED_PINCTRL_PIN(AB16), 1681 ASPEED_PINCTRL_PIN(AB17), 1682 ASPEED_PINCTRL_PIN(AB18), 1683 ASPEED_PINCTRL_PIN(AB19), 1684 ASPEED_PINCTRL_PIN(AB22), 1685 ASPEED_PINCTRL_PIN(AB23), 1686 ASPEED_PINCTRL_PIN(AB24), 1687 ASPEED_PINCTRL_PIN(AB25), 1688 ASPEED_PINCTRL_PIN(AB26), 1689 ASPEED_PINCTRL_PIN(AB4), 1690 ASPEED_PINCTRL_PIN(AB5), 1691 ASPEED_PINCTRL_PIN(AB6), 1692 ASPEED_PINCTRL_PIN(AB7), 1693 ASPEED_PINCTRL_PIN(AB8), 1694 ASPEED_PINCTRL_PIN(AB9), 1695 ASPEED_PINCTRL_PIN(AC10), 1696 ASPEED_PINCTRL_PIN(AC11), 1697 ASPEED_PINCTRL_PIN(AC12), 1698 ASPEED_PINCTRL_PIN(AC15), 1699 ASPEED_PINCTRL_PIN(AC16), 1700 ASPEED_PINCTRL_PIN(AC17), 1701 ASPEED_PINCTRL_PIN(AC18), 1702 ASPEED_PINCTRL_PIN(AC19), 1703 ASPEED_PINCTRL_PIN(AC22), 1704 ASPEED_PINCTRL_PIN(AC23), 1705 ASPEED_PINCTRL_PIN(AC24), 1706 ASPEED_PINCTRL_PIN(AC26), 1707 ASPEED_PINCTRL_PIN(AC4), 1708 ASPEED_PINCTRL_PIN(AC5), 1709 ASPEED_PINCTRL_PIN(AC7), 1710 ASPEED_PINCTRL_PIN(AC8), 1711 ASPEED_PINCTRL_PIN(AC9), 1712 ASPEED_PINCTRL_PIN(AD10), 1713 ASPEED_PINCTRL_PIN(AD11), 1714 ASPEED_PINCTRL_PIN(AD12), 1715 ASPEED_PINCTRL_PIN(AD14), 1716 ASPEED_PINCTRL_PIN(AD15), 1717 ASPEED_PINCTRL_PIN(AD16), 1718 ASPEED_PINCTRL_PIN(AD19), 1719 ASPEED_PINCTRL_PIN(AD20), 1720 ASPEED_PINCTRL_PIN(AD22), 1721 ASPEED_PINCTRL_PIN(AD23), 1722 ASPEED_PINCTRL_PIN(AD24), 1723 ASPEED_PINCTRL_PIN(AD25), 1724 ASPEED_PINCTRL_PIN(AD26), 1725 ASPEED_PINCTRL_PIN(AD7), 1726 ASPEED_PINCTRL_PIN(AD8), 1727 ASPEED_PINCTRL_PIN(AD9), 1728 ASPEED_PINCTRL_PIN(AE10), 1729 ASPEED_PINCTRL_PIN(AE11), 1730 ASPEED_PINCTRL_PIN(AE12), 1731 ASPEED_PINCTRL_PIN(AE14), 1732 ASPEED_PINCTRL_PIN(AE15), 1733 ASPEED_PINCTRL_PIN(AE16), 1734 ASPEED_PINCTRL_PIN(AE18), 1735 ASPEED_PINCTRL_PIN(AE19), 1736 ASPEED_PINCTRL_PIN(AE22), 1737 ASPEED_PINCTRL_PIN(AE24), 1738 ASPEED_PINCTRL_PIN(AE25), 1739 ASPEED_PINCTRL_PIN(AE26), 1740 ASPEED_PINCTRL_PIN(AE7), 1741 ASPEED_PINCTRL_PIN(AE8), 1742 ASPEED_PINCTRL_PIN(AF10), 1743 ASPEED_PINCTRL_PIN(AF11), 1744 ASPEED_PINCTRL_PIN(AF12), 1745 ASPEED_PINCTRL_PIN(AF14), 1746 ASPEED_PINCTRL_PIN(AF15), 1747 ASPEED_PINCTRL_PIN(AF22), 1748 ASPEED_PINCTRL_PIN(AF23), 1749 ASPEED_PINCTRL_PIN(AF24), 1750 ASPEED_PINCTRL_PIN(AF25), 1751 ASPEED_PINCTRL_PIN(AF7), 1752 ASPEED_PINCTRL_PIN(AF8), 1753 ASPEED_PINCTRL_PIN(AF9), 1754 ASPEED_PINCTRL_PIN(B1), 1755 ASPEED_PINCTRL_PIN(B12), 1756 ASPEED_PINCTRL_PIN(B13), 1757 ASPEED_PINCTRL_PIN(B14), 1758 ASPEED_PINCTRL_PIN(B16), 1759 ASPEED_PINCTRL_PIN(B17), 1760 ASPEED_PINCTRL_PIN(B18), 1761 ASPEED_PINCTRL_PIN(B2), 1762 ASPEED_PINCTRL_PIN(B20), 1763 ASPEED_PINCTRL_PIN(B21), 1764 ASPEED_PINCTRL_PIN(B22), 1765 ASPEED_PINCTRL_PIN(B24), 1766 ASPEED_PINCTRL_PIN(B25), 1767 ASPEED_PINCTRL_PIN(B26), 1768 ASPEED_PINCTRL_PIN(B3), 1769 ASPEED_PINCTRL_PIN(B4), 1770 ASPEED_PINCTRL_PIN(B6), 1771 ASPEED_PINCTRL_PIN(C1), 1772 ASPEED_PINCTRL_PIN(C11), 1773 ASPEED_PINCTRL_PIN(C12), 1774 ASPEED_PINCTRL_PIN(C13), 1775 ASPEED_PINCTRL_PIN(C14), 1776 ASPEED_PINCTRL_PIN(C15), 1777 ASPEED_PINCTRL_PIN(C16), 1778 ASPEED_PINCTRL_PIN(C17), 1779 ASPEED_PINCTRL_PIN(C18), 1780 ASPEED_PINCTRL_PIN(C19), 1781 ASPEED_PINCTRL_PIN(C2), 1782 ASPEED_PINCTRL_PIN(C20), 1783 ASPEED_PINCTRL_PIN(C21), 1784 ASPEED_PINCTRL_PIN(C22), 1785 ASPEED_PINCTRL_PIN(C23), 1786 ASPEED_PINCTRL_PIN(C24), 1787 ASPEED_PINCTRL_PIN(C25), 1788 ASPEED_PINCTRL_PIN(C26), 1789 ASPEED_PINCTRL_PIN(C4), 1790 ASPEED_PINCTRL_PIN(C5), 1791 ASPEED_PINCTRL_PIN(C6), 1792 ASPEED_PINCTRL_PIN(D1), 1793 ASPEED_PINCTRL_PIN(D11), 1794 ASPEED_PINCTRL_PIN(D12), 1795 ASPEED_PINCTRL_PIN(D13), 1796 ASPEED_PINCTRL_PIN(D14), 1797 ASPEED_PINCTRL_PIN(D15), 1798 ASPEED_PINCTRL_PIN(D16), 1799 ASPEED_PINCTRL_PIN(D17), 1800 ASPEED_PINCTRL_PIN(D18), 1801 ASPEED_PINCTRL_PIN(D19), 1802 ASPEED_PINCTRL_PIN(D2), 1803 ASPEED_PINCTRL_PIN(D20), 1804 ASPEED_PINCTRL_PIN(D21), 1805 ASPEED_PINCTRL_PIN(D22), 1806 ASPEED_PINCTRL_PIN(D23), 1807 ASPEED_PINCTRL_PIN(D24), 1808 ASPEED_PINCTRL_PIN(D26), 1809 ASPEED_PINCTRL_PIN(D3), 1810 ASPEED_PINCTRL_PIN(D4), 1811 ASPEED_PINCTRL_PIN(D5), 1812 ASPEED_PINCTRL_PIN(D6), 1813 ASPEED_PINCTRL_PIN(D7), 1814 ASPEED_PINCTRL_PIN(E1), 1815 ASPEED_PINCTRL_PIN(E11), 1816 ASPEED_PINCTRL_PIN(E12), 1817 ASPEED_PINCTRL_PIN(E13), 1818 ASPEED_PINCTRL_PIN(E14), 1819 ASPEED_PINCTRL_PIN(E15), 1820 ASPEED_PINCTRL_PIN(E16), 1821 ASPEED_PINCTRL_PIN(E17), 1822 ASPEED_PINCTRL_PIN(E18), 1823 ASPEED_PINCTRL_PIN(E19), 1824 ASPEED_PINCTRL_PIN(E2), 1825 ASPEED_PINCTRL_PIN(E20), 1826 ASPEED_PINCTRL_PIN(E21), 1827 ASPEED_PINCTRL_PIN(E22), 1828 ASPEED_PINCTRL_PIN(E23), 1829 ASPEED_PINCTRL_PIN(E24), 1830 ASPEED_PINCTRL_PIN(E25), 1831 ASPEED_PINCTRL_PIN(E26), 1832 ASPEED_PINCTRL_PIN(E3), 1833 ASPEED_PINCTRL_PIN(E4), 1834 ASPEED_PINCTRL_PIN(E5), 1835 ASPEED_PINCTRL_PIN(E6), 1836 ASPEED_PINCTRL_PIN(F13), 1837 ASPEED_PINCTRL_PIN(F15), 1838 ASPEED_PINCTRL_PIN(F22), 1839 ASPEED_PINCTRL_PIN(F23), 1840 ASPEED_PINCTRL_PIN(F24), 1841 ASPEED_PINCTRL_PIN(F25), 1842 ASPEED_PINCTRL_PIN(F26), 1843 ASPEED_PINCTRL_PIN(F4), 1844 ASPEED_PINCTRL_PIN(F5), 1845 ASPEED_PINCTRL_PIN(G22), 1846 ASPEED_PINCTRL_PIN(G23), 1847 ASPEED_PINCTRL_PIN(G24), 1848 ASPEED_PINCTRL_PIN(G26), 1849 ASPEED_PINCTRL_PIN(H22), 1850 ASPEED_PINCTRL_PIN(H23), 1851 ASPEED_PINCTRL_PIN(H24), 1852 ASPEED_PINCTRL_PIN(H25), 1853 ASPEED_PINCTRL_PIN(H26), 1854 ASPEED_PINCTRL_PIN(J22), 1855 ASPEED_PINCTRL_PIN(J23), 1856 ASPEED_PINCTRL_PIN(J24), 1857 ASPEED_PINCTRL_PIN(J25), 1858 ASPEED_PINCTRL_PIN(J26), 1859 ASPEED_PINCTRL_PIN(K23), 1860 ASPEED_PINCTRL_PIN(K24), 1861 ASPEED_PINCTRL_PIN(K25), 1862 ASPEED_PINCTRL_PIN(K26), 1863 ASPEED_PINCTRL_PIN(L23), 1864 ASPEED_PINCTRL_PIN(L24), 1865 ASPEED_PINCTRL_PIN(L26), 1866 ASPEED_PINCTRL_PIN(M23), 1867 ASPEED_PINCTRL_PIN(M24), 1868 ASPEED_PINCTRL_PIN(M25), 1869 ASPEED_PINCTRL_PIN(M26), 1870 ASPEED_PINCTRL_PIN(N23), 1871 ASPEED_PINCTRL_PIN(N24), 1872 ASPEED_PINCTRL_PIN(N25), 1873 ASPEED_PINCTRL_PIN(N26), 1874 ASPEED_PINCTRL_PIN(P23), 1875 ASPEED_PINCTRL_PIN(P24), 1876 ASPEED_PINCTRL_PIN(P25), 1877 ASPEED_PINCTRL_PIN(P26), 1878 ASPEED_PINCTRL_PIN(R23), 1879 ASPEED_PINCTRL_PIN(R24), 1880 ASPEED_PINCTRL_PIN(R26), 1881 ASPEED_PINCTRL_PIN(T23), 1882 ASPEED_PINCTRL_PIN(T24), 1883 ASPEED_PINCTRL_PIN(T25), 1884 ASPEED_PINCTRL_PIN(T26), 1885 ASPEED_PINCTRL_PIN(U24), 1886 ASPEED_PINCTRL_PIN(U25), 1887 ASPEED_PINCTRL_PIN(U26), 1888 ASPEED_PINCTRL_PIN(V24), 1889 ASPEED_PINCTRL_PIN(V25), 1890 ASPEED_PINCTRL_PIN(V26), 1891 ASPEED_PINCTRL_PIN(W23), 1892 ASPEED_PINCTRL_PIN(W24), 1893 ASPEED_PINCTRL_PIN(W26), 1894 ASPEED_PINCTRL_PIN(Y1), 1895 ASPEED_PINCTRL_PIN(Y2), 1896 ASPEED_PINCTRL_PIN(Y23), 1897 ASPEED_PINCTRL_PIN(Y24), 1898 ASPEED_PINCTRL_PIN(Y25), 1899 ASPEED_PINCTRL_PIN(Y26), 1900 ASPEED_PINCTRL_PIN(Y3), 1901 ASPEED_PINCTRL_PIN(Y4), 1902 ASPEED_PINCTRL_PIN(Y5), 1903 }; 1904 1905 static const struct aspeed_pin_group aspeed_g6_groups[] = { 1906 ASPEED_PINCTRL_GROUP(ADC0), 1907 ASPEED_PINCTRL_GROUP(ADC1), 1908 ASPEED_PINCTRL_GROUP(ADC10), 1909 ASPEED_PINCTRL_GROUP(ADC11), 1910 ASPEED_PINCTRL_GROUP(ADC12), 1911 ASPEED_PINCTRL_GROUP(ADC13), 1912 ASPEED_PINCTRL_GROUP(ADC14), 1913 ASPEED_PINCTRL_GROUP(ADC15), 1914 ASPEED_PINCTRL_GROUP(ADC2), 1915 ASPEED_PINCTRL_GROUP(ADC3), 1916 ASPEED_PINCTRL_GROUP(ADC4), 1917 ASPEED_PINCTRL_GROUP(ADC5), 1918 ASPEED_PINCTRL_GROUP(ADC6), 1919 ASPEED_PINCTRL_GROUP(ADC7), 1920 ASPEED_PINCTRL_GROUP(ADC8), 1921 ASPEED_PINCTRL_GROUP(ADC9), 1922 ASPEED_PINCTRL_GROUP(BMCINT), 1923 ASPEED_PINCTRL_GROUP(ESPI), 1924 ASPEED_PINCTRL_GROUP(ESPIALT), 1925 ASPEED_PINCTRL_GROUP(FSI1), 1926 ASPEED_PINCTRL_GROUP(FSI2), 1927 ASPEED_PINCTRL_GROUP(FWSPIABR), 1928 ASPEED_PINCTRL_GROUP(FWSPID), 1929 ASPEED_PINCTRL_GROUP(FWQSPI), 1930 ASPEED_PINCTRL_GROUP(FWSPIWP), 1931 ASPEED_PINCTRL_GROUP(GPIT0), 1932 ASPEED_PINCTRL_GROUP(GPIT1), 1933 ASPEED_PINCTRL_GROUP(GPIT2), 1934 ASPEED_PINCTRL_GROUP(GPIT3), 1935 ASPEED_PINCTRL_GROUP(GPIT4), 1936 ASPEED_PINCTRL_GROUP(GPIT5), 1937 ASPEED_PINCTRL_GROUP(GPIT6), 1938 ASPEED_PINCTRL_GROUP(GPIT7), 1939 ASPEED_PINCTRL_GROUP(GPIU0), 1940 ASPEED_PINCTRL_GROUP(GPIU1), 1941 ASPEED_PINCTRL_GROUP(GPIU2), 1942 ASPEED_PINCTRL_GROUP(GPIU3), 1943 ASPEED_PINCTRL_GROUP(GPIU4), 1944 ASPEED_PINCTRL_GROUP(GPIU5), 1945 ASPEED_PINCTRL_GROUP(GPIU6), 1946 ASPEED_PINCTRL_GROUP(GPIU7), 1947 ASPEED_PINCTRL_GROUP(HEARTBEAT), 1948 ASPEED_PINCTRL_GROUP(HVI3C3), 1949 ASPEED_PINCTRL_GROUP(HVI3C4), 1950 ASPEED_PINCTRL_GROUP(I2C1), 1951 ASPEED_PINCTRL_GROUP(I2C10), 1952 ASPEED_PINCTRL_GROUP(I2C11), 1953 ASPEED_PINCTRL_GROUP(I2C12), 1954 ASPEED_PINCTRL_GROUP(I2C13), 1955 ASPEED_PINCTRL_GROUP(I2C14), 1956 ASPEED_PINCTRL_GROUP(I2C15), 1957 ASPEED_PINCTRL_GROUP(I2C16), 1958 ASPEED_PINCTRL_GROUP(I2C2), 1959 ASPEED_PINCTRL_GROUP(I2C3), 1960 ASPEED_PINCTRL_GROUP(I2C4), 1961 ASPEED_PINCTRL_GROUP(I2C5), 1962 ASPEED_PINCTRL_GROUP(I2C6), 1963 ASPEED_PINCTRL_GROUP(I2C7), 1964 ASPEED_PINCTRL_GROUP(I2C8), 1965 ASPEED_PINCTRL_GROUP(I2C9), 1966 ASPEED_PINCTRL_GROUP(I3C1), 1967 ASPEED_PINCTRL_GROUP(I3C2), 1968 ASPEED_PINCTRL_GROUP(I3C3), 1969 ASPEED_PINCTRL_GROUP(I3C4), 1970 ASPEED_PINCTRL_GROUP(I3C5), 1971 ASPEED_PINCTRL_GROUP(I3C6), 1972 ASPEED_PINCTRL_GROUP(JTAGM), 1973 ASPEED_PINCTRL_GROUP(LHPD), 1974 ASPEED_PINCTRL_GROUP(LHSIRQ), 1975 ASPEED_PINCTRL_GROUP(LPC), 1976 ASPEED_PINCTRL_GROUP(LPCHC), 1977 ASPEED_PINCTRL_GROUP(LPCPD), 1978 ASPEED_PINCTRL_GROUP(LPCPME), 1979 ASPEED_PINCTRL_GROUP(LPCSMI), 1980 ASPEED_PINCTRL_GROUP(LSIRQ), 1981 ASPEED_PINCTRL_GROUP(MACLINK1), 1982 ASPEED_PINCTRL_GROUP(MACLINK2), 1983 ASPEED_PINCTRL_GROUP(MACLINK3), 1984 ASPEED_PINCTRL_GROUP(MACLINK4), 1985 ASPEED_PINCTRL_GROUP(MDIO1), 1986 ASPEED_PINCTRL_GROUP(MDIO2), 1987 ASPEED_PINCTRL_GROUP(MDIO3), 1988 ASPEED_PINCTRL_GROUP(MDIO4), 1989 ASPEED_PINCTRL_GROUP(NCSI3), 1990 ASPEED_PINCTRL_GROUP(NCSI4), 1991 ASPEED_PINCTRL_GROUP(NCTS1), 1992 ASPEED_PINCTRL_GROUP(NCTS2), 1993 ASPEED_PINCTRL_GROUP(NCTS3), 1994 ASPEED_PINCTRL_GROUP(NCTS4), 1995 ASPEED_PINCTRL_GROUP(NDCD1), 1996 ASPEED_PINCTRL_GROUP(NDCD2), 1997 ASPEED_PINCTRL_GROUP(NDCD3), 1998 ASPEED_PINCTRL_GROUP(NDCD4), 1999 ASPEED_PINCTRL_GROUP(NDSR1), 2000 ASPEED_PINCTRL_GROUP(NDSR2), 2001 ASPEED_PINCTRL_GROUP(NDSR3), 2002 ASPEED_PINCTRL_GROUP(NDSR4), 2003 ASPEED_PINCTRL_GROUP(NDTR1), 2004 ASPEED_PINCTRL_GROUP(NDTR2), 2005 ASPEED_PINCTRL_GROUP(NDTR3), 2006 ASPEED_PINCTRL_GROUP(NDTR4), 2007 ASPEED_PINCTRL_GROUP(NRI1), 2008 ASPEED_PINCTRL_GROUP(NRI2), 2009 ASPEED_PINCTRL_GROUP(NRI3), 2010 ASPEED_PINCTRL_GROUP(NRI4), 2011 ASPEED_PINCTRL_GROUP(NRTS1), 2012 ASPEED_PINCTRL_GROUP(NRTS2), 2013 ASPEED_PINCTRL_GROUP(NRTS3), 2014 ASPEED_PINCTRL_GROUP(NRTS4), 2015 ASPEED_PINCTRL_GROUP(OSCCLK), 2016 ASPEED_PINCTRL_GROUP(PEWAKE), 2017 ASPEED_PINCTRL_GROUP(PWM0), 2018 ASPEED_PINCTRL_GROUP(PWM1), 2019 ASPEED_PINCTRL_GROUP(PWM10G0), 2020 ASPEED_PINCTRL_GROUP(PWM10G1), 2021 ASPEED_PINCTRL_GROUP(PWM11G0), 2022 ASPEED_PINCTRL_GROUP(PWM11G1), 2023 ASPEED_PINCTRL_GROUP(PWM12G0), 2024 ASPEED_PINCTRL_GROUP(PWM12G1), 2025 ASPEED_PINCTRL_GROUP(PWM13G0), 2026 ASPEED_PINCTRL_GROUP(PWM13G1), 2027 ASPEED_PINCTRL_GROUP(PWM14G0), 2028 ASPEED_PINCTRL_GROUP(PWM14G1), 2029 ASPEED_PINCTRL_GROUP(PWM15G0), 2030 ASPEED_PINCTRL_GROUP(PWM15G1), 2031 ASPEED_PINCTRL_GROUP(PWM2), 2032 ASPEED_PINCTRL_GROUP(PWM3), 2033 ASPEED_PINCTRL_GROUP(PWM4), 2034 ASPEED_PINCTRL_GROUP(PWM5), 2035 ASPEED_PINCTRL_GROUP(PWM6), 2036 ASPEED_PINCTRL_GROUP(PWM7), 2037 ASPEED_PINCTRL_GROUP(PWM8G0), 2038 ASPEED_PINCTRL_GROUP(PWM8G1), 2039 ASPEED_PINCTRL_GROUP(PWM9G0), 2040 ASPEED_PINCTRL_GROUP(PWM9G1), 2041 ASPEED_PINCTRL_GROUP(QSPI1), 2042 ASPEED_PINCTRL_GROUP(QSPI2), 2043 ASPEED_PINCTRL_GROUP(RGMII1), 2044 ASPEED_PINCTRL_GROUP(RGMII2), 2045 ASPEED_PINCTRL_GROUP(RGMII3), 2046 ASPEED_PINCTRL_GROUP(RGMII4), 2047 ASPEED_PINCTRL_GROUP(RMII1), 2048 ASPEED_PINCTRL_GROUP(RMII2), 2049 ASPEED_PINCTRL_GROUP(RMII3), 2050 ASPEED_PINCTRL_GROUP(RMII4), 2051 ASPEED_PINCTRL_GROUP(RXD1), 2052 ASPEED_PINCTRL_GROUP(RXD2), 2053 ASPEED_PINCTRL_GROUP(RXD3), 2054 ASPEED_PINCTRL_GROUP(RXD4), 2055 ASPEED_PINCTRL_GROUP(SALT1), 2056 ASPEED_PINCTRL_GROUP(SALT10G0), 2057 ASPEED_PINCTRL_GROUP(SALT10G1), 2058 ASPEED_PINCTRL_GROUP(SALT11G0), 2059 ASPEED_PINCTRL_GROUP(SALT11G1), 2060 ASPEED_PINCTRL_GROUP(SALT12G0), 2061 ASPEED_PINCTRL_GROUP(SALT12G1), 2062 ASPEED_PINCTRL_GROUP(SALT13G0), 2063 ASPEED_PINCTRL_GROUP(SALT13G1), 2064 ASPEED_PINCTRL_GROUP(SALT14G0), 2065 ASPEED_PINCTRL_GROUP(SALT14G1), 2066 ASPEED_PINCTRL_GROUP(SALT15G0), 2067 ASPEED_PINCTRL_GROUP(SALT15G1), 2068 ASPEED_PINCTRL_GROUP(SALT16G0), 2069 ASPEED_PINCTRL_GROUP(SALT16G1), 2070 ASPEED_PINCTRL_GROUP(SALT2), 2071 ASPEED_PINCTRL_GROUP(SALT3), 2072 ASPEED_PINCTRL_GROUP(SALT4), 2073 ASPEED_PINCTRL_GROUP(SALT5), 2074 ASPEED_PINCTRL_GROUP(SALT6), 2075 ASPEED_PINCTRL_GROUP(SALT7), 2076 ASPEED_PINCTRL_GROUP(SALT8), 2077 ASPEED_PINCTRL_GROUP(SALT9G0), 2078 ASPEED_PINCTRL_GROUP(SALT9G1), 2079 ASPEED_PINCTRL_GROUP(SD1), 2080 ASPEED_PINCTRL_GROUP(SD2), 2081 ASPEED_PINCTRL_GROUP(PCIERC1), 2082 ASPEED_PINCTRL_GROUP(EMMCG1), 2083 ASPEED_PINCTRL_GROUP(EMMCG4), 2084 ASPEED_PINCTRL_GROUP(EMMCG8), 2085 ASPEED_PINCTRL_GROUP(SGPM1), 2086 ASPEED_PINCTRL_GROUP(SGPM2), 2087 ASPEED_PINCTRL_GROUP(SGPS1), 2088 ASPEED_PINCTRL_GROUP(SGPS2), 2089 ASPEED_PINCTRL_GROUP(SIOONCTRL), 2090 ASPEED_PINCTRL_GROUP(SIOPBI), 2091 ASPEED_PINCTRL_GROUP(SIOPBO), 2092 ASPEED_PINCTRL_GROUP(SIOPWREQ), 2093 ASPEED_PINCTRL_GROUP(SIOPWRGD), 2094 ASPEED_PINCTRL_GROUP(SIOS3), 2095 ASPEED_PINCTRL_GROUP(SIOS5), 2096 ASPEED_PINCTRL_GROUP(SIOSCI), 2097 ASPEED_PINCTRL_GROUP(SPI1), 2098 ASPEED_PINCTRL_GROUP(SPI1ABR), 2099 ASPEED_PINCTRL_GROUP(SPI1CS1), 2100 ASPEED_PINCTRL_GROUP(SPI1WP), 2101 ASPEED_PINCTRL_GROUP(SPI2), 2102 ASPEED_PINCTRL_GROUP(SPI2CS1), 2103 ASPEED_PINCTRL_GROUP(SPI2CS2), 2104 ASPEED_PINCTRL_GROUP(TACH0), 2105 ASPEED_PINCTRL_GROUP(TACH1), 2106 ASPEED_PINCTRL_GROUP(TACH10), 2107 ASPEED_PINCTRL_GROUP(TACH11), 2108 ASPEED_PINCTRL_GROUP(TACH12), 2109 ASPEED_PINCTRL_GROUP(TACH13), 2110 ASPEED_PINCTRL_GROUP(TACH14), 2111 ASPEED_PINCTRL_GROUP(TACH15), 2112 ASPEED_PINCTRL_GROUP(TACH2), 2113 ASPEED_PINCTRL_GROUP(TACH3), 2114 ASPEED_PINCTRL_GROUP(TACH4), 2115 ASPEED_PINCTRL_GROUP(TACH5), 2116 ASPEED_PINCTRL_GROUP(TACH6), 2117 ASPEED_PINCTRL_GROUP(TACH7), 2118 ASPEED_PINCTRL_GROUP(TACH8), 2119 ASPEED_PINCTRL_GROUP(TACH9), 2120 ASPEED_PINCTRL_GROUP(THRU0), 2121 ASPEED_PINCTRL_GROUP(THRU1), 2122 ASPEED_PINCTRL_GROUP(THRU2), 2123 ASPEED_PINCTRL_GROUP(THRU3), 2124 ASPEED_PINCTRL_GROUP(TXD1), 2125 ASPEED_PINCTRL_GROUP(TXD2), 2126 ASPEED_PINCTRL_GROUP(TXD3), 2127 ASPEED_PINCTRL_GROUP(TXD4), 2128 ASPEED_PINCTRL_GROUP(UART10), 2129 ASPEED_PINCTRL_GROUP(UART11), 2130 ASPEED_PINCTRL_GROUP(UART12G0), 2131 ASPEED_PINCTRL_GROUP(UART12G1), 2132 ASPEED_PINCTRL_GROUP(UART13G0), 2133 ASPEED_PINCTRL_GROUP(UART13G1), 2134 ASPEED_PINCTRL_GROUP(UART6), 2135 ASPEED_PINCTRL_GROUP(UART7), 2136 ASPEED_PINCTRL_GROUP(UART8), 2137 ASPEED_PINCTRL_GROUP(UART9), 2138 ASPEED_PINCTRL_GROUP(USBA), 2139 ASPEED_PINCTRL_GROUP(USBB), 2140 ASPEED_PINCTRL_GROUP(VB), 2141 ASPEED_PINCTRL_GROUP(VGAHS), 2142 ASPEED_PINCTRL_GROUP(VGAVS), 2143 ASPEED_PINCTRL_GROUP(WDTRST1), 2144 ASPEED_PINCTRL_GROUP(WDTRST2), 2145 ASPEED_PINCTRL_GROUP(WDTRST3), 2146 ASPEED_PINCTRL_GROUP(WDTRST4), 2147 }; 2148 2149 static const struct aspeed_pin_function aspeed_g6_functions[] = { 2150 ASPEED_PINCTRL_FUNC(ADC0), 2151 ASPEED_PINCTRL_FUNC(ADC1), 2152 ASPEED_PINCTRL_FUNC(ADC10), 2153 ASPEED_PINCTRL_FUNC(ADC11), 2154 ASPEED_PINCTRL_FUNC(ADC12), 2155 ASPEED_PINCTRL_FUNC(ADC13), 2156 ASPEED_PINCTRL_FUNC(ADC14), 2157 ASPEED_PINCTRL_FUNC(ADC15), 2158 ASPEED_PINCTRL_FUNC(ADC2), 2159 ASPEED_PINCTRL_FUNC(ADC3), 2160 ASPEED_PINCTRL_FUNC(ADC4), 2161 ASPEED_PINCTRL_FUNC(ADC5), 2162 ASPEED_PINCTRL_FUNC(ADC6), 2163 ASPEED_PINCTRL_FUNC(ADC7), 2164 ASPEED_PINCTRL_FUNC(ADC8), 2165 ASPEED_PINCTRL_FUNC(ADC9), 2166 ASPEED_PINCTRL_FUNC(BMCINT), 2167 ASPEED_PINCTRL_FUNC(EMMC), 2168 ASPEED_PINCTRL_FUNC(ESPI), 2169 ASPEED_PINCTRL_FUNC(ESPIALT), 2170 ASPEED_PINCTRL_FUNC(FSI1), 2171 ASPEED_PINCTRL_FUNC(FSI2), 2172 ASPEED_PINCTRL_FUNC(FWSPIABR), 2173 ASPEED_PINCTRL_FUNC(FWSPID), 2174 ASPEED_PINCTRL_FUNC(FWQSPI), 2175 ASPEED_PINCTRL_FUNC(FWSPIWP), 2176 ASPEED_PINCTRL_FUNC(GPIT0), 2177 ASPEED_PINCTRL_FUNC(GPIT1), 2178 ASPEED_PINCTRL_FUNC(GPIT2), 2179 ASPEED_PINCTRL_FUNC(GPIT3), 2180 ASPEED_PINCTRL_FUNC(GPIT4), 2181 ASPEED_PINCTRL_FUNC(GPIT5), 2182 ASPEED_PINCTRL_FUNC(GPIT6), 2183 ASPEED_PINCTRL_FUNC(GPIT7), 2184 ASPEED_PINCTRL_FUNC(GPIU0), 2185 ASPEED_PINCTRL_FUNC(GPIU1), 2186 ASPEED_PINCTRL_FUNC(GPIU2), 2187 ASPEED_PINCTRL_FUNC(GPIU3), 2188 ASPEED_PINCTRL_FUNC(GPIU4), 2189 ASPEED_PINCTRL_FUNC(GPIU5), 2190 ASPEED_PINCTRL_FUNC(GPIU6), 2191 ASPEED_PINCTRL_FUNC(GPIU7), 2192 ASPEED_PINCTRL_FUNC(HEARTBEAT), 2193 ASPEED_PINCTRL_FUNC(I2C1), 2194 ASPEED_PINCTRL_FUNC(I2C10), 2195 ASPEED_PINCTRL_FUNC(I2C11), 2196 ASPEED_PINCTRL_FUNC(I2C12), 2197 ASPEED_PINCTRL_FUNC(I2C13), 2198 ASPEED_PINCTRL_FUNC(I2C14), 2199 ASPEED_PINCTRL_FUNC(I2C15), 2200 ASPEED_PINCTRL_FUNC(I2C16), 2201 ASPEED_PINCTRL_FUNC(I2C2), 2202 ASPEED_PINCTRL_FUNC(I2C3), 2203 ASPEED_PINCTRL_FUNC(I2C4), 2204 ASPEED_PINCTRL_FUNC(I2C5), 2205 ASPEED_PINCTRL_FUNC(I2C6), 2206 ASPEED_PINCTRL_FUNC(I2C7), 2207 ASPEED_PINCTRL_FUNC(I2C8), 2208 ASPEED_PINCTRL_FUNC(I2C9), 2209 ASPEED_PINCTRL_FUNC(I3C1), 2210 ASPEED_PINCTRL_FUNC(I3C2), 2211 ASPEED_PINCTRL_FUNC(I3C3), 2212 ASPEED_PINCTRL_FUNC(I3C4), 2213 ASPEED_PINCTRL_FUNC(I3C5), 2214 ASPEED_PINCTRL_FUNC(I3C6), 2215 ASPEED_PINCTRL_FUNC(JTAGM), 2216 ASPEED_PINCTRL_FUNC(LHPD), 2217 ASPEED_PINCTRL_FUNC(LHSIRQ), 2218 ASPEED_PINCTRL_FUNC(LPC), 2219 ASPEED_PINCTRL_FUNC(LPCHC), 2220 ASPEED_PINCTRL_FUNC(LPCPD), 2221 ASPEED_PINCTRL_FUNC(LPCPME), 2222 ASPEED_PINCTRL_FUNC(LPCSMI), 2223 ASPEED_PINCTRL_FUNC(LSIRQ), 2224 ASPEED_PINCTRL_FUNC(MACLINK1), 2225 ASPEED_PINCTRL_FUNC(MACLINK2), 2226 ASPEED_PINCTRL_FUNC(MACLINK3), 2227 ASPEED_PINCTRL_FUNC(MACLINK4), 2228 ASPEED_PINCTRL_FUNC(MDIO1), 2229 ASPEED_PINCTRL_FUNC(MDIO2), 2230 ASPEED_PINCTRL_FUNC(MDIO3), 2231 ASPEED_PINCTRL_FUNC(MDIO4), 2232 ASPEED_PINCTRL_FUNC(NCTS1), 2233 ASPEED_PINCTRL_FUNC(NCTS2), 2234 ASPEED_PINCTRL_FUNC(NCTS3), 2235 ASPEED_PINCTRL_FUNC(NCTS4), 2236 ASPEED_PINCTRL_FUNC(NDCD1), 2237 ASPEED_PINCTRL_FUNC(NDCD2), 2238 ASPEED_PINCTRL_FUNC(NDCD3), 2239 ASPEED_PINCTRL_FUNC(NDCD4), 2240 ASPEED_PINCTRL_FUNC(NDSR1), 2241 ASPEED_PINCTRL_FUNC(NDSR2), 2242 ASPEED_PINCTRL_FUNC(NDSR3), 2243 ASPEED_PINCTRL_FUNC(NDSR4), 2244 ASPEED_PINCTRL_FUNC(NDTR1), 2245 ASPEED_PINCTRL_FUNC(NDTR2), 2246 ASPEED_PINCTRL_FUNC(NDTR3), 2247 ASPEED_PINCTRL_FUNC(NDTR4), 2248 ASPEED_PINCTRL_FUNC(NRI1), 2249 ASPEED_PINCTRL_FUNC(NRI2), 2250 ASPEED_PINCTRL_FUNC(NRI3), 2251 ASPEED_PINCTRL_FUNC(NRI4), 2252 ASPEED_PINCTRL_FUNC(NRTS1), 2253 ASPEED_PINCTRL_FUNC(NRTS2), 2254 ASPEED_PINCTRL_FUNC(NRTS3), 2255 ASPEED_PINCTRL_FUNC(NRTS4), 2256 ASPEED_PINCTRL_FUNC(OSCCLK), 2257 ASPEED_PINCTRL_FUNC(PEWAKE), 2258 ASPEED_PINCTRL_FUNC(PWM0), 2259 ASPEED_PINCTRL_FUNC(PWM1), 2260 ASPEED_PINCTRL_FUNC(PWM10), 2261 ASPEED_PINCTRL_FUNC(PWM11), 2262 ASPEED_PINCTRL_FUNC(PWM12), 2263 ASPEED_PINCTRL_FUNC(PWM13), 2264 ASPEED_PINCTRL_FUNC(PWM14), 2265 ASPEED_PINCTRL_FUNC(PWM15), 2266 ASPEED_PINCTRL_FUNC(PWM2), 2267 ASPEED_PINCTRL_FUNC(PWM3), 2268 ASPEED_PINCTRL_FUNC(PWM4), 2269 ASPEED_PINCTRL_FUNC(PWM5), 2270 ASPEED_PINCTRL_FUNC(PWM6), 2271 ASPEED_PINCTRL_FUNC(PWM7), 2272 ASPEED_PINCTRL_FUNC(PWM8), 2273 ASPEED_PINCTRL_FUNC(PWM9), 2274 ASPEED_PINCTRL_FUNC(RGMII1), 2275 ASPEED_PINCTRL_FUNC(RGMII2), 2276 ASPEED_PINCTRL_FUNC(RGMII3), 2277 ASPEED_PINCTRL_FUNC(RGMII4), 2278 ASPEED_PINCTRL_FUNC(RMII1), 2279 ASPEED_PINCTRL_FUNC(RMII2), 2280 ASPEED_PINCTRL_FUNC(RMII3), 2281 ASPEED_PINCTRL_FUNC(RMII4), 2282 ASPEED_PINCTRL_FUNC(RXD1), 2283 ASPEED_PINCTRL_FUNC(RXD2), 2284 ASPEED_PINCTRL_FUNC(RXD3), 2285 ASPEED_PINCTRL_FUNC(RXD4), 2286 ASPEED_PINCTRL_FUNC(SALT1), 2287 ASPEED_PINCTRL_FUNC(SALT10), 2288 ASPEED_PINCTRL_FUNC(SALT11), 2289 ASPEED_PINCTRL_FUNC(SALT12), 2290 ASPEED_PINCTRL_FUNC(SALT13), 2291 ASPEED_PINCTRL_FUNC(SALT14), 2292 ASPEED_PINCTRL_FUNC(SALT15), 2293 ASPEED_PINCTRL_FUNC(SALT16), 2294 ASPEED_PINCTRL_FUNC(SALT2), 2295 ASPEED_PINCTRL_FUNC(SALT3), 2296 ASPEED_PINCTRL_FUNC(SALT4), 2297 ASPEED_PINCTRL_FUNC(SALT5), 2298 ASPEED_PINCTRL_FUNC(SALT6), 2299 ASPEED_PINCTRL_FUNC(SALT7), 2300 ASPEED_PINCTRL_FUNC(SALT8), 2301 ASPEED_PINCTRL_FUNC(SALT9), 2302 ASPEED_PINCTRL_FUNC(SD1), 2303 ASPEED_PINCTRL_FUNC(SD2), 2304 ASPEED_PINCTRL_FUNC(SGPM1), 2305 ASPEED_PINCTRL_FUNC(SGPM2), 2306 ASPEED_PINCTRL_FUNC(SGPS1), 2307 ASPEED_PINCTRL_FUNC(SGPS2), 2308 ASPEED_PINCTRL_FUNC(SIOONCTRL), 2309 ASPEED_PINCTRL_FUNC(SIOPBI), 2310 ASPEED_PINCTRL_FUNC(SIOPBO), 2311 ASPEED_PINCTRL_FUNC(SIOPWREQ), 2312 ASPEED_PINCTRL_FUNC(SIOPWRGD), 2313 ASPEED_PINCTRL_FUNC(SIOS3), 2314 ASPEED_PINCTRL_FUNC(SIOS5), 2315 ASPEED_PINCTRL_FUNC(SIOSCI), 2316 ASPEED_PINCTRL_FUNC(SPI1), 2317 ASPEED_PINCTRL_FUNC(SPI1ABR), 2318 ASPEED_PINCTRL_FUNC(SPI1CS1), 2319 ASPEED_PINCTRL_FUNC(SPI1WP), 2320 ASPEED_PINCTRL_FUNC(SPI2), 2321 ASPEED_PINCTRL_FUNC(SPI2CS1), 2322 ASPEED_PINCTRL_FUNC(SPI2CS2), 2323 ASPEED_PINCTRL_FUNC(PCIERC1), 2324 ASPEED_PINCTRL_FUNC(TACH0), 2325 ASPEED_PINCTRL_FUNC(TACH1), 2326 ASPEED_PINCTRL_FUNC(TACH10), 2327 ASPEED_PINCTRL_FUNC(TACH11), 2328 ASPEED_PINCTRL_FUNC(TACH12), 2329 ASPEED_PINCTRL_FUNC(TACH13), 2330 ASPEED_PINCTRL_FUNC(TACH14), 2331 ASPEED_PINCTRL_FUNC(TACH15), 2332 ASPEED_PINCTRL_FUNC(TACH2), 2333 ASPEED_PINCTRL_FUNC(TACH3), 2334 ASPEED_PINCTRL_FUNC(TACH4), 2335 ASPEED_PINCTRL_FUNC(TACH5), 2336 ASPEED_PINCTRL_FUNC(TACH6), 2337 ASPEED_PINCTRL_FUNC(TACH7), 2338 ASPEED_PINCTRL_FUNC(TACH8), 2339 ASPEED_PINCTRL_FUNC(TACH9), 2340 ASPEED_PINCTRL_FUNC(THRU0), 2341 ASPEED_PINCTRL_FUNC(THRU1), 2342 ASPEED_PINCTRL_FUNC(THRU2), 2343 ASPEED_PINCTRL_FUNC(THRU3), 2344 ASPEED_PINCTRL_FUNC(TXD1), 2345 ASPEED_PINCTRL_FUNC(TXD2), 2346 ASPEED_PINCTRL_FUNC(TXD3), 2347 ASPEED_PINCTRL_FUNC(TXD4), 2348 ASPEED_PINCTRL_FUNC(UART10), 2349 ASPEED_PINCTRL_FUNC(UART11), 2350 ASPEED_PINCTRL_FUNC(UART12), 2351 ASPEED_PINCTRL_FUNC(UART13), 2352 ASPEED_PINCTRL_FUNC(UART6), 2353 ASPEED_PINCTRL_FUNC(UART7), 2354 ASPEED_PINCTRL_FUNC(UART8), 2355 ASPEED_PINCTRL_FUNC(UART9), 2356 ASPEED_PINCTRL_FUNC(USB11BHID), 2357 ASPEED_PINCTRL_FUNC(USB2AD), 2358 ASPEED_PINCTRL_FUNC(USB2ADP), 2359 ASPEED_PINCTRL_FUNC(USB2AH), 2360 ASPEED_PINCTRL_FUNC(USB2AHP), 2361 ASPEED_PINCTRL_FUNC(USB2BD), 2362 ASPEED_PINCTRL_FUNC(USB2BH), 2363 ASPEED_PINCTRL_FUNC(VB), 2364 ASPEED_PINCTRL_FUNC(VGAHS), 2365 ASPEED_PINCTRL_FUNC(VGAVS), 2366 ASPEED_PINCTRL_FUNC(WDTRST1), 2367 ASPEED_PINCTRL_FUNC(WDTRST2), 2368 ASPEED_PINCTRL_FUNC(WDTRST3), 2369 ASPEED_PINCTRL_FUNC(WDTRST4), 2370 }; 2371 2372 static struct aspeed_pin_config aspeed_g6_configs[] = { 2373 /* GPIOB7 */ 2374 ASPEED_PULL_DOWN_PINCONF(J24, SCU610, 15), 2375 /* GPIOB6 */ 2376 ASPEED_PULL_DOWN_PINCONF(H25, SCU610, 14), 2377 /* GPIOB5 */ 2378 ASPEED_PULL_DOWN_PINCONF(G26, SCU610, 13), 2379 /* GPIOB4 */ 2380 ASPEED_PULL_DOWN_PINCONF(J23, SCU610, 12), 2381 /* GPIOB3 */ 2382 ASPEED_PULL_DOWN_PINCONF(J25, SCU610, 11), 2383 /* GPIOB2 */ 2384 ASPEED_PULL_DOWN_PINCONF(H26, SCU610, 10), 2385 /* GPIOB1 */ 2386 ASPEED_PULL_DOWN_PINCONF(K23, SCU610, 9), 2387 /* GPIOB0 */ 2388 ASPEED_PULL_DOWN_PINCONF(J26, SCU610, 8), 2389 2390 /* GPIOH3 */ 2391 ASPEED_PULL_DOWN_PINCONF(A17, SCU614, 27), 2392 /* GPIOH2 */ 2393 ASPEED_PULL_DOWN_PINCONF(C18, SCU614, 26), 2394 /* GPIOH1 */ 2395 ASPEED_PULL_DOWN_PINCONF(B18, SCU614, 25), 2396 /* GPIOH0 */ 2397 ASPEED_PULL_DOWN_PINCONF(A18, SCU614, 24), 2398 2399 /* GPIOL7 */ 2400 ASPEED_PULL_DOWN_PINCONF(C14, SCU618, 31), 2401 /* GPIOL6 */ 2402 ASPEED_PULL_DOWN_PINCONF(B14, SCU618, 30), 2403 /* GPIOL5 */ 2404 ASPEED_PULL_DOWN_PINCONF(F15, SCU618, 29), 2405 /* GPIOL4 */ 2406 ASPEED_PULL_DOWN_PINCONF(C15, SCU618, 28), 2407 2408 /* GPIOJ7 */ 2409 ASPEED_PULL_UP_PINCONF(D19, SCU618, 15), 2410 /* GPIOJ6 */ 2411 ASPEED_PULL_UP_PINCONF(C20, SCU618, 14), 2412 /* GPIOJ5 */ 2413 ASPEED_PULL_UP_PINCONF(A19, SCU618, 13), 2414 /* GPIOJ4 */ 2415 ASPEED_PULL_UP_PINCONF(C19, SCU618, 12), 2416 /* GPIOJ3 */ 2417 ASPEED_PULL_UP_PINCONF(D20, SCU618, 11), 2418 /* GPIOJ2 */ 2419 ASPEED_PULL_UP_PINCONF(E19, SCU618, 10), 2420 /* GPIOJ1 */ 2421 ASPEED_PULL_UP_PINCONF(A20, SCU618, 9), 2422 /* GPIOJ0 */ 2423 ASPEED_PULL_UP_PINCONF(B20, SCU618, 8), 2424 2425 /* GPIOI7 */ 2426 ASPEED_PULL_DOWN_PINCONF(A15, SCU618, 7), 2427 /* GPIOI6 */ 2428 ASPEED_PULL_DOWN_PINCONF(B16, SCU618, 6), 2429 /* GPIOI5 */ 2430 ASPEED_PULL_DOWN_PINCONF(E16, SCU618, 5), 2431 /* GPIOI4 */ 2432 ASPEED_PULL_DOWN_PINCONF(C16, SCU618, 4), 2433 /* GPIOI3 */ 2434 ASPEED_PULL_DOWN_PINCONF(D16, SCU618, 3), 2435 /* GPIOI2 */ 2436 ASPEED_PULL_DOWN_PINCONF(E17, SCU618, 2), 2437 /* GPIOI1 */ 2438 ASPEED_PULL_DOWN_PINCONF(A16, SCU618, 1), 2439 /* GPIOI0 */ 2440 ASPEED_PULL_DOWN_PINCONF(D17, SCU618, 0), 2441 2442 /* GPIOP7 */ 2443 ASPEED_PULL_DOWN_PINCONF(Y23, SCU61C, 31), 2444 /* GPIOP6 */ 2445 ASPEED_PULL_DOWN_PINCONF(AB24, SCU61C, 30), 2446 /* GPIOP5 */ 2447 ASPEED_PULL_DOWN_PINCONF(AB23, SCU61C, 29), 2448 /* GPIOP4 */ 2449 ASPEED_PULL_DOWN_PINCONF(W23, SCU61C, 28), 2450 /* GPIOP3 */ 2451 ASPEED_PULL_DOWN_PINCONF(AA24, SCU61C, 27), 2452 /* GPIOP2 */ 2453 ASPEED_PULL_DOWN_PINCONF(AA23, SCU61C, 26), 2454 /* GPIOP1 */ 2455 ASPEED_PULL_DOWN_PINCONF(W24, SCU61C, 25), 2456 /* GPIOP0 */ 2457 ASPEED_PULL_DOWN_PINCONF(AB22, SCU61C, 24), 2458 2459 /* GPIOO7 */ 2460 ASPEED_PULL_DOWN_PINCONF(AC23, SCU61C, 23), 2461 /* GPIOO6 */ 2462 ASPEED_PULL_DOWN_PINCONF(AC24, SCU61C, 22), 2463 /* GPIOO5 */ 2464 ASPEED_PULL_DOWN_PINCONF(AC22, SCU61C, 21), 2465 /* GPIOO4 */ 2466 ASPEED_PULL_DOWN_PINCONF(AD25, SCU61C, 20), 2467 /* GPIOO3 */ 2468 ASPEED_PULL_DOWN_PINCONF(AD24, SCU61C, 19), 2469 /* GPIOO2 */ 2470 ASPEED_PULL_DOWN_PINCONF(AD23, SCU61C, 18), 2471 /* GPIOO1 */ 2472 ASPEED_PULL_DOWN_PINCONF(AD22, SCU61C, 17), 2473 /* GPIOO0 */ 2474 ASPEED_PULL_DOWN_PINCONF(AD26, SCU61C, 16), 2475 2476 /* GPION7 */ 2477 ASPEED_PULL_DOWN_PINCONF(M26, SCU61C, 15), 2478 /* GPION6 */ 2479 ASPEED_PULL_DOWN_PINCONF(N26, SCU61C, 14), 2480 /* GPION5 */ 2481 ASPEED_PULL_DOWN_PINCONF(M23, SCU61C, 13), 2482 /* GPION4 */ 2483 ASPEED_PULL_DOWN_PINCONF(P26, SCU61C, 12), 2484 /* GPION3 */ 2485 ASPEED_PULL_DOWN_PINCONF(N24, SCU61C, 11), 2486 /* GPION2 */ 2487 ASPEED_PULL_DOWN_PINCONF(N25, SCU61C, 10), 2488 /* GPION1 */ 2489 ASPEED_PULL_DOWN_PINCONF(N23, SCU61C, 9), 2490 /* GPION0 */ 2491 ASPEED_PULL_DOWN_PINCONF(P25, SCU61C, 8), 2492 2493 /* GPIOM7 */ 2494 ASPEED_PULL_DOWN_PINCONF(D13, SCU61C, 7), 2495 /* GPIOM6 */ 2496 ASPEED_PULL_DOWN_PINCONF(C13, SCU61C, 6), 2497 /* GPIOM5 */ 2498 ASPEED_PULL_DOWN_PINCONF(C12, SCU61C, 5), 2499 /* GPIOM4 */ 2500 ASPEED_PULL_DOWN_PINCONF(B12, SCU61C, 4), 2501 /* GPIOM3 */ 2502 ASPEED_PULL_DOWN_PINCONF(E14, SCU61C, 3), 2503 /* GPIOM2 */ 2504 ASPEED_PULL_DOWN_PINCONF(A12, SCU61C, 2), 2505 /* GPIOM1 */ 2506 ASPEED_PULL_DOWN_PINCONF(B13, SCU61C, 1), 2507 /* GPIOM0 */ 2508 ASPEED_PULL_DOWN_PINCONF(D14, SCU61C, 0), 2509 2510 /* GPIOS7 */ 2511 ASPEED_PULL_DOWN_PINCONF(T24, SCU630, 23), 2512 /* GPIOS6 */ 2513 ASPEED_PULL_DOWN_PINCONF(P23, SCU630, 22), 2514 /* GPIOS5 */ 2515 ASPEED_PULL_DOWN_PINCONF(P24, SCU630, 21), 2516 /* GPIOS4 */ 2517 ASPEED_PULL_DOWN_PINCONF(R26, SCU630, 20), 2518 /* GPIOS3*/ 2519 ASPEED_PULL_DOWN_PINCONF(R24, SCU630, 19), 2520 /* GPIOS2 */ 2521 ASPEED_PULL_DOWN_PINCONF(T26, SCU630, 18), 2522 /* GPIOS1 */ 2523 ASPEED_PULL_DOWN_PINCONF(T25, SCU630, 17), 2524 /* GPIOS0 */ 2525 ASPEED_PULL_DOWN_PINCONF(R23, SCU630, 16), 2526 2527 /* GPIOR7 */ 2528 ASPEED_PULL_DOWN_PINCONF(U26, SCU630, 15), 2529 /* GPIOR6 */ 2530 ASPEED_PULL_DOWN_PINCONF(W26, SCU630, 14), 2531 /* GPIOR5 */ 2532 ASPEED_PULL_DOWN_PINCONF(T23, SCU630, 13), 2533 /* GPIOR4 */ 2534 ASPEED_PULL_DOWN_PINCONF(U25, SCU630, 12), 2535 /* GPIOR3*/ 2536 ASPEED_PULL_DOWN_PINCONF(V26, SCU630, 11), 2537 /* GPIOR2 */ 2538 ASPEED_PULL_DOWN_PINCONF(V24, SCU630, 10), 2539 /* GPIOR1 */ 2540 ASPEED_PULL_DOWN_PINCONF(U24, SCU630, 9), 2541 /* GPIOR0 */ 2542 ASPEED_PULL_DOWN_PINCONF(V25, SCU630, 8), 2543 2544 /* GPIOX7 */ 2545 ASPEED_PULL_DOWN_PINCONF(AB10, SCU634, 31), 2546 /* GPIOX6 */ 2547 ASPEED_PULL_DOWN_PINCONF(AF9, SCU634, 30), 2548 /* GPIOX5 */ 2549 ASPEED_PULL_DOWN_PINCONF(AD9, SCU634, 29), 2550 /* GPIOX4 */ 2551 ASPEED_PULL_DOWN_PINCONF(AB9, SCU634, 28), 2552 /* GPIOX3*/ 2553 ASPEED_PULL_DOWN_PINCONF(AF8, SCU634, 27), 2554 /* GPIOX2 */ 2555 ASPEED_PULL_DOWN_PINCONF(AC9, SCU634, 26), 2556 /* GPIOX1 */ 2557 ASPEED_PULL_DOWN_PINCONF(AA9, SCU634, 25), 2558 /* GPIOX0 */ 2559 ASPEED_PULL_DOWN_PINCONF(AE8, SCU634, 24), 2560 2561 /* GPIOV7 */ 2562 ASPEED_PULL_DOWN_PINCONF(AF15, SCU634, 15), 2563 /* GPIOV6 */ 2564 ASPEED_PULL_DOWN_PINCONF(AD15, SCU634, 14), 2565 /* GPIOV5 */ 2566 ASPEED_PULL_DOWN_PINCONF(AE14, SCU634, 13), 2567 /* GPIOV4 */ 2568 ASPEED_PULL_DOWN_PINCONF(AE15, SCU634, 12), 2569 /* GPIOV3*/ 2570 ASPEED_PULL_DOWN_PINCONF(AC15, SCU634, 11), 2571 /* GPIOV2 */ 2572 ASPEED_PULL_DOWN_PINCONF(AD14, SCU634, 10), 2573 /* GPIOV1 */ 2574 ASPEED_PULL_DOWN_PINCONF(AF14, SCU634, 9), 2575 /* GPIOV0 */ 2576 ASPEED_PULL_DOWN_PINCONF(AB15, SCU634, 8), 2577 2578 /* GPIOZ7 */ 2579 ASPEED_PULL_DOWN_PINCONF(AF10, SCU638, 15), 2580 /* GPIOZ6 */ 2581 ASPEED_PULL_DOWN_PINCONF(AD11, SCU638, 14), 2582 /* GPIOZ5 */ 2583 ASPEED_PULL_DOWN_PINCONF(AA11, SCU638, 13), 2584 /* GPIOZ4 */ 2585 ASPEED_PULL_DOWN_PINCONF(AC11, SCU638, 12), 2586 /* GPIOZ3*/ 2587 ASPEED_PULL_DOWN_PINCONF(AB11, SCU638, 11), 2588 2589 /* GPIOZ1 */ 2590 ASPEED_PULL_DOWN_PINCONF(AD10, SCU638, 9), 2591 /* GPIOZ0 */ 2592 ASPEED_PULL_DOWN_PINCONF(AC10, SCU638, 8), 2593 2594 /* GPIOY6 */ 2595 ASPEED_PULL_DOWN_PINCONF(AC12, SCU638, 6), 2596 /* GPIOY5 */ 2597 ASPEED_PULL_DOWN_PINCONF(AF12, SCU638, 5), 2598 /* GPIOY4 */ 2599 ASPEED_PULL_DOWN_PINCONF(AE12, SCU638, 4), 2600 /* GPIOY3 */ 2601 ASPEED_PULL_DOWN_PINCONF(AA12, SCU638, 3), 2602 /* GPIOY2 */ 2603 ASPEED_PULL_DOWN_PINCONF(AE11, SCU638, 2), 2604 /* GPIOY1 */ 2605 ASPEED_PULL_DOWN_PINCONF(AD12, SCU638, 1), 2606 /* GPIOY0 */ 2607 ASPEED_PULL_DOWN_PINCONF(AF11, SCU638, 0), 2608 2609 /* LAD3 */ 2610 { PIN_CONFIG_DRIVE_STRENGTH, { AC7, AC7 }, SCU454, GENMASK(31, 30)}, 2611 /* LAD2 */ 2612 { PIN_CONFIG_DRIVE_STRENGTH, { AC8, AC8 }, SCU454, GENMASK(29, 28)}, 2613 /* LAD1 */ 2614 { PIN_CONFIG_DRIVE_STRENGTH, { AB8, AB8 }, SCU454, GENMASK(27, 26)}, 2615 /* LAD0 */ 2616 { PIN_CONFIG_DRIVE_STRENGTH, { AB7, AB7 }, SCU454, GENMASK(25, 24)}, 2617 /* GPIOF */ 2618 { PIN_CONFIG_DRIVE_STRENGTH, { D22, A23 }, SCU458, GENMASK(9, 8)}, 2619 /* GPIOG */ 2620 { PIN_CONFIG_DRIVE_STRENGTH, { E21, B21 }, SCU458, GENMASK(11, 10)}, 2621 2622 /* MAC3 */ 2623 { PIN_CONFIG_POWER_SOURCE, { H24, E26 }, SCU458, BIT_MASK(4)}, 2624 { PIN_CONFIG_DRIVE_STRENGTH, { H24, E26 }, SCU458, GENMASK(1, 0)}, 2625 /* MAC4 */ 2626 { PIN_CONFIG_POWER_SOURCE, { F24, B24 }, SCU458, BIT_MASK(5)}, 2627 { PIN_CONFIG_DRIVE_STRENGTH, { F24, B24 }, SCU458, GENMASK(3, 2)}, 2628 2629 /* GPIO18E */ 2630 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, Y1, Y4, SCU40C, 4), 2631 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, Y1, Y4, SCU40C, 4), 2632 /* GPIO18D */ 2633 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, AB4, AC5, SCU40C, 3), 2634 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, AB4, AC5, SCU40C, 3), 2635 /* GPIO18C */ 2636 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, E4, E1, SCU40C, 2), 2637 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, E4, E1, SCU40C, 2), 2638 /* GPIO18B */ 2639 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, B2, D3, SCU40C, 1), 2640 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, B2, D3, SCU40C, 1), 2641 /* GPIO18A */ 2642 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_PULL_DOWN, C6, A2, SCU40C, 0), 2643 ASPEED_SB_PINCONF(PIN_CONFIG_BIAS_DISABLE, C6, A2, SCU40C, 0), 2644 }; 2645 2646 /** 2647 * aspeed_g6_sig_expr_set() - Configure a pin's signal by applying an 2648 * expression's descriptor state for all descriptors in the expression. 2649 * 2650 * @ctx: The pinmux context 2651 * @expr: The expression associated with the function whose signal is to be 2652 * configured 2653 * @enable: true to enable an function's signal through a pin's signal 2654 * expression, false to disable the function's signal 2655 * 2656 * Return: 0 if the expression is configured as requested and a negative error 2657 * code otherwise 2658 */ 2659 static int aspeed_g6_sig_expr_set(struct aspeed_pinmux_data *ctx, 2660 const struct aspeed_sig_expr *expr, 2661 bool enable) 2662 { 2663 int ret; 2664 int i; 2665 2666 for (i = 0; i < expr->ndescs; i++) { 2667 const struct aspeed_sig_desc *desc = &expr->descs[i]; 2668 u32 pattern = enable ? desc->enable : desc->disable; 2669 u32 val = (pattern << __ffs(desc->mask)); 2670 bool is_strap; 2671 2672 if (!ctx->maps[desc->ip]) 2673 return -ENODEV; 2674 2675 WARN_ON(desc->ip != ASPEED_IP_SCU); 2676 is_strap = desc->reg == SCU500 || desc->reg == SCU510; 2677 2678 if (is_strap) { 2679 /* 2680 * The AST2600 has write protection mask registers for 2681 * the hardware strapping in SCU508 and SCU518. Assume 2682 * that if the platform doesn't want the strapping 2683 * values changed that it has set the write mask. 2684 * 2685 * The strapping registers implement write-1-clear 2686 * behaviour. SCU500 is paired with clear writes on 2687 * SCU504, likewise SCU510 is paired with SCU514. 2688 */ 2689 u32 clear = ~val & desc->mask; 2690 u32 w1c = desc->reg + 4; 2691 2692 if (clear) 2693 ret = regmap_update_bits(ctx->maps[desc->ip], 2694 w1c, desc->mask, 2695 clear); 2696 } 2697 2698 ret = regmap_update_bits(ctx->maps[desc->ip], desc->reg, 2699 desc->mask, val); 2700 if (ret) 2701 return ret; 2702 } 2703 2704 ret = aspeed_sig_expr_eval(ctx, expr, enable); 2705 if (ret < 0) 2706 return ret; 2707 2708 if (!ret) 2709 return -EPERM; 2710 return 0; 2711 } 2712 2713 static const struct aspeed_pin_config_map aspeed_g6_pin_config_map[] = { 2714 { PIN_CONFIG_BIAS_PULL_DOWN, 0, 1, BIT_MASK(0)}, 2715 { PIN_CONFIG_BIAS_PULL_DOWN, -1, 0, BIT_MASK(0)}, 2716 { PIN_CONFIG_BIAS_PULL_UP, 0, 1, BIT_MASK(0)}, 2717 { PIN_CONFIG_BIAS_PULL_UP, -1, 0, BIT_MASK(0)}, 2718 { PIN_CONFIG_BIAS_DISABLE, -1, 1, BIT_MASK(0)}, 2719 { PIN_CONFIG_DRIVE_STRENGTH, 4, 0, GENMASK(1, 0)}, 2720 { PIN_CONFIG_DRIVE_STRENGTH, 8, 1, GENMASK(1, 0)}, 2721 { PIN_CONFIG_DRIVE_STRENGTH, 12, 2, GENMASK(1, 0)}, 2722 { PIN_CONFIG_DRIVE_STRENGTH, 16, 3, GENMASK(1, 0)}, 2723 { PIN_CONFIG_POWER_SOURCE, 3300, 0, BIT_MASK(0)}, 2724 { PIN_CONFIG_POWER_SOURCE, 1800, 1, BIT_MASK(0)}, 2725 }; 2726 2727 static const struct aspeed_pinmux_ops aspeed_g5_ops = { 2728 .set = aspeed_g6_sig_expr_set, 2729 }; 2730 2731 static struct aspeed_pinctrl_data aspeed_g6_pinctrl_data = { 2732 .pins = aspeed_g6_pins, 2733 .npins = ARRAY_SIZE(aspeed_g6_pins), 2734 .pinmux = { 2735 .ops = &aspeed_g5_ops, 2736 .groups = aspeed_g6_groups, 2737 .ngroups = ARRAY_SIZE(aspeed_g6_groups), 2738 .functions = aspeed_g6_functions, 2739 .nfunctions = ARRAY_SIZE(aspeed_g6_functions), 2740 }, 2741 .configs = aspeed_g6_configs, 2742 .nconfigs = ARRAY_SIZE(aspeed_g6_configs), 2743 .confmaps = aspeed_g6_pin_config_map, 2744 .nconfmaps = ARRAY_SIZE(aspeed_g6_pin_config_map), 2745 }; 2746 2747 static const struct pinmux_ops aspeed_g6_pinmux_ops = { 2748 .get_functions_count = aspeed_pinmux_get_fn_count, 2749 .get_function_name = aspeed_pinmux_get_fn_name, 2750 .get_function_groups = aspeed_pinmux_get_fn_groups, 2751 .set_mux = aspeed_pinmux_set_mux, 2752 .gpio_request_enable = aspeed_gpio_request_enable, 2753 .strict = true, 2754 }; 2755 2756 static const struct pinctrl_ops aspeed_g6_pinctrl_ops = { 2757 .get_groups_count = aspeed_pinctrl_get_groups_count, 2758 .get_group_name = aspeed_pinctrl_get_group_name, 2759 .get_group_pins = aspeed_pinctrl_get_group_pins, 2760 .pin_dbg_show = aspeed_pinctrl_pin_dbg_show, 2761 .dt_node_to_map = pinconf_generic_dt_node_to_map_all, 2762 .dt_free_map = pinctrl_utils_free_map, 2763 }; 2764 2765 static const struct pinconf_ops aspeed_g6_conf_ops = { 2766 .is_generic = true, 2767 .pin_config_get = aspeed_pin_config_get, 2768 .pin_config_set = aspeed_pin_config_set, 2769 .pin_config_group_get = aspeed_pin_config_group_get, 2770 .pin_config_group_set = aspeed_pin_config_group_set, 2771 }; 2772 2773 static const struct pinctrl_desc aspeed_g6_pinctrl_desc = { 2774 .name = "aspeed-g6-pinctrl", 2775 .pins = aspeed_g6_pins, 2776 .npins = ARRAY_SIZE(aspeed_g6_pins), 2777 .pctlops = &aspeed_g6_pinctrl_ops, 2778 .pmxops = &aspeed_g6_pinmux_ops, 2779 .confops = &aspeed_g6_conf_ops, 2780 }; 2781 2782 static int aspeed_g6_pinctrl_probe(struct platform_device *pdev) 2783 { 2784 int i; 2785 2786 for (i = 0; i < ARRAY_SIZE(aspeed_g6_pins); i++) 2787 aspeed_g6_pins[i].number = i; 2788 2789 return aspeed_pinctrl_probe(pdev, &aspeed_g6_pinctrl_desc, 2790 &aspeed_g6_pinctrl_data); 2791 } 2792 2793 static const struct of_device_id aspeed_g6_pinctrl_of_match[] = { 2794 { .compatible = "aspeed,ast2600-pinctrl", }, 2795 { }, 2796 }; 2797 2798 static struct platform_driver aspeed_g6_pinctrl_driver = { 2799 .probe = aspeed_g6_pinctrl_probe, 2800 .driver = { 2801 .name = "aspeed-g6-pinctrl", 2802 .of_match_table = aspeed_g6_pinctrl_of_match, 2803 }, 2804 }; 2805 2806 static int aspeed_g6_pinctrl_init(void) 2807 { 2808 return platform_driver_register(&aspeed_g6_pinctrl_driver); 2809 } 2810 2811 arch_initcall(aspeed_g6_pinctrl_init); 2812