---

yaml --- r: 233819 b: refs/heads/master c: 450adcb h: refs/heads/master i: 233817: 0285c8c 233815: 1a8da4f v: v3
git-mirror · Mar 1, 2011 · 7852c9b · 7852c9b
1 parent e91b7c3
commit 7852c9b
Show file tree

Hide file tree

Showing 63 changed files with 452 additions and 525 deletions.
diff --git a/[refs] b/[refs]
@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8336026942fdf6a96a45057a2fe6d7f7946979d5
+refs/heads/master: 450adcbe518ab3a3953d8475309525d22de77cba
diff --git a/trunk/Makefile b/trunk/Makefile
@@ -1,7 +1,7 @@
 VERSION = 2
 PATCHLEVEL = 6
 SUBLEVEL = 38
-EXTRAVERSION = -rc7
+EXTRAVERSION = -rc6
 NAME = Flesh-Eating Bats with Fangs
 
 # *DOCUMENTATION*

diff --git a/trunk/arch/alpha/Kconfig b/trunk/arch/alpha/Kconfig
@@ -11,7 +11,6 @@ config ALPHA
 	select HAVE_GENERIC_HARDIRQS
 	select GENERIC_IRQ_PROBE
 	select AUTO_IRQ_AFFINITY if SMP
-	select GENERIC_HARDIRQS_NO_DEPRECATED
 	help
 	  The Alpha is a 64-bit general-purpose processor designed and
 	  marketed by the Digital Equipment Corporation of blessed memory,

diff --git a/trunk/arch/alpha/kernel/irq.c b/trunk/arch/alpha/kernel/irq.c
@@ -44,25 +44,20 @@ static char irq_user_affinity[NR_IRQS];
 
 int irq_select_affinity(unsigned int irq)
 {
-	struct irq_data *data = irq_get_irq_data(irq);
-	struct irq_chip *chip;
+	struct irq_desc *desc = irq_to_desc[irq];
 	static int last_cpu;
 	int cpu = last_cpu + 1;
 
-	if (!data)
-		return 1;
-	chip = irq_data_get_irq_chip(data);
-
-	if (!chip->irq_set_affinity || irq_user_affinity[irq])
+	if (!desc || !get_irq_desc_chip(desc)->set_affinity || irq_user_affinity[irq])
 		return 1;
 
 	while (!cpu_possible(cpu) ||
 	       !cpumask_test_cpu(cpu, irq_default_affinity))
 		cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
 	last_cpu = cpu;
 
-	cpumask_copy(data->affinity, cpumask_of(cpu));
-	chip->irq_set_affinity(data, cpumask_of(cpu), false);
+	cpumask_copy(desc->affinity, cpumask_of(cpu));
+	get_irq_desc_chip(desc)->set_affinity(irq, cpumask_of(cpu));
 	return 0;
 }
 #endif /* CONFIG_SMP */

diff --git a/trunk/arch/alpha/kernel/irq_alpha.c b/trunk/arch/alpha/kernel/irq_alpha.c
@@ -228,9 +228,14 @@ struct irqaction timer_irqaction = {
 void __init
 init_rtc_irq(void)
 {
-	set_irq_chip_and_handler_name(RTC_IRQ, &no_irq_chip,
-				      handle_simple_irq, "RTC");
-	setup_irq(RTC_IRQ, &timer_irqaction);
+	struct irq_desc *desc = irq_to_desc(RTC_IRQ);
+
+	if (desc) {
+		desc->status |= IRQ_DISABLED;
+		set_irq_chip_and_handler_name(RTC_IRQ, &no_irq_chip,
+			handle_simple_irq, "RTC");
+		setup_irq(RTC_IRQ, &timer_irqaction);
+	}
 }
 
 /* Dummy irqactions.  */

diff --git a/trunk/arch/alpha/kernel/irq_i8259.c b/trunk/arch/alpha/kernel/irq_i8259.c
@@ -33,10 +33,10 @@ i8259_update_irq_hw(unsigned int irq, unsigned long mask)
 }
 
 inline void
-i8259a_enable_irq(struct irq_data *d)
+i8259a_enable_irq(unsigned int irq)
 {
 	spin_lock(&i8259_irq_lock);
-	i8259_update_irq_hw(d->irq, cached_irq_mask &= ~(1 << d->irq));
+	i8259_update_irq_hw(irq, cached_irq_mask &= ~(1 << irq));
 	spin_unlock(&i8259_irq_lock);
 }
 
@@ -47,18 +47,16 @@ __i8259a_disable_irq(unsigned int irq)
 }
 
 void
-i8259a_disable_irq(struct irq_data *d)
+i8259a_disable_irq(unsigned int irq)
 {
 	spin_lock(&i8259_irq_lock);
-	__i8259a_disable_irq(d->irq);
+	__i8259a_disable_irq(irq);
 	spin_unlock(&i8259_irq_lock);
 }
 
 void
