1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Pistachio SoC pinctrl driver
4  *
5  * Copyright (C) 2014 Imagination Technologies Ltd.
6  * Copyright (C) 2014 Google, Inc.
7  */
8 
9 #include <linux/gpio/driver.h>
10 #include <linux/interrupt.h>
11 #include <linux/io.h>
12 #include <linux/irq.h>
13 #include <linux/of.h>
14 #include <linux/of_irq.h>
15 #include <linux/pinctrl/pinconf.h>
16 #include <linux/pinctrl/pinconf-generic.h>
17 #include <linux/pinctrl/pinctrl.h>
18 #include <linux/pinctrl/pinmux.h>
19 #include <linux/platform_device.h>
20 #include <linux/slab.h>
21 #include <linux/spinlock.h>
22 
23 #include "pinctrl-utils.h"
24 
25 #define PADS_SCHMITT_EN0		0x000
26 #define PADS_SCHMITT_EN_REG(pin)	(PADS_SCHMITT_EN0 + 0x4 * ((pin) / 32))
27 #define PADS_SCHMITT_EN_BIT(pin)	BIT((pin) % 32)
28 
29 #define PADS_PU_PD0			0x040
30 #define PADS_PU_PD_REG(pin)		(PADS_PU_PD0 + 0x4 * ((pin) / 16))
31 #define PADS_PU_PD_SHIFT(pin)		(2 * ((pin) % 16))
32 #define PADS_PU_PD_MASK			0x3
33 #define PADS_PU_PD_HIGHZ		0x0
34 #define PADS_PU_PD_UP			0x1
35 #define PADS_PU_PD_DOWN			0x2
36 #define PADS_PU_PD_BUS			0x3
37 
38 #define PADS_FUNCTION_SELECT0		0x0c0
39 #define PADS_FUNCTION_SELECT1		0x0c4
40 #define PADS_FUNCTION_SELECT2		0x0c8
41 #define PADS_SCENARIO_SELECT		0x0f8
42 
43 #define PADS_SLEW_RATE0			0x100
44 #define PADS_SLEW_RATE_REG(pin)		(PADS_SLEW_RATE0 + 0x4 * ((pin) / 32))
45 #define PADS_SLEW_RATE_BIT(pin)		BIT((pin) % 32)
46 
47 #define PADS_DRIVE_STRENGTH0		0x120
48 #define PADS_DRIVE_STRENGTH_REG(pin)					\
49 	(PADS_DRIVE_STRENGTH0 + 0x4 * ((pin) / 16))
50 #define PADS_DRIVE_STRENGTH_SHIFT(pin)	(2 * ((pin) % 16))
51 #define PADS_DRIVE_STRENGTH_MASK	0x3
52 #define PADS_DRIVE_STRENGTH_2MA		0x0
53 #define PADS_DRIVE_STRENGTH_4MA		0x1
54 #define PADS_DRIVE_STRENGTH_8MA		0x2
55 #define PADS_DRIVE_STRENGTH_12MA	0x3
56 
57 #define GPIO_BANK_BASE(bank)		(0x200 + 0x24 * (bank))
58 
59 #define GPIO_BIT_EN			0x00
60 #define GPIO_OUTPUT_EN			0x04
61 #define GPIO_OUTPUT			0x08
62 #define GPIO_INPUT			0x0c
63 #define GPIO_INPUT_POLARITY		0x10
64 #define GPIO_INTERRUPT_TYPE		0x14
65 #define GPIO_INTERRUPT_TYPE_LEVEL	0x0
66 #define GPIO_INTERRUPT_TYPE_EDGE	0x1
67 #define GPIO_INTERRUPT_EDGE		0x18
68 #define GPIO_INTERRUPT_EDGE_SINGLE	0x0
69 #define GPIO_INTERRUPT_EDGE_DUAL	0x1
70 #define GPIO_INTERRUPT_EN		0x1c
71 #define GPIO_INTERRUPT_STATUS		0x20
72 
73 struct pistachio_function {
74 	const char *name;
75 	const char * const *groups;
76 	unsigned int ngroups;
77 	const int *scenarios;
78 	unsigned int nscenarios;
79 	unsigned int scenario_reg;
80 	unsigned int scenario_shift;
81 	unsigned int scenario_mask;
82 };
83 
84 struct pistachio_pin_group {
85 	const char *name;
86 	unsigned int pin;
87 	int mux_option[3];
88 	int mux_reg;
89 	int mux_shift;
90 	int mux_mask;
91 };
92 
93 struct pistachio_gpio_bank {
94 	struct pistachio_pinctrl *pctl;
95 	void __iomem *base;
96 	unsigned int pin_base;
97 	unsigned int npins;
98 	struct gpio_chip gpio_chip;
99 	struct irq_chip irq_chip;
100 };
101 
102 struct pistachio_pinctrl {
103 	struct device *dev;
104 	void __iomem *base;
105 	struct pinctrl_dev *pctldev;
106 	const struct pinctrl_pin_desc *pins;
107 	unsigned int npins;
108 	const struct pistachio_function *functions;
109 	unsigned int nfunctions;
110 	const struct pistachio_pin_group *groups;
111 	unsigned int ngroups;
112 	struct pistachio_gpio_bank *gpio_banks;
113 	unsigned int nbanks;
114 };
115 
116 #define PISTACHIO_PIN_MFIO(p)		(p)
117 #define PISTACHIO_PIN_TCK		90
118 #define PISTACHIO_PIN_TRSTN		91
119 #define PISTACHIO_PIN_TDI		92
120 #define PISTACHIO_PIN_TMS		93
121 #define PISTACHIO_PIN_TDO		94
122 #define PISTACHIO_PIN_JTAG_COMPLY	95
123 #define PISTACHIO_PIN_SAFE_MODE		96
124 #define PISTACHIO_PIN_POR_DISABLE	97
125 #define PISTACHIO_PIN_RESETN		98
126 
127 #define MFIO_PIN_DESC(p)	PINCTRL_PIN(PISTACHIO_PIN_MFIO(p), "mfio" #p)
128 
129 static const struct pinctrl_pin_desc pistachio_pins[] = {
130 	MFIO_PIN_DESC(0),
131 	MFIO_PIN_DESC(1),
132 	MFIO_PIN_DESC(2),
133 	MFIO_PIN_DESC(3),
134 	MFIO_PIN_DESC(4),
135 	MFIO_PIN_DESC(5),
136 	MFIO_PIN_DESC(6),
137 	MFIO_PIN_DESC(7),
138 	MFIO_PIN_DESC(8),
139 	MFIO_PIN_DESC(9),
140 	MFIO_PIN_DESC(10),
141 	MFIO_PIN_DESC(11),
142 	MFIO_PIN_DESC(12),
143 	MFIO_PIN_DESC(13),
144 	MFIO_PIN_DESC(14),
145 	MFIO_PIN_DESC(15),
146 	MFIO_PIN_DESC(16),
147 	MFIO_PIN_DESC(17),
148 	MFIO_PIN_DESC(18),
149 	MFIO_PIN_DESC(19),
150 	MFIO_PIN_DESC(20),
151 	MFIO_PIN_DESC(21),
152 	MFIO_PIN_DESC(22),
153 	MFIO_PIN_DESC(23),
154 	MFIO_PIN_DESC(24),
155 	MFIO_PIN_DESC(25),
156 	MFIO_PIN_DESC(26),
157 	MFIO_PIN_DESC(27),
158 	MFIO_PIN_DESC(28),
159 	MFIO_PIN_DESC(29),
160 	MFIO_PIN_DESC(30),
161 	MFIO_PIN_DESC(31),
162 	MFIO_PIN_DESC(32),
163 	MFIO_PIN_DESC(33),
164 	MFIO_PIN_DESC(34),
165 	MFIO_PIN_DESC(35),
166 	MFIO_PIN_DESC(36),
167 	MFIO_PIN_DESC(37),
168 	MFIO_PIN_DESC(38),
169 	MFIO_PIN_DESC(39),
170 	MFIO_PIN_DESC(40),
171 	MFIO_PIN_DESC(41),
172 	MFIO_PIN_DESC(42),
173 	MFIO_PIN_DESC(43),
174 	MFIO_PIN_DESC(44),
175 	MFIO_PIN_DESC(45),
176 	MFIO_PIN_DESC(46),
177 	MFIO_PIN_DESC(47),
178 	MFIO_PIN_DESC(48),
179 	MFIO_PIN_DESC(49),
180 	MFIO_PIN_DESC(50),
181 	MFIO_PIN_DESC(51),
182 	MFIO_PIN_DESC(52),
183 	MFIO_PIN_DESC(53),
184 	MFIO_PIN_DESC(54),
185 	MFIO_PIN_DESC(55),
186 	MFIO_PIN_DESC(56),
187 	MFIO_PIN_DESC(57),
188 	MFIO_PIN_DESC(58),
189 	MFIO_PIN_DESC(59),
190 	MFIO_PIN_DESC(60),
191 	MFIO_PIN_DESC(61),
192 	MFIO_PIN_DESC(62),
193 	MFIO_PIN_DESC(63),
194 	MFIO_PIN_DESC(64),
195 	MFIO_PIN_DESC(65),
196 	MFIO_PIN_DESC(66),
197 	MFIO_PIN_DESC(67),
198 	MFIO_PIN_DESC(68),
199 	MFIO_PIN_DESC(69),
200 	MFIO_PIN_DESC(70),
201 	MFIO_PIN_DESC(71),
202 	MFIO_PIN_DESC(72),
203 	MFIO_PIN_DESC(73),
204 	MFIO_PIN_DESC(74),
205 	MFIO_PIN_DESC(75),
206 	MFIO_PIN_DESC(76),
207 	MFIO_PIN_DESC(77),
208 	MFIO_PIN_DESC(78),
209 	MFIO_PIN_DESC(79),
210 	MFIO_PIN_DESC(80),
211 	MFIO_PIN_DESC(81),
212 	MFIO_PIN_DESC(82),
213 	MFIO_PIN_DESC(83),
214 	MFIO_PIN_DESC(84),
215 	MFIO_PIN_DESC(85),
216 	MFIO_PIN_DESC(86),
217 	MFIO_PIN_DESC(87),
218 	MFIO_PIN_DESC(88),
219 	MFIO_PIN_DESC(89),
220 	PINCTRL_PIN(PISTACHIO_PIN_TCK, "tck"),
221 	PINCTRL_PIN(PISTACHIO_PIN_TRSTN, "trstn"),
222 	PINCTRL_PIN(PISTACHIO_PIN_TDI, "tdi"),
223 	PINCTRL_PIN(PISTACHIO_PIN_TMS, "tms"),
224 	PINCTRL_PIN(PISTACHIO_PIN_TDO, "tdo"),
225 	PINCTRL_PIN(PISTACHIO_PIN_JTAG_COMPLY, "jtag_comply"),
226 	PINCTRL_PIN(PISTACHIO_PIN_SAFE_MODE, "safe_mode"),
227 	PINCTRL_PIN(PISTACHIO_PIN_POR_DISABLE, "por_disable"),
228 	PINCTRL_PIN(PISTACHIO_PIN_RESETN, "resetn"),
229 };
230 
231 static const char * const pistachio_spim0_groups[] = {
232 	"mfio1", "mfio2", "mfio8", "mfio9", "mfio10", "mfio28", "mfio29",
233 	"mfio30", "mfio55", "mfio56", "mfio57",
234 };
235 
236 static const char * const pistachio_spim1_groups[] = {
237 	"mfio0", "mfio1", "mfio2", "mfio3", "mfio4", "mfio5", "mfio6",
238 	"mfio7", "mfio31", "mfio55", "mfio56", "mfio57", "mfio58",
239 };
240 
241 static const char * const pistachio_spis_groups[] = {
242 	"mfio11", "mfio12", "mfio13", "mfio14",
243 };
244 
245 static const char *const pistachio_sdhost_groups[] = {
246 	"mfio15", "mfio16", "mfio17", "mfio18", "mfio19", "mfio20",
247 	"mfio21", "mfio22", "mfio23", "mfio24", "mfio25", "mfio26",
248 	"mfio27",
249 };
250 
251 static const char * const pistachio_i2c0_groups[] = {
252 	"mfio28", "mfio29",
253 };
254 
255 static const char * const pistachio_i2c1_groups[] = {
256 	"mfio30", "mfio31",
257 };
258 
259 static const char * const pistachio_i2c2_groups[] = {
260 	"mfio32", "mfio33",
261 };
262 
263 static const char * const pistachio_i2c3_groups[] = {
264 	"mfio34", "mfio35",
265 };
266 
267 static const char * const pistachio_audio_clk_in_groups[] = {
268 	"mfio36",
269 };
270 
271 static const char * const pistachio_i2s_out_groups[] = {
272 	"mfio36", "mfio37", "mfio38", "mfio39", "mfio40", "mfio41",
273 	"mfio42", "mfio43", "mfio44",
274 };
275 
276 static const char * const pistachio_debug_raw_cca_ind_groups[] = {
277 	"mfio37",
278 };
279 
280 static const char * const pistachio_debug_ed_sec20_cca_ind_groups[] = {
281 	"mfio38",
282 };
283 
284 static const char * const pistachio_debug_ed_sec40_cca_ind_groups[] = {
285 	"mfio39",
286 };
287 
288 static const char * const pistachio_debug_agc_done_0_groups[] = {
289 	"mfio40",
290 };
291 
292 static const char * const pistachio_debug_agc_done_1_groups[] = {
293 	"mfio41",
294 };
295 
296 static const char * const pistachio_debug_ed_cca_ind_groups[] = {
297 	"mfio42",
298 };
299 
300 static const char * const pistachio_debug_s2l_done_groups[] = {
301 	"mfio43",
302 };
303 
304 static const char * const pistachio_i2s_dac_clk_groups[] = {
305 	"mfio45",
306 };
307 
308 static const char * const pistachio_audio_sync_groups[] = {
309 	"mfio45",
310 };
311 
312 static const char * const pistachio_audio_trigger_groups[] = {
313 	"mfio46",
314 };
315 
316 static const char * const pistachio_i2s_in_groups[] = {
317 	"mfio47", "mfio48", "mfio49", "mfio50", "mfio51", "mfio52",
318 	"mfio53", "mfio54",
319 };
320 
321 static const char * const pistachio_uart0_groups[] = {
322 	"mfio55", "mfio56", "mfio57", "mfio58",
323 };
324 
325 static const char * const pistachio_uart1_groups[] = {
326 	"mfio59", "mfio60", "mfio1", "mfio2",
327 };
328 
329 static const char * const pistachio_spdif_out_groups[] = {
330 	"mfio61",
331 };
332 
333 static const char * const pistachio_spdif_in_groups[] = {
334 	"mfio62", "mfio54",
335 };
336 static const int pistachio_spdif_in_scenarios[] = {
337 	PISTACHIO_PIN_MFIO(62),
338 	PISTACHIO_PIN_MFIO(54),
339 };
340 
341 static const char * const pistachio_eth_groups[] = {
342 	"mfio63", "mfio64", "mfio65", "mfio66", "mfio67", "mfio68",
343 	"mfio69", "mfio70", "mfio71",
344 };
345 
346 static const char * const pistachio_ir_groups[] = {
347 	"mfio72",
348 };
349 
350 static const char * const pistachio_pwmpdm_groups[] = {
351 	"mfio73", "mfio74", "mfio75", "mfio76",
352 };
353 
354 static const char * const pistachio_mips_trace_clk_groups[] = {
355 	"mfio15", "mfio63", "mfio73",
356 };
357 
358 static const char * const pistachio_mips_trace_dint_groups[] = {
359 	"mfio16", "mfio64", "mfio74",
360 };
361 static const int pistachio_mips_trace_dint_scenarios[] = {
362 	PISTACHIO_PIN_MFIO(16),
363 	PISTACHIO_PIN_MFIO(64),
364 	PISTACHIO_PIN_MFIO(74),
365 };
366 
367 static const char * const pistachio_mips_trace_trigout_groups[] = {
368 	"mfio17", "mfio65", "mfio75",
369 };
370 
371 static const char * const pistachio_mips_trace_trigin_groups[] = {
372 	"mfio18", "mfio66", "mfio76",
373 };
374 static const int pistachio_mips_trace_trigin_scenarios[] = {
375 	PISTACHIO_PIN_MFIO(18),
376 	PISTACHIO_PIN_MFIO(66),
377 	PISTACHIO_PIN_MFIO(76),
378 };
379 
380 static const char * const pistachio_mips_trace_dm_groups[] = {
381 	"mfio19", "mfio67", "mfio77",
382 };
383 
384 static const char * const pistachio_mips_probe_n_groups[] = {
385 	"mfio20", "mfio68", "mfio78",
386 };
387 static const int pistachio_mips_probe_n_scenarios[] = {
388 	PISTACHIO_PIN_MFIO(20),
389 	PISTACHIO_PIN_MFIO(68),
390 	PISTACHIO_PIN_MFIO(78),
391 };
392 
393 static const char * const pistachio_mips_trace_data_groups[] = {
394 	"mfio15", "mfio16", "mfio17", "mfio18", "mfio19", "mfio20",
395 	"mfio21", "mfio22", "mfio63", "mfio64", "mfio65", "mfio66",
396 	"mfio67", "mfio68", "mfio69", "mfio70", "mfio79", "mfio80",
397 	"mfio81", "mfio82", "mfio83", "mfio84", "mfio85", "mfio86",
398 };
399 
400 static const char * const pistachio_sram_debug_groups[] = {
401 	"mfio73", "mfio74",
402 };
403 
404 static const char * const pistachio_rom_debug_groups[] = {
405 	"mfio75", "mfio76",
406 };
407 
408 static const char * const pistachio_rpu_debug_groups[] = {
409 	"mfio77", "mfio78",
410 };
411 
412 static const char * const pistachio_mips_debug_groups[] = {
413 	"mfio79", "mfio80",
414 };
415 
416 static const char * const pistachio_eth_debug_groups[] = {
417 	"mfio81", "mfio82",
418 };
419 
420 static const char * const pistachio_usb_debug_groups[] = {
421 	"mfio83", "mfio84",
422 };
423 
424 static const char * const pistachio_sdhost_debug_groups[] = {
425 	"mfio85", "mfio86",
426 };
427 
428 static const char * const pistachio_socif_debug_groups[] = {
429 	"mfio87", "mfio88",
430 };
431 
432 static const char * const pistachio_mdc_debug_groups[] = {
433 	"mfio77", "mfio78",
434 };
435 
436 static const char * const pistachio_ddr_debug_groups[] = {
437 	"mfio79", "mfio80",
438 };
439 
440 static const char * const pistachio_dreq0_groups[] = {
441 	"mfio81",
442 };
443 
444 static const char * const pistachio_dreq1_groups[] = {
445 	"mfio82",
446 };
447 
448 static const char * const pistachio_dreq2_groups[] = {
449 	"mfio87",
450 };
451 
452 static const char * const pistachio_dreq3_groups[] = {
453 	"mfio88",
454 };
455 
456 static const char * const pistachio_dreq4_groups[] = {
457 	"mfio89",
458 };
459 
460 static const char * const pistachio_dreq5_groups[] = {
461 	"mfio89",
462 };
463 
464 static const char * const pistachio_mips_pll_lock_groups[] = {
465 	"mfio83",
466 };
467 
468 static const char * const pistachio_audio_pll_lock_groups[] = {
469 	"mfio84",
470 };
471 
472 static const char * const pistachio_rpu_v_pll_lock_groups[] = {
473 	"mfio85",
474 };
475 
476 static const char * const pistachio_rpu_l_pll_lock_groups[] = {
477 	"mfio86",
478 };
479 
480 static const char * const pistachio_sys_pll_lock_groups[] = {
481 	"mfio87",
482 };
483 
484 static const char * const pistachio_wifi_pll_lock_groups[] = {
485 	"mfio88",
486 };
487 
488 static const char * const pistachio_bt_pll_lock_groups[] = {
489 	"mfio89",
490 };
491 
492 #define FUNCTION(_name)							\
493 	{								\
494 		.name = #_name,						\
495 		.groups = pistachio_##_name##_groups,			\
496 		.ngroups = ARRAY_SIZE(pistachio_##_name##_groups),	\
497 	}
498 
499 #define FUNCTION_SCENARIO(_name, _reg, _shift, _mask)			\
500 	{								\
501 		.name = #_name,						\
502 		.groups = pistachio_##_name##_groups,			\
503 		.ngroups = ARRAY_SIZE(pistachio_##_name##_groups),	\
504 		.scenarios = pistachio_##_name##_scenarios,		\
505 		.nscenarios = ARRAY_SIZE(pistachio_##_name##_scenarios),\
506 		.scenario_reg = _reg,					\
507 		.scenario_shift = _shift,				\
508 		.scenario_mask = _mask,					\
509 	}
510 
511 enum pistachio_mux_option {
512 	PISTACHIO_FUNCTION_NONE = -1,
513 	PISTACHIO_FUNCTION_SPIM0,
514 	PISTACHIO_FUNCTION_SPIM1,
515 	PISTACHIO_FUNCTION_SPIS,
516 	PISTACHIO_FUNCTION_SDHOST,
517 	PISTACHIO_FUNCTION_I2C0,
518 	PISTACHIO_FUNCTION_I2C1,
519 	PISTACHIO_FUNCTION_I2C2,
520 	PISTACHIO_FUNCTION_I2C3,
521 	PISTACHIO_FUNCTION_AUDIO_CLK_IN,
522 	PISTACHIO_FUNCTION_I2S_OUT,
523 	PISTACHIO_FUNCTION_I2S_DAC_CLK,
524 	PISTACHIO_FUNCTION_AUDIO_SYNC,
525 	PISTACHIO_FUNCTION_AUDIO_TRIGGER,
526 	PISTACHIO_FUNCTION_I2S_IN,
527 	PISTACHIO_FUNCTION_UART0,
528 	PISTACHIO_FUNCTION_UART1,
529 	PISTACHIO_FUNCTION_SPDIF_OUT,
530 	PISTACHIO_FUNCTION_SPDIF_IN,
531 	PISTACHIO_FUNCTION_ETH,
532 	PISTACHIO_FUNCTION_IR,
533 	PISTACHIO_FUNCTION_PWMPDM,
534 	PISTACHIO_FUNCTION_MIPS_TRACE_CLK,
535 	PISTACHIO_FUNCTION_MIPS_TRACE_DINT,
536 	PISTACHIO_FUNCTION_MIPS_TRACE_TRIGOUT,
537 	PISTACHIO_FUNCTION_MIPS_TRACE_TRIGIN,
538 	PISTACHIO_FUNCTION_MIPS_TRACE_DM,
539 	PISTACHIO_FUNCTION_MIPS_TRACE_PROBE_N,
540 	PISTACHIO_FUNCTION_MIPS_TRACE_DATA,
541 	PISTACHIO_FUNCTION_SRAM_DEBUG,
542 	PISTACHIO_FUNCTION_ROM_DEBUG,
543 	PISTACHIO_FUNCTION_RPU_DEBUG,
544 	PISTACHIO_FUNCTION_MIPS_DEBUG,
545 	PISTACHIO_FUNCTION_ETH_DEBUG,
546 	PISTACHIO_FUNCTION_USB_DEBUG,
547 	PISTACHIO_FUNCTION_SDHOST_DEBUG,
548 	PISTACHIO_FUNCTION_SOCIF_DEBUG,
549 	PISTACHIO_FUNCTION_MDC_DEBUG,
550 	PISTACHIO_FUNCTION_DDR_DEBUG,
551 	PISTACHIO_FUNCTION_DREQ0,
552 	PISTACHIO_FUNCTION_DREQ1,
553 	PISTACHIO_FUNCTION_DREQ2,
554 	PISTACHIO_FUNCTION_DREQ3,
555 	PISTACHIO_FUNCTION_DREQ4,
556 	PISTACHIO_FUNCTION_DREQ5,
557 	PISTACHIO_FUNCTION_MIPS_PLL_LOCK,
558 	PISTACHIO_FUNCTION_AUDIO_PLL_LOCK,
559 	PISTACHIO_FUNCTION_RPU_V_PLL_LOCK,
560 	PISTACHIO_FUNCTION_RPU_L_PLL_LOCK,
561 	PISTACHIO_FUNCTION_SYS_PLL_LOCK,
562 	PISTACHIO_FUNCTION_WIFI_PLL_LOCK,
563 	PISTACHIO_FUNCTION_BT_PLL_LOCK,
564 	PISTACHIO_FUNCTION_DEBUG_RAW_CCA_IND,
565 	PISTACHIO_FUNCTION_DEBUG_ED_SEC20_CCA_IND,
566 	PISTACHIO_FUNCTION_DEBUG_ED_SEC40_CCA_IND,
567 	PISTACHIO_FUNCTION_DEBUG_AGC_DONE_0,
568 	PISTACHIO_FUNCTION_DEBUG_AGC_DONE_1,
569 	PISTACHIO_FUNCTION_DEBUG_ED_CCA_IND,
570 	PISTACHIO_FUNCTION_DEBUG_S2L_DONE,
571 };
572 
573 static const struct pistachio_function pistachio_functions[] = {
574 	FUNCTION(spim0),
575 	FUNCTION(spim1),
576 	FUNCTION(spis),
577 	FUNCTION(sdhost),
578 	FUNCTION(i2c0),
579 	FUNCTION(i2c1),
580 	FUNCTION(i2c2),
581 	FUNCTION(i2c3),
582 	FUNCTION(audio_clk_in),
583 	FUNCTION(i2s_out),
584 	FUNCTION(i2s_dac_clk),
585 	FUNCTION(audio_sync),
586 	FUNCTION(audio_trigger),
587 	FUNCTION(i2s_in),
588 	FUNCTION(uart0),
589 	FUNCTION(uart1),
590 	FUNCTION(spdif_out),
591 	FUNCTION_SCENARIO(spdif_in, PADS_SCENARIO_SELECT, 0, 0x1),
592 	FUNCTION(eth),
593 	FUNCTION(ir),
594 	FUNCTION(pwmpdm),
595 	FUNCTION(mips_trace_clk),
596 	FUNCTION_SCENARIO(mips_trace_dint, PADS_SCENARIO_SELECT, 1, 0x3),
597 	FUNCTION(mips_trace_trigout),
598 	FUNCTION_SCENARIO(mips_trace_trigin, PADS_SCENARIO_SELECT, 3, 0x3),
599 	FUNCTION(mips_trace_dm),
600 	FUNCTION_SCENARIO(mips_probe_n, PADS_SCENARIO_SELECT, 5, 0x3),
601 	FUNCTION(mips_trace_data),
602 	FUNCTION(sram_debug),
603 	FUNCTION(rom_debug),
604 	FUNCTION(rpu_debug),
605 	FUNCTION(mips_debug),
606 	FUNCTION(eth_debug),
607 	FUNCTION(usb_debug),
608 	FUNCTION(sdhost_debug),
609 	FUNCTION(socif_debug),
610 	FUNCTION(mdc_debug),
611 	FUNCTION(ddr_debug),
612 	FUNCTION(dreq0),
613 	FUNCTION(dreq1),
614 	FUNCTION(dreq2),
615 	FUNCTION(dreq3),
616 	FUNCTION(dreq4),
617 	FUNCTION(dreq5),
618 	FUNCTION(mips_pll_lock),
619 	FUNCTION(audio_pll_lock),
620 	FUNCTION(rpu_v_pll_lock),
621 	FUNCTION(rpu_l_pll_lock),
622 	FUNCTION(sys_pll_lock),
623 	FUNCTION(wifi_pll_lock),
624 	FUNCTION(bt_pll_lock),
625 	FUNCTION(debug_raw_cca_ind),
626 	FUNCTION(debug_ed_sec20_cca_ind),
627 	FUNCTION(debug_ed_sec40_cca_ind),
628 	FUNCTION(debug_agc_done_0),
629 	FUNCTION(debug_agc_done_1),
630 	FUNCTION(debug_ed_cca_ind),
631 	FUNCTION(debug_s2l_done),
632 };
633 
634 #define PIN_GROUP(_pin, _name)					\
635 	{							\
636 		.name = #_name,					\
637 		.pin = PISTACHIO_PIN_##_pin,			\
638 		.mux_option = {					\
639 			PISTACHIO_FUNCTION_NONE,		\
640 			PISTACHIO_FUNCTION_NONE,		\
641 			PISTACHIO_FUNCTION_NONE,		\
642 		},						\
643 		.mux_reg = -1,					\
644 		.mux_shift = -1,				\
645 		.mux_mask = -1,					\
646 	}
647 
648 #define MFIO_PIN_GROUP(_pin, _func)				\
649 	{							\
650 		.name = "mfio" #_pin,				\
651 		.pin = PISTACHIO_PIN_MFIO(_pin),		\
652 		.mux_option = {					\
653 			PISTACHIO_FUNCTION_##_func,		\
654 			PISTACHIO_FUNCTION_NONE,		\
655 			PISTACHIO_FUNCTION_NONE,		\
656 		},						\
657 		.mux_reg = -1,					\
658 		.mux_shift = -1,				\
659 		.mux_mask = -1,					\
660 	}
661 
662 #define MFIO_MUX_PIN_GROUP(_pin, _f0, _f1, _f2, _reg, _shift, _mask)	\
663 	{								\
664 		.name = "mfio" #_pin,					\
665 		.pin = PISTACHIO_PIN_MFIO(_pin),			\
666 		.mux_option = {						\
667 			PISTACHIO_FUNCTION_##_f0,			\
668 			PISTACHIO_FUNCTION_##_f1,			\
669 			PISTACHIO_FUNCTION_##_f2,			\
670 		},							\
671 		.mux_reg = _reg,					\
672 		.mux_shift = _shift,					\
673 		.mux_mask = _mask,					\
674 	}
675 
676 static const struct pistachio_pin_group pistachio_groups[] = {
677 	MFIO_PIN_GROUP(0, SPIM1),
678 	MFIO_MUX_PIN_GROUP(1, SPIM1, SPIM0, UART1,
679 			   PADS_FUNCTION_SELECT0, 0, 0x3),
680 	MFIO_MUX_PIN_GROUP(2, SPIM1, SPIM0, UART1,
681 			   PADS_FUNCTION_SELECT0, 2, 0x3),
682 	MFIO_PIN_GROUP(3, SPIM1),
683 	MFIO_PIN_GROUP(4, SPIM1),
684 	MFIO_PIN_GROUP(5, SPIM1),
685 	MFIO_PIN_GROUP(6, SPIM1),
686 	MFIO_PIN_GROUP(7, SPIM1),
687 	MFIO_PIN_GROUP(8, SPIM0),
688 	MFIO_PIN_GROUP(9, SPIM0),
689 	MFIO_PIN_GROUP(10, SPIM0),
690 	MFIO_PIN_GROUP(11, SPIS),
691 	MFIO_PIN_GROUP(12, SPIS),
692 	MFIO_PIN_GROUP(13, SPIS),
693 	MFIO_PIN_GROUP(14, SPIS),
694 	MFIO_MUX_PIN_GROUP(15, SDHOST, MIPS_TRACE_CLK, MIPS_TRACE_DATA,
695 			   PADS_FUNCTION_SELECT0, 4, 0x3),
696 	MFIO_MUX_PIN_GROUP(16, SDHOST, MIPS_TRACE_DINT, MIPS_TRACE_DATA,
697 			   PADS_FUNCTION_SELECT0, 6, 0x3),
698 	MFIO_MUX_PIN_GROUP(17, SDHOST, MIPS_TRACE_TRIGOUT, MIPS_TRACE_DATA,
699 			   PADS_FUNCTION_SELECT0, 8, 0x3),
700 	MFIO_MUX_PIN_GROUP(18, SDHOST, MIPS_TRACE_TRIGIN, MIPS_TRACE_DATA,
701 			   PADS_FUNCTION_SELECT0, 10, 0x3),
702 	MFIO_MUX_PIN_GROUP(19, SDHOST, MIPS_TRACE_DM, MIPS_TRACE_DATA,
703 			   PADS_FUNCTION_SELECT0, 12, 0x3),
704 	MFIO_MUX_PIN_GROUP(20, SDHOST, MIPS_TRACE_PROBE_N, MIPS_TRACE_DATA,
705 			   PADS_FUNCTION_SELECT0, 14, 0x3),
706 	MFIO_MUX_PIN_GROUP(21, SDHOST, NONE, MIPS_TRACE_DATA,
707 			   PADS_FUNCTION_SELECT0, 16, 0x3),
708 	MFIO_MUX_PIN_GROUP(22, SDHOST, NONE, MIPS_TRACE_DATA,
709 			   PADS_FUNCTION_SELECT0, 18, 0x3),
710 	MFIO_PIN_GROUP(23, SDHOST),
711 	MFIO_PIN_GROUP(24, SDHOST),
712 	MFIO_PIN_GROUP(25, SDHOST),
713 	MFIO_PIN_GROUP(26, SDHOST),
714 	MFIO_PIN_GROUP(27, SDHOST),
715 	MFIO_MUX_PIN_GROUP(28, I2C0, SPIM0, NONE,
716 			   PADS_FUNCTION_SELECT0, 20, 0x1),
717 	MFIO_MUX_PIN_GROUP(29, I2C0, SPIM0, NONE,
718 			   PADS_FUNCTION_SELECT0, 21, 0x1),
719 	MFIO_MUX_PIN_GROUP(30, I2C1, SPIM0, NONE,
720 			   PADS_FUNCTION_SELECT0, 22, 0x1),
721 	MFIO_MUX_PIN_GROUP(31, I2C1, SPIM1, NONE,
722 			   PADS_FUNCTION_SELECT0, 23, 0x1),
723 	MFIO_PIN_GROUP(32, I2C2),
724 	MFIO_PIN_GROUP(33, I2C2),
725 	MFIO_PIN_GROUP(34, I2C3),
726 	MFIO_PIN_GROUP(35, I2C3),
727 	MFIO_MUX_PIN_GROUP(36, I2S_OUT, AUDIO_CLK_IN, NONE,
728 			   PADS_FUNCTION_SELECT0, 24, 0x1),
729 	MFIO_MUX_PIN_GROUP(37, I2S_OUT, DEBUG_RAW_CCA_IND, NONE,
730 			   PADS_FUNCTION_SELECT0, 25, 0x1),
731 	MFIO_MUX_PIN_GROUP(38, I2S_OUT, DEBUG_ED_SEC20_CCA_IND, NONE,
732 			   PADS_FUNCTION_SELECT0, 26, 0x1),
733 	MFIO_MUX_PIN_GROUP(39, I2S_OUT, DEBUG_ED_SEC40_CCA_IND, NONE,
734 			   PADS_FUNCTION_SELECT0, 27, 0x1),
735 	MFIO_MUX_PIN_GROUP(40, I2S_OUT, DEBUG_AGC_DONE_0, NONE,
736 			   PADS_FUNCTION_SELECT0, 28, 0x1),
737 	MFIO_MUX_PIN_GROUP(41, I2S_OUT, DEBUG_AGC_DONE_1, NONE,
738 			   PADS_FUNCTION_SELECT0, 29, 0x1),
739 	MFIO_MUX_PIN_GROUP(42, I2S_OUT, DEBUG_ED_CCA_IND, NONE,
740 			   PADS_FUNCTION_SELECT0, 30, 0x1),
741 	MFIO_MUX_PIN_GROUP(43, I2S_OUT, DEBUG_S2L_DONE, NONE,
742 			   PADS_FUNCTION_SELECT0, 31, 0x1),
743 	MFIO_PIN_GROUP(44, I2S_OUT),
744 	MFIO_MUX_PIN_GROUP(45, I2S_DAC_CLK, AUDIO_SYNC, NONE,
745 			   PADS_FUNCTION_SELECT1, 0, 0x1),
746 	MFIO_PIN_GROUP(46, AUDIO_TRIGGER),
747 	MFIO_PIN_GROUP(47, I2S_IN),
748 	MFIO_PIN_GROUP(48, I2S_IN),
749 	MFIO_PIN_GROUP(49, I2S_IN),
750 	MFIO_PIN_GROUP(50, I2S_IN),
751 	MFIO_PIN_GROUP(51, I2S_IN),
752 	MFIO_PIN_GROUP(52, I2S_IN),
753 	MFIO_PIN_GROUP(53, I2S_IN),
754 	MFIO_MUX_PIN_GROUP(54, I2S_IN, NONE, SPDIF_IN,
755 			   PADS_FUNCTION_SELECT1, 1, 0x3),
756 	MFIO_MUX_PIN_GROUP(55, UART0, SPIM0, SPIM1,
757 			   PADS_FUNCTION_SELECT1, 3, 0x3),
758 	MFIO_MUX_PIN_GROUP(56, UART0, SPIM0, SPIM1,
759 			   PADS_FUNCTION_SELECT1, 5, 0x3),
760 	MFIO_MUX_PIN_GROUP(57, UART0, SPIM0, SPIM1,
761 			   PADS_FUNCTION_SELECT1, 7, 0x3),
762 	MFIO_MUX_PIN_GROUP(58, UART0, SPIM1, NONE,
763 			   PADS_FUNCTION_SELECT1, 9, 0x1),
764 	MFIO_PIN_GROUP(59, UART1),
765 	MFIO_PIN_GROUP(60, UART1),
766 	MFIO_PIN_GROUP(61, SPDIF_OUT),
767 	MFIO_PIN_GROUP(62, SPDIF_IN),
768 	MFIO_MUX_PIN_GROUP(63, ETH, MIPS_TRACE_CLK, MIPS_TRACE_DATA,
769 			   PADS_FUNCTION_SELECT1, 10, 0x3),
770 	MFIO_MUX_PIN_GROUP(64, ETH, MIPS_TRACE_DINT, MIPS_TRACE_DATA,
771 			   PADS_FUNCTION_SELECT1, 12, 0x3),
772 	MFIO_MUX_PIN_GROUP(65, ETH, MIPS_TRACE_TRIGOUT, MIPS_TRACE_DATA,
773 			   PADS_FUNCTION_SELECT1, 14, 0x3),
774 	MFIO_MUX_PIN_GROUP(66, ETH, MIPS_TRACE_TRIGIN, MIPS_TRACE_DATA,
775 			   PADS_FUNCTION_SELECT1, 16, 0x3),
776 	MFIO_MUX_PIN_GROUP(67, ETH, MIPS_TRACE_DM, MIPS_TRACE_DATA,
777 			   PADS_FUNCTION_SELECT1, 18, 0x3),
778 	MFIO_MUX_PIN_GROUP(68, ETH, MIPS_TRACE_PROBE_N, MIPS_TRACE_DATA,
779 			   PADS_FUNCTION_SELECT1, 20, 0x3),
780 	MFIO_MUX_PIN_GROUP(69, ETH, NONE, MIPS_TRACE_DATA,
781 			   PADS_FUNCTION_SELECT1, 22, 0x3),
782 	MFIO_MUX_PIN_GROUP(70, ETH, NONE, MIPS_TRACE_DATA,
783 			   PADS_FUNCTION_SELECT1, 24, 0x3),
784 	MFIO_PIN_GROUP(71, ETH),
785 	MFIO_PIN_GROUP(72, IR),
786 	MFIO_MUX_PIN_GROUP(73, PWMPDM, MIPS_TRACE_CLK, SRAM_DEBUG,
787 			   PADS_FUNCTION_SELECT1, 26, 0x3),
788 	MFIO_MUX_PIN_GROUP(74, PWMPDM, MIPS_TRACE_DINT, SRAM_DEBUG,
789 			   PADS_FUNCTION_SELECT1, 28, 0x3),
790 	MFIO_MUX_PIN_GROUP(75, PWMPDM, MIPS_TRACE_TRIGOUT, ROM_DEBUG,
791 			   PADS_FUNCTION_SELECT1, 30, 0x3),
792 	MFIO_MUX_PIN_GROUP(76, PWMPDM, MIPS_TRACE_TRIGIN, ROM_DEBUG,
793 			   PADS_FUNCTION_SELECT2, 0, 0x3),
794 	MFIO_MUX_PIN_GROUP(77, MDC_DEBUG, MIPS_TRACE_DM, RPU_DEBUG,
795 			   PADS_FUNCTION_SELECT2, 2, 0x3),
796 	MFIO_MUX_PIN_GROUP(78, MDC_DEBUG, MIPS_TRACE_PROBE_N, RPU_DEBUG,
797 			   PADS_FUNCTION_SELECT2, 4, 0x3),
798 	MFIO_MUX_PIN_GROUP(79, DDR_DEBUG, MIPS_TRACE_DATA, MIPS_DEBUG,
799 			   PADS_FUNCTION_SELECT2, 6, 0x3),
800 	MFIO_MUX_PIN_GROUP(80, DDR_DEBUG, MIPS_TRACE_DATA, MIPS_DEBUG,
801 			   PADS_FUNCTION_SELECT2, 8, 0x3),
802 	MFIO_MUX_PIN_GROUP(81, DREQ0, MIPS_TRACE_DATA, ETH_DEBUG,
803 			   PADS_FUNCTION_SELECT2, 10, 0x3),
804 	MFIO_MUX_PIN_GROUP(82, DREQ1, MIPS_TRACE_DATA, ETH_DEBUG,
805 			   PADS_FUNCTION_SELECT2, 12, 0x3),
806 	MFIO_MUX_PIN_GROUP(83, MIPS_PLL_LOCK, MIPS_TRACE_DATA, USB_DEBUG,
807 			   PADS_FUNCTION_SELECT2, 14, 0x3),
808 	MFIO_MUX_PIN_GROUP(84, AUDIO_PLL_LOCK, MIPS_TRACE_DATA, USB_DEBUG,
809 			   PADS_FUNCTION_SELECT2, 16, 0x3),
810 	MFIO_MUX_PIN_GROUP(85, RPU_V_PLL_LOCK, MIPS_TRACE_DATA, SDHOST_DEBUG,
811 			   PADS_FUNCTION_SELECT2, 18, 0x3),
812 	MFIO_MUX_PIN_GROUP(86, RPU_L_PLL_LOCK, MIPS_TRACE_DATA, SDHOST_DEBUG,
813 			   PADS_FUNCTION_SELECT2, 20, 0x3),
814 	MFIO_MUX_PIN_GROUP(87, SYS_PLL_LOCK, DREQ2, SOCIF_DEBUG,
815 			   PADS_FUNCTION_SELECT2, 22, 0x3),
816 	MFIO_MUX_PIN_GROUP(88, WIFI_PLL_LOCK, DREQ3, SOCIF_DEBUG,
817 			   PADS_FUNCTION_SELECT2, 24, 0x3),
818 	MFIO_MUX_PIN_GROUP(89, BT_PLL_LOCK, DREQ4, DREQ5,
819 			   PADS_FUNCTION_SELECT2, 26, 0x3),
820 	PIN_GROUP(TCK, "tck"),
821 	PIN_GROUP(TRSTN, "trstn"),
822 	PIN_GROUP(TDI, "tdi"),
823 	PIN_GROUP(TMS, "tms"),
824 	PIN_GROUP(TDO, "tdo"),
825 	PIN_GROUP(JTAG_COMPLY, "jtag_comply"),
826 	PIN_GROUP(SAFE_MODE, "safe_mode"),
827 	PIN_GROUP(POR_DISABLE, "por_disable"),
828 	PIN_GROUP(RESETN, "resetn"),
829 };
830 
831 static inline u32 pctl_readl(struct pistachio_pinctrl *pctl, u32 reg)
832 {
833 	return readl(pctl->base + reg);
834 }
835 
836 static inline void pctl_writel(struct pistachio_pinctrl *pctl, u32 val, u32 reg)
837 {
838 	writel(val, pctl->base + reg);
839 }
840 
841 static inline struct pistachio_gpio_bank *irqd_to_bank(struct irq_data *d)
842 {
843 	return gpiochip_get_data(irq_data_get_irq_chip_data(d));
844 }
845 
846 static inline u32 gpio_readl(struct pistachio_gpio_bank *bank, u32 reg)
847 {
848 	return readl(bank->base + reg);
849 }
850 
851 static inline void gpio_writel(struct pistachio_gpio_bank *bank, u32 val,
852 			       u32 reg)
853 {
854 	writel(val, bank->base + reg);
855 }
856 
857 static inline void gpio_mask_writel(struct pistachio_gpio_bank *bank,
858 				    u32 reg, unsigned int bit, u32 val)
859 {
860 	/*
861 	 * For most of the GPIO registers, bit 16 + X must be set in order to
862 	 * write bit X.
863 	 */
864 	gpio_writel(bank, (0x10000 | val) << bit, reg);
865 }
866 
867 static inline void gpio_enable(struct pistachio_gpio_bank *bank,
868 			       unsigned offset)
869 {
870 	gpio_mask_writel(bank, GPIO_BIT_EN, offset, 1);
871 }
872 
873 static inline void gpio_disable(struct pistachio_gpio_bank *bank,
874 				unsigned offset)
875 {
876 	gpio_mask_writel(bank, GPIO_BIT_EN, offset, 0);
877 }
878 
879 static int pistachio_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
880 {
881 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
882 
883 	return pctl->ngroups;
884 }
885 
886 static const char *pistachio_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
887 						    unsigned group)
888 {
889 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
890 
891 	return pctl->groups[group].name;
892 }
893 
894 static int pistachio_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
895 					    unsigned group,
896 					    const unsigned **pins,
897 					    unsigned *num_pins)
898 {
899 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
900 
901 	*pins = &pctl->groups[group].pin;
902 	*num_pins = 1;
903 
904 	return 0;
905 }
906 
907 static const struct pinctrl_ops pistachio_pinctrl_ops = {
908 	.get_groups_count = pistachio_pinctrl_get_groups_count,
909 	.get_group_name = pistachio_pinctrl_get_group_name,
910 	.get_group_pins = pistachio_pinctrl_get_group_pins,
911 	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
912 	.dt_free_map = pinctrl_utils_free_map,
913 };
914 
915 static int pistachio_pinmux_get_functions_count(struct pinctrl_dev *pctldev)
916 {
917 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
918 
919 	return pctl->nfunctions;
920 }
921 
922 static const char *
923 pistachio_pinmux_get_function_name(struct pinctrl_dev *pctldev, unsigned func)
924 {
925 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
926 
927 	return pctl->functions[func].name;
928 }
929 
930 static int pistachio_pinmux_get_function_groups(struct pinctrl_dev *pctldev,
931 						unsigned func,
932 						const char * const **groups,
933 						unsigned * const num_groups)
934 {
935 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
936 
937 	*groups = pctl->functions[func].groups;
938 	*num_groups = pctl->functions[func].ngroups;
939 
940 	return 0;
941 }
942 
943 static int pistachio_pinmux_enable(struct pinctrl_dev *pctldev,
944 				   unsigned func, unsigned group)
945 {
946 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
947 	const struct pistachio_pin_group *pg = &pctl->groups[group];
948 	const struct pistachio_function *pf = &pctl->functions[func];
949 	struct pinctrl_gpio_range *range;
950 	unsigned int i;
951 	u32 val;
952 
953 	if (pg->mux_reg > 0) {
954 		for (i = 0; i < ARRAY_SIZE(pg->mux_option); i++) {
955 			if (pg->mux_option[i] == func)
956 				break;
957 		}
958 		if (i == ARRAY_SIZE(pg->mux_option)) {
959 			dev_err(pctl->dev, "Cannot mux pin %u to function %u\n",
960 				group, func);
961 			return -EINVAL;
962 		}
963 
964 		val = pctl_readl(pctl, pg->mux_reg);
965 		val &= ~(pg->mux_mask << pg->mux_shift);
966 		val |= i << pg->mux_shift;
967 		pctl_writel(pctl, val, pg->mux_reg);
968 
969 		if (pf->scenarios) {
970 			for (i = 0; i < pf->nscenarios; i++) {
971 				if (pf->scenarios[i] == group)
972 					break;
973 			}
974 			if (WARN_ON(i == pf->nscenarios))
975 				return -EINVAL;
976 
977 			val = pctl_readl(pctl, pf->scenario_reg);
978 			val &= ~(pf->scenario_mask << pf->scenario_shift);
979 			val |= i << pf->scenario_shift;
980 			pctl_writel(pctl, val, pf->scenario_reg);
981 		}
982 	}
983 
984 	range = pinctrl_find_gpio_range_from_pin(pctl->pctldev, pg->pin);
985 	if (range)
986 		gpio_disable(gpiochip_get_data(range->gc), pg->pin - range->pin_base);
987 
988 	return 0;
989 }
990 
991 static const struct pinmux_ops pistachio_pinmux_ops = {
992 	.get_functions_count = pistachio_pinmux_get_functions_count,
993 	.get_function_name = pistachio_pinmux_get_function_name,
994 	.get_function_groups = pistachio_pinmux_get_function_groups,
995 	.set_mux = pistachio_pinmux_enable,
996 };
997 
998 static int pistachio_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
999 				 unsigned long *config)
1000 {
1001 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1002 	enum pin_config_param param = pinconf_to_config_param(*config);
1003 	u32 val, arg;
1004 
1005 	switch (param) {
1006 	case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
1007 		val = pctl_readl(pctl, PADS_SCHMITT_EN_REG(pin));
1008 		arg = !!(val & PADS_SCHMITT_EN_BIT(pin));
1009 		break;
1010 	case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
1011 		val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >>
1012 			PADS_PU_PD_SHIFT(pin);
1013 		arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_HIGHZ;
1014 		break;
1015 	case PIN_CONFIG_BIAS_PULL_UP:
1016 		val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >>
1017 			PADS_PU_PD_SHIFT(pin);
1018 		arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_UP;
1019 		break;
1020 	case PIN_CONFIG_BIAS_PULL_DOWN:
1021 		val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >>
1022 			PADS_PU_PD_SHIFT(pin);
1023 		arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_DOWN;
1024 		break;
1025 	case PIN_CONFIG_BIAS_BUS_HOLD:
1026 		val = pctl_readl(pctl, PADS_PU_PD_REG(pin)) >>
1027 			PADS_PU_PD_SHIFT(pin);
1028 		arg = (val & PADS_PU_PD_MASK) == PADS_PU_PD_BUS;
1029 		break;
1030 	case PIN_CONFIG_SLEW_RATE:
1031 		val = pctl_readl(pctl, PADS_SLEW_RATE_REG(pin));
1032 		arg = !!(val & PADS_SLEW_RATE_BIT(pin));
1033 		break;
1034 	case PIN_CONFIG_DRIVE_STRENGTH:
1035 		val = pctl_readl(pctl, PADS_DRIVE_STRENGTH_REG(pin)) >>
1036 			PADS_DRIVE_STRENGTH_SHIFT(pin);
1037 		switch (val & PADS_DRIVE_STRENGTH_MASK) {
1038 		case PADS_DRIVE_STRENGTH_2MA:
1039 			arg = 2;
1040 			break;
1041 		case PADS_DRIVE_STRENGTH_4MA:
1042 			arg = 4;
1043 			break;
1044 		case PADS_DRIVE_STRENGTH_8MA:
1045 			arg = 8;
1046 			break;
1047 		case PADS_DRIVE_STRENGTH_12MA:
1048 		default:
1049 			arg = 12;
1050 			break;
1051 		}
1052 		break;
1053 	default:
1054 		dev_dbg(pctl->dev, "Property %u not supported\n", param);
1055 		return -ENOTSUPP;
1056 	}
1057 
1058 	*config = pinconf_to_config_packed(param, arg);
1059 
1060 	return 0;
1061 }
1062 
1063 static int pistachio_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
1064 				 unsigned long *configs, unsigned num_configs)
1065 {
1066 	struct pistachio_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1067 	enum pin_config_param param;
1068 	u32 drv, val, arg;
1069 	unsigned int i;
1070 
1071 	for (i = 0; i < num_configs; i++) {
1072 		param = pinconf_to_config_param(configs[i]);
1073 		arg = pinconf_to_config_argument(configs[i]);
1074 
1075 		switch (param) {
1076 		case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
1077 			val = pctl_readl(pctl, PADS_SCHMITT_EN_REG(pin));
1078 			if (arg)
1079 				val |= PADS_SCHMITT_EN_BIT(pin);
1080 			else
1081 				val &= ~PADS_SCHMITT_EN_BIT(pin);
1082 			pctl_writel(pctl, val, PADS_SCHMITT_EN_REG(pin));
1083 			break;
1084 		case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
1085 			val = pctl_readl(pctl, PADS_PU_PD_REG(pin));
1086 			val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin));
1087 			val |= PADS_PU_PD_HIGHZ << PADS_PU_PD_SHIFT(pin);
1088 			pctl_writel(pctl, val, PADS_PU_PD_REG(pin));
1089 			break;
1090 		case PIN_CONFIG_BIAS_PULL_UP:
1091 			val = pctl_readl(pctl, PADS_PU_PD_REG(pin));
1092 			val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin));
1093 			val |= PADS_PU_PD_UP << PADS_PU_PD_SHIFT(pin);
1094 			pctl_writel(pctl, val, PADS_PU_PD_REG(pin));
1095 			break;
1096 		case PIN_CONFIG_BIAS_PULL_DOWN:
1097 			val = pctl_readl(pctl, PADS_PU_PD_REG(pin));
1098 			val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin));
1099 			val |= PADS_PU_PD_DOWN << PADS_PU_PD_SHIFT(pin);
1100 			pctl_writel(pctl, val, PADS_PU_PD_REG(pin));
1101 			break;
1102 		case PIN_CONFIG_BIAS_BUS_HOLD:
1103 			val = pctl_readl(pctl, PADS_PU_PD_REG(pin));
1104 			val &= ~(PADS_PU_PD_MASK << PADS_PU_PD_SHIFT(pin));
1105 			val |= PADS_PU_PD_BUS << PADS_PU_PD_SHIFT(pin);
1106 			pctl_writel(pctl, val, PADS_PU_PD_REG(pin));
1107 			break;
1108 		case PIN_CONFIG_SLEW_RATE:
1109 			val = pctl_readl(pctl, PADS_SLEW_RATE_REG(pin));
1110 			if (arg)
1111 				val |= PADS_SLEW_RATE_BIT(pin);
1112 			else
1113 				val &= ~PADS_SLEW_RATE_BIT(pin);
1114 			pctl_writel(pctl, val, PADS_SLEW_RATE_REG(pin));
1115 			break;
1116 		case PIN_CONFIG_DRIVE_STRENGTH:
1117 			val = pctl_readl(pctl, PADS_DRIVE_STRENGTH_REG(pin));
1118 			val &= ~(PADS_DRIVE_STRENGTH_MASK <<
1119 				 PADS_DRIVE_STRENGTH_SHIFT(pin));
1120 			switch (arg) {
1121 			case 2:
1122 				drv = PADS_DRIVE_STRENGTH_2MA;
1123 				break;
1124 			case 4:
1125 				drv = PADS_DRIVE_STRENGTH_4MA;
1126 				break;
1127 			case 8:
1128 				drv = PADS_DRIVE_STRENGTH_8MA;
1129 				break;
1130 			case 12:
1131 				drv = PADS_DRIVE_STRENGTH_12MA;
1132 				break;
1133 			default:
1134 				dev_err(pctl->dev,
1135 					"Drive strength %umA not supported\n",
1136 					arg);
1137 				return -EINVAL;
1138 			}
1139 			val |= drv << PADS_DRIVE_STRENGTH_SHIFT(pin);
1140 			pctl_writel(pctl, val, PADS_DRIVE_STRENGTH_REG(pin));
1141 			break;
1142 		default:
1143 			dev_err(pctl->dev, "Property %u not supported\n",
1144 				param);
1145 			return -ENOTSUPP;
1146 		}
1147 	}
1148 
1149 	return 0;
1150 }
1151 
1152 static const struct pinconf_ops pistachio_pinconf_ops = {
1153 	.pin_config_get = pistachio_pinconf_get,
1154 	.pin_config_set = pistachio_pinconf_set,
1155 	.is_generic = true,
1156 };
1157 
1158 static struct pinctrl_desc pistachio_pinctrl_desc = {
1159 	.name = "pistachio-pinctrl",
1160 	.pctlops = &pistachio_pinctrl_ops,
1161 	.pmxops = &pistachio_pinmux_ops,
1162 	.confops = &pistachio_pinconf_ops,
1163 };
1164 
1165 static int pistachio_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
1166 {
1167 	struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
1168 
1169 	if (gpio_readl(bank, GPIO_OUTPUT_EN) & BIT(offset))
1170 		return GPIO_LINE_DIRECTION_OUT;
1171 
1172 	return GPIO_LINE_DIRECTION_IN;
1173 }
1174 
1175 static int pistachio_gpio_get(struct gpio_chip *chip, unsigned offset)
1176 {
1177 	struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
1178 	u32 reg;
1179 
1180 	if (gpio_readl(bank, GPIO_OUTPUT_EN) & BIT(offset))
1181 		reg = GPIO_OUTPUT;
1182 	else
1183 		reg = GPIO_INPUT;
1184 
1185 	return !!(gpio_readl(bank, reg) & BIT(offset));
1186 }
1187 
1188 static void pistachio_gpio_set(struct gpio_chip *chip, unsigned offset,
1189 			       int value)
1190 {
1191 	struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
1192 
1193 	gpio_mask_writel(bank, GPIO_OUTPUT, offset, !!value);
1194 }
1195 
1196 static int pistachio_gpio_direction_input(struct gpio_chip *chip,
1197 					  unsigned offset)
1198 {
1199 	struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
1200 
1201 	gpio_mask_writel(bank, GPIO_OUTPUT_EN, offset, 0);
1202 	gpio_enable(bank, offset);
1203 
1204 	return 0;
1205 }
1206 
1207 static int pistachio_gpio_direction_output(struct gpio_chip *chip,
1208 					   unsigned offset, int value)
1209 {
1210 	struct pistachio_gpio_bank *bank = gpiochip_get_data(chip);
1211 
1212 	pistachio_gpio_set(chip, offset, value);
1213 	gpio_mask_writel(bank, GPIO_OUTPUT_EN, offset, 1);
1214 	gpio_enable(bank, offset);
1215 
1216 	return 0;
1217 }
1218 
1219 static void pistachio_gpio_irq_ack(struct irq_data *data)
1220 {
1221 	struct pistachio_gpio_bank *bank = irqd_to_bank(data);
1222 
1223 	gpio_mask_writel(bank, GPIO_INTERRUPT_STATUS, data->hwirq, 0);
1224 }
1225 
1226 static void pistachio_gpio_irq_mask(struct irq_data *data)
1227 {
1228 	struct pistachio_gpio_bank *bank = irqd_to_bank(data);
1229 
1230 	gpio_mask_writel(bank, GPIO_INTERRUPT_EN, data->hwirq, 0);
1231 }
1232 
1233 static void pistachio_gpio_irq_unmask(struct irq_data *data)
1234 {
1235 	struct pistachio_gpio_bank *bank = irqd_to_bank(data);
1236 
1237 	gpio_mask_writel(bank, GPIO_INTERRUPT_EN, data->hwirq, 1);
1238 }
1239 
1240 static unsigned int pistachio_gpio_irq_startup(struct irq_data *data)
1241 {
1242 	struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
1243 
1244 	pistachio_gpio_direction_input(chip, data->hwirq);
1245 	pistachio_gpio_irq_unmask(data);
1246 
1247 	return 0;
1248 }
1249 
1250 static int pistachio_gpio_irq_set_type(struct irq_data *data, unsigned int type)
1251 {
1252 	struct pistachio_gpio_bank *bank = irqd_to_bank(data);
1253 
1254 	switch (type & IRQ_TYPE_SENSE_MASK) {
1255 	case IRQ_TYPE_EDGE_RISING:
1256 		gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 1);
1257 		gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq,
1258 				 GPIO_INTERRUPT_TYPE_EDGE);
1259 		gpio_mask_writel(bank, GPIO_INTERRUPT_EDGE, data->hwirq,
1260 				 GPIO_INTERRUPT_EDGE_SINGLE);
1261 		break;
1262 	case IRQ_TYPE_EDGE_FALLING:
1263 		gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 0);
1264 		gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq,
1265 				 GPIO_INTERRUPT_TYPE_EDGE);
1266 		gpio_mask_writel(bank, GPIO_INTERRUPT_EDGE, data->hwirq,
1267 				 GPIO_INTERRUPT_EDGE_SINGLE);
1268 		break;
1269 	case IRQ_TYPE_EDGE_BOTH:
1270 		gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq,
1271 				 GPIO_INTERRUPT_TYPE_EDGE);
1272 		gpio_mask_writel(bank, GPIO_INTERRUPT_EDGE, data->hwirq,
1273 				 GPIO_INTERRUPT_EDGE_DUAL);
1274 		break;
1275 	case IRQ_TYPE_LEVEL_HIGH:
1276 		gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 1);
1277 		gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq,
1278 				 GPIO_INTERRUPT_TYPE_LEVEL);
1279 		break;
1280 	case IRQ_TYPE_LEVEL_LOW:
1281 		gpio_mask_writel(bank, GPIO_INPUT_POLARITY, data->hwirq, 0);
1282 		gpio_mask_writel(bank, GPIO_INTERRUPT_TYPE, data->hwirq,
1283 				 GPIO_INTERRUPT_TYPE_LEVEL);
1284 		break;
1285 	default:
1286 		return -EINVAL;
1287 	}
1288 
1289 	if (type & IRQ_TYPE_LEVEL_MASK)
1290 		irq_set_handler_locked(data, handle_level_irq);
1291 	else
1292 		irq_set_handler_locked(data, handle_edge_irq);
1293 
1294 	return 0;
1295 }
1296 
1297 static void pistachio_gpio_irq_handler(struct irq_desc *desc)
1298 {
1299 	struct gpio_chip *gc = irq_desc_get_handler_data(desc);
1300 	struct pistachio_gpio_bank *bank = gpiochip_get_data(gc);
1301 	struct irq_chip *chip = irq_desc_get_chip(desc);
1302 	unsigned long pending;
1303 	unsigned int pin;
1304 
1305 	chained_irq_enter(chip, desc);
1306 	pending = gpio_readl(bank, GPIO_INTERRUPT_STATUS) &
1307 		gpio_readl(bank, GPIO_INTERRUPT_EN);
1308 	for_each_set_bit(pin, &pending, 16)
1309 		generic_handle_domain_irq(gc->irq.domain, pin);
1310 	chained_irq_exit(chip, desc);
1311 }
1312 
1313 #define GPIO_BANK(_bank, _pin_base, _npins)				\
1314 	{								\
1315 		.pin_base = _pin_base,					\
1316 		.npins = _npins,					\
1317 		.gpio_chip = {						\
1318 			.label = "GPIO" #_bank,				\
1319 			.request = gpiochip_generic_request,		\
1320 			.free = gpiochip_generic_free,			\
1321 			.get_direction = pistachio_gpio_get_direction,	\
1322 			.direction_input = pistachio_gpio_direction_input, \
1323 			.direction_output = pistachio_gpio_direction_output, \
1324 			.get = pistachio_gpio_get,			\
1325 			.set = pistachio_gpio_set,			\
1326 			.base = _pin_base,				\
1327 			.ngpio = _npins,				\
1328 		},							\
1329 		.irq_chip = {						\
1330 			.name = "GPIO" #_bank,				\
1331 			.irq_startup = pistachio_gpio_irq_startup,	\
1332 			.irq_ack = pistachio_gpio_irq_ack,		\
1333 			.irq_mask = pistachio_gpio_irq_mask,		\
1334 			.irq_unmask = pistachio_gpio_irq_unmask,	\
1335 			.irq_set_type = pistachio_gpio_irq_set_type,	\
1336 		},							\
1337 	}
1338 
1339 static struct pistachio_gpio_bank pistachio_gpio_banks[] = {
1340 	GPIO_BANK(0, PISTACHIO_PIN_MFIO(0), 16),
1341 	GPIO_BANK(1, PISTACHIO_PIN_MFIO(16), 16),
1342 	GPIO_BANK(2, PISTACHIO_PIN_MFIO(32), 16),
1343 	GPIO_BANK(3, PISTACHIO_PIN_MFIO(48), 16),
1344 	GPIO_BANK(4, PISTACHIO_PIN_MFIO(64), 16),
1345 	GPIO_BANK(5, PISTACHIO_PIN_MFIO(80), 10),
1346 };
1347 
1348 static int pistachio_gpio_register(struct pistachio_pinctrl *pctl)
1349 {
1350 	struct device_node *node = pctl->dev->of_node;
1351 	struct pistachio_gpio_bank *bank;
1352 	unsigned int i;
1353 	int irq, ret = 0;
1354 
1355 	for (i = 0; i < pctl->nbanks; i++) {
1356 		char child_name[sizeof("gpioXX")];
1357 		struct device_node *child;
1358 		struct gpio_irq_chip *girq;
1359 
1360 		snprintf(child_name, sizeof(child_name), "gpio%d", i);
1361 		child = of_get_child_by_name(node, child_name);
1362 		if (!child) {
1363 			dev_err(pctl->dev, "No node for bank %u\n", i);
1364 			ret = -ENODEV;
1365 			goto err;
1366 		}
1367 
1368 		if (!of_find_property(child, "gpio-controller", NULL)) {
1369 			dev_err(pctl->dev,
1370 				"No gpio-controller property for bank %u\n", i);
1371 			of_node_put(child);
1372 			ret = -ENODEV;
1373 			goto err;
1374 		}
1375 
1376 		irq = irq_of_parse_and_map(child, 0);
1377 		if (!irq) {
1378 			dev_err(pctl->dev, "No IRQ for bank %u\n", i);
1379 			of_node_put(child);
1380 			ret = -EINVAL;
1381 			goto err;
1382 		}
1383 
1384 		bank = &pctl->gpio_banks[i];
1385 		bank->pctl = pctl;
1386 		bank->base = pctl->base + GPIO_BANK_BASE(i);
1387 
1388 		bank->gpio_chip.parent = pctl->dev;
1389 		bank->gpio_chip.of_node = child;
1390 
1391 		girq = &bank->gpio_chip.irq;
1392 		girq->chip = &bank->irq_chip;
1393 		girq->parent_handler = pistachio_gpio_irq_handler;
1394 		girq->num_parents = 1;
1395 		girq->parents = devm_kcalloc(pctl->dev, 1,
1396 					     sizeof(*girq->parents),
1397 					     GFP_KERNEL);
1398 		if (!girq->parents) {
1399 			ret = -ENOMEM;
1400 			goto err;
1401 		}
1402 		girq->parents[0] = irq;
1403 		girq->default_type = IRQ_TYPE_NONE;
1404 		girq->handler = handle_level_irq;
1405 
1406 		ret = gpiochip_add_data(&bank->gpio_chip, bank);
1407 		if (ret < 0) {
1408 			dev_err(pctl->dev, "Failed to add GPIO chip %u: %d\n",
1409 				i, ret);
1410 			goto err;
1411 		}
1412 
1413 		ret = gpiochip_add_pin_range(&bank->gpio_chip,
1414 					     dev_name(pctl->dev), 0,
1415 					     bank->pin_base, bank->npins);
1416 		if (ret < 0) {
1417 			dev_err(pctl->dev, "Failed to add GPIO range %u: %d\n",
1418 				i, ret);
1419 			gpiochip_remove(&bank->gpio_chip);
1420 			goto err;
1421 		}
1422 	}
1423 
1424 	return 0;
1425 err:
1426 	for (; i > 0; i--) {
1427 		bank = &pctl->gpio_banks[i - 1];
1428 		gpiochip_remove(&bank->gpio_chip);
1429 	}
1430 	return ret;
1431 }
1432 
1433 static const struct of_device_id pistachio_pinctrl_of_match[] = {
1434 	{ .compatible = "img,pistachio-system-pinctrl", },
1435 	{ },
1436 };
1437 
1438 static int pistachio_pinctrl_probe(struct platform_device *pdev)
1439 {
1440 	struct pistachio_pinctrl *pctl;
1441 
1442 	pctl = devm_kzalloc(&pdev->dev, sizeof(*pctl), GFP_KERNEL);
1443 	if (!pctl)
1444 		return -ENOMEM;
1445 	pctl->dev = &pdev->dev;
1446 	dev_set_drvdata(&pdev->dev, pctl);
1447 
1448 	pctl->base = devm_platform_ioremap_resource(pdev, 0);
1449 	if (IS_ERR(pctl->base))
1450 		return PTR_ERR(pctl->base);
1451 
1452 	pctl->pins = pistachio_pins;
1453 	pctl->npins = ARRAY_SIZE(pistachio_pins);
1454 	pctl->functions = pistachio_functions;
1455 	pctl->nfunctions = ARRAY_SIZE(pistachio_functions);
1456 	pctl->groups = pistachio_groups;
1457 	pctl->ngroups = ARRAY_SIZE(pistachio_groups);
1458 	pctl->gpio_banks = pistachio_gpio_banks;
1459 	pctl->nbanks = ARRAY_SIZE(pistachio_gpio_banks);
1460 
1461 	pistachio_pinctrl_desc.pins = pctl->pins;
1462 	pistachio_pinctrl_desc.npins = pctl->npins;
1463 
1464 	pctl->pctldev = devm_pinctrl_register(&pdev->dev, &pistachio_pinctrl_desc,
1465 					      pctl);
1466 	if (IS_ERR(pctl->pctldev)) {
1467 		dev_err(&pdev->dev, "Failed to register pinctrl device\n");
1468 		return PTR_ERR(pctl->pctldev);
1469 	}
1470 
1471 	return pistachio_gpio_register(pctl);
1472 }
1473 
1474 static struct platform_driver pistachio_pinctrl_driver = {
1475 	.driver = {
1476 		.name = "pistachio-pinctrl",
1477 		.of_match_table = pistachio_pinctrl_of_match,
1478 		.suppress_bind_attrs = true,
1479 	},
1480 	.probe = pistachio_pinctrl_probe,
1481 };
1482 
1483 static int __init pistachio_pinctrl_register(void)
1484 {
1485 	return platform_driver_register(&pistachio_pinctrl_driver);
1486 }
1487 arch_initcall(pistachio_pinctrl_register);
1488