amd.c 14.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
#include <linux/init.h>
#include <linux/bitops.h>
#include <linux/mm.h>
Y
Yinghai Lu 已提交
4

A
Alan Cox 已提交
5
#include <linux/io.h>
L
Linus Torvalds 已提交
6
#include <asm/processor.h>
7
#include <asm/apic.h>
8
#include <asm/cpu.h>
9
#include <asm/pci-direct.h>
L
Linus Torvalds 已提交
10

Y
Yinghai Lu 已提交
11 12 13 14 15 16
#ifdef CONFIG_X86_64
# include <asm/numa_64.h>
# include <asm/mmconfig.h>
# include <asm/cacheflush.h>
#endif

L
Linus Torvalds 已提交
17 18
#include "cpu.h"

19
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31
/*
 *	B step AMD K6 before B 9730xxxx have hardware bugs that can cause
 *	misexecution of code under Linux. Owners of such processors should
 *	contact AMD for precise details and a CPU swap.
 *
 *	See	http://www.multimania.com/poulot/k6bug.html
 *		http://www.amd.com/K6/k6docs/revgd.html
 *
 *	The following test is erm.. interesting. AMD neglected to up
 *	the chip setting when fixing the bug but they also tweaked some
 *	performance at the same time..
 */
32

L
Linus Torvalds 已提交
33 34 35
extern void vide(void);
__asm__(".align 4\nvide: ret");

36 37 38 39 40 41 42 43 44 45 46 47
static void __cpuinit init_amd_k5(struct cpuinfo_x86 *c)
{
/*
 * General Systems BIOSen alias the cpu frequency registers
 * of the Elan at 0x000df000. Unfortuantly, one of the Linux
 * drivers subsequently pokes it, and changes the CPU speed.
 * Workaround : Remove the unneeded alias.
 */
#define CBAR		(0xfffc) /* Configuration Base Address  (32-bit) */
#define CBAR_ENB	(0x80000000)
#define CBAR_KEY	(0X000000CB)
	if (c->x86_model == 9 || c->x86_model == 10) {
A
Alan Cox 已提交
48 49
		if (inl(CBAR) & CBAR_ENB)
			outl(0 | CBAR_KEY, CBAR);
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
	}
}


static void __cpuinit init_amd_k6(struct cpuinfo_x86 *c)
{
	u32 l, h;
	int mbytes = num_physpages >> (20-PAGE_SHIFT);

	if (c->x86_model < 6) {
		/* Based on AMD doc 20734R - June 2000 */
		if (c->x86_model == 0) {
			clear_cpu_cap(c, X86_FEATURE_APIC);
			set_cpu_cap(c, X86_FEATURE_PGE);
		}
		return;
	}

	if (c->x86_model == 6 && c->x86_mask == 1) {
		const int K6_BUG_LOOP = 1000000;
		int n;
		void (*f_vide)(void);
		unsigned long d, d2;

		printk(KERN_INFO "AMD K6 stepping B detected - ");

		/*
		 * It looks like AMD fixed the 2.6.2 bug and improved indirect
		 * calls at the same time.
		 */

		n = K6_BUG_LOOP;
		f_vide = vide;
		rdtscl(d);
		while (n--)
			f_vide();
		rdtscl(d2);
		d = d2-d;

		if (d > 20*K6_BUG_LOOP)
A
Alan Cox 已提交
90 91
			printk(KERN_CONT
				"system stability may be impaired when more than 32 MB are used.\n");
92
		else
A
Alan Cox 已提交
93
			printk(KERN_CONT "probably OK (after B9730xxxx).\n");
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 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
		printk(KERN_INFO "Please see http://membres.lycos.fr/poulot/k6bug.html\n");
	}

	/* K6 with old style WHCR */
	if (c->x86_model < 8 ||
	   (c->x86_model == 8 && c->x86_mask < 8)) {
		/* We can only write allocate on the low 508Mb */
		if (mbytes > 508)
			mbytes = 508;

		rdmsr(MSR_K6_WHCR, l, h);
		if ((l&0x0000FFFF) == 0) {
			unsigned long flags;
			l = (1<<0)|((mbytes/4)<<1);
			local_irq_save(flags);
			wbinvd();
			wrmsr(MSR_K6_WHCR, l, h);
			local_irq_restore(flags);
			printk(KERN_INFO "Enabling old style K6 write allocation for %d Mb\n",
				mbytes);
		}
		return;
	}

	if ((c->x86_model == 8 && c->x86_mask > 7) ||
	     c->x86_model == 9 || c->x86_model == 13) {
		/* The more serious chips .. */

		if (mbytes > 4092)
			mbytes = 4092;

		rdmsr(MSR_K6_WHCR, l, h);
		if ((l&0xFFFF0000) == 0) {
			unsigned long flags;
			l = ((mbytes>>2)<<22)|(1<<16);
			local_irq_save(flags);
			wbinvd();
			wrmsr(MSR_K6_WHCR, l, h);
			local_irq_restore(flags);
			printk(KERN_INFO "Enabling new style K6 write allocation for %d Mb\n",
				mbytes);
		}

		return;
	}

	if (c->x86_model == 10) {
		/* AMD Geode LX is model 10 */
		/* placeholder for any needed mods */
		return;
	}
}

