1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) Maxime Coquelin 2015
4 * Copyright (C) STMicroelectronics 2017
5 * Author: Maxime Coquelin <mcoquelin.stm32@gmail.com>
8 #include <linux/bitops.h>
9 #include <linux/delay.h>
10 #include <linux/hwspinlock.h>
11 #include <linux/interrupt.h>
13 #include <linux/irq.h>
14 #include <linux/irqchip.h>
15 #include <linux/irqchip/chained_irq.h>
16 #include <linux/irqdomain.h>
17 #include <linux/module.h>
18 #include <linux/of_address.h>
19 #include <linux/of_irq.h>
20 #include <linux/of_platform.h>
21 #include <linux/syscore_ops.h>
23 #include <dt-bindings/interrupt-controller/arm-gic.h>
25 #define IRQS_PER_BANK 32
27 #define HWSPNLCK_TIMEOUT 1000 /* usec */
29 struct stm32_exti_bank
{
41 struct stm32_desc_irq
{
44 struct irq_chip
*chip
;
47 struct stm32_exti_drv_data
{
48 const struct stm32_exti_bank
**exti_banks
;
49 const struct stm32_desc_irq
*desc_irqs
;
54 struct stm32_exti_chip_data
{
55 struct stm32_exti_host_data
*host_data
;
56 const struct stm32_exti_bank
*reg_bank
;
57 struct raw_spinlock rlock
;
64 struct stm32_exti_host_data
{
66 struct stm32_exti_chip_data
*chips_data
;
67 const struct stm32_exti_drv_data
*drv_data
;
68 struct hwspinlock
*hwlock
;
71 static struct stm32_exti_host_data
*stm32_host_data
;
73 static const struct stm32_exti_bank stm32f4xx_exti_b1
= {
80 .fpr_ofst
= UNDEF_REG
,
83 static const struct stm32_exti_bank
*stm32f4xx_exti_banks
[] = {
87 static const struct stm32_exti_drv_data stm32f4xx_drv_data
= {
88 .exti_banks
= stm32f4xx_exti_banks
,
89 .bank_nr
= ARRAY_SIZE(stm32f4xx_exti_banks
),
92 static const struct stm32_exti_bank stm32h7xx_exti_b1
= {
99 .fpr_ofst
= UNDEF_REG
,
102 static const struct stm32_exti_bank stm32h7xx_exti_b2
= {
109 .fpr_ofst
= UNDEF_REG
,
112 static const struct stm32_exti_bank stm32h7xx_exti_b3
= {
119 .fpr_ofst
= UNDEF_REG
,
122 static const struct stm32_exti_bank
*stm32h7xx_exti_banks
[] = {
128 static const struct stm32_exti_drv_data stm32h7xx_drv_data
= {
129 .exti_banks
= stm32h7xx_exti_banks
,
130 .bank_nr
= ARRAY_SIZE(stm32h7xx_exti_banks
),
133 static const struct stm32_exti_bank stm32mp1_exti_b1
= {
143 static const struct stm32_exti_bank stm32mp1_exti_b2
= {
153 static const struct stm32_exti_bank stm32mp1_exti_b3
= {
163 static const struct stm32_exti_bank
*stm32mp1_exti_banks
[] = {
169 static struct irq_chip stm32_exti_h_chip
;
170 static struct irq_chip stm32_exti_h_chip_direct
;
172 static const struct stm32_desc_irq stm32mp1_desc_irq
[] = {
173 { .exti
= 0, .irq_parent
= 6, .chip
= &stm32_exti_h_chip
},
174 { .exti
= 1, .irq_parent
= 7, .chip
= &stm32_exti_h_chip
},
175 { .exti
= 2, .irq_parent
= 8, .chip
= &stm32_exti_h_chip
},
176 { .exti
= 3, .irq_parent
= 9, .chip
= &stm32_exti_h_chip
},
177 { .exti
= 4, .irq_parent
= 10, .chip
= &stm32_exti_h_chip
},
178 { .exti
= 5, .irq_parent
= 23, .chip
= &stm32_exti_h_chip
},
179 { .exti
= 6, .irq_parent
= 64, .chip
= &stm32_exti_h_chip
},
180 { .exti
= 7, .irq_parent
= 65, .chip
= &stm32_exti_h_chip
},
181 { .exti
= 8, .irq_parent
= 66, .chip
= &stm32_exti_h_chip
},
182 { .exti
= 9, .irq_parent
= 67, .chip
= &stm32_exti_h_chip
},
183 { .exti
= 10, .irq_parent
= 40, .chip
= &stm32_exti_h_chip
},
184 { .exti
= 11, .irq_parent
= 42, .chip
= &stm32_exti_h_chip
},
185 { .exti
= 12, .irq_parent
= 76, .chip
= &stm32_exti_h_chip
},
186 { .exti
= 13, .irq_parent
= 77, .chip
= &stm32_exti_h_chip
},
187 { .exti
= 14, .irq_parent
= 121, .chip
= &stm32_exti_h_chip
},
188 { .exti
= 15, .irq_parent
= 127, .chip
= &stm32_exti_h_chip
},
189 { .exti
= 16, .irq_parent
= 1, .chip
= &stm32_exti_h_chip
},
190 { .exti
= 19, .irq_parent
= 3, .chip
= &stm32_exti_h_chip_direct
},
191 { .exti
= 21, .irq_parent
= 31, .chip
= &stm32_exti_h_chip_direct
},
192 { .exti
= 22, .irq_parent
= 33, .chip
= &stm32_exti_h_chip_direct
},
193 { .exti
= 23, .irq_parent
= 72, .chip
= &stm32_exti_h_chip_direct
},
194 { .exti
= 24, .irq_parent
= 95, .chip
= &stm32_exti_h_chip_direct
},
195 { .exti
= 25, .irq_parent
= 107, .chip
= &stm32_exti_h_chip_direct
},
196 { .exti
= 30, .irq_parent
= 52, .chip
= &stm32_exti_h_chip_direct
},
197 { .exti
= 47, .irq_parent
= 93, .chip
= &stm32_exti_h_chip_direct
},
198 { .exti
= 48, .irq_parent
= 138, .chip
= &stm32_exti_h_chip_direct
},
199 { .exti
= 50, .irq_parent
= 139, .chip
= &stm32_exti_h_chip_direct
},
200 { .exti
= 52, .irq_parent
= 140, .chip
= &stm32_exti_h_chip_direct
},
201 { .exti
= 53, .irq_parent
= 141, .chip
= &stm32_exti_h_chip_direct
},
202 { .exti
= 54, .irq_parent
= 135, .chip
= &stm32_exti_h_chip_direct
},
203 { .exti
= 61, .irq_parent
= 100, .chip
= &stm32_exti_h_chip_direct
},
204 { .exti
= 65, .irq_parent
= 144, .chip
= &stm32_exti_h_chip
},
205 { .exti
= 68, .irq_parent
= 143, .chip
= &stm32_exti_h_chip
},
206 { .exti
= 70, .irq_parent
= 62, .chip
= &stm32_exti_h_chip_direct
},
207 { .exti
= 73, .irq_parent
= 129, .chip
= &stm32_exti_h_chip
},
210 static const struct stm32_exti_drv_data stm32mp1_drv_data
= {
211 .exti_banks
= stm32mp1_exti_banks
,
212 .bank_nr
= ARRAY_SIZE(stm32mp1_exti_banks
),
213 .desc_irqs
= stm32mp1_desc_irq
,
214 .irq_nr
= ARRAY_SIZE(stm32mp1_desc_irq
),
218 stm32_desc_irq
*stm32_exti_get_desc(const struct stm32_exti_drv_data
*drv_data
,
219 irq_hw_number_t hwirq
)
221 const struct stm32_desc_irq
*desc
= NULL
;
224 if (!drv_data
->desc_irqs
)
227 for (i
= 0; i
< drv_data
->irq_nr
; i
++) {
228 desc
= &drv_data
->desc_irqs
[i
];
229 if (desc
->exti
== hwirq
)
236 static unsigned long stm32_exti_pending(struct irq_chip_generic
*gc
)
238 struct stm32_exti_chip_data
*chip_data
= gc
->private;
239 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
240 unsigned long pending
;
242 pending
= irq_reg_readl(gc
, stm32_bank
->rpr_ofst
);
243 if (stm32_bank
->fpr_ofst
!= UNDEF_REG
)
244 pending
|= irq_reg_readl(gc
, stm32_bank
->fpr_ofst
);
249 static void stm32_irq_handler(struct irq_desc
*desc
)
251 struct irq_domain
*domain
= irq_desc_get_handler_data(desc
);
252 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
253 unsigned int virq
, nbanks
= domain
->gc
->num_chips
;
254 struct irq_chip_generic
*gc
;
255 unsigned long pending
;
256 int n
, i
, irq_base
= 0;
258 chained_irq_enter(chip
, desc
);
260 for (i
= 0; i
< nbanks
; i
++, irq_base
+= IRQS_PER_BANK
) {
261 gc
= irq_get_domain_generic_chip(domain
, irq_base
);
263 while ((pending
= stm32_exti_pending(gc
))) {
264 for_each_set_bit(n
, &pending
, IRQS_PER_BANK
) {
265 virq
= irq_find_mapping(domain
, irq_base
+ n
);
266 generic_handle_irq(virq
);
271 chained_irq_exit(chip
, desc
);
274 static int stm32_exti_set_type(struct irq_data
*d
,
275 unsigned int type
, u32
*rtsr
, u32
*ftsr
)
277 u32 mask
= BIT(d
->hwirq
% IRQS_PER_BANK
);
280 case IRQ_TYPE_EDGE_RISING
:
284 case IRQ_TYPE_EDGE_FALLING
:
288 case IRQ_TYPE_EDGE_BOTH
:
299 static int stm32_irq_set_type(struct irq_data
*d
, unsigned int type
)
301 struct irq_chip_generic
*gc
= irq_data_get_irq_chip_data(d
);
302 struct stm32_exti_chip_data
*chip_data
= gc
->private;
303 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
304 struct hwspinlock
*hwlock
= chip_data
->host_data
->hwlock
;
311 err
= hwspin_lock_timeout_in_atomic(hwlock
, HWSPNLCK_TIMEOUT
);
313 pr_err("%s can't get hwspinlock (%d)\n", __func__
, err
);
318 rtsr
= irq_reg_readl(gc
, stm32_bank
->rtsr_ofst
);
319 ftsr
= irq_reg_readl(gc
, stm32_bank
->ftsr_ofst
);
321 err
= stm32_exti_set_type(d
, type
, &rtsr
, &ftsr
);
325 irq_reg_writel(gc
, rtsr
, stm32_bank
->rtsr_ofst
);
326 irq_reg_writel(gc
, ftsr
, stm32_bank
->ftsr_ofst
);
330 hwspin_unlock_in_atomic(hwlock
);
337 static void stm32_chip_suspend(struct stm32_exti_chip_data
*chip_data
,
340 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
341 void __iomem
*base
= chip_data
->host_data
->base
;
343 /* save rtsr, ftsr registers */
344 chip_data
->rtsr_cache
= readl_relaxed(base
+ stm32_bank
->rtsr_ofst
);
345 chip_data
->ftsr_cache
= readl_relaxed(base
+ stm32_bank
->ftsr_ofst
);
347 writel_relaxed(wake_active
, base
+ stm32_bank
->imr_ofst
);
350 static void stm32_chip_resume(struct stm32_exti_chip_data
*chip_data
,
353 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
354 void __iomem
*base
= chip_data
->host_data
->base
;
356 /* restore rtsr, ftsr, registers */
357 writel_relaxed(chip_data
->rtsr_cache
, base
+ stm32_bank
->rtsr_ofst
);
358 writel_relaxed(chip_data
->ftsr_cache
, base
+ stm32_bank
->ftsr_ofst
);
360 writel_relaxed(mask_cache
, base
+ stm32_bank
->imr_ofst
);
363 static void stm32_irq_suspend(struct irq_chip_generic
*gc
)
365 struct stm32_exti_chip_data
*chip_data
= gc
->private;
368 stm32_chip_suspend(chip_data
, gc
->wake_active
);
372 static void stm32_irq_resume(struct irq_chip_generic
*gc
)
374 struct stm32_exti_chip_data
*chip_data
= gc
->private;
377 stm32_chip_resume(chip_data
, gc
->mask_cache
);
381 static int stm32_exti_alloc(struct irq_domain
*d
, unsigned int virq
,
382 unsigned int nr_irqs
, void *data
)
384 struct irq_fwspec
*fwspec
= data
;
385 irq_hw_number_t hwirq
;
387 hwirq
= fwspec
->param
[0];
389 irq_map_generic_chip(d
, virq
, hwirq
);
394 static void stm32_exti_free(struct irq_domain
*d
, unsigned int virq
,
395 unsigned int nr_irqs
)
397 struct irq_data
*data
= irq_domain_get_irq_data(d
, virq
);
399 irq_domain_reset_irq_data(data
);
402 static const struct irq_domain_ops irq_exti_domain_ops
= {
403 .map
= irq_map_generic_chip
,
404 .alloc
= stm32_exti_alloc
,
405 .free
= stm32_exti_free
,
408 static void stm32_irq_ack(struct irq_data
*d
)
410 struct irq_chip_generic
*gc
= irq_data_get_irq_chip_data(d
);
411 struct stm32_exti_chip_data
*chip_data
= gc
->private;
412 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
416 irq_reg_writel(gc
, d
->mask
, stm32_bank
->rpr_ofst
);
417 if (stm32_bank
->fpr_ofst
!= UNDEF_REG
)
418 irq_reg_writel(gc
, d
->mask
, stm32_bank
->fpr_ofst
);
423 /* directly set the target bit without reading first. */
424 static inline void stm32_exti_write_bit(struct irq_data
*d
, u32 reg
)
426 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
427 void __iomem
*base
= chip_data
->host_data
->base
;
428 u32 val
= BIT(d
->hwirq
% IRQS_PER_BANK
);
430 writel_relaxed(val
, base
+ reg
);
433 static inline u32
stm32_exti_set_bit(struct irq_data
*d
, u32 reg
)
435 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
436 void __iomem
*base
= chip_data
->host_data
->base
;
439 val
= readl_relaxed(base
+ reg
);
440 val
|= BIT(d
->hwirq
% IRQS_PER_BANK
);
441 writel_relaxed(val
, base
+ reg
);
446 static inline u32
stm32_exti_clr_bit(struct irq_data
*d
, u32 reg
)
448 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
449 void __iomem
*base
= chip_data
->host_data
->base
;
452 val
= readl_relaxed(base
+ reg
);
453 val
&= ~BIT(d
->hwirq
% IRQS_PER_BANK
);
454 writel_relaxed(val
, base
+ reg
);
459 static void stm32_exti_h_eoi(struct irq_data
*d
)
461 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
462 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
464 raw_spin_lock(&chip_data
->rlock
);
466 stm32_exti_write_bit(d
, stm32_bank
->rpr_ofst
);
467 if (stm32_bank
->fpr_ofst
!= UNDEF_REG
)
468 stm32_exti_write_bit(d
, stm32_bank
->fpr_ofst
);
470 raw_spin_unlock(&chip_data
->rlock
);
472 if (d
->parent_data
->chip
)
473 irq_chip_eoi_parent(d
);
476 static void stm32_exti_h_mask(struct irq_data
*d
)
478 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
479 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
481 raw_spin_lock(&chip_data
->rlock
);
482 chip_data
->mask_cache
= stm32_exti_clr_bit(d
, stm32_bank
->imr_ofst
);
483 raw_spin_unlock(&chip_data
->rlock
);
485 if (d
->parent_data
->chip
)
486 irq_chip_mask_parent(d
);
489 static void stm32_exti_h_unmask(struct irq_data
*d
)
491 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
492 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
494 raw_spin_lock(&chip_data
->rlock
);
495 chip_data
->mask_cache
= stm32_exti_set_bit(d
, stm32_bank
->imr_ofst
);
496 raw_spin_unlock(&chip_data
->rlock
);
498 if (d
->parent_data
->chip
)
499 irq_chip_unmask_parent(d
);
502 static int stm32_exti_h_set_type(struct irq_data
*d
, unsigned int type
)
504 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
505 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
506 struct hwspinlock
*hwlock
= chip_data
->host_data
->hwlock
;
507 void __iomem
*base
= chip_data
->host_data
->base
;
511 raw_spin_lock(&chip_data
->rlock
);
514 err
= hwspin_lock_timeout_in_atomic(hwlock
, HWSPNLCK_TIMEOUT
);
516 pr_err("%s can't get hwspinlock (%d)\n", __func__
, err
);
521 rtsr
= readl_relaxed(base
+ stm32_bank
->rtsr_ofst
);
522 ftsr
= readl_relaxed(base
+ stm32_bank
->ftsr_ofst
);
524 err
= stm32_exti_set_type(d
, type
, &rtsr
, &ftsr
);
528 writel_relaxed(rtsr
, base
+ stm32_bank
->rtsr_ofst
);
529 writel_relaxed(ftsr
, base
+ stm32_bank
->ftsr_ofst
);
533 hwspin_unlock_in_atomic(hwlock
);
535 raw_spin_unlock(&chip_data
->rlock
);
540 static int stm32_exti_h_set_wake(struct irq_data
*d
, unsigned int on
)
542 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
543 u32 mask
= BIT(d
->hwirq
% IRQS_PER_BANK
);
545 raw_spin_lock(&chip_data
->rlock
);
548 chip_data
->wake_active
|= mask
;
550 chip_data
->wake_active
&= ~mask
;
552 raw_spin_unlock(&chip_data
->rlock
);
557 static int stm32_exti_h_set_affinity(struct irq_data
*d
,
558 const struct cpumask
*dest
, bool force
)
560 if (d
->parent_data
->chip
)
561 return irq_chip_set_affinity_parent(d
, dest
, force
);
566 static int __maybe_unused
stm32_exti_h_suspend(void)
568 struct stm32_exti_chip_data
*chip_data
;
571 for (i
= 0; i
< stm32_host_data
->drv_data
->bank_nr
; i
++) {
572 chip_data
= &stm32_host_data
->chips_data
[i
];
573 raw_spin_lock(&chip_data
->rlock
);
574 stm32_chip_suspend(chip_data
, chip_data
->wake_active
);
575 raw_spin_unlock(&chip_data
->rlock
);
581 static void __maybe_unused
stm32_exti_h_resume(void)
583 struct stm32_exti_chip_data
*chip_data
;
586 for (i
= 0; i
< stm32_host_data
->drv_data
->bank_nr
; i
++) {
587 chip_data
= &stm32_host_data
->chips_data
[i
];
588 raw_spin_lock(&chip_data
->rlock
);
589 stm32_chip_resume(chip_data
, chip_data
->mask_cache
);
590 raw_spin_unlock(&chip_data
->rlock
);
594 static struct syscore_ops stm32_exti_h_syscore_ops
= {
595 #ifdef CONFIG_PM_SLEEP
596 .suspend
= stm32_exti_h_suspend
,
597 .resume
= stm32_exti_h_resume
,
601 static void stm32_exti_h_syscore_init(struct stm32_exti_host_data
*host_data
)
603 stm32_host_data
= host_data
;
604 register_syscore_ops(&stm32_exti_h_syscore_ops
);
607 static void stm32_exti_h_syscore_deinit(void)
609 unregister_syscore_ops(&stm32_exti_h_syscore_ops
);
612 static int stm32_exti_h_retrigger(struct irq_data
*d
)
614 struct stm32_exti_chip_data
*chip_data
= irq_data_get_irq_chip_data(d
);
615 const struct stm32_exti_bank
*stm32_bank
= chip_data
->reg_bank
;
616 void __iomem
*base
= chip_data
->host_data
->base
;
617 u32 mask
= BIT(d
->hwirq
% IRQS_PER_BANK
);
619 writel_relaxed(mask
, base
+ stm32_bank
->swier_ofst
);
624 static struct irq_chip stm32_exti_h_chip
= {
625 .name
= "stm32-exti-h",
626 .irq_eoi
= stm32_exti_h_eoi
,
627 .irq_mask
= stm32_exti_h_mask
,
628 .irq_unmask
= stm32_exti_h_unmask
,
629 .irq_retrigger
= stm32_exti_h_retrigger
,
630 .irq_set_type
= stm32_exti_h_set_type
,
631 .irq_set_wake
= stm32_exti_h_set_wake
,
632 .flags
= IRQCHIP_MASK_ON_SUSPEND
,
633 .irq_set_affinity
= IS_ENABLED(CONFIG_SMP
) ? stm32_exti_h_set_affinity
: NULL
,
636 static struct irq_chip stm32_exti_h_chip_direct
= {
637 .name
= "stm32-exti-h-direct",
638 .irq_eoi
= irq_chip_eoi_parent
,
639 .irq_ack
= irq_chip_ack_parent
,
640 .irq_mask
= irq_chip_mask_parent
,
641 .irq_unmask
= irq_chip_unmask_parent
,
642 .irq_retrigger
= irq_chip_retrigger_hierarchy
,
643 .irq_set_type
= irq_chip_set_type_parent
,
644 .irq_set_wake
= stm32_exti_h_set_wake
,
645 .flags
= IRQCHIP_MASK_ON_SUSPEND
,
646 .irq_set_affinity
= IS_ENABLED(CONFIG_SMP
) ? irq_chip_set_affinity_parent
: NULL
,
649 static int stm32_exti_h_domain_alloc(struct irq_domain
*dm
,
651 unsigned int nr_irqs
, void *data
)
653 struct stm32_exti_host_data
*host_data
= dm
->host_data
;
654 struct stm32_exti_chip_data
*chip_data
;
655 const struct stm32_desc_irq
*desc
;
656 struct irq_fwspec
*fwspec
= data
;
657 struct irq_fwspec p_fwspec
;
658 irq_hw_number_t hwirq
;
661 hwirq
= fwspec
->param
[0];
662 bank
= hwirq
/ IRQS_PER_BANK
;
663 chip_data
= &host_data
->chips_data
[bank
];
666 desc
= stm32_exti_get_desc(host_data
->drv_data
, hwirq
);
670 irq_domain_set_hwirq_and_chip(dm
, virq
, hwirq
, desc
->chip
,
672 if (desc
->irq_parent
) {
673 p_fwspec
.fwnode
= dm
->parent
->fwnode
;
674 p_fwspec
.param_count
= 3;
675 p_fwspec
.param
[0] = GIC_SPI
;
676 p_fwspec
.param
[1] = desc
->irq_parent
;
677 p_fwspec
.param
[2] = IRQ_TYPE_LEVEL_HIGH
;
679 return irq_domain_alloc_irqs_parent(dm
, virq
, 1, &p_fwspec
);
686 stm32_exti_host_data
*stm32_exti_host_init(const struct stm32_exti_drv_data
*dd
,
687 struct device_node
*node
)
689 struct stm32_exti_host_data
*host_data
;
691 host_data
= kzalloc(sizeof(*host_data
), GFP_KERNEL
);
695 host_data
->drv_data
= dd
;
696 host_data
->chips_data
= kcalloc(dd
->bank_nr
,
697 sizeof(struct stm32_exti_chip_data
),
699 if (!host_data
->chips_data
)
702 host_data
->base
= of_iomap(node
, 0);
703 if (!host_data
->base
) {
704 pr_err("%pOF: Unable to map registers\n", node
);
705 goto free_chips_data
;
708 stm32_host_data
= host_data
;
713 kfree(host_data
->chips_data
);
721 stm32_exti_chip_data
*stm32_exti_chip_init(struct stm32_exti_host_data
*h_data
,
723 struct device_node
*node
)
725 const struct stm32_exti_bank
*stm32_bank
;
726 struct stm32_exti_chip_data
*chip_data
;
727 void __iomem
*base
= h_data
->base
;
729 stm32_bank
= h_data
->drv_data
->exti_banks
[bank_idx
];
730 chip_data
= &h_data
->chips_data
[bank_idx
];
731 chip_data
->host_data
= h_data
;
732 chip_data
->reg_bank
= stm32_bank
;
734 raw_spin_lock_init(&chip_data
->rlock
);
737 * This IP has no reset, so after hot reboot we should
738 * clear registers to avoid residue
740 writel_relaxed(0, base
+ stm32_bank
->imr_ofst
);
741 writel_relaxed(0, base
+ stm32_bank
->emr_ofst
);
743 pr_info("%pOF: bank%d\n", node
, bank_idx
);
748 static int __init
stm32_exti_init(const struct stm32_exti_drv_data
*drv_data
,
749 struct device_node
*node
)
751 struct stm32_exti_host_data
*host_data
;
752 unsigned int clr
= IRQ_NOREQUEST
| IRQ_NOPROBE
| IRQ_NOAUTOEN
;
754 struct irq_chip_generic
*gc
;
755 struct irq_domain
*domain
;
757 host_data
= stm32_exti_host_init(drv_data
, node
);
761 domain
= irq_domain_add_linear(node
, drv_data
->bank_nr
* IRQS_PER_BANK
,
762 &irq_exti_domain_ops
, NULL
);
764 pr_err("%pOFn: Could not register interrupt domain.\n",
770 ret
= irq_alloc_domain_generic_chips(domain
, IRQS_PER_BANK
, 1, "exti",
771 handle_edge_irq
, clr
, 0, 0);
773 pr_err("%pOF: Could not allocate generic interrupt chip.\n",
775 goto out_free_domain
;
778 for (i
= 0; i
< drv_data
->bank_nr
; i
++) {
779 const struct stm32_exti_bank
*stm32_bank
;
780 struct stm32_exti_chip_data
*chip_data
;
782 stm32_bank
= drv_data
->exti_banks
[i
];
783 chip_data
= stm32_exti_chip_init(host_data
, i
, node
);
785 gc
= irq_get_domain_generic_chip(domain
, i
* IRQS_PER_BANK
);
787 gc
->reg_base
= host_data
->base
;
788 gc
->chip_types
->type
= IRQ_TYPE_EDGE_BOTH
;
789 gc
->chip_types
->chip
.irq_ack
= stm32_irq_ack
;
790 gc
->chip_types
->chip
.irq_mask
= irq_gc_mask_clr_bit
;
791 gc
->chip_types
->chip
.irq_unmask
= irq_gc_mask_set_bit
;
792 gc
->chip_types
->chip
.irq_set_type
= stm32_irq_set_type
;
793 gc
->chip_types
->chip
.irq_set_wake
= irq_gc_set_wake
;
794 gc
->suspend
= stm32_irq_suspend
;
795 gc
->resume
= stm32_irq_resume
;
796 gc
->wake_enabled
= IRQ_MSK(IRQS_PER_BANK
);
798 gc
->chip_types
->regs
.mask
= stm32_bank
->imr_ofst
;
799 gc
->private = (void *)chip_data
;
802 nr_irqs
= of_irq_count(node
);
803 for (i
= 0; i
< nr_irqs
; i
++) {
804 unsigned int irq
= irq_of_parse_and_map(node
, i
);
806 irq_set_handler_data(irq
, domain
);
807 irq_set_chained_handler(irq
, stm32_irq_handler
);
813 irq_domain_remove(domain
);
815 iounmap(host_data
->base
);
816 kfree(host_data
->chips_data
);
821 static const struct irq_domain_ops stm32_exti_h_domain_ops
= {
822 .alloc
= stm32_exti_h_domain_alloc
,
823 .free
= irq_domain_free_irqs_common
,
824 .xlate
= irq_domain_xlate_twocell
,
827 static void stm32_exti_remove_irq(void *data
)
829 struct irq_domain
*domain
= data
;
831 irq_domain_remove(domain
);
834 static int stm32_exti_remove(struct platform_device
*pdev
)
836 stm32_exti_h_syscore_deinit();
840 static int stm32_exti_probe(struct platform_device
*pdev
)
843 struct device
*dev
= &pdev
->dev
;
844 struct device_node
*np
= dev
->of_node
;
845 struct irq_domain
*parent_domain
, *domain
;
846 struct stm32_exti_host_data
*host_data
;
847 const struct stm32_exti_drv_data
*drv_data
;
848 struct resource
*res
;
850 host_data
= devm_kzalloc(dev
, sizeof(*host_data
), GFP_KERNEL
);
854 /* check for optional hwspinlock which may be not available yet */
855 ret
= of_hwspin_lock_get_id(np
, 0);
856 if (ret
== -EPROBE_DEFER
)
857 /* hwspinlock framework not yet ready */
861 host_data
->hwlock
= devm_hwspin_lock_request_specific(dev
, ret
);
862 if (!host_data
->hwlock
) {
863 dev_err(dev
, "Failed to request hwspinlock\n");
866 } else if (ret
!= -ENOENT
) {
867 /* note: ENOENT is a valid case (means 'no hwspinlock') */
868 dev_err(dev
, "Failed to get hwspinlock\n");
872 /* initialize host_data */
873 drv_data
= of_device_get_match_data(dev
);
875 dev_err(dev
, "no of match data\n");
878 host_data
->drv_data
= drv_data
;
880 host_data
->chips_data
= devm_kcalloc(dev
, drv_data
->bank_nr
,
881 sizeof(*host_data
->chips_data
),
883 if (!host_data
->chips_data
)
886 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
887 host_data
->base
= devm_ioremap_resource(dev
, res
);
888 if (IS_ERR(host_data
->base
)) {
889 dev_err(dev
, "Unable to map registers\n");
890 return PTR_ERR(host_data
->base
);
893 for (i
= 0; i
< drv_data
->bank_nr
; i
++)
894 stm32_exti_chip_init(host_data
, i
, np
);
896 parent_domain
= irq_find_host(of_irq_find_parent(np
));
897 if (!parent_domain
) {
898 dev_err(dev
, "GIC interrupt-parent not found\n");
902 domain
= irq_domain_add_hierarchy(parent_domain
, 0,
903 drv_data
->bank_nr
* IRQS_PER_BANK
,
904 np
, &stm32_exti_h_domain_ops
,
908 dev_err(dev
, "Could not register exti domain\n");
912 ret
= devm_add_action_or_reset(dev
, stm32_exti_remove_irq
, domain
);
916 stm32_exti_h_syscore_init(host_data
);
921 /* platform driver only for MP1 */
922 static const struct of_device_id stm32_exti_ids
[] = {
923 { .compatible
= "st,stm32mp1-exti", .data
= &stm32mp1_drv_data
},
926 MODULE_DEVICE_TABLE(of
, stm32_exti_ids
);
928 static struct platform_driver stm32_exti_driver
= {
929 .probe
= stm32_exti_probe
,
930 .remove
= stm32_exti_remove
,
932 .name
= "stm32_exti",
933 .of_match_table
= stm32_exti_ids
,
937 static int __init
stm32_exti_arch_init(void)
939 return platform_driver_register(&stm32_exti_driver
);
942 static void __exit
stm32_exti_arch_exit(void)
944 return platform_driver_unregister(&stm32_exti_driver
);
947 arch_initcall(stm32_exti_arch_init
);
948 module_exit(stm32_exti_arch_exit
);
950 /* no platform driver for F4 and H7 */
951 static int __init
stm32f4_exti_of_init(struct device_node
*np
,
952 struct device_node
*parent
)
954 return stm32_exti_init(&stm32f4xx_drv_data
, np
);
957 IRQCHIP_DECLARE(stm32f4_exti
, "st,stm32-exti", stm32f4_exti_of_init
);
959 static int __init
stm32h7_exti_of_init(struct device_node
*np
,
960 struct device_node
*parent
)
962 return stm32_exti_init(&stm32h7xx_drv_data
, np
);
965 IRQCHIP_DECLARE(stm32h7_exti
, "st,stm32h7-exti", stm32h7_exti_of_init
);