Merge tag 'keystone_dts_for_5.7' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.git] / drivers / pinctrl / pinctrl-pistachio.c
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_irq(irq_linear_revmap(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 < 0) {
1378                         dev_err(pctl->dev, "No IRQ for bank %u: %d\n", i, irq);
1379                         of_node_put(child);
1380                         ret = irq;
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);