147 148 149 150 151 152 153 154 155 156 157 158 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
static void __cpuinit amd_k7_smp_check(struct cpuinfo_x86 *c)
{
#ifdef CONFIG_SMP
	/* calling is from identify_secondary_cpu() ? */
	if (c->cpu_index == boot_cpu_id)
		return;

	/*
	 * Certain Athlons might work (for various values of 'work') in SMP
	 * but they are not certified as MP capable.
	 */
	/* Athlon 660/661 is valid. */
	if ((c->x86_model == 6) && ((c->x86_mask == 0) ||
	    (c->x86_mask == 1)))
		goto valid_k7;

	/* Duron 670 is valid */
	if ((c->x86_model == 7) && (c->x86_mask == 0))
		goto valid_k7;

	/*
	 * Athlon 662, Duron 671, and Athlon >model 7 have capability
	 * bit. It's worth noting that the A5 stepping (662) of some
	 * Athlon XP's have the MP bit set.
	 * See http://www.heise.de/newsticker/data/jow-18.10.01-000 for
	 * more.
	 */
	if (((c->x86_model == 6) && (c->x86_mask >= 2)) ||
	    ((c->x86_model == 7) && (c->x86_mask >= 1)) ||
	     (c->x86_model > 7))
		if (cpu_has_mp)
			goto valid_k7;

	/* If we get here, not a certified SMP capable AMD system. */

	/*
	 * Don't taint if we are running SMP kernel on a single non-MP
	 * approved Athlon
	 */
	WARN_ONCE(1, "WARNING: This combination of AMD"
187
		" processors is not suitable for SMP.\n");
188 189 190 191 192 193 194 195
	if (!test_taint(TAINT_UNSAFE_SMP))
		add_taint(TAINT_UNSAFE_SMP);

valid_k7:
	;
#endif
}

