?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm/slab: sanity-check page type when looking up cache
[linux/fpc-iii.git] / drivers / pinctrl / pinctrl-xway.c
blob376222d0e5c570eb30e3468d30c7759c9a954ee7
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * linux/drivers/pinctrl/pinmux-xway.c
4 * based on linux/drivers/pinctrl/pinmux-pxa910.c
5 *
6 * Copyright (C) 2012 John Crispin <john@phrozen.org>
7 * Copyright (C) 2015 Martin Schiller <mschiller@tdt.de>
8 */
9
10 #include <linux/err.h>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13 #include <linux/of_platform.h>
14 #include <linux/of_address.h>
15 #include <linux/of_gpio.h>
16 #include <linux/ioport.h>
17 #include <linux/io.h>
18 #include <linux/device.h>
19 #include <linux/platform_device.h>
20
21 #include "pinctrl-lantiq.h"
22
23 #include <lantiq_soc.h>
24
25 /* we have up to 4 banks of 16 bit each */
26 #define PINS 16
27 #define PORT3 3
28 #define PORT(x) (x / PINS)
29 #define PORT_PIN(x) (x % PINS)
30
31 /* we have 2 mux bits that can be set for each pin */
32 #define MUX_ALT0 0x1
33 #define MUX_ALT1 0x2
34
35 /*
36 * each bank has this offset apart from the 4th bank that is mixed into the
37 * other 3 ranges
38 */
39 #define REG_OFF 0x30
40
41 /* these are the offsets to our registers */
42 #define GPIO_BASE(p) (REG_OFF * PORT(p))
43 #define GPIO_OUT(p) GPIO_BASE(p)
44 #define GPIO_IN(p) (GPIO_BASE(p) + 0x04)
45 #define GPIO_DIR(p) (GPIO_BASE(p) + 0x08)
46 #define GPIO_ALT0(p) (GPIO_BASE(p) + 0x0C)
47 #define GPIO_ALT1(p) (GPIO_BASE(p) + 0x10)
48 #define GPIO_OD(p) (GPIO_BASE(p) + 0x14)
49 #define GPIO_PUDSEL(p) (GPIO_BASE(p) + 0x1c)
50 #define GPIO_PUDEN(p) (GPIO_BASE(p) + 0x20)
51
52 /* the 4th port needs special offsets for some registers */
53 #define GPIO3_OD (GPIO_BASE(0) + 0x24)
54 #define GPIO3_PUDSEL (GPIO_BASE(0) + 0x28)
55 #define GPIO3_PUDEN (GPIO_BASE(0) + 0x2C)
56 #define GPIO3_ALT1 (GPIO_BASE(PINS) + 0x24)
57
58 /* macros to help us access the registers */
59 #define gpio_getbit(m, r, p) (!!(ltq_r32(m + r) & BIT(p)))
60 #define gpio_setbit(m, r, p) ltq_w32_mask(0, BIT(p), m + r)
61 #define gpio_clearbit(m, r, p) ltq_w32_mask(BIT(p), 0, m + r)
62
63 #define MFP_XWAY(a, f0, f1, f2, f3) \
64 { \
65 .name = #a, \
66 .pin = a, \
67 .func = { \
68 XWAY_MUX_##f0, \
69 XWAY_MUX_##f1, \
70 XWAY_MUX_##f2, \
71 XWAY_MUX_##f3, \
72 }, \
73 }
74
75 #define GRP_MUX(a, m, p) \
76 { .name = a, .mux = XWAY_MUX_##m, .pins = p, .npins = ARRAY_SIZE(p), }
77
78 #define FUNC_MUX(f, m) \
79 { .func = f, .mux = XWAY_MUX_##m, }
80
81 enum xway_mux {
82 XWAY_MUX_GPIO = 0,
83 XWAY_MUX_SPI,
84 XWAY_MUX_ASC,
85 XWAY_MUX_USIF,
86 XWAY_MUX_PCI,
87 XWAY_MUX_CBUS,
88 XWAY_MUX_CGU,
89 XWAY_MUX_EBU,
90 XWAY_MUX_EBU2,
91 XWAY_MUX_JTAG,
92 XWAY_MUX_MCD,
93 XWAY_MUX_EXIN,
94 XWAY_MUX_TDM,
95 XWAY_MUX_STP,
96 XWAY_MUX_SIN,
97 XWAY_MUX_GPT,
98 XWAY_MUX_NMI,
99 XWAY_MUX_MDIO,
100 XWAY_MUX_MII,
101 XWAY_MUX_EPHY,
102 XWAY_MUX_DFE,
103 XWAY_MUX_SDIO,
104 XWAY_MUX_GPHY,
105 XWAY_MUX_SSI,
106 XWAY_MUX_WIFI,
107 XWAY_MUX_NONE = 0xffff,
108 };
109
110 /* --------- DEPRECATED: xr9 related code --------- */
111 /* ---------- use xrx100/xrx200 instead ---------- */
112 #define XR9_MAX_PIN 56
113
114 static const struct ltq_mfp_pin xway_mfp[] = {
115 /* pin f0 f1 f2 f3 */
116 MFP_XWAY(GPIO0, GPIO, EXIN, NONE, TDM),
117 MFP_XWAY(GPIO1, GPIO, EXIN, NONE, NONE),
118 MFP_XWAY(GPIO2, GPIO, CGU, EXIN, GPHY),
119 MFP_XWAY(GPIO3, GPIO, CGU, NONE, PCI),
120 MFP_XWAY(GPIO4, GPIO, STP, NONE, ASC),
121 MFP_XWAY(GPIO5, GPIO, STP, GPHY, NONE),
122 MFP_XWAY(GPIO6, GPIO, STP, GPT, ASC),
123 MFP_XWAY(GPIO7, GPIO, CGU, PCI, GPHY),
124 MFP_XWAY(GPIO8, GPIO, CGU, NMI, NONE),
125 MFP_XWAY(GPIO9, GPIO, ASC, SPI, EXIN),
126 MFP_XWAY(GPIO10, GPIO, ASC, SPI, NONE),
127 MFP_XWAY(GPIO11, GPIO, ASC, PCI, SPI),
128 MFP_XWAY(GPIO12, GPIO, ASC, NONE, NONE),
129 MFP_XWAY(GPIO13, GPIO, EBU, SPI, NONE),
130 MFP_XWAY(GPIO14, GPIO, CGU, PCI, NONE),
131 MFP_XWAY(GPIO15, GPIO, SPI, JTAG, NONE),
132 MFP_XWAY(GPIO16, GPIO, SPI, NONE, JTAG),
133 MFP_XWAY(GPIO17, GPIO, SPI, NONE, JTAG),
134 MFP_XWAY(GPIO18, GPIO, SPI, NONE, JTAG),
135 MFP_XWAY(GPIO19, GPIO, PCI, NONE, NONE),
136 MFP_XWAY(GPIO20, GPIO, JTAG, NONE, NONE),
137 MFP_XWAY(GPIO21, GPIO, PCI, EBU, GPT),
138 MFP_XWAY(GPIO22, GPIO, SPI, NONE, NONE),
139 MFP_XWAY(GPIO23, GPIO, EBU, PCI, STP),
140 MFP_XWAY(GPIO24, GPIO, EBU, TDM, PCI),
141 MFP_XWAY(GPIO25, GPIO, TDM, NONE, ASC),
142 MFP_XWAY(GPIO26, GPIO, EBU, NONE, TDM),
143 MFP_XWAY(GPIO27, GPIO, TDM, NONE, ASC),
144 MFP_XWAY(GPIO28, GPIO, GPT, NONE, NONE),
145 MFP_XWAY(GPIO29, GPIO, PCI, NONE, NONE),
146 MFP_XWAY(GPIO30, GPIO, PCI, NONE, NONE),
147 MFP_XWAY(GPIO31, GPIO, EBU, PCI, NONE),
148 MFP_XWAY(GPIO32, GPIO, NONE, NONE, EBU),
149 MFP_XWAY(GPIO33, GPIO, NONE, NONE, EBU),
150 MFP_XWAY(GPIO34, GPIO, NONE, NONE, EBU),
151 MFP_XWAY(GPIO35, GPIO, NONE, NONE, EBU),
152 MFP_XWAY(GPIO36, GPIO, SIN, NONE, EBU),
153 MFP_XWAY(GPIO37, GPIO, PCI, NONE, NONE),
154 MFP_XWAY(GPIO38, GPIO, PCI, NONE, NONE),
155 MFP_XWAY(GPIO39, GPIO, EXIN, NONE, NONE),
156 MFP_XWAY(GPIO40, GPIO, NONE, NONE, NONE),
157 MFP_XWAY(GPIO41, GPIO, NONE, NONE, NONE),
158 MFP_XWAY(GPIO42, GPIO, MDIO, NONE, NONE),
159 MFP_XWAY(GPIO43, GPIO, MDIO, NONE, NONE),
160 MFP_XWAY(GPIO44, GPIO, MII, SIN, GPHY),
161 MFP_XWAY(GPIO45, GPIO, NONE, GPHY, SIN),
162 MFP_XWAY(GPIO46, GPIO, NONE, NONE, EXIN),
163 MFP_XWAY(GPIO47, GPIO, MII, GPHY, SIN),
164 MFP_XWAY(GPIO48, GPIO, EBU, NONE, NONE),
165 MFP_XWAY(GPIO49, GPIO, EBU, NONE, NONE),
166 MFP_XWAY(GPIO50, GPIO, NONE, NONE, NONE),
167 MFP_XWAY(GPIO51, GPIO, NONE, NONE, NONE),
168 MFP_XWAY(GPIO52, GPIO, NONE, NONE, NONE),
169 MFP_XWAY(GPIO53, GPIO, NONE, NONE, NONE),
170 MFP_XWAY(GPIO54, GPIO, NONE, NONE, NONE),
171 MFP_XWAY(GPIO55, GPIO, NONE, NONE, NONE),
172 };
173
174 static const unsigned pins_jtag[] = {GPIO15, GPIO16, GPIO17, GPIO19, GPIO35};
175 static const unsigned pins_asc0[] = {GPIO11, GPIO12};
176 static const unsigned pins_asc0_cts_rts[] = {GPIO9, GPIO10};
177 static const unsigned pins_stp[] = {GPIO4, GPIO5, GPIO6};
178 static const unsigned pins_nmi[] = {GPIO8};
179 static const unsigned pins_mdio[] = {GPIO42, GPIO43};
180
181 static const unsigned pins_gphy0_led0[] = {GPIO5};
182 static const unsigned pins_gphy0_led1[] = {GPIO7};
183 static const unsigned pins_gphy0_led2[] = {GPIO2};
184 static const unsigned pins_gphy1_led0[] = {GPIO44};
185 static const unsigned pins_gphy1_led1[] = {GPIO45};
186 static const unsigned pins_gphy1_led2[] = {GPIO47};
187
188 static const unsigned pins_ebu_a24[] = {GPIO13};
189 static const unsigned pins_ebu_clk[] = {GPIO21};
190 static const unsigned pins_ebu_cs1[] = {GPIO23};
191 static const unsigned pins_ebu_a23[] = {GPIO24};
192 static const unsigned pins_ebu_wait[] = {GPIO26};
193 static const unsigned pins_ebu_a25[] = {GPIO31};
194 static const unsigned pins_ebu_rdy[] = {GPIO48};
195 static const unsigned pins_ebu_rd[] = {GPIO49};
196
197 static const unsigned pins_nand_ale[] = {GPIO13};
198 static const unsigned pins_nand_cs1[] = {GPIO23};
199 static const unsigned pins_nand_cle[] = {GPIO24};
200 static const unsigned pins_nand_rdy[] = {GPIO48};
201 static const unsigned pins_nand_rd[] = {GPIO49};
202
203 static const unsigned xway_exin_pin_map[] = {GPIO0, GPIO1, GPIO2, GPIO39, GPIO46, GPIO9};
204
205 static const unsigned pins_exin0[] = {GPIO0};
206 static const unsigned pins_exin1[] = {GPIO1};
207 static const unsigned pins_exin2[] = {GPIO2};
208 static const unsigned pins_exin3[] = {GPIO39};
209 static const unsigned pins_exin4[] = {GPIO46};
210 static const unsigned pins_exin5[] = {GPIO9};
211
212 static const unsigned pins_spi[] = {GPIO16, GPIO17, GPIO18};
213 static const unsigned pins_spi_cs1[] = {GPIO15};
214 static const unsigned pins_spi_cs2[] = {GPIO22};
215 static const unsigned pins_spi_cs3[] = {GPIO13};
216 static const unsigned pins_spi_cs4[] = {GPIO10};
217 static const unsigned pins_spi_cs5[] = {GPIO9};
218 static const unsigned pins_spi_cs6[] = {GPIO11};
219
220 static const unsigned pins_gpt1[] = {GPIO28};
221 static const unsigned pins_gpt2[] = {GPIO21};
222 static const unsigned pins_gpt3[] = {GPIO6};
223
224 static const unsigned pins_clkout0[] = {GPIO8};
225 static const unsigned pins_clkout1[] = {GPIO7};
226 static const unsigned pins_clkout2[] = {GPIO3};
227 static const unsigned pins_clkout3[] = {GPIO2};
228
229 static const unsigned pins_pci_gnt1[] = {GPIO30};
230 static const unsigned pins_pci_gnt2[] = {GPIO23};
231 static const unsigned pins_pci_gnt3[] = {GPIO19};
232 static const unsigned pins_pci_gnt4[] = {GPIO38};
233 static const unsigned pins_pci_req1[] = {GPIO29};
234 static const unsigned pins_pci_req2[] = {GPIO31};
235 static const unsigned pins_pci_req3[] = {GPIO3};
236 static const unsigned pins_pci_req4[] = {GPIO37};
237
238 static const struct ltq_pin_group xway_grps[] = {
239 GRP_MUX("exin0", EXIN, pins_exin0),
240 GRP_MUX("exin1", EXIN, pins_exin1),
241 GRP_MUX("exin2", EXIN, pins_exin2),
242 GRP_MUX("jtag", JTAG, pins_jtag),
243 GRP_MUX("ebu a23", EBU, pins_ebu_a23),
244 GRP_MUX("ebu a24", EBU, pins_ebu_a24),
245 GRP_MUX("ebu a25", EBU, pins_ebu_a25),
246 GRP_MUX("ebu clk", EBU, pins_ebu_clk),
247 GRP_MUX("ebu cs1", EBU, pins_ebu_cs1),
248 GRP_MUX("ebu wait", EBU, pins_ebu_wait),
249 GRP_MUX("nand ale", EBU, pins_nand_ale),
250 GRP_MUX("nand cs1", EBU, pins_nand_cs1),
251 GRP_MUX("nand cle", EBU, pins_nand_cle),
252 GRP_MUX("spi", SPI, pins_spi),
253 GRP_MUX("spi_cs1", SPI, pins_spi_cs1),
254 GRP_MUX("spi_cs2", SPI, pins_spi_cs2),
255 GRP_MUX("spi_cs3", SPI, pins_spi_cs3),
256 GRP_MUX("spi_cs4", SPI, pins_spi_cs4),
257 GRP_MUX("spi_cs5", SPI, pins_spi_cs5),
258 GRP_MUX("spi_cs6", SPI, pins_spi_cs6),
259 GRP_MUX("asc0", ASC, pins_asc0),
260 GRP_MUX("asc0 cts rts", ASC, pins_asc0_cts_rts),
261 GRP_MUX("stp", STP, pins_stp),
262 GRP_MUX("nmi", NMI, pins_nmi),
263 GRP_MUX("gpt1", GPT, pins_gpt1),
264 GRP_MUX("gpt2", GPT, pins_gpt2),
265 GRP_MUX("gpt3", GPT, pins_gpt3),
266 GRP_MUX("clkout0", CGU, pins_clkout0),
267 GRP_MUX("clkout1", CGU, pins_clkout1),
268 GRP_MUX("clkout2", CGU, pins_clkout2),
269 GRP_MUX("clkout3", CGU, pins_clkout3),
270 GRP_MUX("gnt1", PCI, pins_pci_gnt1),
271 GRP_MUX("gnt2", PCI, pins_pci_gnt2),
272 GRP_MUX("gnt3", PCI, pins_pci_gnt3),
273 GRP_MUX("req1", PCI, pins_pci_req1),
274 GRP_MUX("req2", PCI, pins_pci_req2),
275 GRP_MUX("req3", PCI, pins_pci_req3),
276 /* xrx only */
277 GRP_MUX("nand rdy", EBU, pins_nand_rdy),
278 GRP_MUX("nand rd", EBU, pins_nand_rd),
279 GRP_MUX("exin3", EXIN, pins_exin3),
280 GRP_MUX("exin4", EXIN, pins_exin4),
281 GRP_MUX("exin5", EXIN, pins_exin5),
282 GRP_MUX("gnt4", PCI, pins_pci_gnt4),
283 GRP_MUX("req4", PCI, pins_pci_gnt4),
284 GRP_MUX("mdio", MDIO, pins_mdio),
285 GRP_MUX("gphy0 led0", GPHY, pins_gphy0_led0),
286 GRP_MUX("gphy0 led1", GPHY, pins_gphy0_led1),
287 GRP_MUX("gphy0 led2", GPHY, pins_gphy0_led2),
288 GRP_MUX("gphy1 led0", GPHY, pins_gphy1_led0),
289 GRP_MUX("gphy1 led1", GPHY, pins_gphy1_led1),
290 GRP_MUX("gphy1 led2", GPHY, pins_gphy1_led2),
291 };
292
293 static const char * const xway_pci_grps[] = {"gnt1", "gnt2",
294 "gnt3", "req1",
295 "req2", "req3"};
296 static const char * const xway_spi_grps[] = {"spi", "spi_cs1",
297 "spi_cs2", "spi_cs3",
298 "spi_cs4", "spi_cs5",
299 "spi_cs6"};
300 static const char * const xway_cgu_grps[] = {"clkout0", "clkout1",
301 "clkout2", "clkout3"};
302 static const char * const xway_ebu_grps[] = {"ebu a23", "ebu a24",
303 "ebu a25", "ebu cs1",
304 "ebu wait", "ebu clk",
305 "nand ale", "nand cs1",
306 "nand cle"};
307 static const char * const xway_exin_grps[] = {"exin0", "exin1", "exin2"};
308 static const char * const xway_gpt_grps[] = {"gpt1", "gpt2", "gpt3"};
309 static const char * const xway_asc_grps[] = {"asc0", "asc0 cts rts"};
310 static const char * const xway_jtag_grps[] = {"jtag"};
311 static const char * const xway_stp_grps[] = {"stp"};
312 static const char * const xway_nmi_grps[] = {"nmi"};
313
314 /* ar9/vr9/gr9 */
315 static const char * const xrx_mdio_grps[] = {"mdio"};
316 static const char * const xrx_gphy_grps[] = {"gphy0 led0", "gphy0 led1",
317 "gphy0 led2", "gphy1 led0",
318 "gphy1 led1", "gphy1 led2"};
319 static const char * const xrx_ebu_grps[] = {"ebu a23", "ebu a24",
320 "ebu a25", "ebu cs1",
321 "ebu wait", "ebu clk",
322 "nand ale", "nand cs1",
323 "nand cle", "nand rdy",
324 "nand rd"};
325 static const char * const xrx_exin_grps[] = {"exin0", "exin1", "exin2",
326 "exin3", "exin4", "exin5"};
327 static const char * const xrx_pci_grps[] = {"gnt1", "gnt2",
328 "gnt3", "gnt4",
329 "req1", "req2",
330 "req3", "req4"};
331
332 static const struct ltq_pmx_func xrx_funcs[] = {
333 {"spi", ARRAY_AND_SIZE(xway_spi_grps)},
334 {"asc", ARRAY_AND_SIZE(xway_asc_grps)},
335 {"cgu", ARRAY_AND_SIZE(xway_cgu_grps)},
336 {"jtag", ARRAY_AND_SIZE(xway_jtag_grps)},
337 {"exin", ARRAY_AND_SIZE(xrx_exin_grps)},
338 {"stp", ARRAY_AND_SIZE(xway_stp_grps)},
339 {"gpt", ARRAY_AND_SIZE(xway_gpt_grps)},
340 {"nmi", ARRAY_AND_SIZE(xway_nmi_grps)},
341 {"pci", ARRAY_AND_SIZE(xrx_pci_grps)},
342 {"ebu", ARRAY_AND_SIZE(xrx_ebu_grps)},
343 {"mdio", ARRAY_AND_SIZE(xrx_mdio_grps)},
344 {"gphy", ARRAY_AND_SIZE(xrx_gphy_grps)},
345 };
346
347 /* --------- ase related code --------- */
348 #define ASE_MAX_PIN 32
349
350 static const struct ltq_mfp_pin ase_mfp[] = {
351 /* pin f0 f1 f2 f3 */
352 MFP_XWAY(GPIO0, GPIO, EXIN, MII, TDM),
353 MFP_XWAY(GPIO1, GPIO, STP, DFE, EBU),
354 MFP_XWAY(GPIO2, GPIO, STP, DFE, EPHY),
355 MFP_XWAY(GPIO3, GPIO, STP, EPHY, EBU),
356 MFP_XWAY(GPIO4, GPIO, GPT, EPHY, MII),
357 MFP_XWAY(GPIO5, GPIO, MII, ASC, GPT),
358 MFP_XWAY(GPIO6, GPIO, MII, ASC, EXIN),
359 MFP_XWAY(GPIO7, GPIO, SPI, MII, JTAG),
360 MFP_XWAY(GPIO8, GPIO, SPI, MII, JTAG),
361 MFP_XWAY(GPIO9, GPIO, SPI, MII, JTAG),
362 MFP_XWAY(GPIO10, GPIO, SPI, MII, JTAG),
363 MFP_XWAY(GPIO11, GPIO, EBU, CGU, JTAG),
364 MFP_XWAY(GPIO12, GPIO, EBU, MII, SDIO),
365 MFP_XWAY(GPIO13, GPIO, EBU, MII, CGU),
366 MFP_XWAY(GPIO14, GPIO, EBU, SPI, CGU),
367 MFP_XWAY(GPIO15, GPIO, EBU, SPI, SDIO),
368 MFP_XWAY(GPIO16, GPIO, NONE, NONE, NONE),
369 MFP_XWAY(GPIO17, GPIO, NONE, NONE, NONE),
370 MFP_XWAY(GPIO18, GPIO, NONE, NONE, NONE),
371 MFP_XWAY(GPIO19, GPIO, EBU, MII, SDIO),
372 MFP_XWAY(GPIO20, GPIO, EBU, MII, SDIO),
373 MFP_XWAY(GPIO21, GPIO, EBU, MII, EBU2),
374 MFP_XWAY(GPIO22, GPIO, EBU, MII, CGU),
375 MFP_XWAY(GPIO23, GPIO, EBU, MII, CGU),
376 MFP_XWAY(GPIO24, GPIO, EBU, EBU2, MDIO),
377 MFP_XWAY(GPIO25, GPIO, EBU, MII, GPT),
378 MFP_XWAY(GPIO26, GPIO, EBU, MII, SDIO),
379 MFP_XWAY(GPIO27, GPIO, EBU, NONE, MDIO),
380 MFP_XWAY(GPIO28, GPIO, MII, EBU, SDIO),
381 MFP_XWAY(GPIO29, GPIO, EBU, MII, EXIN),
382 MFP_XWAY(GPIO30, GPIO, NONE, NONE, NONE),
383 MFP_XWAY(GPIO31, GPIO, NONE, NONE, NONE),
384 };
385
386 static const unsigned ase_exin_pin_map[] = {GPIO6, GPIO29, GPIO0};
387
388 static const unsigned ase_pins_exin0[] = {GPIO6};
389 static const unsigned ase_pins_exin1[] = {GPIO29};
390 static const unsigned ase_pins_exin2[] = {GPIO0};
391
392 static const unsigned ase_pins_jtag[] = {GPIO7, GPIO8, GPIO9, GPIO10, GPIO11};
393 static const unsigned ase_pins_asc[] = {GPIO5, GPIO6};
394 static const unsigned ase_pins_stp[] = {GPIO1, GPIO2, GPIO3};
395 static const unsigned ase_pins_mdio[] = {GPIO24, GPIO27};
396 static const unsigned ase_pins_ephy_led0[] = {GPIO2};
397 static const unsigned ase_pins_ephy_led1[] = {GPIO3};
398 static const unsigned ase_pins_ephy_led2[] = {GPIO4};
399 static const unsigned ase_pins_dfe_led0[] = {GPIO1};
400 static const unsigned ase_pins_dfe_led1[] = {GPIO2};
401
402 static const unsigned ase_pins_spi[] = {GPIO8, GPIO9, GPIO10}; /* DEPRECATED */
403 static const unsigned ase_pins_spi_di[] = {GPIO8};
404 static const unsigned ase_pins_spi_do[] = {GPIO9};
405 static const unsigned ase_pins_spi_clk[] = {GPIO10};
406 static const unsigned ase_pins_spi_cs1[] = {GPIO7};
407 static const unsigned ase_pins_spi_cs2[] = {GPIO15};
408 static const unsigned ase_pins_spi_cs3[] = {GPIO14};
409
410 static const unsigned ase_pins_gpt1[] = {GPIO5};
411 static const unsigned ase_pins_gpt2[] = {GPIO4};
412 static const unsigned ase_pins_gpt3[] = {GPIO25};
413
414 static const unsigned ase_pins_clkout0[] = {GPIO23};
415 static const unsigned ase_pins_clkout1[] = {GPIO22};
416 static const unsigned ase_pins_clkout2[] = {GPIO14};
417
418 static const struct ltq_pin_group ase_grps[] = {
419 GRP_MUX("exin0", EXIN, ase_pins_exin0),
420 GRP_MUX("exin1", EXIN, ase_pins_exin1),
421 GRP_MUX("exin2", EXIN, ase_pins_exin2),
422 GRP_MUX("jtag", JTAG, ase_pins_jtag),
423 GRP_MUX("spi", SPI, ase_pins_spi), /* DEPRECATED */
424 GRP_MUX("spi_di", SPI, ase_pins_spi_di),
425 GRP_MUX("spi_do", SPI, ase_pins_spi_do),
426 GRP_MUX("spi_clk", SPI, ase_pins_spi_clk),
427 GRP_MUX("spi_cs1", SPI, ase_pins_spi_cs1),
428 GRP_MUX("spi_cs2", SPI, ase_pins_spi_cs2),
429 GRP_MUX("spi_cs3", SPI, ase_pins_spi_cs3),
430 GRP_MUX("asc", ASC, ase_pins_asc),
431 GRP_MUX("stp", STP, ase_pins_stp),
432 GRP_MUX("gpt1", GPT, ase_pins_gpt1),
433 GRP_MUX("gpt2", GPT, ase_pins_gpt2),
434 GRP_MUX("gpt3", GPT, ase_pins_gpt3),
435 GRP_MUX("clkout0", CGU, ase_pins_clkout0),
436 GRP_MUX("clkout1", CGU, ase_pins_clkout1),
437 GRP_MUX("clkout2", CGU, ase_pins_clkout2),
438 GRP_MUX("mdio", MDIO, ase_pins_mdio),
439 GRP_MUX("dfe led0", DFE, ase_pins_dfe_led0),
440 GRP_MUX("dfe led1", DFE, ase_pins_dfe_led1),
441 GRP_MUX("ephy led0", EPHY, ase_pins_ephy_led0),
442 GRP_MUX("ephy led1", EPHY, ase_pins_ephy_led1),
443 GRP_MUX("ephy led2", EPHY, ase_pins_ephy_led2),
444 };
445
446 static const char * const ase_exin_grps[] = {"exin0", "exin1", "exin2"};
447 static const char * const ase_gpt_grps[] = {"gpt1", "gpt2", "gpt3"};
448 static const char * const ase_cgu_grps[] = {"clkout0", "clkout1",
449 "clkout2"};
450 static const char * const ase_mdio_grps[] = {"mdio"};
451 static const char * const ase_dfe_grps[] = {"dfe led0", "dfe led1"};
452 static const char * const ase_ephy_grps[] = {"ephy led0", "ephy led1",
453 "ephy led2"};
454 static const char * const ase_asc_grps[] = {"asc"};
455 static const char * const ase_jtag_grps[] = {"jtag"};
456 static const char * const ase_stp_grps[] = {"stp"};
457 static const char * const ase_spi_grps[] = {"spi", /* DEPRECATED */
458 "spi_di", "spi_do",
459 "spi_clk", "spi_cs1",
460 "spi_cs2", "spi_cs3"};
461
462 static const struct ltq_pmx_func ase_funcs[] = {
463 {"spi", ARRAY_AND_SIZE(ase_spi_grps)},
464 {"asc", ARRAY_AND_SIZE(ase_asc_grps)},
465 {"cgu", ARRAY_AND_SIZE(ase_cgu_grps)},
466 {"jtag", ARRAY_AND_SIZE(ase_jtag_grps)},
467 {"exin", ARRAY_AND_SIZE(ase_exin_grps)},
468 {"stp", ARRAY_AND_SIZE(ase_stp_grps)},
469 {"gpt", ARRAY_AND_SIZE(ase_gpt_grps)},
470 {"mdio", ARRAY_AND_SIZE(ase_mdio_grps)},
471 {"ephy", ARRAY_AND_SIZE(ase_ephy_grps)},
472 {"dfe", ARRAY_AND_SIZE(ase_dfe_grps)},
473 };
474
475 /* --------- danube related code --------- */
476 #define DANUBE_MAX_PIN 32
477
478 static const struct ltq_mfp_pin danube_mfp[] = {
479 /* pin f0 f1 f2 f3 */
480 MFP_XWAY(GPIO0, GPIO, EXIN, SDIO, TDM),
481 MFP_XWAY(GPIO1, GPIO, EXIN, CBUS, MII),
482 MFP_XWAY(GPIO2, GPIO, CGU, EXIN, MII),
483 MFP_XWAY(GPIO3, GPIO, CGU, SDIO, PCI),
484 MFP_XWAY(GPIO4, GPIO, STP, DFE, ASC),
485 MFP_XWAY(GPIO5, GPIO, STP, MII, DFE),
486 MFP_XWAY(GPIO6, GPIO, STP, GPT, ASC),
487 MFP_XWAY(GPIO7, GPIO, CGU, CBUS, MII),
488 MFP_XWAY(GPIO8, GPIO, CGU, NMI, MII),
489 MFP_XWAY(GPIO9, GPIO, ASC, SPI, MII),
490 MFP_XWAY(GPIO10, GPIO, ASC, SPI, MII),
491 MFP_XWAY(GPIO11, GPIO, ASC, CBUS, SPI),
492 MFP_XWAY(GPIO12, GPIO, ASC, CBUS, MCD),
493 MFP_XWAY(GPIO13, GPIO, EBU, SPI, MII),
494 MFP_XWAY(GPIO14, GPIO, CGU, CBUS, MII),
495 MFP_XWAY(GPIO15, GPIO, SPI, SDIO, JTAG),
496 MFP_XWAY(GPIO16, GPIO, SPI, SDIO, JTAG),
497 MFP_XWAY(GPIO17, GPIO, SPI, SDIO, JTAG),
498 MFP_XWAY(GPIO18, GPIO, SPI, SDIO, JTAG),
499 MFP_XWAY(GPIO19, GPIO, PCI, SDIO, MII),
500 MFP_XWAY(GPIO20, GPIO, JTAG, SDIO, MII),
501 MFP_XWAY(GPIO21, GPIO, PCI, EBU, GPT),
502 MFP_XWAY(GPIO22, GPIO, SPI, MCD, MII),
503 MFP_XWAY(GPIO23, GPIO, EBU, PCI, STP),
504 MFP_XWAY(GPIO24, GPIO, EBU, TDM, PCI),
505 MFP_XWAY(GPIO25, GPIO, TDM, SDIO, ASC),
506 MFP_XWAY(GPIO26, GPIO, EBU, TDM, SDIO),
507 MFP_XWAY(GPIO27, GPIO, TDM, SDIO, ASC),
508 MFP_XWAY(GPIO28, GPIO, GPT, MII, SDIO),
509 MFP_XWAY(GPIO29, GPIO, PCI, CBUS, MII),
510 MFP_XWAY(GPIO30, GPIO, PCI, CBUS, MII),
511 MFP_XWAY(GPIO31, GPIO, EBU, PCI, MII),
512 };
513
514 static const unsigned danube_exin_pin_map[] = {GPIO0, GPIO1, GPIO2};
515
516 static const unsigned danube_pins_exin0[] = {GPIO0};
517 static const unsigned danube_pins_exin1[] = {GPIO1};
518 static const unsigned danube_pins_exin2[] = {GPIO2};
519
520 static const unsigned danube_pins_jtag[] = {GPIO15, GPIO16, GPIO17, GPIO18, GPIO20};
521 static const unsigned danube_pins_asc0[] = {GPIO11, GPIO12};
522 static const unsigned danube_pins_asc0_cts_rts[] = {GPIO9, GPIO10};
523 static const unsigned danube_pins_stp[] = {GPIO4, GPIO5, GPIO6};
524 static const unsigned danube_pins_nmi[] = {GPIO8};
525
526 static const unsigned danube_pins_dfe_led0[] = {GPIO4};
527 static const unsigned danube_pins_dfe_led1[] = {GPIO5};
528
529 static const unsigned danube_pins_ebu_a24[] = {GPIO13};
530 static const unsigned danube_pins_ebu_clk[] = {GPIO21};
531 static const unsigned danube_pins_ebu_cs1[] = {GPIO23};
532 static const unsigned danube_pins_ebu_a23[] = {GPIO24};
533 static const unsigned danube_pins_ebu_wait[] = {GPIO26};
534 static const unsigned danube_pins_ebu_a25[] = {GPIO31};
535
536 static const unsigned danube_pins_nand_ale[] = {GPIO13};
537 static const unsigned danube_pins_nand_cs1[] = {GPIO23};
538 static const unsigned danube_pins_nand_cle[] = {GPIO24};
539
540 static const unsigned danube_pins_spi[] = {GPIO16, GPIO17, GPIO18}; /* DEPRECATED */
541 static const unsigned danube_pins_spi_di[] = {GPIO16};
542 static const unsigned danube_pins_spi_do[] = {GPIO17};
543 static const unsigned danube_pins_spi_clk[] = {GPIO18};
544 static const unsigned danube_pins_spi_cs1[] = {GPIO15};
545 static const unsigned danube_pins_spi_cs2[] = {GPIO21};
546 static const unsigned danube_pins_spi_cs3[] = {GPIO13};
547 static const unsigned danube_pins_spi_cs4[] = {GPIO10};
548 static const unsigned danube_pins_spi_cs5[] = {GPIO9};
549 static const unsigned danube_pins_spi_cs6[] = {GPIO11};
550
551 static const unsigned danube_pins_gpt1[] = {GPIO28};
552 static const unsigned danube_pins_gpt2[] = {GPIO21};
553 static const unsigned danube_pins_gpt3[] = {GPIO6};
554
555 static const unsigned danube_pins_clkout0[] = {GPIO8};
556 static const unsigned danube_pins_clkout1[] = {GPIO7};
557 static const unsigned danube_pins_clkout2[] = {GPIO3};
558 static const unsigned danube_pins_clkout3[] = {GPIO2};
559
560 static const unsigned danube_pins_pci_gnt1[] = {GPIO30};
561 static const unsigned danube_pins_pci_gnt2[] = {GPIO23};
562 static const unsigned danube_pins_pci_gnt3[] = {GPIO19};
563 static const unsigned danube_pins_pci_req1[] = {GPIO29};
564 static const unsigned danube_pins_pci_req2[] = {GPIO31};
565 static const unsigned danube_pins_pci_req3[] = {GPIO3};
566
567 static const struct ltq_pin_group danube_grps[] = {
568 GRP_MUX("exin0", EXIN, danube_pins_exin0),
569 GRP_MUX("exin1", EXIN, danube_pins_exin1),
570 GRP_MUX("exin2", EXIN, danube_pins_exin2),
571 GRP_MUX("jtag", JTAG, danube_pins_jtag),
572 GRP_MUX("ebu a23", EBU, danube_pins_ebu_a23),
573 GRP_MUX("ebu a24", EBU, danube_pins_ebu_a24),
574 GRP_MUX("ebu a25", EBU, danube_pins_ebu_a25),
575 GRP_MUX("ebu clk", EBU, danube_pins_ebu_clk),
576 GRP_MUX("ebu cs1", EBU, danube_pins_ebu_cs1),
577 GRP_MUX("ebu wait", EBU, danube_pins_ebu_wait),
578 GRP_MUX("nand ale", EBU, danube_pins_nand_ale),
579 GRP_MUX("nand cs1", EBU, danube_pins_nand_cs1),
580 GRP_MUX("nand cle", EBU, danube_pins_nand_cle),
581 GRP_MUX("spi", SPI, danube_pins_spi), /* DEPRECATED */
582 GRP_MUX("spi_di", SPI, danube_pins_spi_di),
583 GRP_MUX("spi_do", SPI, danube_pins_spi_do),
584 GRP_MUX("spi_clk", SPI, danube_pins_spi_clk),
585 GRP_MUX("spi_cs1", SPI, danube_pins_spi_cs1),
586 GRP_MUX("spi_cs2", SPI, danube_pins_spi_cs2),
587 GRP_MUX("spi_cs3", SPI, danube_pins_spi_cs3),
588 GRP_MUX("spi_cs4", SPI, danube_pins_spi_cs4),
589 GRP_MUX("spi_cs5", SPI, danube_pins_spi_cs5),
590 GRP_MUX("spi_cs6", SPI, danube_pins_spi_cs6),
591 GRP_MUX("asc0", ASC, danube_pins_asc0),
592 GRP_MUX("asc0 cts rts", ASC, danube_pins_asc0_cts_rts),
593 GRP_MUX("stp", STP, danube_pins_stp),
594 GRP_MUX("nmi", NMI, danube_pins_nmi),
595 GRP_MUX("gpt1", GPT, danube_pins_gpt1),
596 GRP_MUX("gpt2", GPT, danube_pins_gpt2),
597 GRP_MUX("gpt3", GPT, danube_pins_gpt3),
598 GRP_MUX("clkout0", CGU, danube_pins_clkout0),
599 GRP_MUX("clkout1", CGU, danube_pins_clkout1),
600 GRP_MUX("clkout2", CGU, danube_pins_clkout2),
601 GRP_MUX("clkout3", CGU, danube_pins_clkout3),
602 GRP_MUX("gnt1", PCI, danube_pins_pci_gnt1),
603 GRP_MUX("gnt2", PCI, danube_pins_pci_gnt2),
604 GRP_MUX("gnt3", PCI, danube_pins_pci_gnt3),
605 GRP_MUX("req1", PCI, danube_pins_pci_req1),
606 GRP_MUX("req2", PCI, danube_pins_pci_req2),
607 GRP_MUX("req3", PCI, danube_pins_pci_req3),
608 GRP_MUX("dfe led0", DFE, danube_pins_dfe_led0),
609 GRP_MUX("dfe led1", DFE, danube_pins_dfe_led1),
610 };
611
612 static const char * const danube_pci_grps[] = {"gnt1", "gnt2",
613 "gnt3", "req1",
614 "req2", "req3"};
615 static const char * const danube_spi_grps[] = {"spi", /* DEPRECATED */
616 "spi_di", "spi_do",
617 "spi_clk", "spi_cs1",
618 "spi_cs2", "spi_cs3",
619 "spi_cs4", "spi_cs5",
620 "spi_cs6"};
621 static const char * const danube_cgu_grps[] = {"clkout0", "clkout1",
622 "clkout2", "clkout3"};
623 static const char * const danube_ebu_grps[] = {"ebu a23", "ebu a24",
624 "ebu a25", "ebu cs1",
625 "ebu wait", "ebu clk",
626 "nand ale", "nand cs1",
627 "nand cle"};
628 static const char * const danube_dfe_grps[] = {"dfe led0", "dfe led1"};
629 static const char * const danube_exin_grps[] = {"exin0", "exin1", "exin2"};
630 static const char * const danube_gpt_grps[] = {"gpt1", "gpt2", "gpt3"};
631 static const char * const danube_asc_grps[] = {"asc0", "asc0 cts rts"};
632 static const char * const danube_jtag_grps[] = {"jtag"};
633 static const char * const danube_stp_grps[] = {"stp"};
634 static const char * const danube_nmi_grps[] = {"nmi"};
635
636 static const struct ltq_pmx_func danube_funcs[] = {
637 {"spi", ARRAY_AND_SIZE(danube_spi_grps)},
638 {"asc", ARRAY_AND_SIZE(danube_asc_grps)},
639 {"cgu", ARRAY_AND_SIZE(danube_cgu_grps)},
640 {"jtag", ARRAY_AND_SIZE(danube_jtag_grps)},
641 {"exin", ARRAY_AND_SIZE(danube_exin_grps)},
642 {"stp", ARRAY_AND_SIZE(danube_stp_grps)},
643 {"gpt", ARRAY_AND_SIZE(danube_gpt_grps)},
644 {"nmi", ARRAY_AND_SIZE(danube_nmi_grps)},
645 {"pci", ARRAY_AND_SIZE(danube_pci_grps)},
646 {"ebu", ARRAY_AND_SIZE(danube_ebu_grps)},
647 {"dfe", ARRAY_AND_SIZE(danube_dfe_grps)},
648 };
649
650 /* --------- xrx100 related code --------- */
651 #define XRX100_MAX_PIN 56
652
653 static const struct ltq_mfp_pin xrx100_mfp[] = {
654 /* pin f0 f1 f2 f3 */
655 MFP_XWAY(GPIO0, GPIO, EXIN, SDIO, TDM),
656 MFP_XWAY(GPIO1, GPIO, EXIN, CBUS, SIN),
657 MFP_XWAY(GPIO2, GPIO, CGU, EXIN, NONE),
658 MFP_XWAY(GPIO3, GPIO, CGU, SDIO, PCI),
659 MFP_XWAY(GPIO4, GPIO, STP, DFE, ASC),
660 MFP_XWAY(GPIO5, GPIO, STP, NONE, DFE),
661 MFP_XWAY(GPIO6, GPIO, STP, GPT, ASC),
662 MFP_XWAY(GPIO7, GPIO, CGU, CBUS, NONE),
663 MFP_XWAY(GPIO8, GPIO, CGU, NMI, NONE),
664 MFP_XWAY(GPIO9, GPIO, ASC, SPI, EXIN),
665 MFP_XWAY(GPIO10, GPIO, ASC, SPI, EXIN),
666 MFP_XWAY(GPIO11, GPIO, ASC, CBUS, SPI),
667 MFP_XWAY(GPIO12, GPIO, ASC, CBUS, MCD),
668 MFP_XWAY(GPIO13, GPIO, EBU, SPI, NONE),
669 MFP_XWAY(GPIO14, GPIO, CGU, NONE, NONE),
670 MFP_XWAY(GPIO15, GPIO, SPI, SDIO, MCD),
671 MFP_XWAY(GPIO16, GPIO, SPI, SDIO, NONE),
672 MFP_XWAY(GPIO17, GPIO, SPI, SDIO, NONE),
673 MFP_XWAY(GPIO18, GPIO, SPI, SDIO, NONE),
674 MFP_XWAY(GPIO19, GPIO, PCI, SDIO, CGU),
675 MFP_XWAY(GPIO20, GPIO, NONE, SDIO, EBU),
676 MFP_XWAY(GPIO21, GPIO, PCI, EBU, GPT),
677 MFP_XWAY(GPIO22, GPIO, SPI, NONE, EBU),
678 MFP_XWAY(GPIO23, GPIO, EBU, PCI, STP),
679 MFP_XWAY(GPIO24, GPIO, EBU, TDM, PCI),
680 MFP_XWAY(GPIO25, GPIO, TDM, SDIO, ASC),
681 MFP_XWAY(GPIO26, GPIO, EBU, TDM, SDIO),
682 MFP_XWAY(GPIO27, GPIO, TDM, SDIO, ASC),
683 MFP_XWAY(GPIO28, GPIO, GPT, NONE, SDIO),
684 MFP_XWAY(GPIO29, GPIO, PCI, CBUS, NONE),
685 MFP_XWAY(GPIO30, GPIO, PCI, CBUS, NONE),
686 MFP_XWAY(GPIO31, GPIO, EBU, PCI, NONE),
687 MFP_XWAY(GPIO32, GPIO, MII, NONE, EBU),
688 MFP_XWAY(GPIO33, GPIO, MII, NONE, EBU),
689 MFP_XWAY(GPIO34, GPIO, SIN, SSI, NONE),
690 MFP_XWAY(GPIO35, GPIO, SIN, SSI, NONE),
691 MFP_XWAY(GPIO36, GPIO, SIN, SSI, NONE),
692 MFP_XWAY(GPIO37, GPIO, PCI, NONE, NONE),
693 MFP_XWAY(GPIO38, GPIO, PCI, NONE, NONE),
694 MFP_XWAY(GPIO39, GPIO, NONE, EXIN, NONE),
695 MFP_XWAY(GPIO40, GPIO, MII, TDM, NONE),
696 MFP_XWAY(GPIO41, GPIO, MII, TDM, NONE),
697 MFP_XWAY(GPIO42, GPIO, MDIO, NONE, NONE),
698 MFP_XWAY(GPIO43, GPIO, MDIO, NONE, NONE),
699 MFP_XWAY(GPIO44, GPIO, MII, SIN, NONE),
700 MFP_XWAY(GPIO45, GPIO, MII, NONE, SIN),
701 MFP_XWAY(GPIO46, GPIO, MII, NONE, EXIN),
702 MFP_XWAY(GPIO47, GPIO, MII, NONE, SIN),
703 MFP_XWAY(GPIO48, GPIO, EBU, NONE, NONE),
704 MFP_XWAY(GPIO49, GPIO, EBU, NONE, NONE),
705 MFP_XWAY(GPIO50, GPIO, NONE, NONE, NONE),
706 MFP_XWAY(GPIO51, GPIO, NONE, NONE, NONE),
707 MFP_XWAY(GPIO52, GPIO, NONE, NONE, NONE),
708 MFP_XWAY(GPIO53, GPIO, NONE, NONE, NONE),
709 MFP_XWAY(GPIO54, GPIO, NONE, NONE, NONE),
710 MFP_XWAY(GPIO55, GPIO, NONE, NONE, NONE),
711 };
712
713 static const unsigned xrx100_exin_pin_map[] = {GPIO0, GPIO1, GPIO2, GPIO39, GPIO10, GPIO9};
714
715 static const unsigned xrx100_pins_exin0[] = {GPIO0};
716 static const unsigned xrx100_pins_exin1[] = {GPIO1};
717 static const unsigned xrx100_pins_exin2[] = {GPIO2};
718 static const unsigned xrx100_pins_exin3[] = {GPIO39};
719 static const unsigned xrx100_pins_exin4[] = {GPIO10};
720 static const unsigned xrx100_pins_exin5[] = {GPIO9};
721
722 static const unsigned xrx100_pins_asc0[] = {GPIO11, GPIO12};
723 static const unsigned xrx100_pins_asc0_cts_rts[] = {GPIO9, GPIO10};
724 static const unsigned xrx100_pins_stp[] = {GPIO4, GPIO5, GPIO6};
725 static const unsigned xrx100_pins_nmi[] = {GPIO8};
726 static const unsigned xrx100_pins_mdio[] = {GPIO42, GPIO43};
727
728 static const unsigned xrx100_pins_dfe_led0[] = {GPIO4};
729 static const unsigned xrx100_pins_dfe_led1[] = {GPIO5};
730
731 static const unsigned xrx100_pins_ebu_a24[] = {GPIO13};
732 static const unsigned xrx100_pins_ebu_clk[] = {GPIO21};
733 static const unsigned xrx100_pins_ebu_cs1[] = {GPIO23};
734 static const unsigned xrx100_pins_ebu_a23[] = {GPIO24};
735 static const unsigned xrx100_pins_ebu_wait[] = {GPIO26};
736 static const unsigned xrx100_pins_ebu_a25[] = {GPIO31};
737
738 static const unsigned xrx100_pins_nand_ale[] = {GPIO13};
739 static const unsigned xrx100_pins_nand_cs1[] = {GPIO23};
740 static const unsigned xrx100_pins_nand_cle[] = {GPIO24};
741 static const unsigned xrx100_pins_nand_rdy[] = {GPIO48};
742 static const unsigned xrx100_pins_nand_rd[] = {GPIO49};
743
744 static const unsigned xrx100_pins_spi_di[] = {GPIO16};
745 static const unsigned xrx100_pins_spi_do[] = {GPIO17};
746 static const unsigned xrx100_pins_spi_clk[] = {GPIO18};
747 static const unsigned xrx100_pins_spi_cs1[] = {GPIO15};
748 static const unsigned xrx100_pins_spi_cs2[] = {GPIO22};
749 static const unsigned xrx100_pins_spi_cs3[] = {GPIO13};
750 static const unsigned xrx100_pins_spi_cs4[] = {GPIO10};
751 static const unsigned xrx100_pins_spi_cs5[] = {GPIO9};
752 static const unsigned xrx100_pins_spi_cs6[] = {GPIO11};
753
754 static const unsigned xrx100_pins_gpt1[] = {GPIO28};
755 static const unsigned xrx100_pins_gpt2[] = {GPIO21};
756 static const unsigned xrx100_pins_gpt3[] = {GPIO6};
757
758 static const unsigned xrx100_pins_clkout0[] = {GPIO8};
759 static const unsigned xrx100_pins_clkout1[] = {GPIO7};
760 static const unsigned xrx100_pins_clkout2[] = {GPIO3};
761 static const unsigned xrx100_pins_clkout3[] = {GPIO2};
762
763 static const unsigned xrx100_pins_pci_gnt1[] = {GPIO30};
764 static const unsigned xrx100_pins_pci_gnt2[] = {GPIO23};
765 static const unsigned xrx100_pins_pci_gnt3[] = {GPIO19};
766 static const unsigned xrx100_pins_pci_gnt4[] = {GPIO38};
767 static const unsigned xrx100_pins_pci_req1[] = {GPIO29};
768 static const unsigned xrx100_pins_pci_req2[] = {GPIO31};
769 static const unsigned xrx100_pins_pci_req3[] = {GPIO3};
770 static const unsigned xrx100_pins_pci_req4[] = {GPIO37};
771
772 static const struct ltq_pin_group xrx100_grps[] = {
773 GRP_MUX("exin0", EXIN, xrx100_pins_exin0),
774 GRP_MUX("exin1", EXIN, xrx100_pins_exin1),
775 GRP_MUX("exin2", EXIN, xrx100_pins_exin2),
776 GRP_MUX("exin3", EXIN, xrx100_pins_exin3),
777 GRP_MUX("exin4", EXIN, xrx100_pins_exin4),
778 GRP_MUX("exin5", EXIN, xrx100_pins_exin5),
779 GRP_MUX("ebu a23", EBU, xrx100_pins_ebu_a23),
780 GRP_MUX("ebu a24", EBU, xrx100_pins_ebu_a24),
781 GRP_MUX("ebu a25", EBU, xrx100_pins_ebu_a25),
782 GRP_MUX("ebu clk", EBU, xrx100_pins_ebu_clk),
783 GRP_MUX("ebu cs1", EBU, xrx100_pins_ebu_cs1),
784 GRP_MUX("ebu wait", EBU, xrx100_pins_ebu_wait),
785 GRP_MUX("nand ale", EBU, xrx100_pins_nand_ale),
786 GRP_MUX("nand cs1", EBU, xrx100_pins_nand_cs1),
787 GRP_MUX("nand cle", EBU, xrx100_pins_nand_cle),
788 GRP_MUX("nand rdy", EBU, xrx100_pins_nand_rdy),
789 GRP_MUX("nand rd", EBU, xrx100_pins_nand_rd),
790 GRP_MUX("spi_di", SPI, xrx100_pins_spi_di),
791 GRP_MUX("spi_do", SPI, xrx100_pins_spi_do),
792 GRP_MUX("spi_clk", SPI, xrx100_pins_spi_clk),
793 GRP_MUX("spi_cs1", SPI, xrx100_pins_spi_cs1),
794 GRP_MUX("spi_cs2", SPI, xrx100_pins_spi_cs2),
795 GRP_MUX("spi_cs3", SPI, xrx100_pins_spi_cs3),
796 GRP_MUX("spi_cs4", SPI, xrx100_pins_spi_cs4),
797 GRP_MUX("spi_cs5", SPI, xrx100_pins_spi_cs5),
798 GRP_MUX("spi_cs6", SPI, xrx100_pins_spi_cs6),
799 GRP_MUX("asc0", ASC, xrx100_pins_asc0),
800 GRP_MUX("asc0 cts rts", ASC, xrx100_pins_asc0_cts_rts),
801 GRP_MUX("stp", STP, xrx100_pins_stp),
802 GRP_MUX("nmi", NMI, xrx100_pins_nmi),
803 GRP_MUX("gpt1", GPT, xrx100_pins_gpt1),
804 GRP_MUX("gpt2", GPT, xrx100_pins_gpt2),
805 GRP_MUX("gpt3", GPT, xrx100_pins_gpt3),
806 GRP_MUX("clkout0", CGU, xrx100_pins_clkout0),
807 GRP_MUX("clkout1", CGU, xrx100_pins_clkout1),
808 GRP_MUX("clkout2", CGU, xrx100_pins_clkout2),
809 GRP_MUX("clkout3", CGU, xrx100_pins_clkout3),
810 GRP_MUX("gnt1", PCI, xrx100_pins_pci_gnt1),
811 GRP_MUX("gnt2", PCI, xrx100_pins_pci_gnt2),
812 GRP_MUX("gnt3", PCI, xrx100_pins_pci_gnt3),
813 GRP_MUX("gnt4", PCI, xrx100_pins_pci_gnt4),
814 GRP_MUX("req1", PCI, xrx100_pins_pci_req1),
815 GRP_MUX("req2", PCI, xrx100_pins_pci_req2),
816 GRP_MUX("req3", PCI, xrx100_pins_pci_req3),
817 GRP_MUX("req4", PCI, xrx100_pins_pci_req4),
818 GRP_MUX("mdio", MDIO, xrx100_pins_mdio),
819 GRP_MUX("dfe led0", DFE, xrx100_pins_dfe_led0),
820 GRP_MUX("dfe led1", DFE, xrx100_pins_dfe_led1),
821 };
822
823 static const char * const xrx100_pci_grps[] = {"gnt1", "gnt2",
824 "gnt3", "gnt4",
825 "req1", "req2",
826 "req3", "req4"};
827 static const char * const xrx100_spi_grps[] = {"spi_di", "spi_do",
828 "spi_clk", "spi_cs1",
829 "spi_cs2", "spi_cs3",
830 "spi_cs4", "spi_cs5",
831 "spi_cs6"};
832 static const char * const xrx100_cgu_grps[] = {"clkout0", "clkout1",
833 "clkout2", "clkout3"};
834 static const char * const xrx100_ebu_grps[] = {"ebu a23", "ebu a24",
835 "ebu a25", "ebu cs1",
836 "ebu wait", "ebu clk",
837 "nand ale", "nand cs1",
838 "nand cle", "nand rdy",
839 "nand rd"};
840 static const char * const xrx100_exin_grps[] = {"exin0", "exin1", "exin2",
841 "exin3", "exin4", "exin5"};
842 static const char * const xrx100_gpt_grps[] = {"gpt1", "gpt2", "gpt3"};
843 static const char * const xrx100_asc_grps[] = {"asc0", "asc0 cts rts"};
844 static const char * const xrx100_stp_grps[] = {"stp"};
845 static const char * const xrx100_nmi_grps[] = {"nmi"};
846 static const char * const xrx100_mdio_grps[] = {"mdio"};
847 static const char * const xrx100_dfe_grps[] = {"dfe led0", "dfe led1"};
848
849 static const struct ltq_pmx_func xrx100_funcs[] = {
850 {"spi", ARRAY_AND_SIZE(xrx100_spi_grps)},
851 {"asc", ARRAY_AND_SIZE(xrx100_asc_grps)},
852 {"cgu", ARRAY_AND_SIZE(xrx100_cgu_grps)},
853 {"exin", ARRAY_AND_SIZE(xrx100_exin_grps)},
854 {"stp", ARRAY_AND_SIZE(xrx100_stp_grps)},
855 {"gpt", ARRAY_AND_SIZE(xrx100_gpt_grps)},
856 {"nmi", ARRAY_AND_SIZE(xrx100_nmi_grps)},
857 {"pci", ARRAY_AND_SIZE(xrx100_pci_grps)},
858 {"ebu", ARRAY_AND_SIZE(xrx100_ebu_grps)},
859 {"mdio", ARRAY_AND_SIZE(xrx100_mdio_grps)},
860 {"dfe", ARRAY_AND_SIZE(xrx100_dfe_grps)},
861 };
862
863 /* --------- xrx200 related code --------- */
864 #define XRX200_MAX_PIN 50
865
866 static const struct ltq_mfp_pin xrx200_mfp[] = {
867 /* pin f0 f1 f2 f3 */
868 MFP_XWAY(GPIO0, GPIO, EXIN, SDIO, TDM),
869 MFP_XWAY(GPIO1, GPIO, EXIN, CBUS, SIN),
870 MFP_XWAY(GPIO2, GPIO, CGU, EXIN, GPHY),
871 MFP_XWAY(GPIO3, GPIO, CGU, SDIO, PCI),
872 MFP_XWAY(GPIO4, GPIO, STP, DFE, USIF),
873 MFP_XWAY(GPIO5, GPIO, STP, GPHY, DFE),
874 MFP_XWAY(GPIO6, GPIO, STP, GPT, USIF),
875 MFP_XWAY(GPIO7, GPIO, CGU, CBUS, GPHY),
876 MFP_XWAY(GPIO8, GPIO, CGU, NMI, NONE),
877 MFP_XWAY(GPIO9, GPIO, USIF, SPI, EXIN),
878 MFP_XWAY(GPIO10, GPIO, USIF, SPI, EXIN),
879 MFP_XWAY(GPIO11, GPIO, USIF, CBUS, SPI),
880 MFP_XWAY(GPIO12, GPIO, USIF, CBUS, MCD),
881 MFP_XWAY(GPIO13, GPIO, EBU, SPI, NONE),
882 MFP_XWAY(GPIO14, GPIO, CGU, CBUS, USIF),
883 MFP_XWAY(GPIO15, GPIO, SPI, SDIO, MCD),
884 MFP_XWAY(GPIO16, GPIO, SPI, SDIO, NONE),
885 MFP_XWAY(GPIO17, GPIO, SPI, SDIO, NONE),
886 MFP_XWAY(GPIO18, GPIO, SPI, SDIO, NONE),
887 MFP_XWAY(GPIO19, GPIO, PCI, SDIO, CGU),
888 MFP_XWAY(GPIO20, GPIO, NONE, SDIO, EBU),
889 MFP_XWAY(GPIO21, GPIO, PCI, EBU, GPT),
890 MFP_XWAY(GPIO22, GPIO, SPI, CGU, EBU),
891 MFP_XWAY(GPIO23, GPIO, EBU, PCI, STP),
892 MFP_XWAY(GPIO24, GPIO, EBU, TDM, PCI),
893 MFP_XWAY(GPIO25, GPIO, TDM, SDIO, USIF),
894 MFP_XWAY(GPIO26, GPIO, EBU, TDM, SDIO),
895 MFP_XWAY(GPIO27, GPIO, TDM, SDIO, USIF),
896 MFP_XWAY(GPIO28, GPIO, GPT, PCI, SDIO),
897 MFP_XWAY(GPIO29, GPIO, PCI, CBUS, EXIN),
898 MFP_XWAY(GPIO30, GPIO, PCI, CBUS, NONE),
899 MFP_XWAY(GPIO31, GPIO, EBU, PCI, NONE),
900 MFP_XWAY(GPIO32, GPIO, MII, NONE, EBU),
901 MFP_XWAY(GPIO33, GPIO, MII, NONE, EBU),
902 MFP_XWAY(GPIO34, GPIO, SIN, SSI, NONE),
903 MFP_XWAY(GPIO35, GPIO, SIN, SSI, NONE),
904 MFP_XWAY(GPIO36, GPIO, SIN, SSI, EXIN),
905 MFP_XWAY(GPIO37, GPIO, USIF, NONE, PCI),
906 MFP_XWAY(GPIO38, GPIO, PCI, USIF, NONE),
907 MFP_XWAY(GPIO39, GPIO, USIF, EXIN, NONE),
908 MFP_XWAY(GPIO40, GPIO, MII, TDM, NONE),
909 MFP_XWAY(GPIO41, GPIO, MII, TDM, NONE),
910 MFP_XWAY(GPIO42, GPIO, MDIO, NONE, NONE),
911 MFP_XWAY(GPIO43, GPIO, MDIO, NONE, NONE),
912 MFP_XWAY(GPIO44, GPIO, MII, SIN, GPHY),
913 MFP_XWAY(GPIO45, GPIO, MII, GPHY, SIN),
914 MFP_XWAY(GPIO46, GPIO, MII, NONE, EXIN),
915 MFP_XWAY(GPIO47, GPIO, MII, GPHY, SIN),
916 MFP_XWAY(GPIO48, GPIO, EBU, NONE, NONE),
917 MFP_XWAY(GPIO49, GPIO, EBU, NONE, NONE),
918 };
919
920 static const unsigned xrx200_exin_pin_map[] = {GPIO0, GPIO1, GPIO2, GPIO39, GPIO10, GPIO9};
921
922 static const unsigned xrx200_pins_exin0[] = {GPIO0};
923 static const unsigned xrx200_pins_exin1[] = {GPIO1};
924 static const unsigned xrx200_pins_exin2[] = {GPIO2};
925 static const unsigned xrx200_pins_exin3[] = {GPIO39};
926 static const unsigned xrx200_pins_exin4[] = {GPIO10};
927 static const unsigned xrx200_pins_exin5[] = {GPIO9};
928
929 static const unsigned xrx200_pins_usif_uart_rx[] = {GPIO11};
930 static const unsigned xrx200_pins_usif_uart_tx[] = {GPIO12};
931 static const unsigned xrx200_pins_usif_uart_rts[] = {GPIO9};
932 static const unsigned xrx200_pins_usif_uart_cts[] = {GPIO10};
933 static const unsigned xrx200_pins_usif_uart_dtr[] = {GPIO4};
934 static const unsigned xrx200_pins_usif_uart_dsr[] = {GPIO6};
935 static const unsigned xrx200_pins_usif_uart_dcd[] = {GPIO25};
936 static const unsigned xrx200_pins_usif_uart_ri[] = {GPIO27};
937
938 static const unsigned xrx200_pins_usif_spi_di[] = {GPIO11};
939 static const unsigned xrx200_pins_usif_spi_do[] = {GPIO12};
940 static const unsigned xrx200_pins_usif_spi_clk[] = {GPIO38};
941 static const unsigned xrx200_pins_usif_spi_cs0[] = {GPIO37};
942 static const unsigned xrx200_pins_usif_spi_cs1[] = {GPIO39};
943 static const unsigned xrx200_pins_usif_spi_cs2[] = {GPIO14};
944
945 static const unsigned xrx200_pins_stp[] = {GPIO4, GPIO5, GPIO6};
946 static const unsigned xrx200_pins_nmi[] = {GPIO8};
947 static const unsigned xrx200_pins_mdio[] = {GPIO42, GPIO43};
948
949 static const unsigned xrx200_pins_dfe_led0[] = {GPIO4};
950 static const unsigned xrx200_pins_dfe_led1[] = {GPIO5};
951
952 static const unsigned xrx200_pins_gphy0_led0[] = {GPIO5};
953 static const unsigned xrx200_pins_gphy0_led1[] = {GPIO7};
954 static const unsigned xrx200_pins_gphy0_led2[] = {GPIO2};
955 static const unsigned xrx200_pins_gphy1_led0[] = {GPIO44};
956 static const unsigned xrx200_pins_gphy1_led1[] = {GPIO45};
957 static const unsigned xrx200_pins_gphy1_led2[] = {GPIO47};
958
959 static const unsigned xrx200_pins_ebu_a24[] = {GPIO13};
960 static const unsigned xrx200_pins_ebu_clk[] = {GPIO21};
961 static const unsigned xrx200_pins_ebu_cs1[] = {GPIO23};
962 static const unsigned xrx200_pins_ebu_a23[] = {GPIO24};
963 static const unsigned xrx200_pins_ebu_wait[] = {GPIO26};
964 static const unsigned xrx200_pins_ebu_a25[] = {GPIO31};
965
966 static const unsigned xrx200_pins_nand_ale[] = {GPIO13};
967 static const unsigned xrx200_pins_nand_cs1[] = {GPIO23};
968 static const unsigned xrx200_pins_nand_cle[] = {GPIO24};
969 static const unsigned xrx200_pins_nand_rdy[] = {GPIO48};
970 static const unsigned xrx200_pins_nand_rd[] = {GPIO49};
971
972 static const unsigned xrx200_pins_spi_di[] = {GPIO16};
973 static const unsigned xrx200_pins_spi_do[] = {GPIO17};
974 static const unsigned xrx200_pins_spi_clk[] = {GPIO18};
975 static const unsigned xrx200_pins_spi_cs1[] = {GPIO15};
976 static const unsigned xrx200_pins_spi_cs2[] = {GPIO22};
977 static const unsigned xrx200_pins_spi_cs3[] = {GPIO13};
978 static const unsigned xrx200_pins_spi_cs4[] = {GPIO10};
979 static const unsigned xrx200_pins_spi_cs5[] = {GPIO9};
980 static const unsigned xrx200_pins_spi_cs6[] = {GPIO11};
981
982 static const unsigned xrx200_pins_gpt1[] = {GPIO28};
983 static const unsigned xrx200_pins_gpt2[] = {GPIO21};
984 static const unsigned xrx200_pins_gpt3[] = {GPIO6};
985
986 static const unsigned xrx200_pins_clkout0[] = {GPIO8};
987 static const unsigned xrx200_pins_clkout1[] = {GPIO7};
988 static const unsigned xrx200_pins_clkout2[] = {GPIO3};
989 static const unsigned xrx200_pins_clkout3[] = {GPIO2};
990
991 static const unsigned xrx200_pins_pci_gnt1[] = {GPIO28};
992 static const unsigned xrx200_pins_pci_gnt2[] = {GPIO23};
993 static const unsigned xrx200_pins_pci_gnt3[] = {GPIO19};
994 static const unsigned xrx200_pins_pci_gnt4[] = {GPIO38};
995 static const unsigned xrx200_pins_pci_req1[] = {GPIO29};
996 static const unsigned xrx200_pins_pci_req2[] = {GPIO31};
997 static const unsigned xrx200_pins_pci_req3[] = {GPIO3};
998 static const unsigned xrx200_pins_pci_req4[] = {GPIO37};
999
1000 static const struct ltq_pin_group xrx200_grps[] = {
1001 GRP_MUX("exin0", EXIN, xrx200_pins_exin0),
1002 GRP_MUX("exin1", EXIN, xrx200_pins_exin1),
1003 GRP_MUX("exin2", EXIN, xrx200_pins_exin2),
1004 GRP_MUX("exin3", EXIN, xrx200_pins_exin3),
1005 GRP_MUX("exin4", EXIN, xrx200_pins_exin4),
1006 GRP_MUX("exin5", EXIN, xrx200_pins_exin5),
1007 GRP_MUX("ebu a23", EBU, xrx200_pins_ebu_a23),
1008 GRP_MUX("ebu a24", EBU, xrx200_pins_ebu_a24),
1009 GRP_MUX("ebu a25", EBU, xrx200_pins_ebu_a25),
1010 GRP_MUX("ebu clk", EBU, xrx200_pins_ebu_clk),
1011 GRP_MUX("ebu cs1", EBU, xrx200_pins_ebu_cs1),
1012 GRP_MUX("ebu wait", EBU, xrx200_pins_ebu_wait),
1013 GRP_MUX("nand ale", EBU, xrx200_pins_nand_ale),
1014 GRP_MUX("nand cs1", EBU, xrx200_pins_nand_cs1),
1015 GRP_MUX("nand cle", EBU, xrx200_pins_nand_cle),
1016 GRP_MUX("nand rdy", EBU, xrx200_pins_nand_rdy),
1017 GRP_MUX("nand rd", EBU, xrx200_pins_nand_rd),
1018 GRP_MUX("spi_di", SPI, xrx200_pins_spi_di),
1019 GRP_MUX("spi_do", SPI, xrx200_pins_spi_do),
1020 GRP_MUX("spi_clk", SPI, xrx200_pins_spi_clk),
1021 GRP_MUX("spi_cs1", SPI, xrx200_pins_spi_cs1),
1022 GRP_MUX("spi_cs2", SPI, xrx200_pins_spi_cs2),
1023 GRP_MUX("spi_cs3", SPI, xrx200_pins_spi_cs3),
1024 GRP_MUX("spi_cs4", SPI, xrx200_pins_spi_cs4),
1025 GRP_MUX("spi_cs5", SPI, xrx200_pins_spi_cs5),
1026 GRP_MUX("spi_cs6", SPI, xrx200_pins_spi_cs6),
1027 GRP_MUX("usif uart_rx", USIF, xrx200_pins_usif_uart_rx),
1028 GRP_MUX("usif uart_tx", USIF, xrx200_pins_usif_uart_tx),
1029 GRP_MUX("usif uart_rts", USIF, xrx200_pins_usif_uart_rts),
1030 GRP_MUX("usif uart_cts", USIF, xrx200_pins_usif_uart_cts),
1031 GRP_MUX("usif uart_dtr", USIF, xrx200_pins_usif_uart_dtr),
1032 GRP_MUX("usif uart_dsr", USIF, xrx200_pins_usif_uart_dsr),
1033 GRP_MUX("usif uart_dcd", USIF, xrx200_pins_usif_uart_dcd),
1034 GRP_MUX("usif uart_ri", USIF, xrx200_pins_usif_uart_ri),
1035 GRP_MUX("usif spi_di", USIF, xrx200_pins_usif_spi_di),
1036 GRP_MUX("usif spi_do", USIF, xrx200_pins_usif_spi_do),
1037 GRP_MUX("usif spi_clk", USIF, xrx200_pins_usif_spi_clk),
1038 GRP_MUX("usif spi_cs0", USIF, xrx200_pins_usif_spi_cs0),
1039 GRP_MUX("usif spi_cs1", USIF, xrx200_pins_usif_spi_cs1),
1040 GRP_MUX("usif spi_cs2", USIF, xrx200_pins_usif_spi_cs2),
1041 GRP_MUX("stp", STP, xrx200_pins_stp),
1042 GRP_MUX("nmi", NMI, xrx200_pins_nmi),
1043 GRP_MUX("gpt1", GPT, xrx200_pins_gpt1),
1044 GRP_MUX("gpt2", GPT, xrx200_pins_gpt2),
1045 GRP_MUX("gpt3", GPT, xrx200_pins_gpt3),
1046 GRP_MUX("clkout0", CGU, xrx200_pins_clkout0),
1047 GRP_MUX("clkout1", CGU, xrx200_pins_clkout1),
1048 GRP_MUX("clkout2", CGU, xrx200_pins_clkout2),
1049 GRP_MUX("clkout3", CGU, xrx200_pins_clkout3),
1050 GRP_MUX("gnt1", PCI, xrx200_pins_pci_gnt1),
1051 GRP_MUX("gnt2", PCI, xrx200_pins_pci_gnt2),
1052 GRP_MUX("gnt3", PCI, xrx200_pins_pci_gnt3),
1053 GRP_MUX("gnt4", PCI, xrx200_pins_pci_gnt4),
1054 GRP_MUX("req1", PCI, xrx200_pins_pci_req1),
1055 GRP_MUX("req2", PCI, xrx200_pins_pci_req2),
1056 GRP_MUX("req3", PCI, xrx200_pins_pci_req3),
1057 GRP_MUX("req4", PCI, xrx200_pins_pci_req4),
1058 GRP_MUX("mdio", MDIO, xrx200_pins_mdio),
1059 GRP_MUX("dfe led0", DFE, xrx200_pins_dfe_led0),
1060 GRP_MUX("dfe led1", DFE, xrx200_pins_dfe_led1),
1061 GRP_MUX("gphy0 led0", GPHY, xrx200_pins_gphy0_led0),
1062 GRP_MUX("gphy0 led1", GPHY, xrx200_pins_gphy0_led1),
1063 GRP_MUX("gphy0 led2", GPHY, xrx200_pins_gphy0_led2),
1064 GRP_MUX("gphy1 led0", GPHY, xrx200_pins_gphy1_led0),
1065 GRP_MUX("gphy1 led1", GPHY, xrx200_pins_gphy1_led1),
1066 GRP_MUX("gphy1 led2", GPHY, xrx200_pins_gphy1_led2),
1067 };
1068
1069 static const char * const xrx200_pci_grps[] = {"gnt1", "gnt2",
1070 "gnt3", "gnt4",
1071 "req1", "req2",
1072 "req3", "req4"};
1073 static const char * const xrx200_spi_grps[] = {"spi_di", "spi_do",
1074 "spi_clk", "spi_cs1",
1075 "spi_cs2", "spi_cs3",
1076 "spi_cs4", "spi_cs5",
1077 "spi_cs6"};
1078 static const char * const xrx200_cgu_grps[] = {"clkout0", "clkout1",
1079 "clkout2", "clkout3"};
1080 static const char * const xrx200_ebu_grps[] = {"ebu a23", "ebu a24",
1081 "ebu a25", "ebu cs1",
1082 "ebu wait", "ebu clk",
1083 "nand ale", "nand cs1",
1084 "nand cle", "nand rdy",
1085 "nand rd"};
1086 static const char * const xrx200_exin_grps[] = {"exin0", "exin1", "exin2",
1087 "exin3", "exin4", "exin5"};
1088 static const char * const xrx200_gpt_grps[] = {"gpt1", "gpt2", "gpt3"};
1089 static const char * const xrx200_usif_grps[] = {"usif uart_rx", "usif uart_tx",
1090 "usif uart_rts", "usif uart_cts",
1091 "usif uart_dtr", "usif uart_dsr",
1092 "usif uart_dcd", "usif uart_ri",
1093 "usif spi_di", "usif spi_do",
1094 "usif spi_clk", "usif spi_cs0",
1095 "usif spi_cs1", "usif spi_cs2"};
1096 static const char * const xrx200_stp_grps[] = {"stp"};
1097 static const char * const xrx200_nmi_grps[] = {"nmi"};
1098 static const char * const xrx200_mdio_grps[] = {"mdio"};
1099 static const char * const xrx200_dfe_grps[] = {"dfe led0", "dfe led1"};
1100 static const char * const xrx200_gphy_grps[] = {"gphy0 led0", "gphy0 led1",
1101 "gphy0 led2", "gphy1 led0",
1102 "gphy1 led1", "gphy1 led2"};
1103
1104 static const struct ltq_pmx_func xrx200_funcs[] = {
1105 {"spi", ARRAY_AND_SIZE(xrx200_spi_grps)},
1106 {"usif", ARRAY_AND_SIZE(xrx200_usif_grps)},
1107 {"cgu", ARRAY_AND_SIZE(xrx200_cgu_grps)},
1108 {"exin", ARRAY_AND_SIZE(xrx200_exin_grps)},
1109 {"stp", ARRAY_AND_SIZE(xrx200_stp_grps)},
1110 {"gpt", ARRAY_AND_SIZE(xrx200_gpt_grps)},
1111 {"nmi", ARRAY_AND_SIZE(xrx200_nmi_grps)},
1112 {"pci", ARRAY_AND_SIZE(xrx200_pci_grps)},
1113 {"ebu", ARRAY_AND_SIZE(xrx200_ebu_grps)},
1114 {"mdio", ARRAY_AND_SIZE(xrx200_mdio_grps)},
1115 {"dfe", ARRAY_AND_SIZE(xrx200_dfe_grps)},
1116 {"gphy", ARRAY_AND_SIZE(xrx200_gphy_grps)},
1117 };
1118
1119 /* --------- xrx300 related code --------- */
1120 #define XRX300_MAX_PIN 64
1121
1122 static const struct ltq_mfp_pin xrx300_mfp[] = {
1123 /* pin f0 f1 f2 f3 */
1124 MFP_XWAY(GPIO0, GPIO, EXIN, EPHY, NONE),
1125 MFP_XWAY(GPIO1, GPIO, NONE, EXIN, NONE),
1126 MFP_XWAY(GPIO2, NONE, NONE, NONE, NONE),
1127 MFP_XWAY(GPIO3, GPIO, CGU, NONE, NONE),
1128 MFP_XWAY(GPIO4, GPIO, STP, DFE, NONE),
1129 MFP_XWAY(GPIO5, GPIO, STP, EPHY, DFE),
1130 MFP_XWAY(GPIO6, GPIO, STP, NONE, NONE),
1131 MFP_XWAY(GPIO7, NONE, NONE, NONE, NONE),
1132 MFP_XWAY(GPIO8, GPIO, CGU, GPHY, EPHY),
1133 MFP_XWAY(GPIO9, GPIO, WIFI, NONE, EXIN),
1134 MFP_XWAY(GPIO10, GPIO, USIF, SPI, EXIN),
1135 MFP_XWAY(GPIO11, GPIO, USIF, WIFI, SPI),
1136 MFP_XWAY(GPIO12, NONE, NONE, NONE, NONE),
1137 MFP_XWAY(GPIO13, GPIO, EBU, NONE, NONE),
1138 MFP_XWAY(GPIO14, GPIO, CGU, USIF, EPHY),
1139 MFP_XWAY(GPIO15, GPIO, SPI, NONE, MCD),
1140 MFP_XWAY(GPIO16, GPIO, SPI, EXIN, NONE),
1141 MFP_XWAY(GPIO17, GPIO, SPI, NONE, NONE),
1142 MFP_XWAY(GPIO18, GPIO, SPI, NONE, NONE),
1143 MFP_XWAY(GPIO19, GPIO, USIF, NONE, EPHY),
1144 MFP_XWAY(GPIO20, NONE, NONE, NONE, NONE),
1145 MFP_XWAY(GPIO21, NONE, NONE, NONE, NONE),
1146 MFP_XWAY(GPIO22, NONE, NONE, NONE, NONE),
1147 MFP_XWAY(GPIO23, GPIO, EBU, NONE, NONE),
1148 MFP_XWAY(GPIO24, GPIO, EBU, NONE, NONE),
1149 MFP_XWAY(GPIO25, GPIO, TDM, NONE, NONE),
1150 MFP_XWAY(GPIO26, GPIO, TDM, NONE, NONE),
1151 MFP_XWAY(GPIO27, GPIO, TDM, NONE, NONE),
1152 MFP_XWAY(GPIO28, NONE, NONE, NONE, NONE),
1153 MFP_XWAY(GPIO29, NONE, NONE, NONE, NONE),
1154 MFP_XWAY(GPIO30, NONE, NONE, NONE, NONE),
1155 MFP_XWAY(GPIO31, NONE, NONE, NONE, NONE),
1156 MFP_XWAY(GPIO32, NONE, NONE, NONE, NONE),
1157 MFP_XWAY(GPIO33, NONE, NONE, NONE, NONE),
1158 MFP_XWAY(GPIO34, GPIO, NONE, SSI, NONE),
1159 MFP_XWAY(GPIO35, GPIO, NONE, SSI, NONE),
1160 MFP_XWAY(GPIO36, GPIO, NONE, SSI, NONE),
1161 MFP_XWAY(GPIO37, NONE, NONE, NONE, NONE),
1162 MFP_XWAY(GPIO38, NONE, NONE, NONE, NONE),
1163 MFP_XWAY(GPIO39, NONE, NONE, NONE, NONE),
1164 MFP_XWAY(GPIO40, NONE, NONE, NONE, NONE),
1165 MFP_XWAY(GPIO41, NONE, NONE, NONE, NONE),
1166 MFP_XWAY(GPIO42, GPIO, MDIO, NONE, NONE),
1167 MFP_XWAY(GPIO43, GPIO, MDIO, NONE, NONE),
1168 MFP_XWAY(GPIO44, NONE, NONE, NONE, NONE),
1169 MFP_XWAY(GPIO45, NONE, NONE, NONE, NONE),
1170 MFP_XWAY(GPIO46, NONE, NONE, NONE, NONE),
1171 MFP_XWAY(GPIO47, NONE, NONE, NONE, NONE),
1172 MFP_XWAY(GPIO48, GPIO, EBU, NONE, NONE),
1173 MFP_XWAY(GPIO49, GPIO, EBU, NONE, NONE),
1174 MFP_XWAY(GPIO50, GPIO, EBU, NONE, NONE),
1175 MFP_XWAY(GPIO51, GPIO, EBU, NONE, NONE),
1176 MFP_XWAY(GPIO52, GPIO, EBU, NONE, NONE),
1177 MFP_XWAY(GPIO53, GPIO, EBU, NONE, NONE),
1178 MFP_XWAY(GPIO54, GPIO, EBU, NONE, NONE),
1179 MFP_XWAY(GPIO55, GPIO, EBU, NONE, NONE),
1180 MFP_XWAY(GPIO56, GPIO, EBU, NONE, NONE),
1181 MFP_XWAY(GPIO57, GPIO, EBU, NONE, NONE),
1182 MFP_XWAY(GPIO58, GPIO, EBU, TDM, NONE),
1183 MFP_XWAY(GPIO59, GPIO, EBU, NONE, NONE),
1184 MFP_XWAY(GPIO60, GPIO, EBU, NONE, NONE),
1185 MFP_XWAY(GPIO61, GPIO, EBU, NONE, NONE),
1186 MFP_XWAY(GPIO62, NONE, NONE, NONE, NONE),
1187 MFP_XWAY(GPIO63, NONE, NONE, NONE, NONE),
1188 };
1189
1190 static const unsigned xrx300_exin_pin_map[] = {GPIO0, GPIO1, GPIO16, GPIO10, GPIO9};
1191
1192 static const unsigned xrx300_pins_exin0[] = {GPIO0};
1193 static const unsigned xrx300_pins_exin1[] = {GPIO1};
1194 static const unsigned xrx300_pins_exin2[] = {GPIO16};
1195 /* EXIN3 is not available on xrX300 */
1196 static const unsigned xrx300_pins_exin4[] = {GPIO10};
1197 static const unsigned xrx300_pins_exin5[] = {GPIO9};
1198
1199 static const unsigned xrx300_pins_usif_uart_rx[] = {GPIO11};
1200 static const unsigned xrx300_pins_usif_uart_tx[] = {GPIO10};
1201
1202 static const unsigned xrx300_pins_usif_spi_di[] = {GPIO11};
1203 static const unsigned xrx300_pins_usif_spi_do[] = {GPIO10};
1204 static const unsigned xrx300_pins_usif_spi_clk[] = {GPIO19};
1205 static const unsigned xrx300_pins_usif_spi_cs0[] = {GPIO14};
1206
1207 static const unsigned xrx300_pins_stp[] = {GPIO4, GPIO5, GPIO6};
1208 static const unsigned xrx300_pins_mdio[] = {GPIO42, GPIO43};
1209
1210 static const unsigned xrx300_pins_dfe_led0[] = {GPIO4};
1211 static const unsigned xrx300_pins_dfe_led1[] = {GPIO5};
1212
1213 static const unsigned xrx300_pins_ephy0_led0[] = {GPIO5};
1214 static const unsigned xrx300_pins_ephy0_led1[] = {GPIO8};
1215 static const unsigned xrx300_pins_ephy1_led0[] = {GPIO14};
1216 static const unsigned xrx300_pins_ephy1_led1[] = {GPIO19};
1217
1218 static const unsigned xrx300_pins_nand_ale[] = {GPIO13};
1219 static const unsigned xrx300_pins_nand_cs1[] = {GPIO23};
1220 static const unsigned xrx300_pins_nand_cle[] = {GPIO24};
1221 static const unsigned xrx300_pins_nand_rdy[] = {GPIO48};
1222 static const unsigned xrx300_pins_nand_rd[] = {GPIO49};
1223 static const unsigned xrx300_pins_nand_d1[] = {GPIO50};
1224 static const unsigned xrx300_pins_nand_d0[] = {GPIO51};
1225 static const unsigned xrx300_pins_nand_d2[] = {GPIO52};
1226 static const unsigned xrx300_pins_nand_d7[] = {GPIO53};
1227 static const unsigned xrx300_pins_nand_d6[] = {GPIO54};
1228 static const unsigned xrx300_pins_nand_d5[] = {GPIO55};
1229 static const unsigned xrx300_pins_nand_d4[] = {GPIO56};
1230 static const unsigned xrx300_pins_nand_d3[] = {GPIO57};
1231 static const unsigned xrx300_pins_nand_cs0[] = {GPIO58};
1232 static const unsigned xrx300_pins_nand_wr[] = {GPIO59};
1233 static const unsigned xrx300_pins_nand_wp[] = {GPIO60};
1234 static const unsigned xrx300_pins_nand_se[] = {GPIO61};
1235
1236 static const unsigned xrx300_pins_spi_di[] = {GPIO16};
1237 static const unsigned xrx300_pins_spi_do[] = {GPIO17};
1238 static const unsigned xrx300_pins_spi_clk[] = {GPIO18};
1239 static const unsigned xrx300_pins_spi_cs1[] = {GPIO15};
1240 /* SPI_CS2 is not available on xrX300 */
1241 /* SPI_CS3 is not available on xrX300 */
1242 static const unsigned xrx300_pins_spi_cs4[] = {GPIO10};
1243 /* SPI_CS5 is not available on xrX300 */
1244 static const unsigned xrx300_pins_spi_cs6[] = {GPIO11};
1245
1246 /* CLKOUT0 is not available on xrX300 */
1247 /* CLKOUT1 is not available on xrX300 */
1248 static const unsigned xrx300_pins_clkout2[] = {GPIO3};
1249
1250 static const struct ltq_pin_group xrx300_grps[] = {
1251 GRP_MUX("exin0", EXIN, xrx300_pins_exin0),
1252 GRP_MUX("exin1", EXIN, xrx300_pins_exin1),
1253 GRP_MUX("exin2", EXIN, xrx300_pins_exin2),
1254 GRP_MUX("exin4", EXIN, xrx300_pins_exin4),
1255 GRP_MUX("exin5", EXIN, xrx300_pins_exin5),
1256 GRP_MUX("nand ale", EBU, xrx300_pins_nand_ale),
1257 GRP_MUX("nand cs1", EBU, xrx300_pins_nand_cs1),
1258 GRP_MUX("nand cle", EBU, xrx300_pins_nand_cle),
1259 GRP_MUX("nand rdy", EBU, xrx300_pins_nand_rdy),
1260 GRP_MUX("nand rd", EBU, xrx300_pins_nand_rd),
1261 GRP_MUX("nand d1", EBU, xrx300_pins_nand_d1),
1262 GRP_MUX("nand d0", EBU, xrx300_pins_nand_d0),
1263 GRP_MUX("nand d2", EBU, xrx300_pins_nand_d2),
1264 GRP_MUX("nand d7", EBU, xrx300_pins_nand_d7),
1265 GRP_MUX("nand d6", EBU, xrx300_pins_nand_d6),
1266 GRP_MUX("nand d5", EBU, xrx300_pins_nand_d5),
1267 GRP_MUX("nand d4", EBU, xrx300_pins_nand_d4),
1268 GRP_MUX("nand d3", EBU, xrx300_pins_nand_d3),
1269 GRP_MUX("nand cs0", EBU, xrx300_pins_nand_cs0),
1270 GRP_MUX("nand wr", EBU, xrx300_pins_nand_wr),
1271 GRP_MUX("nand wp", EBU, xrx300_pins_nand_wp),
1272 GRP_MUX("nand se", EBU, xrx300_pins_nand_se),
1273 GRP_MUX("spi_di", SPI, xrx300_pins_spi_di),
1274 GRP_MUX("spi_do", SPI, xrx300_pins_spi_do),
1275 GRP_MUX("spi_clk", SPI, xrx300_pins_spi_clk),
1276 GRP_MUX("spi_cs1", SPI, xrx300_pins_spi_cs1),
1277 GRP_MUX("spi_cs4", SPI, xrx300_pins_spi_cs4),
1278 GRP_MUX("spi_cs6", SPI, xrx300_pins_spi_cs6),
1279 GRP_MUX("usif uart_rx", USIF, xrx300_pins_usif_uart_rx),
1280 GRP_MUX("usif uart_tx", USIF, xrx300_pins_usif_uart_tx),
1281 GRP_MUX("usif spi_di", USIF, xrx300_pins_usif_spi_di),
1282 GRP_MUX("usif spi_do", USIF, xrx300_pins_usif_spi_do),
1283 GRP_MUX("usif spi_clk", USIF, xrx300_pins_usif_spi_clk),
1284 GRP_MUX("usif spi_cs0", USIF, xrx300_pins_usif_spi_cs0),
1285 GRP_MUX("stp", STP, xrx300_pins_stp),
1286 GRP_MUX("clkout2", CGU, xrx300_pins_clkout2),
1287 GRP_MUX("mdio", MDIO, xrx300_pins_mdio),
1288 GRP_MUX("dfe led0", DFE, xrx300_pins_dfe_led0),
1289 GRP_MUX("dfe led1", DFE, xrx300_pins_dfe_led1),
1290 GRP_MUX("ephy0 led0", GPHY, xrx300_pins_ephy0_led0),
1291 GRP_MUX("ephy0 led1", GPHY, xrx300_pins_ephy0_led1),
1292 GRP_MUX("ephy1 led0", GPHY, xrx300_pins_ephy1_led0),
1293 GRP_MUX("ephy1 led1", GPHY, xrx300_pins_ephy1_led1),
1294 };
1295
1296 static const char * const xrx300_spi_grps[] = {"spi_di", "spi_do",
1297 "spi_clk", "spi_cs1",
1298 "spi_cs4", "spi_cs6"};
1299 static const char * const xrx300_cgu_grps[] = {"clkout2"};
1300 static const char * const xrx300_ebu_grps[] = {"nand ale", "nand cs1",
1301 "nand cle", "nand rdy",
1302 "nand rd", "nand d1",
1303 "nand d0", "nand d2",
1304 "nand d7", "nand d6",
1305 "nand d5", "nand d4",
1306 "nand d3", "nand cs0",
1307 "nand wr", "nand wp",
1308 "nand se"};
1309 static const char * const xrx300_exin_grps[] = {"exin0", "exin1", "exin2",
1310 "exin4", "exin5"};
1311 static const char * const xrx300_usif_grps[] = {"usif uart_rx", "usif uart_tx",
1312 "usif spi_di", "usif spi_do",
1313 "usif spi_clk", "usif spi_cs0"};
1314 static const char * const xrx300_stp_grps[] = {"stp"};
1315 static const char * const xrx300_mdio_grps[] = {"mdio"};
1316 static const char * const xrx300_dfe_grps[] = {"dfe led0", "dfe led1"};
1317 static const char * const xrx300_gphy_grps[] = {"ephy0 led0", "ephy0 led1",
1318 "ephy1 led0", "ephy1 led1"};
1319
1320 static const struct ltq_pmx_func xrx300_funcs[] = {
1321 {"spi", ARRAY_AND_SIZE(xrx300_spi_grps)},
1322 {"usif", ARRAY_AND_SIZE(xrx300_usif_grps)},
1323 {"cgu", ARRAY_AND_SIZE(xrx300_cgu_grps)},
1324 {"exin", ARRAY_AND_SIZE(xrx300_exin_grps)},
1325 {"stp", ARRAY_AND_SIZE(xrx300_stp_grps)},
1326 {"ebu", ARRAY_AND_SIZE(xrx300_ebu_grps)},
1327 {"mdio", ARRAY_AND_SIZE(xrx300_mdio_grps)},
1328 {"dfe", ARRAY_AND_SIZE(xrx300_dfe_grps)},
1329 {"ephy", ARRAY_AND_SIZE(xrx300_gphy_grps)},
1330 };
1331
1332 /* --------- pinconf related code --------- */
1333 static int xway_pinconf_get(struct pinctrl_dev *pctldev,
1334 unsigned pin,
1335 unsigned long *config)
1336 {
1337 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);
1338 enum ltq_pinconf_param param = LTQ_PINCONF_UNPACK_PARAM(*config);
1339 int port = PORT(pin);
1340 u32 reg;
1341
1342 switch (param) {
1343 case LTQ_PINCONF_PARAM_OPEN_DRAIN:
1344 if (port == PORT3)
1345 reg = GPIO3_OD;
1346 else
1347 reg = GPIO_OD(pin);
1348 *config = LTQ_PINCONF_PACK(param,
1349 !gpio_getbit(info->membase[0], reg, PORT_PIN(pin)));
1350 break;
1351
1352 case LTQ_PINCONF_PARAM_PULL:
1353 if (port == PORT3)
1354 reg = GPIO3_PUDEN;
1355 else
1356 reg = GPIO_PUDEN(pin);
1357 if (!gpio_getbit(info->membase[0], reg, PORT_PIN(pin))) {
1358 *config = LTQ_PINCONF_PACK(param, 0);
1359 break;
1360 }
1361
1362 if (port == PORT3)
1363 reg = GPIO3_PUDSEL;
1364 else
1365 reg = GPIO_PUDSEL(pin);
1366 if (!gpio_getbit(info->membase[0], reg, PORT_PIN(pin)))
1367 *config = LTQ_PINCONF_PACK(param, 2);
1368 else
1369 *config = LTQ_PINCONF_PACK(param, 1);
1370 break;
1371
1372 case LTQ_PINCONF_PARAM_OUTPUT:
1373 reg = GPIO_DIR(pin);
1374 *config = LTQ_PINCONF_PACK(param,
1375 gpio_getbit(info->membase[0], reg, PORT_PIN(pin)));
1376 break;
1377 default:
1378 dev_err(pctldev->dev, "Invalid config param %04x\n", param);
1379 return -ENOTSUPP;
1380 }
1381 return 0;
1382 }
1383
1384 static int xway_pinconf_set(struct pinctrl_dev *pctldev,
1385 unsigned pin,
1386 unsigned long *configs,
1387 unsigned num_configs)
1388 {
1389 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);
1390 enum ltq_pinconf_param param;
1391 int arg;
1392 int port = PORT(pin);
1393 u32 reg;
1394 int i;
1395
1396 for (i = 0; i < num_configs; i++) {
1397 param = LTQ_PINCONF_UNPACK_PARAM(configs[i]);
1398 arg = LTQ_PINCONF_UNPACK_ARG(configs[i]);
1399
1400 switch (param) {
1401 case LTQ_PINCONF_PARAM_OPEN_DRAIN:
1402 if (port == PORT3)
1403 reg = GPIO3_OD;
1404 else
1405 reg = GPIO_OD(pin);
1406 if (arg == 0)
1407 gpio_setbit(info->membase[0],
1408 reg,
1409 PORT_PIN(pin));
1410 else
1411 gpio_clearbit(info->membase[0],
1412 reg,
1413 PORT_PIN(pin));
1414 break;
1415
1416 case LTQ_PINCONF_PARAM_PULL:
1417 if (port == PORT3)
1418 reg = GPIO3_PUDEN;
1419 else
1420 reg = GPIO_PUDEN(pin);
1421 if (arg == 0) {
1422 gpio_clearbit(info->membase[0],
1423 reg,
1424 PORT_PIN(pin));
1425 break;
1426 }
1427 gpio_setbit(info->membase[0], reg, PORT_PIN(pin));
1428
1429 if (port == PORT3)
1430 reg = GPIO3_PUDSEL;
1431 else
1432 reg = GPIO_PUDSEL(pin);
1433 if (arg == 1)
1434 gpio_clearbit(info->membase[0],
1435 reg,
1436 PORT_PIN(pin));
1437 else if (arg == 2)
1438 gpio_setbit(info->membase[0],
1439 reg,
1440 PORT_PIN(pin));
1441 else
1442 dev_err(pctldev->dev,
1443 "Invalid pull value %d\n", arg);
1444 break;
1445
1446 case LTQ_PINCONF_PARAM_OUTPUT:
1447 reg = GPIO_DIR(pin);
1448 if (arg == 0)
1449 gpio_clearbit(info->membase[0],
1450 reg,
1451 PORT_PIN(pin));
1452 else
1453 gpio_setbit(info->membase[0],
1454 reg,
1455 PORT_PIN(pin));
1456 break;
1457
1458 default:
1459 dev_err(pctldev->dev,
1460 "Invalid config param %04x\n", param);
1461 return -ENOTSUPP;
1462 }
1463 } /* for each config */
1464
1465 return 0;
1466 }
1467
1468 int xway_pinconf_group_set(struct pinctrl_dev *pctldev,
1469 unsigned selector,
1470 unsigned long *configs,
1471 unsigned num_configs)
1472 {
1473 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);
1474 int i, ret = 0;
1475
1476 for (i = 0; i < info->grps[selector].npins && !ret; i++)
1477 ret = xway_pinconf_set(pctldev,
1478 info->grps[selector].pins[i],
1479 configs,
1480 num_configs);
1481
1482 return ret;
1483 }
1484
1485 static const struct pinconf_ops xway_pinconf_ops = {
1486 .pin_config_get = xway_pinconf_get,
1487 .pin_config_set = xway_pinconf_set,
1488 .pin_config_group_set = xway_pinconf_group_set,
1489 };
1490
1491 static struct pinctrl_desc xway_pctrl_desc = {
1492 .owner = THIS_MODULE,
1493 .confops = &xway_pinconf_ops,
1494 };
1495
1496 static inline int xway_mux_apply(struct pinctrl_dev *pctrldev,
1497 int pin, int mux)
1498 {
1499 struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
1500 int port = PORT(pin);
1501 u32 alt1_reg = GPIO_ALT1(pin);
1502
1503 if (port == PORT3)
1504 alt1_reg = GPIO3_ALT1;
1505
1506 if (mux & MUX_ALT0)
1507 gpio_setbit(info->membase[0], GPIO_ALT0(pin), PORT_PIN(pin));
1508 else
1509 gpio_clearbit(info->membase[0], GPIO_ALT0(pin), PORT_PIN(pin));
1510
1511 if (mux & MUX_ALT1)
1512 gpio_setbit(info->membase[0], alt1_reg, PORT_PIN(pin));
1513 else
1514 gpio_clearbit(info->membase[0], alt1_reg, PORT_PIN(pin));
1515
1516 return 0;
1517 }
1518
1519 static const struct ltq_cfg_param xway_cfg_params[] = {
1520 {"lantiq,pull", LTQ_PINCONF_PARAM_PULL},
1521 {"lantiq,open-drain", LTQ_PINCONF_PARAM_OPEN_DRAIN},
1522 {"lantiq,output", LTQ_PINCONF_PARAM_OUTPUT},
1523 };
1524
1525 static struct ltq_pinmux_info xway_info = {
1526 .desc = &xway_pctrl_desc,
1527 .apply_mux = xway_mux_apply,
1528 .params = xway_cfg_params,
1529 .num_params = ARRAY_SIZE(xway_cfg_params),
1530 };
1531
1532 /* --------- gpio_chip related code --------- */
1533 static void xway_gpio_set(struct gpio_chip *chip, unsigned int pin, int val)
1534 {
1535 struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
1536
1537 if (val)
1538 gpio_setbit(info->membase[0], GPIO_OUT(pin), PORT_PIN(pin));
1539 else
1540 gpio_clearbit(info->membase[0], GPIO_OUT(pin), PORT_PIN(pin));
1541 }
1542
1543 static int xway_gpio_get(struct gpio_chip *chip, unsigned int pin)
1544 {
1545 struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
1546
1547 return !!gpio_getbit(info->membase[0], GPIO_IN(pin), PORT_PIN(pin));
1548 }
1549
1550 static int xway_gpio_dir_in(struct gpio_chip *chip, unsigned int pin)
1551 {
1552 struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
1553
1554 gpio_clearbit(info->membase[0], GPIO_DIR(pin), PORT_PIN(pin));
1555
1556 return 0;
1557 }
1558
1559 static int xway_gpio_dir_out(struct gpio_chip *chip, unsigned int pin, int val)
1560 {
1561 struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
1562
1563 if (PORT(pin) == PORT3)
1564 gpio_setbit(info->membase[0], GPIO3_OD, PORT_PIN(pin));
1565 else
1566 gpio_setbit(info->membase[0], GPIO_OD(pin), PORT_PIN(pin));
1567 gpio_setbit(info->membase[0], GPIO_DIR(pin), PORT_PIN(pin));
1568 xway_gpio_set(chip, pin, val);
1569
1570 return 0;
1571 }
1572
1573 /*
1574 * gpiolib gpiod_to_irq callback function.
1575 * Returns the mapped IRQ (external interrupt) number for a given GPIO pin.
1576 */
1577 static int xway_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
1578 {
1579 struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
1580 int i;
1581
1582 for (i = 0; i < info->num_exin; i++)
1583 if (info->exin[i] == offset)
1584 return ltq_eiu_get_irq(i);
1585
1586 return -1;
1587 }
1588
1589 static struct gpio_chip xway_chip = {
1590 .label = "gpio-xway",
1591 .direction_input = xway_gpio_dir_in,
1592 .direction_output = xway_gpio_dir_out,
1593 .get = xway_gpio_get,
1594 .set = xway_gpio_set,
1595 .request = gpiochip_generic_request,
1596 .free = gpiochip_generic_free,
1597 .to_irq = xway_gpio_to_irq,
1598 .base = -1,
1599 };
1600
1601
1602 /* --------- register the pinctrl layer --------- */
1603 struct pinctrl_xway_soc {
1604 int pin_count;
1605 const struct ltq_mfp_pin *mfp;
1606 const struct ltq_pin_group *grps;
1607 unsigned int num_grps;
1608 const struct ltq_pmx_func *funcs;
1609 unsigned int num_funcs;
1610 const unsigned *exin;
1611 unsigned int num_exin;
1612 };
1613
1614 /* xway xr9 series (DEPRECATED: Use XWAY xRX100/xRX200 Family) */
1615 static struct pinctrl_xway_soc xr9_pinctrl = {
1616 .pin_count = XR9_MAX_PIN,
1617 .mfp = xway_mfp,
1618 .grps = xway_grps,
1619 .num_grps = ARRAY_SIZE(xway_grps),
1620 .funcs = xrx_funcs,
1621 .num_funcs = ARRAY_SIZE(xrx_funcs),
1622 .exin = xway_exin_pin_map,
1623 .num_exin = 6
1624 };
1625
1626 /* XWAY AMAZON Family */
1627 static struct pinctrl_xway_soc ase_pinctrl = {
1628 .pin_count = ASE_MAX_PIN,
1629 .mfp = ase_mfp,
1630 .grps = ase_grps,
1631 .num_grps = ARRAY_SIZE(ase_grps),
1632 .funcs = ase_funcs,
1633 .num_funcs = ARRAY_SIZE(ase_funcs),
1634 .exin = ase_exin_pin_map,
1635 .num_exin = 3
1636 };
1637
1638 /* XWAY DANUBE Family */
1639 static struct pinctrl_xway_soc danube_pinctrl = {
1640 .pin_count = DANUBE_MAX_PIN,
1641 .mfp = danube_mfp,
1642 .grps = danube_grps,
1643 .num_grps = ARRAY_SIZE(danube_grps),
1644 .funcs = danube_funcs,
1645 .num_funcs = ARRAY_SIZE(danube_funcs),
1646 .exin = danube_exin_pin_map,
1647 .num_exin = 3
1648 };
1649
1650 /* XWAY xRX100 Family */
1651 static struct pinctrl_xway_soc xrx100_pinctrl = {
1652 .pin_count = XRX100_MAX_PIN,
1653 .mfp = xrx100_mfp,
1654 .grps = xrx100_grps,
1655 .num_grps = ARRAY_SIZE(xrx100_grps),
1656 .funcs = xrx100_funcs,
1657 .num_funcs = ARRAY_SIZE(xrx100_funcs),
1658 .exin = xrx100_exin_pin_map,
1659 .num_exin = 6
1660 };
1661
1662 /* XWAY xRX200 Family */
1663 static struct pinctrl_xway_soc xrx200_pinctrl = {
1664 .pin_count = XRX200_MAX_PIN,
1665 .mfp = xrx200_mfp,
1666 .grps = xrx200_grps,
1667 .num_grps = ARRAY_SIZE(xrx200_grps),
1668 .funcs = xrx200_funcs,
1669 .num_funcs = ARRAY_SIZE(xrx200_funcs),
1670 .exin = xrx200_exin_pin_map,
1671 .num_exin = 6
1672 };
1673
1674 /* XWAY xRX300 Family */
1675 static struct pinctrl_xway_soc xrx300_pinctrl = {
1676 .pin_count = XRX300_MAX_PIN,
1677 .mfp = xrx300_mfp,
1678 .grps = xrx300_grps,
1679 .num_grps = ARRAY_SIZE(xrx300_grps),
1680 .funcs = xrx300_funcs,
1681 .num_funcs = ARRAY_SIZE(xrx300_funcs),
1682 .exin = xrx300_exin_pin_map,
1683 .num_exin = 5
1684 };
1685
1686 static struct pinctrl_gpio_range xway_gpio_range = {
1687 .name = "XWAY GPIO",
1688 .gc = &xway_chip,
1689 };
1690
1691 static const struct of_device_id xway_match[] = {
1692 { .compatible = "lantiq,pinctrl-xway", .data = &danube_pinctrl}, /*DEPRECATED*/
1693 { .compatible = "lantiq,pinctrl-xr9", .data = &xr9_pinctrl}, /*DEPRECATED*/
1694 { .compatible = "lantiq,pinctrl-ase", .data = &ase_pinctrl}, /*DEPRECATED*/
1695 { .compatible = "lantiq,ase-pinctrl", .data = &ase_pinctrl},
1696 { .compatible = "lantiq,danube-pinctrl", .data = &danube_pinctrl},
1697 { .compatible = "lantiq,xrx100-pinctrl", .data = &xrx100_pinctrl},
1698 { .compatible = "lantiq,xrx200-pinctrl", .data = &xrx200_pinctrl},
1699 { .compatible = "lantiq,xrx300-pinctrl", .data = &xrx300_pinctrl},
1700 {},
1701 };
1702 MODULE_DEVICE_TABLE(of, xway_match);
1703
1704 static int pinmux_xway_probe(struct platform_device *pdev)
1705 {
1706 const struct of_device_id *match;
1707 const struct pinctrl_xway_soc *xway_soc;
1708 struct resource *res;
1709 int ret, i;
1710
1711 /* get and remap our register range */
1712 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1713 xway_info.membase[0] = devm_ioremap_resource(&pdev->dev, res);
1714 if (IS_ERR(xway_info.membase[0]))
1715 return PTR_ERR(xway_info.membase[0]);
1716
1717 match = of_match_device(xway_match, &pdev->dev);
1718 if (match)
1719 xway_soc = (const struct pinctrl_xway_soc *) match->data;
1720 else
1721 xway_soc = &danube_pinctrl;
1722
1723 /* find out how many pads we have */
1724 xway_chip.ngpio = xway_soc->pin_count;
1725
1726 /* load our pad descriptors */
1727 xway_info.pads = devm_kcalloc(&pdev->dev,
1728 xway_chip.ngpio, sizeof(struct pinctrl_pin_desc),
1729 GFP_KERNEL);
1730 if (!xway_info.pads)
1731 return -ENOMEM;
1732
1733 for (i = 0; i < xway_chip.ngpio; i++) {
1734 /* strlen("ioXY") + 1 = 5 */
1735 char *name = devm_kzalloc(&pdev->dev, 5, GFP_KERNEL);
1736
1737 if (!name)
1738 return -ENOMEM;
1739
1740 snprintf(name, 5, "io%d", i);
1741 xway_info.pads[i].number = GPIO0 + i;
1742 xway_info.pads[i].name = name;
1743 }
1744 xway_pctrl_desc.pins = xway_info.pads;
1745
1746 /* setup the data needed by pinctrl */
1747 xway_pctrl_desc.name = dev_name(&pdev->dev);
1748 xway_pctrl_desc.npins = xway_chip.ngpio;
1749
1750 xway_info.num_pads = xway_chip.ngpio;
1751 xway_info.num_mfp = xway_chip.ngpio;
1752 xway_info.mfp = xway_soc->mfp;
1753 xway_info.grps = xway_soc->grps;
1754 xway_info.num_grps = xway_soc->num_grps;
1755 xway_info.funcs = xway_soc->funcs;
1756 xway_info.num_funcs = xway_soc->num_funcs;
1757 xway_info.exin = xway_soc->exin;
1758 xway_info.num_exin = xway_soc->num_exin;
1759
1760 /* register with the generic lantiq layer */
1761 ret = ltq_pinctrl_register(pdev, &xway_info);
1762 if (ret) {
1763 dev_err(&pdev->dev, "Failed to register pinctrl driver\n");
1764 return ret;
1765 }
1766
1767 /* register the gpio chip */
1768 xway_chip.parent = &pdev->dev;
1769 xway_chip.owner = THIS_MODULE;
1770 xway_chip.of_node = pdev->dev.of_node;
1771 ret = devm_gpiochip_add_data(&pdev->dev, &xway_chip, NULL);
1772 if (ret) {
1773 dev_err(&pdev->dev, "Failed to register gpio chip\n");
1774 return ret;
1775 }
1776
1777 /*
1778 * For DeviceTree-supported systems, the gpio core checks the
1779 * pinctrl's device node for the "gpio-ranges" property.
1780 * If it is present, it takes care of adding the pin ranges
1781 * for the driver. In this case the driver can skip ahead.
1782 *
1783 * In order to remain compatible with older, existing DeviceTree
1784 * files which don't set the "gpio-ranges" property or systems that
1785 * utilize ACPI the driver has to call gpiochip_add_pin_range().
1786 */
1787 if (!of_property_read_bool(pdev->dev.of_node, "gpio-ranges")) {
1788 /* finish with registering the gpio range in pinctrl */
1789 xway_gpio_range.npins = xway_chip.ngpio;
1790 xway_gpio_range.base = xway_chip.base;
1791 pinctrl_add_gpio_range(xway_info.pctrl, &xway_gpio_range);
1792 }
1793
1794 dev_info(&pdev->dev, "Init done\n");
1795 return 0;
1796 }
1797
1798 static struct platform_driver pinmux_xway_driver = {
1799 .probe = pinmux_xway_probe,
1800 .driver = {
1801 .name = "pinctrl-xway",
1802 .of_match_table = xway_match,
1803 },
1804 };
1805
1806 static int __init pinmux_xway_init(void)
1807 {
1808 return platform_driver_register(&pinmux_xway_driver);
1809 }
1810
1811 core_initcall_sync(pinmux_xway_init);
Linux with added FPC-III support