-i8259a_mask_and_ack_irq(struct irq_data *d)
+i8259a_mask_and_ack_irq(unsigned int irq)
 {
-	unsigned int irq = d->irq;
-
 	spin_lock(&i8259_irq_lock);
 	__i8259a_disable_irq(irq);
 
@@ -73,9 +71,9 @@ i8259a_mask_and_ack_irq(struct irq_data *d)
 
 struct irq_chip i8259a_irq_type = {
 	.name		= "XT-PIC",
-	.irq_unmask	= i8259a_enable_irq,
-	.irq_mask	= i8259a_disable_irq,
-	.irq_mask_ack	= i8259a_mask_and_ack_irq,
+	.unmask		= i8259a_enable_irq,
+	.mask		= i8259a_disable_irq,
+	.mask_ack	= i8259a_mask_and_ack_irq,
 };
 
 void __init

diff --git a/trunk/arch/alpha/kernel/irq_impl.h b/trunk/arch/alpha/kernel/irq_impl.h
@@ -31,9 +31,11 @@ extern void init_rtc_irq(void);
 
 extern void common_init_isa_dma(void);
 
-extern void i8259a_enable_irq(struct irq_data *d);
-extern void i8259a_disable_irq(struct irq_data *d);
-extern void i8259a_mask_and_ack_irq(struct irq_data *d);
+extern void i8259a_enable_irq(unsigned int);
+extern void i8259a_disable_irq(unsigned int);
+extern void i8259a_mask_and_ack_irq(unsigned int);
+extern unsigned int i8259a_startup_irq(unsigned int);
+extern void i8259a_end_irq(unsigned int);
 extern struct irq_chip i8259a_irq_type;
 extern void init_i8259a_irqs(void);
 

diff --git a/trunk/arch/alpha/kernel/irq_pyxis.c b/trunk/arch/alpha/kernel/irq_pyxis.c
@@ -29,21 +29,21 @@ pyxis_update_irq_hw(unsigned long mask)
 }
 
 static inline void
-pyxis_enable_irq(struct irq_data *d)
+pyxis_enable_irq(unsigned int irq)
 {
-	pyxis_update_irq_hw(cached_irq_mask |= 1UL << (d->irq - 16));
+	pyxis_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16));
 }
 
 static void
-pyxis_disable_irq(struct irq_data *d)
+pyxis_disable_irq(unsigned int irq)
 {
-	pyxis_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
+	pyxis_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16)));
 }
 
 static void
-pyxis_mask_and_ack_irq(struct irq_data *d)
+pyxis_mask_and_ack_irq(unsigned int irq)
 {
-	unsigned long bit = 1UL << (d->irq - 16);
+	unsigned long bit = 1UL << (irq - 16);
 	unsigned long mask = cached_irq_mask &= ~bit;
 
 	/* Disable the interrupt.  */
@@ -58,9 +58,9 @@ pyxis_mask_and_ack_irq(struct irq_data *d)
 
 static struct irq_chip pyxis_irq_type = {
 	.name		= "PYXIS",
-	.irq_mask_ack	= pyxis_mask_and_ack_irq,
-	.irq_mask	= pyxis_disable_irq,
-	.irq_unmask	= pyxis_enable_irq,
+	.mask_ack	= pyxis_mask_and_ack_irq,
+	.mask		= pyxis_disable_irq,
+	.unmask		= pyxis_enable_irq,
 };
 
 void 
@@ -103,7 +103,7 @@ init_pyxis_irqs(unsigned long ignore_mask)
 		if ((ignore_mask >> i) & 1)
 			continue;
 		set_irq_chip_and_handler(i, &pyxis_irq_type, handle_level_irq);
-		irq_set_status_flags(i, IRQ_LEVEL);
+		irq_to_desc(i)->status |= IRQ_LEVEL;
 	}
 
 	setup_irq(16+7, &isa_cascade_irqaction);

diff --git a/trunk/arch/alpha/kernel/irq_srm.c b/trunk/arch/alpha/kernel/irq_srm.c
@@ -18,27 +18,27 @@
 DEFINE_SPINLOCK(srm_irq_lock);
 
 static inline void
-srm_enable_irq(struct irq_data *d)
+srm_enable_irq(unsigned int irq)
 {
 	spin_lock(&srm_irq_lock);
-	cserve_ena(d->irq - 16);
+	cserve_ena(irq - 16);
 	spin_unlock(&srm_irq_lock);
 }
 
 static void
-srm_disable_irq(struct irq_data *d)
+srm_disable_irq(unsigned int irq)
 {
 	spin_lock(&srm_irq_lock);
-	cserve_dis(d->irq - 16);
+	cserve_dis(irq - 16);
 	spin_unlock(&srm_irq_lock);
 }
 
 /* Handle interrupts from the SRM, assuming no additional weirdness.  */
 static struct irq_chip srm_irq_type = {
 	.name		= "SRM",
-	.irq_unmask	= srm_enable_irq,
-	.irq_mask	= srm_disable_irq,
-	.irq_mask_ack	= srm_disable_irq,
+	.unmask		= srm_enable_irq,
+	.mask		= srm_disable_irq,
+	.mask_ack	= srm_disable_irq,
 };
 
 void __init