196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
static void __cpuinit init_amd_k7(struct cpuinfo_x86 *c)
{
	u32 l, h;

	/*
	 * Bit 15 of Athlon specific MSR 15, needs to be 0
	 * to enable SSE on Palomino/Morgan/Barton CPU's.
	 * If the BIOS didn't enable it already, enable it here.
	 */
	if (c->x86_model >= 6 && c->x86_model <= 10) {
		if (!cpu_has(c, X86_FEATURE_XMM)) {
			printk(KERN_INFO "Enabling disabled K7/SSE Support.\n");
			rdmsr(MSR_K7_HWCR, l, h);
			l &= ~0x00008000;
			wrmsr(MSR_K7_HWCR, l, h);
			set_cpu_cap(c, X86_FEATURE_XMM);
		}
	}

	/*
	 * It's been determined by AMD that Athlons since model 8 stepping 1
	 * are more robust with CLK_CTL set to 200xxxxx instead of 600xxxxx
	 * As per AMD technical note 27212 0.2
	 */
	if ((c->x86_model == 8 && c->x86_mask >= 1) || (c->x86_model > 8)) {
		rdmsr(MSR_K7_CLK_CTL, l, h);
		if ((l & 0xfff00000) != 0x20000000) {
A
Alan Cox 已提交
223 224 225
			printk(KERN_INFO
			    "CPU: CLK_CTL MSR was %x. Reprogramming to %x\n",
					l, ((l & 0x000fffff)|0x20000000));
226 227 228 229 230
			wrmsr(MSR_K7_CLK_CTL, (l & 0x000fffff)|0x20000000, h);
		}
	}

	set_cpu_cap(c, X86_FEATURE_K7);
231 232

	amd_k7_smp_check(c);
233
}
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
#endif

#if defined(CONFIG_NUMA) && defined(CONFIG_X86_64)
static int __cpuinit nearby_node(int apicid)
{
	int i, node;

	for (i = apicid - 1; i >= 0; i--) {
		node = apicid_to_node[i];
		if (node != NUMA_NO_NODE && node_online(node))
			return node;
	}
	for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
		node = apicid_to_node[i];
		if (node != NUMA_NO_NODE && node_online(node))
			return node;
	}
	return first_node(node_online_map); /* Shouldn't happen */
}
#endif
254

255 256
/*
 * Fixup core topology information for AMD multi-node processors.
257
 * Assumption: Number of cores in each internal node is the same.
258 259 260 261
 */
#ifdef CONFIG_X86_HT
static void __cpuinit amd_fixup_dcm(struct cpuinfo_x86 *c)
{
262 263
	unsigned long long value;
	u32 nodes, cores_per_node;
264 265
	int cpu = smp_processor_id();

266 267 268
	if (!cpu_has(c, X86_FEATURE_NODEID_MSR))
		return;

269 270 271 272
	/* fixup topology information only once for a core */
	if (cpu_has(c, X86_FEATURE_AMD_DCM))
		return;

273 274 275 276
	rdmsrl(MSR_FAM10H_NODE_ID, value);

	nodes = ((value >> 3) & 7) + 1;
	if (nodes == 1)
277 278 279
		return;

	set_cpu_cap(c, X86_FEATURE_AMD_DCM);
280
	cores_per_node = c->x86_max_cores / nodes;
281

282 283
	/* store NodeID, use llc_shared_map to store sibling info */
	per_cpu(cpu_llc_id, cpu) = value & 7;
284

285 286
	/* fixup core id to be in range from 0 to (cores_per_node - 1) */
	c->cpu_core_id = c->cpu_core_id % cores_per_node;
287 288 289
}
#endif

290 291 292 293 294 295 296 297
/*
 * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
 * Assumes number of cores is a power of two.
 */
static void __cpuinit amd_detect_cmp(struct cpuinfo_x86 *c)
{
#ifdef CONFIG_X86_HT
	unsigned bits;
298
	int cpu = smp_processor_id();
299 300 301 302 303 304

	bits = c->x86_coreid_bits;
	/* Low order bits define the core id (index of core in socket) */
	c->cpu_core_id = c->initial_apicid & ((1 << bits)-1);
	/* Convert the initial APIC ID into the socket ID */
	c->phys_proc_id = c->initial_apicid >> bits;
305 306
	/* use socket ID also for last level cache */
	per_cpu(cpu_llc_id, cpu) = c->phys_proc_id;
307 308 309
	/* fixup topology information on multi-node processors */
	if ((c->x86 == 0x10) && (c->x86_model == 9))
		amd_fixup_dcm(c);
310 311 312
#endif
}

