Merge bk://kernel.bkbits.net/jgarzik/libata-2.6

into ppc970.osdl.org:/home/torvalds/v2.6/linux

arch/i386/Kconfig

@@ -1207,6 +1207,10 @@ config GENERIC_HARDIRQS
 	bool
 	default y
 
+config GENERIC_IRQ_PROBE
+	bool
+	default y
+
 config X86_SMP
 	bool
 	depends on SMP && !X86_VOYAGER

arch/ppc/kernel/irq.c

@@ -71,6 +71,11 @@ unsigned long ppc_cached_irq_mask[NR_MASK_WORDS];
 unsigned long ppc_lost_interrupts[NR_MASK_WORDS];
 atomic_t ppc_n_lost_interrupts;
 
+#ifdef CONFIG_TAU_INT
+extern int tau_initialized;
+extern int tau_interrupts(int);
+#endif
+
 int show_interrupts(struct seq_file *p, void *v)
 {
 	int i = *(loff_t *) v, j;

arch/ppc64/boot/main.c

@@ -166,7 +166,7 @@ void start(unsigned long a1, unsigned long a2, void *promptr)
 		gunzip((void *)vmlinux.addr, vmlinux.size,
 			(unsigned char *)vmlinuz.addr, &len);
 		printf("done 0x%lx bytes\n\r", len);
-		printf("0x%x bytes of heap consumed, max in use 0x%\n\r",
+		printf("0x%x bytes of heap consumed, max in use 0x%x\n\r",
 		       (unsigned)(avail_high - begin_avail), heap_max);
 	} else {
 		memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,vmlinuz.size);

arch/ppc64/kernel/prom_init.c

@@ -675,7 +675,7 @@ static void __init prom_init_mem(void)
 	if ( RELOC(of_platform) == PLATFORM_PSERIES_LPAR )
 		RELOC(alloc_top) = RELOC(rmo_top);
 	else
-		RELOC(alloc_top) = min(0x40000000ul, RELOC(ram_top));
+		RELOC(alloc_top) = RELOC(rmo_top) = min(0x40000000ul, RELOC(ram_top));
 	RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(klimit) - offset + 0x4000);
 	RELOC(alloc_top_high) = RELOC(ram_top);
 

arch/ppc64/mm/init.c

