common.c 27.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
#include <linux/init.h>
2 3
#include <linux/kernel.h>
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
4
#include <linux/string.h>
5 6 7 8 9
#include <linux/bootmem.h>
#include <linux/bitops.h>
#include <linux/module.h>
#include <linux/kgdb.h>
#include <linux/topology.h>
Linus Torvalds's avatar
Linus Torvalds committed
10 11 12 13 14 15
#include <linux/delay.h>
#include <linux/smp.h>
#include <linux/percpu.h>
#include <asm/i387.h>
#include <asm/msr.h>
#include <asm/io.h>
16
#include <asm/linkage.h>
Linus Torvalds's avatar
Linus Torvalds committed
17
#include <asm/mmu_context.h>
18
#include <asm/mtrr.h>
19
#include <asm/mce.h>
20
#include <asm/pat.h>
21
#include <asm/asm.h>
22
#include <asm/numa.h>
Linus Torvalds's avatar
Linus Torvalds committed
23 24 25 26
#ifdef CONFIG_X86_LOCAL_APIC
#include <asm/mpspec.h>
#include <asm/apic.h>
#include <mach_apic.h>
27
#include <asm/genapic.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29
#endif

30 31 32 33 34 35 36 37 38
#include <asm/pda.h>
#include <asm/pgtable.h>
#include <asm/processor.h>
#include <asm/desc.h>
#include <asm/atomic.h>
#include <asm/proto.h>
#include <asm/sections.h>
#include <asm/setup.h>

Linus Torvalds's avatar
Linus Torvalds committed
39 40
#include "cpu.h"

41 42
static struct cpu_dev *this_cpu __cpuinitdata;

Yinghai Lu's avatar
Yinghai Lu committed
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
#ifdef CONFIG_X86_64
/* We need valid kernel segments for data and code in long mode too
 * IRET will check the segment types  kkeil 2000/10/28
 * Also sysret mandates a special GDT layout
 */
/* The TLS descriptors are currently at a different place compared to i386.
   Hopefully nobody expects them at a fixed place (Wine?) */
DEFINE_PER_CPU(struct gdt_page, gdt_page) = { .gdt = {
	[GDT_ENTRY_KERNEL32_CS] = { { { 0x0000ffff, 0x00cf9b00 } } },
	[GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00af9b00 } } },
	[GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9300 } } },
	[GDT_ENTRY_DEFAULT_USER32_CS] = { { { 0x0000ffff, 0x00cffb00 } } },
	[GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff300 } } },
	[GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00affb00 } } },
} };
#else
59
DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
60 61 62 63
	[GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00cf9a00 } } },
	[GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9200 } } },
	[GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00cffa00 } } },
	[GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff200 } } },
64 65 66 67 68
	/*
	 * Segments used for calling PnP BIOS have byte granularity.
	 * They code segments and data segments have fixed 64k limits,
	 * the transfer segment sizes are set at run time.
	 */
69 70 71 72 73 74 75 76 77 78
	/* 32-bit code */
	[GDT_ENTRY_PNPBIOS_CS32] = { { { 0x0000ffff, 0x00409a00 } } },
	/* 16-bit code */
	[GDT_ENTRY_PNPBIOS_CS16] = { { { 0x0000ffff, 0x00009a00 } } },
	/* 16-bit data */
	[GDT_ENTRY_PNPBIOS_DS] = { { { 0x0000ffff, 0x00009200 } } },
	/* 16-bit data */
	[GDT_ENTRY_PNPBIOS_TS1] = { { { 0x00000000, 0x00009200 } } },
	/* 16-bit data */
	[GDT_ENTRY_PNPBIOS_TS2] = { { { 0x00000000, 0x00009200 } } },
79 80 81 82
	/*
	 * The APM segments have byte granularity and their bases
	 * are set at run time.  All have 64k limits.
	 */
83 84
	/* 32-bit code */
	[GDT_ENTRY_APMBIOS_BASE] = { { { 0x0000ffff, 0x00409a00 } } },
85
	/* 16-bit code */
86 87 88
	[GDT_ENTRY_APMBIOS_BASE+1] = { { { 0x0000ffff, 0x00009a00 } } },
	/* data */
	[GDT_ENTRY_APMBIOS_BASE+2] = { { { 0x0000ffff, 0x00409200 } } },
89

90 91
	[GDT_ENTRY_ESPFIX_SS] = { { { 0x00000000, 0x00c09200 } } },
	[GDT_ENTRY_PERCPU] = { { { 0x00000000, 0x00000000 } } },
92
} };
Yinghai Lu's avatar
Yinghai Lu committed
93
#endif
94
EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);
95

96
#ifdef CONFIG_X86_32
97 98
static int cachesize_override __cpuinitdata = -1;
static int disable_x86_serial_nr __cpuinitdata = 1;
Linus Torvalds's avatar
Linus Torvalds committed
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 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 187 188 189 190 191 192 193 194 195 196 197 198
static int __init cachesize_setup(char *str)
{
	get_option(&str, &cachesize_override);
	return 1;
}
__setup("cachesize=", cachesize_setup);

/*
 * Naming convention should be: <Name> [(<Codename>)]
 * This table only is used unless init_<vendor>() below doesn't set it;
 * in particular, if CPUID levels 0x80000002..4 are supported, this isn't used
 *
 */