313 314 315 316 317 318 319 320 321 322
int amd_get_nb_id(int cpu)
{
	int id = 0;
#ifdef CONFIG_SMP
	id = per_cpu(cpu_llc_id, cpu);
#endif
	return id;
}
EXPORT_SYMBOL_GPL(amd_get_nb_id);

323 324 325 326 327
static void __cpuinit srat_detect_node(struct cpuinfo_x86 *c)
{
#if defined(CONFIG_NUMA) && defined(CONFIG_X86_64)
	int cpu = smp_processor_id();
	int node;
328
	unsigned apicid = c->apicid;
329

330
	node = per_cpu(cpu_llc_id, cpu);
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357

	if (apicid_to_node[apicid] != NUMA_NO_NODE)
		node = apicid_to_node[apicid];
	if (!node_online(node)) {
		/* Two possibilities here:
		   - The CPU is missing memory and no node was created.
		   In that case try picking one from a nearby CPU
		   - The APIC IDs differ from the HyperTransport node IDs
		   which the K8 northbridge parsing fills in.
		   Assume they are all increased by a constant offset,
		   but in the same order as the HT nodeids.
		   If that doesn't result in a usable node fall back to the
		   path for the previous case.  */

		int ht_nodeid = c->initial_apicid;

		if (ht_nodeid >= 0 &&
		    apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
			node = apicid_to_node[ht_nodeid];
		/* Pick a nearby node */
		if (!node_online(node))
			node = nearby_node(apicid);
	}
	numa_set_node(cpu, node);
#endif
}

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
static void __cpuinit early_init_amd_mc(struct cpuinfo_x86 *c)
{
#ifdef CONFIG_X86_HT
	unsigned bits, ecx;

	/* Multi core CPU? */
	if (c->extended_cpuid_level < 0x80000008)
		return;

	ecx = cpuid_ecx(0x80000008);

	c->x86_max_cores = (ecx & 0xff) + 1;

	/* CPU telling us the core id bits shift? */
	bits = (ecx >> 12) & 0xF;

	/* Otherwise recompute */
	if (bits == 0) {
		while ((1 << bits) < c->x86_max_cores)
			bits++;
	}

	c->x86_coreid_bits = bits;
#endif
}

384
static void __cpuinit early_init_amd(struct cpuinfo_x86 *c)
385
{
386 387
	early_init_amd_mc(c);

388 389 390 391 392
	/*
	 * c->x86_power is 8000_0007 edx. Bit 8 is TSC runs at constant rate
	 * with P/T states and does not stop in deep C-states
	 */
	if (c->x86_power & (1 << 8)) {
393
		set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC);
394 395
		set_cpu_cap(c, X86_FEATURE_NONSTOP_TSC);
	}
396

397 398 399
#ifdef CONFIG_X86_64
	set_cpu_cap(c, X86_FEATURE_SYSCALL32);
#else
400
	/*  Set MTRR capability flag if appropriate */
401 402 403 404 405
	if (c->x86 == 5)
		if (c->x86_model == 13 || c->x86_model == 9 ||
		    (c->x86_model == 8 && c->x86_mask >= 8))
			set_cpu_cap(c, X86_FEATURE_K6_MTRR);
#endif
406 407
#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_PCI)
	/* check CPU config space for extended APIC ID */
408
	if (cpu_has_apic && c->x86 >= 0xf) {
409 410 411 412 413 414
		unsigned int val;
		val = read_pci_config(0, 24, 0, 0x68);
		if ((val & ((1 << 17) | (1 << 18))) == ((1 << 17) | (1 << 18)))
			set_cpu_cap(c, X86_FEATURE_EXTD_APICID);
	}
#endif
415 416
}

