litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Chris Wright <chrisw@sous-sol.org>	2007-07-21 11:11:33 -0400
committer	Linus Torvalds <torvalds@woody.linux-foundation.org>	2007-07-21 21:37:14 -0400
commit	43d6ca01844789b4c695175f8c205861a06a84cb (patch)
tree	2d5e1bc3d9ec1e0f8c2ffd339d4e774160ee4911
parent	f5352fd0ce41b079a01e23c01ea3578c29f097e7 (diff)

i386: hpet assumes boot cpu is 0

I fixed this in x86_64. Looks like the kind of thing that will break voyager on i386. Signed-off-by: Chris Wright <chrisw@sous-sol.org> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Ingo Molnar <mingo@elte.hu> Cc: john stultz <johnstul@us.ibm.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Andi Kleen <ak@suse.de> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Diffstat

-rw-r--r--

arch/i386/kernel/hpet.c

1 files changed, 1 insertions, 1 deletions


diff --git a/arch/i386/kernel/hpet.c b/arch/i386/kernel/hpet.c index b93310d11950..533d4932bc79 100644 --- a/arch/i386/kernel/hpet.c +++ b/arch/i386/kernel/hpet.c
@@ -326,7 +326,7 @@ int __init hpet_enable(void)
326	* Start hpet with the boot cpu mask and make it	326	* Start hpet with the boot cpu mask and make it
327	* global after the IO_APIC has been initialized.	327	* global after the IO_APIC has been initialized.
328	*/	328	*/
329	hpet_clockevent.cpumask =cpumask_of_cpu(0);	329	hpet_clockevent.cpumask = cpumask_of_cpu(smp_processor_id());
330	clockevents_register_device(&hpet_clockevent);	330	clockevents_register_device(&hpet_clockevent);
331	global_clock_event = &hpet_clockevent;	331	global_clock_event = &hpet_clockevent;
332	return 1;	332	return 1;