/* Look up CPU names by table lookup. */
static char __cpuinit *table_lookup_model(struct cpuinfo_x86 *c)
{
	struct cpu_model_info *info;

	if (c->x86_model >= 16)
		return NULL;	/* Range check */

	if (!this_cpu)
		return NULL;

	info = this_cpu->c_models;

	while (info && info->family) {
		if (info->family == c->x86)
			return info->model_names[c->x86_model];
		info++;
	}
	return NULL;		/* Not found */
}

static int __init x86_fxsr_setup(char *s)
{
	setup_clear_cpu_cap(X86_FEATURE_FXSR);
	setup_clear_cpu_cap(X86_FEATURE_XMM);
	return 1;
}
__setup("nofxsr", x86_fxsr_setup);

static int __init x86_sep_setup(char *s)
{
	setup_clear_cpu_cap(X86_FEATURE_SEP);
	return 1;
}
__setup("nosep", x86_sep_setup);

/* Standard macro to see if a specific flag is changeable */
static inline int flag_is_changeable_p(u32 flag)
{
	u32 f1, f2;

	asm("pushfl\n\t"
	    "pushfl\n\t"
	    "popl %0\n\t"
	    "movl %0,%1\n\t"
	    "xorl %2,%0\n\t"
	    "pushl %0\n\t"
	    "popfl\n\t"
	    "pushfl\n\t"
	    "popl %0\n\t"
	    "popfl\n\t"
	    : "=&r" (f1), "=&r" (f2)
	    : "ir" (flag));

	return ((f1^f2) & flag) != 0;
}

/* Probe for the CPUID instruction */
static int __cpuinit have_cpuid_p(void)
{
	return flag_is_changeable_p(X86_EFLAGS_ID);
}

static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
{
	if (cpu_has(c, X86_FEATURE_PN) && disable_x86_serial_nr) {
		/* Disable processor serial number */
		unsigned long lo, hi;
		rdmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
		lo |= 0x200000;
		wrmsr(MSR_IA32_BBL_CR_CTL, lo, hi);
		printk(KERN_NOTICE "CPU serial number disabled.\n");
		clear_cpu_cap(c, X86_FEATURE_PN);

		/* Disabling the serial number may affect the cpuid level */
		c->cpuid_level = cpuid_eax(0);
	}
}

static int __init x86_serial_nr_setup(char *s)
{
	disable_x86_serial_nr = 0;
	return 1;
}
__setup("serialnumber", x86_serial_nr_setup);
199 200 201 202 203 204 205
#else
/* Probe for the CPUID instruction */
static inline int have_cpuid_p(void)
{
	return 1;
}
#endif
206

207 208
__u32 cleared_cpu_caps[NCAPINTS] __cpuinitdata;

209 210 211 212 213 214 215 216 217
/* Current gdt points %fs at the "master" per-cpu area: after this,
 * it's on the real one. */
void switch_to_new_gdt(void)
{
	struct desc_ptr gdt_descr;

	gdt_descr.address = (long)get_cpu_gdt_table(smp_processor_id());
	gdt_descr.size = GDT_SIZE - 1;
	load_gdt(&gdt_descr);
218
#ifdef CONFIG_X86_32
219
	asm("mov %0, %%fs" : : "r" (__KERNEL_PERCPU) : "memory");
220
#endif
221 222
}

Yinghai Lu's avatar
Yinghai Lu committed
223
static struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
Linus Torvalds's avatar
Linus Torvalds committed
224

