xref: /linux/drivers/pinctrl/spear/pinctrl-spear1310.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
1 /*
2  * Driver for the ST Microelectronics SPEAr1310 pinmux
3  *
4  * Copyright (C) 2012 ST Microelectronics
5  * Viresh Kumar <vireshk@kernel.org>
6  *
7  * This file is licensed under the terms of the GNU General Public
8  * License version 2. This program is licensed "as is" without any
9  * warranty of any kind, whether express or implied.
10  */
11 
12 #include <linux/err.h>
13 #include <linux/init.h>
14 #include <linux/mod_devicetable.h>
15 #include <linux/platform_device.h>
16 #include "pinctrl-spear.h"
17 
18 #define DRIVER_NAME "spear1310-pinmux"
19 
20 /* pins */
21 static const struct pinctrl_pin_desc spear1310_pins[] = {
22 	SPEAR_PIN_0_TO_101,
23 	SPEAR_PIN_102_TO_245,
24 };
25 
26 /* registers */
27 #define PERIP_CFG					0x3B0
28 	#define MCIF_SEL_SHIFT				5
29 	#define MCIF_SEL_SD				(0x1 << MCIF_SEL_SHIFT)
30 	#define MCIF_SEL_CF				(0x2 << MCIF_SEL_SHIFT)
31 	#define MCIF_SEL_XD				(0x3 << MCIF_SEL_SHIFT)
32 	#define MCIF_SEL_MASK				(0x3 << MCIF_SEL_SHIFT)
33 
34 #define PCIE_SATA_CFG					0x3A4
35 	#define PCIE_SATA2_SEL_PCIE			(0 << 31)
36 	#define PCIE_SATA1_SEL_PCIE			(0 << 30)
37 	#define PCIE_SATA0_SEL_PCIE			(0 << 29)
38 	#define PCIE_SATA2_SEL_SATA			(1 << 31)
39 	#define PCIE_SATA1_SEL_SATA			(1 << 30)
40 	#define PCIE_SATA0_SEL_SATA			(1 << 29)
41 	#define SATA2_CFG_TX_CLK_EN			(1 << 27)
42 	#define SATA2_CFG_RX_CLK_EN			(1 << 26)
43 	#define SATA2_CFG_POWERUP_RESET			(1 << 25)
44 	#define SATA2_CFG_PM_CLK_EN			(1 << 24)
45 	#define SATA1_CFG_TX_CLK_EN			(1 << 23)
46 	#define SATA1_CFG_RX_CLK_EN			(1 << 22)
47 	#define SATA1_CFG_POWERUP_RESET			(1 << 21)
48 	#define SATA1_CFG_PM_CLK_EN			(1 << 20)
49 	#define SATA0_CFG_TX_CLK_EN			(1 << 19)
50 	#define SATA0_CFG_RX_CLK_EN			(1 << 18)
51 	#define SATA0_CFG_POWERUP_RESET			(1 << 17)
52 	#define SATA0_CFG_PM_CLK_EN			(1 << 16)
53 	#define PCIE2_CFG_DEVICE_PRESENT		(1 << 11)
54 	#define PCIE2_CFG_POWERUP_RESET			(1 << 10)
55 	#define PCIE2_CFG_CORE_CLK_EN			(1 << 9)
56 	#define PCIE2_CFG_AUX_CLK_EN			(1 << 8)
57 	#define PCIE1_CFG_DEVICE_PRESENT		(1 << 7)
58 	#define PCIE1_CFG_POWERUP_RESET			(1 << 6)
59 	#define PCIE1_CFG_CORE_CLK_EN			(1 << 5)
60 	#define PCIE1_CFG_AUX_CLK_EN			(1 << 4)
61 	#define PCIE0_CFG_DEVICE_PRESENT		(1 << 3)
62 	#define PCIE0_CFG_POWERUP_RESET			(1 << 2)
63 	#define PCIE0_CFG_CORE_CLK_EN			(1 << 1)
64 	#define PCIE0_CFG_AUX_CLK_EN			(1 << 0)
65 
66 #define PAD_FUNCTION_EN_0				0x650
67 	#define PMX_UART0_MASK				(1 << 1)
68 	#define PMX_I2C0_MASK				(1 << 2)
69 	#define PMX_I2S0_MASK				(1 << 3)
70 	#define PMX_SSP0_MASK				(1 << 4)
71 	#define PMX_CLCD1_MASK				(1 << 5)
72 	#define PMX_EGPIO00_MASK			(1 << 6)
73 	#define PMX_EGPIO01_MASK			(1 << 7)
74 	#define PMX_EGPIO02_MASK			(1 << 8)
75 	#define PMX_EGPIO03_MASK			(1 << 9)
76 	#define PMX_EGPIO04_MASK			(1 << 10)
77 	#define PMX_EGPIO05_MASK			(1 << 11)
78 	#define PMX_EGPIO06_MASK			(1 << 12)
79 	#define PMX_EGPIO07_MASK			(1 << 13)
80 	#define PMX_EGPIO08_MASK			(1 << 14)
81 	#define PMX_EGPIO09_MASK			(1 << 15)
82 	#define PMX_SMI_MASK				(1 << 16)
83 	#define PMX_NAND8_MASK				(1 << 17)
84 	#define PMX_GMIICLK_MASK			(1 << 18)
85 	#define PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK	(1 << 19)
86 	#define PMX_RXCLK_RDV_TXEN_D03_MASK		(1 << 20)
87 	#define PMX_GMIID47_MASK			(1 << 21)
88 	#define PMX_MDC_MDIO_MASK			(1 << 22)
89 	#define PMX_MCI_DATA8_15_MASK			(1 << 23)
90 	#define PMX_NFAD23_MASK				(1 << 24)
91 	#define PMX_NFAD24_MASK				(1 << 25)
92 	#define PMX_NFAD25_MASK				(1 << 26)
93 	#define PMX_NFCE3_MASK				(1 << 27)
94 	#define PMX_NFWPRT3_MASK			(1 << 28)
95 	#define PMX_NFRSTPWDWN0_MASK			(1 << 29)
96 	#define PMX_NFRSTPWDWN1_MASK			(1 << 30)
97 	#define PMX_NFRSTPWDWN2_MASK			(1 << 31)
98 
99 #define PAD_FUNCTION_EN_1				0x654
100 	#define PMX_NFRSTPWDWN3_MASK			(1 << 0)
101 	#define PMX_SMINCS2_MASK			(1 << 1)
102 	#define PMX_SMINCS3_MASK			(1 << 2)
103 	#define PMX_CLCD2_MASK				(1 << 3)
104 	#define PMX_KBD_ROWCOL68_MASK			(1 << 4)
105 	#define PMX_EGPIO10_MASK			(1 << 5)
106 	#define PMX_EGPIO11_MASK			(1 << 6)
107 	#define PMX_EGPIO12_MASK			(1 << 7)
108 	#define PMX_EGPIO13_MASK			(1 << 8)
109 	#define PMX_EGPIO14_MASK			(1 << 9)
110 	#define PMX_EGPIO15_MASK			(1 << 10)
111 	#define PMX_UART0_MODEM_MASK			(1 << 11)
112 	#define PMX_GPT0_TMR0_MASK			(1 << 12)
113 	#define PMX_GPT0_TMR1_MASK			(1 << 13)
114 	#define PMX_GPT1_TMR0_MASK			(1 << 14)
115 	#define PMX_GPT1_TMR1_MASK			(1 << 15)
116 	#define PMX_I2S1_MASK				(1 << 16)
117 	#define PMX_KBD_ROWCOL25_MASK			(1 << 17)
118 	#define PMX_NFIO8_15_MASK			(1 << 18)
119 	#define PMX_KBD_COL1_MASK			(1 << 19)
120 	#define PMX_NFCE1_MASK				(1 << 20)
121 	#define PMX_KBD_COL0_MASK			(1 << 21)
122 	#define PMX_NFCE2_MASK				(1 << 22)
123 	#define PMX_KBD_ROW1_MASK			(1 << 23)
124 	#define PMX_NFWPRT1_MASK			(1 << 24)
125 	#define PMX_KBD_ROW0_MASK			(1 << 25)
126 	#define PMX_NFWPRT2_MASK			(1 << 26)
127 	#define PMX_MCIDATA0_MASK			(1 << 27)
128 	#define PMX_MCIDATA1_MASK			(1 << 28)
129 	#define PMX_MCIDATA2_MASK			(1 << 29)
130 	#define PMX_MCIDATA3_MASK			(1 << 30)
131 	#define PMX_MCIDATA4_MASK			(1 << 31)
132 
133 #define PAD_FUNCTION_EN_2				0x658
134 	#define PMX_MCIDATA5_MASK			(1 << 0)
135 	#define PMX_MCIDATA6_MASK			(1 << 1)
136 	#define PMX_MCIDATA7_MASK			(1 << 2)
137 	#define PMX_MCIDATA1SD_MASK			(1 << 3)
138 	#define PMX_MCIDATA2SD_MASK			(1 << 4)
139 	#define PMX_MCIDATA3SD_MASK			(1 << 5)
140 	#define PMX_MCIADDR0ALE_MASK			(1 << 6)
141 	#define PMX_MCIADDR1CLECLK_MASK			(1 << 7)
142 	#define PMX_MCIADDR2_MASK			(1 << 8)
143 	#define PMX_MCICECF_MASK			(1 << 9)
144 	#define PMX_MCICEXD_MASK			(1 << 10)
145 	#define PMX_MCICESDMMC_MASK			(1 << 11)
146 	#define PMX_MCICDCF1_MASK			(1 << 12)
147 	#define PMX_MCICDCF2_MASK			(1 << 13)
148 	#define PMX_MCICDXD_MASK			(1 << 14)
149 	#define PMX_MCICDSDMMC_MASK			(1 << 15)
150 	#define PMX_MCIDATADIR_MASK			(1 << 16)
151 	#define PMX_MCIDMARQWP_MASK			(1 << 17)
152 	#define PMX_MCIIORDRE_MASK			(1 << 18)
153 	#define PMX_MCIIOWRWE_MASK			(1 << 19)
154 	#define PMX_MCIRESETCF_MASK			(1 << 20)
155 	#define PMX_MCICS0CE_MASK			(1 << 21)
156 	#define PMX_MCICFINTR_MASK			(1 << 22)
157 	#define PMX_MCIIORDY_MASK			(1 << 23)
158 	#define PMX_MCICS1_MASK				(1 << 24)
159 	#define PMX_MCIDMAACK_MASK			(1 << 25)
160 	#define PMX_MCISDCMD_MASK			(1 << 26)
161 	#define PMX_MCILEDS_MASK			(1 << 27)
162 	#define PMX_TOUCH_XY_MASK			(1 << 28)
163 	#define PMX_SSP0_CS0_MASK			(1 << 29)
164 	#define PMX_SSP0_CS1_2_MASK			(1 << 30)
165 
166 #define PAD_DIRECTION_SEL_0				0x65C
167 #define PAD_DIRECTION_SEL_1				0x660
168 #define PAD_DIRECTION_SEL_2				0x664
169 
170 /* combined macros */
171 #define PMX_GMII_MASK		(PMX_GMIICLK_MASK |			\
172 				PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK |	\
173 				PMX_RXCLK_RDV_TXEN_D03_MASK |		\
174 				PMX_GMIID47_MASK | PMX_MDC_MDIO_MASK)
175 
176 #define PMX_EGPIO_0_GRP_MASK	(PMX_EGPIO00_MASK | PMX_EGPIO01_MASK |	\
177 				PMX_EGPIO02_MASK |			\
178 				PMX_EGPIO03_MASK | PMX_EGPIO04_MASK |	\
179 				PMX_EGPIO05_MASK | PMX_EGPIO06_MASK |	\
180 				PMX_EGPIO07_MASK | PMX_EGPIO08_MASK |	\
181 				PMX_EGPIO09_MASK)
182 #define PMX_EGPIO_1_GRP_MASK	(PMX_EGPIO10_MASK | PMX_EGPIO11_MASK |	\
183 				PMX_EGPIO12_MASK | PMX_EGPIO13_MASK |	\
184 				PMX_EGPIO14_MASK | PMX_EGPIO15_MASK)
185 
186 #define PMX_KEYBOARD_6X6_MASK	(PMX_KBD_ROW0_MASK | PMX_KBD_ROW1_MASK | \
187 				PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL0_MASK | \
188 				PMX_KBD_COL1_MASK)
189 
190 #define PMX_NAND8BIT_0_MASK	(PMX_NAND8_MASK | PMX_NFAD23_MASK |	\
191 				PMX_NFAD24_MASK | PMX_NFAD25_MASK |	\
192 				PMX_NFWPRT3_MASK | PMX_NFRSTPWDWN0_MASK | \
193 				PMX_NFRSTPWDWN1_MASK | PMX_NFRSTPWDWN2_MASK | \
194 				PMX_NFCE3_MASK)
195 #define PMX_NAND8BIT_1_MASK	PMX_NFRSTPWDWN3_MASK
196 
197 #define PMX_NAND16BIT_1_MASK	(PMX_KBD_ROWCOL25_MASK | PMX_NFIO8_15_MASK)
198 #define PMX_NAND_4CHIPS_MASK	(PMX_NFCE1_MASK | PMX_NFCE2_MASK |	\
199 				PMX_NFWPRT1_MASK | PMX_NFWPRT2_MASK |	\
200 				PMX_KBD_ROW0_MASK | PMX_KBD_ROW1_MASK |	\
201 				PMX_KBD_COL0_MASK | PMX_KBD_COL1_MASK)
202 
203 #define PMX_MCIFALL_1_MASK	0xF8000000
204 #define PMX_MCIFALL_2_MASK	0x0FFFFFFF
205 
206 #define PMX_PCI_REG1_MASK	(PMX_SMINCS2_MASK | PMX_SMINCS3_MASK |	\
207 				PMX_CLCD2_MASK | PMX_KBD_ROWCOL68_MASK | \
208 				PMX_EGPIO_1_GRP_MASK | PMX_GPT0_TMR0_MASK | \
209 				PMX_GPT0_TMR1_MASK | PMX_GPT1_TMR0_MASK | \
210 				PMX_GPT1_TMR1_MASK | PMX_I2S1_MASK |	\
211 				PMX_NFCE2_MASK)
212 #define PMX_PCI_REG2_MASK	(PMX_TOUCH_XY_MASK | PMX_SSP0_CS0_MASK | \
213 				PMX_SSP0_CS1_2_MASK)
214 
215 #define PMX_SMII_0_1_2_MASK	(PMX_CLCD2_MASK | PMX_KBD_ROWCOL68_MASK)
216 #define PMX_RGMII_REG0_MASK	(PMX_MCI_DATA8_15_MASK |		\
217 				PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK |	\
218 				PMX_GMIID47_MASK)
219 #define PMX_RGMII_REG1_MASK	(PMX_KBD_ROWCOL68_MASK | PMX_EGPIO_1_GRP_MASK |\
220 				PMX_KBD_ROW1_MASK | PMX_NFWPRT1_MASK |	\
221 				PMX_KBD_ROW0_MASK | PMX_NFWPRT2_MASK)
222 #define PMX_RGMII_REG2_MASK	(PMX_TOUCH_XY_MASK | PMX_SSP0_CS0_MASK | \
223 				PMX_SSP0_CS1_2_MASK)
224 
225 #define PCIE_CFG_VAL(x)		(PCIE_SATA##x##_SEL_PCIE |	\
226 				PCIE##x##_CFG_AUX_CLK_EN |	\
227 				PCIE##x##_CFG_CORE_CLK_EN |	\
228 				PCIE##x##_CFG_POWERUP_RESET |	\
229 				PCIE##x##_CFG_DEVICE_PRESENT)
230 #define SATA_CFG_VAL(x)		(PCIE_SATA##x##_SEL_SATA |	\
231 				SATA##x##_CFG_PM_CLK_EN |	\
232 				SATA##x##_CFG_POWERUP_RESET |	\
233 				SATA##x##_CFG_RX_CLK_EN |	\
234 				SATA##x##_CFG_TX_CLK_EN)
235 
236 /* Pad multiplexing for i2c0 device */
237 static const unsigned i2c0_pins[] = { 102, 103 };
238 static struct spear_muxreg i2c0_muxreg[] = {
239 	{
240 		.reg = PAD_FUNCTION_EN_0,
241 		.mask = PMX_I2C0_MASK,
242 		.val = PMX_I2C0_MASK,
243 	}, {
244 		.reg = PAD_DIRECTION_SEL_0,
245 		.mask = PMX_I2C0_MASK,
246 		.val = PMX_I2C0_MASK,
247 	},
248 };
249 
250 static struct spear_modemux i2c0_modemux[] = {
251 	{
252 		.muxregs = i2c0_muxreg,
253 		.nmuxregs = ARRAY_SIZE(i2c0_muxreg),
254 	},
255 };
256 
257 static struct spear_pingroup i2c0_pingroup = {
258 	.name = "i2c0_grp",
259 	.pins = i2c0_pins,
260 	.npins = ARRAY_SIZE(i2c0_pins),
261 	.modemuxs = i2c0_modemux,
262 	.nmodemuxs = ARRAY_SIZE(i2c0_modemux),
263 };
264 
265 static const char *const i2c0_grps[] = { "i2c0_grp" };
266 static struct spear_function i2c0_function = {
267 	.name = "i2c0",
268 	.groups = i2c0_grps,
269 	.ngroups = ARRAY_SIZE(i2c0_grps),
270 };
271 
272 /* Pad multiplexing for ssp0 device */
273 static const unsigned ssp0_pins[] = { 109, 110, 111, 112 };
274 static struct spear_muxreg ssp0_muxreg[] = {
275 	{
276 		.reg = PAD_FUNCTION_EN_0,
277 		.mask = PMX_SSP0_MASK,
278 		.val = PMX_SSP0_MASK,
279 	}, {
280 		.reg = PAD_DIRECTION_SEL_0,
281 		.mask = PMX_SSP0_MASK,
282 		.val = PMX_SSP0_MASK,
283 	},
284 };
285 
286 static struct spear_modemux ssp0_modemux[] = {
287 	{
288 		.muxregs = ssp0_muxreg,
289 		.nmuxregs = ARRAY_SIZE(ssp0_muxreg),
290 	},
291 };
292 
293 static struct spear_pingroup ssp0_pingroup = {
294 	.name = "ssp0_grp",
295 	.pins = ssp0_pins,
296 	.npins = ARRAY_SIZE(ssp0_pins),
297 	.modemuxs = ssp0_modemux,
298 	.nmodemuxs = ARRAY_SIZE(ssp0_modemux),
299 };
300 
301 /* Pad multiplexing for ssp0_cs0 device */
302 static const unsigned ssp0_cs0_pins[] = { 96 };
303 static struct spear_muxreg ssp0_cs0_muxreg[] = {
304 	{
305 		.reg = PAD_FUNCTION_EN_2,
306 		.mask = PMX_SSP0_CS0_MASK,
307 		.val = PMX_SSP0_CS0_MASK,
308 	}, {
309 		.reg = PAD_DIRECTION_SEL_2,
310 		.mask = PMX_SSP0_CS0_MASK,
311 		.val = PMX_SSP0_CS0_MASK,
312 	},
313 };
314 
315 static struct spear_modemux ssp0_cs0_modemux[] = {
316 	{
317 		.muxregs = ssp0_cs0_muxreg,
318 		.nmuxregs = ARRAY_SIZE(ssp0_cs0_muxreg),
319 	},
320 };
321 
322 static struct spear_pingroup ssp0_cs0_pingroup = {
323 	.name = "ssp0_cs0_grp",
324 	.pins = ssp0_cs0_pins,
325 	.npins = ARRAY_SIZE(ssp0_cs0_pins),
326 	.modemuxs = ssp0_cs0_modemux,
327 	.nmodemuxs = ARRAY_SIZE(ssp0_cs0_modemux),
328 };
329 
330 /* ssp0_cs1_2 device */
331 static const unsigned ssp0_cs1_2_pins[] = { 94, 95 };
332 static struct spear_muxreg ssp0_cs1_2_muxreg[] = {
333 	{
334 		.reg = PAD_FUNCTION_EN_2,
335 		.mask = PMX_SSP0_CS1_2_MASK,
336 		.val = PMX_SSP0_CS1_2_MASK,
337 	}, {
338 		.reg = PAD_DIRECTION_SEL_2,
339 		.mask = PMX_SSP0_CS1_2_MASK,
340 		.val = PMX_SSP0_CS1_2_MASK,
341 	},
342 };
343 
344 static struct spear_modemux ssp0_cs1_2_modemux[] = {
345 	{
346 		.muxregs = ssp0_cs1_2_muxreg,
347 		.nmuxregs = ARRAY_SIZE(ssp0_cs1_2_muxreg),
348 	},
349 };
350 
351 static struct spear_pingroup ssp0_cs1_2_pingroup = {
352 	.name = "ssp0_cs1_2_grp",
353 	.pins = ssp0_cs1_2_pins,
354 	.npins = ARRAY_SIZE(ssp0_cs1_2_pins),
355 	.modemuxs = ssp0_cs1_2_modemux,
356 	.nmodemuxs = ARRAY_SIZE(ssp0_cs1_2_modemux),
357 };
358 
359 static const char *const ssp0_grps[] = { "ssp0_grp", "ssp0_cs0_grp",
360 	"ssp0_cs1_2_grp" };
361 static struct spear_function ssp0_function = {
362 	.name = "ssp0",
363 	.groups = ssp0_grps,
364 	.ngroups = ARRAY_SIZE(ssp0_grps),
365 };
366 
367 /* Pad multiplexing for i2s0 device */
368 static const unsigned i2s0_pins[] = { 104, 105, 106, 107, 108 };
369 static struct spear_muxreg i2s0_muxreg[] = {
370 	{
371 		.reg = PAD_FUNCTION_EN_0,
372 		.mask = PMX_I2S0_MASK,
373 		.val = PMX_I2S0_MASK,
374 	}, {
375 		.reg = PAD_DIRECTION_SEL_0,
376 		.mask = PMX_I2S0_MASK,
377 		.val = PMX_I2S0_MASK,
378 	},
379 };
380 
381 static struct spear_modemux i2s0_modemux[] = {
382 	{
383 		.muxregs = i2s0_muxreg,
384 		.nmuxregs = ARRAY_SIZE(i2s0_muxreg),
385 	},
386 };
387 
388 static struct spear_pingroup i2s0_pingroup = {
389 	.name = "i2s0_grp",
390 	.pins = i2s0_pins,
391 	.npins = ARRAY_SIZE(i2s0_pins),
392 	.modemuxs = i2s0_modemux,
393 	.nmodemuxs = ARRAY_SIZE(i2s0_modemux),
394 };
395 
396 static const char *const i2s0_grps[] = { "i2s0_grp" };
397 static struct spear_function i2s0_function = {
398 	.name = "i2s0",
399 	.groups = i2s0_grps,
400 	.ngroups = ARRAY_SIZE(i2s0_grps),
401 };
402 
403 /* Pad multiplexing for i2s1 device */
404 static const unsigned i2s1_pins[] = { 0, 1, 2, 3 };
405 static struct spear_muxreg i2s1_muxreg[] = {
406 	{
407 		.reg = PAD_FUNCTION_EN_1,
408 		.mask = PMX_I2S1_MASK,
409 		.val = PMX_I2S1_MASK,
410 	}, {
411 		.reg = PAD_DIRECTION_SEL_1,
412 		.mask = PMX_I2S1_MASK,
413 		.val = PMX_I2S1_MASK,
414 	},
415 };
416 
417 static struct spear_modemux i2s1_modemux[] = {
418 	{
419 		.muxregs = i2s1_muxreg,
420 		.nmuxregs = ARRAY_SIZE(i2s1_muxreg),
421 	},
422 };
423 
424 static struct spear_pingroup i2s1_pingroup = {
425 	.name = "i2s1_grp",
426 	.pins = i2s1_pins,
427 	.npins = ARRAY_SIZE(i2s1_pins),
428 	.modemuxs = i2s1_modemux,
429 	.nmodemuxs = ARRAY_SIZE(i2s1_modemux),
430 };
431 
432 static const char *const i2s1_grps[] = { "i2s1_grp" };
433 static struct spear_function i2s1_function = {
434 	.name = "i2s1",
435 	.groups = i2s1_grps,
436 	.ngroups = ARRAY_SIZE(i2s1_grps),
437 };
438 
439 /* Pad multiplexing for clcd device */
440 static const unsigned clcd_pins[] = { 113, 114, 115, 116, 117, 118, 119, 120,
441 	121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
442 	135, 136, 137, 138, 139, 140, 141, 142 };
443 static struct spear_muxreg clcd_muxreg[] = {
444 	{
445 		.reg = PAD_FUNCTION_EN_0,
446 		.mask = PMX_CLCD1_MASK,
447 		.val = PMX_CLCD1_MASK,
448 	}, {
449 		.reg = PAD_DIRECTION_SEL_0,
450 		.mask = PMX_CLCD1_MASK,
451 		.val = PMX_CLCD1_MASK,
452 	},
453 };
454 
455 static struct spear_modemux clcd_modemux[] = {
456 	{
457 		.muxregs = clcd_muxreg,
458 		.nmuxregs = ARRAY_SIZE(clcd_muxreg),
459 	},
460 };
461 
462 static struct spear_pingroup clcd_pingroup = {
463 	.name = "clcd_grp",
464 	.pins = clcd_pins,
465 	.npins = ARRAY_SIZE(clcd_pins),
466 	.modemuxs = clcd_modemux,
467 	.nmodemuxs = ARRAY_SIZE(clcd_modemux),
468 };
469 
470 static const unsigned clcd_high_res_pins[] = { 30, 31, 32, 33, 34, 35, 36, 37,
471 	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 };
472 static struct spear_muxreg clcd_high_res_muxreg[] = {
473 	{
474 		.reg = PAD_FUNCTION_EN_1,
475 		.mask = PMX_CLCD2_MASK,
476 		.val = PMX_CLCD2_MASK,
477 	}, {
478 		.reg = PAD_DIRECTION_SEL_1,
479 		.mask = PMX_CLCD2_MASK,
480 		.val = PMX_CLCD2_MASK,
481 	},
482 };
483 
484 static struct spear_modemux clcd_high_res_modemux[] = {
485 	{
486 		.muxregs = clcd_high_res_muxreg,
487 		.nmuxregs = ARRAY_SIZE(clcd_high_res_muxreg),
488 	},
489 };
490 
491 static struct spear_pingroup clcd_high_res_pingroup = {
492 	.name = "clcd_high_res_grp",
493 	.pins = clcd_high_res_pins,
494 	.npins = ARRAY_SIZE(clcd_high_res_pins),
495 	.modemuxs = clcd_high_res_modemux,
496 	.nmodemuxs = ARRAY_SIZE(clcd_high_res_modemux),
497 };
498 
499 static const char *const clcd_grps[] = { "clcd_grp", "clcd_high_res_grp" };
500 static struct spear_function clcd_function = {
501 	.name = "clcd",
502 	.groups = clcd_grps,
503 	.ngroups = ARRAY_SIZE(clcd_grps),
504 };
505 
506 static const unsigned arm_gpio_pins[] = { 18, 19, 20, 21, 22, 23, 143, 144, 145,
507 	146, 147, 148, 149, 150, 151, 152 };
508 static struct spear_muxreg arm_gpio_muxreg[] = {
509 	{
510 		.reg = PAD_FUNCTION_EN_0,
511 		.mask = PMX_EGPIO_0_GRP_MASK,
512 		.val = PMX_EGPIO_0_GRP_MASK,
513 	}, {
514 		.reg = PAD_FUNCTION_EN_1,
515 		.mask = PMX_EGPIO_1_GRP_MASK,
516 		.val = PMX_EGPIO_1_GRP_MASK,
517 	}, {
518 		.reg = PAD_DIRECTION_SEL_0,
519 		.mask = PMX_EGPIO_0_GRP_MASK,
520 		.val = PMX_EGPIO_0_GRP_MASK,
521 	}, {
522 		.reg = PAD_DIRECTION_SEL_1,
523 		.mask = PMX_EGPIO_1_GRP_MASK,
524 		.val = PMX_EGPIO_1_GRP_MASK,
525 	},
526 };
527 
528 static struct spear_modemux arm_gpio_modemux[] = {
529 	{
530 		.muxregs = arm_gpio_muxreg,
531 		.nmuxregs = ARRAY_SIZE(arm_gpio_muxreg),
532 	},
533 };
534 
535 static struct spear_pingroup arm_gpio_pingroup = {
536 	.name = "arm_gpio_grp",
537 	.pins = arm_gpio_pins,
538 	.npins = ARRAY_SIZE(arm_gpio_pins),
539 	.modemuxs = arm_gpio_modemux,
540 	.nmodemuxs = ARRAY_SIZE(arm_gpio_modemux),
541 };
542 
543 static const char *const arm_gpio_grps[] = { "arm_gpio_grp" };
544 static struct spear_function arm_gpio_function = {
545 	.name = "arm_gpio",
546 	.groups = arm_gpio_grps,
547 	.ngroups = ARRAY_SIZE(arm_gpio_grps),
548 };
549 
550 /* Pad multiplexing for smi 2 chips device */
551 static const unsigned smi_2_chips_pins[] = { 153, 154, 155, 156, 157 };
552 static struct spear_muxreg smi_2_chips_muxreg[] = {
553 	{
554 		.reg = PAD_FUNCTION_EN_0,
555 		.mask = PMX_SMI_MASK,
556 		.val = PMX_SMI_MASK,
557 	}, {
558 		.reg = PAD_DIRECTION_SEL_0,
559 		.mask = PMX_SMI_MASK,
560 		.val = PMX_SMI_MASK,
561 	},
562 };
563 
564 static struct spear_modemux smi_2_chips_modemux[] = {
565 	{
566 		.muxregs = smi_2_chips_muxreg,
567 		.nmuxregs = ARRAY_SIZE(smi_2_chips_muxreg),
568 	},
569 };
570 
571 static struct spear_pingroup smi_2_chips_pingroup = {
572 	.name = "smi_2_chips_grp",
573 	.pins = smi_2_chips_pins,
574 	.npins = ARRAY_SIZE(smi_2_chips_pins),
575 	.modemuxs = smi_2_chips_modemux,
576 	.nmodemuxs = ARRAY_SIZE(smi_2_chips_modemux),
577 };
578 
579 static const unsigned smi_4_chips_pins[] = { 54, 55 };
580 static struct spear_muxreg smi_4_chips_muxreg[] = {
581 	{
582 		.reg = PAD_FUNCTION_EN_0,
583 		.mask = PMX_SMI_MASK,
584 		.val = PMX_SMI_MASK,
585 	}, {
586 		.reg = PAD_FUNCTION_EN_1,
587 		.mask = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
588 		.val = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
589 	}, {
590 		.reg = PAD_DIRECTION_SEL_0,
591 		.mask = PMX_SMI_MASK,
592 		.val = PMX_SMI_MASK,
593 	}, {
594 		.reg = PAD_DIRECTION_SEL_1,
595 		.mask = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
596 		.val = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
597 	},
598 };
599 
600 static struct spear_modemux smi_4_chips_modemux[] = {
601 	{
602 		.muxregs = smi_4_chips_muxreg,
603 		.nmuxregs = ARRAY_SIZE(smi_4_chips_muxreg),
604 	},
605 };
606 
607 static struct spear_pingroup smi_4_chips_pingroup = {
608 	.name = "smi_4_chips_grp",
609 	.pins = smi_4_chips_pins,
610 	.npins = ARRAY_SIZE(smi_4_chips_pins),
611 	.modemuxs = smi_4_chips_modemux,
612 	.nmodemuxs = ARRAY_SIZE(smi_4_chips_modemux),
613 };
614 
615 static const char *const smi_grps[] = { "smi_2_chips_grp", "smi_4_chips_grp" };
616 static struct spear_function smi_function = {
617 	.name = "smi",
618 	.groups = smi_grps,
619 	.ngroups = ARRAY_SIZE(smi_grps),
620 };
621 
622 /* Pad multiplexing for gmii device */
623 static const unsigned gmii_pins[] = { 173, 174, 175, 176, 177, 178, 179, 180,
624 	181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
625 	195, 196, 197, 198, 199, 200 };
626 static struct spear_muxreg gmii_muxreg[] = {
627 	{
628 		.reg = PAD_FUNCTION_EN_0,
629 		.mask = PMX_GMII_MASK,
630 		.val = PMX_GMII_MASK,
631 	}, {
632 		.reg = PAD_DIRECTION_SEL_0,
633 		.mask = PMX_GMII_MASK,
634 		.val = PMX_GMII_MASK,
635 	},
636 };
637 
638 static struct spear_modemux gmii_modemux[] = {
639 	{
640 		.muxregs = gmii_muxreg,
641 		.nmuxregs = ARRAY_SIZE(gmii_muxreg),
642 	},
643 };
644 
645 static struct spear_pingroup gmii_pingroup = {
646 	.name = "gmii_grp",
647 	.pins = gmii_pins,
648 	.npins = ARRAY_SIZE(gmii_pins),
649 	.modemuxs = gmii_modemux,
650 	.nmodemuxs = ARRAY_SIZE(gmii_modemux),
651 };
652 
653 static const char *const gmii_grps[] = { "gmii_grp" };
654 static struct spear_function gmii_function = {
655 	.name = "gmii",
656 	.groups = gmii_grps,
657 	.ngroups = ARRAY_SIZE(gmii_grps),
658 };
659 
660 /* Pad multiplexing for rgmii device */
661 static const unsigned rgmii_pins[] = { 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
662 	28, 29, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 175,
663 	180, 181, 182, 183, 185, 188, 193, 194, 195, 196, 197, 198, 211, 212 };
664 static struct spear_muxreg rgmii_muxreg[] = {
665 	{
666 		.reg = PAD_FUNCTION_EN_0,
667 		.mask = PMX_RGMII_REG0_MASK,
668 		.val = 0,
669 	}, {
670 		.reg = PAD_FUNCTION_EN_1,
671 		.mask = PMX_RGMII_REG1_MASK,
672 		.val = 0,
673 	}, {
674 		.reg = PAD_FUNCTION_EN_2,
675 		.mask = PMX_RGMII_REG2_MASK,
676 		.val = 0,
677 	}, {
678 		.reg = PAD_DIRECTION_SEL_0,
679 		.mask = PMX_RGMII_REG0_MASK,
680 		.val = PMX_RGMII_REG0_MASK,
681 	}, {
682 		.reg = PAD_DIRECTION_SEL_1,
683 		.mask = PMX_RGMII_REG1_MASK,
684 		.val = PMX_RGMII_REG1_MASK,
685 	}, {
686 		.reg = PAD_DIRECTION_SEL_2,
687 		.mask = PMX_RGMII_REG2_MASK,
688 		.val = PMX_RGMII_REG2_MASK,
689 	},
690 };
691 
692 static struct spear_modemux rgmii_modemux[] = {
693 	{
694 		.muxregs = rgmii_muxreg,
695 		.nmuxregs = ARRAY_SIZE(rgmii_muxreg),
696 	},
697 };
698 
699 static struct spear_pingroup rgmii_pingroup = {
700 	.name = "rgmii_grp",
701 	.pins = rgmii_pins,
702 	.npins = ARRAY_SIZE(rgmii_pins),
703 	.modemuxs = rgmii_modemux,
704 	.nmodemuxs = ARRAY_SIZE(rgmii_modemux),
705 };
706 
707 static const char *const rgmii_grps[] = { "rgmii_grp" };
708 static struct spear_function rgmii_function = {
709 	.name = "rgmii",
710 	.groups = rgmii_grps,
711 	.ngroups = ARRAY_SIZE(rgmii_grps),
712 };
713 
714 /* Pad multiplexing for smii_0_1_2 device */
715 static const unsigned smii_0_1_2_pins[] = { 24, 25, 26, 27, 28, 29, 30, 31, 32,
716 	33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
717 	51, 52, 53, 54, 55 };
718 static struct spear_muxreg smii_0_1_2_muxreg[] = {
719 	{
720 		.reg = PAD_FUNCTION_EN_1,
721 		.mask = PMX_SMII_0_1_2_MASK,
722 		.val = 0,
723 	}, {
724 		.reg = PAD_DIRECTION_SEL_1,
725 		.mask = PMX_SMII_0_1_2_MASK,
726 		.val = PMX_SMII_0_1_2_MASK,
727 	},
728 };
729 
730 static struct spear_modemux smii_0_1_2_modemux[] = {
731 	{
732 		.muxregs = smii_0_1_2_muxreg,
733 		.nmuxregs = ARRAY_SIZE(smii_0_1_2_muxreg),
734 	},
735 };
736 
737 static struct spear_pingroup smii_0_1_2_pingroup = {
738 	.name = "smii_0_1_2_grp",
739 	.pins = smii_0_1_2_pins,
740 	.npins = ARRAY_SIZE(smii_0_1_2_pins),
741 	.modemuxs = smii_0_1_2_modemux,
742 	.nmodemuxs = ARRAY_SIZE(smii_0_1_2_modemux),
743 };
744 
745 static const char *const smii_0_1_2_grps[] = { "smii_0_1_2_grp" };
746 static struct spear_function smii_0_1_2_function = {
747 	.name = "smii_0_1_2",
748 	.groups = smii_0_1_2_grps,
749 	.ngroups = ARRAY_SIZE(smii_0_1_2_grps),
750 };
751 
752 /* Pad multiplexing for ras_mii_txclk device */
753 static const unsigned ras_mii_txclk_pins[] = { 98, 99 };
754 static struct spear_muxreg ras_mii_txclk_muxreg[] = {
755 	{
756 		.reg = PAD_FUNCTION_EN_1,
757 		.mask = PMX_NFCE2_MASK,
758 		.val = 0,
759 	}, {
760 		.reg = PAD_DIRECTION_SEL_1,
761 		.mask = PMX_NFCE2_MASK,
762 		.val = PMX_NFCE2_MASK,
763 	},
764 };
765 
766 static struct spear_modemux ras_mii_txclk_modemux[] = {
767 	{
768 		.muxregs = ras_mii_txclk_muxreg,
769 		.nmuxregs = ARRAY_SIZE(ras_mii_txclk_muxreg),
770 	},
771 };
772 
773 static struct spear_pingroup ras_mii_txclk_pingroup = {
774 	.name = "ras_mii_txclk_grp",
775 	.pins = ras_mii_txclk_pins,
776 	.npins = ARRAY_SIZE(ras_mii_txclk_pins),
777 	.modemuxs = ras_mii_txclk_modemux,
778 	.nmodemuxs = ARRAY_SIZE(ras_mii_txclk_modemux),
779 };
780 
781 static const char *const ras_mii_txclk_grps[] = { "ras_mii_txclk_grp" };
782 static struct spear_function ras_mii_txclk_function = {
783 	.name = "ras_mii_txclk",
784 	.groups = ras_mii_txclk_grps,
785 	.ngroups = ARRAY_SIZE(ras_mii_txclk_grps),
786 };
787 
788 /* Pad multiplexing for nand 8bit device (cs0 only) */
789 static const unsigned nand_8bit_pins[] = { 56, 57, 58, 59, 60, 61, 62, 63, 64,
790 	65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
791 	83, 84, 85, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
792 	170, 171, 172, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
793 	212 };
794 static struct spear_muxreg nand_8bit_muxreg[] = {
795 	{
796 		.reg = PAD_FUNCTION_EN_0,
797 		.mask = PMX_NAND8BIT_0_MASK,
798 		.val = PMX_NAND8BIT_0_MASK,
799 	}, {
800 		.reg = PAD_FUNCTION_EN_1,
801 		.mask = PMX_NAND8BIT_1_MASK,
802 		.val = PMX_NAND8BIT_1_MASK,
803 	}, {
804 		.reg = PAD_DIRECTION_SEL_0,
805 		.mask = PMX_NAND8BIT_0_MASK,
806 		.val = PMX_NAND8BIT_0_MASK,
807 	}, {
808 		.reg = PAD_DIRECTION_SEL_1,
809 		.mask = PMX_NAND8BIT_1_MASK,
810 		.val = PMX_NAND8BIT_1_MASK,
811 	},
812 };
813 
814 static struct spear_modemux nand_8bit_modemux[] = {
815 	{
816 		.muxregs = nand_8bit_muxreg,
817 		.nmuxregs = ARRAY_SIZE(nand_8bit_muxreg),
818 	},
819 };
820 
821 static struct spear_pingroup nand_8bit_pingroup = {
822 	.name = "nand_8bit_grp",
823 	.pins = nand_8bit_pins,
824 	.npins = ARRAY_SIZE(nand_8bit_pins),
825 	.modemuxs = nand_8bit_modemux,
826 	.nmodemuxs = ARRAY_SIZE(nand_8bit_modemux),
827 };
828 
829 /* Pad multiplexing for nand 16bit device */
830 static const unsigned nand_16bit_pins[] = { 201, 202, 203, 204, 207, 208, 209,
831 	210 };
832 static struct spear_muxreg nand_16bit_muxreg[] = {
833 	{
834 		.reg = PAD_FUNCTION_EN_1,
835 		.mask = PMX_NAND16BIT_1_MASK,
836 		.val = PMX_NAND16BIT_1_MASK,
837 	}, {
838 		.reg = PAD_DIRECTION_SEL_1,
839 		.mask = PMX_NAND16BIT_1_MASK,
840 		.val = PMX_NAND16BIT_1_MASK,
841 	},
842 };
843 
844 static struct spear_modemux nand_16bit_modemux[] = {
845 	{
846 		.muxregs = nand_16bit_muxreg,
847 		.nmuxregs = ARRAY_SIZE(nand_16bit_muxreg),
848 	},
849 };
850 
851 static struct spear_pingroup nand_16bit_pingroup = {
852 	.name = "nand_16bit_grp",
853 	.pins = nand_16bit_pins,
854 	.npins = ARRAY_SIZE(nand_16bit_pins),
855 	.modemuxs = nand_16bit_modemux,
856 	.nmodemuxs = ARRAY_SIZE(nand_16bit_modemux),
857 };
858 
859 /* Pad multiplexing for nand 4 chips */
860 static const unsigned nand_4_chips_pins[] = { 205, 206, 211, 212 };
861 static struct spear_muxreg nand_4_chips_muxreg[] = {
862 	{
863 		.reg = PAD_FUNCTION_EN_1,
864 		.mask = PMX_NAND_4CHIPS_MASK,
865 		.val = PMX_NAND_4CHIPS_MASK,
866 	}, {
867 		.reg = PAD_DIRECTION_SEL_1,
868 		.mask = PMX_NAND_4CHIPS_MASK,
869 		.val = PMX_NAND_4CHIPS_MASK,
870 	},
871 };
872 
873 static struct spear_modemux nand_4_chips_modemux[] = {
874 	{
875 		.muxregs = nand_4_chips_muxreg,
876 		.nmuxregs = ARRAY_SIZE(nand_4_chips_muxreg),
877 	},
878 };
879 
880 static struct spear_pingroup nand_4_chips_pingroup = {
881 	.name = "nand_4_chips_grp",
882 	.pins = nand_4_chips_pins,
883 	.npins = ARRAY_SIZE(nand_4_chips_pins),
884 	.modemuxs = nand_4_chips_modemux,
885 	.nmodemuxs = ARRAY_SIZE(nand_4_chips_modemux),
886 };
887 
888 static const char *const nand_grps[] = { "nand_8bit_grp", "nand_16bit_grp",
889 	"nand_4_chips_grp" };
890 static struct spear_function nand_function = {
891 	.name = "nand",
892 	.groups = nand_grps,
893 	.ngroups = ARRAY_SIZE(nand_grps),
894 };
895 
896 /* Pad multiplexing for keyboard_6x6 device */
897 static const unsigned keyboard_6x6_pins[] = { 201, 202, 203, 204, 205, 206, 207,
898 	208, 209, 210, 211, 212 };
899 static struct spear_muxreg keyboard_6x6_muxreg[] = {
900 	{
901 		.reg = PAD_FUNCTION_EN_1,
902 		.mask = PMX_KEYBOARD_6X6_MASK | PMX_NFIO8_15_MASK |
903 			PMX_NFCE1_MASK | PMX_NFCE2_MASK | PMX_NFWPRT1_MASK |
904 			PMX_NFWPRT2_MASK,
905 		.val = PMX_KEYBOARD_6X6_MASK,
906 	},
907 };
908 
909 static struct spear_modemux keyboard_6x6_modemux[] = {
910 	{
911 		.muxregs = keyboard_6x6_muxreg,
912 		.nmuxregs = ARRAY_SIZE(keyboard_6x6_muxreg),
913 	},
914 };
915 
916 static struct spear_pingroup keyboard_6x6_pingroup = {
917 	.name = "keyboard_6x6_grp",
918 	.pins = keyboard_6x6_pins,
919 	.npins = ARRAY_SIZE(keyboard_6x6_pins),
920 	.modemuxs = keyboard_6x6_modemux,
921 	.nmodemuxs = ARRAY_SIZE(keyboard_6x6_modemux),
922 };
923 
924 /* Pad multiplexing for keyboard_rowcol6_8 device */
925 static const unsigned keyboard_rowcol6_8_pins[] = { 24, 25, 26, 27, 28, 29 };
926 static struct spear_muxreg keyboard_rowcol6_8_muxreg[] = {
927 	{
928 		.reg = PAD_FUNCTION_EN_1,
929 		.mask = PMX_KBD_ROWCOL68_MASK,
930 		.val = PMX_KBD_ROWCOL68_MASK,
931 	}, {
932 		.reg = PAD_DIRECTION_SEL_1,
933 		.mask = PMX_KBD_ROWCOL68_MASK,
934 		.val = PMX_KBD_ROWCOL68_MASK,
935 	},
936 };
937 
938 static struct spear_modemux keyboard_rowcol6_8_modemux[] = {
939 	{
940 		.muxregs = keyboard_rowcol6_8_muxreg,
941 		.nmuxregs = ARRAY_SIZE(keyboard_rowcol6_8_muxreg),
942 	},
943 };
944 
945 static struct spear_pingroup keyboard_rowcol6_8_pingroup = {
946 	.name = "keyboard_rowcol6_8_grp",
947 	.pins = keyboard_rowcol6_8_pins,
948 	.npins = ARRAY_SIZE(keyboard_rowcol6_8_pins),
949 	.modemuxs = keyboard_rowcol6_8_modemux,
950 	.nmodemuxs = ARRAY_SIZE(keyboard_rowcol6_8_modemux),
951 };
952 
953 static const char *const keyboard_grps[] = { "keyboard_6x6_grp",
954 	"keyboard_rowcol6_8_grp" };
955 static struct spear_function keyboard_function = {
956 	.name = "keyboard",
957 	.groups = keyboard_grps,
958 	.ngroups = ARRAY_SIZE(keyboard_grps),
959 };
960 
961 /* Pad multiplexing for uart0 device */
962 static const unsigned uart0_pins[] = { 100, 101 };
963 static struct spear_muxreg uart0_muxreg[] = {
964 	{
965 		.reg = PAD_FUNCTION_EN_0,
966 		.mask = PMX_UART0_MASK,
967 		.val = PMX_UART0_MASK,
968 	}, {
969 		.reg = PAD_DIRECTION_SEL_0,
970 		.mask = PMX_UART0_MASK,
971 		.val = PMX_UART0_MASK,
972 	},
973 };
974 
975 static struct spear_modemux uart0_modemux[] = {
976 	{
977 		.muxregs = uart0_muxreg,
978 		.nmuxregs = ARRAY_SIZE(uart0_muxreg),
979 	},
980 };
981 
982 static struct spear_pingroup uart0_pingroup = {
983 	.name = "uart0_grp",
984 	.pins = uart0_pins,
985 	.npins = ARRAY_SIZE(uart0_pins),
986 	.modemuxs = uart0_modemux,
987 	.nmodemuxs = ARRAY_SIZE(uart0_modemux),
988 };
989 
990 /* Pad multiplexing for uart0_modem device */
991 static const unsigned uart0_modem_pins[] = { 12, 13, 14, 15, 16, 17 };
992 static struct spear_muxreg uart0_modem_muxreg[] = {
993 	{
994 		.reg = PAD_FUNCTION_EN_1,
995 		.mask = PMX_UART0_MODEM_MASK,
996 		.val = PMX_UART0_MODEM_MASK,
997 	}, {
998 		.reg = PAD_DIRECTION_SEL_1,
999 		.mask = PMX_UART0_MODEM_MASK,
1000 		.val = PMX_UART0_MODEM_MASK,
1001 	},
1002 };
1003 
1004 static struct spear_modemux uart0_modem_modemux[] = {
1005 	{
1006 		.muxregs = uart0_modem_muxreg,
1007 		.nmuxregs = ARRAY_SIZE(uart0_modem_muxreg),
1008 	},
1009 };
1010 
1011 static struct spear_pingroup uart0_modem_pingroup = {
1012 	.name = "uart0_modem_grp",
1013 	.pins = uart0_modem_pins,
1014 	.npins = ARRAY_SIZE(uart0_modem_pins),
1015 	.modemuxs = uart0_modem_modemux,
1016 	.nmodemuxs = ARRAY_SIZE(uart0_modem_modemux),
1017 };
1018 
1019 static const char *const uart0_grps[] = { "uart0_grp", "uart0_modem_grp" };
1020 static struct spear_function uart0_function = {
1021 	.name = "uart0",
1022 	.groups = uart0_grps,
1023 	.ngroups = ARRAY_SIZE(uart0_grps),
1024 };
1025 
1026 /* Pad multiplexing for gpt0_tmr0 device */
1027 static const unsigned gpt0_tmr0_pins[] = { 10, 11 };
1028 static struct spear_muxreg gpt0_tmr0_muxreg[] = {
1029 	{
1030 		.reg = PAD_FUNCTION_EN_1,
1031 		.mask = PMX_GPT0_TMR0_MASK,
1032 		.val = PMX_GPT0_TMR0_MASK,
1033 	}, {
1034 		.reg = PAD_DIRECTION_SEL_1,
1035 		.mask = PMX_GPT0_TMR0_MASK,
1036 		.val = PMX_GPT0_TMR0_MASK,
1037 	},
1038 };
1039 
1040 static struct spear_modemux gpt0_tmr0_modemux[] = {
1041 	{
1042 		.muxregs = gpt0_tmr0_muxreg,
1043 		.nmuxregs = ARRAY_SIZE(gpt0_tmr0_muxreg),
1044 	},
1045 };
1046 
1047 static struct spear_pingroup gpt0_tmr0_pingroup = {
1048 	.name = "gpt0_tmr0_grp",
1049 	.pins = gpt0_tmr0_pins,
1050 	.npins = ARRAY_SIZE(gpt0_tmr0_pins),
1051 	.modemuxs = gpt0_tmr0_modemux,
1052 	.nmodemuxs = ARRAY_SIZE(gpt0_tmr0_modemux),
1053 };
1054 
1055 /* Pad multiplexing for gpt0_tmr1 device */
1056 static const unsigned gpt0_tmr1_pins[] = { 8, 9 };
1057 static struct spear_muxreg gpt0_tmr1_muxreg[] = {
1058 	{
1059 		.reg = PAD_FUNCTION_EN_1,
1060 		.mask = PMX_GPT0_TMR1_MASK,
1061 		.val = PMX_GPT0_TMR1_MASK,
1062 	}, {
1063 		.reg = PAD_DIRECTION_SEL_1,
1064 		.mask = PMX_GPT0_TMR1_MASK,
1065 		.val = PMX_GPT0_TMR1_MASK,
1066 	},
1067 };
1068 
1069 static struct spear_modemux gpt0_tmr1_modemux[] = {
1070 	{
1071 		.muxregs = gpt0_tmr1_muxreg,
1072 		.nmuxregs = ARRAY_SIZE(gpt0_tmr1_muxreg),
1073 	},
1074 };
1075 
1076 static struct spear_pingroup gpt0_tmr1_pingroup = {
1077 	.name = "gpt0_tmr1_grp",
1078 	.pins = gpt0_tmr1_pins,
1079 	.npins = ARRAY_SIZE(gpt0_tmr1_pins),
1080 	.modemuxs = gpt0_tmr1_modemux,
1081 	.nmodemuxs = ARRAY_SIZE(gpt0_tmr1_modemux),
1082 };
1083 
1084 static const char *const gpt0_grps[] = { "gpt0_tmr0_grp", "gpt0_tmr1_grp" };
1085 static struct spear_function gpt0_function = {
1086 	.name = "gpt0",
1087 	.groups = gpt0_grps,
1088 	.ngroups = ARRAY_SIZE(gpt0_grps),
1089 };
1090 
1091 /* Pad multiplexing for gpt1_tmr0 device */
1092 static const unsigned gpt1_tmr0_pins[] = { 6, 7 };
1093 static struct spear_muxreg gpt1_tmr0_muxreg[] = {
1094 	{
1095 		.reg = PAD_FUNCTION_EN_1,
1096 		.mask = PMX_GPT1_TMR0_MASK,
1097 		.val = PMX_GPT1_TMR0_MASK,
1098 	}, {
1099 		.reg = PAD_DIRECTION_SEL_1,
1100 		.mask = PMX_GPT1_TMR0_MASK,
1101 		.val = PMX_GPT1_TMR0_MASK,
1102 	},
1103 };
1104 
1105 static struct spear_modemux gpt1_tmr0_modemux[] = {
1106 	{
1107 		.muxregs = gpt1_tmr0_muxreg,
1108 		.nmuxregs = ARRAY_SIZE(gpt1_tmr0_muxreg),
1109 	},
1110 };
1111 
1112 static struct spear_pingroup gpt1_tmr0_pingroup = {
1113 	.name = "gpt1_tmr0_grp",
1114 	.pins = gpt1_tmr0_pins,
1115 	.npins = ARRAY_SIZE(gpt1_tmr0_pins),
1116 	.modemuxs = gpt1_tmr0_modemux,
1117 	.nmodemuxs = ARRAY_SIZE(gpt1_tmr0_modemux),
1118 };
1119 
1120 /* Pad multiplexing for gpt1_tmr1 device */
1121 static const unsigned gpt1_tmr1_pins[] = { 4, 5 };
1122 static struct spear_muxreg gpt1_tmr1_muxreg[] = {
1123 	{
1124 		.reg = PAD_FUNCTION_EN_1,
1125 		.mask = PMX_GPT1_TMR1_MASK,
1126 		.val = PMX_GPT1_TMR1_MASK,
1127 	}, {
1128 		.reg = PAD_DIRECTION_SEL_1,
1129 		.mask = PMX_GPT1_TMR1_MASK,
1130 		.val = PMX_GPT1_TMR1_MASK,
1131 	},
1132 };
1133 
1134 static struct spear_modemux gpt1_tmr1_modemux[] = {
1135 	{
1136 		.muxregs = gpt1_tmr1_muxreg,
1137 		.nmuxregs = ARRAY_SIZE(gpt1_tmr1_muxreg),
1138 	},
1139 };
1140 
1141 static struct spear_pingroup gpt1_tmr1_pingroup = {
1142 	.name = "gpt1_tmr1_grp",
1143 	.pins = gpt1_tmr1_pins,
1144 	.npins = ARRAY_SIZE(gpt1_tmr1_pins),
1145 	.modemuxs = gpt1_tmr1_modemux,
1146 	.nmodemuxs = ARRAY_SIZE(gpt1_tmr1_modemux),
1147 };
1148 
1149 static const char *const gpt1_grps[] = { "gpt1_tmr1_grp", "gpt1_tmr0_grp" };
1150 static struct spear_function gpt1_function = {
1151 	.name = "gpt1",
1152 	.groups = gpt1_grps,
1153 	.ngroups = ARRAY_SIZE(gpt1_grps),
1154 };
1155 
1156 /* Pad multiplexing for mcif device */
1157 static const unsigned mcif_pins[] = { 86, 87, 88, 89, 90, 91, 92, 93, 213, 214,
1158 	215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
1159 	229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
1160 	243, 244, 245 };
1161 #define MCIF_MUXREG						\
1162 	{							\
1163 		.reg = PAD_FUNCTION_EN_0,			\
1164 		.mask = PMX_MCI_DATA8_15_MASK,			\
1165 		.val = PMX_MCI_DATA8_15_MASK,			\
1166 	}, {							\
1167 		.reg = PAD_FUNCTION_EN_1,			\
1168 		.mask = PMX_MCIFALL_1_MASK | PMX_NFWPRT1_MASK |	\
1169 			PMX_NFWPRT2_MASK,			\
1170 		.val = PMX_MCIFALL_1_MASK,			\
1171 	}, {							\
1172 		.reg = PAD_FUNCTION_EN_2,			\
1173 		.mask = PMX_MCIFALL_2_MASK,			\
1174 		.val = PMX_MCIFALL_2_MASK,			\
1175 	}, {							\
1176 		.reg = PAD_DIRECTION_SEL_0,			\
1177 		.mask = PMX_MCI_DATA8_15_MASK,			\
1178 		.val = PMX_MCI_DATA8_15_MASK,			\
1179 	}, {							\
1180 		.reg = PAD_DIRECTION_SEL_1,			\
1181 		.mask = PMX_MCIFALL_1_MASK | PMX_NFWPRT1_MASK |	\
1182 			PMX_NFWPRT2_MASK,			\
1183 		.val = PMX_MCIFALL_1_MASK | PMX_NFWPRT1_MASK |  \
1184 			PMX_NFWPRT2_MASK,			\
1185 	}, {							\
1186 		.reg = PAD_DIRECTION_SEL_2,			\
1187 		.mask = PMX_MCIFALL_2_MASK,			\
1188 		.val = PMX_MCIFALL_2_MASK,			\
1189 	}
1190 
1191 /* sdhci device */
1192 static struct spear_muxreg sdhci_muxreg[] = {
1193 	MCIF_MUXREG,
1194 	{
1195 		.reg = PERIP_CFG,
1196 		.mask = MCIF_SEL_MASK,
1197 		.val = MCIF_SEL_SD,
1198 	},
1199 };
1200 
1201 static struct spear_modemux sdhci_modemux[] = {
1202 	{
1203 		.muxregs = sdhci_muxreg,
1204 		.nmuxregs = ARRAY_SIZE(sdhci_muxreg),
1205 	},
1206 };
1207 
1208 static struct spear_pingroup sdhci_pingroup = {
1209 	.name = "sdhci_grp",
1210 	.pins = mcif_pins,
1211 	.npins = ARRAY_SIZE(mcif_pins),
1212 	.modemuxs = sdhci_modemux,
1213 	.nmodemuxs = ARRAY_SIZE(sdhci_modemux),
1214 };
1215 
1216 static const char *const sdhci_grps[] = { "sdhci_grp" };
1217 static struct spear_function sdhci_function = {
1218 	.name = "sdhci",
1219 	.groups = sdhci_grps,
1220 	.ngroups = ARRAY_SIZE(sdhci_grps),
1221 };
1222 
1223 /* cf device */
1224 static struct spear_muxreg cf_muxreg[] = {
1225 	MCIF_MUXREG,
1226 	{
1227 		.reg = PERIP_CFG,
1228 		.mask = MCIF_SEL_MASK,
1229 		.val = MCIF_SEL_CF,
1230 	},
1231 };
1232 
1233 static struct spear_modemux cf_modemux[] = {
1234 	{
1235 		.muxregs = cf_muxreg,
1236 		.nmuxregs = ARRAY_SIZE(cf_muxreg),
1237 	},
1238 };
1239 
1240 static struct spear_pingroup cf_pingroup = {
1241 	.name = "cf_grp",
1242 	.pins = mcif_pins,
1243 	.npins = ARRAY_SIZE(mcif_pins),
1244 	.modemuxs = cf_modemux,
1245 	.nmodemuxs = ARRAY_SIZE(cf_modemux),
1246 };
1247 
1248 static const char *const cf_grps[] = { "cf_grp" };
1249 static struct spear_function cf_function = {
1250 	.name = "cf",
1251 	.groups = cf_grps,
1252 	.ngroups = ARRAY_SIZE(cf_grps),
1253 };
1254 
1255 /* xd device */
1256 static struct spear_muxreg xd_muxreg[] = {
1257 	MCIF_MUXREG,
1258 	{
1259 		.reg = PERIP_CFG,
1260 		.mask = MCIF_SEL_MASK,
1261 		.val = MCIF_SEL_XD,
1262 	},
1263 };
1264 
1265 static struct spear_modemux xd_modemux[] = {
1266 	{
1267 		.muxregs = xd_muxreg,
1268 		.nmuxregs = ARRAY_SIZE(xd_muxreg),
1269 	},
1270 };
1271 
1272 static struct spear_pingroup xd_pingroup = {
1273 	.name = "xd_grp",
1274 	.pins = mcif_pins,
1275 	.npins = ARRAY_SIZE(mcif_pins),
1276 	.modemuxs = xd_modemux,
1277 	.nmodemuxs = ARRAY_SIZE(xd_modemux),
1278 };
1279 
1280 static const char *const xd_grps[] = { "xd_grp" };
1281 static struct spear_function xd_function = {
1282 	.name = "xd",
1283 	.groups = xd_grps,
1284 	.ngroups = ARRAY_SIZE(xd_grps),
1285 };
1286 
1287 /* Pad multiplexing for touch_xy device */
1288 static const unsigned touch_xy_pins[] = { 97 };
1289 static struct spear_muxreg touch_xy_muxreg[] = {
1290 	{
1291 		.reg = PAD_FUNCTION_EN_2,
1292 		.mask = PMX_TOUCH_XY_MASK,
1293 		.val = PMX_TOUCH_XY_MASK,
1294 	}, {
1295 		.reg = PAD_DIRECTION_SEL_2,
1296 		.mask = PMX_TOUCH_XY_MASK,
1297 		.val = PMX_TOUCH_XY_MASK,
1298 	},
1299 };
1300 
1301 static struct spear_modemux touch_xy_modemux[] = {
1302 	{
1303 		.muxregs = touch_xy_muxreg,
1304 		.nmuxregs = ARRAY_SIZE(touch_xy_muxreg),
1305 	},
1306 };
1307 
1308 static struct spear_pingroup touch_xy_pingroup = {
1309 	.name = "touch_xy_grp",
1310 	.pins = touch_xy_pins,
1311 	.npins = ARRAY_SIZE(touch_xy_pins),
1312 	.modemuxs = touch_xy_modemux,
1313 	.nmodemuxs = ARRAY_SIZE(touch_xy_modemux),
1314 };
1315 
1316 static const char *const touch_xy_grps[] = { "touch_xy_grp" };
1317 static struct spear_function touch_xy_function = {
1318 	.name = "touchscreen",
1319 	.groups = touch_xy_grps,
1320 	.ngroups = ARRAY_SIZE(touch_xy_grps),
1321 };
1322 
1323 /* Pad multiplexing for uart1 device */
1324 /* Muxed with I2C */
1325 static const unsigned uart1_dis_i2c_pins[] = { 102, 103 };
1326 static struct spear_muxreg uart1_dis_i2c_muxreg[] = {
1327 	{
1328 		.reg = PAD_FUNCTION_EN_0,
1329 		.mask = PMX_I2C0_MASK,
1330 		.val = 0,
1331 	}, {
1332 		.reg = PAD_DIRECTION_SEL_0,
1333 		.mask = PMX_I2C0_MASK,
1334 		.val = PMX_I2C0_MASK,
1335 	},
1336 };
1337 
1338 static struct spear_modemux uart1_dis_i2c_modemux[] = {
1339 	{
1340 		.muxregs = uart1_dis_i2c_muxreg,
1341 		.nmuxregs = ARRAY_SIZE(uart1_dis_i2c_muxreg),
1342 	},
1343 };
1344 
1345 static struct spear_pingroup uart_1_dis_i2c_pingroup = {
1346 	.name = "uart1_disable_i2c_grp",
1347 	.pins = uart1_dis_i2c_pins,
1348 	.npins = ARRAY_SIZE(uart1_dis_i2c_pins),
1349 	.modemuxs = uart1_dis_i2c_modemux,
1350 	.nmodemuxs = ARRAY_SIZE(uart1_dis_i2c_modemux),
1351 };
1352 
1353 /* Muxed with SD/MMC */
1354 static const unsigned uart1_dis_sd_pins[] = { 214, 215 };
1355 static struct spear_muxreg uart1_dis_sd_muxreg[] = {
1356 	{
1357 		.reg = PAD_FUNCTION_EN_1,
1358 		.mask = PMX_MCIDATA1_MASK |
1359 			PMX_MCIDATA2_MASK,
1360 		.val = 0,
1361 	}, {
1362 		.reg = PAD_DIRECTION_SEL_1,
1363 		.mask = PMX_MCIDATA1_MASK |
1364 			PMX_MCIDATA2_MASK,
1365 		.val = PMX_MCIDATA1_MASK |
1366 			PMX_MCIDATA2_MASK,
1367 	},
1368 };
1369 
1370 static struct spear_modemux uart1_dis_sd_modemux[] = {
1371 	{
1372 		.muxregs = uart1_dis_sd_muxreg,
1373 		.nmuxregs = ARRAY_SIZE(uart1_dis_sd_muxreg),
1374 	},
1375 };
1376 
1377 static struct spear_pingroup uart_1_dis_sd_pingroup = {
1378 	.name = "uart1_disable_sd_grp",
1379 	.pins = uart1_dis_sd_pins,
1380 	.npins = ARRAY_SIZE(uart1_dis_sd_pins),
1381 	.modemuxs = uart1_dis_sd_modemux,
1382 	.nmodemuxs = ARRAY_SIZE(uart1_dis_sd_modemux),
1383 };
1384 
1385 static const char *const uart1_grps[] = { "uart1_disable_i2c_grp",
1386 	"uart1_disable_sd_grp" };
1387 static struct spear_function uart1_function = {
1388 	.name = "uart1",
1389 	.groups = uart1_grps,
1390 	.ngroups = ARRAY_SIZE(uart1_grps),
1391 };
1392 
1393 /* Pad multiplexing for uart2_3 device */
1394 static const unsigned uart2_3_pins[] = { 104, 105, 106, 107 };
1395 static struct spear_muxreg uart2_3_muxreg[] = {
1396 	{
1397 		.reg = PAD_FUNCTION_EN_0,
1398 		.mask = PMX_I2S0_MASK,
1399 		.val = 0,
1400 	}, {
1401 		.reg = PAD_DIRECTION_SEL_0,
1402 		.mask = PMX_I2S0_MASK,
1403 		.val = PMX_I2S0_MASK,
1404 	},
1405 };
1406 
1407 static struct spear_modemux uart2_3_modemux[] = {
1408 	{
1409 		.muxregs = uart2_3_muxreg,
1410 		.nmuxregs = ARRAY_SIZE(uart2_3_muxreg),
1411 	},
1412 };
1413 
1414 static struct spear_pingroup uart_2_3_pingroup = {
1415 	.name = "uart2_3_grp",
1416 	.pins = uart2_3_pins,
1417 	.npins = ARRAY_SIZE(uart2_3_pins),
1418 	.modemuxs = uart2_3_modemux,
1419 	.nmodemuxs = ARRAY_SIZE(uart2_3_modemux),
1420 };
1421 
1422 static const char *const uart2_3_grps[] = { "uart2_3_grp" };
1423 static struct spear_function uart2_3_function = {
1424 	.name = "uart2_3",
1425 	.groups = uart2_3_grps,
1426 	.ngroups = ARRAY_SIZE(uart2_3_grps),
1427 };
1428 
1429 /* Pad multiplexing for uart4 device */
1430 static const unsigned uart4_pins[] = { 108, 113 };
1431 static struct spear_muxreg uart4_muxreg[] = {
1432 	{
1433 		.reg = PAD_FUNCTION_EN_0,
1434 		.mask = PMX_I2S0_MASK | PMX_CLCD1_MASK,
1435 		.val = 0,
1436 	}, {
1437 		.reg = PAD_DIRECTION_SEL_0,
1438 		.mask = PMX_I2S0_MASK | PMX_CLCD1_MASK,
1439 		.val = PMX_I2S0_MASK | PMX_CLCD1_MASK,
1440 	},
1441 };
1442 
1443 static struct spear_modemux uart4_modemux[] = {
1444 	{
1445 		.muxregs = uart4_muxreg,
1446 		.nmuxregs = ARRAY_SIZE(uart4_muxreg),
1447 	},
1448 };
1449 
1450 static struct spear_pingroup uart_4_pingroup = {
1451 	.name = "uart4_grp",
1452 	.pins = uart4_pins,
1453 	.npins = ARRAY_SIZE(uart4_pins),
1454 	.modemuxs = uart4_modemux,
1455 	.nmodemuxs = ARRAY_SIZE(uart4_modemux),
1456 };
1457 
1458 static const char *const uart4_grps[] = { "uart4_grp" };
1459 static struct spear_function uart4_function = {
1460 	.name = "uart4",
1461 	.groups = uart4_grps,
1462 	.ngroups = ARRAY_SIZE(uart4_grps),
1463 };
1464 
1465 /* Pad multiplexing for uart5 device */
1466 static const unsigned uart5_pins[] = { 114, 115 };
1467 static struct spear_muxreg uart5_muxreg[] = {
1468 	{
1469 		.reg = PAD_FUNCTION_EN_0,
1470 		.mask = PMX_CLCD1_MASK,
1471 		.val = 0,
1472 	}, {
1473 		.reg = PAD_DIRECTION_SEL_0,
1474 		.mask = PMX_CLCD1_MASK,
1475 		.val = PMX_CLCD1_MASK,
1476 	},
1477 };
1478 
1479 static struct spear_modemux uart5_modemux[] = {
1480 	{
1481 		.muxregs = uart5_muxreg,
1482 		.nmuxregs = ARRAY_SIZE(uart5_muxreg),
1483 	},
1484 };
1485 
1486 static struct spear_pingroup uart_5_pingroup = {
1487 	.name = "uart5_grp",
1488 	.pins = uart5_pins,
1489 	.npins = ARRAY_SIZE(uart5_pins),
1490 	.modemuxs = uart5_modemux,
1491 	.nmodemuxs = ARRAY_SIZE(uart5_modemux),
1492 };
1493 
1494 static const char *const uart5_grps[] = { "uart5_grp" };
1495 static struct spear_function uart5_function = {
1496 	.name = "uart5",
1497 	.groups = uart5_grps,
1498 	.ngroups = ARRAY_SIZE(uart5_grps),
1499 };
1500 
1501 /* Pad multiplexing for rs485_0_1_tdm_0_1 device */
1502 static const unsigned rs485_0_1_tdm_0_1_pins[] = { 116, 117, 118, 119, 120, 121,
1503 	122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1504 	136, 137 };
1505 static struct spear_muxreg rs485_0_1_tdm_0_1_muxreg[] = {
1506 	{
1507 		.reg = PAD_FUNCTION_EN_0,
1508 		.mask = PMX_CLCD1_MASK,
1509 		.val = 0,
1510 	}, {
1511 		.reg = PAD_DIRECTION_SEL_0,
1512 		.mask = PMX_CLCD1_MASK,
1513 		.val = PMX_CLCD1_MASK,
1514 	},
1515 };
1516 
1517 static struct spear_modemux rs485_0_1_tdm_0_1_modemux[] = {
1518 	{
1519 		.muxregs = rs485_0_1_tdm_0_1_muxreg,
1520 		.nmuxregs = ARRAY_SIZE(rs485_0_1_tdm_0_1_muxreg),
1521 	},
1522 };
1523 
1524 static struct spear_pingroup rs485_0_1_tdm_0_1_pingroup = {
1525 	.name = "rs485_0_1_tdm_0_1_grp",
1526 	.pins = rs485_0_1_tdm_0_1_pins,
1527 	.npins = ARRAY_SIZE(rs485_0_1_tdm_0_1_pins),
1528 	.modemuxs = rs485_0_1_tdm_0_1_modemux,
1529 	.nmodemuxs = ARRAY_SIZE(rs485_0_1_tdm_0_1_modemux),
1530 };
1531 
1532 static const char *const rs485_0_1_tdm_0_1_grps[] = { "rs485_0_1_tdm_0_1_grp" };
1533 static struct spear_function rs485_0_1_tdm_0_1_function = {
1534 	.name = "rs485_0_1_tdm_0_1",
1535 	.groups = rs485_0_1_tdm_0_1_grps,
1536 	.ngroups = ARRAY_SIZE(rs485_0_1_tdm_0_1_grps),
1537 };
1538 
1539 /* Pad multiplexing for i2c_1_2 device */
1540 static const unsigned i2c_1_2_pins[] = { 138, 139, 140, 141 };
1541 static struct spear_muxreg i2c_1_2_muxreg[] = {
1542 	{
1543 		.reg = PAD_FUNCTION_EN_0,
1544 		.mask = PMX_CLCD1_MASK,
1545 		.val = 0,
1546 	}, {
1547 		.reg = PAD_DIRECTION_SEL_0,
1548 		.mask = PMX_CLCD1_MASK,
1549 		.val = PMX_CLCD1_MASK,
1550 	},
1551 };
1552 
1553 static struct spear_modemux i2c_1_2_modemux[] = {
1554 	{
1555 		.muxregs = i2c_1_2_muxreg,
1556 		.nmuxregs = ARRAY_SIZE(i2c_1_2_muxreg),
1557 	},
1558 };
1559 
1560 static struct spear_pingroup i2c_1_2_pingroup = {
1561 	.name = "i2c_1_2_grp",
1562 	.pins = i2c_1_2_pins,
1563 	.npins = ARRAY_SIZE(i2c_1_2_pins),
1564 	.modemuxs = i2c_1_2_modemux,
1565 	.nmodemuxs = ARRAY_SIZE(i2c_1_2_modemux),
1566 };
1567 
1568 static const char *const i2c_1_2_grps[] = { "i2c_1_2_grp" };
1569 static struct spear_function i2c_1_2_function = {
1570 	.name = "i2c_1_2",
1571 	.groups = i2c_1_2_grps,
1572 	.ngroups = ARRAY_SIZE(i2c_1_2_grps),
1573 };
1574 
1575 /* Pad multiplexing for i2c3_dis_smi_clcd device */
1576 /* Muxed with SMI & CLCD */
1577 static const unsigned i2c3_dis_smi_clcd_pins[] = { 142, 153 };
1578 static struct spear_muxreg i2c3_dis_smi_clcd_muxreg[] = {
1579 	{
1580 		.reg = PAD_FUNCTION_EN_0,
1581 		.mask = PMX_CLCD1_MASK | PMX_SMI_MASK,
1582 		.val = 0,
1583 	}, {
1584 		.reg = PAD_DIRECTION_SEL_0,
1585 		.mask = PMX_CLCD1_MASK | PMX_SMI_MASK,
1586 		.val = PMX_CLCD1_MASK | PMX_SMI_MASK,
1587 	},
1588 };
1589 
1590 static struct spear_modemux i2c3_dis_smi_clcd_modemux[] = {
1591 	{
1592 		.muxregs = i2c3_dis_smi_clcd_muxreg,
1593 		.nmuxregs = ARRAY_SIZE(i2c3_dis_smi_clcd_muxreg),
1594 	},
1595 };
1596 
1597 static struct spear_pingroup i2c3_dis_smi_clcd_pingroup = {
1598 	.name = "i2c3_dis_smi_clcd_grp",
1599 	.pins = i2c3_dis_smi_clcd_pins,
1600 	.npins = ARRAY_SIZE(i2c3_dis_smi_clcd_pins),
1601 	.modemuxs = i2c3_dis_smi_clcd_modemux,
1602 	.nmodemuxs = ARRAY_SIZE(i2c3_dis_smi_clcd_modemux),
1603 };
1604 
1605 /* Pad multiplexing for i2c3_dis_sd_i2s0 device */
1606 /* Muxed with SD/MMC & I2S1 */
1607 static const unsigned i2c3_dis_sd_i2s0_pins[] = { 0, 216 };
1608 static struct spear_muxreg i2c3_dis_sd_i2s0_muxreg[] = {
1609 	{
1610 		.reg = PAD_FUNCTION_EN_1,
1611 		.mask = PMX_I2S1_MASK | PMX_MCIDATA3_MASK,
1612 		.val = 0,
1613 	}, {
1614 		.reg = PAD_DIRECTION_SEL_1,
1615 		.mask = PMX_I2S1_MASK | PMX_MCIDATA3_MASK,
1616 		.val = PMX_I2S1_MASK | PMX_MCIDATA3_MASK,
1617 	},
1618 };
1619 
1620 static struct spear_modemux i2c3_dis_sd_i2s0_modemux[] = {
1621 	{
1622 		.muxregs = i2c3_dis_sd_i2s0_muxreg,
1623 		.nmuxregs = ARRAY_SIZE(i2c3_dis_sd_i2s0_muxreg),
1624 	},
1625 };
1626 
1627 static struct spear_pingroup i2c3_dis_sd_i2s0_pingroup = {
1628 	.name = "i2c3_dis_sd_i2s0_grp",
1629 	.pins = i2c3_dis_sd_i2s0_pins,
1630 	.npins = ARRAY_SIZE(i2c3_dis_sd_i2s0_pins),
1631 	.modemuxs = i2c3_dis_sd_i2s0_modemux,
1632 	.nmodemuxs = ARRAY_SIZE(i2c3_dis_sd_i2s0_modemux),
1633 };
1634 
1635 static const char *const i2c3_grps[] = { "i2c3_dis_smi_clcd_grp",
1636 	"i2c3_dis_sd_i2s0_grp" };
1637 static struct spear_function i2c3_unction = {
1638 	.name = "i2c3_i2s1",
1639 	.groups = i2c3_grps,
1640 	.ngroups = ARRAY_SIZE(i2c3_grps),
1641 };
1642 
1643 /* Pad multiplexing for i2c_4_5_dis_smi device */
1644 /* Muxed with SMI */
1645 static const unsigned i2c_4_5_dis_smi_pins[] = { 154, 155, 156, 157 };
1646 static struct spear_muxreg i2c_4_5_dis_smi_muxreg[] = {
1647 	{
1648 		.reg = PAD_FUNCTION_EN_0,
1649 		.mask = PMX_SMI_MASK,
1650 		.val = 0,
1651 	}, {
1652 		.reg = PAD_DIRECTION_SEL_0,
1653 		.mask = PMX_SMI_MASK,
1654 		.val = PMX_SMI_MASK,
1655 	},
1656 };
1657 
1658 static struct spear_modemux i2c_4_5_dis_smi_modemux[] = {
1659 	{
1660 		.muxregs = i2c_4_5_dis_smi_muxreg,
1661 		.nmuxregs = ARRAY_SIZE(i2c_4_5_dis_smi_muxreg),
1662 	},
1663 };
1664 
1665 static struct spear_pingroup i2c_4_5_dis_smi_pingroup = {
1666 	.name = "i2c_4_5_dis_smi_grp",
1667 	.pins = i2c_4_5_dis_smi_pins,
1668 	.npins = ARRAY_SIZE(i2c_4_5_dis_smi_pins),
1669 	.modemuxs = i2c_4_5_dis_smi_modemux,
1670 	.nmodemuxs = ARRAY_SIZE(i2c_4_5_dis_smi_modemux),
1671 };
1672 
1673 /* Pad multiplexing for i2c4_dis_sd device */
1674 /* Muxed with SD/MMC */
1675 static const unsigned i2c4_dis_sd_pins[] = { 217, 218 };
1676 static struct spear_muxreg i2c4_dis_sd_muxreg[] = {
1677 	{
1678 		.reg = PAD_FUNCTION_EN_1,
1679 		.mask = PMX_MCIDATA4_MASK,
1680 		.val = 0,
1681 	}, {
1682 		.reg = PAD_FUNCTION_EN_2,
1683 		.mask = PMX_MCIDATA5_MASK,
1684 		.val = 0,
1685 	}, {
1686 		.reg = PAD_DIRECTION_SEL_1,
1687 		.mask = PMX_MCIDATA4_MASK,
1688 		.val = PMX_MCIDATA4_MASK,
1689 	}, {
1690 		.reg = PAD_DIRECTION_SEL_2,
1691 		.mask = PMX_MCIDATA5_MASK,
1692 		.val = PMX_MCIDATA5_MASK,
1693 	},
1694 };
1695 
1696 static struct spear_modemux i2c4_dis_sd_modemux[] = {
1697 	{
1698 		.muxregs = i2c4_dis_sd_muxreg,
1699 		.nmuxregs = ARRAY_SIZE(i2c4_dis_sd_muxreg),
1700 	},
1701 };
1702 
1703 static struct spear_pingroup i2c4_dis_sd_pingroup = {
1704 	.name = "i2c4_dis_sd_grp",
1705 	.pins = i2c4_dis_sd_pins,
1706 	.npins = ARRAY_SIZE(i2c4_dis_sd_pins),
1707 	.modemuxs = i2c4_dis_sd_modemux,
1708 	.nmodemuxs = ARRAY_SIZE(i2c4_dis_sd_modemux),
1709 };
1710 
1711 /* Pad multiplexing for i2c5_dis_sd device */
1712 /* Muxed with SD/MMC */
1713 static const unsigned i2c5_dis_sd_pins[] = { 219, 220 };
1714 static struct spear_muxreg i2c5_dis_sd_muxreg[] = {
1715 	{
1716 		.reg = PAD_FUNCTION_EN_2,
1717 		.mask = PMX_MCIDATA6_MASK |
1718 			PMX_MCIDATA7_MASK,
1719 		.val = 0,
1720 	}, {
1721 		.reg = PAD_DIRECTION_SEL_2,
1722 		.mask = PMX_MCIDATA6_MASK |
1723 			PMX_MCIDATA7_MASK,
1724 		.val = PMX_MCIDATA6_MASK |
1725 			PMX_MCIDATA7_MASK,
1726 	},
1727 };
1728 
1729 static struct spear_modemux i2c5_dis_sd_modemux[] = {
1730 	{
1731 		.muxregs = i2c5_dis_sd_muxreg,
1732 		.nmuxregs = ARRAY_SIZE(i2c5_dis_sd_muxreg),
1733 	},
1734 };
1735 
1736 static struct spear_pingroup i2c5_dis_sd_pingroup = {
1737 	.name = "i2c5_dis_sd_grp",
1738 	.pins = i2c5_dis_sd_pins,
1739 	.npins = ARRAY_SIZE(i2c5_dis_sd_pins),
1740 	.modemuxs = i2c5_dis_sd_modemux,
1741 	.nmodemuxs = ARRAY_SIZE(i2c5_dis_sd_modemux),
1742 };
1743 
1744 static const char *const i2c_4_5_grps[] = { "i2c5_dis_sd_grp",
1745 	"i2c4_dis_sd_grp", "i2c_4_5_dis_smi_grp" };
1746 static struct spear_function i2c_4_5_function = {
1747 	.name = "i2c_4_5",
1748 	.groups = i2c_4_5_grps,
1749 	.ngroups = ARRAY_SIZE(i2c_4_5_grps),
1750 };
1751 
1752 /* Pad multiplexing for i2c_6_7_dis_kbd device */
1753 /* Muxed with KBD */
1754 static const unsigned i2c_6_7_dis_kbd_pins[] = { 207, 208, 209, 210 };
1755 static struct spear_muxreg i2c_6_7_dis_kbd_muxreg[] = {
1756 	{
1757 		.reg = PAD_FUNCTION_EN_1,
1758 		.mask = PMX_KBD_ROWCOL25_MASK,
1759 		.val = 0,
1760 	}, {
1761 		.reg = PAD_DIRECTION_SEL_1,
1762 		.mask = PMX_KBD_ROWCOL25_MASK,
1763 		.val = PMX_KBD_ROWCOL25_MASK,
1764 	},
1765 };
1766 
1767 static struct spear_modemux i2c_6_7_dis_kbd_modemux[] = {
1768 	{
1769 		.muxregs = i2c_6_7_dis_kbd_muxreg,
1770 		.nmuxregs = ARRAY_SIZE(i2c_6_7_dis_kbd_muxreg),
1771 	},
1772 };
1773 
1774 static struct spear_pingroup i2c_6_7_dis_kbd_pingroup = {
1775 	.name = "i2c_6_7_dis_kbd_grp",
1776 	.pins = i2c_6_7_dis_kbd_pins,
1777 	.npins = ARRAY_SIZE(i2c_6_7_dis_kbd_pins),
1778 	.modemuxs = i2c_6_7_dis_kbd_modemux,
1779 	.nmodemuxs = ARRAY_SIZE(i2c_6_7_dis_kbd_modemux),
1780 };
1781 
1782 /* Pad multiplexing for i2c6_dis_sd device */
1783 /* Muxed with SD/MMC */
1784 static const unsigned i2c6_dis_sd_pins[] = { 236, 237 };
1785 static struct spear_muxreg i2c6_dis_sd_muxreg[] = {
1786 	{
1787 		.reg = PAD_FUNCTION_EN_2,
1788 		.mask = PMX_MCIIORDRE_MASK |
1789 			PMX_MCIIOWRWE_MASK,
1790 		.val = 0,
1791 	}, {
1792 		.reg = PAD_DIRECTION_SEL_2,
1793 		.mask = PMX_MCIIORDRE_MASK |
1794 			PMX_MCIIOWRWE_MASK,
1795 		.val = PMX_MCIIORDRE_MASK |
1796 			PMX_MCIIOWRWE_MASK,
1797 	},
1798 };
1799 
1800 static struct spear_modemux i2c6_dis_sd_modemux[] = {
1801 	{
1802 		.muxregs = i2c6_dis_sd_muxreg,
1803 		.nmuxregs = ARRAY_SIZE(i2c6_dis_sd_muxreg),
1804 	},
1805 };
1806 
1807 static struct spear_pingroup i2c6_dis_sd_pingroup = {
1808 	.name = "i2c6_dis_sd_grp",
1809 	.pins = i2c6_dis_sd_pins,
1810 	.npins = ARRAY_SIZE(i2c6_dis_sd_pins),
1811 	.modemuxs = i2c6_dis_sd_modemux,
1812 	.nmodemuxs = ARRAY_SIZE(i2c6_dis_sd_modemux),
1813 };
1814 
1815 /* Pad multiplexing for i2c7_dis_sd device */
1816 static const unsigned i2c7_dis_sd_pins[] = { 238, 239 };
1817 static struct spear_muxreg i2c7_dis_sd_muxreg[] = {
1818 	{
1819 		.reg = PAD_FUNCTION_EN_2,
1820 		.mask = PMX_MCIRESETCF_MASK |
1821 			PMX_MCICS0CE_MASK,
1822 		.val = 0,
1823 	}, {
1824 		.reg = PAD_DIRECTION_SEL_2,
1825 		.mask = PMX_MCIRESETCF_MASK |
1826 			PMX_MCICS0CE_MASK,
1827 		.val = PMX_MCIRESETCF_MASK |
1828 			PMX_MCICS0CE_MASK,
1829 	},
1830 };
1831 
1832 static struct spear_modemux i2c7_dis_sd_modemux[] = {
1833 	{
1834 		.muxregs = i2c7_dis_sd_muxreg,
1835 		.nmuxregs = ARRAY_SIZE(i2c7_dis_sd_muxreg),
1836 	},
1837 };
1838 
1839 static struct spear_pingroup i2c7_dis_sd_pingroup = {
1840 	.name = "i2c7_dis_sd_grp",
1841 	.pins = i2c7_dis_sd_pins,
1842 	.npins = ARRAY_SIZE(i2c7_dis_sd_pins),
1843 	.modemuxs = i2c7_dis_sd_modemux,
1844 	.nmodemuxs = ARRAY_SIZE(i2c7_dis_sd_modemux),
1845 };
1846 
1847 static const char *const i2c_6_7_grps[] = { "i2c6_dis_sd_grp",
1848 	"i2c7_dis_sd_grp", "i2c_6_7_dis_kbd_grp" };
1849 static struct spear_function i2c_6_7_function = {
1850 	.name = "i2c_6_7",
1851 	.groups = i2c_6_7_grps,
1852 	.ngroups = ARRAY_SIZE(i2c_6_7_grps),
1853 };
1854 
1855 /* Pad multiplexing for can0_dis_nor device */
1856 /* Muxed with NOR */
1857 static const unsigned can0_dis_nor_pins[] = { 56, 57 };
1858 static struct spear_muxreg can0_dis_nor_muxreg[] = {
1859 	{
1860 		.reg = PAD_FUNCTION_EN_0,
1861 		.mask = PMX_NFRSTPWDWN2_MASK,
1862 		.val = 0,
1863 	}, {
1864 		.reg = PAD_FUNCTION_EN_1,
1865 		.mask = PMX_NFRSTPWDWN3_MASK,
1866 		.val = 0,
1867 	}, {
1868 		.reg = PAD_DIRECTION_SEL_0,
1869 		.mask = PMX_NFRSTPWDWN2_MASK,
1870 		.val = PMX_NFRSTPWDWN2_MASK,
1871 	}, {
1872 		.reg = PAD_DIRECTION_SEL_1,
1873 		.mask = PMX_NFRSTPWDWN3_MASK,
1874 		.val = PMX_NFRSTPWDWN3_MASK,
1875 	},
1876 };
1877 
1878 static struct spear_modemux can0_dis_nor_modemux[] = {
1879 	{
1880 		.muxregs = can0_dis_nor_muxreg,
1881 		.nmuxregs = ARRAY_SIZE(can0_dis_nor_muxreg),
1882 	},
1883 };
1884 
1885 static struct spear_pingroup can0_dis_nor_pingroup = {
1886 	.name = "can0_dis_nor_grp",
1887 	.pins = can0_dis_nor_pins,
1888 	.npins = ARRAY_SIZE(can0_dis_nor_pins),
1889 	.modemuxs = can0_dis_nor_modemux,
1890 	.nmodemuxs = ARRAY_SIZE(can0_dis_nor_modemux),
1891 };
1892 
1893 /* Pad multiplexing for can0_dis_sd device */
1894 /* Muxed with SD/MMC */
1895 static const unsigned can0_dis_sd_pins[] = { 240, 241 };
1896 static struct spear_muxreg can0_dis_sd_muxreg[] = {
1897 	{
1898 		.reg = PAD_FUNCTION_EN_2,
1899 		.mask = PMX_MCICFINTR_MASK | PMX_MCIIORDY_MASK,
1900 		.val = 0,
1901 	}, {
1902 		.reg = PAD_DIRECTION_SEL_2,
1903 		.mask = PMX_MCICFINTR_MASK | PMX_MCIIORDY_MASK,
1904 		.val = PMX_MCICFINTR_MASK | PMX_MCIIORDY_MASK,
1905 	},
1906 };
1907 
1908 static struct spear_modemux can0_dis_sd_modemux[] = {
1909 	{
1910 		.muxregs = can0_dis_sd_muxreg,
1911 		.nmuxregs = ARRAY_SIZE(can0_dis_sd_muxreg),
1912 	},
1913 };
1914 
1915 static struct spear_pingroup can0_dis_sd_pingroup = {
1916 	.name = "can0_dis_sd_grp",
1917 	.pins = can0_dis_sd_pins,
1918 	.npins = ARRAY_SIZE(can0_dis_sd_pins),
1919 	.modemuxs = can0_dis_sd_modemux,
1920 	.nmodemuxs = ARRAY_SIZE(can0_dis_sd_modemux),
1921 };
1922 
1923 static const char *const can0_grps[] = { "can0_dis_nor_grp", "can0_dis_sd_grp"
1924 };
1925 static struct spear_function can0_function = {
1926 	.name = "can0",
1927 	.groups = can0_grps,
1928 	.ngroups = ARRAY_SIZE(can0_grps),
1929 };
1930 
1931 /* Pad multiplexing for can1_dis_sd device */
1932 /* Muxed with SD/MMC */
1933 static const unsigned can1_dis_sd_pins[] = { 242, 243 };
1934 static struct spear_muxreg can1_dis_sd_muxreg[] = {
1935 	{
1936 		.reg = PAD_FUNCTION_EN_2,
1937 		.mask = PMX_MCICS1_MASK | PMX_MCIDMAACK_MASK,
1938 		.val = 0,
1939 	}, {
1940 		.reg = PAD_DIRECTION_SEL_2,
1941 		.mask = PMX_MCICS1_MASK | PMX_MCIDMAACK_MASK,
1942 		.val = PMX_MCICS1_MASK | PMX_MCIDMAACK_MASK,
1943 	},
1944 };
1945 
1946 static struct spear_modemux can1_dis_sd_modemux[] = {
1947 	{
1948 		.muxregs = can1_dis_sd_muxreg,
1949 		.nmuxregs = ARRAY_SIZE(can1_dis_sd_muxreg),
1950 	},
1951 };
1952 
1953 static struct spear_pingroup can1_dis_sd_pingroup = {
1954 	.name = "can1_dis_sd_grp",
1955 	.pins = can1_dis_sd_pins,
1956 	.npins = ARRAY_SIZE(can1_dis_sd_pins),
1957 	.modemuxs = can1_dis_sd_modemux,
1958 	.nmodemuxs = ARRAY_SIZE(can1_dis_sd_modemux),
1959 };
1960 
1961 /* Pad multiplexing for can1_dis_kbd device */
1962 /* Muxed with KBD */
1963 static const unsigned can1_dis_kbd_pins[] = { 201, 202 };
1964 static struct spear_muxreg can1_dis_kbd_muxreg[] = {
1965 	{
1966 		.reg = PAD_FUNCTION_EN_1,
1967 		.mask = PMX_KBD_ROWCOL25_MASK,
1968 		.val = 0,
1969 	}, {
1970 		.reg = PAD_DIRECTION_SEL_1,
1971 		.mask = PMX_KBD_ROWCOL25_MASK,
1972 		.val = PMX_KBD_ROWCOL25_MASK,
1973 	},
1974 };
1975 
1976 static struct spear_modemux can1_dis_kbd_modemux[] = {
1977 	{
1978 		.muxregs = can1_dis_kbd_muxreg,
1979 		.nmuxregs = ARRAY_SIZE(can1_dis_kbd_muxreg),
1980 	},
1981 };
1982 
1983 static struct spear_pingroup can1_dis_kbd_pingroup = {
1984 	.name = "can1_dis_kbd_grp",
1985 	.pins = can1_dis_kbd_pins,
1986 	.npins = ARRAY_SIZE(can1_dis_kbd_pins),
1987 	.modemuxs = can1_dis_kbd_modemux,
1988 	.nmodemuxs = ARRAY_SIZE(can1_dis_kbd_modemux),
1989 };
1990 
1991 static const char *const can1_grps[] = { "can1_dis_sd_grp", "can1_dis_kbd_grp"
1992 };
1993 static struct spear_function can1_function = {
1994 	.name = "can1",
1995 	.groups = can1_grps,
1996 	.ngroups = ARRAY_SIZE(can1_grps),
1997 };
1998 
1999 /* Pad multiplexing for (ras-ip) pci device */
2000 static const unsigned pci_pins[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 18,
2001 	19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2002 	37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2003 	55, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 };
2004 
2005 static struct spear_muxreg pci_muxreg[] = {
2006 	{
2007 		.reg = PAD_FUNCTION_EN_0,
2008 		.mask = PMX_MCI_DATA8_15_MASK,
2009 		.val = 0,
2010 	}, {
2011 		.reg = PAD_FUNCTION_EN_1,
2012 		.mask = PMX_PCI_REG1_MASK,
2013 		.val = 0,
2014 	}, {
2015 		.reg = PAD_FUNCTION_EN_2,
2016 		.mask = PMX_PCI_REG2_MASK,
2017 		.val = 0,
2018 	}, {
2019 		.reg = PAD_DIRECTION_SEL_0,
2020 		.mask = PMX_MCI_DATA8_15_MASK,
2021 		.val = PMX_MCI_DATA8_15_MASK,
2022 	}, {
2023 		.reg = PAD_DIRECTION_SEL_1,
2024 		.mask = PMX_PCI_REG1_MASK,
2025 		.val = PMX_PCI_REG1_MASK,
2026 	}, {
2027 		.reg = PAD_DIRECTION_SEL_2,
2028 		.mask = PMX_PCI_REG2_MASK,
2029 		.val = PMX_PCI_REG2_MASK,
2030 	},
2031 };
2032 
2033 static struct spear_modemux pci_modemux[] = {
2034 	{
2035 		.muxregs = pci_muxreg,
2036 		.nmuxregs = ARRAY_SIZE(pci_muxreg),
2037 	},
2038 };
2039 
2040 static struct spear_pingroup pci_pingroup = {
2041 	.name = "pci_grp",
2042 	.pins = pci_pins,
2043 	.npins = ARRAY_SIZE(pci_pins),
2044 	.modemuxs = pci_modemux,
2045 	.nmodemuxs = ARRAY_SIZE(pci_modemux),
2046 };
2047 
2048 static const char *const pci_grps[] = { "pci_grp" };
2049 static struct spear_function pci_function = {
2050 	.name = "pci",
2051 	.groups = pci_grps,
2052 	.ngroups = ARRAY_SIZE(pci_grps),
2053 };
2054 
2055 /* pad multiplexing for (fix-part) pcie0 device */
2056 static struct spear_muxreg pcie0_muxreg[] = {
2057 	{
2058 		.reg = PCIE_SATA_CFG,
2059 		.mask = PCIE_CFG_VAL(0),
2060 		.val = PCIE_CFG_VAL(0),
2061 	},
2062 };
2063 
2064 static struct spear_modemux pcie0_modemux[] = {
2065 	{
2066 		.muxregs = pcie0_muxreg,
2067 		.nmuxregs = ARRAY_SIZE(pcie0_muxreg),
2068 	},
2069 };
2070 
2071 static struct spear_pingroup pcie0_pingroup = {
2072 	.name = "pcie0_grp",
2073 	.modemuxs = pcie0_modemux,
2074 	.nmodemuxs = ARRAY_SIZE(pcie0_modemux),
2075 };
2076 
2077 /* pad multiplexing for (fix-part) pcie1 device */
2078 static struct spear_muxreg pcie1_muxreg[] = {
2079 	{
2080 		.reg = PCIE_SATA_CFG,
2081 		.mask = PCIE_CFG_VAL(1),
2082 		.val = PCIE_CFG_VAL(1),
2083 	},
2084 };
2085 
2086 static struct spear_modemux pcie1_modemux[] = {
2087 	{
2088 		.muxregs = pcie1_muxreg,
2089 		.nmuxregs = ARRAY_SIZE(pcie1_muxreg),
2090 	},
2091 };
2092 
2093 static struct spear_pingroup pcie1_pingroup = {
2094 	.name = "pcie1_grp",
2095 	.modemuxs = pcie1_modemux,
2096 	.nmodemuxs = ARRAY_SIZE(pcie1_modemux),
2097 };
2098 
2099 /* pad multiplexing for (fix-part) pcie2 device */
2100 static struct spear_muxreg pcie2_muxreg[] = {
2101 	{
2102 		.reg = PCIE_SATA_CFG,
2103 		.mask = PCIE_CFG_VAL(2),
2104 		.val = PCIE_CFG_VAL(2),
2105 	},
2106 };
2107 
2108 static struct spear_modemux pcie2_modemux[] = {
2109 	{
2110 		.muxregs = pcie2_muxreg,
2111 		.nmuxregs = ARRAY_SIZE(pcie2_muxreg),
2112 	},
2113 };
2114 
2115 static struct spear_pingroup pcie2_pingroup = {
2116 	.name = "pcie2_grp",
2117 	.modemuxs = pcie2_modemux,
2118 	.nmodemuxs = ARRAY_SIZE(pcie2_modemux),
2119 };
2120 
2121 static const char *const pcie_grps[] = { "pcie0_grp", "pcie1_grp", "pcie2_grp"
2122 };
2123 static struct spear_function pcie_function = {
2124 	.name = "pci_express",
2125 	.groups = pcie_grps,
2126 	.ngroups = ARRAY_SIZE(pcie_grps),
2127 };
2128 
2129 /* pad multiplexing for sata0 device */
2130 static struct spear_muxreg sata0_muxreg[] = {
2131 	{
2132 		.reg = PCIE_SATA_CFG,
2133 		.mask = SATA_CFG_VAL(0),
2134 		.val = SATA_CFG_VAL(0),
2135 	},
2136 };
2137 
2138 static struct spear_modemux sata0_modemux[] = {
2139 	{
2140 		.muxregs = sata0_muxreg,
2141 		.nmuxregs = ARRAY_SIZE(sata0_muxreg),
2142 	},
2143 };
2144 
2145 static struct spear_pingroup sata0_pingroup = {
2146 	.name = "sata0_grp",
2147 	.modemuxs = sata0_modemux,
2148 	.nmodemuxs = ARRAY_SIZE(sata0_modemux),
2149 };
2150 
2151 /* pad multiplexing for sata1 device */
2152 static struct spear_muxreg sata1_muxreg[] = {
2153 	{
2154 		.reg = PCIE_SATA_CFG,
2155 		.mask = SATA_CFG_VAL(1),
2156 		.val = SATA_CFG_VAL(1),
2157 	},
2158 };
2159 
2160 static struct spear_modemux sata1_modemux[] = {
2161 	{
2162 		.muxregs = sata1_muxreg,
2163 		.nmuxregs = ARRAY_SIZE(sata1_muxreg),
2164 	},
2165 };
2166 
2167 static struct spear_pingroup sata1_pingroup = {
2168 	.name = "sata1_grp",
2169 	.modemuxs = sata1_modemux,
2170 	.nmodemuxs = ARRAY_SIZE(sata1_modemux),
2171 };
2172 
2173 /* pad multiplexing for sata2 device */
2174 static struct spear_muxreg sata2_muxreg[] = {
2175 	{
2176 		.reg = PCIE_SATA_CFG,
2177 		.mask = SATA_CFG_VAL(2),
2178 		.val = SATA_CFG_VAL(2),
2179 	},
2180 };
2181 
2182 static struct spear_modemux sata2_modemux[] = {
2183 	{
2184 		.muxregs = sata2_muxreg,
2185 		.nmuxregs = ARRAY_SIZE(sata2_muxreg),
2186 	},
2187 };
2188 
2189 static struct spear_pingroup sata2_pingroup = {
2190 	.name = "sata2_grp",
2191 	.modemuxs = sata2_modemux,
2192 	.nmodemuxs = ARRAY_SIZE(sata2_modemux),
2193 };
2194 
2195 static const char *const sata_grps[] = { "sata0_grp", "sata1_grp", "sata2_grp"
2196 };
2197 static struct spear_function sata_function = {
2198 	.name = "sata",
2199 	.groups = sata_grps,
2200 	.ngroups = ARRAY_SIZE(sata_grps),
2201 };
2202 
2203 /* Pad multiplexing for ssp1_dis_kbd device */
2204 static const unsigned ssp1_dis_kbd_pins[] = { 203, 204, 205, 206 };
2205 static struct spear_muxreg ssp1_dis_kbd_muxreg[] = {
2206 	{
2207 		.reg = PAD_FUNCTION_EN_1,
2208 		.mask = PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL1_MASK |
2209 			PMX_KBD_COL0_MASK | PMX_NFIO8_15_MASK | PMX_NFCE1_MASK |
2210 			PMX_NFCE2_MASK,
2211 		.val = 0,
2212 	}, {
2213 		.reg = PAD_DIRECTION_SEL_1,
2214 		.mask = PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL1_MASK |
2215 			PMX_KBD_COL0_MASK | PMX_NFIO8_15_MASK | PMX_NFCE1_MASK |
2216 			PMX_NFCE2_MASK,
2217 		.val = PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL1_MASK |
2218 			PMX_KBD_COL0_MASK | PMX_NFIO8_15_MASK | PMX_NFCE1_MASK |
2219 			PMX_NFCE2_MASK,
2220 	},
2221 };
2222 
2223 static struct spear_modemux ssp1_dis_kbd_modemux[] = {
2224 	{
2225 		.muxregs = ssp1_dis_kbd_muxreg,
2226 		.nmuxregs = ARRAY_SIZE(ssp1_dis_kbd_muxreg),
2227 	},
2228 };
2229 
2230 static struct spear_pingroup ssp1_dis_kbd_pingroup = {
2231 	.name = "ssp1_dis_kbd_grp",
2232 	.pins = ssp1_dis_kbd_pins,
2233 	.npins = ARRAY_SIZE(ssp1_dis_kbd_pins),
2234 	.modemuxs = ssp1_dis_kbd_modemux,
2235 	.nmodemuxs = ARRAY_SIZE(ssp1_dis_kbd_modemux),
2236 };
2237 
2238 /* Pad multiplexing for ssp1_dis_sd device */
2239 static const unsigned ssp1_dis_sd_pins[] = { 224, 226, 227, 228 };
2240 static struct spear_muxreg ssp1_dis_sd_muxreg[] = {
2241 	{
2242 		.reg = PAD_FUNCTION_EN_2,
2243 		.mask = PMX_MCIADDR0ALE_MASK | PMX_MCIADDR2_MASK |
2244 			PMX_MCICECF_MASK | PMX_MCICEXD_MASK,
2245 		.val = 0,
2246 	}, {
2247 		.reg = PAD_DIRECTION_SEL_2,
2248 		.mask = PMX_MCIADDR0ALE_MASK | PMX_MCIADDR2_MASK |
2249 			PMX_MCICECF_MASK | PMX_MCICEXD_MASK,
2250 		.val = PMX_MCIADDR0ALE_MASK | PMX_MCIADDR2_MASK |
2251 			PMX_MCICECF_MASK | PMX_MCICEXD_MASK,
2252 	},
2253 };
2254 
2255 static struct spear_modemux ssp1_dis_sd_modemux[] = {
2256 	{
2257 		.muxregs = ssp1_dis_sd_muxreg,
2258 		.nmuxregs = ARRAY_SIZE(ssp1_dis_sd_muxreg),
2259 	},
2260 };
2261 
2262 static struct spear_pingroup ssp1_dis_sd_pingroup = {
2263 	.name = "ssp1_dis_sd_grp",
2264 	.pins = ssp1_dis_sd_pins,
2265 	.npins = ARRAY_SIZE(ssp1_dis_sd_pins),
2266 	.modemuxs = ssp1_dis_sd_modemux,
2267 	.nmodemuxs = ARRAY_SIZE(ssp1_dis_sd_modemux),
2268 };
2269 
2270 static const char *const ssp1_grps[] = { "ssp1_dis_kbd_grp",
2271 	"ssp1_dis_sd_grp" };
2272 static struct spear_function ssp1_function = {
2273 	.name = "ssp1",
2274 	.groups = ssp1_grps,
2275 	.ngroups = ARRAY_SIZE(ssp1_grps),
2276 };
2277 
2278 /* Pad multiplexing for gpt64 device */
2279 static const unsigned gpt64_pins[] = { 230, 231, 232, 245 };
2280 static struct spear_muxreg gpt64_muxreg[] = {
2281 	{
2282 		.reg = PAD_FUNCTION_EN_2,
2283 		.mask = PMX_MCICDCF1_MASK | PMX_MCICDCF2_MASK | PMX_MCICDXD_MASK
2284 			| PMX_MCILEDS_MASK,
2285 		.val = 0,
2286 	}, {
2287 		.reg = PAD_DIRECTION_SEL_2,
2288 		.mask = PMX_MCICDCF1_MASK | PMX_MCICDCF2_MASK | PMX_MCICDXD_MASK
2289 			| PMX_MCILEDS_MASK,
2290 		.val = PMX_MCICDCF1_MASK | PMX_MCICDCF2_MASK | PMX_MCICDXD_MASK
2291 			| PMX_MCILEDS_MASK,
2292 	},
2293 };
2294 
2295 static struct spear_modemux gpt64_modemux[] = {
2296 	{
2297 		.muxregs = gpt64_muxreg,
2298 		.nmuxregs = ARRAY_SIZE(gpt64_muxreg),
2299 	},
2300 };
2301 
2302 static struct spear_pingroup gpt64_pingroup = {
2303 	.name = "gpt64_grp",
2304 	.pins = gpt64_pins,
2305 	.npins = ARRAY_SIZE(gpt64_pins),
2306 	.modemuxs = gpt64_modemux,
2307 	.nmodemuxs = ARRAY_SIZE(gpt64_modemux),
2308 };
2309 
2310 static const char *const gpt64_grps[] = { "gpt64_grp" };
2311 static struct spear_function gpt64_function = {
2312 	.name = "gpt64",
2313 	.groups = gpt64_grps,
2314 	.ngroups = ARRAY_SIZE(gpt64_grps),
2315 };
2316 
2317 /* pingroups */
2318 static struct spear_pingroup *spear1310_pingroups[] = {
2319 	&i2c0_pingroup,
2320 	&ssp0_pingroup,
2321 	&i2s0_pingroup,
2322 	&i2s1_pingroup,
2323 	&clcd_pingroup,
2324 	&clcd_high_res_pingroup,
2325 	&arm_gpio_pingroup,
2326 	&smi_2_chips_pingroup,
2327 	&smi_4_chips_pingroup,
2328 	&gmii_pingroup,
2329 	&rgmii_pingroup,
2330 	&smii_0_1_2_pingroup,
2331 	&ras_mii_txclk_pingroup,
2332 	&nand_8bit_pingroup,
2333 	&nand_16bit_pingroup,
2334 	&nand_4_chips_pingroup,
2335 	&keyboard_6x6_pingroup,
2336 	&keyboard_rowcol6_8_pingroup,
2337 	&uart0_pingroup,
2338 	&uart0_modem_pingroup,
2339 	&gpt0_tmr0_pingroup,
2340 	&gpt0_tmr1_pingroup,
2341 	&gpt1_tmr0_pingroup,
2342 	&gpt1_tmr1_pingroup,
2343 	&sdhci_pingroup,
2344 	&cf_pingroup,
2345 	&xd_pingroup,
2346 	&touch_xy_pingroup,
2347 	&ssp0_cs0_pingroup,
2348 	&ssp0_cs1_2_pingroup,
2349 	&uart_1_dis_i2c_pingroup,
2350 	&uart_1_dis_sd_pingroup,
2351 	&uart_2_3_pingroup,
2352 	&uart_4_pingroup,
2353 	&uart_5_pingroup,
2354 	&rs485_0_1_tdm_0_1_pingroup,
2355 	&i2c_1_2_pingroup,
2356 	&i2c3_dis_smi_clcd_pingroup,
2357 	&i2c3_dis_sd_i2s0_pingroup,
2358 	&i2c_4_5_dis_smi_pingroup,
2359 	&i2c4_dis_sd_pingroup,
2360 	&i2c5_dis_sd_pingroup,
2361 	&i2c_6_7_dis_kbd_pingroup,
2362 	&i2c6_dis_sd_pingroup,
2363 	&i2c7_dis_sd_pingroup,
2364 	&can0_dis_nor_pingroup,
2365 	&can0_dis_sd_pingroup,
2366 	&can1_dis_sd_pingroup,
2367 	&can1_dis_kbd_pingroup,
2368 	&pci_pingroup,
2369 	&pcie0_pingroup,
2370 	&pcie1_pingroup,
2371 	&pcie2_pingroup,
2372 	&sata0_pingroup,
2373 	&sata1_pingroup,
2374 	&sata2_pingroup,
2375 	&ssp1_dis_kbd_pingroup,
2376 	&ssp1_dis_sd_pingroup,
2377 	&gpt64_pingroup,
2378 };
2379 
2380 /* functions */
2381 static struct spear_function *spear1310_functions[] = {
2382 	&i2c0_function,
2383 	&ssp0_function,
2384 	&i2s0_function,
2385 	&i2s1_function,
2386 	&clcd_function,
2387 	&arm_gpio_function,
2388 	&smi_function,
2389 	&gmii_function,
2390 	&rgmii_function,
2391 	&smii_0_1_2_function,
2392 	&ras_mii_txclk_function,
2393 	&nand_function,
2394 	&keyboard_function,
2395 	&uart0_function,
2396 	&gpt0_function,
2397 	&gpt1_function,
2398 	&sdhci_function,
2399 	&cf_function,
2400 	&xd_function,
2401 	&touch_xy_function,
2402 	&uart1_function,
2403 	&uart2_3_function,
2404 	&uart4_function,
2405 	&uart5_function,
2406 	&rs485_0_1_tdm_0_1_function,
2407 	&i2c_1_2_function,
2408 	&i2c3_unction,
2409 	&i2c_4_5_function,
2410 	&i2c_6_7_function,
2411 	&can0_function,
2412 	&can1_function,
2413 	&pci_function,
2414 	&pcie_function,
2415 	&sata_function,
2416 	&ssp1_function,
2417 	&gpt64_function,
2418 };
2419 
2420 static const unsigned pin18[] = { 18, };
2421 static const unsigned pin19[] = { 19, };
2422 static const unsigned pin20[] = { 20, };
2423 static const unsigned pin21[] = { 21, };
2424 static const unsigned pin22[] = { 22, };
2425 static const unsigned pin23[] = { 23, };
2426 static const unsigned pin54[] = { 54, };
2427 static const unsigned pin55[] = { 55, };
2428 static const unsigned pin56[] = { 56, };
2429 static const unsigned pin57[] = { 57, };
2430 static const unsigned pin58[] = { 58, };
2431 static const unsigned pin59[] = { 59, };
2432 static const unsigned pin60[] = { 60, };
2433 static const unsigned pin61[] = { 61, };
2434 static const unsigned pin62[] = { 62, };
2435 static const unsigned pin63[] = { 63, };
2436 static const unsigned pin143[] = { 143, };
2437 static const unsigned pin144[] = { 144, };
2438 static const unsigned pin145[] = { 145, };
2439 static const unsigned pin146[] = { 146, };
2440 static const unsigned pin147[] = { 147, };
2441 static const unsigned pin148[] = { 148, };
2442 static const unsigned pin149[] = { 149, };
2443 static const unsigned pin150[] = { 150, };
2444 static const unsigned pin151[] = { 151, };
2445 static const unsigned pin152[] = { 152, };
2446 static const unsigned pin205[] = { 205, };
2447 static const unsigned pin206[] = { 206, };
2448 static const unsigned pin211[] = { 211, };
2449 static const unsigned pin212[] = { 212, };
2450 static const unsigned pin213[] = { 213, };
2451 static const unsigned pin214[] = { 214, };
2452 static const unsigned pin215[] = { 215, };
2453 static const unsigned pin216[] = { 216, };
2454 static const unsigned pin217[] = { 217, };
2455 static const unsigned pin218[] = { 218, };
2456 static const unsigned pin219[] = { 219, };
2457 static const unsigned pin220[] = { 220, };
2458 static const unsigned pin221[] = { 221, };
2459 static const unsigned pin222[] = { 222, };
2460 static const unsigned pin223[] = { 223, };
2461 static const unsigned pin224[] = { 224, };
2462 static const unsigned pin225[] = { 225, };
2463 static const unsigned pin226[] = { 226, };
2464 static const unsigned pin227[] = { 227, };
2465 static const unsigned pin228[] = { 228, };
2466 static const unsigned pin229[] = { 229, };
2467 static const unsigned pin230[] = { 230, };
2468 static const unsigned pin231[] = { 231, };
2469 static const unsigned pin232[] = { 232, };
2470 static const unsigned pin233[] = { 233, };
2471 static const unsigned pin234[] = { 234, };
2472 static const unsigned pin235[] = { 235, };
2473 static const unsigned pin236[] = { 236, };
2474 static const unsigned pin237[] = { 237, };
2475 static const unsigned pin238[] = { 238, };
2476 static const unsigned pin239[] = { 239, };
2477 static const unsigned pin240[] = { 240, };
2478 static const unsigned pin241[] = { 241, };
2479 static const unsigned pin242[] = { 242, };
2480 static const unsigned pin243[] = { 243, };
2481 static const unsigned pin244[] = { 244, };
2482 static const unsigned pin245[] = { 245, };
2483 
2484 static const unsigned pin_grp0[] = { 173, 174, };
2485 static const unsigned pin_grp1[] = { 175, 185, 188, 197, 198, };
2486 static const unsigned pin_grp2[] = { 176, 177, 178, 179, 184, 186, 187, 189,
2487 	190, 191, 192, };
2488 static const unsigned pin_grp3[] = { 180, 181, 182, 183, 193, 194, 195, 196, };
2489 static const unsigned pin_grp4[] = { 199, 200, };
2490 static const unsigned pin_grp5[] = { 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2491 	75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, };
2492 static const unsigned pin_grp6[] = { 86, 87, 88, 89, 90, 91, 92, 93, };
2493 static const unsigned pin_grp7[] = { 98, 99, };
2494 static const unsigned pin_grp8[] = { 158, 159, 160, 161, 162, 163, 164, 165,
2495 	166, 167, 168, 169, 170, 171, 172, };
2496 
2497 /* Define muxreg arrays */
2498 DEFINE_2_MUXREG(i2c0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_I2C0_MASK, 0, 1);
2499 DEFINE_2_MUXREG(ssp0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_SSP0_MASK, 0, 1);
2500 DEFINE_2_MUXREG(ssp0_cs0_pins, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_SSP0_CS0_MASK, 0, 1);
2501 DEFINE_2_MUXREG(ssp0_cs1_2_pins, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_SSP0_CS1_2_MASK, 0, 1);
2502 DEFINE_2_MUXREG(i2s0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_I2S0_MASK, 0, 1);
2503 DEFINE_2_MUXREG(i2s1_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_I2S1_MASK, 0, 1);
2504 DEFINE_2_MUXREG(clcd_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_CLCD1_MASK, 0, 1);
2505 DEFINE_2_MUXREG(clcd_high_res_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_CLCD2_MASK, 0, 1);
2506 DEFINE_2_MUXREG(pin18, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO15_MASK, 0, 1);
2507 DEFINE_2_MUXREG(pin19, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO14_MASK, 0, 1);
2508 DEFINE_2_MUXREG(pin20, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO13_MASK, 0, 1);
2509 DEFINE_2_MUXREG(pin21, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO12_MASK, 0, 1);
2510 DEFINE_2_MUXREG(pin22, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO11_MASK, 0, 1);
2511 DEFINE_2_MUXREG(pin23, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO10_MASK, 0, 1);
2512 DEFINE_2_MUXREG(pin143, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO00_MASK, 0, 1);
2513 DEFINE_2_MUXREG(pin144, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO01_MASK, 0, 1);
2514 DEFINE_2_MUXREG(pin145, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO02_MASK, 0, 1);
2515 DEFINE_2_MUXREG(pin146, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO03_MASK, 0, 1);
2516 DEFINE_2_MUXREG(pin147, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO04_MASK, 0, 1);
2517 DEFINE_2_MUXREG(pin148, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO05_MASK, 0, 1);
2518 DEFINE_2_MUXREG(pin149, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO06_MASK, 0, 1);
2519 DEFINE_2_MUXREG(pin150, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO07_MASK, 0, 1);
2520 DEFINE_2_MUXREG(pin151, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO08_MASK, 0, 1);
2521 DEFINE_2_MUXREG(pin152, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO09_MASK, 0, 1);
2522 DEFINE_2_MUXREG(smi_2_chips_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_SMI_MASK, 0, 1);
2523 DEFINE_2_MUXREG(pin54, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_SMINCS3_MASK, 0, 1);
2524 DEFINE_2_MUXREG(pin55, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_SMINCS2_MASK, 0, 1);
2525 DEFINE_2_MUXREG(pin56, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NFRSTPWDWN3_MASK, 0, 1);
2526 DEFINE_2_MUXREG(pin57, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFRSTPWDWN2_MASK, 0, 1);
2527 DEFINE_2_MUXREG(pin58, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFRSTPWDWN1_MASK, 0, 1);
2528 DEFINE_2_MUXREG(pin59, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFRSTPWDWN0_MASK, 0, 1);
2529 DEFINE_2_MUXREG(pin60, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFWPRT3_MASK, 0, 1);
2530 DEFINE_2_MUXREG(pin61, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFCE3_MASK, 0, 1);
2531 DEFINE_2_MUXREG(pin62, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFAD25_MASK, 0, 1);
2532 DEFINE_2_MUXREG(pin63, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFAD24_MASK, 0, 1);
2533 DEFINE_2_MUXREG(pin_grp0, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_GMIICLK_MASK, 0, 1);
2534 DEFINE_2_MUXREG(pin_grp1, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK, 0, 1);
2535 DEFINE_2_MUXREG(pin_grp2, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_RXCLK_RDV_TXEN_D03_MASK, 0, 1);
2536 DEFINE_2_MUXREG(pin_grp3, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_GMIID47_MASK, 0, 1);
2537 DEFINE_2_MUXREG(pin_grp4, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_MDC_MDIO_MASK, 0, 1);
2538 DEFINE_2_MUXREG(pin_grp5, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFAD23_MASK, 0, 1);
2539 DEFINE_2_MUXREG(pin_grp6, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_MCI_DATA8_15_MASK, 0, 1);
2540 DEFINE_2_MUXREG(pin_grp7, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NFCE2_MASK, 0, 1);
2541 DEFINE_2_MUXREG(pin_grp8, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NAND8_MASK, 0, 1);
2542 DEFINE_2_MUXREG(nand_16bit_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NAND16BIT_1_MASK, 0, 1);
2543 DEFINE_2_MUXREG(pin205, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_COL1_MASK | PMX_NFCE1_MASK, 0, 1);
2544 DEFINE_2_MUXREG(pin206, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_COL0_MASK | PMX_NFCE2_MASK, 0, 1);
2545 DEFINE_2_MUXREG(pin211, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_ROW1_MASK | PMX_NFWPRT1_MASK, 0, 1);
2546 DEFINE_2_MUXREG(pin212, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_ROW0_MASK | PMX_NFWPRT2_MASK, 0, 1);
2547 DEFINE_2_MUXREG(pin213, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA0_MASK, 0, 1);
2548 DEFINE_2_MUXREG(pin214, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA1_MASK, 0, 1);
2549 DEFINE_2_MUXREG(pin215, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA2_MASK, 0, 1);
2550 DEFINE_2_MUXREG(pin216, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA3_MASK, 0, 1);
2551 DEFINE_2_MUXREG(pin217, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA4_MASK, 0, 1);
2552 DEFINE_2_MUXREG(pin218, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA5_MASK, 0, 1);
2553 DEFINE_2_MUXREG(pin219, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA6_MASK, 0, 1);
2554 DEFINE_2_MUXREG(pin220, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA7_MASK, 0, 1);
2555 DEFINE_2_MUXREG(pin221, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA1SD_MASK, 0, 1);
2556 DEFINE_2_MUXREG(pin222, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA2SD_MASK, 0, 1);
2557 DEFINE_2_MUXREG(pin223, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA3SD_MASK, 0, 1);
2558 DEFINE_2_MUXREG(pin224, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIADDR0ALE_MASK, 0, 1);
2559 DEFINE_2_MUXREG(pin225, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIADDR1CLECLK_MASK, 0, 1);
2560 DEFINE_2_MUXREG(pin226, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIADDR2_MASK, 0, 1);
2561 DEFINE_2_MUXREG(pin227, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICECF_MASK, 0, 1);
2562 DEFINE_2_MUXREG(pin228, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICEXD_MASK, 0, 1);
2563 DEFINE_2_MUXREG(pin229, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICESDMMC_MASK, 0, 1);
2564 DEFINE_2_MUXREG(pin230, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDCF1_MASK, 0, 1);
2565 DEFINE_2_MUXREG(pin231, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDCF2_MASK, 0, 1);
2566 DEFINE_2_MUXREG(pin232, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDXD_MASK, 0, 1);
2567 DEFINE_2_MUXREG(pin233, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDSDMMC_MASK, 0, 1);
2568 DEFINE_2_MUXREG(pin234, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATADIR_MASK, 0, 1);
2569 DEFINE_2_MUXREG(pin235, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDMARQWP_MASK, 0, 1);
2570 DEFINE_2_MUXREG(pin236, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIIORDRE_MASK, 0, 1);
2571 DEFINE_2_MUXREG(pin237, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIIOWRWE_MASK, 0, 1);
2572 DEFINE_2_MUXREG(pin238, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIRESETCF_MASK, 0, 1);
2573 DEFINE_2_MUXREG(pin239, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICS0CE_MASK, 0, 1);
2574 DEFINE_2_MUXREG(pin240, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICFINTR_MASK, 0, 1);
2575 DEFINE_2_MUXREG(pin241, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIIORDY_MASK, 0, 1);
2576 DEFINE_2_MUXREG(pin242, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICS1_MASK, 0, 1);
2577 DEFINE_2_MUXREG(pin243, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDMAACK_MASK, 0, 1);
2578 DEFINE_2_MUXREG(pin244, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCISDCMD_MASK, 0, 1);
2579 DEFINE_2_MUXREG(pin245, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCILEDS_MASK, 0, 1);
2580 DEFINE_2_MUXREG(keyboard_rowcol6_8_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_ROWCOL68_MASK, 0, 1);
2581 DEFINE_2_MUXREG(uart0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_UART0_MASK, 0, 1);
2582 DEFINE_2_MUXREG(uart0_modem_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_UART0_MODEM_MASK, 0, 1);
2583 DEFINE_2_MUXREG(gpt0_tmr0_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT0_TMR0_MASK, 0, 1);
2584 DEFINE_2_MUXREG(gpt0_tmr1_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT0_TMR1_MASK, 0, 1);
2585 DEFINE_2_MUXREG(gpt1_tmr0_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT1_TMR0_MASK, 0, 1);
2586 DEFINE_2_MUXREG(gpt1_tmr1_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT1_TMR1_MASK, 0, 1);
2587 DEFINE_2_MUXREG(touch_xy_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_TOUCH_XY_MASK, 0, 1);
2588 
2589 static struct spear_gpio_pingroup spear1310_gpio_pingroup[] = {
2590 	GPIO_PINGROUP(i2c0_pins),
2591 	GPIO_PINGROUP(ssp0_pins),
2592 	GPIO_PINGROUP(ssp0_cs0_pins),
2593 	GPIO_PINGROUP(ssp0_cs1_2_pins),
2594 	GPIO_PINGROUP(i2s0_pins),
2595 	GPIO_PINGROUP(i2s1_pins),
2596 	GPIO_PINGROUP(clcd_pins),
2597 	GPIO_PINGROUP(clcd_high_res_pins),
2598 	GPIO_PINGROUP(pin18),
2599 	GPIO_PINGROUP(pin19),
2600 	GPIO_PINGROUP(pin20),
2601 	GPIO_PINGROUP(pin21),
2602 	GPIO_PINGROUP(pin22),
2603 	GPIO_PINGROUP(pin23),
2604 	GPIO_PINGROUP(pin143),
2605 	GPIO_PINGROUP(pin144),
2606 	GPIO_PINGROUP(pin145),
2607 	GPIO_PINGROUP(pin146),
2608 	GPIO_PINGROUP(pin147),
2609 	GPIO_PINGROUP(pin148),
2610 	GPIO_PINGROUP(pin149),
2611 	GPIO_PINGROUP(pin150),
2612 	GPIO_PINGROUP(pin151),
2613 	GPIO_PINGROUP(pin152),
2614 	GPIO_PINGROUP(smi_2_chips_pins),
2615 	GPIO_PINGROUP(pin54),
2616 	GPIO_PINGROUP(pin55),
2617 	GPIO_PINGROUP(pin56),
2618 	GPIO_PINGROUP(pin57),
2619 	GPIO_PINGROUP(pin58),
2620 	GPIO_PINGROUP(pin59),
2621 	GPIO_PINGROUP(pin60),
2622 	GPIO_PINGROUP(pin61),
2623 	GPIO_PINGROUP(pin62),
2624 	GPIO_PINGROUP(pin63),
2625 	GPIO_PINGROUP(pin_grp0),
2626 	GPIO_PINGROUP(pin_grp1),
2627 	GPIO_PINGROUP(pin_grp2),
2628 	GPIO_PINGROUP(pin_grp3),
2629 	GPIO_PINGROUP(pin_grp4),
2630 	GPIO_PINGROUP(pin_grp5),
2631 	GPIO_PINGROUP(pin_grp6),
2632 	GPIO_PINGROUP(pin_grp7),
2633 	GPIO_PINGROUP(pin_grp8),
2634 	GPIO_PINGROUP(nand_16bit_pins),
2635 	GPIO_PINGROUP(pin205),
2636 	GPIO_PINGROUP(pin206),
2637 	GPIO_PINGROUP(pin211),
2638 	GPIO_PINGROUP(pin212),
2639 	GPIO_PINGROUP(pin213),
2640 	GPIO_PINGROUP(pin214),
2641 	GPIO_PINGROUP(pin215),
2642 	GPIO_PINGROUP(pin216),
2643 	GPIO_PINGROUP(pin217),
2644 	GPIO_PINGROUP(pin218),
2645 	GPIO_PINGROUP(pin219),
2646 	GPIO_PINGROUP(pin220),
2647 	GPIO_PINGROUP(pin221),
2648 	GPIO_PINGROUP(pin222),
2649 	GPIO_PINGROUP(pin223),
2650 	GPIO_PINGROUP(pin224),
2651 	GPIO_PINGROUP(pin225),
2652 	GPIO_PINGROUP(pin226),
2653 	GPIO_PINGROUP(pin227),
2654 	GPIO_PINGROUP(pin228),
2655 	GPIO_PINGROUP(pin229),
2656 	GPIO_PINGROUP(pin230),
2657 	GPIO_PINGROUP(pin231),
2658 	GPIO_PINGROUP(pin232),
2659 	GPIO_PINGROUP(pin233),
2660 	GPIO_PINGROUP(pin234),
2661 	GPIO_PINGROUP(pin235),
2662 	GPIO_PINGROUP(pin236),
2663 	GPIO_PINGROUP(pin237),
2664 	GPIO_PINGROUP(pin238),
2665 	GPIO_PINGROUP(pin239),
2666 	GPIO_PINGROUP(pin240),
2667 	GPIO_PINGROUP(pin241),
2668 	GPIO_PINGROUP(pin242),
2669 	GPIO_PINGROUP(pin243),
2670 	GPIO_PINGROUP(pin244),
2671 	GPIO_PINGROUP(pin245),
2672 	GPIO_PINGROUP(keyboard_rowcol6_8_pins),
2673 	GPIO_PINGROUP(uart0_pins),
2674 	GPIO_PINGROUP(uart0_modem_pins),
2675 	GPIO_PINGROUP(gpt0_tmr0_pins),
2676 	GPIO_PINGROUP(gpt0_tmr1_pins),
2677 	GPIO_PINGROUP(gpt1_tmr0_pins),
2678 	GPIO_PINGROUP(gpt1_tmr1_pins),
2679 	GPIO_PINGROUP(touch_xy_pins),
2680 };
2681 
2682 static struct spear_pinctrl_machdata spear1310_machdata = {
2683 	.pins = spear1310_pins,
2684 	.npins = ARRAY_SIZE(spear1310_pins),
2685 	.groups = spear1310_pingroups,
2686 	.ngroups = ARRAY_SIZE(spear1310_pingroups),
2687 	.functions = spear1310_functions,
2688 	.nfunctions = ARRAY_SIZE(spear1310_functions),
2689 	.gpio_pingroups = spear1310_gpio_pingroup,
2690 	.ngpio_pingroups = ARRAY_SIZE(spear1310_gpio_pingroup),
2691 	.modes_supported = false,
2692 };
2693 
2694 static const struct of_device_id spear1310_pinctrl_of_match[] = {
2695 	{
2696 		.compatible = "st,spear1310-pinmux",
2697 	},
2698 	{},
2699 };
2700 
spear1310_pinctrl_probe(struct platform_device * pdev)2701 static int spear1310_pinctrl_probe(struct platform_device *pdev)
2702 {
2703 	return spear_pinctrl_probe(pdev, &spear1310_machdata);
2704 }
2705 
2706 static struct platform_driver spear1310_pinctrl_driver = {
2707 	.driver = {
2708 		.name = DRIVER_NAME,
2709 		.of_match_table = spear1310_pinctrl_of_match,
2710 	},
2711 	.probe = spear1310_pinctrl_probe,
2712 };
2713 
spear1310_pinctrl_init(void)2714 static int __init spear1310_pinctrl_init(void)
2715 {
2716 	return platform_driver_register(&spear1310_pinctrl_driver);
2717 }
2718 arch_initcall(spear1310_pinctrl_init);
2719