GNU Linux-libre 5.13.14-gnu1
[releases.git] / drivers / pinctrl / pinctrl-microchip-sgpio.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Microsemi/Microchip SoCs serial gpio driver
4  *
5  * Author: Lars Povlsen <lars.povlsen@microchip.com>
6  *
7  * Copyright (c) 2020 Microchip Technology Inc. and its subsidiaries.
8  */
9
10 #include <linux/bitfield.h>
11 #include <linux/bits.h>
12 #include <linux/clk.h>
13 #include <linux/gpio/driver.h>
14 #include <linux/io.h>
15 #include <linux/mod_devicetable.h>
16 #include <linux/module.h>
17 #include <linux/pinctrl/pinmux.h>
18 #include <linux/platform_device.h>
19 #include <linux/property.h>
20
21 #include "core.h"
22 #include "pinconf.h"
23
24 #define SGPIO_BITS_PER_WORD     32
25 #define SGPIO_MAX_BITS          4
26 #define SGPIO_SRC_BITS          3 /* 3 bit wide field per pin */
27
28 enum {
29         REG_INPUT_DATA,
30         REG_PORT_CONFIG,
31         REG_PORT_ENABLE,
32         REG_SIO_CONFIG,
33         REG_SIO_CLOCK,
34         REG_INT_POLARITY,
35         REG_INT_TRIGGER,
36         REG_INT_ACK,
37         REG_INT_ENABLE,
38         REG_INT_IDENT,
39         MAXREG
40 };
41
42 enum {
43         SGPIO_ARCH_LUTON,
44         SGPIO_ARCH_OCELOT,
45         SGPIO_ARCH_SPARX5,
46 };
47
48 enum {
49         SGPIO_FLAGS_HAS_IRQ     = BIT(0),
50 };
51
52 struct sgpio_properties {
53         int arch;
54         int flags;
55         u8 regoff[MAXREG];
56 };
57
58 #define SGPIO_LUTON_AUTO_REPEAT  BIT(5)
59 #define SGPIO_LUTON_PORT_WIDTH   GENMASK(3, 2)
60 #define SGPIO_LUTON_CLK_FREQ     GENMASK(11, 0)
61 #define SGPIO_LUTON_BIT_SOURCE   GENMASK(11, 0)
62
63 #define SGPIO_OCELOT_AUTO_REPEAT BIT(10)
64 #define SGPIO_OCELOT_PORT_WIDTH  GENMASK(8, 7)
65 #define SGPIO_OCELOT_CLK_FREQ    GENMASK(19, 8)
66 #define SGPIO_OCELOT_BIT_SOURCE  GENMASK(23, 12)
67
68 #define SGPIO_SPARX5_AUTO_REPEAT BIT(6)
69 #define SGPIO_SPARX5_PORT_WIDTH  GENMASK(4, 3)
70 #define SGPIO_SPARX5_CLK_FREQ    GENMASK(19, 8)
71 #define SGPIO_SPARX5_BIT_SOURCE  GENMASK(23, 12)
72
73 #define SGPIO_MASTER_INTR_ENA    BIT(0)
74
75 #define SGPIO_INT_TRG_LEVEL     0
76 #define SGPIO_INT_TRG_EDGE      1
77 #define SGPIO_INT_TRG_EDGE_FALL 2
78 #define SGPIO_INT_TRG_EDGE_RISE 3
79
80 #define SGPIO_TRG_LEVEL_HIGH    0
81 #define SGPIO_TRG_LEVEL_LOW     1
82
83 static const struct sgpio_properties properties_luton = {
84         .arch   = SGPIO_ARCH_LUTON,
85         .regoff = { 0x00, 0x09, 0x29, 0x2a, 0x2b },
86 };
87
88 static const struct sgpio_properties properties_ocelot = {
89         .arch   = SGPIO_ARCH_OCELOT,
90         .regoff = { 0x00, 0x06, 0x26, 0x04, 0x05 },
91 };
92
93 static const struct sgpio_properties properties_sparx5 = {
94         .arch   = SGPIO_ARCH_SPARX5,
95         .flags  = SGPIO_FLAGS_HAS_IRQ,
96         .regoff = { 0x00, 0x06, 0x26, 0x04, 0x05, 0x2a, 0x32, 0x3a, 0x3e, 0x42 },
97 };
98
99 static const char * const functions[] = { "gpio" };
100
101 struct sgpio_bank {
102         struct sgpio_priv *priv;
103         bool is_input;
104         struct gpio_chip gpio;
105         struct pinctrl_desc pctl_desc;
106 };
107
108 struct sgpio_priv {
109         struct device *dev;
110         struct sgpio_bank in;
111         struct sgpio_bank out;
112         u32 bitcount;
113         u32 ports;
114         u32 clock;
115         u32 __iomem *regs;
116         const struct sgpio_properties *properties;
117 };
118
119 struct sgpio_port_addr {
120         u8 port;
121         u8 bit;
122 };
123
124 static inline void sgpio_pin_to_addr(struct sgpio_priv *priv, int pin,
125                                      struct sgpio_port_addr *addr)
126 {
127         addr->port = pin / priv->bitcount;
128         addr->bit = pin % priv->bitcount;
129 }
130
131 static inline int sgpio_addr_to_pin(struct sgpio_priv *priv, int port, int bit)
132 {
133         return bit + port * priv->bitcount;
134 }
135
136 static inline u32 sgpio_readl(struct sgpio_priv *priv, u32 rno, u32 off)
137 {
138         u32 __iomem *reg = &priv->regs[priv->properties->regoff[rno] + off];
139
140         return readl(reg);
141 }
142
143 static inline void sgpio_writel(struct sgpio_priv *priv,
144                                 u32 val, u32 rno, u32 off)
145 {
146         u32 __iomem *reg = &priv->regs[priv->properties->regoff[rno] + off];
147
148         writel(val, reg);
149 }
150
151 static inline void sgpio_clrsetbits(struct sgpio_priv *priv,
152                                     u32 rno, u32 off, u32 clear, u32 set)
153 {
154         u32 __iomem *reg = &priv->regs[priv->properties->regoff[rno] + off];
155         u32 val = readl(reg);
156
157         val &= ~clear;
158         val |= set;
159
160         writel(val, reg);
161 }
162
163 static inline void sgpio_configure_bitstream(struct sgpio_priv *priv)
164 {
165         int width = priv->bitcount - 1;
166         u32 clr, set;
167
168         switch (priv->properties->arch) {
169         case SGPIO_ARCH_LUTON:
170                 clr = SGPIO_LUTON_PORT_WIDTH;
171                 set = SGPIO_LUTON_AUTO_REPEAT |
172                         FIELD_PREP(SGPIO_LUTON_PORT_WIDTH, width);
173                 break;
174         case SGPIO_ARCH_OCELOT:
175                 clr = SGPIO_OCELOT_PORT_WIDTH;
176                 set = SGPIO_OCELOT_AUTO_REPEAT |
177                         FIELD_PREP(SGPIO_OCELOT_PORT_WIDTH, width);
178                 break;
179         case SGPIO_ARCH_SPARX5:
180                 clr = SGPIO_SPARX5_PORT_WIDTH;
181                 set = SGPIO_SPARX5_AUTO_REPEAT |
182                         FIELD_PREP(SGPIO_SPARX5_PORT_WIDTH, width);
183                 break;
184         default:
185                 return;
186         }
187         sgpio_clrsetbits(priv, REG_SIO_CONFIG, 0, clr, set);
188 }
189
190 static inline void sgpio_configure_clock(struct sgpio_priv *priv, u32 clkfrq)
191 {
192         u32 clr, set;
193
194         switch (priv->properties->arch) {
195         case SGPIO_ARCH_LUTON:
196                 clr = SGPIO_LUTON_CLK_FREQ;
197                 set = FIELD_PREP(SGPIO_LUTON_CLK_FREQ, clkfrq);
198                 break;
199         case SGPIO_ARCH_OCELOT:
200                 clr = SGPIO_OCELOT_CLK_FREQ;
201                 set = FIELD_PREP(SGPIO_OCELOT_CLK_FREQ, clkfrq);
202                 break;
203         case SGPIO_ARCH_SPARX5:
204                 clr = SGPIO_SPARX5_CLK_FREQ;
205                 set = FIELD_PREP(SGPIO_SPARX5_CLK_FREQ, clkfrq);
206                 break;
207         default:
208                 return;
209         }
210         sgpio_clrsetbits(priv, REG_SIO_CLOCK, 0, clr, set);
211 }
212
213 static void sgpio_output_set(struct sgpio_priv *priv,
214                              struct sgpio_port_addr *addr,
215                              int value)
216 {
217         unsigned int bit = SGPIO_SRC_BITS * addr->bit;
218         u32 clr, set;
219
220         switch (priv->properties->arch) {
221         case SGPIO_ARCH_LUTON:
222                 clr = FIELD_PREP(SGPIO_LUTON_BIT_SOURCE, BIT(bit));
223                 set = FIELD_PREP(SGPIO_LUTON_BIT_SOURCE, value << bit);
224                 break;
225         case SGPIO_ARCH_OCELOT:
226                 clr = FIELD_PREP(SGPIO_OCELOT_BIT_SOURCE, BIT(bit));
227                 set = FIELD_PREP(SGPIO_OCELOT_BIT_SOURCE, value << bit);
228                 break;
229         case SGPIO_ARCH_SPARX5:
230                 clr = FIELD_PREP(SGPIO_SPARX5_BIT_SOURCE, BIT(bit));
231                 set = FIELD_PREP(SGPIO_SPARX5_BIT_SOURCE, value << bit);
232                 break;
233         default:
234                 return;
235         }
236         sgpio_clrsetbits(priv, REG_PORT_CONFIG, addr->port, clr, set);
237 }
238
239 static int sgpio_output_get(struct sgpio_priv *priv,
240                             struct sgpio_port_addr *addr)
241 {
242         u32 val, portval = sgpio_readl(priv, REG_PORT_CONFIG, addr->port);
243         unsigned int bit = SGPIO_SRC_BITS * addr->bit;
244
245         switch (priv->properties->arch) {
246         case SGPIO_ARCH_LUTON:
247                 val = FIELD_GET(SGPIO_LUTON_BIT_SOURCE, portval);
248                 break;
249         case SGPIO_ARCH_OCELOT:
250                 val = FIELD_GET(SGPIO_OCELOT_BIT_SOURCE, portval);
251                 break;
252         case SGPIO_ARCH_SPARX5:
253                 val = FIELD_GET(SGPIO_SPARX5_BIT_SOURCE, portval);
254                 break;
255         default:
256                 val = 0;
257                 break;
258         }
259         return !!(val & BIT(bit));
260 }
261
262 static int sgpio_input_get(struct sgpio_priv *priv,
263                            struct sgpio_port_addr *addr)
264 {
265         return !!(sgpio_readl(priv, REG_INPUT_DATA, addr->bit) & BIT(addr->port));
266 }
267
268 static int sgpio_pinconf_get(struct pinctrl_dev *pctldev,
269                              unsigned int pin, unsigned long *config)
270 {
271         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
272         u32 param = pinconf_to_config_param(*config);
273         struct sgpio_priv *priv = bank->priv;
274         struct sgpio_port_addr addr;
275         int val;
276
277         sgpio_pin_to_addr(priv, pin, &addr);
278
279         switch (param) {
280         case PIN_CONFIG_INPUT_ENABLE:
281                 val = bank->is_input;
282                 break;
283
284         case PIN_CONFIG_OUTPUT_ENABLE:
285                 val = !bank->is_input;
286                 break;
287
288         case PIN_CONFIG_OUTPUT:
289                 if (bank->is_input)
290                         return -EINVAL;
291                 val = sgpio_output_get(priv, &addr);
292                 break;
293
294         default:
295                 return -ENOTSUPP;
296         }
297
298         *config = pinconf_to_config_packed(param, val);
299
300         return 0;
301 }
302
303 static int sgpio_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
304                              unsigned long *configs, unsigned int num_configs)
305 {
306         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
307         struct sgpio_priv *priv = bank->priv;
308         struct sgpio_port_addr addr;
309         int cfg, err = 0;
310         u32 param, arg;
311
312         sgpio_pin_to_addr(priv, pin, &addr);
313
314         for (cfg = 0; cfg < num_configs; cfg++) {
315                 param = pinconf_to_config_param(configs[cfg]);
316                 arg = pinconf_to_config_argument(configs[cfg]);
317
318                 switch (param) {
319                 case PIN_CONFIG_OUTPUT:
320                         if (bank->is_input)
321                                 return -EINVAL;
322                         sgpio_output_set(priv, &addr, arg);
323                         break;
324
325                 default:
326                         err = -ENOTSUPP;
327                 }
328         }
329
330         return err;
331 }
332
333 static const struct pinconf_ops sgpio_confops = {
334         .is_generic = true,
335         .pin_config_get = sgpio_pinconf_get,
336         .pin_config_set = sgpio_pinconf_set,
337         .pin_config_config_dbg_show = pinconf_generic_dump_config,
338 };
339
340 static int sgpio_get_functions_count(struct pinctrl_dev *pctldev)
341 {
342         return 1;
343 }
344
345 static const char *sgpio_get_function_name(struct pinctrl_dev *pctldev,
346                                            unsigned int function)
347 {
348         return functions[0];
349 }
350
351 static int sgpio_get_function_groups(struct pinctrl_dev *pctldev,
352                                      unsigned int function,
353                                      const char *const **groups,
354                                      unsigned *const num_groups)
355 {
356         *groups  = functions;
357         *num_groups = ARRAY_SIZE(functions);
358
359         return 0;
360 }
361
362 static int sgpio_pinmux_set_mux(struct pinctrl_dev *pctldev,
363                                 unsigned int selector, unsigned int group)
364 {
365         return 0;
366 }
367
368 static int sgpio_gpio_set_direction(struct pinctrl_dev *pctldev,
369                                     struct pinctrl_gpio_range *range,
370                                     unsigned int pin, bool input)
371 {
372         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
373
374         return (input == bank->is_input) ? 0 : -EINVAL;
375 }
376
377 static int sgpio_gpio_request_enable(struct pinctrl_dev *pctldev,
378                                      struct pinctrl_gpio_range *range,
379                                      unsigned int offset)
380 {
381         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
382         struct sgpio_priv *priv = bank->priv;
383         struct sgpio_port_addr addr;
384
385         sgpio_pin_to_addr(priv, offset, &addr);
386
387         if ((priv->ports & BIT(addr.port)) == 0) {
388                 dev_warn(priv->dev, "Request port %d.%d: Port is not enabled\n",
389                          addr.port, addr.bit);
390                 return -EINVAL;
391         }
392
393         return 0;
394 }
395
396 static const struct pinmux_ops sgpio_pmx_ops = {
397         .get_functions_count = sgpio_get_functions_count,
398         .get_function_name = sgpio_get_function_name,
399         .get_function_groups = sgpio_get_function_groups,
400         .set_mux = sgpio_pinmux_set_mux,
401         .gpio_set_direction = sgpio_gpio_set_direction,
402         .gpio_request_enable = sgpio_gpio_request_enable,
403 };
404
405 static int sgpio_pctl_get_groups_count(struct pinctrl_dev *pctldev)
406 {
407         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
408
409         return bank->pctl_desc.npins;
410 }
411
412 static const char *sgpio_pctl_get_group_name(struct pinctrl_dev *pctldev,
413                                              unsigned int group)
414 {
415         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
416
417         return bank->pctl_desc.pins[group].name;
418 }
419
420 static int sgpio_pctl_get_group_pins(struct pinctrl_dev *pctldev,
421                                      unsigned int group,
422                                      const unsigned int **pins,
423                                      unsigned int *num_pins)
424 {
425         struct sgpio_bank *bank = pinctrl_dev_get_drvdata(pctldev);
426
427         *pins = &bank->pctl_desc.pins[group].number;
428         *num_pins = 1;
429
430         return 0;
431 }
432
433 static const struct pinctrl_ops sgpio_pctl_ops = {
434         .get_groups_count = sgpio_pctl_get_groups_count,
435         .get_group_name = sgpio_pctl_get_group_name,
436         .get_group_pins = sgpio_pctl_get_group_pins,
437         .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
438         .dt_free_map = pinconf_generic_dt_free_map,
439 };
440
441 static int microchip_sgpio_direction_input(struct gpio_chip *gc, unsigned int gpio)
442 {
443         struct sgpio_bank *bank = gpiochip_get_data(gc);
444
445         /* Fixed-position function */
446         return bank->is_input ? 0 : -EINVAL;
447 }
448
449 static int microchip_sgpio_direction_output(struct gpio_chip *gc,
450                                        unsigned int gpio, int value)
451 {
452         struct sgpio_bank *bank = gpiochip_get_data(gc);
453         struct sgpio_priv *priv = bank->priv;
454         struct sgpio_port_addr addr;
455
456         /* Fixed-position function */
457         if (bank->is_input)
458                 return -EINVAL;
459
460         sgpio_pin_to_addr(priv, gpio, &addr);
461
462         sgpio_output_set(priv, &addr, value);
463
464         return 0;
465 }
466
467 static int microchip_sgpio_get_direction(struct gpio_chip *gc, unsigned int gpio)
468 {
469         struct sgpio_bank *bank = gpiochip_get_data(gc);
470
471         return bank->is_input ? GPIO_LINE_DIRECTION_IN : GPIO_LINE_DIRECTION_OUT;
472 }
473
474 static void microchip_sgpio_set_value(struct gpio_chip *gc,
475                                 unsigned int gpio, int value)
476 {
477         microchip_sgpio_direction_output(gc, gpio, value);
478 }
479
480 static int microchip_sgpio_get_value(struct gpio_chip *gc, unsigned int gpio)
481 {
482         struct sgpio_bank *bank = gpiochip_get_data(gc);
483         struct sgpio_priv *priv = bank->priv;
484         struct sgpio_port_addr addr;
485
486         sgpio_pin_to_addr(priv, gpio, &addr);
487
488         return bank->is_input ? sgpio_input_get(priv, &addr) : sgpio_output_get(priv, &addr);
489 }
490
491 static int microchip_sgpio_of_xlate(struct gpio_chip *gc,
492                                const struct of_phandle_args *gpiospec,
493                                u32 *flags)
494 {
495         struct sgpio_bank *bank = gpiochip_get_data(gc);
496         struct sgpio_priv *priv = bank->priv;
497         int pin;
498
499         /*
500          * Note that the SGIO pin is defined by *2* numbers, a port
501          * number between 0 and 31, and a bit index, 0 to 3.
502          */
503         if (gpiospec->args[0] > SGPIO_BITS_PER_WORD ||
504             gpiospec->args[1] > priv->bitcount)
505                 return -EINVAL;
506
507         pin = sgpio_addr_to_pin(priv, gpiospec->args[0], gpiospec->args[1]);
508
509         if (pin > gc->ngpio)
510                 return -EINVAL;
511
512         if (flags)
513                 *flags = gpiospec->args[2];
514
515         return pin;
516 }
517
518 static int microchip_sgpio_get_ports(struct sgpio_priv *priv)
519 {
520         const char *range_property_name = "microchip,sgpio-port-ranges";
521         struct device *dev = priv->dev;
522         u32 range_params[64];
523         int i, nranges, ret;
524
525         /* Calculate port mask */
526         nranges = device_property_count_u32(dev, range_property_name);
527         if (nranges < 2 || nranges % 2 || nranges > ARRAY_SIZE(range_params)) {
528                 dev_err(dev, "%s port range: '%s' property\n",
529                         nranges == -EINVAL ? "Missing" : "Invalid",
530                         range_property_name);
531                 return -EINVAL;
532         }
533
534         ret = device_property_read_u32_array(dev, range_property_name,
535                                              range_params, nranges);
536         if (ret) {
537                 dev_err(dev, "failed to parse '%s' property: %d\n",
538                         range_property_name, ret);
539                 return ret;
540         }
541         for (i = 0; i < nranges; i += 2) {
542                 int start, end;
543
544                 start = range_params[i];
545                 end = range_params[i + 1];
546                 if (start > end || end >= SGPIO_BITS_PER_WORD) {
547                         dev_err(dev, "Ill-formed port-range [%d:%d]\n",
548                                 start, end);
549                 }
550                 priv->ports |= GENMASK(end, start);
551         }
552
553         return 0;
554 }
555
556 static void microchip_sgpio_irq_settype(struct irq_data *data,
557                                         int type,
558                                         int polarity)
559 {
560         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
561         struct sgpio_bank *bank = gpiochip_get_data(chip);
562         unsigned int gpio = irqd_to_hwirq(data);
563         struct sgpio_port_addr addr;
564         u32 ena;
565
566         sgpio_pin_to_addr(bank->priv, gpio, &addr);
567
568         /* Disable interrupt while changing type */
569         ena = sgpio_readl(bank->priv, REG_INT_ENABLE, addr.bit);
570         sgpio_writel(bank->priv, ena & ~BIT(addr.port), REG_INT_ENABLE, addr.bit);
571
572         /* Type value spread over 2 registers sets: low, high bit */
573         sgpio_clrsetbits(bank->priv, REG_INT_TRIGGER, addr.bit,
574                          BIT(addr.port), (!!(type & 0x1)) << addr.port);
575         sgpio_clrsetbits(bank->priv, REG_INT_TRIGGER, SGPIO_MAX_BITS + addr.bit,
576                          BIT(addr.port), (!!(type & 0x2)) << addr.port);
577
578         if (type == SGPIO_INT_TRG_LEVEL)
579                 sgpio_clrsetbits(bank->priv, REG_INT_POLARITY, addr.bit,
580                                  BIT(addr.port), polarity << addr.port);
581
582         /* Possibly re-enable interrupts */
583         sgpio_writel(bank->priv, ena, REG_INT_ENABLE, addr.bit);
584 }
585
586 static void microchip_sgpio_irq_setreg(struct irq_data *data,
587                                        int reg,
588                                        bool clear)
589 {
590         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
591         struct sgpio_bank *bank = gpiochip_get_data(chip);
592         unsigned int gpio = irqd_to_hwirq(data);
593         struct sgpio_port_addr addr;
594
595         sgpio_pin_to_addr(bank->priv, gpio, &addr);
596
597         if (clear)
598                 sgpio_clrsetbits(bank->priv, reg, addr.bit, BIT(addr.port), 0);
599         else
600                 sgpio_clrsetbits(bank->priv, reg, addr.bit, 0, BIT(addr.port));
601 }
602
603 static void microchip_sgpio_irq_mask(struct irq_data *data)
604 {
605         microchip_sgpio_irq_setreg(data, REG_INT_ENABLE, true);
606 }
607
608 static void microchip_sgpio_irq_unmask(struct irq_data *data)
609 {
610         microchip_sgpio_irq_setreg(data, REG_INT_ENABLE, false);
611 }
612
613 static void microchip_sgpio_irq_ack(struct irq_data *data)
614 {
615         microchip_sgpio_irq_setreg(data, REG_INT_ACK, false);
616 }
617
618 static int microchip_sgpio_irq_set_type(struct irq_data *data, unsigned int type)
619 {
620         type &= IRQ_TYPE_SENSE_MASK;
621
622         switch (type) {
623         case IRQ_TYPE_EDGE_BOTH:
624                 irq_set_handler_locked(data, handle_edge_irq);
625                 microchip_sgpio_irq_settype(data, SGPIO_INT_TRG_EDGE, 0);
626                 break;
627         case IRQ_TYPE_EDGE_RISING:
628                 irq_set_handler_locked(data, handle_edge_irq);
629                 microchip_sgpio_irq_settype(data, SGPIO_INT_TRG_EDGE_RISE, 0);
630                 break;
631         case IRQ_TYPE_EDGE_FALLING:
632                 irq_set_handler_locked(data, handle_edge_irq);
633                 microchip_sgpio_irq_settype(data, SGPIO_INT_TRG_EDGE_FALL, 0);
634                 break;
635         case IRQ_TYPE_LEVEL_HIGH:
636                 irq_set_handler_locked(data, handle_level_irq);
637                 microchip_sgpio_irq_settype(data, SGPIO_INT_TRG_LEVEL, SGPIO_TRG_LEVEL_HIGH);
638                 break;
639         case IRQ_TYPE_LEVEL_LOW:
640                 irq_set_handler_locked(data, handle_level_irq);
641                 microchip_sgpio_irq_settype(data, SGPIO_INT_TRG_LEVEL, SGPIO_TRG_LEVEL_LOW);
642                 break;
643         default:
644                 return -EINVAL;
645         }
646
647         return 0;
648 }
649
650 static const struct irq_chip microchip_sgpio_irqchip = {
651         .name           = "gpio",
652         .irq_mask       = microchip_sgpio_irq_mask,
653         .irq_ack        = microchip_sgpio_irq_ack,
654         .irq_unmask     = microchip_sgpio_irq_unmask,
655         .irq_set_type   = microchip_sgpio_irq_set_type,
656 };
657
658 static void sgpio_irq_handler(struct irq_desc *desc)
659 {
660         struct irq_chip *parent_chip = irq_desc_get_chip(desc);
661         struct gpio_chip *chip = irq_desc_get_handler_data(desc);
662         struct sgpio_bank *bank = gpiochip_get_data(chip);
663         struct sgpio_priv *priv = bank->priv;
664         int bit, port, gpio;
665         long val;
666
667         for (bit = 0; bit < priv->bitcount; bit++) {
668                 val = sgpio_readl(priv, REG_INT_IDENT, bit);
669                 if (!val)
670                         continue;
671
672                 chained_irq_enter(parent_chip, desc);
673
674                 for_each_set_bit(port, &val, SGPIO_BITS_PER_WORD) {
675                         gpio = sgpio_addr_to_pin(priv, port, bit);
676                         generic_handle_irq(irq_linear_revmap(chip->irq.domain, gpio));
677                 }
678
679                 chained_irq_exit(parent_chip, desc);
680         }
681 }
682
683 static int microchip_sgpio_register_bank(struct device *dev,
684                                          struct sgpio_priv *priv,
685                                          struct fwnode_handle *fwnode,
686                                          int bankno)
687 {
688         struct pinctrl_pin_desc *pins;
689         struct pinctrl_desc *pctl_desc;
690         struct pinctrl_dev *pctldev;
691         struct sgpio_bank *bank;
692         struct gpio_chip *gc;
693         u32 ngpios;
694         int i, ret;
695
696         /* Get overall bank struct */
697         bank = (bankno == 0) ? &priv->in : &priv->out;
698         bank->priv = priv;
699
700         if (fwnode_property_read_u32(fwnode, "ngpios", &ngpios)) {
701                 dev_info(dev, "failed to get number of gpios for bank%d\n",
702                          bankno);
703                 ngpios = 64;
704         }
705
706         priv->bitcount = ngpios / SGPIO_BITS_PER_WORD;
707         if (priv->bitcount > SGPIO_MAX_BITS) {
708                 dev_err(dev, "Bit width exceeds maximum (%d)\n",
709                         SGPIO_MAX_BITS);
710                 return -EINVAL;
711         }
712
713         pctl_desc = &bank->pctl_desc;
714         pctl_desc->name = devm_kasprintf(dev, GFP_KERNEL, "%s-%sput",
715                                          dev_name(dev),
716                                          bank->is_input ? "in" : "out");
717         pctl_desc->pctlops = &sgpio_pctl_ops;
718         pctl_desc->pmxops = &sgpio_pmx_ops;
719         pctl_desc->confops = &sgpio_confops;
720         pctl_desc->owner = THIS_MODULE;
721
722         pins = devm_kzalloc(dev, sizeof(*pins)*ngpios, GFP_KERNEL);
723         if (!pins)
724                 return -ENOMEM;
725
726         pctl_desc->npins = ngpios;
727         pctl_desc->pins = pins;
728
729         for (i = 0; i < ngpios; i++) {
730                 struct sgpio_port_addr addr;
731
732                 sgpio_pin_to_addr(priv, i, &addr);
733
734                 pins[i].number = i;
735                 pins[i].name = devm_kasprintf(dev, GFP_KERNEL,
736                                               "SGPIO_%c_p%db%d",
737                                               bank->is_input ? 'I' : 'O',
738                                               addr.port, addr.bit);
739                 if (!pins[i].name)
740                         return -ENOMEM;
741         }
742
743         pctldev = devm_pinctrl_register(dev, pctl_desc, bank);
744         if (IS_ERR(pctldev))
745                 return dev_err_probe(dev, PTR_ERR(pctldev), "Failed to register pinctrl\n");
746
747         gc                      = &bank->gpio;
748         gc->label               = pctl_desc->name;
749         gc->parent              = dev;
750         gc->of_node             = to_of_node(fwnode);
751         gc->owner               = THIS_MODULE;
752         gc->get_direction       = microchip_sgpio_get_direction;
753         gc->direction_input     = microchip_sgpio_direction_input;
754         gc->direction_output    = microchip_sgpio_direction_output;
755         gc->get                 = microchip_sgpio_get_value;
756         gc->set                 = microchip_sgpio_set_value;
757         gc->request             = gpiochip_generic_request;
758         gc->free                = gpiochip_generic_free;
759         gc->of_xlate            = microchip_sgpio_of_xlate;
760         gc->of_gpio_n_cells     = 3;
761         gc->base                = -1;
762         gc->ngpio               = ngpios;
763
764         if (bank->is_input && priv->properties->flags & SGPIO_FLAGS_HAS_IRQ) {
765                 int irq = fwnode_irq_get(fwnode, 0);
766
767                 if (irq) {
768                         struct gpio_irq_chip *girq = &gc->irq;
769
770                         girq->chip = devm_kmemdup(dev, &microchip_sgpio_irqchip,
771                                                   sizeof(microchip_sgpio_irqchip),
772                                                   GFP_KERNEL);
773                         if (!girq->chip)
774                                 return -ENOMEM;
775                         girq->parent_handler = sgpio_irq_handler;
776                         girq->num_parents = 1;
777                         girq->parents = devm_kcalloc(dev, 1,
778                                                      sizeof(*girq->parents),
779                                                      GFP_KERNEL);
780                         if (!girq->parents)
781                                 return -ENOMEM;
782                         girq->parents[0] = irq;
783                         girq->default_type = IRQ_TYPE_NONE;
784                         girq->handler = handle_bad_irq;
785
786                         /* Disable all individual pins */
787                         for (i = 0; i < SGPIO_MAX_BITS; i++)
788                                 sgpio_writel(priv, 0, REG_INT_ENABLE, i);
789                         /* Master enable */
790                         sgpio_clrsetbits(priv, REG_SIO_CONFIG, 0, 0, SGPIO_MASTER_INTR_ENA);
791                 }
792         }
793
794         ret = devm_gpiochip_add_data(dev, gc, bank);
795         if (ret)
796                 dev_err(dev, "Failed to register: ret %d\n", ret);
797
798         return ret;
799 }
800
801 static int microchip_sgpio_probe(struct platform_device *pdev)
802 {
803         int div_clock = 0, ret, port, i, nbanks;
804         struct device *dev = &pdev->dev;
805         struct fwnode_handle *fwnode;
806         struct sgpio_priv *priv;
807         struct clk *clk;
808         u32 val;
809
810         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
811         if (!priv)
812                 return -ENOMEM;
813
814         priv->dev = dev;
815
816         clk = devm_clk_get(dev, NULL);
817         if (IS_ERR(clk))
818                 return dev_err_probe(dev, PTR_ERR(clk), "Failed to get clock\n");
819
820         div_clock = clk_get_rate(clk);
821         if (device_property_read_u32(dev, "bus-frequency", &priv->clock))
822                 priv->clock = 12500000;
823         if (priv->clock == 0 || priv->clock > (div_clock / 2)) {
824                 dev_err(dev, "Invalid frequency %d\n", priv->clock);
825                 return -EINVAL;
826         }
827
828         priv->regs = devm_platform_ioremap_resource(pdev, 0);
829         if (IS_ERR(priv->regs))
830                 return PTR_ERR(priv->regs);
831         priv->properties = device_get_match_data(dev);
832         priv->in.is_input = true;
833
834         /* Get rest of device properties */
835         ret = microchip_sgpio_get_ports(priv);
836         if (ret)
837                 return ret;
838
839         nbanks = device_get_child_node_count(dev);
840         if (nbanks != 2) {
841                 dev_err(dev, "Must have 2 banks (have %d)\n", nbanks);
842                 return -EINVAL;
843         }
844
845         i = 0;
846         device_for_each_child_node(dev, fwnode) {
847                 ret = microchip_sgpio_register_bank(dev, priv, fwnode, i++);
848                 if (ret) {
849                         fwnode_handle_put(fwnode);
850                         return ret;
851                 }
852         }
853
854         if (priv->in.gpio.ngpio != priv->out.gpio.ngpio) {
855                 dev_err(dev, "Banks must have same GPIO count\n");
856                 return -ERANGE;
857         }
858
859         sgpio_configure_bitstream(priv);
860
861         val = max(2U, div_clock / priv->clock);
862         sgpio_configure_clock(priv, val);
863
864         for (port = 0; port < SGPIO_BITS_PER_WORD; port++)
865                 sgpio_writel(priv, 0, REG_PORT_CONFIG, port);
866         sgpio_writel(priv, priv->ports, REG_PORT_ENABLE, 0);
867
868         return 0;
869 }
870
871 static const struct of_device_id microchip_sgpio_gpio_of_match[] = {
872         {
873                 .compatible = "microchip,sparx5-sgpio",
874                 .data = &properties_sparx5,
875         }, {
876                 .compatible = "mscc,luton-sgpio",
877                 .data = &properties_luton,
878         }, {
879                 .compatible = "mscc,ocelot-sgpio",
880                 .data = &properties_ocelot,
881         }, {
882                 /* sentinel */
883         }
884 };
885
886 static struct platform_driver microchip_sgpio_pinctrl_driver = {
887         .driver = {
888                 .name = "pinctrl-microchip-sgpio",
889                 .of_match_table = microchip_sgpio_gpio_of_match,
890                 .suppress_bind_attrs = true,
891         },
892         .probe = microchip_sgpio_probe,
893 };
894 builtin_platform_driver(microchip_sgpio_pinctrl_driver);