225
static void __cpuinit default_init(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
226
{
227 228 229
#ifdef CONFIG_X86_64
	display_cacheinfo(c);
#else
Linus Torvalds's avatar
Linus Torvalds committed
230 231 232 233 234 235 236 237 238
	/* Not much we can do here... */
	/* Check if at least it has cpuid */
	if (c->cpuid_level == -1) {
		/* No cpuid. It must be an ancient CPU */
		if (c->x86 == 4)
			strcpy(c->x86_model_id, "486");
		else if (c->x86 == 3)
			strcpy(c->x86_model_id, "386");
	}
239
#endif
Linus Torvalds's avatar
Linus Torvalds committed
240 241
}

242
static struct cpu_dev __cpuinitdata default_cpu = {
Linus Torvalds's avatar
Linus Torvalds committed
243
	.c_init	= default_init,
244
	.c_vendor = "Unknown",
Yinghai Lu's avatar
Yinghai Lu committed
245
	.c_x86_vendor = X86_VENDOR_UNKNOWN,
Linus Torvalds's avatar
Linus Torvalds committed
246 247
};

248
int __cpuinit get_model_name(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
249 250 251 252
{
	unsigned int *v;
	char *p, *q;

253
	if (c->extended_cpuid_level < 0x80000004)
Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258 259 260 261 262 263 264
		return 0;

	v = (unsigned int *) c->x86_model_id;
	cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
	cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
	cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
	c->x86_model_id[48] = 0;

	/* Intel chips right-justify this string for some dumb reason;
	   undo that brain damage */
	p = q = &c->x86_model_id[0];
265
	while (*p == ' ')
Linus Torvalds's avatar
Linus Torvalds committed
266
	     p++;
267 268
	if (p != q) {
	     while (*p)
Linus Torvalds's avatar
Linus Torvalds committed
269
		  *q++ = *p++;
270
	     while (q <= &c->x86_model_id[48])
Linus Torvalds's avatar
Linus Torvalds committed
271 272 273 274 275 276
		  *q++ = '\0';	/* Zero-pad the rest */
	}

	return 1;
}

277
void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
278
{
279
	unsigned int n, dummy, ebx, ecx, edx, l2size;
Linus Torvalds's avatar
Linus Torvalds committed
280

281
	n = c->extended_cpuid_level;
Linus Torvalds's avatar
Linus Torvalds committed
282 283

	if (n >= 0x80000005) {
284
		cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
Linus Torvalds's avatar
Linus Torvalds committed
285
		printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
286 287
				edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
		c->x86_cache_size = (ecx>>24) + (edx>>24);
288 289 290 291
#ifdef CONFIG_X86_64
		/* On K8 L1 TLB is inclusive, so don't count it */
		c->x86_tlbsize = 0;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295 296
	}

	if (n < 0x80000006)	/* Some chips just has a large L1. */
		return;

297
	cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
Linus Torvalds's avatar
Linus Torvalds committed
298
	l2size = ecx >> 16;
299

300 301 302
#ifdef CONFIG_X86_64
	c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
#else
Linus Torvalds's avatar
Linus Torvalds committed
303 304
	/* do processor-specific cache resizing */
	if (this_cpu->c_size_cache)
305
		l2size = this_cpu->c_size_cache(c, l2size);
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309 310

	/* Allow user to override all this if necessary. */
	if (cachesize_override != -1)
		l2size = cachesize_override;

311
	if (l2size == 0)
Linus Torvalds's avatar
Linus Torvalds committed
312
		return;		/* Again, no L2 cache is possible */
313
#endif
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316 317

	c->x86_cache_size = l2size;

	printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
318
			l2size, ecx & 0xFF);
Linus Torvalds's avatar
Linus Torvalds committed
319 320
}

321
void __cpuinit detect_ht(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
322
{
323
#ifdef CONFIG_X86_HT
324 325
	u32 eax, ebx, ecx, edx;
	int index_msb, core_bits;
Linus Torvalds's avatar
Linus Torvalds committed
326

327
	if (!cpu_has(c, X86_FEATURE_HT))
328
		return;
Linus Torvalds's avatar
Linus Torvalds committed
329

330 331
	if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
332

333 334 335
	if (cpu_has(c, X86_FEATURE_XTOPOLOGY))
		return;

336
	cpuid(1, &eax, &ebx, &ecx, &edx);
Linus Torvalds's avatar
Linus Torvalds committed
337

338 339 340 341 342 343 344 345 346 347 348 349 350 351
	smp_num_siblings = (ebx & 0xff0000) >> 16;

	if (smp_num_siblings == 1) {
		printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
	} else if (smp_num_siblings > 1) {

		if (smp_num_siblings > NR_CPUS) {
			printk(KERN_WARNING "CPU: Unsupported number of siblings %d",
					smp_num_siblings);
			smp_num_siblings = 1;
			return;
		}

		index_msb = get_count_order(smp_num_siblings);
352 353 354
#ifdef CONFIG_X86_64
		c->phys_proc_id = phys_pkg_id(index_msb);
#else
355
		c->phys_proc_id = phys_pkg_id(c->initial_apicid, index_msb);
356
#endif
357 358 359 360 361 362 363

		smp_num_siblings = smp_num_siblings / c->x86_max_cores;

		index_msb = get_count_order(smp_num_siblings);

		core_bits = get_count_order(c->x86_max_cores);

364 365 366 367
#ifdef CONFIG_X86_64
		c->cpu_core_id = phys_pkg_id(index_msb) &
					       ((1 << core_bits) - 1);
#else
368 369
		c->cpu_core_id = phys_pkg_id(c->initial_apicid, index_msb) &
					       ((1 << core_bits) - 1);
370
#endif
Linus Torvalds's avatar
Linus Torvalds committed
371 372
	}

373 374 375 376 377 378
out:
	if ((c->x86_max_cores * smp_num_siblings) > 1) {
		printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
		       c->phys_proc_id);
		printk(KERN_INFO  "CPU: Processor Core ID: %d\n",
		       c->cpu_core_id);
379 380
	}
#endif
381
}
Linus Torvalds's avatar
Linus Torvalds committed
382

383
static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
384 385 386
{
	char *v = c->x86_vendor_id;
	int i;
387
	static int printed;
Linus Torvalds's avatar
Linus Torvalds committed
388 389

	for (i = 0; i < X86_VENDOR_NUM; i++) {
Yinghai Lu's avatar
Yinghai Lu committed
390 391 392 393 394 395 396 397 398
		if (!cpu_devs[i])
			break;

		if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
		    (cpu_devs[i]->c_ident[1] &&
		     !strcmp(v, cpu_devs[i]->c_ident[1]))) {
			this_cpu = cpu_devs[i];
			c->x86_vendor = this_cpu->c_x86_vendor;
			return;
Linus Torvalds's avatar
Linus Torvalds committed
399 400
		}
	}
Yinghai Lu's avatar
Yinghai Lu committed
401

402 403 404 405 406
	if (!printed) {
		printed++;
		printk(KERN_ERR "CPU: Vendor unknown, using generic init.\n");
		printk(KERN_ERR "CPU: Your system may be unstable.\n");
	}
Yinghai Lu's avatar
Yinghai Lu committed
407

408 409
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	this_cpu = &default_cpu;
Linus Torvalds's avatar
Linus Torvalds committed
410 411
}

