2005-10-26 14:11:18 +07:00
|
|
|
/*
|
|
|
|
* Common boot and setup code for both 32-bit and 64-bit.
|
|
|
|
* Extracted from arch/powerpc/kernel/setup_64.c.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001 PPC64 Team, IBM Corp
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
2006-03-28 19:15:54 +07:00
|
|
|
|
|
|
|
#undef DEBUG
|
|
|
|
|
2011-07-23 05:24:23 +07:00
|
|
|
#include <linux/export.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/initrd.h>
|
2006-03-14 12:11:50 +07:00
|
|
|
#include <linux/platform_device.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/console.h>
|
2006-07-10 18:44:13 +07:00
|
|
|
#include <linux/screen_info.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <linux/root_dev.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/serial.h>
|
|
|
|
#include <linux/serial_8250.h>
|
2007-06-20 07:54:19 +07:00
|
|
|
#include <linux/debugfs.h>
|
2007-10-25 12:27:44 +07:00
|
|
|
#include <linux/percpu.h>
|
2010-07-12 11:36:09 +07:00
|
|
|
#include <linux/memblock.h>
|
2009-03-19 10:40:51 +07:00
|
|
|
#include <linux/of_platform.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <asm/io.h>
|
2010-01-28 20:23:22 +07:00
|
|
|
#include <asm/paca.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/processor.h>
|
2005-11-11 17:15:21 +07:00
|
|
|
#include <asm/vdso_datapage.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/elf.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/time.h>
|
|
|
|
#include <asm/cputable.h>
|
|
|
|
#include <asm/sections.h>
|
2006-03-28 19:15:54 +07:00
|
|
|
#include <asm/firmware.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#include <asm/btext.h>
|
|
|
|
#include <asm/nvram.h>
|
|
|
|
#include <asm/setup.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/rtas.h>
|
|
|
|
#include <asm/iommu.h>
|
|
|
|
#include <asm/serial.h>
|
|
|
|
#include <asm/cache.h>
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/mmu.h>
|
2005-11-08 18:55:08 +07:00
|
|
|
#include <asm/xmon.h>
|
2007-10-25 12:27:44 +07:00
|
|
|
#include <asm/cputhreads.h>
|
2008-10-15 15:25:28 +07:00
|
|
|
#include <mm/mmu_decl.h>
|
2012-02-16 08:14:45 +07:00
|
|
|
#include <asm/fadump.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
|
2005-11-09 07:01:06 +07:00
|
|
|
#include "setup.h"
|
|
|
|
|
2005-10-26 14:11:18 +07:00
|
|
|
#ifdef DEBUG
|
2005-11-15 11:16:38 +07:00
|
|
|
#include <asm/udbg.h>
|
2005-10-26 14:11:18 +07:00
|
|
|
#define DBG(fmt...) udbg_printf(fmt)
|
|
|
|
#else
|
|
|
|
#define DBG(fmt...)
|
|
|
|
#endif
|
|
|
|
|
2006-03-28 19:15:54 +07:00
|
|
|
/* The main machine-dep calls structure
|
|
|
|
*/
|
|
|
|
struct machdep_calls ppc_md;
|
|
|
|
EXPORT_SYMBOL(ppc_md);
|
|
|
|
struct machdep_calls *machine_id;
|
|
|
|
EXPORT_SYMBOL(machine_id);
|
2005-11-10 09:37:51 +07:00
|
|
|
|
2005-11-10 11:53:40 +07:00
|
|
|
unsigned long klimit = (unsigned long) _end;
|
|
|
|
|
2007-09-17 11:41:38 +07:00
|
|
|
char cmd_line[COMMAND_LINE_SIZE];
|
|
|
|
|
2005-10-26 14:11:18 +07:00
|
|
|
/*
|
|
|
|
* This still seems to be needed... -- paulus
|
|
|
|
*/
|
|
|
|
struct screen_info screen_info = {
|
|
|
|
.orig_x = 0,
|
|
|
|
.orig_y = 25,
|
|
|
|
.orig_video_cols = 80,
|
|
|
|
.orig_video_lines = 25,
|
|
|
|
.orig_video_isVGA = 1,
|
|
|
|
.orig_video_points = 16
|
|
|
|
};
|
|
|
|
|
2010-05-25 05:09:16 +07:00
|
|
|
/* Variables required to store legacy IO irq routing */
|
|
|
|
int of_i8042_kbd_irq;
|
2010-08-07 09:49:20 +07:00
|
|
|
EXPORT_SYMBOL_GPL(of_i8042_kbd_irq);
|
2010-05-25 05:09:16 +07:00
|
|
|
int of_i8042_aux_irq;
|
2010-08-07 09:49:20 +07:00
|
|
|
EXPORT_SYMBOL_GPL(of_i8042_aux_irq);
|
2010-05-25 05:09:16 +07:00
|
|
|
|
2005-10-26 14:11:18 +07:00
|
|
|
#ifdef __DO_IRQ_CANON
|
|
|
|
/* XXX should go elsewhere eventually */
|
|
|
|
int ppc_do_canonicalize_irqs;
|
|
|
|
EXPORT_SYMBOL(ppc_do_canonicalize_irqs);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* also used by kexec */
|
|
|
|
void machine_shutdown(void)
|
|
|
|
{
|
2012-02-16 08:15:15 +07:00
|
|
|
#ifdef CONFIG_FA_DUMP
|
|
|
|
/*
|
|
|
|
* if fadump is active, cleanup the fadump registration before we
|
|
|
|
* shutdown.
|
|
|
|
*/
|
|
|
|
fadump_cleanup();
|
|
|
|
#endif
|
|
|
|
|
[PATCH] powerpc: Merge kexec
This patch merges, to some extent, the PPC32 and PPC64 kexec implementations.
We adopt the PPC32 approach of having ppc_md callbacks for the kexec functions.
The current PPC64 implementation becomes the "default" implementation for PPC64
which platforms can select if they need no special treatment.
I've added these default callbacks to pseries/maple/cell/powermac, this means
iSeries no longer supports kexec - but it never worked anyway.
I've renamed PPC32's machine_kexec_simple to default_machine_kexec, inline with
PPC64. Judging by the comments it might be better named machine_kexec_non_of,
or something, but at the moment it's the only implementation for PPC32 so it's
the "default".
Kexec requires machine_shutdown(), which is in machine_kexec.c on PPC32, but we
already have in setup-common.c on powerpc. All this does is call
ppc_md.nvram_sync, which only powermac implements, so instead make
machine_shutdown a ppc_md member and have it call core99_nvram_sync directly
on powermac.
I've also stuck relocate_kernel.S into misc_32.S for powerpc.
Built for ARCH=ppc, and 32 & 64 bit ARCH=powerpc, with KEXEC=y/n. Booted on
P5 LPAR and successfully kexec'ed.
Should apply on top of 493f25ef4087395891c99fcfe2c72e62e293e89f.
Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-14 19:35:00 +07:00
|
|
|
if (ppc_md.machine_shutdown)
|
|
|
|
ppc_md.machine_shutdown();
|
2005-10-26 14:11:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void machine_restart(char *cmd)
|
|
|
|
{
|
|
|
|
machine_shutdown();
|
2006-01-13 23:15:17 +07:00
|
|
|
if (ppc_md.restart)
|
|
|
|
ppc_md.restart(cmd);
|
2005-10-26 14:11:18 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
smp_send_stop();
|
|
|
|
#endif
|
|
|
|
printk(KERN_EMERG "System Halted, OK to turn off power\n");
|
|
|
|
local_irq_disable();
|
|
|
|
while (1) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
void machine_power_off(void)
|
|
|
|
{
|
|
|
|
machine_shutdown();
|
2006-01-13 23:15:17 +07:00
|
|
|
if (ppc_md.power_off)
|
|
|
|
ppc_md.power_off();
|
2005-10-26 14:11:18 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
smp_send_stop();
|
|
|
|
#endif
|
|
|
|
printk(KERN_EMERG "System Halted, OK to turn off power\n");
|
|
|
|
local_irq_disable();
|
|
|
|
while (1) ;
|
|
|
|
}
|
|
|
|
/* Used by the G5 thermal driver */
|
|
|
|
EXPORT_SYMBOL_GPL(machine_power_off);
|
|
|
|
|
|
|
|
void (*pm_power_off)(void) = machine_power_off;
|
|
|
|
EXPORT_SYMBOL_GPL(pm_power_off);
|
|
|
|
|
|
|
|
void machine_halt(void)
|
|
|
|
{
|
|
|
|
machine_shutdown();
|
2006-01-13 23:15:17 +07:00
|
|
|
if (ppc_md.halt)
|
|
|
|
ppc_md.halt();
|
2005-10-26 14:11:18 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
smp_send_stop();
|
|
|
|
#endif
|
|
|
|
printk(KERN_EMERG "System Halted, OK to turn off power\n");
|
|
|
|
local_irq_disable();
|
|
|
|
while (1) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_TAU
|
|
|
|
extern u32 cpu_temp(unsigned long cpu);
|
|
|
|
extern u32 cpu_temp_both(unsigned long cpu);
|
|
|
|
#endif /* CONFIG_TAU */
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2009-10-29 20:34:14 +07:00
|
|
|
DEFINE_PER_CPU(unsigned int, cpu_pvr);
|
2005-10-26 14:11:18 +07:00
|
|
|
#endif
|
|
|
|
|
2010-04-26 22:32:39 +07:00
|
|
|
static void show_cpuinfo_summary(struct seq_file *m)
|
|
|
|
{
|
|
|
|
struct device_node *root;
|
|
|
|
const char *model = NULL;
|
|
|
|
#if defined(CONFIG_SMP) && defined(CONFIG_PPC32)
|
|
|
|
unsigned long bogosum = 0;
|
|
|
|
int i;
|
|
|
|
for_each_online_cpu(i)
|
|
|
|
bogosum += loops_per_jiffy;
|
|
|
|
seq_printf(m, "total bogomips\t: %lu.%02lu\n",
|
|
|
|
bogosum/(500000/HZ), bogosum/(5000/HZ) % 100);
|
|
|
|
#endif /* CONFIG_SMP && CONFIG_PPC32 */
|
|
|
|
seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);
|
|
|
|
if (ppc_md.name)
|
|
|
|
seq_printf(m, "platform\t: %s\n", ppc_md.name);
|
|
|
|
root = of_find_node_by_path("/");
|
|
|
|
if (root)
|
|
|
|
model = of_get_property(root, "model", NULL);
|
|
|
|
if (model)
|
|
|
|
seq_printf(m, "model\t\t: %s\n", model);
|
|
|
|
of_node_put(root);
|
|
|
|
|
|
|
|
if (ppc_md.show_cpuinfo != NULL)
|
|
|
|
ppc_md.show_cpuinfo(m);
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
/* Display the amount of memory */
|
|
|
|
seq_printf(m, "Memory\t\t: %d MB\n",
|
|
|
|
(unsigned int)(total_memory / (1024 * 1024)));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-10-26 14:11:18 +07:00
|
|
|
static int show_cpuinfo(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
unsigned long cpu_id = (unsigned long)v - 1;
|
|
|
|
unsigned int pvr;
|
|
|
|
unsigned short maj;
|
|
|
|
unsigned short min;
|
|
|
|
|
|
|
|
/* We only show online cpus: disable preempt (overzealous, I
|
|
|
|
* knew) to prevent cpu going down. */
|
|
|
|
preempt_disable();
|
|
|
|
if (!cpu_online(cpu_id)) {
|
|
|
|
preempt_enable();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2009-10-29 20:34:14 +07:00
|
|
|
pvr = per_cpu(cpu_pvr, cpu_id);
|
2005-10-26 14:11:18 +07:00
|
|
|
#else
|
|
|
|
pvr = mfspr(SPRN_PVR);
|
|
|
|
#endif
|
|
|
|
maj = (pvr >> 8) & 0xFF;
|
|
|
|
min = pvr & 0xFF;
|
|
|
|
|
|
|
|
seq_printf(m, "processor\t: %lu\n", cpu_id);
|
|
|
|
seq_printf(m, "cpu\t\t: ");
|
|
|
|
|
|
|
|
if (cur_cpu_spec->pvr_mask)
|
|
|
|
seq_printf(m, "%s", cur_cpu_spec->cpu_name);
|
|
|
|
else
|
|
|
|
seq_printf(m, "unknown (%08x)", pvr);
|
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
if (cpu_has_feature(CPU_FTR_ALTIVEC))
|
|
|
|
seq_printf(m, ", altivec supported");
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
|
|
|
|
seq_printf(m, "\n");
|
|
|
|
|
|
|
|
#ifdef CONFIG_TAU
|
|
|
|
if (cur_cpu_spec->cpu_features & CPU_FTR_TAU) {
|
|
|
|
#ifdef CONFIG_TAU_AVERAGE
|
|
|
|
/* more straightforward, but potentially misleading */
|
|
|
|
seq_printf(m, "temperature \t: %u C (uncalibrated)\n",
|
2005-11-02 11:06:22 +07:00
|
|
|
cpu_temp(cpu_id));
|
2005-10-26 14:11:18 +07:00
|
|
|
#else
|
|
|
|
/* show the actual temp sensor range */
|
|
|
|
u32 temp;
|
2005-11-02 11:06:22 +07:00
|
|
|
temp = cpu_temp_both(cpu_id);
|
2005-10-26 14:11:18 +07:00
|
|
|
seq_printf(m, "temperature \t: %u-%u C (uncalibrated)\n",
|
|
|
|
temp & 0xff, temp >> 16);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TAU */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Assume here that all clock rates are the same in a
|
|
|
|
* smp system. -- Cort
|
|
|
|
*/
|
|
|
|
if (ppc_proc_freq)
|
|
|
|
seq_printf(m, "clock\t\t: %lu.%06luMHz\n",
|
|
|
|
ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
|
|
|
|
|
|
|
|
if (ppc_md.show_percpuinfo != NULL)
|
|
|
|
ppc_md.show_percpuinfo(m, cpu_id);
|
|
|
|
|
|
|
|
/* If we are a Freescale core do a simple check so
|
|
|
|
* we dont have to keep adding cases in the future */
|
|
|
|
if (PVR_VER(pvr) & 0x8000) {
|
2008-09-07 14:51:32 +07:00
|
|
|
switch (PVR_VER(pvr)) {
|
|
|
|
case 0x8000: /* 7441/7450/7451, Voyager */
|
|
|
|
case 0x8001: /* 7445/7455, Apollo 6 */
|
|
|
|
case 0x8002: /* 7447/7457, Apollo 7 */
|
|
|
|
case 0x8003: /* 7447A, Apollo 7 PM */
|
|
|
|
case 0x8004: /* 7448, Apollo 8 */
|
|
|
|
case 0x800c: /* 7410, Nitro */
|
|
|
|
maj = ((pvr >> 8) & 0xF);
|
|
|
|
min = PVR_MIN(pvr);
|
|
|
|
break;
|
|
|
|
default: /* e500/book-e */
|
|
|
|
maj = PVR_MAJ(pvr);
|
|
|
|
min = PVR_MIN(pvr);
|
|
|
|
break;
|
|
|
|
}
|
2005-10-26 14:11:18 +07:00
|
|
|
} else {
|
|
|
|
switch (PVR_VER(pvr)) {
|
|
|
|
case 0x0020: /* 403 family */
|
|
|
|
maj = PVR_MAJ(pvr) + 1;
|
|
|
|
min = PVR_MIN(pvr);
|
|
|
|
break;
|
|
|
|
case 0x1008: /* 740P/750P ?? */
|
|
|
|
maj = ((pvr >> 8) & 0xFF) - 1;
|
|
|
|
min = pvr & 0xFF;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
maj = (pvr >> 8) & 0xFF;
|
|
|
|
min = pvr & 0xFF;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(m, "revision\t: %hd.%hd (pvr %04x %04x)\n",
|
|
|
|
maj, min, PVR_VER(pvr), PVR_REV(pvr));
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
seq_printf(m, "bogomips\t: %lu.%02lu\n",
|
|
|
|
loops_per_jiffy / (500000/HZ),
|
|
|
|
(loops_per_jiffy / (5000/HZ)) % 100);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
seq_printf(m, "\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
preempt_enable();
|
2010-04-26 22:32:40 +07:00
|
|
|
|
|
|
|
/* If this is the last cpu, print the summary */
|
|
|
|
if (cpumask_next(cpu_id, cpu_online_mask) >= nr_cpu_ids)
|
|
|
|
show_cpuinfo_summary(m);
|
|
|
|
|
2005-10-26 14:11:18 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *c_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
2010-04-26 22:32:40 +07:00
|
|
|
if (*pos == 0) /* just in case, cpu 0 is not the first */
|
|
|
|
*pos = cpumask_first(cpu_online_mask);
|
|
|
|
else
|
|
|
|
*pos = cpumask_next(*pos - 1, cpu_online_mask);
|
|
|
|
if ((*pos) < nr_cpu_ids)
|
|
|
|
return (void *)(unsigned long)(*pos + 1);
|
|
|
|
return NULL;
|
2005-10-26 14:11:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *c_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
2010-04-26 22:32:40 +07:00
|
|
|
(*pos)++;
|
2005-10-26 14:11:18 +07:00
|
|
|
return c_start(m, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void c_stop(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-09-23 06:43:43 +07:00
|
|
|
const struct seq_operations cpuinfo_op = {
|
2005-10-26 14:11:18 +07:00
|
|
|
.start =c_start,
|
|
|
|
.next = c_next,
|
|
|
|
.stop = c_stop,
|
|
|
|
.show = show_cpuinfo,
|
|
|
|
};
|
|
|
|
|
2005-11-03 05:34:20 +07:00
|
|
|
void __init check_for_initrd(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
2007-02-28 10:12:29 +07:00
|
|
|
DBG(" -> check_for_initrd() initrd_start=0x%lx initrd_end=0x%lx\n",
|
|
|
|
initrd_start, initrd_end);
|
2005-11-03 05:34:20 +07:00
|
|
|
|
|
|
|
/* If we were passed an initrd, set the ROOT_DEV properly if the values
|
|
|
|
* look sensible. If not, clear initrd reference.
|
|
|
|
*/
|
2005-12-04 14:39:15 +07:00
|
|
|
if (is_kernel_addr(initrd_start) && is_kernel_addr(initrd_end) &&
|
2005-11-03 05:34:20 +07:00
|
|
|
initrd_end > initrd_start)
|
|
|
|
ROOT_DEV = Root_RAM0;
|
2005-11-11 15:07:11 +07:00
|
|
|
else
|
2005-11-03 05:34:20 +07:00
|
|
|
initrd_start = initrd_end = 0;
|
|
|
|
|
|
|
|
if (initrd_start)
|
|
|
|
printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);
|
|
|
|
|
|
|
|
DBG(" <- check_for_initrd()\n");
|
|
|
|
#endif /* CONFIG_BLK_DEV_INITRD */
|
|
|
|
}
|
|
|
|
|
2005-11-05 06:33:55 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
2007-10-25 12:27:44 +07:00
|
|
|
int threads_per_core, threads_shift;
|
|
|
|
cpumask_t threads_core_mask;
|
KVM: PPC: Add support for Book3S processors in hypervisor mode
This adds support for KVM running on 64-bit Book 3S processors,
specifically POWER7, in hypervisor mode. Using hypervisor mode means
that the guest can use the processor's supervisor mode. That means
that the guest can execute privileged instructions and access privileged
registers itself without trapping to the host. This gives excellent
performance, but does mean that KVM cannot emulate a processor
architecture other than the one that the hardware implements.
This code assumes that the guest is running paravirtualized using the
PAPR (Power Architecture Platform Requirements) interface, which is the
interface that IBM's PowerVM hypervisor uses. That means that existing
Linux distributions that run on IBM pSeries machines will also run
under KVM without modification. In order to communicate the PAPR
hypercalls to qemu, this adds a new KVM_EXIT_PAPR_HCALL exit code
to include/linux/kvm.h.
Currently the choice between book3s_hv support and book3s_pr support
(i.e. the existing code, which runs the guest in user mode) has to be
made at kernel configuration time, so a given kernel binary can only
do one or the other.
This new book3s_hv code doesn't support MMIO emulation at present.
Since we are running paravirtualized guests, this isn't a serious
restriction.
With the guest running in supervisor mode, most exceptions go straight
to the guest. We will never get data or instruction storage or segment
interrupts, alignment interrupts, decrementer interrupts, program
interrupts, single-step interrupts, etc., coming to the hypervisor from
the guest. Therefore this introduces a new KVMTEST_NONHV macro for the
exception entry path so that we don't have to do the KVM test on entry
to those exception handlers.
We do however get hypervisor decrementer, hypervisor data storage,
hypervisor instruction storage, and hypervisor emulation assist
interrupts, so we have to handle those.
In hypervisor mode, real-mode accesses can access all of RAM, not just
a limited amount. Therefore we put all the guest state in the vcpu.arch
and use the shadow_vcpu in the PACA only for temporary scratch space.
We allocate the vcpu with kzalloc rather than vzalloc, and we don't use
anything in the kvmppc_vcpu_book3s struct, so we don't allocate it.
We don't have a shared page with the guest, but we still need a
kvm_vcpu_arch_shared struct to store the values of various registers,
so we include one in the vcpu_arch struct.
The POWER7 processor has a restriction that all threads in a core have
to be in the same partition. MMU-on kernel code counts as a partition
(partition 0), so we have to do a partition switch on every entry to and
exit from the guest. At present we require the host and guest to run
in single-thread mode because of this hardware restriction.
This code allocates a hashed page table for the guest and initializes
it with HPTEs for the guest's Virtual Real Memory Area (VRMA). We
require that the guest memory is allocated using 16MB huge pages, in
order to simplify the low-level memory management. This also means that
we can get away without tracking paging activity in the host for now,
since huge pages can't be paged or swapped.
This also adds a few new exports needed by the book3s_hv code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2011-06-29 07:21:34 +07:00
|
|
|
EXPORT_SYMBOL_GPL(threads_per_core);
|
|
|
|
EXPORT_SYMBOL_GPL(threads_shift);
|
|
|
|
EXPORT_SYMBOL_GPL(threads_core_mask);
|
2007-10-25 12:27:44 +07:00
|
|
|
|
|
|
|
static void __init cpu_init_thread_core_maps(int tpc)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
threads_per_core = tpc;
|
2011-04-28 12:07:23 +07:00
|
|
|
cpumask_clear(&threads_core_mask);
|
2007-10-25 12:27:44 +07:00
|
|
|
|
|
|
|
/* This implementation only supports power of 2 number of threads
|
|
|
|
* for simplicity and performance
|
|
|
|
*/
|
|
|
|
threads_shift = ilog2(tpc);
|
|
|
|
BUG_ON(tpc != (1 << threads_shift));
|
|
|
|
|
|
|
|
for (i = 0; i < tpc; i++)
|
2011-04-28 12:07:23 +07:00
|
|
|
cpumask_set_cpu(i, &threads_core_mask);
|
2007-10-25 12:27:44 +07:00
|
|
|
|
|
|
|
printk(KERN_INFO "CPU maps initialized for %d thread%s per core\n",
|
|
|
|
tpc, tpc > 1 ? "s" : "");
|
|
|
|
printk(KERN_DEBUG " (thread shift is %d)\n", threads_shift);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-11-05 06:33:55 +07:00
|
|
|
/**
|
|
|
|
* setup_cpu_maps - initialize the following cpu maps:
|
2010-04-26 22:32:44 +07:00
|
|
|
* cpu_possible_mask
|
|
|
|
* cpu_present_mask
|
2005-11-05 06:33:55 +07:00
|
|
|
*
|
|
|
|
* Having the possible map set up early allows us to restrict allocations
|
2011-05-11 02:28:48 +07:00
|
|
|
* of things like irqstacks to nr_cpu_ids rather than NR_CPUS.
|
2005-11-05 06:33:55 +07:00
|
|
|
*
|
|
|
|
* We do not initialize the online map here; cpus set their own bits in
|
2010-04-26 22:32:44 +07:00
|
|
|
* cpu_online_mask as they come up.
|
2005-11-05 06:33:55 +07:00
|
|
|
*
|
|
|
|
* This function is valid only for Open Firmware systems. finish_device_tree
|
|
|
|
* must be called before using this.
|
|
|
|
*
|
|
|
|
* While we're here, we may as well set the "physical" cpu ids in the paca.
|
2006-03-25 13:25:17 +07:00
|
|
|
*
|
|
|
|
* NOTE: This must match the parsing done in early_init_dt_scan_cpus.
|
2005-11-05 06:33:55 +07:00
|
|
|
*/
|
|
|
|
void __init smp_setup_cpu_maps(void)
|
|
|
|
{
|
|
|
|
struct device_node *dn = NULL;
|
|
|
|
int cpu = 0;
|
2007-10-25 12:27:44 +07:00
|
|
|
int nthreads = 1;
|
|
|
|
|
|
|
|
DBG("smp_setup_cpu_maps()\n");
|
2005-11-05 06:33:55 +07:00
|
|
|
|
2011-05-11 02:28:48 +07:00
|
|
|
while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < nr_cpu_ids) {
|
2006-07-12 12:35:54 +07:00
|
|
|
const int *intserv;
|
2007-10-25 12:27:44 +07:00
|
|
|
int j, len;
|
|
|
|
|
|
|
|
DBG(" * %s...\n", dn->full_name);
|
2005-11-05 06:33:55 +07:00
|
|
|
|
2007-04-03 19:26:41 +07:00
|
|
|
intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s",
|
|
|
|
&len);
|
2007-10-25 12:27:44 +07:00
|
|
|
if (intserv) {
|
2005-11-05 06:33:55 +07:00
|
|
|
nthreads = len / sizeof(int);
|
2007-10-25 12:27:44 +07:00
|
|
|
DBG(" ibm,ppc-interrupt-server#s -> %d threads\n",
|
|
|
|
nthreads);
|
|
|
|
} else {
|
|
|
|
DBG(" no ibm,ppc-interrupt-server#s -> 1 thread\n");
|
2007-04-03 19:26:41 +07:00
|
|
|
intserv = of_get_property(dn, "reg", NULL);
|
2005-11-05 06:33:55 +07:00
|
|
|
if (!intserv)
|
|
|
|
intserv = &cpu; /* assume logical == phys */
|
|
|
|
}
|
|
|
|
|
2011-05-11 02:28:48 +07:00
|
|
|
for (j = 0; j < nthreads && cpu < nr_cpu_ids; j++) {
|
2007-10-25 12:27:44 +07:00
|
|
|
DBG(" thread %d -> cpu %d (hard id %d)\n",
|
|
|
|
j, cpu, intserv[j]);
|
2009-09-24 22:34:48 +07:00
|
|
|
set_cpu_present(cpu, true);
|
2005-11-05 06:33:55 +07:00
|
|
|
set_hard_smp_processor_id(cpu, intserv[j]);
|
2009-09-24 22:34:48 +07:00
|
|
|
set_cpu_possible(cpu, true);
|
2005-11-05 06:33:55 +07:00
|
|
|
cpu++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-25 12:27:44 +07:00
|
|
|
/* If no SMT supported, nthreads is forced to 1 */
|
|
|
|
if (!cpu_has_feature(CPU_FTR_SMT)) {
|
|
|
|
DBG(" SMT disabled ! nthreads forced to 1\n");
|
|
|
|
nthreads = 1;
|
|
|
|
}
|
|
|
|
|
2005-11-05 06:33:55 +07:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
/*
|
|
|
|
* On pSeries LPAR, we need to know how many cpus
|
|
|
|
* could possibly be added to this partition.
|
|
|
|
*/
|
2006-03-28 19:15:54 +07:00
|
|
|
if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR) &&
|
2005-11-10 09:37:51 +07:00
|
|
|
(dn = of_find_node_by_path("/rtas"))) {
|
2005-11-05 06:33:55 +07:00
|
|
|
int num_addr_cell, num_size_cell, maxcpus;
|
2006-07-12 12:35:54 +07:00
|
|
|
const unsigned int *ireg;
|
2005-11-05 06:33:55 +07:00
|
|
|
|
2007-04-03 07:56:50 +07:00
|
|
|
num_addr_cell = of_n_addr_cells(dn);
|
2007-04-03 07:57:48 +07:00
|
|
|
num_size_cell = of_n_size_cells(dn);
|
2005-11-05 06:33:55 +07:00
|
|
|
|
2007-04-03 19:26:41 +07:00
|
|
|
ireg = of_get_property(dn, "ibm,lrdr-capacity", NULL);
|
2005-11-05 06:33:55 +07:00
|
|
|
|
|
|
|
if (!ireg)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
maxcpus = ireg[num_addr_cell + num_size_cell];
|
|
|
|
|
|
|
|
/* Double maxcpus for processors which have SMT capability */
|
|
|
|
if (cpu_has_feature(CPU_FTR_SMT))
|
2007-10-25 12:27:44 +07:00
|
|
|
maxcpus *= nthreads;
|
2005-11-05 06:33:55 +07:00
|
|
|
|
2011-05-11 02:28:48 +07:00
|
|
|
if (maxcpus > nr_cpu_ids) {
|
2005-11-05 06:33:55 +07:00
|
|
|
printk(KERN_WARNING
|
|
|
|
"Partition configured for %d cpus, "
|
|
|
|
"operating system maximum is %d.\n",
|
2011-05-11 02:28:48 +07:00
|
|
|
maxcpus, nr_cpu_ids);
|
|
|
|
maxcpus = nr_cpu_ids;
|
2005-11-05 06:33:55 +07:00
|
|
|
} else
|
|
|
|
printk(KERN_INFO "Partition configured for %d cpus.\n",
|
|
|
|
maxcpus);
|
|
|
|
|
|
|
|
for (cpu = 0; cpu < maxcpus; cpu++)
|
2009-09-24 22:34:48 +07:00
|
|
|
set_cpu_possible(cpu, true);
|
2005-11-05 06:33:55 +07:00
|
|
|
out:
|
|
|
|
of_node_put(dn);
|
|
|
|
}
|
2007-10-16 15:24:05 +07:00
|
|
|
vdso_data->processorCount = num_present_cpus();
|
|
|
|
#endif /* CONFIG_PPC64 */
|
2007-10-25 12:27:44 +07:00
|
|
|
|
|
|
|
/* Initialize CPU <=> thread mapping/
|
|
|
|
*
|
|
|
|
* WARNING: We assume that the number of threads is the same for
|
|
|
|
* every CPU in the system. If that is not the case, then some code
|
|
|
|
* here will have to be reworked
|
|
|
|
*/
|
|
|
|
cpu_init_thread_core_maps(nthreads);
|
2010-01-28 20:23:22 +07:00
|
|
|
|
2011-04-01 02:33:02 +07:00
|
|
|
/* Now that possible cpus are set, set nr_cpu_ids for later use */
|
2011-05-11 02:28:55 +07:00
|
|
|
setup_nr_cpu_ids();
|
2011-04-01 02:33:02 +07:00
|
|
|
|
2010-01-28 20:23:22 +07:00
|
|
|
free_unused_pacas();
|
2007-10-16 15:24:05 +07:00
|
|
|
}
|
2005-11-05 06:33:55 +07:00
|
|
|
#endif /* CONFIG_SMP */
|
2005-11-08 18:55:08 +07:00
|
|
|
|
2008-05-23 05:40:16 +07:00
|
|
|
#ifdef CONFIG_PCSPKR_PLATFORM
|
2006-03-14 12:11:50 +07:00
|
|
|
static __init int add_pcspkr(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct platform_device *pd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
np = of_find_compatible_node(NULL, NULL, "pnpPNP,100");
|
|
|
|
of_node_put(np);
|
|
|
|
if (!np)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
pd = platform_device_alloc("pcspkr", -1);
|
|
|
|
if (!pd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = platform_device_add(pd);
|
|
|
|
if (ret)
|
|
|
|
platform_device_put(pd);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
device_initcall(add_pcspkr);
|
2008-05-23 05:40:16 +07:00
|
|
|
#endif /* CONFIG_PCSPKR_PLATFORM */
|
2006-04-02 12:08:05 +07:00
|
|
|
|
2006-03-28 19:15:54 +07:00
|
|
|
void probe_machine(void)
|
|
|
|
{
|
|
|
|
extern struct machdep_calls __machine_desc_start;
|
|
|
|
extern struct machdep_calls __machine_desc_end;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Iterate all ppc_md structures until we find the proper
|
|
|
|
* one for the current machine type
|
|
|
|
*/
|
|
|
|
DBG("Probing machine type ...\n");
|
|
|
|
|
|
|
|
for (machine_id = &__machine_desc_start;
|
|
|
|
machine_id < &__machine_desc_end;
|
|
|
|
machine_id++) {
|
|
|
|
DBG(" %s ...", machine_id->name);
|
|
|
|
memcpy(&ppc_md, machine_id, sizeof(struct machdep_calls));
|
|
|
|
if (ppc_md.probe()) {
|
|
|
|
DBG(" match !\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
DBG("\n");
|
|
|
|
}
|
|
|
|
/* What can we do if we didn't find ? */
|
|
|
|
if (machine_id >= &__machine_desc_end) {
|
|
|
|
DBG("No suitable machine found !\n");
|
|
|
|
for (;;);
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO "Using %s machine description\n", ppc_md.name);
|
|
|
|
}
|
2006-04-25 05:22:17 +07:00
|
|
|
|
2007-04-26 03:36:56 +07:00
|
|
|
/* Match a class of boards, not a specific device configuration. */
|
2006-04-25 05:22:17 +07:00
|
|
|
int check_legacy_ioport(unsigned long base_port)
|
|
|
|
{
|
2007-04-26 03:36:56 +07:00
|
|
|
struct device_node *parent, *np = NULL;
|
|
|
|
int ret = -ENODEV;
|
|
|
|
|
|
|
|
switch(base_port) {
|
|
|
|
case I8042_DATA_REG:
|
2007-06-20 07:15:10 +07:00
|
|
|
if (!(np = of_find_compatible_node(NULL, NULL, "pnpPNP,303")))
|
|
|
|
np = of_find_compatible_node(NULL, NULL, "pnpPNP,f03");
|
|
|
|
if (np) {
|
|
|
|
parent = of_get_parent(np);
|
2010-05-25 05:09:16 +07:00
|
|
|
|
|
|
|
of_i8042_kbd_irq = irq_of_parse_and_map(parent, 0);
|
|
|
|
if (!of_i8042_kbd_irq)
|
|
|
|
of_i8042_kbd_irq = 1;
|
|
|
|
|
|
|
|
of_i8042_aux_irq = irq_of_parse_and_map(parent, 1);
|
|
|
|
if (!of_i8042_aux_irq)
|
|
|
|
of_i8042_aux_irq = 12;
|
|
|
|
|
2007-06-20 07:15:10 +07:00
|
|
|
of_node_put(np);
|
|
|
|
np = parent;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-26 03:36:56 +07:00
|
|
|
np = of_find_node_by_type(NULL, "8042");
|
2007-07-25 08:28:32 +07:00
|
|
|
/* Pegasos has no device_type on its 8042 node, look for the
|
|
|
|
* name instead */
|
|
|
|
if (!np)
|
|
|
|
np = of_find_node_by_name(NULL, "8042");
|
2011-05-13 08:03:13 +07:00
|
|
|
if (np) {
|
|
|
|
of_i8042_kbd_irq = 1;
|
|
|
|
of_i8042_aux_irq = 12;
|
|
|
|
}
|
2007-04-26 03:36:56 +07:00
|
|
|
break;
|
|
|
|
case FDC_BASE: /* FDC1 */
|
|
|
|
np = of_find_node_by_type(NULL, "fdc");
|
|
|
|
break;
|
|
|
|
#ifdef CONFIG_PPC_PREP
|
|
|
|
case _PIDXR:
|
|
|
|
case _PNPWRP:
|
|
|
|
case PNPBIOS_BASE:
|
|
|
|
/* implement me */
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
/* ipmi is supposed to fail here */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!np)
|
|
|
|
return ret;
|
|
|
|
parent = of_get_parent(np);
|
|
|
|
if (parent) {
|
|
|
|
if (strcmp(parent->type, "isa") == 0)
|
|
|
|
ret = 0;
|
|
|
|
of_node_put(parent);
|
|
|
|
}
|
|
|
|
of_node_put(np);
|
|
|
|
return ret;
|
2006-04-25 05:22:17 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(check_legacy_ioport);
|
2006-05-05 12:02:08 +07:00
|
|
|
|
|
|
|
static int ppc_panic_event(struct notifier_block *this,
|
|
|
|
unsigned long event, void *ptr)
|
|
|
|
{
|
2012-02-16 08:14:45 +07:00
|
|
|
/*
|
|
|
|
* If firmware-assisted dump has been registered then trigger
|
|
|
|
* firmware-assisted dump and let firmware handle everything else.
|
|
|
|
*/
|
|
|
|
crash_fadump(NULL, ptr);
|
2006-05-05 12:02:08 +07:00
|
|
|
ppc_md.panic(ptr); /* May not return */
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block ppc_panic_block = {
|
|
|
|
.notifier_call = ppc_panic_event,
|
|
|
|
.priority = INT_MIN /* may not return; must be done last */
|
|
|
|
};
|
|
|
|
|
|
|
|
void __init setup_panic(void)
|
|
|
|
{
|
|
|
|
atomic_notifier_chain_register(&panic_notifier_list, &ppc_panic_block);
|
|
|
|
}
|
2007-05-12 07:57:35 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_CHECK_CACHE_COHERENCY
|
|
|
|
/*
|
|
|
|
* For platforms that have configurable cache-coherency. This function
|
|
|
|
* checks that the cache coherency setting of the kernel matches the setting
|
|
|
|
* left by the firmware, as indicated in the device tree. Since a mismatch
|
|
|
|
* will eventually result in DMA failures, we print * and error and call
|
|
|
|
* BUG() in that case.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NOT_COHERENT_CACHE
|
|
|
|
#define KERNEL_COHERENCY 0
|
|
|
|
#else
|
|
|
|
#define KERNEL_COHERENCY 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int __init check_cache_coherency(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
const void *prop;
|
|
|
|
int devtree_coherency;
|
|
|
|
|
|
|
|
np = of_find_node_by_path("/");
|
|
|
|
prop = of_get_property(np, "coherency-off", NULL);
|
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
devtree_coherency = prop ? 0 : 1;
|
|
|
|
|
|
|
|
if (devtree_coherency != KERNEL_COHERENCY) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"kernel coherency:%s != device tree_coherency:%s\n",
|
|
|
|
KERNEL_COHERENCY ? "on" : "off",
|
|
|
|
devtree_coherency ? "on" : "off");
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(check_cache_coherency);
|
|
|
|
#endif /* CONFIG_CHECK_CACHE_COHERENCY */
|
2007-06-20 07:54:19 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *powerpc_debugfs_root;
|
2009-10-27 01:52:24 +07:00
|
|
|
EXPORT_SYMBOL(powerpc_debugfs_root);
|
2007-06-20 07:54:19 +07:00
|
|
|
|
|
|
|
static int powerpc_debugfs_init(void)
|
|
|
|
{
|
|
|
|
powerpc_debugfs_root = debugfs_create_dir("powerpc", NULL);
|
|
|
|
|
|
|
|
return powerpc_debugfs_root == NULL;
|
|
|
|
}
|
|
|
|
arch_initcall(powerpc_debugfs_init);
|
|
|
|
#endif
|
2009-03-19 10:40:51 +07:00
|
|
|
|
2011-06-18 14:36:40 +07:00
|
|
|
void ppc_printk_progress(char *s, unsigned short hex)
|
2009-03-19 10:40:51 +07:00
|
|
|
{
|
2011-06-18 14:36:40 +07:00
|
|
|
pr_info("%s\n", s);
|
2009-03-19 10:40:51 +07:00
|
|
|
}
|
|
|
|
|
2011-07-08 12:17:27 +07:00
|
|
|
void arch_setup_pdev_archdata(struct platform_device *pdev)
|
2009-03-19 10:40:51 +07:00
|
|
|
{
|
2011-07-08 12:17:27 +07:00
|
|
|
pdev->archdata.dma_mask = DMA_BIT_MASK(32);
|
|
|
|
pdev->dev.dma_mask = &pdev->archdata.dma_mask;
|
|
|
|
set_dma_ops(&pdev->dev, &dma_direct_ops);
|
2009-03-19 10:40:51 +07:00
|
|
|
}
|