serial: exar: Add support for IOT2040 device
[muen/linux.git] / drivers / gpio / gpio-mvebu.c
1 /*
2  * GPIO driver for Marvell SoCs
3  *
4  * Copyright (C) 2012 Marvell
5  *
6  * Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
7  * Andrew Lunn <andrew@lunn.ch>
8  * Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
9  *
10  * This file is licensed under the terms of the GNU General Public
11  * License version 2.  This program is licensed "as is" without any
12  * warranty of any kind, whether express or implied.
13  *
14  * This driver is a fairly straightforward GPIO driver for the
15  * complete family of Marvell EBU SoC platforms (Orion, Dove,
16  * Kirkwood, Discovery, Armada 370/XP). The only complexity of this
17  * driver is the different register layout that exists between the
18  * non-SMP platforms (Orion, Dove, Kirkwood, Armada 370) and the SMP
19  * platforms (MV78200 from the Discovery family and the Armada
20  * XP). Therefore, this driver handles three variants of the GPIO
21  * block:
22  * - the basic variant, called "orion-gpio", with the simplest
23  *   register set. Used on Orion, Dove, Kirkwoord, Armada 370 and
24  *   non-SMP Discovery systems
25  * - the mv78200 variant for MV78200 Discovery systems. This variant
26  *   turns the edge mask and level mask registers into CPU0 edge
27  *   mask/level mask registers, and adds CPU1 edge mask/level mask
28  *   registers.
29  * - the armadaxp variant for Armada XP systems. This variant keeps
30  *   the normal cause/edge mask/level mask registers when the global
31  *   interrupts are used, but adds per-CPU cause/edge mask/level mask
32  *   registers n a separate memory area for the per-CPU GPIO
33  *   interrupts.
34  */
35
36 #include <linux/bitops.h>
37 #include <linux/clk.h>
38 #include <linux/err.h>
39 #include <linux/gpio.h>
40 #include <linux/init.h>
41 #include <linux/io.h>
42 #include <linux/irq.h>
43 #include <linux/irqchip/chained_irq.h>
44 #include <linux/irqdomain.h>
45 #include <linux/mfd/syscon.h>
46 #include <linux/of_device.h>
47 #include <linux/of_irq.h>
48 #include <linux/pinctrl/consumer.h>
49 #include <linux/platform_device.h>
50 #include <linux/pwm.h>
51 #include <linux/regmap.h>
52 #include <linux/slab.h>
53
54 #include "gpiolib.h"
55
56 /*
57  * GPIO unit register offsets.
58  */
59 #define GPIO_OUT_OFF                    0x0000
60 #define GPIO_IO_CONF_OFF                0x0004
61 #define GPIO_BLINK_EN_OFF               0x0008
62 #define GPIO_IN_POL_OFF                 0x000c
63 #define GPIO_DATA_IN_OFF                0x0010
64 #define GPIO_EDGE_CAUSE_OFF             0x0014
65 #define GPIO_EDGE_MASK_OFF              0x0018
66 #define GPIO_LEVEL_MASK_OFF             0x001c
67 #define GPIO_BLINK_CNT_SELECT_OFF       0x0020
68
69 /*
70  * PWM register offsets.
71  */
72 #define PWM_BLINK_ON_DURATION_OFF       0x0
73 #define PWM_BLINK_OFF_DURATION_OFF      0x4
74
75
76 /* The MV78200 has per-CPU registers for edge mask and level mask */
77 #define GPIO_EDGE_MASK_MV78200_OFF(cpu)   ((cpu) ? 0x30 : 0x18)
78 #define GPIO_LEVEL_MASK_MV78200_OFF(cpu)  ((cpu) ? 0x34 : 0x1C)
79
80 /*
81  * The Armada XP has per-CPU registers for interrupt cause, interrupt
82  * mask and interrupt level mask. Those are relative to the
83  * percpu_membase.
84  */
85 #define GPIO_EDGE_CAUSE_ARMADAXP_OFF(cpu) ((cpu) * 0x4)
86 #define GPIO_EDGE_MASK_ARMADAXP_OFF(cpu)  (0x10 + (cpu) * 0x4)
87 #define GPIO_LEVEL_MASK_ARMADAXP_OFF(cpu) (0x20 + (cpu) * 0x4)
88
89 #define MVEBU_GPIO_SOC_VARIANT_ORION    0x1
90 #define MVEBU_GPIO_SOC_VARIANT_MV78200  0x2
91 #define MVEBU_GPIO_SOC_VARIANT_ARMADAXP 0x3
92 #define MVEBU_GPIO_SOC_VARIANT_A8K      0x4
93
94 #define MVEBU_MAX_GPIO_PER_BANK         32
95
96 struct mvebu_pwm {
97         void __iomem            *membase;
98         unsigned long            clk_rate;
99         struct gpio_desc        *gpiod;
100         struct pwm_chip          chip;
101         spinlock_t               lock;
102         struct mvebu_gpio_chip  *mvchip;
103
104         /* Used to preserve GPIO/PWM registers across suspend/resume */
105         u32                      blink_select;
106         u32                      blink_on_duration;
107         u32                      blink_off_duration;
108 };
109
110 struct mvebu_gpio_chip {
111         struct gpio_chip   chip;
112         struct regmap     *regs;
113         u32                offset;
114         struct regmap     *percpu_regs;
115         int                irqbase;
116         struct irq_domain *domain;
117         int                soc_variant;
118
119         /* Used for PWM support */
120         struct clk        *clk;
121         struct mvebu_pwm  *mvpwm;
122
123         /* Used to preserve GPIO registers across suspend/resume */
124         u32                out_reg;
125         u32                io_conf_reg;
126         u32                blink_en_reg;
127         u32                in_pol_reg;
128         u32                edge_mask_regs[4];
129         u32                level_mask_regs[4];
130 };
131
132 /*
133  * Functions returning addresses of individual registers for a given
134  * GPIO controller.
135  */
136
137 static void mvebu_gpioreg_edge_cause(struct mvebu_gpio_chip *mvchip,
138                          struct regmap **map, unsigned int *offset)
139 {
140         int cpu;
141
142         switch (mvchip->soc_variant) {
143         case MVEBU_GPIO_SOC_VARIANT_ORION:
144         case MVEBU_GPIO_SOC_VARIANT_MV78200:
145         case MVEBU_GPIO_SOC_VARIANT_A8K:
146                 *map = mvchip->regs;
147                 *offset = GPIO_EDGE_CAUSE_OFF + mvchip->offset;
148                 break;
149         case MVEBU_GPIO_SOC_VARIANT_ARMADAXP:
150                 cpu = smp_processor_id();
151                 *map = mvchip->percpu_regs;
152                 *offset = GPIO_EDGE_CAUSE_ARMADAXP_OFF(cpu);
153                 break;
154         default:
155                 BUG();
156         }
157 }
158
159 static u32
160 mvebu_gpio_read_edge_cause(struct mvebu_gpio_chip *mvchip)
161 {
162         struct regmap *map;
163         unsigned int offset;
164         u32 val;
165
166         mvebu_gpioreg_edge_cause(mvchip, &map, &offset);
167         regmap_read(map, offset, &val);
168
169         return val;
170 }
171
172 static void
173 mvebu_gpio_write_edge_cause(struct mvebu_gpio_chip *mvchip, u32 val)
174 {
175         struct regmap *map;
176         unsigned int offset;
177
178         mvebu_gpioreg_edge_cause(mvchip, &map, &offset);
179         regmap_write(map, offset, val);
180 }
181
182 static inline void
183 mvebu_gpioreg_edge_mask(struct mvebu_gpio_chip *mvchip,
184                         struct regmap **map, unsigned int *offset)
185 {
186         int cpu;
187
188         switch (mvchip->soc_variant) {
189         case MVEBU_GPIO_SOC_VARIANT_ORION:
190         case MVEBU_GPIO_SOC_VARIANT_A8K:
191                 *map = mvchip->regs;
192                 *offset = GPIO_EDGE_MASK_OFF + mvchip->offset;
193                 break;
194         case MVEBU_GPIO_SOC_VARIANT_MV78200:
195                 cpu = smp_processor_id();
196                 *map = mvchip->regs;
197                 *offset = GPIO_EDGE_MASK_MV78200_OFF(cpu);
198                 break;
199         case MVEBU_GPIO_SOC_VARIANT_ARMADAXP:
200                 cpu = smp_processor_id();
201                 *map = mvchip->percpu_regs;
202                 *offset = GPIO_EDGE_MASK_ARMADAXP_OFF(cpu);
203                 break;
204         default:
205                 BUG();
206         }
207 }
208
209 static u32
210 mvebu_gpio_read_edge_mask(struct mvebu_gpio_chip *mvchip)
211 {
212         struct regmap *map;
213         unsigned int offset;
214         u32 val;
215
216         mvebu_gpioreg_edge_mask(mvchip, &map, &offset);
217         regmap_read(map, offset, &val);
218
219         return val;
220 }
221
222 static void
223 mvebu_gpio_write_edge_mask(struct mvebu_gpio_chip *mvchip, u32 val)
224 {
225         struct regmap *map;
226         unsigned int offset;
227
228         mvebu_gpioreg_edge_mask(mvchip, &map, &offset);
229         regmap_write(map, offset, val);
230 }
231
232 static void
233 mvebu_gpioreg_level_mask(struct mvebu_gpio_chip *mvchip,
234                          struct regmap **map, unsigned int *offset)
235 {
236         int cpu;
237
238         switch (mvchip->soc_variant) {
239         case MVEBU_GPIO_SOC_VARIANT_ORION:
240         case MVEBU_GPIO_SOC_VARIANT_A8K:
241                 *map = mvchip->regs;
242                 *offset = GPIO_LEVEL_MASK_OFF + mvchip->offset;
243                 break;
244         case MVEBU_GPIO_SOC_VARIANT_MV78200:
245                 cpu = smp_processor_id();
246                 *map = mvchip->regs;
247                 *offset = GPIO_LEVEL_MASK_MV78200_OFF(cpu);
248                 break;
249         case MVEBU_GPIO_SOC_VARIANT_ARMADAXP:
250                 cpu = smp_processor_id();
251                 *map = mvchip->percpu_regs;
252                 *offset = GPIO_LEVEL_MASK_ARMADAXP_OFF(cpu);
253                 break;
254         default:
255                 BUG();
256         }
257 }
258
259 static u32
260 mvebu_gpio_read_level_mask(struct mvebu_gpio_chip *mvchip)
261 {
262         struct regmap *map;
263         unsigned int offset;
264         u32 val;
265
266         mvebu_gpioreg_level_mask(mvchip, &map, &offset);
267         regmap_read(map, offset, &val);
268
269         return val;
270 }
271
272 static void
273 mvebu_gpio_write_level_mask(struct mvebu_gpio_chip *mvchip, u32 val)
274 {
275         struct regmap *map;
276         unsigned int offset;
277
278         mvebu_gpioreg_level_mask(mvchip, &map, &offset);
279         regmap_write(map, offset, val);
280 }
281
282 /*
283  * Functions returning addresses of individual registers for a given
284  * PWM controller.
285  */
286 static void __iomem *mvebu_pwmreg_blink_on_duration(struct mvebu_pwm *mvpwm)
287 {
288         return mvpwm->membase + PWM_BLINK_ON_DURATION_OFF;
289 }
290
291 static void __iomem *mvebu_pwmreg_blink_off_duration(struct mvebu_pwm *mvpwm)
292 {
293         return mvpwm->membase + PWM_BLINK_OFF_DURATION_OFF;
294 }
295
296 /*
297  * Functions implementing the gpio_chip methods
298  */
299 static void mvebu_gpio_set(struct gpio_chip *chip, unsigned int pin, int value)
300 {
301         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
302
303         regmap_update_bits(mvchip->regs, GPIO_OUT_OFF + mvchip->offset,
304                            BIT(pin), value ? BIT(pin) : 0);
305 }
306
307 static int mvebu_gpio_get(struct gpio_chip *chip, unsigned int pin)
308 {
309         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
310         u32 u;
311
312         regmap_read(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset, &u);
313
314         if (u & BIT(pin)) {
315                 u32 data_in, in_pol;
316
317                 regmap_read(mvchip->regs, GPIO_DATA_IN_OFF + mvchip->offset,
318                             &data_in);
319                 regmap_read(mvchip->regs, GPIO_IN_POL_OFF + mvchip->offset,
320                             &in_pol);
321                 u = data_in ^ in_pol;
322         } else {
323                 regmap_read(mvchip->regs, GPIO_OUT_OFF + mvchip->offset, &u);
324         }
325
326         return (u >> pin) & 1;
327 }
328
329 static void mvebu_gpio_blink(struct gpio_chip *chip, unsigned int pin,
330                              int value)
331 {
332         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
333
334         regmap_update_bits(mvchip->regs, GPIO_BLINK_EN_OFF + mvchip->offset,
335                            BIT(pin), value ? BIT(pin) : 0);
336 }
337
338 static int mvebu_gpio_direction_input(struct gpio_chip *chip, unsigned int pin)
339 {
340         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
341         int ret;
342
343         /*
344          * Check with the pinctrl driver whether this pin is usable as
345          * an input GPIO
346          */
347         ret = pinctrl_gpio_direction_input(chip->base + pin);
348         if (ret)
349                 return ret;
350
351         regmap_update_bits(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset,
352                            BIT(pin), BIT(pin));
353
354         return 0;
355 }
356
357 static int mvebu_gpio_direction_output(struct gpio_chip *chip, unsigned int pin,
358                                        int value)
359 {
360         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
361         int ret;
362
363         /*
364          * Check with the pinctrl driver whether this pin is usable as
365          * an output GPIO
366          */
367         ret = pinctrl_gpio_direction_output(chip->base + pin);
368         if (ret)
369                 return ret;
370
371         mvebu_gpio_blink(chip, pin, 0);
372         mvebu_gpio_set(chip, pin, value);
373
374         regmap_update_bits(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset,
375                            BIT(pin), 0);
376
377         return 0;
378 }
379
380 static int mvebu_gpio_to_irq(struct gpio_chip *chip, unsigned int pin)
381 {
382         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
383
384         return irq_create_mapping(mvchip->domain, pin);
385 }
386
387 /*
388  * Functions implementing the irq_chip methods
389  */
390 static void mvebu_gpio_irq_ack(struct irq_data *d)
391 {
392         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
393         struct mvebu_gpio_chip *mvchip = gc->private;
394         u32 mask = d->mask;
395
396         irq_gc_lock(gc);
397         mvebu_gpio_write_edge_cause(mvchip, ~mask);
398         irq_gc_unlock(gc);
399 }
400
401 static void mvebu_gpio_edge_irq_mask(struct irq_data *d)
402 {
403         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
404         struct mvebu_gpio_chip *mvchip = gc->private;
405         struct irq_chip_type *ct = irq_data_get_chip_type(d);
406         u32 mask = d->mask;
407
408         irq_gc_lock(gc);
409         ct->mask_cache_priv &= ~mask;
410         mvebu_gpio_write_edge_mask(mvchip, ct->mask_cache_priv);
411         irq_gc_unlock(gc);
412 }
413
414 static void mvebu_gpio_edge_irq_unmask(struct irq_data *d)
415 {
416         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
417         struct mvebu_gpio_chip *mvchip = gc->private;
418         struct irq_chip_type *ct = irq_data_get_chip_type(d);
419         u32 mask = d->mask;
420
421         irq_gc_lock(gc);
422         ct->mask_cache_priv |= mask;
423         mvebu_gpio_write_edge_mask(mvchip, ct->mask_cache_priv);
424         irq_gc_unlock(gc);
425 }
426
427 static void mvebu_gpio_level_irq_mask(struct irq_data *d)
428 {
429         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
430         struct mvebu_gpio_chip *mvchip = gc->private;
431         struct irq_chip_type *ct = irq_data_get_chip_type(d);
432         u32 mask = d->mask;
433
434         irq_gc_lock(gc);
435         ct->mask_cache_priv &= ~mask;
436         mvebu_gpio_write_level_mask(mvchip, ct->mask_cache_priv);
437         irq_gc_unlock(gc);
438 }
439
440 static void mvebu_gpio_level_irq_unmask(struct irq_data *d)
441 {
442         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
443         struct mvebu_gpio_chip *mvchip = gc->private;
444         struct irq_chip_type *ct = irq_data_get_chip_type(d);
445         u32 mask = d->mask;
446
447         irq_gc_lock(gc);
448         ct->mask_cache_priv |= mask;
449         mvebu_gpio_write_level_mask(mvchip, ct->mask_cache_priv);
450         irq_gc_unlock(gc);
451 }
452
453 /*****************************************************************************
454  * MVEBU GPIO IRQ
455  *
456  * GPIO_IN_POL register controls whether GPIO_DATA_IN will hold the same
457  * value of the line or the opposite value.
458  *
459  * Level IRQ handlers: DATA_IN is used directly as cause register.
460  *                     Interrupt are masked by LEVEL_MASK registers.
461  * Edge IRQ handlers:  Change in DATA_IN are latched in EDGE_CAUSE.
462  *                     Interrupt are masked by EDGE_MASK registers.
463  * Both-edge handlers: Similar to regular Edge handlers, but also swaps
464  *                     the polarity to catch the next line transaction.
465  *                     This is a race condition that might not perfectly
466  *                     work on some use cases.
467  *
468  * Every eight GPIO lines are grouped (OR'ed) before going up to main
469  * cause register.
470  *
471  *                    EDGE  cause    mask
472  *        data-in   /--------| |-----| |----\
473  *     -----| |-----                         ---- to main cause reg
474  *           X      \----------------| |----/
475  *        polarity    LEVEL          mask
476  *
477  ****************************************************************************/
478
479 static int mvebu_gpio_irq_set_type(struct irq_data *d, unsigned int type)
480 {
481         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
482         struct irq_chip_type *ct = irq_data_get_chip_type(d);
483         struct mvebu_gpio_chip *mvchip = gc->private;
484         int pin;
485         u32 u;
486
487         pin = d->hwirq;
488
489         regmap_read(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset, &u);
490         if ((u & BIT(pin)) == 0)
491                 return -EINVAL;
492
493         type &= IRQ_TYPE_SENSE_MASK;
494         if (type == IRQ_TYPE_NONE)
495                 return -EINVAL;
496
497         /* Check if we need to change chip and handler */
498         if (!(ct->type & type))
499                 if (irq_setup_alt_chip(d, type))
500                         return -EINVAL;
501
502         /*
503          * Configure interrupt polarity.
504          */
505         switch (type) {
506         case IRQ_TYPE_EDGE_RISING:
507         case IRQ_TYPE_LEVEL_HIGH:
508                 regmap_update_bits(mvchip->regs,
509                                    GPIO_IN_POL_OFF + mvchip->offset,
510                                    BIT(pin), 0);
511                 break;
512         case IRQ_TYPE_EDGE_FALLING:
513         case IRQ_TYPE_LEVEL_LOW:
514                 regmap_update_bits(mvchip->regs,
515                                    GPIO_IN_POL_OFF + mvchip->offset,
516                                    BIT(pin), BIT(pin));
517                 break;
518         case IRQ_TYPE_EDGE_BOTH: {
519                 u32 data_in, in_pol, val;
520
521                 regmap_read(mvchip->regs,
522                             GPIO_IN_POL_OFF + mvchip->offset, &in_pol);
523                 regmap_read(mvchip->regs,
524                             GPIO_DATA_IN_OFF + mvchip->offset, &data_in);
525
526                 /*
527                  * set initial polarity based on current input level
528                  */
529                 if ((data_in ^ in_pol) & BIT(pin))
530                         val = BIT(pin); /* falling */
531                 else
532                         val = 0; /* raising */
533
534                 regmap_update_bits(mvchip->regs,
535                                    GPIO_IN_POL_OFF + mvchip->offset,
536                                    BIT(pin), val);
537                 break;
538         }
539         }
540         return 0;
541 }
542
543 static void mvebu_gpio_irq_handler(struct irq_desc *desc)
544 {
545         struct mvebu_gpio_chip *mvchip = irq_desc_get_handler_data(desc);
546         struct irq_chip *chip = irq_desc_get_chip(desc);
547         u32 cause, type, data_in, level_mask, edge_cause, edge_mask;
548         int i;
549
550         if (mvchip == NULL)
551                 return;
552
553         chained_irq_enter(chip, desc);
554
555         regmap_read(mvchip->regs, GPIO_DATA_IN_OFF + mvchip->offset, &data_in);
556         level_mask = mvebu_gpio_read_level_mask(mvchip);
557         edge_cause = mvebu_gpio_read_edge_cause(mvchip);
558         edge_mask  = mvebu_gpio_read_edge_mask(mvchip);
559
560         cause = (data_in ^ level_mask) | (edge_cause & edge_mask);
561
562         for (i = 0; i < mvchip->chip.ngpio; i++) {
563                 int irq;
564
565                 irq = irq_find_mapping(mvchip->domain, i);
566
567                 if (!(cause & BIT(i)))
568                         continue;
569
570                 type = irq_get_trigger_type(irq);
571                 if ((type & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH) {
572                         /* Swap polarity (race with GPIO line) */
573                         u32 polarity;
574
575                         regmap_read(mvchip->regs,
576                                     GPIO_IN_POL_OFF + mvchip->offset,
577                                     &polarity);
578                         polarity ^= BIT(i);
579                         regmap_write(mvchip->regs,
580                                      GPIO_IN_POL_OFF + mvchip->offset,
581                                      polarity);
582                 }
583
584                 generic_handle_irq(irq);
585         }
586
587         chained_irq_exit(chip, desc);
588 }
589
590 /*
591  * Functions implementing the pwm_chip methods
592  */
593 static struct mvebu_pwm *to_mvebu_pwm(struct pwm_chip *chip)
594 {
595         return container_of(chip, struct mvebu_pwm, chip);
596 }
597
598 static int mvebu_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
599 {
600         struct mvebu_pwm *mvpwm = to_mvebu_pwm(chip);
601         struct mvebu_gpio_chip *mvchip = mvpwm->mvchip;
602         struct gpio_desc *desc;
603         unsigned long flags;
604         int ret = 0;
605
606         spin_lock_irqsave(&mvpwm->lock, flags);
607
608         if (mvpwm->gpiod) {
609                 ret = -EBUSY;
610         } else {
611                 desc = gpio_to_desc(mvchip->chip.base + pwm->hwpwm);
612                 if (!desc) {
613                         ret = -ENODEV;
614                         goto out;
615                 }
616
617                 ret = gpiod_request(desc, "mvebu-pwm");
618                 if (ret)
619                         goto out;
620
621                 ret = gpiod_direction_output(desc, 0);
622                 if (ret) {
623                         gpiod_free(desc);
624                         goto out;
625                 }
626
627                 mvpwm->gpiod = desc;
628         }
629 out:
630         spin_unlock_irqrestore(&mvpwm->lock, flags);
631         return ret;
632 }
633
634 static void mvebu_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
635 {
636         struct mvebu_pwm *mvpwm = to_mvebu_pwm(chip);
637         unsigned long flags;
638
639         spin_lock_irqsave(&mvpwm->lock, flags);
640         gpiod_free(mvpwm->gpiod);
641         mvpwm->gpiod = NULL;
642         spin_unlock_irqrestore(&mvpwm->lock, flags);
643 }
644
645 static void mvebu_pwm_get_state(struct pwm_chip *chip,
646                                 struct pwm_device *pwm,
647                                 struct pwm_state *state) {
648
649         struct mvebu_pwm *mvpwm = to_mvebu_pwm(chip);
650         struct mvebu_gpio_chip *mvchip = mvpwm->mvchip;
651         unsigned long long val;
652         unsigned long flags;
653         u32 u;
654
655         spin_lock_irqsave(&mvpwm->lock, flags);
656
657         val = (unsigned long long)
658                 readl_relaxed(mvebu_pwmreg_blink_on_duration(mvpwm));
659         val *= NSEC_PER_SEC;
660         do_div(val, mvpwm->clk_rate);
661         if (val > UINT_MAX)
662                 state->duty_cycle = UINT_MAX;
663         else if (val)
664                 state->duty_cycle = val;
665         else
666                 state->duty_cycle = 1;
667
668         val = (unsigned long long)
669                 readl_relaxed(mvebu_pwmreg_blink_off_duration(mvpwm));
670         val *= NSEC_PER_SEC;
671         do_div(val, mvpwm->clk_rate);
672         if (val < state->duty_cycle) {
673                 state->period = 1;
674         } else {
675                 val -= state->duty_cycle;
676                 if (val > UINT_MAX)
677                         state->period = UINT_MAX;
678                 else if (val)
679                         state->period = val;
680                 else
681                         state->period = 1;
682         }
683
684         regmap_read(mvchip->regs, GPIO_BLINK_EN_OFF + mvchip->offset, &u);
685         if (u)
686                 state->enabled = true;
687         else
688                 state->enabled = false;
689
690         spin_unlock_irqrestore(&mvpwm->lock, flags);
691 }
692
693 static int mvebu_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
694                            struct pwm_state *state)
695 {
696         struct mvebu_pwm *mvpwm = to_mvebu_pwm(chip);
697         struct mvebu_gpio_chip *mvchip = mvpwm->mvchip;
698         unsigned long long val;
699         unsigned long flags;
700         unsigned int on, off;
701
702         val = (unsigned long long) mvpwm->clk_rate * state->duty_cycle;
703         do_div(val, NSEC_PER_SEC);
704         if (val > UINT_MAX)
705                 return -EINVAL;
706         if (val)
707                 on = val;
708         else
709                 on = 1;
710
711         val = (unsigned long long) mvpwm->clk_rate *
712                 (state->period - state->duty_cycle);
713         do_div(val, NSEC_PER_SEC);
714         if (val > UINT_MAX)
715                 return -EINVAL;
716         if (val)
717                 off = val;
718         else
719                 off = 1;
720
721         spin_lock_irqsave(&mvpwm->lock, flags);
722
723         writel_relaxed(on, mvebu_pwmreg_blink_on_duration(mvpwm));
724         writel_relaxed(off, mvebu_pwmreg_blink_off_duration(mvpwm));
725         if (state->enabled)
726                 mvebu_gpio_blink(&mvchip->chip, pwm->hwpwm, 1);
727         else
728                 mvebu_gpio_blink(&mvchip->chip, pwm->hwpwm, 0);
729
730         spin_unlock_irqrestore(&mvpwm->lock, flags);
731
732         return 0;
733 }
734
735 static const struct pwm_ops mvebu_pwm_ops = {
736         .request = mvebu_pwm_request,
737         .free = mvebu_pwm_free,
738         .get_state = mvebu_pwm_get_state,
739         .apply = mvebu_pwm_apply,
740         .owner = THIS_MODULE,
741 };
742
743 static void __maybe_unused mvebu_pwm_suspend(struct mvebu_gpio_chip *mvchip)
744 {
745         struct mvebu_pwm *mvpwm = mvchip->mvpwm;
746
747         regmap_read(mvchip->regs, GPIO_BLINK_CNT_SELECT_OFF + mvchip->offset,
748                     &mvpwm->blink_select);
749         mvpwm->blink_on_duration =
750                 readl_relaxed(mvebu_pwmreg_blink_on_duration(mvpwm));
751         mvpwm->blink_off_duration =
752                 readl_relaxed(mvebu_pwmreg_blink_off_duration(mvpwm));
753 }
754
755 static void __maybe_unused mvebu_pwm_resume(struct mvebu_gpio_chip *mvchip)
756 {
757         struct mvebu_pwm *mvpwm = mvchip->mvpwm;
758
759         regmap_write(mvchip->regs, GPIO_BLINK_CNT_SELECT_OFF + mvchip->offset,
760                      mvpwm->blink_select);
761         writel_relaxed(mvpwm->blink_on_duration,
762                        mvebu_pwmreg_blink_on_duration(mvpwm));
763         writel_relaxed(mvpwm->blink_off_duration,
764                        mvebu_pwmreg_blink_off_duration(mvpwm));
765 }
766
767 static int mvebu_pwm_probe(struct platform_device *pdev,
768                            struct mvebu_gpio_chip *mvchip,
769                            int id)
770 {
771         struct device *dev = &pdev->dev;
772         struct mvebu_pwm *mvpwm;
773         struct resource *res;
774         u32 set;
775
776         if (!of_device_is_compatible(mvchip->chip.of_node,
777                                      "marvell,armada-370-xp-gpio"))
778                 return 0;
779
780         if (IS_ERR(mvchip->clk))
781                 return PTR_ERR(mvchip->clk);
782
783         /*
784          * There are only two sets of PWM configuration registers for
785          * all the GPIO lines on those SoCs which this driver reserves
786          * for the first two GPIO chips. So if the resource is missing
787          * we can't treat it as an error.
788          */
789         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pwm");
790         if (!res)
791                 return 0;
792
793         /*
794          * Use set A for lines of GPIO chip with id 0, B for GPIO chip
795          * with id 1. Don't allow further GPIO chips to be used for PWM.
796          */
797         if (id == 0)
798                 set = 0;
799         else if (id == 1)
800                 set = U32_MAX;
801         else
802                 return -EINVAL;
803         regmap_write(mvchip->regs,
804                      GPIO_BLINK_CNT_SELECT_OFF + mvchip->offset, 0);
805
806         mvpwm = devm_kzalloc(dev, sizeof(struct mvebu_pwm), GFP_KERNEL);
807         if (!mvpwm)
808                 return -ENOMEM;
809         mvchip->mvpwm = mvpwm;
810         mvpwm->mvchip = mvchip;
811
812         mvpwm->membase = devm_ioremap_resource(dev, res);
813         if (IS_ERR(mvpwm->membase))
814                 return PTR_ERR(mvpwm->membase);
815
816         mvpwm->clk_rate = clk_get_rate(mvchip->clk);
817         if (!mvpwm->clk_rate) {
818                 dev_err(dev, "failed to get clock rate\n");
819                 return -EINVAL;
820         }
821
822         mvpwm->chip.dev = dev;
823         mvpwm->chip.ops = &mvebu_pwm_ops;
824         mvpwm->chip.npwm = mvchip->chip.ngpio;
825
826         spin_lock_init(&mvpwm->lock);
827
828         return pwmchip_add(&mvpwm->chip);
829 }
830
831 #ifdef CONFIG_DEBUG_FS
832 #include <linux/seq_file.h>
833
834 static void mvebu_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
835 {
836         struct mvebu_gpio_chip *mvchip = gpiochip_get_data(chip);
837         u32 out, io_conf, blink, in_pol, data_in, cause, edg_msk, lvl_msk;
838         int i;
839
840         regmap_read(mvchip->regs, GPIO_OUT_OFF + mvchip->offset, &out);
841         regmap_read(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset, &io_conf);
842         regmap_read(mvchip->regs, GPIO_BLINK_EN_OFF + mvchip->offset, &blink);
843         regmap_read(mvchip->regs, GPIO_IN_POL_OFF + mvchip->offset, &in_pol);
844         regmap_read(mvchip->regs, GPIO_DATA_IN_OFF + mvchip->offset, &data_in);
845         cause   = mvebu_gpio_read_edge_cause(mvchip);
846         edg_msk = mvebu_gpio_read_edge_mask(mvchip);
847         lvl_msk = mvebu_gpio_read_level_mask(mvchip);
848
849         for (i = 0; i < chip->ngpio; i++) {
850                 const char *label;
851                 u32 msk;
852                 bool is_out;
853
854                 label = gpiochip_is_requested(chip, i);
855                 if (!label)
856                         continue;
857
858                 msk = BIT(i);
859                 is_out = !(io_conf & msk);
860
861                 seq_printf(s, " gpio-%-3d (%-20.20s)", chip->base + i, label);
862
863                 if (is_out) {
864                         seq_printf(s, " out %s %s\n",
865                                    out & msk ? "hi" : "lo",
866                                    blink & msk ? "(blink )" : "");
867                         continue;
868                 }
869
870                 seq_printf(s, " in  %s (act %s) - IRQ",
871                            (data_in ^ in_pol) & msk  ? "hi" : "lo",
872                            in_pol & msk ? "lo" : "hi");
873                 if (!((edg_msk | lvl_msk) & msk)) {
874                         seq_puts(s, " disabled\n");
875                         continue;
876                 }
877                 if (edg_msk & msk)
878                         seq_puts(s, " edge ");
879                 if (lvl_msk & msk)
880                         seq_puts(s, " level");
881                 seq_printf(s, " (%s)\n", cause & msk ? "pending" : "clear  ");
882         }
883 }
884 #else
885 #define mvebu_gpio_dbg_show NULL
886 #endif
887
888 static const struct of_device_id mvebu_gpio_of_match[] = {
889         {
890                 .compatible = "marvell,orion-gpio",
891                 .data       = (void *) MVEBU_GPIO_SOC_VARIANT_ORION,
892         },
893         {
894                 .compatible = "marvell,mv78200-gpio",
895                 .data       = (void *) MVEBU_GPIO_SOC_VARIANT_MV78200,
896         },
897         {
898                 .compatible = "marvell,armadaxp-gpio",
899                 .data       = (void *) MVEBU_GPIO_SOC_VARIANT_ARMADAXP,
900         },
901         {
902                 .compatible = "marvell,armada-370-xp-gpio",
903                 .data       = (void *) MVEBU_GPIO_SOC_VARIANT_ORION,
904         },
905         {
906                 .compatible = "marvell,armada-8k-gpio",
907                 .data       = (void *) MVEBU_GPIO_SOC_VARIANT_A8K,
908         },
909         {
910                 /* sentinel */
911         },
912 };
913
914 static int mvebu_gpio_suspend(struct platform_device *pdev, pm_message_t state)
915 {
916         struct mvebu_gpio_chip *mvchip = platform_get_drvdata(pdev);
917         int i;
918
919         regmap_read(mvchip->regs, GPIO_OUT_OFF + mvchip->offset,
920                     &mvchip->out_reg);
921         regmap_read(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset,
922                     &mvchip->io_conf_reg);
923         regmap_read(mvchip->regs, GPIO_BLINK_EN_OFF + mvchip->offset,
924                     &mvchip->blink_en_reg);
925         regmap_read(mvchip->regs, GPIO_IN_POL_OFF + mvchip->offset,
926                     &mvchip->in_pol_reg);
927
928         switch (mvchip->soc_variant) {
929         case MVEBU_GPIO_SOC_VARIANT_ORION:
930         case MVEBU_GPIO_SOC_VARIANT_A8K:
931                 regmap_read(mvchip->regs, GPIO_EDGE_MASK_OFF + mvchip->offset,
932                             &mvchip->edge_mask_regs[0]);
933                 regmap_read(mvchip->regs, GPIO_LEVEL_MASK_OFF + mvchip->offset,
934                             &mvchip->level_mask_regs[0]);
935                 break;
936         case MVEBU_GPIO_SOC_VARIANT_MV78200:
937                 for (i = 0; i < 2; i++) {
938                         regmap_read(mvchip->regs,
939                                     GPIO_EDGE_MASK_MV78200_OFF(i),
940                                     &mvchip->edge_mask_regs[i]);
941                         regmap_read(mvchip->regs,
942                                     GPIO_LEVEL_MASK_MV78200_OFF(i),
943                                     &mvchip->level_mask_regs[i]);
944                 }
945                 break;
946         case MVEBU_GPIO_SOC_VARIANT_ARMADAXP:
947                 for (i = 0; i < 4; i++) {
948                         regmap_read(mvchip->regs,
949                                     GPIO_EDGE_MASK_ARMADAXP_OFF(i),
950                                     &mvchip->edge_mask_regs[i]);
951                         regmap_read(mvchip->regs,
952                                     GPIO_LEVEL_MASK_ARMADAXP_OFF(i),
953                                     &mvchip->level_mask_regs[i]);
954                 }
955                 break;
956         default:
957                 BUG();
958         }
959
960         if (IS_ENABLED(CONFIG_PWM))
961                 mvebu_pwm_suspend(mvchip);
962
963         return 0;
964 }
965
966 static int mvebu_gpio_resume(struct platform_device *pdev)
967 {
968         struct mvebu_gpio_chip *mvchip = platform_get_drvdata(pdev);
969         int i;
970
971         regmap_write(mvchip->regs, GPIO_OUT_OFF + mvchip->offset,
972                      mvchip->out_reg);
973         regmap_write(mvchip->regs, GPIO_IO_CONF_OFF + mvchip->offset,
974                      mvchip->io_conf_reg);
975         regmap_write(mvchip->regs, GPIO_BLINK_EN_OFF + mvchip->offset,
976                      mvchip->blink_en_reg);
977         regmap_write(mvchip->regs, GPIO_IN_POL_OFF + mvchip->offset,
978                      mvchip->in_pol_reg);
979
980         switch (mvchip->soc_variant) {
981         case MVEBU_GPIO_SOC_VARIANT_ORION:
982         case MVEBU_GPIO_SOC_VARIANT_A8K:
983                 regmap_write(mvchip->regs, GPIO_EDGE_MASK_OFF + mvchip->offset,
984                              mvchip->edge_mask_regs[0]);
985                 regmap_write(mvchip->regs, GPIO_LEVEL_MASK_OFF + mvchip->offset,
986                              mvchip->level_mask_regs[0]);
987                 break;
988         case MVEBU_GPIO_SOC_VARIANT_MV78200:
989                 for (i = 0; i < 2; i++) {
990                         regmap_write(mvchip->regs,
991                                      GPIO_EDGE_MASK_MV78200_OFF(i),
992                                      mvchip->edge_mask_regs[i]);
993                         regmap_write(mvchip->regs,
994                                      GPIO_LEVEL_MASK_MV78200_OFF(i),
995                                      mvchip->level_mask_regs[i]);
996                 }
997                 break;
998         case MVEBU_GPIO_SOC_VARIANT_ARMADAXP:
999                 for (i = 0; i < 4; i++) {
1000                         regmap_write(mvchip->regs,
1001                                      GPIO_EDGE_MASK_ARMADAXP_OFF(i),
1002                                      mvchip->edge_mask_regs[i]);
1003                         regmap_write(mvchip->regs,
1004                                      GPIO_LEVEL_MASK_ARMADAXP_OFF(i),
1005                                      mvchip->level_mask_regs[i]);
1006                 }
1007                 break;
1008         default:
1009                 BUG();
1010         }
1011
1012         if (IS_ENABLED(CONFIG_PWM))
1013                 mvebu_pwm_resume(mvchip);
1014
1015         return 0;
1016 }
1017
1018 static const struct regmap_config mvebu_gpio_regmap_config = {
1019         .reg_bits = 32,
1020         .reg_stride = 4,
1021         .val_bits = 32,
1022         .fast_io = true,
1023 };
1024
1025 static int mvebu_gpio_probe_raw(struct platform_device *pdev,
1026                                 struct mvebu_gpio_chip *mvchip)
1027 {
1028         struct resource *res;
1029         void __iomem *base;
1030
1031         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1032         base = devm_ioremap_resource(&pdev->dev, res);
1033         if (IS_ERR(base))
1034                 return PTR_ERR(base);
1035
1036         mvchip->regs = devm_regmap_init_mmio(&pdev->dev, base,
1037                                              &mvebu_gpio_regmap_config);
1038         if (IS_ERR(mvchip->regs))
1039                 return PTR_ERR(mvchip->regs);
1040
1041         /*
1042          * For the legacy SoCs, the regmap directly maps to the GPIO
1043          * registers, so no offset is needed.
1044          */
1045         mvchip->offset = 0;
1046
1047         /*
1048          * The Armada XP has a second range of registers for the
1049          * per-CPU registers
1050          */
1051         if (mvchip->soc_variant == MVEBU_GPIO_SOC_VARIANT_ARMADAXP) {
1052                 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1053                 base = devm_ioremap_resource(&pdev->dev, res);
1054                 if (IS_ERR(base))
1055                         return PTR_ERR(base);
1056
1057                 mvchip->percpu_regs =
1058                         devm_regmap_init_mmio(&pdev->dev, base,
1059                                               &mvebu_gpio_regmap_config);
1060                 if (IS_ERR(mvchip->percpu_regs))
1061                         return PTR_ERR(mvchip->percpu_regs);
1062         }
1063
1064         return 0;
1065 }
1066
1067 static int mvebu_gpio_probe_syscon(struct platform_device *pdev,
1068                                    struct mvebu_gpio_chip *mvchip)
1069 {
1070         mvchip->regs = syscon_node_to_regmap(pdev->dev.parent->of_node);
1071         if (IS_ERR(mvchip->regs))
1072                 return PTR_ERR(mvchip->regs);
1073
1074         if (of_property_read_u32(pdev->dev.of_node, "offset", &mvchip->offset))
1075                 return -EINVAL;
1076
1077         return 0;
1078 }
1079
1080 static int mvebu_gpio_probe(struct platform_device *pdev)
1081 {
1082         struct mvebu_gpio_chip *mvchip;
1083         const struct of_device_id *match;
1084         struct device_node *np = pdev->dev.of_node;
1085         struct irq_chip_generic *gc;
1086         struct irq_chip_type *ct;
1087         unsigned int ngpios;
1088         bool have_irqs;
1089         int soc_variant;
1090         int i, cpu, id;
1091         int err;
1092
1093         match = of_match_device(mvebu_gpio_of_match, &pdev->dev);
1094         if (match)
1095                 soc_variant = (unsigned long) match->data;
1096         else
1097                 soc_variant = MVEBU_GPIO_SOC_VARIANT_ORION;
1098
1099         /* Some gpio controllers do not provide irq support */
1100         have_irqs = of_irq_count(np) != 0;
1101
1102         mvchip = devm_kzalloc(&pdev->dev, sizeof(struct mvebu_gpio_chip),
1103                               GFP_KERNEL);
1104         if (!mvchip)
1105                 return -ENOMEM;
1106
1107         platform_set_drvdata(pdev, mvchip);
1108
1109         if (of_property_read_u32(pdev->dev.of_node, "ngpios", &ngpios)) {
1110                 dev_err(&pdev->dev, "Missing ngpios OF property\n");
1111                 return -ENODEV;
1112         }
1113
1114         id = of_alias_get_id(pdev->dev.of_node, "gpio");
1115         if (id < 0) {
1116                 dev_err(&pdev->dev, "Couldn't get OF id\n");
1117                 return id;
1118         }
1119
1120         mvchip->clk = devm_clk_get(&pdev->dev, NULL);
1121         /* Not all SoCs require a clock.*/
1122         if (!IS_ERR(mvchip->clk))
1123                 clk_prepare_enable(mvchip->clk);
1124
1125         mvchip->soc_variant = soc_variant;
1126         mvchip->chip.label = dev_name(&pdev->dev);
1127         mvchip->chip.parent = &pdev->dev;
1128         mvchip->chip.request = gpiochip_generic_request;
1129         mvchip->chip.free = gpiochip_generic_free;
1130         mvchip->chip.direction_input = mvebu_gpio_direction_input;
1131         mvchip->chip.get = mvebu_gpio_get;
1132         mvchip->chip.direction_output = mvebu_gpio_direction_output;
1133         mvchip->chip.set = mvebu_gpio_set;
1134         if (have_irqs)
1135                 mvchip->chip.to_irq = mvebu_gpio_to_irq;
1136         mvchip->chip.base = id * MVEBU_MAX_GPIO_PER_BANK;
1137         mvchip->chip.ngpio = ngpios;
1138         mvchip->chip.can_sleep = false;
1139         mvchip->chip.of_node = np;
1140         mvchip->chip.dbg_show = mvebu_gpio_dbg_show;
1141
1142         if (soc_variant == MVEBU_GPIO_SOC_VARIANT_A8K)
1143                 err = mvebu_gpio_probe_syscon(pdev, mvchip);
1144         else
1145                 err = mvebu_gpio_probe_raw(pdev, mvchip);
1146
1147         if (err)
1148                 return err;
1149
1150         /*
1151          * Mask and clear GPIO interrupts.
1152          */
1153         switch (soc_variant) {
1154         case MVEBU_GPIO_SOC_VARIANT_ORION:
1155         case MVEBU_GPIO_SOC_VARIANT_A8K:
1156                 regmap_write(mvchip->regs,
1157                              GPIO_EDGE_CAUSE_OFF + mvchip->offset, 0);
1158                 regmap_write(mvchip->regs,
1159                              GPIO_EDGE_MASK_OFF + mvchip->offset, 0);
1160                 regmap_write(mvchip->regs,
1161                              GPIO_LEVEL_MASK_OFF + mvchip->offset, 0);
1162                 break;
1163         case MVEBU_GPIO_SOC_VARIANT_MV78200:
1164                 regmap_write(mvchip->regs, GPIO_EDGE_CAUSE_OFF, 0);
1165                 for (cpu = 0; cpu < 2; cpu++) {
1166                         regmap_write(mvchip->regs,
1167                                      GPIO_EDGE_MASK_MV78200_OFF(cpu), 0);
1168                         regmap_write(mvchip->regs,
1169                                      GPIO_LEVEL_MASK_MV78200_OFF(cpu), 0);
1170                 }
1171                 break;
1172         case MVEBU_GPIO_SOC_VARIANT_ARMADAXP:
1173                 regmap_write(mvchip->regs, GPIO_EDGE_CAUSE_OFF, 0);
1174                 regmap_write(mvchip->regs, GPIO_EDGE_MASK_OFF, 0);
1175                 regmap_write(mvchip->regs, GPIO_LEVEL_MASK_OFF, 0);
1176                 for (cpu = 0; cpu < 4; cpu++) {
1177                         regmap_write(mvchip->percpu_regs,
1178                                      GPIO_EDGE_CAUSE_ARMADAXP_OFF(cpu), 0);
1179                         regmap_write(mvchip->percpu_regs,
1180                                      GPIO_EDGE_MASK_ARMADAXP_OFF(cpu), 0);
1181                         regmap_write(mvchip->percpu_regs,
1182                                      GPIO_LEVEL_MASK_ARMADAXP_OFF(cpu), 0);
1183                 }
1184                 break;
1185         default:
1186                 BUG();
1187         }
1188
1189         devm_gpiochip_add_data(&pdev->dev, &mvchip->chip, mvchip);
1190
1191         /* Some gpio controllers do not provide irq support */
1192         if (!have_irqs)
1193                 return 0;
1194
1195         mvchip->domain =
1196             irq_domain_add_linear(np, ngpios, &irq_generic_chip_ops, NULL);
1197         if (!mvchip->domain) {
1198                 dev_err(&pdev->dev, "couldn't allocate irq domain %s (DT).\n",
1199                         mvchip->chip.label);
1200                 return -ENODEV;
1201         }
1202
1203         err = irq_alloc_domain_generic_chips(
1204             mvchip->domain, ngpios, 2, np->name, handle_level_irq,
1205             IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_LEVEL, 0, 0);
1206         if (err) {
1207                 dev_err(&pdev->dev, "couldn't allocate irq chips %s (DT).\n",
1208                         mvchip->chip.label);
1209                 goto err_domain;
1210         }
1211
1212         /*
1213          * NOTE: The common accessors cannot be used because of the percpu
1214          * access to the mask registers
1215          */
1216         gc = irq_get_domain_generic_chip(mvchip->domain, 0);
1217         gc->private = mvchip;
1218         ct = &gc->chip_types[0];
1219         ct->type = IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW;
1220         ct->chip.irq_mask = mvebu_gpio_level_irq_mask;
1221         ct->chip.irq_unmask = mvebu_gpio_level_irq_unmask;
1222         ct->chip.irq_set_type = mvebu_gpio_irq_set_type;
1223         ct->chip.name = mvchip->chip.label;
1224
1225         ct = &gc->chip_types[1];
1226         ct->type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
1227         ct->chip.irq_ack = mvebu_gpio_irq_ack;
1228         ct->chip.irq_mask = mvebu_gpio_edge_irq_mask;
1229         ct->chip.irq_unmask = mvebu_gpio_edge_irq_unmask;
1230         ct->chip.irq_set_type = mvebu_gpio_irq_set_type;
1231         ct->handler = handle_edge_irq;
1232         ct->chip.name = mvchip->chip.label;
1233
1234         /*
1235          * Setup the interrupt handlers. Each chip can have up to 4
1236          * interrupt handlers, with each handler dealing with 8 GPIO
1237          * pins.
1238          */
1239         for (i = 0; i < 4; i++) {
1240                 int irq = platform_get_irq(pdev, i);
1241
1242                 if (irq < 0)
1243                         continue;
1244                 irq_set_chained_handler_and_data(irq, mvebu_gpio_irq_handler,
1245                                                  mvchip);
1246         }
1247
1248         /* Armada 370/XP has simple PWM support for GPIO lines */
1249         if (IS_ENABLED(CONFIG_PWM))
1250                 return mvebu_pwm_probe(pdev, mvchip, id);
1251
1252         return 0;
1253
1254 err_domain:
1255         irq_domain_remove(mvchip->domain);
1256
1257         return err;
1258 }
1259
1260 static struct platform_driver mvebu_gpio_driver = {
1261         .driver         = {
1262                 .name           = "mvebu-gpio",
1263                 .of_match_table = mvebu_gpio_of_match,
1264         },
1265         .probe          = mvebu_gpio_probe,
1266         .suspend        = mvebu_gpio_suspend,
1267         .resume         = mvebu_gpio_resume,
1268 };
1269 builtin_platform_driver(mvebu_gpio_driver);