412
void __cpuinit cpu_detect(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
413 414
{
	/* Get vendor name */
415 416 417 418
	cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
	      (unsigned int *)&c->x86_vendor_id[0],
	      (unsigned int *)&c->x86_vendor_id[8],
	      (unsigned int *)&c->x86_vendor_id[4]);
Linus Torvalds's avatar
Linus Torvalds committed
419 420

	c->x86 = 4;
421
	/* Intel-defined flags: level 0x00000001 */
Linus Torvalds's avatar
Linus Torvalds committed
422 423 424
	if (c->cpuid_level >= 0x00000001) {
		u32 junk, tfms, cap0, misc;
		cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
425 426 427
		c->x86 = (tfms >> 8) & 0xf;
		c->x86_model = (tfms >> 4) & 0xf;
		c->x86_mask = tfms & 0xf;
428
		if (c->x86 == 0xf)
Linus Torvalds's avatar
Linus Torvalds committed
429
			c->x86 += (tfms >> 20) & 0xff;
430
		if (c->x86 >= 0x6)
431
			c->x86_model += ((tfms >> 16) & 0xf) << 4;
432 433
		if (cap0 & (1<<19)) {
			c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
434
			c->x86_cache_alignment = c->x86_clflush_size;
435
		}
Linus Torvalds's avatar
Linus Torvalds committed
436 437
	}
}
438 439

static void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c)
440 441
{
	u32 tfms, xlvl;
442
	u32 ebx;
443

444 445 446 447 448 449 450
	/* Intel-defined flags: level 0x00000001 */
	if (c->cpuid_level >= 0x00000001) {
		u32 capability, excap;
		cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
		c->x86_capability[0] = capability;
		c->x86_capability[4] = excap;
	}
451

452 453 454 455 456 457 458
	/* AMD-defined flags: level 0x80000001 */
	xlvl = cpuid_eax(0x80000000);
	c->extended_cpuid_level = xlvl;
	if ((xlvl & 0xffff0000) == 0x80000000) {
		if (xlvl >= 0x80000001) {
			c->x86_capability[1] = cpuid_edx(0x80000001);
			c->x86_capability[6] = cpuid_ecx(0x80000001);
459 460
		}
	}
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480

#ifdef CONFIG_X86_64
	/* Transmeta-defined flags: level 0x80860001 */
	xlvl = cpuid_eax(0x80860000);
	if ((xlvl & 0xffff0000) == 0x80860000) {
		/* Don't set x86_cpuid_level here for now to not confuse. */
		if (xlvl >= 0x80860001)
			c->x86_capability[2] = cpuid_edx(0x80860001);
	}

	if (c->extended_cpuid_level >= 0x80000007)
		c->x86_power = cpuid_edx(0x80000007);

	if (c->extended_cpuid_level >= 0x80000008) {
		u32 eax = cpuid_eax(0x80000008);

		c->x86_virt_bits = (eax >> 8) & 0xff;
		c->x86_phys_bits = eax & 0xff;
	}
#endif
481
}
482 483 484 485 486 487 488 489 490
/*
 * Do minimum CPU detection early.
 * Fields really needed: vendor, cpuid_level, family, model, mask,
 * cache alignment.
 * The others are not touched to avoid unwanted side effects.
 *
 * WARNING: this function is only called on the BP.  Don't add code here
 * that is supposed to run on all CPUs.
 */
491
static void __init early_identify_cpu(struct cpuinfo_x86 *c)
492
{
493
	c->x86_clflush_size = 32;
494
	c->x86_cache_alignment = c->x86_clflush_size;
495 496 497 498

	if (!have_cpuid_p())
		return;

499 500
	memset(&c->x86_capability, 0, sizeof c->x86_capability);

501 502
	c->extended_cpuid_level = 0;

503 504
	cpu_detect(c);

505
	get_cpu_vendor(c);
506

507
	get_cpu_cap(c);
508

Yinghai Lu's avatar
Yinghai Lu committed
509 510
	if (this_cpu->c_early_init)
		this_cpu->c_early_init(c);
511

512
	validate_pat_support(c);
513 514
}

515 516
void __init early_cpu_init(void)
{
Yinghai Lu's avatar
Yinghai Lu committed
517 518 519 520 521 522 523
	struct cpu_dev **cdev;
	int count = 0;

	printk("KERNEL supported cpus:\n");
	for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
		struct cpu_dev *cpudev = *cdev;
		unsigned int j;
524

Yinghai Lu's avatar
Yinghai Lu committed
525 526 527 528 529 530 531 532 533 534 535 536
		if (count >= X86_VENDOR_NUM)
			break;
		cpu_devs[count] = cpudev;
		count++;

		for (j = 0; j < 2; j++) {
			if (!cpudev->c_ident[j])
				continue;
			printk("  %s %s\n", cpudev->c_vendor,
				cpudev->c_ident[j]);
		}
	}
537 538

	early_identify_cpu(&boot_cpu_data);
539 540
}

541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
/*
 * The NOPL instruction is supposed to exist on all CPUs with
 * family >= 6, unfortunately, that's not true in practice because
 * of early VIA chips and (more importantly) broken virtualizers that
 * are not easy to detect.  Hence, probe for it based on first
 * principles.
 */
static void __cpuinit detect_nopl(struct cpuinfo_x86 *c)
{
	const u32 nopl_signature = 0x888c53b1; /* Random number */
	u32 has_nopl = nopl_signature;

	clear_cpu_cap(c, X86_FEATURE_NOPL);
	if (c->x86 >= 6) {
		asm volatile("\n"
			     "1:      .byte 0x0f,0x1f,0xc0\n" /* nopl %eax */
			     "2:\n"
			     "        .section .fixup,\"ax\"\n"
			     "3:      xor %0,%0\n"
			     "        jmp 2b\n"
			     "        .previous\n"
			     _ASM_EXTABLE(1b,3b)
			     : "+a" (has_nopl));

		if (has_nopl == nopl_signature)
			set_cpu_cap(c, X86_FEATURE_NOPL);
	}
}

