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