417
static void __cpuinit init_amd(struct cpuinfo_x86 *c)
L
Linus Torvalds 已提交
418
{
419
#ifdef CONFIG_SMP
420
	unsigned long long value;
421

422 423
	/*
	 * Disable TLB flush filter by setting HWCR.FFDIS on K8
424 425 426 427 428
	 * bit 6 of msr C001_0015
	 *
	 * Errata 63 for SH-B3 steppings
	 * Errata 122 for all steppings (F+ have it disabled by default)
	 */
429
	if (c->x86 == 0xf) {
430 431 432 433 434 435
		rdmsrl(MSR_K7_HWCR, value);
		value |= 1 << 6;
		wrmsrl(MSR_K7_HWCR, value);
	}
#endif

436 437
	early_init_amd(c);

438 439
	/*
	 * Bit 31 in normal CPUID used for nonstandard 3DNow ID;
440
	 * 3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway
441
	 */
442
	clear_cpu_cap(c, 0*32+31);
443

444 445 446 447 448 449
#ifdef CONFIG_X86_64
	/* On C+ stepping K8 rep microcode works well for copy/memset */
	if (c->x86 == 0xf) {
		u32 level;

		level = cpuid_eax(1);
A
Alan Cox 已提交
450
		if ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58)
451
			set_cpu_cap(c, X86_FEATURE_REP_GOOD);
452 453 454 455

		/*
		 * Some BIOSes incorrectly force this feature, but only K8
		 * revision D (model = 0x14) and later actually support it.
456
		 * (AMD Erratum #110, docId: 25759).
457
		 */
458 459 460
		if (c->x86_model < 0x14 && cpu_has(c, X86_FEATURE_LAHF_LM)) {
			u64 val;

461
			clear_cpu_cap(c, X86_FEATURE_LAHF_LM);
462 463 464 465 466 467
			if (!rdmsrl_amd_safe(0xc001100d, &val)) {
				val &= ~(1ULL << 32);
				wrmsrl_amd_safe(0xc001100d, val);
			}
		}

468
	}
469
	if (c->x86 >= 0x10)
470
		set_cpu_cap(c, X86_FEATURE_REP_GOOD);
471 472 473

	/* get apicid instead of initial apic id from cpuid */
	c->apicid = hard_smp_processor_id();
474 475 476 477 478 479 480 481
#else

	/*
	 *	FIXME: We should handle the K5 here. Set up the write
	 *	range and also turn on MSR 83 bits 4 and 31 (write alloc,
	 *	no bus pipeline)
	 */

482 483
	switch (c->x86) {
	case 4:
484 485
		init_amd_k5(c);
		break;
486
	case 5:
487
		init_amd_k6(c);
L
Linus Torvalds 已提交
488
		break;
489 490
	case 6: /* An Athlon/Duron */
		init_amd_k7(c);
L
Linus Torvalds 已提交
491 492
		break;
	}
493 494 495 496

	/* K6s reports MCEs but don't actually have all the MSRs */
	if (c->x86 < 6)
		clear_cpu_cap(c, X86_FEATURE_MCE);
497
#endif
498

499
	/* Enable workaround for FXSAVE leak */
500
	if (c->x86 >= 6)
501
		set_cpu_cap(c, X86_FEATURE_FXSAVE_LEAK);
L
Linus Torvalds 已提交
502

503 504 505 506 507 508 509 510 511
	if (!c->x86_model_id[0]) {
		switch (c->x86) {
		case 0xf:
			/* Should distinguish Models here, but this is only
			   a fallback anyways. */
			strcpy(c->x86_model_id, "Hammer");
			break;
		}
	}
512

513
	cpu_detect_cache_sizes(c);
514

515
	/* Multi core CPU? */
516
	if (c->extended_cpuid_level >= 0x80000008) {
517
		amd_detect_cmp(c);
518 519
		srat_detect_node(c);
	}
520

521
#ifdef CONFIG_X86_32
522
	detect_ht(c);
523
#endif
524

525 526
	if (c->extended_cpuid_level >= 0x80000006) {
		if ((c->x86 >= 0x0f) && (cpuid_edx(0x80000006) & 0xf000))
527 528 529 530
			num_cache_leaves = 4;
		else
			num_cache_leaves = 3;
	}
531

532
	if (c->x86 >= 0xf)