570
static void __cpuinit generic_identify(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
571
{
572 573
	if (!have_cpuid_p())
		return;
Linus Torvalds's avatar
Linus Torvalds committed
574

575
	c->extended_cpuid_level = 0;
576

577
	cpu_detect(c);
Linus Torvalds's avatar
Linus Torvalds committed
578

579
	get_cpu_vendor(c);
Linus Torvalds's avatar
Linus Torvalds committed
580

581
	get_cpu_cap(c);
Linus Torvalds's avatar
Linus Torvalds committed
582

583 584
	if (c->cpuid_level >= 0x00000001) {
		c->initial_apicid = (cpuid_ebx(1) >> 24) & 0xFF;
585
#ifdef CONFIG_X86_HT
586 587
		c->apicid = phys_pkg_id(c->initial_apicid, 0);
		c->phys_proc_id = c->initial_apicid;
588
#else
589
		c->apicid = c->initial_apicid;
590
#endif
591
	}
Linus Torvalds's avatar
Linus Torvalds committed
592

593 594
	if (c->extended_cpuid_level >= 0x80000004)
		get_model_name(c); /* Default name */
Linus Torvalds's avatar
Linus Torvalds committed
595

596 597
	init_scattered_cpuid_features(c);
	detect_nopl(c);
Linus Torvalds's avatar
Linus Torvalds committed
598 599 600 601 602
}

/*
 * This does the hard work of actually picking apart the CPU stuff...
 */
603
static void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
604 605 606 607 608 609 610 611 612 613
{
	int i;

	c->loops_per_jiffy = loops_per_jiffy;
	c->x86_cache_size = -1;
	c->x86_vendor = X86_VENDOR_UNKNOWN;
	c->cpuid_level = -1;	/* CPUID not detected */
	c->x86_model = c->x86_mask = 0;	/* So far unknown... */
	c->x86_vendor_id[0] = '\0'; /* Unset */
	c->x86_model_id[0] = '\0';  /* Unset */
614
	c->x86_max_cores = 1;
615
	c->x86_clflush_size = 32;
Linus Torvalds's avatar
Linus Torvalds committed
616 617 618
	memset(&c->x86_capability, 0, sizeof c->x86_capability);

	if (!have_cpuid_p()) {
619 620 621 622 623
		/*
		 * First of all, decide if this is a 486 or higher
		 * It's a 486 if we can modify the AC flag
		 */
		if (flag_is_changeable_p(X86_EFLAGS_AC))
Linus Torvalds's avatar
Linus Torvalds committed
624 625 626 627 628 629 630
			c->x86 = 4;
		else
			c->x86 = 3;
	}

	generic_identify(c);

631
	if (this_cpu->c_identify)
Linus Torvalds's avatar
Linus Torvalds committed
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
		this_cpu->c_identify(c);

	/*
	 * Vendor-specific initialization.  In this section we
	 * canonicalize the feature flags, meaning if there are
	 * features a certain CPU supports which CPUID doesn't
	 * tell us, CPUID claiming incorrect flags, or other bugs,
	 * we handle them here.
	 *
	 * At the end of this section, c->x86_capability better
	 * indicate the features this CPU genuinely supports!
	 */
	if (this_cpu->c_init)
		this_cpu->c_init(c);

	/* Disable the PN if appropriate */
	squash_the_stupid_serial_number(c);

	/*
	 * The vendor-specific functions might have changed features.  Now
	 * we do "generic changes."
	 */

	/* If the model name is still unset, do table lookup. */
656
	if (!c->x86_model_id[0]) {
Linus Torvalds's avatar
Linus Torvalds committed
657 658
		char *p;
		p = table_lookup_model(c);
659
		if (p)
Linus Torvalds's avatar
Linus Torvalds committed
660 661 662 663
			strcpy(c->x86_model_id, p);
		else
			/* Last resort... */
			sprintf(c->x86_model_id, "%02x/%02x",
664
				c->x86, c->x86_model);
Linus Torvalds's avatar
Linus Torvalds committed
665 666 667 668 669 670 671 672
	}

	/*
	 * On SMP, boot_cpu_data holds the common feature set between
	 * all CPUs; so make sure that we indicate which features are
	 * common between the CPUs.  The first time this routine gets
	 * executed, c == &boot_cpu_data.
	 */
673
	if (c != &boot_cpu_data) {
Linus Torvalds's avatar
Linus Torvalds committed
674
		/* AND the already accumulated flags with these */
675
		for (i = 0; i < NCAPINTS; i++)
Linus Torvalds's avatar
Linus Torvalds committed
676 677 678
			boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
	}

679 680
	/* Clear all flags overriden by options */
	for (i = 0; i < NCAPINTS; i++)
681
		c->x86_capability[i] &= ~cleared_cpu_caps[i];
682

Linus Torvalds's avatar
Linus Torvalds committed
683 684
	/* Init Machine Check Exception if available. */
	mcheck_init(c);
685 686

	select_idle_routine(c);
687
}
Shaohua Li's avatar
Shaohua Li committed
688

689 690 691 692
void __init identify_boot_cpu(void)
{
	identify_cpu(&boot_cpu_data);
	sysenter_setup();
Li Shaohua's avatar
Li Shaohua committed
693
	enable_sep_cpu();
694
}
695

696 697 698 699 700 701
void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c)
{
	BUG_ON(c == &boot_cpu_data);
	identify_cpu(c);
	enable_sep_cpu();
	mtrr_ap_init();
Linus Torvalds's avatar
Linus Torvalds committed
702 703
}

