mce_intel_64.c 7.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * Intel specific MCE features.
 * Copyright 2004 Zwane Mwaikambo <zwane@linuxpower.ca>
A
Andi Kleen 已提交
4 5
 * Copyright (C) 2008, 2009 Intel Corporation
 * Author: Andi Kleen
L
Linus Torvalds 已提交
6 7 8 9 10 11
 */

#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/percpu.h>
#include <asm/processor.h>
I
Ingo Molnar 已提交
12
#include <asm/apic.h>
L
Linus Torvalds 已提交
13 14 15
#include <asm/msr.h>
#include <asm/mce.h>
#include <asm/hw_irq.h>
A
Andi Kleen 已提交
16
#include <asm/idle.h>
17
#include <asm/therm_throt.h>
A
Andi Kleen 已提交
18
#include <asm/apic.h>
L
Linus Torvalds 已提交
19 20 21

asmlinkage void smp_thermal_interrupt(void)
{
22
	__u64 msr_val;
L
Linus Torvalds 已提交
23 24 25

	ack_APIC_irq();

A
Andi Kleen 已提交
26
	exit_idle();
L
Linus Torvalds 已提交
27
	irq_enter();
28 29 30

	rdmsrl(MSR_IA32_THERM_STATUS, msr_val);
	if (therm_throt_process(msr_val & 1))
31
		mce_log_therm_throt_event(msr_val);
32

33
	inc_irq_stat(irq_thermal_count);
L
Linus Torvalds 已提交
34 35 36
	irq_exit();
}