@@ -265,7 +265,7 @@ int __ioremap_explicit(unsigned long pa, unsigned long ea,
 	} else {
 		area = im_get_area(ea, size, IM_REGION_UNUSED|IM_REGION_SUBSET);
 		if (area == NULL) {
-			printk(KERN_ERR "could not obtain imalloc area for ea 0x%lx\n", ea);
+			/* Expected when PHB-dlpar is in play */
 			return 1;
 		}
 		if (ea != (unsigned long) area->addr) {

arch/x86_64/Kconfig

@@ -346,6 +346,10 @@ config GENERIC_HARDIRQS
 	bool
 	default y
 
+config GENERIC_IRQ_PROBE
+	bool
+	default y
+
 menu "Power management options"
 
 source kernel/power/Kconfig

drivers/macintosh/therm_pm72.c

@@ -46,6 +46,9 @@
  *          overtemp conditions so userland can take some policy
  *          decisions, like slewing down CPUs
  *	  - Deal with fan and i2c failures in a better way
+ *	  - Maybe do a generic PID based on params used for
+ *	    U3 and Drives ?
+ *        - Add RackMac3,1 support (XServe g5)
  *
  * History:
  *
@@ -73,6 +76,15 @@
  *        values in the configuration register
  *	- Switch back to use of target fan speed for PID, thus lowering
  *        pressure on i2c
+ *
+ *  Oct. 20, 2004 : 1.1
+ *	- Add device-tree lookup for fan IDs, should detect liquid cooling
+ *        pumps when present
+ *	- Enable driver for PowerMac7,3 machines
+ *	- Split the U3/Backside cooling on U3 & U3H versions as Darwin does
+ *	- Add new CPU cooling algorithm for machines with liquid cooling
+ *	- Workaround for some PowerMac7,3 with empty "fan" node in the devtree
+ *	- Fix a signed/unsigned compare issue in some PID loops
  */
 
 #include <linux/config.h>
@@ -88,7 +100,6 @@
 #include <linux/spinlock.h>
 #include <linux/smp_lock.h>
 #include <linux/wait.h>
-#include <linux/suspend.h>
 #include <linux/reboot.h>
 #include <linux/kmod.h>
 #include <linux/i2c.h>
@@ -102,7 +113,7 @@
 
 #include "therm_pm72.h"
 
-#define VERSION "0.9"
+#define VERSION "1.1"
 
 #undef DEBUG
 
@@ -122,15 +133,99 @@ static struct i2c_adapter *		u3_0;
 static struct i2c_adapter *		u3_1;
 static struct i2c_client *		fcu;
 static struct cpu_pid_state		cpu_state[2];
+static struct basckside_pid_params	backside_params;
 static struct backside_pid_state	backside_state;
 static struct drives_pid_state		drives_state;
 static int				state;
 static int				cpu_count;
+static int				cpu_pid_type;
 static pid_t				ctrl_task;
 static struct completion		ctrl_complete;
 static int				critical_state;
 static DECLARE_MUTEX(driver_lock);
 
+/*
+ * We have 2 types of CPU PID control. One is "split" old style control
+ * for intake & exhaust fans, the other is "combined" control for both
+ * CPUs that also deals with the pumps when present. To be "compatible"
+ * with OS X at this point, we only use "COMBINED" on the machines that
+ * are identified as having the pumps (though that identification is at
+ * least dodgy). Ultimately, we could probably switch completely to this
+ * algorithm provided we hack it to deal with the UP case
+ */
+#define CPU_PID_TYPE_SPLIT	0
+#define CPU_PID_TYPE_COMBINED	1
+
+/*
+ * This table describes all fans in the FCU. The "id" and "type" values
+ * are defaults valid for all earlier machines. Newer machines will
+ * eventually override the table content based on the device-tree
+ */
+struct fcu_fan_table
+{
+	char*	loc;	/* location code */
+	int	type;	/* 0 = rpm, 1 = pwm, 2 = pump */
+	int	id;	/* id or -1 */
+};
+
+#define FCU_FAN_RPM		0
+#define FCU_FAN_PWM		1
+
+#define FCU_FAN_ABSENT_ID	-1
+
+#define FCU_FAN_COUNT		ARRAY_SIZE(fcu_fans)
+
+struct fcu_fan_table	fcu_fans[] = {
+	[BACKSIDE_FAN_PWM_INDEX] = {
+		.loc	= "BACKSIDE",
+		.type	= FCU_FAN_PWM,
+		.id	= BACKSIDE_FAN_PWM_DEFAULT_ID,
+	},
+	[DRIVES_FAN_RPM_INDEX] = {
+		.loc	= "DRIVE BAY",
+		.type	= FCU_FAN_RPM,
+		.id	= DRIVES_FAN_RPM_DEFAULT_ID,
+	},
+	[SLOTS_FAN_PWM_INDEX] = {
+		.loc	= "SLOT",
+		.type	= FCU_FAN_PWM,
+		.id	= SLOTS_FAN_PWM_DEFAULT_ID,
+	},
+	[CPUA_INTAKE_FAN_RPM_INDEX] = {
+		.loc	= "CPU A INTAKE",
+		.type	= FCU_FAN_RPM,
+		.id	= CPUA_INTAKE_FAN_RPM_DEFAULT_ID,
+	},
+	[CPUA_EXHAUST_FAN_RPM_INDEX] = {
+		.loc	= "CPU A EXHAUST",
+		.type	= FCU_FAN_RPM,
+		.id	= CPUA_EXHAUST_FAN_RPM_DEFAULT_ID,
+	},
+	[CPUB_INTAKE_FAN_RPM_INDEX] = {
+		.loc	= "CPU B INTAKE",
+		.type	= FCU_FAN_RPM,
+		.id	= CPUB_INTAKE_FAN_RPM_DEFAULT_ID,
+	},
+	[CPUB_EXHAUST_FAN_RPM_INDEX] = {
+		.loc	= "CPU B EXHAUST",
+		.type	= FCU_FAN_RPM,
+		.id	= CPUB_EXHAUST_FAN_RPM_DEFAULT_ID,
+	},
+	/* pumps aren't present by default, have to be looked up in the
+	 * device-tree
+	 */
+	[CPUA_PUMP_RPM_INDEX] = {
+		.loc	= "CPU A PUMP",
+		.type	= FCU_FAN_RPM,		
+		.id	= FCU_FAN_ABSENT_ID,
+	},
+	[CPUB_PUMP_RPM_INDEX] = {
+		.loc	= "CPU B PUMP",
+		.type	= FCU_FAN_RPM,
+		.id	= FCU_FAN_ABSENT_ID,
+	},
+};
+
 /*
  * i2c_driver structure to attach to the host i2c controller
  */
@@ -332,10 +427,16 @@ static int start_fcu(void)
 	return 0;
 }
 
-static int set_rpm_fan(int fan, int rpm)
+static int set_rpm_fan(int fan_index, int rpm)
 {
 	unsigned char buf[2];
-	int rc;
+	int rc, id;
+
+	if (fcu_fans[fan_index].type != FCU_FAN_RPM)
+		return -EINVAL;
+	id = fcu_fans[fan_index].id; 
+	if (id == FCU_FAN_ABSENT_ID)
+		return -EINVAL;
 
 	if (rpm < 300)
 		rpm = 300;
@@ -343,43 +444,55 @@ static int set_rpm_fan(int fan, int rpm)
 		rpm = 8191;
 	buf[0] = rpm >> 5;
 	buf[1] = rpm << 3;
-	rc = fan_write_reg(0x10 + (fan * 2), buf, 2);
+	rc = fan_write_reg(0x10 + (id * 2), buf, 2);
 	if (rc < 0)
 		return -EIO;
 	return 0;
 }
 
-static int get_rpm_fan(int fan, int programmed)
+static int get_rpm_fan(int fan_index, int programmed)
 {
 	unsigned char failure;
 	unsigned char active;
 	unsigned char buf[2];
-	int rc, reg_base;
+	int rc, id, reg_base;
+
+	if (fcu_fans[fan_index].type != FCU_FAN_RPM)
+		return -EINVAL;
+	id = fcu_fans[fan_index].id; 
+	if (id == FCU_FAN_ABSENT_ID)
+		return -EINVAL;
 
 	rc = fan_read_reg(0xb, &failure, 1);
 	if (rc != 1)
 		return -EIO;
-	if ((failure & (1 << fan)) != 0)
+	if ((failure & (1 << id)) != 0)
 		return -EFAULT;
 	rc = fan_read_reg(0xd, &active, 1);
 	if (rc != 1)
 		return -EIO;
-	if ((active & (1 << fan)) == 0)
+	if ((active & (1 << id)) == 0)
 		return -ENXIO;
 
 	/* Programmed value or real current speed */
 	reg_base = programmed ? 0x10 : 0x11;
-	rc = fan_read_reg(reg_base + (fan * 2), buf, 2);
+	rc = fan_read_reg(reg_base + (id * 2), buf, 2);
 	if (rc != 2)
 		return -EIO;
 
 	return (buf[0] << 5) | buf[1] >> 3;
 }
 
-static int set_pwm_fan(int fan, int pwm)
+static int set_pwm_fan(int fan_index, int pwm)
 {
 	unsigned char buf[2];
-	int rc;
+	int rc, id;
+
+	if (fcu_fans[fan_index].type != FCU_FAN_PWM)
+		return -EINVAL;
+	id = fcu_fans[fan_index].id; 
+	if (id == FCU_FAN_ABSENT_ID)
+		return -EINVAL;
 
 	if (pwm < 10)
 		pwm = 10;
@@ -387,32 +500,38 @@ static int set_pwm_fan(int fan, int pwm)
 		pwm = 100;
 	pwm = (pwm * 2559) / 1000;
 	buf[0] = pwm;
-	rc = fan_write_reg(0x30 + (fan * 2), buf, 1);
+	rc = fan_write_reg(0x30 + (id * 2), buf, 1);
 	if (rc < 0)
 		return rc;
 	return 0;
 }
 
-static int get_pwm_fan(int fan)
+static int get_pwm_fan(int fan_index)
 {
 	unsigned char failure;
 	unsigned char active;
 	unsigned char buf[2];
-	int rc;
+	int rc, id;
+
+	if (fcu_fans[fan_index].type != FCU_FAN_PWM)
+		return -EINVAL;
+	id = fcu_fans[fan_index].id; 
+	if (id == FCU_FAN_ABSENT_ID)
+		return -EINVAL;
 
 	rc = fan_read_reg(0x2b, &failure, 1);
 	if (rc != 1)
 		return -EIO;
-	if ((failure & (1 << fan)) != 0)
+	if ((failure & (1 << id)) != 0)
 		return -EFAULT;
 	rc = fan_read_reg(0x2d, &active, 1);
 	if (rc != 1)
 		return -EIO;
-	if ((active & (1 << fan)) == 0)
+	if ((active & (1 << id)) == 0)
 		return -ENXIO;
 
 	/* Programmed value or real current speed */
-	rc = fan_read_reg(0x30 + (fan * 2), buf, 1);
+	rc = fan_read_reg(0x30 + (id * 2), buf, 1);
 	if (rc != 1)
 		return -EIO;
 
@@ -514,80 +633,84 @@ static DEVICE_ATTR(drives_fan_rpm,S_IRUGO,show_drives_fan_rpm,NULL);
 /*
  * CPUs fans control loop
  */
-static void do_monitor_cpu(struct cpu_pid_state *state)
+
+static int do_read_one_cpu_values(struct cpu_pid_state *state, s32 *temp, s32 *power)
 {
-	s32 temp, voltage, current_a, power, power_target;
-	s32 integral, derivative, proportional, adj_in_target, sval;
-	s64 integ_p, deriv_p, prop_p, sum; 
-	int i, intake, rc;
+	s32 ltemp, volts, amps;
+	int rc = 0;
 
-	DBG("cpu %d:\n", state->index);
+	/* Default (in case of error) */
+	*temp = state->cur_temp;
+	*power = state->cur_power;
 
 	/* Read current fan status */
 	if (state->index == 0)
-		rc = get_rpm_fan(CPUA_EXHAUST_FAN_RPM_ID, !RPM_PID_USE_ACTUAL_SPEED);
+		rc = get_rpm_fan(CPUA_EXHAUST_FAN_RPM_INDEX, !RPM_PID_USE_ACTUAL_SPEED);
 	else
-		rc = get_rpm_fan(CPUB_EXHAUST_FAN_RPM_ID, !RPM_PID_USE_ACTUAL_SPEED);
+		rc = get_rpm_fan(CPUB_EXHAUST_FAN_RPM_INDEX, !RPM_PID_USE_ACTUAL_SPEED);
 	if (rc < 0) {
-		printk(KERN_WARNING "Error %d reading CPU %d exhaust fan !\n",
-		       rc, state->index);
-		/* XXX What do we do now ? */
-	} else
+		/* XXX What do we do now ? Nothing for now, keep old value, but
+		 * return error upstream
+		 */
+		DBG("  cpu %d, fan reading error !\n", state->index);
+	} else {
 		state->rpm = rc;
-	DBG("  current rpm: %d\n", state->rpm);
+		DBG("  cpu %d, exhaust RPM: %d\n", state->index, state->rpm);
+	}
 
 	/* Get some sensor readings and scale it */
-	temp = read_smon_adc(state, 1);
-	if (temp == -1) {
+	ltemp = read_smon_adc(state, 1);
+	if (ltemp == -1) {
+		/* XXX What do we do now ? */
 		state->overtemp++;
-		return;
+		if (rc == 0)
+			rc = -EIO;
+		DBG("  cpu %d, temp reading error !\n", state->index);
+	} else {
+		/* Fixup temperature according to diode calibration
+		 */
+		DBG("  cpu %d, temp raw: %04x, m_diode: %04x, b_diode: %04x\n",
+		    state->index,
+		    ltemp, state->mpu.mdiode, state->mpu.bdiode);
+		*temp = ((s32)ltemp * (s32)state->mpu.mdiode + ((s32)state->mpu.bdiode << 12)) >> 2;
+		state->last_temp = *temp;
+		DBG("  temp: %d.%03d\n", FIX32TOPRINT((*temp)));
 	}
-	voltage = read_smon_adc(state, 3);
-	current_a = read_smon_adc(state, 4);
 
-	/* Fixup temperature according to diode calibration
+	/*
+	 * Read voltage & current and calculate power
 	 */
-	DBG("  temp raw: %04x, m_diode: %04x, b_diode: %04x\n",
-	    temp, state->mpu.mdiode, state->mpu.bdiode);
-	temp = ((s32)temp * (s32)state->mpu.mdiode + ((s32)state->mpu.bdiode << 12)) >> 2;
-	state->last_temp = temp;
-	DBG("  temp: %d.%03d\n", FIX32TOPRINT(temp));
+	volts = read_smon_adc(state, 3);
+	amps = read_smon_adc(state, 4);
 
-	/* Check tmax, increment overtemp if we are there. At tmax+8, we go
-	 * full blown immediately and try to trigger a shutdown
-	 */
-	if (temp >= ((state->mpu.tmax + 8) << 16)) {
-		printk(KERN_WARNING "Warning ! CPU %d temperature way above maximum"
-		       " (%d) !\n",
-		       state->index, temp >> 16);
-		state->overtemp = CPU_MAX_OVERTEMP;
-	} else if (temp > (state->mpu.tmax << 16))
-		state->overtemp++;
-	else
-		state->overtemp = 0;
-	if (state->overtemp >= CPU_MAX_OVERTEMP)
-		critical_state = 1;
-	if (state->overtemp > 0) {
-		state->rpm = state->mpu.rmaxn_exhaust_fan;
-		state->intake_rpm = intake = state->mpu.rmaxn_intake_fan;
-		goto do_set_fans;
-	}
-	
-	/* Scale other sensor values according to fixed scales
+	/* Scale voltage and current raw sensor values according to fixed scales
 	 * obtained in Darwin and calculate power from I and V
 	 */
-	state->voltage = voltage *= ADC_CPU_VOLTAGE_SCALE;
-	state->current_a = current_a *= ADC_CPU_CURRENT_SCALE;
-	power = (((u64)current_a) * ((u64)voltage)) >> 16;
+	volts *= ADC_CPU_VOLTAGE_SCALE;
+	amps *= ADC_CPU_CURRENT_SCALE;
+	*power = (((u64)volts) * ((u64)amps)) >> 16;
+	state->voltage = volts;
+	state->current_a = amps;
+	state->last_power = *power;
+
+	DBG("  cpu %d, current: %d.%03d, voltage: %d.%03d, power: %d.%03d W\n",
+	    state->index, FIX32TOPRINT(state->current_a),
+	    FIX32TOPRINT(state->voltage), FIX32TOPRINT(*power));
+
+	return 0;
+}
+
+static void do_cpu_pid(struct cpu_pid_state *state, s32 temp, s32 power)
+{
+	s32 power_target, integral, derivative, proportional, adj_in_target, sval;
+	s64 integ_p, deriv_p, prop_p, sum; 
+	int i;
 
 	/* Calculate power target value (could be done once for all)
 	 * and convert to a 16.16 fp number
 	 */
 	power_target = ((u32)(state->mpu.pmaxh - state->mpu.padjmax)) << 16;
-
-	DBG("  current: %d.%03d, voltage: %d.%03d\n",
-	    FIX32TOPRINT(current_a), FIX32TOPRINT(voltage));
-	DBG("  power: %d.%03d W, target: %d.%03d, error: %d.%03d\n", FIX32TOPRINT(power),
+	DBG("  power target: %d.%03d, error: %d.%03d\n",
 	    FIX32TOPRINT(power_target), FIX32TOPRINT(power_target - power));
 
 	/* Store temperature and power in history array */
@@ -627,7 +750,7 @@ static void do_monitor_cpu(struct cpu_pid_state *state)
 	 * input target is mpu.ttarget, input max is mpu.tmax
 	 */
 	integ_p = ((s64)state->mpu.pid_gr) * (s64)integral;
-	DBG("   integ_p: %d\n", (int)(deriv_p >> 36));
+	DBG("   integ_p: %d\n", (int)(integ_p >> 36));
 	sval = (state->mpu.tmax << 16) - ((integ_p >> 20) & 0xffffffff);
 	adj_in_target = (state->mpu.ttarget << 16);
 	if (adj_in_target > sval)
@@ -656,15 +779,136 @@ static void do_monitor_cpu(struct cpu_pid_state *state)
 	DBG("   sum: %d\n", (int)sum);
 	state->rpm += (s32)sum;
 
-	if (state->rpm < state->mpu.rminn_exhaust_fan)
+	if (state->rpm < (int)state->mpu.rminn_exhaust_fan)
 		state->rpm = state->mpu.rminn_exhaust_fan;
-	if (state->rpm > state->mpu.rmaxn_exhaust_fan)
+	if (state->rpm > (int)state->mpu.rmaxn_exhaust_fan)
+		state->rpm = state->mpu.rmaxn_exhaust_fan;
+}
+
+static void do_monitor_cpu_combined(void)
+{
+	struct cpu_pid_state *state0 = &cpu_state[0];
+	struct cpu_pid_state *state1 = &cpu_state[1];
+	s32 temp0, power0, temp1, power1;
+	s32 temp_combi, power_combi;
+	int rc, intake, pump;
+
+	rc = do_read_one_cpu_values(state0, &temp0, &power0);
+	if (rc < 0) {
+		/* XXX What do we do now ? */
+	}
+	state1->overtemp = 0;
+	rc = do_read_one_cpu_values(state1, &temp1, &power1);
+	if (rc < 0) {
+		/* XXX What do we do now ? */
+	}
+	if (state1->overtemp)
+		state0->overtemp++;
+
+	temp_combi = max(temp0, temp1);
+	power_combi = max(power0, power1);
+
+	/* Check tmax, increment overtemp if we are there. At tmax+8, we go
+	 * full blown immediately and try to trigger a shutdown
+	 */
+	if (temp_combi >= ((state0->mpu.tmax + 8) << 16)) {
+		printk(KERN_WARNING "Warning ! Temperature way above maximum (%d) !\n",
+		       temp_combi >> 16);
+		state0->overtemp = CPU_MAX_OVERTEMP;
+	} else if (temp_combi > (state0->mpu.tmax << 16))
+		state0->overtemp++;
+	else
+		state0->overtemp = 0;
+	if (state0->overtemp >= CPU_MAX_OVERTEMP)
+		critical_state = 1;
+	if (state0->overtemp > 0) {
+		state0->rpm = state0->mpu.rmaxn_exhaust_fan;
+		state0->intake_rpm = intake = state0->mpu.rmaxn_intake_fan;
+		pump = CPU_PUMP_OUTPUT_MAX;
+		goto do_set_fans;
+	}
+
+	/* Do the PID */
+	do_cpu_pid(state0, temp_combi, power_combi);
+
+	/* Calculate intake fan speed */
+	intake = (state0->rpm * CPU_INTAKE_SCALE) >> 16;
+	if (intake < (int)state0->mpu.rminn_intake_fan)
+		intake = state0->mpu.rminn_intake_fan;
+	if (intake > (int)state0->mpu.rmaxn_intake_fan)
+		intake = state0->mpu.rmaxn_intake_fan;
+	state0->intake_rpm = intake;
+
+	/* Calculate pump speed */
+	pump = (state0->rpm * CPU_PUMP_OUTPUT_MAX) /
+		state0->mpu.rmaxn_exhaust_fan;
+	if (pump > CPU_PUMP_OUTPUT_MAX)
+		pump = CPU_PUMP_OUTPUT_MAX;
+	if (pump < CPU_PUMP_OUTPUT_MIN)
+		pump = CPU_PUMP_OUTPUT_MIN;
+	
+ do_set_fans:
+	/* We copy values from state 0 to state 1 for /sysfs */
+	state1->rpm = state0->rpm;
+	state1->intake_rpm = state0->intake_rpm;
+
+	DBG("** CPU %d RPM: %d Ex, %d, Pump: %d, In, overtemp: %d\n",
+	    state1->index, (int)state1->rpm, intake, pump, state1->overtemp);
+
+	/* We should check for errors, shouldn't we ? But then, what
+	 * do we do once the error occurs ? For FCU notified fan
+	 * failures (-EFAULT) we probably want to notify userland
+	 * some way...
+	 */
+	set_rpm_fan(CPUA_INTAKE_FAN_RPM_INDEX, intake);
+	set_rpm_fan(CPUA_EXHAUST_FAN_RPM_INDEX, state0->rpm);
+	set_rpm_fan(CPUB_INTAKE_FAN_RPM_INDEX, intake);
+	set_rpm_fan(CPUB_EXHAUST_FAN_RPM_INDEX, state0->rpm);
+
+	if (fcu_fans[CPUA_PUMP_RPM_INDEX].id != FCU_FAN_ABSENT_ID)
+		set_rpm_fan(CPUA_PUMP_RPM_INDEX, pump);
+	if (fcu_fans[CPUB_PUMP_RPM_INDEX].id != FCU_FAN_ABSENT_ID)
+		set_rpm_fan(CPUB_PUMP_RPM_INDEX, pump);
+}
+
+static void do_monitor_cpu_split(struct cpu_pid_state *state)
+{
+	s32 temp, power;
+	int rc, intake;
+
+	/* Read current fan status */
+	rc = do_read_one_cpu_values(state, &temp, &power);
+	if (rc < 0) {
+		/* XXX What do we do now ? */
+	}
+
+	/* Check tmax, increment overtemp if we are there. At tmax+8, we go
+	 * full blown immediately and try to trigger a shutdown
+	 */
+	if (temp >= ((state->mpu.tmax + 8) << 16)) {
+		printk(KERN_WARNING "Warning ! CPU %d temperature way above maximum"
+		       " (%d) !\n",
+		       state->index, temp >> 16);
+		state->overtemp = CPU_MAX_OVERTEMP;
+	} else if (temp > (state->mpu.tmax << 16))
+		state->overtemp++;
+	else
+		state->overtemp = 0;
+	if (state->overtemp >= CPU_MAX_OVERTEMP)
+		critical_state = 1;
+	if (state->overtemp > 0) {
 		state->rpm = state->mpu.rmaxn_exhaust_fan;
+		state->intake_rpm = intake = state->mpu.rmaxn_intake_fan;
+		goto do_set_fans;
+	}
+
+	/* Do the PID */
+	do_cpu_pid(state, temp, power);
 
 	intake = (state->rpm * CPU_INTAKE_SCALE) >> 16;
-	if (intake < state->mpu.rminn_intake_fan)
+	if (intake < (int)state->mpu.rminn_intake_fan)
 		intake = state->mpu.rminn_intake_fan;
-	if (intake > state->mpu.rmaxn_intake_fan)
+	if (intake > (int)state->mpu.rmaxn_intake_fan)
 		intake = state->mpu.rmaxn_intake_fan;
 	state->intake_rpm = intake;
 
@@ -678,11 +922,11 @@ static void do_monitor_cpu(struct cpu_pid_state *state)
 	 * some way...
 	 */
 	if (state->index == 0) {
-		set_rpm_fan(CPUA_INTAKE_FAN_RPM_ID, intake);
-		set_rpm_fan(CPUA_EXHAUST_FAN_RPM_ID, state->rpm);
+		set_rpm_fan(CPUA_INTAKE_FAN_RPM_INDEX, intake);
+		set_rpm_fan(CPUA_EXHAUST_FAN_RPM_INDEX, state->rpm);
 	} else {
-		set_rpm_fan(CPUB_INTAKE_FAN_RPM_ID, intake);
-		set_rpm_fan(CPUB_EXHAUST_FAN_RPM_ID, state->rpm);
+		set_rpm_fan(CPUB_INTAKE_FAN_RPM_INDEX, intake);
+		set_rpm_fan(CPUB_EXHAUST_FAN_RPM_INDEX, state->rpm);
 	}
 }
 
@@ -697,6 +941,7 @@ static int init_cpu_state(struct cpu_pid_state *state, int index)
 	state->overtemp = 0;
 	state->adc_config = 0x00;
 
+
 	if (index == 0)
 		state->monitor = attach_i2c_chip(SUPPLY_MONITOR_ID, "CPU0_monitor");
 	else if (index == 1)
@@ -779,7 +1024,7 @@ static void do_monitor_backside(struct backside_pid_state *state)
 	DBG("backside:\n");
 
 	/* Check fan status */
-	rc = get_pwm_fan(BACKSIDE_FAN_PWM_ID);
+	rc = get_pwm_fan(BACKSIDE_FAN_PWM_INDEX);
 	if (rc < 0) {
 		printk(KERN_WARNING "Error %d reading backside fan !\n", rc);
 		/* XXX What do we do now ? */
@@ -791,12 +1036,12 @@ static void do_monitor_backside(struct backside_pid_state *state)
 	temp = i2c_smbus_read_byte_data(state->monitor, MAX6690_EXT_TEMP) << 16;
 	state->last_temp = temp;
 	DBG("  temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp),
-	    FIX32TOPRINT(BACKSIDE_PID_INPUT_TARGET));
+	    FIX32TOPRINT(backside_params.input_target));
 
 	/* Store temperature and error in history array */
 	state->cur_sample = (state->cur_sample + 1) % BACKSIDE_PID_HISTORY_SIZE;
 	state->sample_history[state->cur_sample] = temp;
-	state->error_history[state->cur_sample] = temp - BACKSIDE_PID_INPUT_TARGET;
+	state->error_history[state->cur_sample] = temp - backside_params.input_target;
 	
 	/* If first loop, fill the history table */
 	if (state->first) {
@@ -805,7 +1050,7 @@ static void do_monitor_backside(struct backside_pid_state *state)
 				BACKSIDE_PID_HISTORY_SIZE;
 			state->sample_history[state->cur_sample] = temp;
 			state->error_history[state->cur_sample] =
-				temp - BACKSIDE_PID_INPUT_TARGET;
+				temp - backside_params.input_target;
 		}
 		state->first = 0;
 	}
@@ -817,7 +1062,7 @@ static void do_monitor_backside(struct backside_pid_state *state)
 		integral += state->error_history[i];
 	integral *= BACKSIDE_PID_INTERVAL;
 	DBG("  integral: %08x\n", integral);
-	integ_p = ((s64)BACKSIDE_PID_G_r) * (s64)integral;
+	integ_p = ((s64)backside_params.G_r) * (s64)integral;
 	DBG("   integ_p: %d\n", (int)(integ_p >> 36));
 	sum += integ_p;
 
@@ -826,12 +1071,12 @@ static void do_monitor_backside(struct backside_pid_state *state)
 		state->error_history[(state->cur_sample + BACKSIDE_PID_HISTORY_SIZE - 1)
 				    % BACKSIDE_PID_HISTORY_SIZE];
 	derivative /= BACKSIDE_PID_INTERVAL;
-	deriv_p = ((s64)BACKSIDE_PID_G_d) * (s64)derivative;
+	deriv_p = ((s64)backside_params.G_d) * (s64)derivative;
 	DBG("   deriv_p: %d\n", (int)(deriv_p >> 36));
 	sum += deriv_p;
 
 	/* Calculate the proportional term */
-	prop_p = ((s64)BACKSIDE_PID_G_p) * (s64)(state->error_history[state->cur_sample]);
+	prop_p = ((s64)backside_params.G_p) * (s64)(state->error_history[state->cur_sample]);
 	DBG("   prop_p: %d\n", (int)(prop_p >> 36));
 	sum += prop_p;
 
@@ -840,13 +1085,13 @@ static void do_monitor_backside(struct backside_pid_state *state)
 
 	DBG("   sum: %d\n", (int)sum);
 	state->pwm += (s32)sum;
-	if (state->pwm < BACKSIDE_PID_OUTPUT_MIN)
-		state->pwm = BACKSIDE_PID_OUTPUT_MIN;
-	if (state->pwm > BACKSIDE_PID_OUTPUT_MAX)
-		state->pwm = BACKSIDE_PID_OUTPUT_MAX;
+	if (state->pwm < backside_params.output_min)
+		state->pwm = backside_params.output_min;
+	if (state->pwm > backside_params.output_max)
+		state->pwm = backside_params.output_max;
 
 	DBG("** BACKSIDE PWM: %d\n", (int)state->pwm);
-	set_pwm_fan(BACKSIDE_FAN_PWM_ID, state->pwm);
+	set_pwm_fan(BACKSIDE_FAN_PWM_INDEX, state->pwm);
 }
 
 /*
@@ -854,6 +1099,35 @@ static void do_monitor_backside(struct backside_pid_state *state)
  */
 static int init_backside_state(struct backside_pid_state *state)
 {
+	struct device_node *u3;
+	int u3h = 1; /* conservative by default */
+
+	/*
+	 * There are different PID params for machines with U3 and machines
+	 * with U3H, pick the right ones now
+	 */
+	u3 = of_find_node_by_path("/u3@0,f8000000");
+	if (u3 != NULL) {
+		u32 *vers = (u32 *)get_property(u3, "device-rev", NULL);
+		if (vers)
+			if (((*vers) & 0x3f) < 0x34)
+				u3h = 0;
+		of_node_put(u3);
+	}
+
+	backside_params.G_p = BACKSIDE_PID_G_p;
+	backside_params.G_r = BACKSIDE_PID_G_r;
+	backside_params.output_max = BACKSIDE_PID_OUTPUT_MAX;
+	if (u3h) {
+		backside_params.G_d = BACKSIDE_PID_U3H_G_d;
+		backside_params.input_target = BACKSIDE_PID_U3H_INPUT_TARGET;
+		backside_params.output_min = BACKSIDE_PID_U3H_OUTPUT_MIN;
+	} else {
+		backside_params.G_d = BACKSIDE_PID_U3_G_d;
+		backside_params.input_target = BACKSIDE_PID_U3_INPUT_TARGET;
+		backside_params.output_min = BACKSIDE_PID_U3_OUTPUT_MIN;
+	}
+
 	state->ticks = 1;
 	state->first = 1;
 	state->pwm = 50;
@@ -899,7 +1173,7 @@ static void do_monitor_drives(struct drives_pid_state *state)
 	DBG("drives:\n");
 
 	/* Check fan status */
-	rc = get_rpm_fan(DRIVES_FAN_RPM_ID, !RPM_PID_USE_ACTUAL_SPEED);
+	rc = get_rpm_fan(DRIVES_FAN_RPM_INDEX, !RPM_PID_USE_ACTUAL_SPEED);
 	if (rc < 0) {
 		printk(KERN_WARNING "Error %d reading drives fan !\n", rc);
 		/* XXX What do we do now ? */
@@ -966,7 +1240,7 @@ static void do_monitor_drives(struct drives_pid_state *state)
 		state->rpm = DRIVES_PID_OUTPUT_MAX;
 
 	DBG("** DRIVES RPM: %d\n", (int)state->rpm);
-	set_rpm_fan(DRIVES_FAN_RPM_ID, state->rpm);
+	set_rpm_fan(DRIVES_FAN_RPM_INDEX, state->rpm);
 }
 
 /*
@@ -1033,7 +1307,7 @@ static int main_control_loop(void *x)
 	}
 
 	/* Set the PCI fan once for now */
-	set_pwm_fan(SLOTS_FAN_PWM_ID, SLOTS_FAN_DEFAULT_PWM);
+	set_pwm_fan(SLOTS_FAN_PWM_INDEX, SLOTS_FAN_DEFAULT_PWM);
 
 	/* Initialize ADCs */
 	initialize_adc(&cpu_state[0]);
@@ -1045,17 +1319,16 @@ static int main_control_loop(void *x)
 	while (state == state_attached) {
 		unsigned long elapsed, start;
 
-		if (current->flags & PF_FREEZE) {
-			printk(KERN_INFO "therm_pm72: freezing thermostat\n");
-			refrigerator(PF_FREEZE);
-		}
-
 		start = jiffies;
 
 		down(&driver_lock);
-		do_monitor_cpu(&cpu_state[0]);
-		if (cpu_state[1].monitor != NULL)
-			do_monitor_cpu(&cpu_state[1]);
+		if (cpu_pid_type == CPU_PID_TYPE_COMBINED)
+			do_monitor_cpu_combined();
+		else {
+			do_monitor_cpu_split(&cpu_state[0]);
+			if (cpu_state[1].monitor != NULL)
+				do_monitor_cpu_split(&cpu_state[1]);
+		}
 		do_monitor_backside(&backside_state);
 		do_monitor_drives(&drives_state);
 		up(&driver_lock);
@@ -1119,6 +1392,19 @@ static int create_control_loops(void)
 
 	DBG("counted %d CPUs in the device-tree\n", cpu_count);
 
+	/* Decide the type of PID algorithm to use based on the presence of
+	 * the pumps, though that may not be the best way, that is good enough
+	 * for now
+	 */
+	if (machine_is_compatible("PowerMac7,3")
+	    && (cpu_count > 1)
+	    && fcu_fans[CPUA_PUMP_RPM_INDEX].id != FCU_FAN_ABSENT_ID
+	    && fcu_fans[CPUB_PUMP_RPM_INDEX].id != FCU_FAN_ABSENT_ID) {
+		printk(KERN_INFO "Liquid cooling pumps detected, using new algorithm !\n");
+		cpu_pid_type = CPU_PID_TYPE_COMBINED;
+	} else
+		cpu_pid_type = CPU_PID_TYPE_SPLIT;
+
 	/* Create control loops for everything. If any fail, everything
 	 * fails
 	 */
@@ -1263,12 +1549,91 @@ static int therm_pm72_detach(struct i2c_adapter *adapter)
 	return 0;
 }
 
+static void fcu_lookup_fans(struct device_node *fcu_node)
+{
+	struct device_node *np = NULL;
+	int i;
+
+	/* The table is filled by default with values that are suitable
+	 * for the old machines without device-tree informations. We scan
+	 * the device-tree and override those values with whatever is
+	 * there
+	 */
+
+	DBG("Looking up FCU controls in device-tree...\n");
+
+	while ((np = of_get_next_child(fcu_node, np)) != NULL) {
+		int type = -1;
+		char *loc;
+		u32 *reg;
+
+		DBG(" control: %s, type: %s\n", np->name, np->type);
+
+		/* Detect control type */
+		if (!strcmp(np->type, "fan-rpm-control") ||
+		    !strcmp(np->type, "fan-rpm"))
+			type = FCU_FAN_RPM;
+		if (!strcmp(np->type, "fan-pwm-control") ||
+		    !strcmp(np->type, "fan-pwm"))
+			type = FCU_FAN_PWM;
+		/* Only care about fans for now */
+		if (type == -1)
+			continue;
+
+		/* Lookup for a matching location */
+		loc = (char *)get_property(np, "location", NULL);
+		reg = (u32 *)get_property(np, "reg", NULL);
+		if (loc == NULL || reg == NULL)
+			continue;
+		DBG(" matching location: %s, reg: 0x%08x\n", loc, *reg);
+
+		for (i = 0; i < FCU_FAN_COUNT; i++) {
+			int fan_id;
+
+			if (strcmp(loc, fcu_fans[i].loc))
+				continue;
+			DBG(" location match, index: %d\n", i);
+			fcu_fans[i].id = FCU_FAN_ABSENT_ID;
+			if (type != fcu_fans[i].type) {
+				printk(KERN_WARNING "therm_pm72: Fan type mismatch "
+				       "in device-tree for %s\n", np->full_name);
+				break;
+			}
+			if (type == FCU_FAN_RPM)
+				fan_id = ((*reg) - 0x10) / 2;
+			else
+				fan_id = ((*reg) - 0x30) / 2;
+			if (fan_id > 7) {
+				printk(KERN_WARNING "therm_pm72: Can't parse "
+				       "fan ID in device-tree for %s\n", np->full_name);
+				break;
+			}
+			DBG(" fan id -> %d, type -> %d\n", fan_id, type);
+			fcu_fans[i].id = fan_id;
+		}
+	}
+
+	/* Now dump the array */
+	printk(KERN_INFO "Detected fan controls:\n");
+	for (i = 0; i < FCU_FAN_COUNT; i++) {
+		if (fcu_fans[i].id == FCU_FAN_ABSENT_ID)
+			continue;
+		printk(KERN_INFO "  %d: %s fan, id %d, location: %s\n", i,
+		       fcu_fans[i].type == FCU_FAN_RPM ? "RPM" : "PWM",
+		       fcu_fans[i].id, fcu_fans[i].loc);
+	}
+}
+
 static int fcu_of_probe(struct of_device* dev, const struct of_match *match)
 {
 	int rc;
 
 	state = state_detached;
 
+	/* Lookup the fans in the device tree */
+	fcu_lookup_fans(dev->node);
+
+	/* Add the driver */
 	rc = i2c_add_driver(&therm_pm72_driver);
 	if (rc < 0)
 		return rc;
@@ -1307,15 +1672,20 @@ static int __init therm_pm72_init(void)
 {
 	struct device_node *np;
 
-	if (!machine_is_compatible("PowerMac7,2"))
+	if (!machine_is_compatible("PowerMac7,2") &&
+	    !machine_is_compatible("PowerMac7,3"))
 	    	return -ENODEV;
 
 	printk(KERN_INFO "PowerMac G5 Thermal control driver %s\n", VERSION);
 
 	np = of_find_node_by_type(NULL, "fcu");
 	if (np == NULL) {
-		printk(KERN_ERR "Can't find FCU in device-tree !\n");
-		return -ENODEV;
+		/* Some machines have strangely broken device-tree */
+		np = of_find_node_by_path("/u3@0,f8000000/i2c@f8001000/fan@15e");
+		if (np == NULL) {
+			    printk(KERN_ERR "Can't find FCU in device-tree !\n");
+			    return -ENODEV;
+		}
 	}
 	of_dev = of_platform_device_create(np, "temperature");
 	if (of_dev == NULL) {

drivers/macintosh/therm_pm72.h

@@ -119,18 +119,33 @@ static char * critical_overtemp_path = "/sbin/critical_overtemp";
 #define ADC_CPU_CURRENT_SCALE	0x1f40	/* _AD4 */
 
 /*
- * PID factors for the U3/Backside fan control loop
+ * PID factors for the U3/Backside fan control loop. We have 2 sets
+ * of values here, one set for U3 and one set for U3H
  */
-#define BACKSIDE_FAN_PWM_ID		1
-#define BACKSIDE_PID_G_d		0x02800000
+#define BACKSIDE_FAN_PWM_DEFAULT_ID	1
+#define BACKSIDE_FAN_PWM_INDEX		0
+#define BACKSIDE_PID_U3_G_d		0x02800000
+#define BACKSIDE_PID_U3H_G_d		0x01400000
 #define BACKSIDE_PID_G_p		0x00500000
 #define BACKSIDE_PID_G_r		0x00000000
-#define BACKSIDE_PID_INPUT_TARGET	0x00410000
+#define BACKSIDE_PID_U3_INPUT_TARGET	0x00410000
+#define BACKSIDE_PID_U3H_INPUT_TARGET	0x004b0000
 #define BACKSIDE_PID_INTERVAL		5
 #define BACKSIDE_PID_OUTPUT_MAX		100
-#define BACKSIDE_PID_OUTPUT_MIN		20
+#define BACKSIDE_PID_U3_OUTPUT_MIN	20
+#define BACKSIDE_PID_U3H_OUTPUT_MIN	30
 #define BACKSIDE_PID_HISTORY_SIZE	2
 
+struct basckside_pid_params
+{
+	s32			G_d;
+	s32			G_p;
+	s32			G_r;
+	s32			input_target;
+	s32			output_min;
+	s32			output_max;
+};
+
 struct backside_pid_state
 {
 	int			ticks;
@@ -146,7 +161,8 @@ struct backside_pid_state
 /*
  * PID factors for the Drive Bay fan control loop
  */
-#define DRIVES_FAN_RPM_ID      		2
+#define DRIVES_FAN_RPM_DEFAULT_ID	2
+#define DRIVES_FAN_RPM_INDEX		1
 #define DRIVES_PID_G_d			0x01e00000
 #define DRIVES_PID_G_p			0x00500000
 #define DRIVES_PID_G_r			0x00000000
@@ -168,7 +184,8 @@ struct drives_pid_state
 	int			first;
 };
 
-#define SLOTS_FAN_PWM_ID       		2
+#define SLOTS_FAN_PWM_DEFAULT_ID	2
+#define SLOTS_FAN_PWM_INDEX		2
 #define	SLOTS_FAN_DEFAULT_PWM		50 /* Do better here ! */
 
 /*
@@ -191,10 +208,15 @@ struct drives_pid_state
  * CPU B FAKE POWER	49	(I_V_inputs: 18, 19)
  */
 
-#define CPUA_INTAKE_FAN_RPM_ID		3
-#define CPUA_EXHAUST_FAN_RPM_ID		4
-#define CPUB_INTAKE_FAN_RPM_ID		5
-#define CPUB_EXHAUST_FAN_RPM_ID		6
+#define CPUA_INTAKE_FAN_RPM_DEFAULT_ID	3
+#define CPUA_EXHAUST_FAN_RPM_DEFAULT_ID	4
+#define CPUB_INTAKE_FAN_RPM_DEFAULT_ID	5
+#define CPUB_EXHAUST_FAN_RPM_DEFAULT_ID	6
+
+#define CPUA_INTAKE_FAN_RPM_INDEX	3
+#define CPUA_EXHAUST_FAN_RPM_INDEX	4
+#define CPUB_INTAKE_FAN_RPM_INDEX	5
+#define CPUB_EXHAUST_FAN_RPM_INDEX	6
 
 #define CPU_INTAKE_SCALE		0x0000f852
 #define CPU_TEMP_HISTORY_SIZE		2
@@ -202,6 +224,11 @@ struct drives_pid_state
 #define CPU_PID_INTERVAL		1
 #define CPU_MAX_OVERTEMP		30
 
+#define CPUA_PUMP_RPM_INDEX		7
+#define CPUB_PUMP_RPM_INDEX		8
+#define CPU_PUMP_OUTPUT_MAX		3700
+#define CPU_PUMP_OUTPUT_MIN		1000
+
 struct cpu_pid_state
 {
 	int			index;
@@ -219,6 +246,7 @@ struct cpu_pid_state
 	s32			voltage;
 	s32			current_a;
 	s32			last_temp;
+	s32			last_power;
 	int			first;
 	u8			adc_config;
 };

drivers/scsi/aic7xxx_old.c

@@ -924,7 +924,7 @@ struct aic7xxx_host {
   volatile long            flags;
   ahc_feature              features;         /* chip features */
   unsigned long            base;             /* card base address */
-  volatile unsigned char  *maddr;            /* memory mapped address */
+  volatile unsigned char  __iomem *maddr;            /* memory mapped address */
   unsigned long            isr_count;        /* Interrupt count */
   unsigned long            spurious_int;
   scb_data_type           *scb_data;
@@ -7967,8 +7967,8 @@ aic7xxx_register(Scsi_Host_Template *template, struct aic7xxx_host *p,
     printk(KERN_INFO "(scsi%d) BIOS %sabled, IO Port 0x%lx, IRQ %d\n",
       p->host_no, (p->flags & AHC_BIOS_ENABLED) ? "en" : "dis",
       p->base, p->irq);
-    printk(KERN_INFO "(scsi%d) IO Memory at 0x%lx, MMAP Memory at 0x%lx\n",
-      p->host_no, p->mbase, (unsigned long)p->maddr);
+    printk(KERN_INFO "(scsi%d) IO Memory at 0x%lx, MMAP Memory at %p\n",
+      p->host_no, p->mbase, p->maddr);
   }
 
 #ifdef CONFIG_PCI
@@ -9311,14 +9311,9 @@ aic7xxx_detect(Scsi_Host_Template *template)
                ((temp_p->chip != (AHC_AIC7870 | AHC_PCI)) &&
                 (temp_p->chip != (AHC_AIC7880 | AHC_PCI))) )
           {
-            unsigned long page_offset, base;
-
-            base = temp_p->mbase & PAGE_MASK;
-            page_offset = temp_p->mbase - base;
-            temp_p->maddr = ioremap_nocache(base, page_offset + 256);
+            temp_p->maddr = ioremap_nocache(temp_p->mbase, 256);
             if(temp_p->maddr)
             {
-              temp_p->maddr += page_offset;
               /*
                * We need to check the I/O with the MMAPed address.  Some machines
                * simply fail to work with MMAPed I/O and certain controllers.
@@ -9335,7 +9330,7 @@ aic7xxx_detect(Scsi_Host_Template *template)
                   PCI_FUNC(temp_p->pci_device_fn));
                 printk(KERN_INFO "aic7xxx: MMAPed I/O failed, reverting to "
                                  "Programmed I/O.\n");
-                iounmap((void *) (((unsigned long) temp_p->maddr) & PAGE_MASK));
+                iounmap(temp_p->maddr);
                 temp_p->maddr = NULL;
                 if(temp_p->base == 0)
                 {
@@ -10965,7 +10960,7 @@ aic7xxx_release(struct Scsi_Host *host)
 #ifdef MMAPIO
   if(p->maddr)
   {
-    iounmap((void *) (((unsigned long) p->maddr) & PAGE_MASK));
+    iounmap(p->maddr);
   }
 #endif /* MMAPIO */
   if(!p->pdev)

drivers/scsi/initio.c

@@ -316,7 +316,7 @@ static void tul_do_pause(unsigned amount)
 /*******************************************************************
 	Use memeory refresh time        ~ 15us * 2
 ********************************************************************/
-void tul_se2_wait()
+void tul_se2_wait(void)
 {
 #if 1
 	udelay(30);
@@ -815,7 +815,7 @@ void tul_release_scb(HCS * hcsp, SCB * scbp)
 	printk("Release SCB %lx; ", (ULONG) scbp);
 #endif
 	spin_lock_irqsave(&(hcsp->HCS_AvailLock), flags);
-	scbp->SCB_Srb = 0;
+	scbp->SCB_Srb = NULL;
 	scbp->SCB_Status = 0;
 	scbp->SCB_NxtScb = NULL;
 	if (hcsp->HCS_LastAvail != NULL) {
@@ -1231,7 +1231,7 @@ int tul_device_reset(HCS * pCurHcb, struct scsi_cmnd *pSrb,
 	pScb->SCB_Target = target;
 	pScb->SCB_Mode = 0;
 
-	pScb->SCB_Srb = 0;
+	pScb->SCB_Srb = NULL;
 	if (ResetFlags & SCSI_RESET_SYNCHRONOUS) {
 		pScb->SCB_Srb = pSrb;
 	}
@@ -2535,8 +2535,8 @@ int tul_post_scsi_rst(HCS * pCurHcb)
 	TCS *pCurTcb;
 	int i;
 
-	pCurHcb->HCS_ActScb = 0;
-	pCurHcb->HCS_ActTcs = 0;
+	pCurHcb->HCS_ActScb = NULL;
+	pCurHcb->HCS_ActTcs = NULL;
 	pCurHcb->HCS_Flags = 0;
 
 	while ((pCurScb = tul_pop_busy_scb(pCurHcb)) != NULL) {

drivers/scsi/qlogicisp.c

@@ -564,7 +564,7 @@ struct isp_queue_entry {
 };
 
 struct isp1020_hostdata {
-	u_long	memaddr;
+	void __iomem *memaddr;
 	u_char	revision;
 	struct	host_param host_param;
 	struct	dev_param dev_param[MAX_TARGETS];
@@ -714,7 +714,7 @@ int isp1020_detect(Scsi_Host_Template *tmpt)
 		continue;
 
 	fail_uninit:
-		iounmap((void *)hostdata->memaddr);
+		iounmap(hostdata->memaddr);
 		release_region(host->io_port, 0xff);
 	fail_and_unregister:
 		if (hostdata->res_cpu)
@@ -747,7 +747,7 @@ int isp1020_release(struct Scsi_Host *host)
 	isp_outw(0x0, host, PCI_INTF_CTL);
 	free_irq(host->irq, host);
 
-	iounmap((void *)hostdata->memaddr);
+	iounmap(hostdata->memaddr);
 
 	release_region(host->io_port, 0xff);
 
@@ -769,7 +769,7 @@ const char *isp1020_info(struct Scsi_Host *host)
 		"QLogic ISP1020 SCSI on PCI bus %02x device %02x irq %d %s base 0x%lx",
 		hostdata->pci_dev->bus->number, hostdata->pci_dev->devfn, host->irq,
 		(hostdata->memaddr ? "MEM" : "I/O"),
-		(hostdata->memaddr ? hostdata->memaddr : host->io_port));
+		(hostdata->memaddr ? (unsigned long)hostdata->memaddr : host->io_port));
 
 	LEAVE("isp1020_info");
 
@@ -1410,18 +1410,17 @@ static int isp1020_init(struct Scsi_Host *sh)
 
  	if ((command & PCI_COMMAND_MEMORY) &&
  	    ((mem_flags & 1) == 0)) {
- 		mem_base = (u_long) ioremap(mem_base, PAGE_SIZE);
-		if (!mem_base) {
+ 		hostdata->memaddr = ioremap(mem_base, PAGE_SIZE);
+		if (!hostdata->memaddr) {
  			printk("qlogicisp : i/o remapping failed.\n");
 			goto out_release;
 		}
- 		hostdata->memaddr = mem_base;
  	} else {
 		if (command & PCI_COMMAND_IO && (io_flags & 3) != 1) {
 			printk("qlogicisp : i/o mapping is disabled\n");
 			goto out_release;
  		}
- 		hostdata->memaddr = 0; /* zero to signify no i/o mapping */
+ 		hostdata->memaddr = NULL; /* zero to signify no i/o mapping */
  		mem_base = 0;
 	}
 
@@ -1470,7 +1469,7 @@ static int isp1020_init(struct Scsi_Host *sh)
 	return 0;
 
 out_unmap:
-	iounmap((void *)hostdata->memaddr);
+	iounmap(hostdata->memaddr);
 out_release:
 	release_region(sh->io_port, 0xff);
 	return 1;

drivers/video/aty/aty128fb.c

@@ -397,7 +397,7 @@ struct aty128fb_par {
 	struct aty128_ddafifo fifo_reg;
 	u32 accel_flags;
 	struct aty128_constants constants;  /* PLL and others      */
-	void *regbase;                      /* remapped mmio       */
+	void __iomem *regbase;              /* remapped mmio       */
 	u32 vram_size;                      /* onboard video ram   */
 	int chip_gen;
 	const struct aty128_meminfo *mem;   /* onboard mem info    */
@@ -450,9 +450,9 @@ static int aty128_decode_var(struct fb_var_screeninfo *var,
                              struct aty128fb_par *par);
 #if 0
 static void __init aty128_get_pllinfo(struct aty128fb_par *par,
-				      void *bios);
-static void __init *aty128_map_ROM(struct pci_dev *pdev, const struct aty128fb_par *par);
-static void __init aty128_unmap_ROM(struct pci_dev *dev, void * rom);
+				      void __iomem *bios);
+static void __init __iomem *aty128_map_ROM(struct pci_dev *pdev, const struct aty128fb_par *par);
+static void __init aty128_unmap_ROM(struct pci_dev *dev, void __iomem * rom);
 #endif
 static void aty128_timings(struct aty128fb_par *par);
 static void aty128_init_engine(struct aty128fb_par *par);
@@ -788,7 +788,7 @@ static u32 depth_to_dst(u32 depth)
 
 
 #ifndef __sparc__
-static void __init aty128_unmap_ROM(struct pci_dev *dev, void * rom)
+static void __init aty128_unmap_ROM(struct pci_dev *dev, void __iomem * rom)
 {
 	struct resource *r = &dev->resource[PCI_ROM_RESOURCE];
 	
@@ -806,12 +806,12 @@ static void __init aty128_unmap_ROM(struct pci_dev *dev, void * rom)
 }
 
 
-static void * __init aty128_map_ROM(const struct aty128fb_par *par, struct pci_dev *dev)
+static void __iomem * __init aty128_map_ROM(const struct aty128fb_par *par, struct pci_dev *dev)
 {
 	struct resource *r;
 	u16 dptr;
 	u8 rom_type;
-	void *bios;
+	void __iomem *bios;
 
     	/* Fix from ATI for problem with Rage128 hardware not leaving ROM enabled */
     	unsigned int temp;
@@ -903,7 +903,7 @@ static void * __init aty128_map_ROM(const struct aty128fb_par *par, struct pci_d
 	return NULL;
 }
 
-static void __init aty128_get_pllinfo(struct aty128fb_par *par, unsigned char *bios)
+static void __init aty128_get_pllinfo(struct aty128fb_par *par, unsigned char __iomem *bios)
 {
 	unsigned int bios_hdr;
 	unsigned int bios_pll;
@@ -925,7 +925,7 @@ static void __init aty128_get_pllinfo(struct aty128fb_par *par, unsigned char *b
 }           
 
 #ifdef CONFIG_X86
-static void *  __devinit aty128_find_mem_vbios(struct aty128fb_par *par)
+static void __iomem *  __devinit aty128_find_mem_vbios(struct aty128fb_par *par)
 {
 	/* I simplified this code as we used to miss the signatures in
 	 * a lot of case. It's now closer to XFree, we just don't check
@@ -933,10 +933,10 @@ static void *  __devinit aty128_find_mem_vbios(struct aty128fb_par *par)
 	 * if we end up having conflicts
 	 */
         u32  segstart;
-        unsigned char *rom_base = NULL;
+        unsigned char __iomem *rom_base = NULL;
                                                 
         for (segstart=0x000c0000; segstart<0x000f0000; segstart+=0x00001000) {
-                rom_base = (char *)ioremap(segstart, 0x10000);
+                rom_base = ioremap(segstart, 0x10000);
 		if (rom_base == NULL)
 			return NULL;
                 if ((*rom_base == 0x55) && (((*(rom_base + 1)) & 0xff) == 0xaa))
@@ -1885,7 +1885,7 @@ static int __init aty128_probe(struct pci_dev *pdev, const struct pci_device_id
 	struct fb_info *info;
 	int err;
 #ifndef __sparc__
-	void *bios = NULL;
+	void __iomem *bios = NULL;
 #endif
 
 	/* Enable device in PCI config */

drivers/video/aty/atyfb.h

@@ -59,15 +59,15 @@ union aty_pll {
 struct aty_cursor {
 	u8 bits[8][64];
 	u8 mask[8][64];
-	u8 *ram;
+	u8 __iomem *ram;
 };
 
 struct atyfb_par {
-	struct aty_cmap_regs *aty_cmap_regs;
+	struct aty_cmap_regs __iomem *aty_cmap_regs;
 	const struct aty_dac_ops *dac_ops;
 	const struct aty_pll_ops *pll_ops;
 	struct aty_cursor *cursor;
-	unsigned long ati_regbase;
+	void __iomem *ati_regbase;
 	unsigned long clk_wr_offset;
 	struct crtc crtc;
 	union aty_pll pll;

drivers/video/aty/atyfb_base.c

@@ -1514,7 +1514,7 @@ static int __init aty_init(struct fb_info *info, const char *name)
 	u8 pll_ref_div;
 
 	par->aty_cmap_regs =
-	    (struct aty_cmap_regs *) (par->ati_regbase + 0xc0);
+	    (struct aty_cmap_regs __iomem *) (par->ati_regbase + 0xc0);
 	chip_id = aty_ld_le32(CONFIG_CHIP_ID, par);
 	type = chip_id & CFG_CHIP_TYPE;
 	rev = (chip_id & CFG_CHIP_REV) >> 24;
@@ -1782,8 +1782,7 @@ static int __init aty_init(struct fb_info *info, const char *name)
 		info->fix.smem_len -= GUI_RESERVE;
 
 	/* Clear the video memory */
-	fb_memset((void *) info->screen_base, 0,
-		  info->fix.smem_len);
+	fb_memset(info->screen_base, 0, info->fix.smem_len);
 
 	info->fbops = &atyfb_ops;
 	info->pseudo_palette = pseudo_palette;
@@ -2216,7 +2215,7 @@ int __init atyfb_do_init(void)
 #else				/* __sparc__ */
 
 			info->fix.mmio_start = 0x7ff000 + addr;
-			default_par->ati_regbase = (unsigned long)
+			default_par->ati_regbase = 
 			    ioremap(info->fix.mmio_start, 0x1000);
 
 			if (!default_par->ati_regbase) {
@@ -2249,8 +2248,7 @@ int __init atyfb_do_init(void)
 
 			/* Map in frame buffer */
 			info->fix.smem_start = addr;
-			info->screen_base =
-			    (char *) ioremap(addr, 0x800000);
+			info->screen_base = ioremap(addr, 0x800000);
 
 			if (!info->screen_base) {
 #ifdef __sparc__
@@ -2616,9 +2614,9 @@ void cleanup_module(void)
 
 #ifndef __sparc__
 	if (par->ati_regbase)
-		iounmap((void *) par->ati_regbase);
+		iounmap(par->ati_regbase);
 	if (info->screen_base)
-		iounmap((void *) info->screen_base);
+		iounmap(info->screen_base);
 #ifdef __BIG_ENDIAN
 	if (par->cursor && par->cursor->ram)
 		iounmap(par->cursor->ram);

drivers/video/aty/mach64_cursor.c

@@ -73,7 +73,8 @@ void aty_set_cursor_shape(struct fb_info *info)
 	struct atyfb_par *par = (struct atyfb_par *) info->par;
 	struct fb_cursor *cursor = &info->cursor;
 	struct aty_cursor *c = par->cursor;
-	u8 *ram, m, b;
+	u8 m, b;
+	u8 __iomem *ram;
 	int x, y;
 
 	if (!c)
@@ -178,7 +179,7 @@ int atyfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 struct aty_cursor *__init aty_init_cursor(struct fb_info *info)
 {
 	struct aty_cursor *cursor;
-	unsigned long addr;
+	void __iomem *addr;
 
 	cursor = kmalloc(sizeof(struct aty_cursor), GFP_ATOMIC);
 	if (!cursor)
@@ -195,8 +196,8 @@ struct aty_cursor *__init aty_init_cursor(struct fb_info *info)
 	addr = info->fix.smem_start - 0x800000 + info->fix.smem_len;
 	cursor->ram = (u8 *) ioremap(addr, 1024);
 #else
-	addr = (unsigned long) info->screen_base + info->fix.smem_len;
-	cursor->ram = (u8 *) addr;
+	addr = info->screen_base + info->fix.smem_len;
+	cursor->ram = addr;
 #endif
 #endif
 	if (!cursor->ram) {

include/asm-i386/thread_info.h

@@ -51,7 +51,7 @@ struct thread_info {
 
 #endif
 
-#define PREEMPT_ACTIVE		0x4000000
+#define PREEMPT_ACTIVE		0x10000000
 #ifdef CONFIG_4KSTACKS
 #define THREAD_SIZE            (4096)
 #else

include/asm-ppc/thread_info.h

@@ -65,7 +65,7 @@ static inline struct thread_info *current_thread_info(void)
  */
 #define THREAD_SIZE		8192	/* 2 pages */
 
-#define PREEMPT_ACTIVE		0x4000000
+#define PREEMPT_ACTIVE		0x10000000
 
 /*
  * thread information flag bit numbers

include/asm-ppc64/thread_info.h

@@ -82,7 +82,7 @@ static inline struct thread_info *current_thread_info(void)
 
 #endif /* __ASSEMBLY__ */
 
-#define PREEMPT_ACTIVE		0x4000000
+#define PREEMPT_ACTIVE		0x10000000
 
 /*
  * thread information flag bit numbers

include/asm-x86_64/thread_info.h

@@ -125,7 +125,7 @@ static inline struct thread_info *stack_thread_info(void)
 /* work to do on any return to user space */
 #define _TIF_ALLWORK_MASK 0x0000FFFF	
 
-#define PREEMPT_ACTIVE     0x4000000
+#define PREEMPT_ACTIVE     0x10000000
 
 /*
  * Thread-synchronous status.

include/linux/hardirq.h

@@ -14,7 +14,7 @@
  * - bits 8-15 are the softirq count (max # of softirqs: 256)
  * - bits 16-27 are the hardirq count (max # of hardirqs: 4096)
  *
- * - ( bit 26 is the PREEMPT_ACTIVE flag. )
+ * - ( bit 28 is the PREEMPT_ACTIVE flag. )
  *
  * PREEMPT_MASK: 0x000000ff
  * SOFTIRQ_MASK: 0x0000ff00

include/linux/interrupt.h

@@ -252,8 +252,24 @@ extern void tasklet_init(struct tasklet_struct *t,
  * or zero if none occurred, or a negative irq number
  * if more than one irq occurred.
  */
+
+#if defined(CONFIG_GENERIC_HARDIRQS) && !defined(CONFIG_GENERIC_IRQ_PROBE) 
+static inline unsigned long probe_irq_on(void)
+{
+	return 0;
+}
+static inline int probe_irq_off(unsigned long val)
+{
+	return 0;
+}
+static inline unsigned int probe_irq_mask(unsigned long val)
+{
+	return 0;
+}
+#else
 extern unsigned long probe_irq_on(void);	/* returns 0 on failure */
 extern int probe_irq_off(unsigned long);	/* returns 0 or negative on failure */
 extern unsigned int probe_irq_mask(unsigned long);	/* returns mask of ISA interrupts */
+#endif
 
 #endif

kernel/irq/Makefile

 
-obj-y := autoprobe.o handle.o manage.o spurious.o
+obj-y := handle.o manage.o spurious.o
+obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_PROC_FS) += proc.o