704 705 706 707
struct msr_range {
	unsigned min;
	unsigned max;
};
Linus Torvalds's avatar
Linus Torvalds committed
708

709 710 711 712 713 714
static struct msr_range msr_range_array[] __cpuinitdata = {
	{ 0x00000000, 0x00000418},
	{ 0xc0000000, 0xc000040b},
	{ 0xc0010000, 0xc0010142},
	{ 0xc0011000, 0xc001103b},
};
Linus Torvalds's avatar
Linus Torvalds committed
715

716 717 718 719 720 721 722 723 724 725 726 727 728 729
static void __cpuinit print_cpu_msr(void)
{
	unsigned index;
	u64 val;
	int i;
	unsigned index_min, index_max;

	for (i = 0; i < ARRAY_SIZE(msr_range_array); i++) {
		index_min = msr_range_array[i].min;
		index_max = msr_range_array[i].max;
		for (index = index_min; index < index_max; index++) {
			if (rdmsrl_amd_safe(index, &val))
				continue;
			printk(KERN_INFO " MSR%08x: %016llx\n", index, val);
Linus Torvalds's avatar
Linus Torvalds committed
730
		}
731 732
	}
}
733

734 735 736 737
static int show_msr __cpuinitdata;
static __init int setup_show_msr(char *arg)
{
	int num;
738

739
	get_option(&arg, &num);
740

741 742 743
	if (num > 0)
		show_msr = num;
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
744
}
745
__setup("show_msr=", setup_show_msr);
Linus Torvalds's avatar
Linus Torvalds committed
746

Andi Kleen's avatar
Andi Kleen committed
747 748 749 750 751 752 753
static __init int setup_noclflush(char *arg)
{
	setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
	return 1;
}
__setup("noclflush", setup_noclflush);

754
void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
Linus Torvalds's avatar
Linus Torvalds committed
755 756 757 758 759 760 761 762 763
{
	char *vendor = NULL;

	if (c->x86_vendor < X86_VENDOR_NUM)
		vendor = this_cpu->c_vendor;
	else if (c->cpuid_level >= 0)
		vendor = c->x86_vendor_id;

	if (vendor && strncmp(c->x86_model_id, vendor, strlen(vendor)))
764
		printk(KERN_CONT "%s ", vendor);
Linus Torvalds's avatar
Linus Torvalds committed
765

766 767
	if (c->x86_model_id[0])
		printk(KERN_CONT "%s", c->x86_model_id);
Linus Torvalds's avatar
Linus Torvalds committed
768
	else
769
		printk(KERN_CONT "%d86", c->x86);
Linus Torvalds's avatar
Linus Torvalds committed
770

771
	if (c->x86_mask || c->cpuid_level >= 0)
772
		printk(KERN_CONT " stepping %02x\n", c->x86_mask);
Linus Torvalds's avatar
Linus Torvalds committed
773
	else
774
		printk(KERN_CONT "\n");
775 776 777 778 779 780 781 782

#ifdef CONFIG_SMP
	if (c->cpu_index < show_msr)
		print_cpu_msr();
#else
	if (show_msr)
		print_cpu_msr();
#endif
Linus Torvalds's avatar
Linus Torvalds committed
783 784
}

785 786 787 788 789 790 791 792 793 794 795
static __init int setup_disablecpuid(char *arg)
{
	int bit;
	if (get_option(&arg, &bit) && bit < NCAPINTS*32)
		setup_clear_cpu_cap(bit);
	else
		return 0;
	return 1;
}
__setup("clearcpuid=", setup_disablecpuid);

796
cpumask_t cpu_initialized __cpuinitdata = CPU_MASK_NONE;
Linus Torvalds's avatar
Linus Torvalds committed
797

798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
#ifdef CONFIG_X86_64
struct x8664_pda **_cpu_pda __read_mostly;
EXPORT_SYMBOL(_cpu_pda);

struct desc_ptr idt_descr = { 256 * 16 - 1, (unsigned long) idt_table };

char boot_cpu_stack[IRQSTACKSIZE] __page_aligned_bss;

unsigned long __supported_pte_mask __read_mostly = ~0UL;
EXPORT_SYMBOL_GPL(__supported_pte_mask);

static int do_not_nx __cpuinitdata;

/* noexec=on|off
Control non executable mappings for 64bit processes.

on	Enable(default)
off	Disable
*/
static int __init nonx_setup(char *str)
{
	if (!str)
		return -EINVAL;
	if (!strncmp(str, "on", 2)) {
		__supported_pte_mask |= _PAGE_NX;
		do_not_nx = 0;
	} else if (!strncmp(str, "off", 3)) {
		do_not_nx = 1;
		__supported_pte_mask &= ~_PAGE_NX;
	}
	return 0;
}
early_param("noexec", nonx_setup);

int force_personality32;