37
static void intel_init_thermal(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
{
	u32 l, h;
	int tm2 = 0;
	unsigned int cpu = smp_processor_id();

	if (!cpu_has(c, X86_FEATURE_ACPI))
		return;

	if (!cpu_has(c, X86_FEATURE_ACC))
		return;

	/* first check if TM1 is already enabled by the BIOS, in which
	 * case there might be some SMM goo which handles it, so we can't even
	 * put a handler since it might be delivered via SMI already.
	 */
	rdmsr(MSR_IA32_MISC_ENABLE, l, h);
	h = apic_read(APIC_LVTTHMR);
55
	if ((l & MSR_IA32_MISC_ENABLE_TM1) && (h & APIC_DM_SMI)) {
L
Linus Torvalds 已提交
56 57 58 59 60
		printk(KERN_DEBUG
		       "CPU%d: Thermal monitoring handled by SMI\n", cpu);
		return;
	}

61
	if (cpu_has(c, X86_FEATURE_TM2) && (l & MSR_IA32_MISC_ENABLE_TM2))
L
Linus Torvalds 已提交
62 63 64 65 66 67 68 69 70 71 72
		tm2 = 1;

	if (h & APIC_VECTOR_MASK) {
		printk(KERN_DEBUG
		       "CPU%d: Thermal LVT vector (%#x) already "
		       "installed\n", cpu, (h & APIC_VECTOR_MASK));
		return;
	}

	h = THERMAL_APIC_VECTOR;
	h |= (APIC_DM_FIXED | APIC_LVT_MASKED);
73
	apic_write(APIC_LVTTHMR, h);
L
Linus Torvalds 已提交
74 75 76 77 78

	rdmsr(MSR_IA32_THERM_INTERRUPT, l, h);
	wrmsr(MSR_IA32_THERM_INTERRUPT, l | 0x03, h);

	rdmsr(MSR_IA32_MISC_ENABLE, l, h);
79
	wrmsr(MSR_IA32_MISC_ENABLE, l | MSR_IA32_MISC_ENABLE_TM1, h);
L
Linus Torvalds 已提交
80 81

	l = apic_read(APIC_LVTTHMR);
82
	apic_write(APIC_LVTTHMR, l & ~APIC_LVT_MASKED);
L
Linus Torvalds 已提交
83 84
	printk(KERN_INFO "CPU%d: Thermal monitoring enabled (%s)\n",
		cpu, tm2 ? "TM2" : "TM1");
85 86 87

	/* enable thermal throttle processing */
	atomic_set(&therm_throt_en, 1);
L
Linus Torvalds 已提交
88 89 90
	return;
}

A
Andi Kleen 已提交
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
/*
 * Support for Intel Correct Machine Check Interrupts. This allows
 * the CPU to raise an interrupt when a corrected machine check happened.
 * Normally we pick those up using a regular polling timer.
 * Also supports reliable discovery of shared banks.
 */

static DEFINE_PER_CPU(mce_banks_t, mce_banks_owned);

/*
 * cmci_discover_lock protects against parallel discovery attempts
 * which could race against each other.
 */
static DEFINE_SPINLOCK(cmci_discover_lock);

#define CMCI_THRESHOLD 1

108
static int cmci_supported(int *banks)
A
Andi Kleen 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
{
	u64 cap;

	/*
	 * Vendor check is not strictly needed, but the initial
	 * initialization is vendor keyed and this
	 * makes sure none of the backdoors are entered otherwise.
	 */
	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
		return 0;
	if (!cpu_has_apic || lapic_get_maxlvt() < 6)
		return 0;
	rdmsrl(MSR_IA32_MCG_CAP, cap);
	*banks = min_t(unsigned, MAX_NR_BANKS, cap & 0xff);
	return !!(cap & MCG_CMCI_P);
}

/*
 * The interrupt handler. This is called on every event.
 * Just call the poller directly to log any events.
 * This could in theory increase the threshold under high load,
 * but doesn't for now.
 */
static void intel_threshold_interrupt(void)
{
	machine_check_poll(MCP_TIMESTAMP, &__get_cpu_var(mce_banks_owned));
	mce_notify_user();
}

static void print_update(char *type, int *hdr, int num)
{
	if (*hdr == 0)
		printk(KERN_INFO "CPU %d MCA banks", smp_processor_id());
	*hdr = 1;
	printk(KERN_CONT " %s:%d", type, num);
}

/*
 * Enable CMCI (Corrected Machine Check Interrupt) for available MCE banks
 * on this CPU. Use the algorithm recommended in the SDM to discover shared
 * banks.
 */
151
static void cmci_discover(int banks, int boot)
A
Andi Kleen 已提交
152 153
{
	unsigned long *owned = (void *)&__get_cpu_var(mce_banks_owned);
154
	unsigned long flags;
A
Andi Kleen 已提交
155 156 157
	int hdr = 0;
	int i;

158
	spin_lock_irqsave(&cmci_discover_lock, flags);
A
Andi Kleen 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
	for (i = 0; i < banks; i++) {
		u64 val;

		if (test_bit(i, owned))
			continue;

		rdmsrl(MSR_IA32_MC0_CTL2 + i, val);

		/* Already owned by someone else? */
		if (val & CMCI_EN) {
			if (test_and_clear_bit(i, owned) || boot)
				print_update("SHD", &hdr, i);
			__clear_bit(i, __get_cpu_var(mce_poll_banks));
			continue;
		}

		val |= CMCI_EN | CMCI_THRESHOLD;
		wrmsrl(MSR_IA32_MC0_CTL2 + i, val);
		rdmsrl(MSR_IA32_MC0_CTL2 + i, val);

		/* Did the enable bit stick? -- the bank supports CMCI */
		if (val & CMCI_EN) {
			if (!test_and_set_bit(i, owned) || boot)
				print_update("CMCI", &hdr, i);
			__clear_bit(i, __get_cpu_var(mce_poll_banks));
		} else {
			WARN_ON(!test_bit(i, __get_cpu_var(mce_poll_banks)));
		}
	}
188
	spin_unlock_irqrestore(&cmci_discover_lock, flags);
A
Andi Kleen 已提交
189 190 191 192 193 194 195 196
	if (hdr)
		printk(KERN_CONT "\n");
}

/*
 * Just in case we missed an event during initialization check
 * all the CMCI owned banks.
 */
197
void cmci_recheck(void)
A
Andi Kleen 已提交
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
{
	unsigned long flags;
	int banks;

	if (!mce_available(&current_cpu_data) || !cmci_supported(&banks))
		return;
	local_irq_save(flags);
	machine_check_poll(MCP_TIMESTAMP, &__get_cpu_var(mce_banks_owned));
	local_irq_restore(flags);
}

/*
 * Disable CMCI on this CPU for all banks it owns when it goes down.
 * This allows other CPUs to claim the banks on rediscovery.
 */
213
void cmci_clear(void)
A
Andi Kleen 已提交
214
{
215
	unsigned long flags;
A
Andi Kleen 已提交
216 217 218 219 220 221
	int i;
	int banks;
	u64 val;

	if (!cmci_supported(&banks))
		return;
222
	spin_lock_irqsave(&cmci_discover_lock, flags);
A
Andi Kleen 已提交
223 224 225 226 227 228 229 230 231
	for (i = 0; i < banks; i++) {
		if (!test_bit(i, __get_cpu_var(mce_banks_owned)))
			continue;
		/* Disable CMCI */
		rdmsrl(MSR_IA32_MC0_CTL2 + i, val);
		val &= ~(CMCI_EN|CMCI_THRESHOLD_MASK);
		wrmsrl(MSR_IA32_MC0_CTL2 + i, val);
		__clear_bit(i, __get_cpu_var(mce_banks_owned));
	}
232
	spin_unlock_irqrestore(&cmci_discover_lock, flags);
A
Andi Kleen 已提交
233 234 235 236 237 238
}

/*
 * After a CPU went down cycle through all the others and rediscover
 * Must run in process context.
 */
239
void cmci_rediscover(int dying)
A
Andi Kleen 已提交
240 241 242 243 244 245 246 247 248 249 250 251 252 253
{
	int banks;
	int cpu;
	cpumask_var_t old;

	if (!cmci_supported(&banks))
		return;
	if (!alloc_cpumask_var(&old, GFP_KERNEL))
		return;
	cpumask_copy(old, &current->cpus_allowed);

	for_each_online_cpu (cpu) {
		if (cpu == dying)
			continue;
254
		if (set_cpus_allowed_ptr(current, cpumask_of(cpu)))
A
Andi Kleen 已提交
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
			continue;
		/* Recheck banks in case CPUs don't all have the same */
		if (cmci_supported(&banks))
			cmci_discover(banks, 0);
	}

	set_cpus_allowed_ptr(current, old);
	free_cpumask_var(old);
}

/*
 * Reenable CMCI on this CPU in case a CPU down failed.
 */
void cmci_reenable(void)
{
	int banks;
	if (cmci_supported(&banks))
		cmci_discover(banks, 0);
}

275
static void intel_init_cmci(void)
A
Andi Kleen 已提交
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
{
	int banks;

	if (!cmci_supported(&banks))
		return;

	mce_threshold_vector = intel_threshold_interrupt;
	cmci_discover(banks, 1);
	/*
	 * For CPU #0 this runs with still disabled APIC, but that's
	 * ok because only the vector is set up. We still do another
	 * check for the banks later for CPU #0 just to make sure
	 * to not miss any events.
	 */
	apic_write(APIC_LVTCMCI, THRESHOLD_APIC_VECTOR|APIC_DM_FIXED);
	cmci_recheck();
}

294
void mce_intel_feature_init(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
295 296
{
	intel_init_thermal(c);
A
Andi Kleen 已提交
297
	intel_init_cmci();
L
Linus Torvalds 已提交
298
}