533
		set_cpu_cap(c, X86_FEATURE_K8);
534

535 536
	if (cpu_has_xmm2) {
		/* MFENCE stops RDTSC speculation */
537
		set_cpu_cap(c, X86_FEATURE_MFENCE_RDTSC);
538
	}
539 540 541 542 543 544 545 546 547 548

#ifdef CONFIG_X86_64
	if (c->x86 == 0x10) {
		/* do this for boot cpu */
		if (c == &boot_cpu_data)
			check_enable_amd_mmconf_dmi();

		fam10h_check_enable_mmcfg();
	}

549
	if (c == &boot_cpu_data && c->x86 >= 0xf) {
550 551 552 553 554 555 556 557
		unsigned long long tseg;

		/*
		 * Split up direct mapping around the TSEG SMM area.
		 * Don't do it for gbpages because there seems very little
		 * benefit in doing so.
		 */
		if (!rdmsrl_safe(MSR_K8_TSEG_ADDR, &tseg)) {
A
Alan Cox 已提交
558 559
			printk(KERN_DEBUG "tseg: %010llx\n", tseg);
			if ((tseg>>PMD_SHIFT) <
560
				(max_low_pfn_mapped>>(PMD_SHIFT-PAGE_SHIFT)) ||
A
Alan Cox 已提交
561
				((tseg>>PMD_SHIFT) <
562
				(max_pfn_mapped>>(PMD_SHIFT-PAGE_SHIFT)) &&
A
Alan Cox 已提交
563 564
				(tseg>>PMD_SHIFT) >= (1ULL<<(32 - PMD_SHIFT))))
				set_memory_4k((unsigned long)__va(tseg), 1);
565 566 567
		}
	}
#endif
L
Linus Torvalds 已提交
568 569
}

570
#ifdef CONFIG_X86_32
A
Alan Cox 已提交
571 572
static unsigned int __cpuinit amd_size_cache(struct cpuinfo_x86 *c,
							unsigned int size)
L
Linus Torvalds 已提交
573 574 575
{
	/* AMD errata T13 (order #21922) */
	if ((c->x86 == 6)) {
A
Alan Cox 已提交
576 577
		/* Duron Rev A0 */
		if (c->x86_model == 3 && c->x86_mask == 0)
L
Linus Torvalds 已提交
578
			size = 64;
A
Alan Cox 已提交
579
		/* Tbird rev A1/A2 */
L
Linus Torvalds 已提交
580
		if (c->x86_model == 4 &&
A
Alan Cox 已提交
581
			(c->x86_mask == 0 || c->x86_mask == 1))
L
Linus Torvalds 已提交
582 583 584 585
			size = 256;
	}
	return size;
}
586
#endif
L
Linus Torvalds 已提交
587

588
static const struct cpu_dev __cpuinitconst amd_cpu_dev = {
L
Linus Torvalds 已提交
589
	.c_vendor	= "AMD",
590
	.c_ident	= { "AuthenticAMD" },
591
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
592 593 594 595 596
	.c_models = {
		{ .vendor = X86_VENDOR_AMD, .family = 4, .model_names =
		  {
			  [3] = "486 DX/2",
			  [7] = "486 DX/2-WB",
597 598
			  [8] = "486 DX/4",
			  [9] = "486 DX/4-WB",
L
Linus Torvalds 已提交
599
			  [14] = "Am5x86-WT",
600
			  [15] = "Am5x86-WB"
L
Linus Torvalds 已提交
601 602 603
		  }
		},
	},
604 605
	.c_size_cache	= amd_size_cache,
#endif
606
	.c_early_init   = early_init_amd,
L
Linus Torvalds 已提交
607
	.c_init		= init_amd,
Y
Yinghai Lu 已提交
608
	.c_x86_vendor	= X86_VENDOR_AMD,
L
Linus Torvalds 已提交
609 610
};

Y
Yinghai Lu 已提交
611
cpu_dev_register(amd_cpu_dev);