/* noexec32=on|off
Control non executable heap for 32bit processes.
To control the stack too use noexec=off

on	PROT_READ does not imply PROT_EXEC for 32bit processes (default)
off	PROT_READ implies PROT_EXEC
*/
static int __init nonx32_setup(char *str)
{
	if (!strcmp(str, "on"))
		force_personality32 &= ~READ_IMPLIES_EXEC;
	else if (!strcmp(str, "off"))
		force_personality32 |= READ_IMPLIES_EXEC;
	return 1;
}
__setup("noexec32=", nonx32_setup);

void pda_init(int cpu)
{
	struct x8664_pda *pda = cpu_pda(cpu);

	/* Setup up data that may be needed in __get_free_pages early */
	loadsegment(fs, 0);
	loadsegment(gs, 0);
	/* Memory clobbers used to order PDA accessed */
	mb();
	wrmsrl(MSR_GS_BASE, pda);
	mb();

	pda->cpunumber = cpu;
	pda->irqcount = -1;
	pda->kernelstack = (unsigned long)stack_thread_info() -
				 PDA_STACKOFFSET + THREAD_SIZE;
	pda->active_mm = &init_mm;
	pda->mmu_state = 0;

	if (cpu == 0) {
		/* others are initialized in smpboot.c */
		pda->pcurrent = &init_task;
		pda->irqstackptr = boot_cpu_stack;
		pda->irqstackptr += IRQSTACKSIZE - 64;
	} else {
		if (!pda->irqstackptr) {
			pda->irqstackptr = (char *)
				__get_free_pages(GFP_ATOMIC, IRQSTACK_ORDER);
			if (!pda->irqstackptr)
				panic("cannot allocate irqstack for cpu %d",
				      cpu);
			pda->irqstackptr += IRQSTACKSIZE - 64;
		}

		if (pda->nodenumber == 0 && cpu_to_node(cpu) != NUMA_NO_NODE)
			pda->nodenumber = cpu_to_node(cpu);
	}
}

char boot_exception_stacks[(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ +
			   DEBUG_STKSZ] __page_aligned_bss;

extern asmlinkage void ignore_sysret(void);

/* May not be marked __init: used by software suspend */
void syscall_init(void)
{
	/*
	 * LSTAR and STAR live in a bit strange symbiosis.
	 * They both write to the same internal register. STAR allows to
	 * set CS/DS but only a 32bit target. LSTAR sets the 64bit rip.
	 */
	wrmsrl(MSR_STAR,  ((u64)__USER32_CS)<<48  | ((u64)__KERNEL_CS)<<32);
	wrmsrl(MSR_LSTAR, system_call);
	wrmsrl(MSR_CSTAR, ignore_sysret);

#ifdef CONFIG_IA32_EMULATION
	syscall32_cpu_init();
#endif

	/* Flags to clear on syscall */
	wrmsrl(MSR_SYSCALL_MASK,
	       X86_EFLAGS_TF|X86_EFLAGS_DF|X86_EFLAGS_IF|X86_EFLAGS_IOPL);
}

void __cpuinit check_efer(void)
{
	unsigned long efer;

	rdmsrl(MSR_EFER, efer);
	if (!(efer & EFER_NX) || do_not_nx)
		__supported_pte_mask &= ~_PAGE_NX;
}

unsigned long kernel_eflags;

/*
 * Copies of the original ist values from the tss are only accessed during
 * debugging, no special alignment required.
 */
DEFINE_PER_CPU(struct orig_ist, orig_ist);

#else

935
/* Make sure %fs is initialized properly in idle threads */
Adrian Bunk's avatar
Adrian Bunk committed
936
struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
937 938
{
	memset(regs, 0, sizeof(struct pt_regs));
939
	regs->fs = __KERNEL_PERCPU;
940 941
	return regs;
}
942
#endif
943

944 945 946 947 948
/*
 * cpu_init() initializes state that is per-CPU. Some data is already
 * initialized (naturally) in the bootstrap process, such as the GDT
 * and IDT. We reload them nevertheless, this function acts as a
 * 'CPU state barrier', nothing should get across.
949
 * A lot of state is already set up in PDA init for 64 bit
950
 */
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
#ifdef CONFIG_X86_64
void __cpuinit cpu_init(void)
{
	int cpu = stack_smp_processor_id();
	struct tss_struct *t = &per_cpu(init_tss, cpu);
	struct orig_ist *orig_ist = &per_cpu(orig_ist, cpu);
	unsigned long v;
	char *estacks = NULL;
	struct task_struct *me;
	int i;

	/* CPU 0 is initialised in head64.c */
	if (cpu != 0)
		pda_init(cpu);
	else
		estacks = boot_exception_stacks;

	me = current;

	if (cpu_test_and_set(cpu, cpu_initialized))
		panic("CPU#%d already initialized!\n", cpu);

	printk(KERN_INFO "Initializing CPU#%d\n", cpu);

	clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);

	/*
	 * Initialize the per-CPU GDT with the boot GDT,
	 * and set up the GDT descriptor:
	 */

	switch_to_new_gdt();
	load_idt((const struct desc_ptr *)&idt_descr);

	memset(me->thread.tls_array, 0, GDT_ENTRY_TLS_ENTRIES * 8);
	syscall_init();

	wrmsrl(MSR_FS_BASE, 0);
	wrmsrl(MSR_KERNEL_GS_BASE, 0);
	barrier();

	check_efer();
	if (cpu != 0 && x2apic)
		enable_x2apic();

	/*
	 * set up and load the per-CPU TSS
	 */
	if (!orig_ist->ist[0]) {
		static const unsigned int order[N_EXCEPTION_STACKS] = {
		  [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STACK_ORDER,
		  [DEBUG_STACK - 1] = DEBUG_STACK_ORDER
		};
		for (v = 0; v < N_EXCEPTION_STACKS; v++) {
			if (cpu) {
				estacks = (char *)__get_free_pages(GFP_ATOMIC, order[v]);
				if (!estacks)
					panic("Cannot allocate exception "
					      "stack %ld %d\n", v, cpu);
			}
			estacks += PAGE_SIZE << order[v];
			orig_ist->ist[v] = t->x86_tss.ist[v] =
					(unsigned long)estacks;
		}
	}

	t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);
	/*
	 * <= is required because the CPU will access up to
	 * 8 bits beyond the end of the IO permission bitmap.
	 */
	for (i = 0; i <= IO_BITMAP_LONGS; i++)
		t->io_bitmap[i] = ~0UL;

	atomic_inc(&init_mm.mm_count);
	me->active_mm = &init_mm;
	if (me->mm)
		BUG();
	enter_lazy_tlb(&init_mm, me);

	load_sp0(t, &current->thread);
	set_tss_desc(cpu, t);
	load_TR_desc();
	load_LDT(&init_mm.context);

#ifdef CONFIG_KGDB
	/*
	 * If the kgdb is connected no debug regs should be altered.  This
	 * is only applicable when KGDB and a KGDB I/O module are built
	 * into the kernel and you are using early debugging with
	 * kgdbwait. KGDB will control the kernel HW breakpoint registers.
	 */
	if (kgdb_connected && arch_kgdb_ops.correct_hw_break)
		arch_kgdb_ops.correct_hw_break();
	else {
#endif
	/*
	 * Clear all 6 debug registers:
	 */

	set_debugreg(0UL, 0);
	set_debugreg(0UL, 1);
	set_debugreg(0UL, 2);
	set_debugreg(0UL, 3);
	set_debugreg(0UL, 6);
	set_debugreg(0UL, 7);
#ifdef CONFIG_KGDB
	/* If the kgdb is connected no debug regs should be altered. */
	}
#endif

	fpu_init();

	raw_local_save_flags(kernel_eflags);

	if (is_uv_system())
		uv_cpu_init();
}