/* * cpuidle-powernv - idle state cpuidle driver. * Adapted from drivers/cpuidle/cpuidle-pseries * */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/init.h> #include <linux/moduleparam.h> #include <linux/cpuidle.h> #include <linux/cpu.h> #include <linux/notifier.h> #include <linux/clockchips.h> #include <linux/of.h> #include <linux/slab.h> #include <asm/machdep.h> #include <asm/firmware.h> #include <asm/opal.h> #include <asm/runlatch.h> #include <asm/cpuidle.h> /* * Expose only those Hardware idle states via the cpuidle framework * that have latency value below POWERNV_THRESHOLD_LATENCY_NS. */ #define POWERNV_THRESHOLD_LATENCY_NS 200000 static struct cpuidle_driver powernv_idle_driver = { .name = "powernv_idle", .owner = THIS_MODULE, }; static int max_idle_state; static struct cpuidle_state *cpuidle_state_table; struct stop_psscr_table { u64 val; u64 mask; }; static struct stop_psscr_table stop_psscr_table[CPUIDLE_STATE_MAX]; static u64 snooze_timeout; static bool snooze_timeout_en; static int snooze_loop(struct cpuidle_device *dev, struct cpuidle_driver *drv, int index) { u64 snooze_exit_time; local_irq_enable(); set_thread_flag(TIF_POLLING_NRFLAG); snooze_exit_time = get_tb() + snooze_timeout; ppc64_runlatch_off(); while (!need_resched()) { HMT_low(); HMT_very_low(); if (snooze_timeout_en && get_tb() > snooze_exit_time) break; } HMT_medium(); ppc64_runlatch_on(); clear_thread_flag(TIF_POLLING_NRFLAG); smp_mb(); return index; } static int nap_loop(struct cpuidle_device *dev, struct cpuidle_driver *drv, int index) { ppc64_runlatch_off(); power7_idle(); ppc64_runlatch_on(); return index; } /* Register for fastsleep only in oneshot mode of broadcast */ #ifdef CONFIG_TICK_ONESHOT static int fastsleep_loop(struct cpuidle_device *dev, struct cpuidle_driver *drv, int index) { unsigned long old_lpcr = mfspr(SPRN_LPCR); unsigned long new_lpcr; if (unlikely(system_state < SYSTEM_RUNNING)) return index; new_lpcr = old_lpcr; /* Do not exit powersave upon decrementer as we've setup the timer * offload. */ new_lpcr &= ~LPCR_PECE1; mtspr(SPRN_LPCR, new_lpcr); power7_sleep(); mtspr(SPRN_LPCR, old_lpcr); return index; } #endif static int stop_loop(struct cpuidle_device *dev, struct cpuidle_driver *drv, int index) { ppc64_runlatch_off(); power9_idle_stop(stop_psscr_table[index].val, stop_psscr_table[index].mask); ppc64_runlatch_on(); return index; } /* * States for dedicated partition case. */ static struct cpuidle_state powernv_states[CPUIDLE_STATE_MAX] = { { /* Snooze */ .name = "snooze", .desc = "snooze", .exit_latency = 0, .target_residency = 0, .enter = snooze_loop }, }; static int powernv_cpuidle_cpu_online(unsigned int cpu) { struct cpuidle_device *dev = per_cpu(cpuidle_devices, cpu); if (dev && cpuidle_get_driver()) { cpuidle_pause_and_lock(); cpuidle_enable_device(dev); cpuidle_resume_and_unlock(); } return 0; } static int powernv_cpuidle_cpu_dead(unsigned int cpu) { struct cpuidle_device *dev = per_cpu(cpuidle_devices, cpu); if (dev && cpuidle_get_driver()) { cpuidle_pause_and_lock(); cpuidle_disable_device(dev); cpuidle_resume_and_unlock(); } return 0; } /* * powernv_cpuidle_driver_init() */ static int powernv_cpuidle_driver_init(void) { int idle_state; struct cpuidle_driver *drv = &powernv_idle_driver; drv->state_count = 0; for (idle_state = 0; idle_state < max_idle_state; ++idle_state) { /* Is the state not enabled? */ if (cpuidle_state_table[idle_state].enter == NULL) continue; drv->states[drv->state_count] = /* structure copy */ cpuidle_state_table[idle_state]; drv->state_count += 1; } return 0; } static inline void add_powernv_state(int index, const char *name, unsigned int flags, int (*idle_fn)(struct cpuidle_device *, struct cpuidle_driver *, int), unsigned int target_residency, unsigned int exit_latency, u64 psscr_val, u64 psscr_mask) { strlcpy(powernv_states[index].name, name, CPUIDLE_NAME_LEN); strlcpy(powernv_states[index].desc, name, CPUIDLE_NAME_LEN); powernv_states[index].flags = flags; powernv_states[index].target_residency = target_residency; powernv_states[index].exit_latency = exit_latency; powernv_states[index].enter = idle_fn; stop_psscr_table[index].val = psscr_val; stop_psscr_table[index].mask = psscr_mask; } static int powernv_add_idle_states(void) { struct device_node *power_mgt; int nr_idle_states = 1; /* Snooze */ int dt_idle_states; u32 latency_ns[CPUIDLE_STATE_MAX]; u32 residency_ns[CPUIDLE_STATE_MAX]; u32 flags[CPUIDLE_STATE_MAX]; u64 psscr_val[CPUIDLE_STATE_MAX]; u64 psscr_mask[CPUIDLE_STATE_MAX]; const char *names[CPUIDLE_STATE_MAX]; u32 has_stop_states = 0; int i, rc; /* Currently we have snooze statically defined */ power_mgt = of_find_node_by_path("/ibm,opal/power-mgt"); if (!power_mgt) { pr_warn("opal: PowerMgmt Node not found\n"); goto out; } /* Read values of any property to determine the num of idle states */ dt_idle_states = of_property_count_u32_elems(power_mgt, "ibm,cpu-idle-state-flags"); if (dt_idle_states < 0) { pr_warn("cpuidle-powernv: no idle states found in the DT\n"); goto out; } /* * Since snooze is used as first idle state, max idle states allowed is * CPUIDLE_STATE_MAX -1 */ if (dt_idle_states > CPUIDLE_STATE_MAX - 1) { pr_warn("cpuidle-powernv: discovered idle states more than allowed"); dt_idle_states = CPUIDLE_STATE_MAX - 1; } if (of_property_read_u32_array(power_mgt, "ibm,cpu-idle-state-flags", flags, dt_idle_states)) { pr_warn("cpuidle-powernv : missing ibm,cpu-idle-state-flags in DT\n"); goto out; } if (of_property_read_u32_array(power_mgt, "ibm,cpu-idle-state-latencies-ns", latency_ns, dt_idle_states)) { pr_warn("cpuidle-powernv: missing ibm,cpu-idle-state-latencies-ns in DT\n"); goto out; } if (of_property_read_string_array(power_mgt, "ibm,cpu-idle-state-names", names, dt_idle_states) < 0) { pr_warn("cpuidle-powernv: missing ibm,cpu-idle-state-names in DT\n"); goto out; } /* * If the idle states use stop instruction, probe for psscr values * and psscr mask which are necessary to specify required stop level. */


context:
space:
mode: