Skip to contentSkip to conversation

arm64: timer: Speed up gic-timer-state check

PATCH Superseded Andrew Jones 3 participants 9 messages Feb 11, 2020 – Feb 13, 2020

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

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
index f5cf775ce50f..3c4e27f20e2e 100644
@@ -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
index a72e0cde4e9c..922cbe95750c 100644
@@ -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
index 94301169215c..0563b31132c8 100644
@@ -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
Reviewed-by on v2 1/1
#1 lore raw

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.

---
 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
index f5cf775ce50f..3c4e27f20e2e 100644
@@ -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
index a72e0cde4e9c..922cbe95750c 100644
@@ -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
index 94301169215c..0563b31132c8 100644
@@ -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

#2 lore raw
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.

---
 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
index f5cf775ce50f..3c4e27f20e2e 100644
@@ -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
index a72e0cde4e9c..922cbe95750c 100644
@@ -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
index 94301169215c..0563b31132c8 100644
@@ -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:

Quoted 1 line

Indeed. I'll remove them and add your r-b while applying.

Thanks,
drew

Quoted 4 lines

Thanks,
Alex

reviewer Reviewed-by Tested-by on v2 1/1
#3 lore raw
In reply to Andrew Jones

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.

[...]

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

reviewer
#4 lore raw
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.

[...]

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

#5 lore raw
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.

[...]

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

#6 lore raw
In reply to 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.

[...]

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

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
index ae5fdbf54b35..44621b4f2967 100644
@@ -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
index 0563b31132c8..3924dd1d1ee6 100644
@@ -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)
reviewer
#7 lore raw

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.

[...]

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

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,
drew

arm/timer.c +2 -2
index ae5fdbf54b35..44621b4f2967 100644
@@ -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
index 0563b31132c8..3924dd1d1ee6 100644

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 -6
  	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;

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
index 86035fa..2d4160f 100644
@@ -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
index 3924dd1..34d77e3 100644
@@ -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;
#8 lore raw
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.

[...]

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

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,
drew

arm/timer.c +2 -2
index ae5fdbf54b35..44621b4f2967 100644
@@ -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
index 0563b31132c8..3924dd1d1ee6 100644
@@ -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 -6
  	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) {
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,
Zenghui

arm/pl031.c +0 -0
index 86035fa..2d4160f 100644
@@ -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() with gic_pl031_pending() */ [...]

lib/arm/gic.c +1 -6
index 3924dd1..34d77e3 100644
@@ -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