#else

1072
void __cpuinit cpu_init(void)
1073
{
1074 1075
	int cpu = smp_processor_id();
	struct task_struct *curr = current;
1076
	struct tss_struct *t = &per_cpu(init_tss, cpu);
1077
	struct thread_struct *thread = &curr->thread;
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088

	if (cpu_test_and_set(cpu, cpu_initialized)) {
		printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
		for (;;) local_irq_enable();
	}

	printk(KERN_INFO "Initializing CPU#%d\n", cpu);

	if (cpu_has_vme || cpu_has_tsc || cpu_has_de)
		clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);

1089
	load_idt(&idt_descr);
1090
	switch_to_new_gdt();
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092 1093 1094 1095

	/*
	 * Set up and load the per-CPU TSS and LDT
	 */
	atomic_inc(&init_mm.mm_count);
1096 1097 1098 1099
	curr->active_mm = &init_mm;
	if (curr->mm)
		BUG();
	enter_lazy_tlb(&init_mm, curr);
Linus Torvalds's avatar
Linus Torvalds committed
1100

1101
	load_sp0(t, thread);
1102
	set_tss_desc(cpu, t);
Linus Torvalds's avatar
Linus Torvalds committed
1103 1104 1105
	load_TR_desc();
	load_LDT(&init_mm.context);

1106
#ifdef CONFIG_DOUBLEFAULT
Linus Torvalds's avatar
Linus Torvalds committed
1107 1108
	/* Set up doublefault TSS pointer in the GDT */
	__set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
1109
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1110

1111 1112
	/* Clear %gs. */
	asm volatile ("mov %0, %%gs" : : "r" (0));
Linus Torvalds's avatar
Linus Torvalds committed
1113 1114

	/* Clear all 6 debug registers: */
1115 1116 1117 1118 1119 1120
	set_debugreg(0, 0);
	set_debugreg(0, 1);
	set_debugreg(0, 2);
	set_debugreg(0, 3);
	set_debugreg(0, 6);
	set_debugreg(0, 7);
Linus Torvalds's avatar
Linus Torvalds committed
1121 1122 1123 1124

	/*
	 * Force FPU initialization:
	 */
1125 1126 1127 1128
	if (cpu_has_xsave)
		current_thread_info()->status = TS_XSAVE;
	else
		current_thread_info()->status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1129 1130
	clear_used_math();
	mxcsr_feature_mask_init();
1131 1132 1133 1134 1135 1136 1137 1138

	/*
	 * Boot processor to setup the FP and extended state context info.
	 */
	if (!smp_processor_id())
		init_thread_xstate();

	xsave_init();
Linus Torvalds's avatar
Linus Torvalds committed
1139
}
1140 1141

#ifdef CONFIG_HOTPLUG_CPU
1142
void __cpuinit cpu_uninit(void)
1143 1144 1145 1146 1147 1148 1149 1150 1151
{
	int cpu = raw_smp_processor_id();
	cpu_clear(cpu, cpu_initialized);

	/* lazy TLB state */
	per_cpu(cpu_tlbstate, cpu).state = 0;
	per_cpu(cpu_tlbstate, cpu).active_mm = &init_mm;
}
#endif
1152 1153

#endif