@@ -52,7 +52,7 @@ init_srm_irqs(long max, unsigned long ignore_mask)
 		if (i < 64 && ((ignore_mask >> i) & 1))
 			continue;
 		set_irq_chip_and_handler(i, &srm_irq_type, handle_level_irq);
-		irq_set_status_flags(i, IRQ_LEVEL);
+		irq_to_desc(i)->status |= IRQ_LEVEL;
 	}
 }
 

diff --git a/trunk/arch/alpha/kernel/sys_alcor.c b/trunk/arch/alpha/kernel/sys_alcor.c
@@ -44,31 +44,31 @@ alcor_update_irq_hw(unsigned long mask)
 }
 
 static inline void
-alcor_enable_irq(struct irq_data *d)
+alcor_enable_irq(unsigned int irq)
 {
-	alcor_update_irq_hw(cached_irq_mask |= 1UL << (d->irq - 16));
+	alcor_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16));
 }
 
 static void
-alcor_disable_irq(struct irq_data *d)
+alcor_disable_irq(unsigned int irq)
 {
-	alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
+	alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16)));
 }
 
 static void
-alcor_mask_and_ack_irq(struct irq_data *d)
+alcor_mask_and_ack_irq(unsigned int irq)
 {
-	alcor_disable_irq(d);
+	alcor_disable_irq(irq);
 
 	/* On ALCOR/XLT, need to dismiss interrupt via GRU. */
-	*(vuip)GRU_INT_CLEAR = 1 << (d->irq - 16); mb();
+	*(vuip)GRU_INT_CLEAR = 1 << (irq - 16); mb();
 	*(vuip)GRU_INT_CLEAR = 0; mb();
 }
 
 static void
-alcor_isa_mask_and_ack_irq(struct irq_data *d)
+alcor_isa_mask_and_ack_irq(unsigned int irq)
 {
-	i8259a_mask_and_ack_irq(d);
+	i8259a_mask_and_ack_irq(irq);
 
 	/* On ALCOR/XLT, need to dismiss interrupt via GRU. */
 	*(vuip)GRU_INT_CLEAR = 0x80000000; mb();
@@ -77,9 +77,9 @@ alcor_isa_mask_and_ack_irq(struct irq_data *d)
 
 static struct irq_chip alcor_irq_type = {
 	.name		= "ALCOR",
-	.irq_unmask	= alcor_enable_irq,
-	.irq_mask	= alcor_disable_irq,
-	.irq_mask_ack	= alcor_mask_and_ack_irq,
+	.unmask		= alcor_enable_irq,
+	.mask		= alcor_disable_irq,
+	.mask_ack	= alcor_mask_and_ack_irq,
 };
 
 static void
@@ -126,9 +126,9 @@ alcor_init_irq(void)
 		if (i >= 16+20 && i <= 16+30)
 			continue;
 		set_irq_chip_and_handler(i, &alcor_irq_type, handle_level_irq);
-		irq_set_status_flags(i, IRQ_LEVEL);
+		irq_to_desc(i)->status |= IRQ_LEVEL;
 	}
-	i8259a_irq_type.irq_ack = alcor_isa_mask_and_ack_irq;
+	i8259a_irq_type.ack = alcor_isa_mask_and_ack_irq;
 
 	init_i8259a_irqs();
 	common_init_isa_dma();

diff --git a/trunk/arch/alpha/kernel/sys_cabriolet.c b/trunk/arch/alpha/kernel/sys_cabriolet.c
@@ -46,22 +46,22 @@ cabriolet_update_irq_hw(unsigned int irq, unsigned long mask)
 }
 
 static inline void
-cabriolet_enable_irq(struct irq_data *d)
+cabriolet_enable_irq(unsigned int irq)
 {
-	cabriolet_update_irq_hw(d->irq, cached_irq_mask &= ~(1UL << d->irq));
+	cabriolet_update_irq_hw(irq, cached_irq_mask &= ~(1UL << irq));
 }
 
 static void
-cabriolet_disable_irq(struct irq_data *d)
+cabriolet_disable_irq(unsigned int irq)
 {
-	cabriolet_update_irq_hw(d->irq, cached_irq_mask |= 1UL << d->irq);
+	cabriolet_update_irq_hw(irq, cached_irq_mask |= 1UL << irq);
 }
 
 static struct irq_chip cabriolet_irq_type = {
 	.name		= "CABRIOLET",
-	.irq_unmask	= cabriolet_enable_irq,
-	.irq_mask	= cabriolet_disable_irq,
-	.irq_mask_ack	= cabriolet_disable_irq,
+	.unmask		= cabriolet_enable_irq,
+	.mask		= cabriolet_disable_irq,
+	.mask_ack	= cabriolet_disable_irq,
 };
 
 static void 
@@ -107,7 +107,7 @@ common_init_irq(void (*srm_dev_int)(unsigned long v))
 		for (i = 16; i < 35; ++i) {
 			set_irq_chip_and_handler(i, &cabriolet_irq_type,
 				handle_level_irq);
-			irq_set_status_flags(i, IRQ_LEVEL);
+			irq_to_desc(i)->status |= IRQ_LEVEL;
 		}
 	}