arm64: timer: Speed up gic-timer-state check
PATCH v2 1/1 arm64: timer: Speed up gic-timer-state check
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
--- arm/timer.c | 30 ++++++++++++------------------ lib/arm/asm/gic.h | 11 ++++++----- lib/arm/gic.c | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 23 deletions(-)
arm/timer.c +12 -18
@@ -183,28 +183,22 @@ static bool timer_pending(struct timer_info *info) (info->read_ctl () &ARCH_TIMER_CTL_ISTATUS ); } -static enum gic_state gic_timer_state (struct timer_info *info) +static bool gic_timer_check_state (struct timer_info *info, +enum gic_irq_state expected_state) { -enum gic_state state =GIC_STATE_INACTIVE ;int i; -bool pending, active;/* Wait for up to 1s for the GIC to sample the interrupt. */ for (i =0 ; i <10 ; i++) { - pending =readl (gic_ispendr) & (1 <<PPI (info->irq)); - active =readl (gic_isactiver) & (1 <<PPI (info->irq)); -if (!active && !pending) - state =GIC_STATE_INACTIVE ; -if (pending) - state =GIC_STATE_PENDING ; -if (active) - state =GIC_STATE_ACTIVE ; -if (active && pending) - state =GIC_STATE_ACTIVE_PENDING ;mdelay (100 ); +if (gic_irq_state (info->irq) == expected_state) { +mdelay (100 ); +if (gic_irq_state (info->irq) == expected_state) +return true; + } } -return state; +return false; }static bool test_cval_10msec (struct timer_info *info)
@@ -253,11 +247,11 @@ static void test_timer(struct timer_info *info)/* Enable the timer, but schedule it for much later */ info->write_cval (later); info->write_ctl (ARCH_TIMER_CTL_ENABLE ); -report (!timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (!timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"not pending before" ); info->write_cval (now -1 ); -report (timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_PENDING , +report (timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_PENDING ),"interrupt signal pending" );/* Disable the timer again and prepare to take interrupts */
@@ -265,12 +259,12 @@ static void test_timer(struct timer_info *info) info->irq_received = false;set_timer_irq_enabled (info, true);report (!info->irq_received,"no interrupt when timer is disabled" ); -report (!timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (!timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"interrupt signal no longer pending" ); info->write_cval (now -1 ); info->write_ctl (ARCH_TIMER_CTL_ENABLE |ARCH_TIMER_CTL_IMASK ); -report (timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"interrupt signal not pending" );report (test_cval_10msec (info),"latency within 10 ms" );
lib/arm/asm/gic.h +6 -5
@@ -47,11 +47,11 @@#ifndef __ASSEMBLY__#include <asm/cpumask.h> -enum gic_state { -GIC_STATE_INACTIVE , -GIC_STATE_PENDING , -GIC_STATE_ACTIVE , -GIC_STATE_ACTIVE_PENDING , +enum gic_irq_state { +GIC_IRQ_STATE_INACTIVE , +GIC_IRQ_STATE_PENDING , +GIC_IRQ_STATE_ACTIVE , +GIC_IRQ_STATE_ACTIVE_PENDING , };/*
@@ -80,6 +80,7 @@ extern u32 gic_iar_irqnr(u32 iar);extern void gic_write_eoir (u32 irqstat);extern void gic_ipi_send_single (int irq,int cpu);extern void gic_ipi_send_mask (int irq,const cpumask_t *dest); +extern enum gic_irq_state gic_irq_state (int irq);#endif /* !__ASSEMBLY__ */ #endif /* _ASMARM_GIC_H_ */
lib/arm/gic.c +33 -0
@@ -146,3 +146,36 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)assert (gic_common_ops && gic_common_ops->ipi_send_mask); gic_common_ops->ipi_send_mask (irq, dest); } + +enum gic_irq_state gic_irq_state (int irq) +{ +enum gic_irq_state state; +bool pending = false, active = false; +void *base; + +assert (gic_common_ops); + +switch (gic_version ()) { +case 2 : + base =gicv2_dist_base (); + pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); + active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); +break ; +case 3 : + base =gicv3_sgi_base (); + pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); + active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq)); +break ; + } + +if (!active && !pending) + state =GIC_IRQ_STATE_INACTIVE ; +if (pending) + state =GIC_IRQ_STATE_PENDING ; +if (active) + state =GIC_IRQ_STATE_ACTIVE ; +if (active && pending) + state =GIC_IRQ_STATE_ACTIVE_PENDING ; + +return state; +}
Signature · 1 line
2.21.1
Hi,
Quoted 146 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>--- arm/timer.c | 30 ++++++++++++------------------ lib/arm/asm/gic.h | 11 ++++++----- lib/arm/gic.c | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 23 deletions(-)arm/timer.c +12
-18@@ -183,28 +183,22 @@ static bool timer_pending(struct timer_info *info) (info->read_ctl () &ARCH_TIMER_CTL_ISTATUS ); } -static enum gic_state gic_timer_state (struct timer_info *info) +static bool gic_timer_check_state (struct timer_info *info, +enum gic_irq_state expected_state) { -enum gic_state state =GIC_STATE_INACTIVE ;int i; -bool pending, active;/* Wait for up to 1s for the GIC to sample the interrupt. */ for (i =0 ; i <10 ; i++) { - pending =readl (gic_ispendr) & (1 <<PPI (info->irq)); - active =readl (gic_isactiver) & (1 <<PPI (info->irq)); -if (!active && !pending) - state =GIC_STATE_INACTIVE ; -if (pending) - state =GIC_STATE_PENDING ; -if (active) - state =GIC_STATE_ACTIVE ; -if (active && pending) - state =GIC_STATE_ACTIVE_PENDING ;mdelay (100 ); +if (gic_irq_state (info->irq) == expected_state) { +mdelay (100 ); +if (gic_irq_state (info->irq) == expected_state) +return true; + } } -return state; +return false; }static bool test_cval_10msec (struct timer_info *info)@@ -253,11 +247,11 @@ static void test_timer(struct timer_info *info)/* Enable the timer, but schedule it for much later */ info->write_cval (later); info->write_ctl (ARCH_TIMER_CTL_ENABLE ); -report (!timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (!timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"not pending before" ); info->write_cval (now -1 ); -report (timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_PENDING , +report (timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_PENDING ),"interrupt signal pending" );/* Disable the timer again and prepare to take interrupts */ @@ -265,12 +259,12 @@ static void test_timer(struct timer_info *info) info->irq_received = false;set_timer_irq_enabled (info, true);report (!info->irq_received,"no interrupt when timer is disabled" ); -report (!timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (!timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"interrupt signal no longer pending" ); info->write_cval (now -1 ); info->write_ctl (ARCH_TIMER_CTL_ENABLE |ARCH_TIMER_CTL_IMASK ); -report (timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"interrupt signal not pending" );report (test_cval_10msec (info),"latency within 10 ms" );lib/arm/asm/gic.h +6
-5@@ -47,11 +47,11 @@#ifndef __ASSEMBLY__#include <asm/cpumask.h> -enum gic_state { -GIC_STATE_INACTIVE , -GIC_STATE_PENDING , -GIC_STATE_ACTIVE , -GIC_STATE_ACTIVE_PENDING , +enum gic_irq_state { +GIC_IRQ_STATE_INACTIVE , +GIC_IRQ_STATE_PENDING , +GIC_IRQ_STATE_ACTIVE , +GIC_IRQ_STATE_ACTIVE_PENDING , };/* @@ -80,6 +80,7 @@ extern u32 gic_iar_irqnr(u32 iar);extern void gic_write_eoir (u32 irqstat);extern void gic_ipi_send_single (int irq,int cpu);extern void gic_ipi_send_mask (int irq,const cpumask_t *dest); +extern enum gic_irq_state gic_irq_state (int irq);#endif /* !__ASSEMBLY__ */ #endif /* _ASMARM_GIC_H_ */ lib/arm/gic.c +23
-0@@ -146,3 +146,36 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)assert (gic_common_ops && gic_common_ops->ipi_send_mask); gic_common_ops->ipi_send_mask (irq, dest); } + +enum gic_irq_state gic_irq_state (int irq) +{ +enum gic_irq_state state; +bool pending = false, active = false; +void *base; + +assert (gic_common_ops); + +switch (gic_version ()) { +case 2 : + base =gicv2_dist_base (); + pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); + active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); +break ; +case 3 : + base =gicv3_sgi_base (); + pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); + active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq)); +break ; + } + +if (!active && !pending)
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 181
Quoted 10 lines
lib/arm/gic.c +10
-0+ state =GIC_IRQ_STATE_INACTIVE ; +if (pending) + state =GIC_IRQ_STATE_PENDING ; +if (active) + state =GIC_IRQ_STATE_ACTIVE ; +if (active && pending) + state =GIC_IRQ_STATE_ACTIVE_PENDING ; + +return state; +}
Looks good. The gic_ispendr and gic_isactiver variables are not used anymore and could be removed, but it's not a big deal. Either way:
Thanks,
Alex
Quoted 163 lines · Alexandru Elisei
Hi,
Quoted 146 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>--- arm/timer.c | 30 ++++++++++++------------------ lib/arm/asm/gic.h | 11 ++++++----- lib/arm/gic.c | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 23 deletions(-)arm/timer.c +12
-18@@ -183,28 +183,22 @@ static bool timer_pending(struct timer_info *info) (info->read_ctl () &ARCH_TIMER_CTL_ISTATUS ); } -static enum gic_state gic_timer_state (struct timer_info *info) +static bool gic_timer_check_state (struct timer_info *info, +enum gic_irq_state expected_state) { -enum gic_state state =GIC_STATE_INACTIVE ;int i; -bool pending, active;/* Wait for up to 1s for the GIC to sample the interrupt. */ for (i =0 ; i <10 ; i++) { - pending =readl (gic_ispendr) & (1 <<PPI (info->irq)); - active =readl (gic_isactiver) & (1 <<PPI (info->irq)); -if (!active && !pending) - state =GIC_STATE_INACTIVE ; -if (pending) - state =GIC_STATE_PENDING ; -if (active) - state =GIC_STATE_ACTIVE ; -if (active && pending) - state =GIC_STATE_ACTIVE_PENDING ;mdelay (100 ); +if (gic_irq_state (info->irq) == expected_state) { +mdelay (100 ); +if (gic_irq_state (info->irq) == expected_state) +return true; + } } -return state; +return false; }static bool test_cval_10msec (struct timer_info *info)@@ -253,11 +247,11 @@ static void test_timer(struct timer_info *info)/* Enable the timer, but schedule it for much later */ info->write_cval (later); info->write_ctl (ARCH_TIMER_CTL_ENABLE ); -report (!timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (!timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"not pending before" ); info->write_cval (now -1 ); -report (timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_PENDING , +report (timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_PENDING ),"interrupt signal pending" );/* Disable the timer again and prepare to take interrupts */ @@ -265,12 +259,12 @@ static void test_timer(struct timer_info *info) info->irq_received = false;set_timer_irq_enabled (info, true);report (!info->irq_received,"no interrupt when timer is disabled" ); -report (!timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (!timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"interrupt signal no longer pending" ); info->write_cval (now -1 ); info->write_ctl (ARCH_TIMER_CTL_ENABLE |ARCH_TIMER_CTL_IMASK ); -report (timer_pending (info) &&gic_timer_state (info) ==GIC_STATE_INACTIVE , +report (timer_pending (info) &&gic_timer_check_state (info,GIC_IRQ_STATE_INACTIVE ),"interrupt signal not pending" );report (test_cval_10msec (info),"latency within 10 ms" );lib/arm/asm/gic.h +6
-5@@ -47,11 +47,11 @@#ifndef __ASSEMBLY__#include <asm/cpumask.h> -enum gic_state { -GIC_STATE_INACTIVE , -GIC_STATE_PENDING , -GIC_STATE_ACTIVE , -GIC_STATE_ACTIVE_PENDING , +enum gic_irq_state { +GIC_IRQ_STATE_INACTIVE , +GIC_IRQ_STATE_PENDING , +GIC_IRQ_STATE_ACTIVE , +GIC_IRQ_STATE_ACTIVE_PENDING , };/* @@ -80,6 +80,7 @@ extern u32 gic_iar_irqnr(u32 iar);extern void gic_write_eoir (u32 irqstat);extern void gic_ipi_send_single (int irq,int cpu);extern void gic_ipi_send_mask (int irq,const cpumask_t *dest); +extern enum gic_irq_state gic_irq_state (int irq);#endif /* !__ASSEMBLY__ */ #endif /* _ASMARM_GIC_H_ */ lib/arm/gic.c +23
-0@@ -146,3 +146,36 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)assert (gic_common_ops && gic_common_ops->ipi_send_mask); gic_common_ops->ipi_send_mask (irq, dest); } + +enum gic_irq_state gic_irq_state (int irq) +{ +enum gic_irq_state state; +bool pending = false, active = false; +void *base; + +assert (gic_common_ops); + +switch (gic_version ()) { +case 2 : + base =gicv2_dist_base (); + pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); + active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); +break ; +case 3 : + base =gicv3_sgi_base (); + pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); + active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq)); +break ; + } + +if (!active && !pending)lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 181
Quoted 10 lines
lib/arm/gic.c +10
-0+ state =GIC_IRQ_STATE_INACTIVE ; +if (pending) + state =GIC_IRQ_STATE_PENDING ; +if (active) + state =GIC_IRQ_STATE_ACTIVE ; +if (active && pending) + state =GIC_IRQ_STATE_ACTIVE_PENDING ; + +return state; +}Looks good. The
gic_ispendrandgic_isactivervariables are not used anymore and could be removed, but it's not a big deal. Either way:
Quoted 1 line
Reviewed-by Alexandru Elisei <[email protected]>
Indeed. I'll remove them and add your r-b while applying.
Thanks,
drew
Quoted 4 lines
Thanks,
Alex
Hi Drew,
Quoted 10 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>
[...]
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 150
Quoted 2 lines
lib/arm/gic.c +2
-0+ +enum gic_irq_state gic_irq_state (int irq)
This is a *generic* name while this function only deals with PPI. Maybe we can use something like gic_ppi_state() instead? Or you will have to take all interrupt types into account in a single function, which is not a easy job I think.
Quoted 7 lines
lib/arm/gic.c +7
-0+{ +enum gic_irq_state state; +bool pending = false, active = false; +void *base; + +assert (gic_common_ops); +
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 167
Quoted 10 lines
lib/arm/gic.c +10
-0+switch (gic_version ()) { +case 2 : + base =gicv2_dist_base (); + pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); + active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); +break ; +case 3 : + base =gicv3_sgi_base (); + pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); + active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq));
And you may also want to ensure that the 'irq' is valid for PPI(). Or personally, I'd just use a real PPI number (PPI(info->irq)) as the input parameter of this function.
Quoted 5 lines
lib/arm/gic.c +4
-0+break ; + } + +if (!active && !pending)
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 181
Quoted 10 lines
lib/arm/gic.c +10
-0+ state =GIC_IRQ_STATE_INACTIVE ; +if (pending) + state =GIC_IRQ_STATE_PENDING ; +if (active) + state =GIC_IRQ_STATE_ACTIVE ; +if (active && pending) + state =GIC_IRQ_STATE_ACTIVE_PENDING ; + +return state; +}
Otherwise,
Thanks
Zenghui Yu
reviewerQuoted 16 lines · Zenghui Yu
Hi Drew,
Quoted 10 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>[...]
Quoted 7 lines
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 150
Quoted 2 lines
lib/arm/gic.c +2
-0+ +enum gic_irq_state gic_irq_state (int irq)This is a *generic* name while this function only deals with PPI. Maybe we can use something like
gic_ppi_state()instead? Or you will have to take all interrupt types into account in a single function, which is not a easy job I think.
Just to follow up, gic_irq_get_irqchip_state()/gic_peek_irq() [*] is the Linux implementation of this for PPIs and SPIs.
[*] linux/drivers/irqchip/irq-gic-v3.c
Thanks,
Zenghui
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Quoted 25 lines · Zenghui Yu
Quoted 16 lines · Zenghui Yu
Hi Drew,
Quoted 10 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>[...]
Quoted 7 lines
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 150
Quoted 2 lines
lib/arm/gic.c +2
-0+ +enum gic_irq_state gic_irq_state (int irq)This is a *generic* name while this function only deals with PPI. Maybe we can use something like
gic_ppi_state()instead? Or you will have to take all interrupt types into account in a single function, which is not a easy job I think.
Quoted 5 lines
Just to follow up, gic_irq_get_irqchip_state()/gic_peek_irq() [*] is the Linux implementation of this for PPIs and SPIs.
[*]
linux/drivers/irqchip/irq-gic-v3.c
Thanks. I just skimmed that now and it looks like the diff I sent is pretty close. But, I do see a bug in my diff (missing '* 4' on the offset calculation).
Thanks,
drew
Quoted 16 lines · Zenghui Yu
Hi Drew,
Quoted 10 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>[...]
Quoted 7 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ +enum gic_irq_state gic_irq_state(int irq)This is a *generic* name while this function only deals with PPI. Maybe we can use something like
gic_ppi_state()instead? Or you will have to take all interrupt types into account in a single function, which is not a easy job I think.
Very good point.
Quoted 14 lines
Quoted 14 lines
(quoted diff) +13
-0+{ + enum gic_irq_state state; + bool pending = false, active = false; + void *base; + + assert(gic_common_ops); + + switch (gic_version()) { + case 2: + base = gicv2_dist_base(); + pending = readl(base + GICD_ISPENDR) & (1 << PPI(irq)); + active = readl(base + GICD_ISACTIVER) & (1 << PPI(irq)); + break;
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ case 3: + base = gicv3_sgi_base(); + pending = readl(base + GICR_ISPENDR0) & (1 << PPI(irq)); + active = readl(base + GICR_ISACTIVER0) & (1 << PPI(irq));And you may also want to ensure that the 'irq' is valid for
PPI(). Or personally, I'd just use a real PPI number (PPI(info->irq)) as the input parameter of this function.
Indeed, if we want to make this a general function we should require the caller to pass PPI(irq).
Quoted 19 lines
Quoted 6 lines
(quoted diff) +4
-0+ break; + } + + if (!active && !pending)Review
Quoted 10 lines
(quoted diff) +10
-0+ state = GIC_IRQ_STATE_INACTIVE; + if (pending) + state = GIC_IRQ_STATE_PENDING; + if (active) + state = GIC_IRQ_STATE_ACTIVE; + if (active && pending) + state = GIC_IRQ_STATE_ACTIVE_PENDING; + + return state; +}Otherwise,
Quoted 2 lines
Reviewed-by Zenghui Yu <[email protected]>Tested-by Zenghui Yu <[email protected]>
Thanks, but I guess I should squash in changes to make this function more general. My GIC/SPI skills are weak, so I'm not sure this is right, especially because the SPI stuff doesn't yet have a user to validate it. However, if all reviewers think it's correct, then I'll squash it into the arm/queue branch. I've added Andre and Eric to help review too.
Thanks,
drew
arm/timer.c +2 -2
@@ -189,9 +189,9 @@ static bool gic_timer_check_state(struct timer_info *info,/* Wait for up to 1s for the GIC to sample the interrupt. */ for (i =0 ; i <10 ; i++) {mdelay (100 ); -if (gic_irq_state (info->irq) == expected_state) { +if (gic_irq_state (PPI (info->irq)) == expected_state) {mdelay (100 ); -if (gic_irq_state (info->irq) == expected_state) +if (gic_irq_state (PPI (info->irq)) == expected_state)return true; } }
lib/arm/gic.c +23 -8
@@ -150,22 +150,37 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)enum gic_irq_state gic_irq_state (int irq) {enum gic_irq_state state; -bool pending = false, active = false; -void *base; +void *ispendr, *isactiver; +bool pending, active;assert (gic_common_ops);switch (gic_version ()) {case 2 : - base =gicv2_dist_base (); - pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); - active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); + ispendr =gicv2_dist_base () +GICD_ISPENDR ; + isactiver =gicv2_dist_base () +GICD_ISACTIVER ;break ;case 3 : - base =gicv3_sgi_base (); - pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); - active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq)); +if (irq <GIC_NR_PRIVATE_IRQS ) { + ispendr =gicv3_sgi_base () +GICR_ISPENDR0 ; + isactiver =gicv3_sgi_base () +GICR_ISACTIVER0 ; + }else { + ispendr =gicv3_dist_base () +GICD_ISPENDR ; + isactiver =gicv3_dist_base () +GICD_ISACTIVER ; + }break ; +default : +assert (0 ); + } + +if (irq <GIC_NR_PRIVATE_IRQS ) { + pending =readl (ispendr) & (1 << irq); + active =readl (isactiver) & (1 << irq); + }else { +int offset = (irq -GIC_FIRST_SPI ) /32 ; +int mask =1 << ((irq -GIC_FIRST_SPI ) %32 ); + pending =readl (ispendr + offset) & mask; + active =readl (isactiver + offset) & mask; }if (!active && !pending)
Zenghui Yu
reviewerHi Drew,
Quoted 72 lines · Andrew Jones
Quoted 16 lines · Zenghui Yu
Hi Drew,
Quoted 10 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>[...]
Quoted 7 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ +enum gic_irq_state gic_irq_state(int irq)This is a *generic* name while this function only deals with PPI. Maybe we can use something like
gic_ppi_state()instead? Or you will have to take all interrupt types into account in a single function, which is not a easy job I think.Very good point.
Quoted 14 lines
Quoted 14 lines
(quoted diff) +13
-0+{ + enum gic_irq_state state; + bool pending = false, active = false; + void *base; + + assert(gic_common_ops); + + switch (gic_version()) { + case 2: + base = gicv2_dist_base(); + pending = readl(base + GICD_ISPENDR) & (1 << PPI(irq)); + active = readl(base + GICD_ISACTIVER) & (1 << PPI(irq)); + break;Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ case 3: + base = gicv3_sgi_base(); + pending = readl(base + GICR_ISPENDR0) & (1 << PPI(irq)); + active = readl(base + GICR_ISACTIVER0) & (1 << PPI(irq));And you may also want to ensure that the 'irq' is valid for
PPI(). Or personally, I'd just use a real PPI number (PPI(info->irq)) as the input parameter of this function.Indeed, if we want to make this a general function we should require the caller to pass PPI(irq).
Quoted 19 lines
Quoted 6 lines
(quoted diff) +4
-0+ break; + } + + if (!active && !pending)Review
Quoted 10 lines
(quoted diff) +10
-0+ state = GIC_IRQ_STATE_INACTIVE; + if (pending) + state = GIC_IRQ_STATE_PENDING; + if (active) + state = GIC_IRQ_STATE_ACTIVE; + if (active && pending) + state = GIC_IRQ_STATE_ACTIVE_PENDING; + + return state; +}Otherwise,
Quoted 6 lines
Quoted 2 lines
Reviewed-by Zenghui Yu <[email protected]>Tested-by Zenghui Yu <[email protected]>Thanks, but I guess I should squash in changes to make this function more general. My GIC/SPI skills are weak, so I'm not sure this is right, especially because the SPI stuff doesn't yet have a user to validate it.
(I guess the PL031 can be another new user.)
Quoted 28 lines
However, if all reviewers think it's correct, then I'll squash it into the arm/queue branch. I've added Andre and Eric to help review too.
Thanks,
drewarm/timer.c +2
-2@@ -189,9 +189,9 @@ static bool gic_timer_check_state(struct timer_info *info,/* Wait for up to 1s for the GIC to sample the interrupt. */ for (i =0 ; i <10 ; i++) {mdelay (100 ); -if (gic_irq_state (info->irq) == expected_state) { +if (gic_irq_state (PPI (info->irq)) == expected_state) {mdelay (100 ); -if (gic_irq_state (info->irq) == expected_state) +if (gic_irq_state (PPI (info->irq)) == expected_state)return true; } }lib/arm/gic.c +0
-0
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 156
Quoted 9 lines
lib/arm/gic.c +2
-2@@ -150,22 +150,37 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)enum gic_irq_state gic_irq_state (int irq) {enum gic_irq_state state; -bool pending = false, active = false; -void *base; +void *ispendr, *isactiver; +bool pending, active;assert (gic_common_ops);
We can also assert that only interrupts with ID smaller than 1020 will be handled.
Quoted 21 lines
lib/arm/gic.c +9
-6switch (gic_version ()) {case 2 : - base =gicv2_dist_base (); - pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); - active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); + ispendr =gicv2_dist_base () +GICD_ISPENDR ; + isactiver =gicv2_dist_base () +GICD_ISACTIVER ;break ;case 3 : - base =gicv3_sgi_base (); - pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); - active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq)); +if (irq <GIC_NR_PRIVATE_IRQS ) { + ispendr =gicv3_sgi_base () +GICR_ISPENDR0 ; + isactiver =gicv3_sgi_base () +GICR_ISACTIVER0 ; + }else { + ispendr =gicv3_dist_base () +GICD_ISPENDR ; + isactiver =gicv3_dist_base () +GICD_ISACTIVER ; + }break ;
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 180
Quoted 10 lines
lib/arm/gic.c +10
-0+default : +assert (0 ); + } + +if (irq <GIC_NR_PRIVATE_IRQS ) { + pending =readl (ispendr) & (1 << irq); + active =readl (isactiver) & (1 << irq); + }else { +int offset = (irq -GIC_FIRST_SPI ) /32 ; +int mask =1 << ((irq -GIC_FIRST_SPI ) %32 );
No need to minus GIC_FIRST_SPI. And therefore these two cases can actually be merged.
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 185
Quoted 5 lines
lib/arm/gic.c +2
-0+ pending =readl (ispendr + offset) & mask; + active =readl (isactiver + offset) & mask; }if (!active && !pending)
Otherwise this looks good enough (to me) for now, and let's wait other reviewers to comment. I've used the following diff to give the pl031 test a go (roughly written, not dig into PL031 so much), it just works fine :)
Thanks,
Zenghui
arm/pl031.c +4 -3
@@ -118,11 +118,12 @@ static int check_rtc_freq(void)return 0 ; } -static bool gic_irq_pending (void ) +static bool gic_pl031_pending (void ) { -uint32_t offset = (pl031_irq /32 ) *4 ; +enum gic_irq_state state =gic_irq_state (pl031_irq); -return readl (gic_ispendr + offset) & (1 << (pl031_irq &31 )); +return state ==GIC_IRQ_STATE_PENDING || + state ==GIC_IRQ_STATE_ACTIVE_PENDING ; }static void gic_irq_unmask (void )
[...]
/* replace all gic_irq_pending() with gic_pl031_pending() */ [...]
lib/arm/gic.c +5 -9
@@ -152,6 +152,7 @@ enum gic_irq_state gic_irq_state(int irq)enum gic_irq_state state;void *ispendr, *isactiver;bool pending, active; +int offset, mask;assert (gic_common_ops);
@@ -173,15 +174,10 @@ enum gic_irq_state gic_irq_state(int irq)assert (0 ); } -if (irq <GIC_NR_PRIVATE_IRQS ) { - pending =readl (ispendr) & (1 << irq); - active =readl (isactiver) & (1 << irq); - }else { -int offset = (irq -GIC_FIRST_SPI ) /32 ; -int mask =1 << ((irq -GIC_FIRST_SPI ) %32 ); - pending =readl (ispendr + offset) & mask; - active =readl (isactiver + offset) & mask; - } + offset = (irq /32 ) *4 ; + mask =1 << (irq %32 ); + pending =readl (ispendr + offset) & mask; + active =readl (isactiver + offset) & mask;if (!active && !pending) state =GIC_IRQ_STATE_INACTIVE ;
Quoted 115 lines · Zenghui Yu
Hi Drew,
Quoted 72 lines · Andrew Jones
Quoted 16 lines · Zenghui Yu
Hi Drew,
Quoted 10 lines · Andrew Jones
Let's bail out of the wait loop if we see the expected state to save over six seconds of run time. Make sure we wait a bit before reading the registers and double check again after, though, to somewhat mitigate the chance of seeing the expected state by accident.
We also take this opportunity to push more IRQ state code to the library.
Signed-off-by Andrew Jones <[email protected]>[...]
Quoted 7 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ +enum gic_irq_state gic_irq_state(int irq)This is a *generic* name while this function only deals with PPI. Maybe we can use something like
gic_ppi_state()instead? Or you will have to take all interrupt types into account in a single function, which is not a easy job I think.Very good point.
Quoted 14 lines
Quoted 14 lines
(quoted diff) +13
-0+{ + enum gic_irq_state state; + bool pending = false, active = false; + void *base; + + assert(gic_common_ops); + + switch (gic_version()) { + case 2: + base = gicv2_dist_base(); + pending = readl(base + GICD_ISPENDR) & (1 << PPI(irq)); + active = readl(base + GICD_ISACTIVER) & (1 << PPI(irq)); + break;Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ case 3: + base = gicv3_sgi_base(); + pending = readl(base + GICR_ISPENDR0) & (1 << PPI(irq)); + active = readl(base + GICR_ISACTIVER0) & (1 << PPI(irq));And you may also want to ensure that the 'irq' is valid for
PPI(). Or personally, I'd just use a real PPI number (PPI(info->irq)) as the input parameter of this function.Indeed, if we want to make this a general function we should require the caller to pass PPI(irq).
Quoted 19 lines
Quoted 6 lines
(quoted diff) +4
-0+ break; + } + + if (!active && !pending)Review
Quoted 10 lines
(quoted diff) +10
-0+ state = GIC_IRQ_STATE_INACTIVE; + if (pending) + state = GIC_IRQ_STATE_PENDING; + if (active) + state = GIC_IRQ_STATE_ACTIVE; + if (active && pending) + state = GIC_IRQ_STATE_ACTIVE_PENDING; + + return state; +}Otherwise,
Quoted 6 lines
Quoted 2 lines
Reviewed-by Zenghui Yu <[email protected]>Tested-by Zenghui Yu <[email protected]>Thanks, but I guess I should squash in changes to make this function more general. My GIC/SPI skills are weak, so I'm not sure this is right, especially because the SPI stuff doesn't yet have a user to validate it.
(I guess the PL031 can be another new user.)
Quoted 31 lines
However, if all reviewers think it's correct, then I'll squash it into the arm/queue branch. I've added Andre and Eric to help review too.
Thanks,
drewarm/timer.c +2
-2@@ -189,9 +189,9 @@ static bool gic_timer_check_state(struct timer_info *info,/* Wait for up to 1s for the GIC to sample the interrupt. */ for (i =0 ; i <10 ; i++) {mdelay (100 ); -if (gic_irq_state (info->irq) == expected_state) { +if (gic_irq_state (PPI (info->irq)) == expected_state) {mdelay (100 ); -if (gic_irq_state (info->irq) == expected_state) +if (gic_irq_state (PPI (info->irq)) == expected_state)return true; } }lib/arm/gic.c +0
-0@@ -150,22 +150,37 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)enum gic_irq_state gic_irq_state (int irq) {enum gic_irq_state state;
Quoted 8 lines
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 155
Quoted 5 lines
lib/arm/gic.c +2
-2-bool pending = false, active = false; -void *base; +void *ispendr, *isactiver; +bool pending, active;assert (gic_common_ops);We can also assert that only interrupts with ID smaller than 1020 will be handled.
Good idea
Quoted 26 lines
Quoted 26 lines
lib/arm/gic.c +14
-6switch (gic_version ()) {case 2 : - base =gicv2_dist_base (); - pending =readl (base +GICD_ISPENDR ) & (1 <<PPI (irq)); - active =readl (base +GICD_ISACTIVER ) & (1 <<PPI (irq)); + ispendr =gicv2_dist_base () +GICD_ISPENDR ; + isactiver =gicv2_dist_base () +GICD_ISACTIVER ;break ;case 3 : - base =gicv3_sgi_base (); - pending =readl (base +GICR_ISPENDR0 ) & (1 <<PPI (irq)); - active =readl (base +GICR_ISACTIVER0 ) & (1 <<PPI (irq)); +if (irq <GIC_NR_PRIVATE_IRQS ) { + ispendr =gicv3_sgi_base () +GICR_ISPENDR0 ; + isactiver =gicv3_sgi_base () +GICR_ISACTIVER0 ; + }else { + ispendr =gicv3_dist_base () +GICD_ISPENDR ; + isactiver =gicv3_dist_base () +GICD_ISACTIVER ; + }break ; +default : +assert (0 ); + } + +if (irq <GIC_NR_PRIVATE_IRQS ) {
Quoted 8 lines
lib/arm/gic.c void gic_ipi_send_mask(int irq, const cpumask_t *dest) · line 179
Quoted 5 lines
lib/arm/gic.c +5
-0+ pending =readl (ispendr) & (1 << irq); + active =readl (isactiver) & (1 << irq); + }else { +int offset = (irq -GIC_FIRST_SPI ) /32 ; +int mask =1 << ((irq -GIC_FIRST_SPI ) %32 );No need to minus
GIC_FIRST_SPI. And therefore these two cases can actually be merged.
Yup, will do
Quoted 22 lines
lib/arm/gic.c enum gic_irq_state gic_irq_state(int irq) · line 182
Quoted 5 lines
lib/arm/gic.c +2
-0+ pending =readl (ispendr + offset) & mask; + active =readl (isactiver + offset) & mask; }if (!active && !pending)Otherwise this looks good enough (to me) for now, and let's wait other reviewers to comment. I've used the following diff to give the pl031 test a go (roughly written, not dig into PL031 so much), it just works fine :)
Thanks,
Zenghuiarm/pl031.c +0
-0@@ -118,11 +118,12 @@ static int check_rtc_freq(void)return 0 ; }
arm/pl031.c static int check_rtc_freq(void) · line 126
Quoted 10 lines
arm/pl031.c +4
-3-static bool gic_irq_pending (void ) +static bool gic_pl031_pending (void ) { -uint32_t offset = (pl031_irq /32 ) *4 ; +enum gic_irq_state state =gic_irq_state (pl031_irq); -return readl (gic_ispendr + offset) & (1 << (pl031_irq &31 )); +return state ==GIC_IRQ_STATE_PENDING || + state ==GIC_IRQ_STATE_ACTIVE_PENDING ;
Nice way to test, but I'll leave this change out.
Quoted 31 lines
arm/pl031.c +0
-0}static void gic_irq_unmask (void )/* replace all
gic_irq_pending()withgic_pl031_pending()*/ [...]lib/arm/gic.c +1
-6@@ -152,6 +152,7 @@ enum gic_irq_state gic_irq_state(int irq)enum gic_irq_state state;void *ispendr, *isactiver;bool pending, active; +int offset, mask;assert (gic_common_ops);@@ -173,15 +174,10 @@ enum gic_irq_state gic_irq_state(int irq)assert (0 ); } -if (irq <GIC_NR_PRIVATE_IRQS ) { - pending =readl (ispendr) & (1 << irq); - active =readl (isactiver) & (1 << irq); - }else { -int offset = (irq -GIC_FIRST_SPI ) /32 ; -int mask =1 << ((irq -GIC_FIRST_SPI ) %32 );
lib/arm/gic.c enum gic_irq_state gic_irq_state(int irq) · line 183
Quoted 10 lines
lib/arm/gic.c +4
-3- pending =readl (ispendr + offset) & mask; - active =readl (isactiver + offset) & mask; - } + offset = (irq /32 ) *4 ; + mask =1 << (irq %32 ); + pending =readl (ispendr + offset) & mask; + active =readl (isactiver + offset) & mask;if (!active && !pending) state =GIC_IRQ_STATE_INACTIVE ;
I'll send a final patch now for review, but I'm pretty happy with this so I've gone ahead and squashed it into arm/queue already. I kept Alex's r-b as there shouldn't be any functional change with respect to what he reviewed.
Thanks,
drew