diff --git a/tools/kvm/Makefile b/tools/kvm/Makefile index dc18959..0f24104 100644 --- a/tools/kvm/Makefile +++ b/tools/kvm/Makefile @@ -128,6 +128,8 @@ ifeq ($(uname_M), ppc64) OBJS += powerpc/irq.o OBJS += powerpc/kvm.o OBJS += powerpc/kvm-cpu.o + OBJS += powerpc/spapr_hcall.o + OBJS += powerpc/spapr_rtas.o ARCH_INCLUDE := powerpc/include CFLAGS += -m64 LIBS += -lfdt diff --git a/tools/kvm/powerpc/kvm-cpu.c b/tools/kvm/powerpc/kvm-cpu.c index 79422ff..71c648e 100644 --- a/tools/kvm/powerpc/kvm-cpu.c +++ b/tools/kvm/powerpc/kvm-cpu.c @@ -14,6 +14,8 @@ #include "kvm/util.h" #include "kvm/kvm.h" +#include "spapr.h" + #include #include #include @@ -156,6 +158,9 @@ bool kvm_cpu__handle_exit(struct kvm_cpu *vcpu) bool ret = true; struct kvm_run *run = vcpu->kvm_run; switch(run->exit_reason) { + case KVM_EXIT_PAPR_HCALL: + run->papr_hcall.ret = spapr_hypercall(vcpu, run->papr_hcall.nr, run->papr_hcall.args); + break; default: ret = false; } diff --git a/tools/kvm/powerpc/kvm.c b/tools/kvm/powerpc/kvm.c index d792bee..2f0a921 100644 --- a/tools/kvm/powerpc/kvm.c +++ b/tools/kvm/powerpc/kvm.c @@ -14,6 +14,8 @@ #include "kvm/kvm.h" #include "kvm/util.h" +#include "spapr.h" + #include #include @@ -153,6 +155,10 @@ void kvm__arch_init(struct kvm *kvm, const char *kvm_dev, const char *hugetlbfs_ cap_ppc_rma = ioctl(kvm->sys_fd, KVM_CHECK_EXTENSION, KVM_CAP_PPC_RMA); if (cap_ppc_rma == 2) die("Need contiguous RMA allocation on this hardware, which is not yet supported."); + + /* Do these before FDT setup, IRQ setup, etc. */ + hypercall_init(); + register_core_rtas(); } void kvm__irq_line(struct kvm *kvm, int irq, int level) @@ -262,6 +268,20 @@ static void setup_fdt(struct kvm *kvm) _FDT(fdt_property_cell(fdt, "#address-cells", 0x2)); _FDT(fdt_property_cell(fdt, "#size-cells", 0x2)); + /* RTAS */ + _FDT(fdt_begin_node(fdt, "rtas")); + /* This is what the kernel uses to switch 'We're an LPAR'! */ + _FDT(fdt_property(fdt, "ibm,hypertas-functions", hypertas_prop_kvm, + sizeof(hypertas_prop_kvm))); + _FDT(fdt_property_cell(fdt, "linux,rtas-base", kvm->rtas_gra)); + _FDT(fdt_property_cell(fdt, "linux,rtas-entry", kvm->rtas_gra)); + _FDT(fdt_property_cell(fdt, "rtas-size", kvm->rtas_size)); + /* Now add properties for all RTAS tokens: */ + if (spapr_rtas_fdt_setup(kvm, fdt)) + die("Couldn't create RTAS FDT properties\n"); + + _FDT(fdt_end_node(fdt)); + /* /chosen */ _FDT(fdt_begin_node(fdt, "chosen")); /* cmdline */ @@ -363,7 +383,24 @@ static void setup_fdt(struct kvm *kvm) */ void kvm__arch_setup_firmware(struct kvm *kvm) { - /* Load RTAS */ + /* Set up RTAS stub. All it is is a single hypercall: + 0: 7c 64 1b 78 mr r4,r3 + 4: 3c 60 00 00 lis r3,0 + 8: 60 63 f0 00 ori r3,r3,61440 + c: 44 00 00 22 sc 1 + 10: 4e 80 00 20 blr + */ + uint32_t *rtas = guest_flat_to_host(kvm, kvm->rtas_gra); + + rtas[0] = 0x7c641b78; + rtas[1] = 0x3c600000; + rtas[2] = 0x6063f000; + rtas[3] = 0x44000022; + rtas[4] = 0x4e800020; + kvm->rtas_size = 20; + + pr_info("Set up %ld bytes of RTAS at 0x%lx\n", + kvm->rtas_size, kvm->rtas_gra); /* Load SLOF */ diff --git a/tools/kvm/powerpc/spapr.h b/tools/kvm/powerpc/spapr.h new file mode 100644 index 0000000..4e5d7bd --- /dev/null +++ b/tools/kvm/powerpc/spapr.h @@ -0,0 +1,308 @@ +/* + * SPAPR definitions and declarations + * + * Borrowed heavily from QEMU's spapr.h, + * Copyright (c) 2010 David Gibson, IBM Corporation. + * + * Modifications by Matt Evans , IBM Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published + * by the Free Software Foundation. + */ + +#if !defined(__HW_SPAPR_H__) +#define __HW_SPAPR_H__ + +#include +#include "kvm/kvm.h" +#include "kvm/kvm-cpu.h" + +typedef unsigned long target_ulong; +typedef uintptr_t target_phys_addr_t; + + +#define H_SUCCESS 0 +#define H_BUSY 1 /* Hardware busy -- retry later */ +#define H_CLOSED 2 /* Resource closed */ +#define H_NOT_AVAILABLE 3 +#define H_CONSTRAINED 4 /* Resource request constrained to max allowed */ +#define H_PARTIAL 5 +#define H_IN_PROGRESS 14 /* Kind of like busy */ +#define H_PAGE_REGISTERED 15 +#define H_PARTIAL_STORE 16 +#define H_PENDING 17 /* returned from H_POLL_PENDING */ +#define H_CONTINUE 18 /* Returned from H_Join on success */ +#define H_LONG_BUSY_START_RANGE 9900 /* Start of long busy range */ +#define H_LONG_BUSY_ORDER_1_MSEC 9900 /* Long busy, hint that 1msec \ + is a good time to retry */ +#define H_LONG_BUSY_ORDER_10_MSEC 9901 /* Long busy, hint that 10msec \ + is a good time to retry */ +#define H_LONG_BUSY_ORDER_100_MSEC 9902 /* Long busy, hint that 100msec \ + is a good time to retry */ +#define H_LONG_BUSY_ORDER_1_SEC 9903 /* Long busy, hint that 1sec \ + is a good time to retry */ +#define H_LONG_BUSY_ORDER_10_SEC 9904 /* Long busy, hint that 10sec \ + is a good time to retry */ +#define H_LONG_BUSY_ORDER_100_SEC 9905 /* Long busy, hint that 100sec \ + is a good time to retry */ +#define H_LONG_BUSY_END_RANGE 9905 /* End of long busy range */ +#define H_HARDWARE -1 /* Hardware error */ +#define H_FUNCTION -2 /* Function not supported */ +#define H_PRIVILEGE -3 /* Caller not privileged */ +#define H_PARAMETER -4 /* Parameter invalid, out-of-range or conflicting */ +#define H_BAD_MODE -5 /* Illegal msr value */ +#define H_PTEG_FULL -6 /* PTEG is full */ +#define H_NOT_FOUND -7 /* PTE was not found" */ +#define H_RESERVED_DABR -8 /* DABR address is reserved by the hypervisor on this processor" */ +#define H_NO_MEM -9 +#define H_AUTHORITY -10 +#define H_PERMISSION -11 +#define H_DROPPED -12 +#define H_SOURCE_PARM -13 +#define H_DEST_PARM -14 +#define H_REMOTE_PARM -15 +#define H_RESOURCE -16 +#define H_ADAPTER_PARM -17 +#define H_RH_PARM -18 +#define H_RCQ_PARM -19 +#define H_SCQ_PARM -20 +#define H_EQ_PARM -21 +#define H_RT_PARM -22 +#define H_ST_PARM -23 +#define H_SIGT_PARM -24 +#define H_TOKEN_PARM -25 +#define H_MLENGTH_PARM -27 +#define H_MEM_PARM -28 +#define H_MEM_ACCESS_PARM -29 +#define H_ATTR_PARM -30 +#define H_PORT_PARM -31 +#define H_MCG_PARM -32 +#define H_VL_PARM -33 +#define H_TSIZE_PARM -34 +#define H_TRACE_PARM -35 + +#define H_MASK_PARM -37 +#define H_MCG_FULL -38 +#define H_ALIAS_EXIST -39 +#define H_P_COUNTER -40 +#define H_TABLE_FULL -41 +#define H_ALT_TABLE -42 +#define H_MR_CONDITION -43 +#define H_NOT_ENOUGH_RESOURCES -44 +#define H_R_STATE -45 +#define H_RESCINDEND -46 +#define H_MULTI_THREADS_ACTIVE -9005 + + +/* Long Busy is a condition that can be returned by the firmware + * when a call cannot be completed now, but the identical call + * should be retried later. This prevents calls blocking in the + * firmware for long periods of time. Annoyingly the firmware can return + * a range of return codes, hinting at how long we should wait before + * retrying. If you don't care for the hint, the macro below is a good + * way to check for the long_busy return codes + */ +#define H_IS_LONG_BUSY(x) ((x >= H_LONG_BUSY_START_RANGE) \ + && (x <= H_LONG_BUSY_END_RANGE)) + +/* Flags */ +#define H_LARGE_PAGE (1ULL<<(63-16)) +#define H_EXACT (1ULL<<(63-24)) /* Use exact PTE or return H_PTEG_FULL */ +#define H_R_XLATE (1ULL<<(63-25)) /* include a valid logical page num in the pte if the valid bit is set */ +#define H_READ_4 (1ULL<<(63-26)) /* Return 4 PTEs */ +#define H_PAGE_STATE_CHANGE (1ULL<<(63-28)) +#define H_PAGE_UNUSED ((1ULL<<(63-29)) | (1ULL<<(63-30))) +#define H_PAGE_SET_UNUSED (H_PAGE_STATE_CHANGE | H_PAGE_UNUSED) +#define H_PAGE_SET_LOANED (H_PAGE_SET_UNUSED | (1ULL<<(63-31))) +#define H_PAGE_SET_ACTIVE H_PAGE_STATE_CHANGE +#define H_AVPN (1ULL<<(63-32)) /* An avpn is provided as a sanity test */ +#define H_ANDCOND (1ULL<<(63-33)) +#define H_ICACHE_INVALIDATE (1ULL<<(63-40)) /* icbi, etc. (ignored for IO pages) */ +#define H_ICACHE_SYNCHRONIZE (1ULL<<(63-41)) /* dcbst, icbi, etc (ignored for IO pages */ +#define H_ZERO_PAGE (1ULL<<(63-48)) /* zero the page before mapping (ignored for IO pages) */ +#define H_COPY_PAGE (1ULL<<(63-49)) +#define H_N (1ULL<<(63-61)) +#define H_PP1 (1ULL<<(63-62)) +#define H_PP2 (1ULL<<(63-63)) + +/* VASI States */ +#define H_VASI_INVALID 0 +#define H_VASI_ENABLED 1 +#define H_VASI_ABORTED 2 +#define H_VASI_SUSPENDING 3 +#define H_VASI_SUSPENDED 4 +#define H_VASI_RESUMED 5 +#define H_VASI_COMPLETED 6 + +/* DABRX flags */ +#define H_DABRX_HYPERVISOR (1ULL<<(63-61)) +#define H_DABRX_KERNEL (1ULL<<(63-62)) +#define H_DABRX_USER (1ULL<<(63-63)) + +/* Each control block has to be on a 4K bondary */ +#define H_CB_ALIGNMENT 4096 + +/* pSeries hypervisor opcodes */ +#define H_REMOVE 0x04 +#define H_ENTER 0x08 +#define H_READ 0x0c +#define H_CLEAR_MOD 0x10 +#define H_CLEAR_REF 0x14 +#define H_PROTECT 0x18 +#define H_GET_TCE 0x1c +#define H_PUT_TCE 0x20 +#define H_SET_SPRG0 0x24 +#define H_SET_DABR 0x28 +#define H_PAGE_INIT 0x2c +#define H_SET_ASR 0x30 +#define H_ASR_ON 0x34 +#define H_ASR_OFF 0x38 +#define H_LOGICAL_CI_LOAD 0x3c +#define H_LOGICAL_CI_STORE 0x40 +#define H_LOGICAL_CACHE_LOAD 0x44 +#define H_LOGICAL_CACHE_STORE 0x48 +#define H_LOGICAL_ICBI 0x4c +#define H_LOGICAL_DCBF 0x50 +#define H_GET_TERM_CHAR 0x54 +#define H_PUT_TERM_CHAR 0x58 +#define H_REAL_TO_LOGICAL 0x5c +#define H_HYPERVISOR_DATA 0x60 +#define H_EOI 0x64 +#define H_CPPR 0x68 +#define H_IPI 0x6c +#define H_IPOLL 0x70 +#define H_XIRR 0x74 +#define H_PERFMON 0x7c +#define H_MIGRATE_DMA 0x78 +#define H_REGISTER_VPA 0xDC +#define H_CEDE 0xE0 +#define H_CONFER 0xE4 +#define H_PROD 0xE8 +#define H_GET_PPP 0xEC +#define H_SET_PPP 0xF0 +#define H_PURR 0xF4 +#define H_PIC 0xF8 +#define H_REG_CRQ 0xFC +#define H_FREE_CRQ 0x100 +#define H_VIO_SIGNAL 0x104 +#define H_SEND_CRQ 0x108 +#define H_COPY_RDMA 0x110 +#define H_REGISTER_LOGICAL_LAN 0x114 +#define H_FREE_LOGICAL_LAN 0x118 +#define H_ADD_LOGICAL_LAN_BUFFER 0x11C +#define H_SEND_LOGICAL_LAN 0x120 +#define H_BULK_REMOVE 0x124 +#define H_MULTICAST_CTRL 0x130 +#define H_SET_XDABR 0x134 +#define H_STUFF_TCE 0x138 +#define H_PUT_TCE_INDIRECT 0x13C +#define H_CHANGE_LOGICAL_LAN_MAC 0x14C +#define H_VTERM_PARTNER_INFO 0x150 +#define H_REGISTER_VTERM 0x154 +#define H_FREE_VTERM 0x158 +#define H_RESET_EVENTS 0x15C +#define H_ALLOC_RESOURCE 0x160 +#define H_FREE_RESOURCE 0x164 +#define H_MODIFY_QP 0x168 +#define H_QUERY_QP 0x16C +#define H_REREGISTER_PMR 0x170 +#define H_REGISTER_SMR 0x174 +#define H_QUERY_MR 0x178 +#define H_QUERY_MW 0x17C +#define H_QUERY_HCA 0x180 +#define H_QUERY_PORT 0x184 +#define H_MODIFY_PORT 0x188 +#define H_DEFINE_AQP1 0x18C +#define H_GET_TRACE_BUFFER 0x190 +#define H_DEFINE_AQP0 0x194 +#define H_RESIZE_MR 0x198 +#define H_ATTACH_MCQP 0x19C +#define H_DETACH_MCQP 0x1A0 +#define H_CREATE_RPT 0x1A4 +#define H_REMOVE_RPT 0x1A8 +#define H_REGISTER_RPAGES 0x1AC +#define H_DISABLE_AND_GETC 0x1B0 +#define H_ERROR_DATA 0x1B4 +#define H_GET_HCA_INFO 0x1B8 +#define H_GET_PERF_COUNT 0x1BC +#define H_MANAGE_TRACE 0x1C0 +#define H_FREE_LOGICAL_LAN_BUFFER 0x1D4 +#define H_QUERY_INT_STATE 0x1E4 +#define H_POLL_PENDING 0x1D8 +#define H_ILLAN_ATTRIBUTES 0x244 +#define H_MODIFY_HEA_QP 0x250 +#define H_QUERY_HEA_QP 0x254 +#define H_QUERY_HEA 0x258 +#define H_QUERY_HEA_PORT 0x25C +#define H_MODIFY_HEA_PORT 0x260 +#define H_REG_BCMC 0x264 +#define H_DEREG_BCMC 0x268 +#define H_REGISTER_HEA_RPAGES 0x26C +#define H_DISABLE_AND_GET_HEA 0x270 +#define H_GET_HEA_INFO 0x274 +#define H_ALLOC_HEA_RESOURCE 0x278 +#define H_ADD_CONN 0x284 +#define H_DEL_CONN 0x288 +#define H_JOIN 0x298 +#define H_VASI_STATE 0x2A4 +#define H_ENABLE_CRQ 0x2B0 +#define H_GET_EM_PARMS 0x2B8 +#define H_SET_MPP 0x2D0 +#define H_GET_MPP 0x2D4 +#define MAX_HCALL_OPCODE H_GET_MPP + +/* The hcalls above are standardized in PAPR and implemented by pHyp + * as well. + * + * We also need some hcalls which are specific to qemu / KVM-on-POWER. + * So far we just need one for H_RTAS, but in future we'll need more + * for extensions like virtio. We put those into the 0xf000-0xfffc + * range which is reserved by PAPR for "platform-specific" hcalls. + */ +#define KVMPPC_HCALL_BASE 0xf000 +#define KVMPPC_H_RTAS (KVMPPC_HCALL_BASE + 0x0) +#define KVMPPC_HCALL_MAX KVMPPC_H_RTAS + +#define DEBUG_SPAPR_HCALLS + +#ifdef DEBUG_SPAPR_HCALLS +#define hcall_dprintf(fmt, ...) \ + do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) +#else +#define hcall_dprintf(fmt, ...) \ + do { } while (0) +#endif + +typedef target_ulong (*spapr_hcall_fn)(struct kvm_cpu *vcpu, + target_ulong opcode, + target_ulong *args); + +void hypercall_init(void); +void register_core_rtas(void); + +void spapr_register_hypercall(target_ulong opcode, spapr_hcall_fn fn); +target_ulong spapr_hypercall(struct kvm_cpu *vcpu, target_ulong opcode, + target_ulong *args); + +int spapr_rtas_fdt_setup(struct kvm *kvm, void *fdt); + +static inline uint32_t rtas_ld(struct kvm *kvm, target_ulong phys, int n) +{ + return *((uint32_t *)guest_flat_to_host(kvm, phys + 4*n)); +} + +static inline void rtas_st(struct kvm *kvm, target_ulong phys, int n, uint32_t val) +{ + *((uint32_t *)guest_flat_to_host(kvm, phys + 4*n)) = val; +} + +typedef void (*spapr_rtas_fn)(struct kvm_cpu *vcpu, uint32_t token, + uint32_t nargs, target_ulong args, + uint32_t nret, target_ulong rets); +void spapr_rtas_register(const char *name, spapr_rtas_fn fn); +target_ulong spapr_rtas_call(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, target_ulong args, + uint32_t nret, target_ulong rets); + +#endif /* !defined (__HW_SPAPR_H__) */ diff --git a/tools/kvm/powerpc/spapr_hcall.c b/tools/kvm/powerpc/spapr_hcall.c new file mode 100644 index 0000000..825efb9 --- /dev/null +++ b/tools/kvm/powerpc/spapr_hcall.c @@ -0,0 +1,151 @@ +/* + * SPAPR hypercalls + * + * Borrowed heavily from QEMU's spapr_hcall.c, + * Copyright (c) 2010 David Gibson, IBM Corporation. + * + * Copyright (c) 2011 Matt Evans , IBM Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published + * by the Free Software Foundation. + */ + +#include "spapr.h" +#include "kvm/util.h" +#include "kvm/kvm.h" +#include "kvm/kvm-cpu.h" + +#include +#include + + +static target_ulong h_set_dabr(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + pr_warning("Implement %s!\n", __PRETTY_FUNCTION__); + return H_HARDWARE; +} + +static target_ulong h_register_vpa(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + pr_warning("Implement %s!\n", __PRETTY_FUNCTION__); + return H_SUCCESS; +} + +static target_ulong h_cede(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + pr_warning("Implement %s!\n", __PRETTY_FUNCTION__); + return H_SUCCESS; +} + +static target_ulong h_rtas(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + target_ulong rtas_r3 = args[0]; + /* Pointer read from phys mem; I hereby state these can't be MMIO... + * so just referencing memory directly. + */ + uint32_t token, nargs, nret; + + token = rtas_ld(vcpu->kvm, rtas_r3, 0); + nargs = rtas_ld(vcpu->kvm, rtas_r3, 1); + nret = rtas_ld(vcpu->kvm, rtas_r3, 2); + + return spapr_rtas_call(vcpu, token, nargs, rtas_r3 + 12, + nret, rtas_r3 + 12 + 4*nargs); +} + +static target_ulong h_logical_load(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + /* SLOF will require these, though kernel doesn't. */ + die(__PRETTY_FUNCTION__); + return H_PARAMETER; +} + +static target_ulong h_logical_store(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + /* SLOF will require these, though kernel doesn't. */ + die(__PRETTY_FUNCTION__); + return H_PARAMETER; +} + +static target_ulong h_logical_icbi(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + /* Nothing to do on emulation, KVM will trap this in the kernel */ + return H_SUCCESS; +} + +static target_ulong h_logical_dcbf(struct kvm_cpu *vcpu, target_ulong opcode, target_ulong *args) +{ + /* Nothing to do on emulation, KVM will trap this in the kernel */ + return H_SUCCESS; +} + +static spapr_hcall_fn papr_hypercall_table[(MAX_HCALL_OPCODE / 4) + 1]; +static spapr_hcall_fn kvmppc_hypercall_table[KVMPPC_HCALL_MAX - KVMPPC_HCALL_BASE + 1]; + +void spapr_register_hypercall(target_ulong opcode, spapr_hcall_fn fn) +{ + spapr_hcall_fn *slot; + + if (opcode <= MAX_HCALL_OPCODE) { + assert((opcode & 0x3) == 0); + + slot = &papr_hypercall_table[opcode / 4]; + } else { + assert((opcode >= KVMPPC_HCALL_BASE) && (opcode <= KVMPPC_HCALL_MAX)); + + + slot = &kvmppc_hypercall_table[opcode - KVMPPC_HCALL_BASE]; + } + + assert(!(*slot) || (fn == *slot)); + *slot = fn; +} + +target_ulong spapr_hypercall(struct kvm_cpu *vcpu, target_ulong opcode, + target_ulong *args) +{ + if ((opcode <= MAX_HCALL_OPCODE) + && ((opcode & 0x3) == 0)) { + spapr_hcall_fn fn = papr_hypercall_table[opcode / 4]; + + if (fn) { + return fn(vcpu, opcode, args); + } + } else if ((opcode >= KVMPPC_HCALL_BASE) && + (opcode <= KVMPPC_HCALL_MAX)) { + spapr_hcall_fn fn = kvmppc_hypercall_table[opcode - KVMPPC_HCALL_BASE]; + + if (fn) { + return fn(vcpu, opcode, args); + } + } + + hcall_dprintf("Unimplemented hcall 0x%lx\n", opcode); + return H_FUNCTION; +} + +void hypercall_init(void) +{ + /* hcall-dabr */ + spapr_register_hypercall(H_SET_DABR, h_set_dabr); + + /* hcall-splpar */ + spapr_register_hypercall(H_REGISTER_VPA, h_register_vpa); + spapr_register_hypercall(H_CEDE, h_cede); + + /* "debugger" hcalls (also used by SLOF). Note: We do -not- differentiate + * here between the "CI" and the "CACHE" variants, they will use whatever + * mapping attributes qemu is using. When using KVM, the kernel will + * enforce the attributes more strongly + */ + spapr_register_hypercall(H_LOGICAL_CI_LOAD, h_logical_load); + spapr_register_hypercall(H_LOGICAL_CI_STORE, h_logical_store); + spapr_register_hypercall(H_LOGICAL_CACHE_LOAD, h_logical_load); + spapr_register_hypercall(H_LOGICAL_CACHE_STORE, h_logical_store); + spapr_register_hypercall(H_LOGICAL_ICBI, h_logical_icbi); + spapr_register_hypercall(H_LOGICAL_DCBF, h_logical_dcbf); + + /* KVM-PPC specific hcalls */ + spapr_register_hypercall(KVMPPC_H_RTAS, h_rtas); +} diff --git a/tools/kvm/powerpc/spapr_rtas.c b/tools/kvm/powerpc/spapr_rtas.c new file mode 100644 index 0000000..4e9c2e3 --- /dev/null +++ b/tools/kvm/powerpc/spapr_rtas.c @@ -0,0 +1,226 @@ +/* + * SPAPR base RTAS calls + * + * Borrowed heavily from QEMU's spapr_rtas.c + * Copyright (c) 2010-2011 David Gibson, IBM Corporation. + * + * Modifications copyright 2011 Matt Evans , IBM Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published + * by the Free Software Foundation. + */ + +#include "kvm/kvm.h" +#include "kvm/kvm-cpu.h" +#include "kvm/util.h" +#include "kvm/term.h" + +#include "spapr.h" + +#include +#include +#include + +#define TOKEN_BASE 0x2000 +#define TOKEN_MAX 0x100 + +#define RTAS_CONSOLE + +static void rtas_display_character(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + char c = rtas_ld(vcpu->kvm, args, 0); + term_putc(CONSOLE_HV, &c, 1, 0); + rtas_st(vcpu->kvm, rets, 0, 0); +} + +#ifdef RTAS_CONSOLE +static void rtas_put_term_char(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + char c = rtas_ld(vcpu->kvm, args, 0); + term_putc(CONSOLE_HV, &c, 1, 0); + rtas_st(vcpu->kvm, rets, 0, 0); +} + +static void rtas_get_term_char(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + int c; + if (term_readable(CONSOLE_HV, 0) && (c = term_getc(CONSOLE_HV, 0)) >= 0) { + rtas_st(vcpu->kvm, rets, 0, 0); + rtas_st(vcpu->kvm, rets, 1, c); + } else { + rtas_st(vcpu->kvm, rets, 0, -2); + } +} +#endif + +static void rtas_get_time_of_day(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + struct tm tm; + time_t tnow; + + if (nret != 8) { + rtas_st(vcpu->kvm, rets, 0, -3); + return; + } + + tnow = time(NULL); + /* Guest time is currently not offset in any way. */ + gmtime_r(&tnow, &tm); + + rtas_st(vcpu->kvm, rets, 0, 0); /* Success */ + rtas_st(vcpu->kvm, rets, 1, tm.tm_year + 1900); + rtas_st(vcpu->kvm, rets, 2, tm.tm_mon + 1); + rtas_st(vcpu->kvm, rets, 3, tm.tm_mday); + rtas_st(vcpu->kvm, rets, 4, tm.tm_hour); + rtas_st(vcpu->kvm, rets, 5, tm.tm_min); + rtas_st(vcpu->kvm, rets, 6, tm.tm_sec); + rtas_st(vcpu->kvm, rets, 7, 0); +} + +static void rtas_set_time_of_day(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + pr_warning("%s called; TOD set ignored.\n", __FUNCTION__); +} + +static void rtas_power_off(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, target_ulong args, + uint32_t nret, target_ulong rets) +{ + if (nargs != 2 || nret != 1) { + rtas_st(vcpu->kvm, rets, 0, -3); + return; + } + kvm_cpu__reboot(); +} + +static void rtas_query_cpu_stopped_state(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + unsigned long id; + + if (nargs != 1 || nret != 2) { + rtas_st(vcpu->kvm, rets, 0, -3); + return; + } + + id = rtas_ld(vcpu->kvm, args, 0); + + /* We do start all CPUs. So just return true. */ + rtas_st(vcpu->kvm, rets, 0, 0); + rtas_st(vcpu->kvm, rets, 1, 2); +} + +static void rtas_start_cpu(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, + target_ulong args, + uint32_t nret, target_ulong rets) +{ + die(__FUNCTION__); +} + +static struct rtas_call { + const char *name; + spapr_rtas_fn fn; +} rtas_table[TOKEN_MAX]; + +struct rtas_call *rtas_next = rtas_table; + +target_ulong spapr_rtas_call(struct kvm_cpu *vcpu, + uint32_t token, uint32_t nargs, target_ulong args, + uint32_t nret, target_ulong rets) +{ + if ((token >= TOKEN_BASE) + && ((token - TOKEN_BASE) < TOKEN_MAX)) { + struct rtas_call *call = rtas_table + (token - TOKEN_BASE); + + if (call->fn) { + call->fn(vcpu, token, nargs, args, nret, rets); + return H_SUCCESS; + } + } + + /* HACK: Some Linux early debug code uses RTAS display-character, + * but assumes the token value is 0xa (which it is on some real + * machines) without looking it up in the device tree. This + * special case makes this work */ + if (token == 0xa) { + rtas_display_character(vcpu, 0xa, nargs, args, nret, rets); + return H_SUCCESS; + } + + hcall_dprintf("Unknown RTAS token 0x%x\n", token); + rtas_st(vcpu->kvm, rets, 0, -3); + return H_PARAMETER; +} + +void spapr_rtas_register(const char *name, spapr_rtas_fn fn) +{ + assert(rtas_next < (rtas_table + TOKEN_MAX)); + + rtas_next->name = name; + rtas_next->fn = fn; + + rtas_next++; +} + +/* This is called from the context of an open /rtas node, in order to add + * properties for the rtas call tokens. + */ +int spapr_rtas_fdt_setup(struct kvm *kvm, void *fdt) +{ + int ret; + int i; + + for (i = 0; i < TOKEN_MAX; i++) { + struct rtas_call *call = &rtas_table[i]; + + if (!call->fn) { + continue; + } + + /* HACK borrowed from QEMU */ + ret = fdt_property_cell(fdt, call->name, i + TOKEN_BASE); + + if (ret < 0) { + pr_warning("Couldn't add rtas token for %s: %s\n", + call->name, fdt_strerror(ret)); + return ret; + } + + } + return 0; +} + +void register_core_rtas(void) +{ + spapr_rtas_register("display-character", rtas_display_character); + spapr_rtas_register("get-time-of-day", rtas_get_time_of_day); + spapr_rtas_register("set-time-of-day", rtas_set_time_of_day); + spapr_rtas_register("power-off", rtas_power_off); + spapr_rtas_register("query-cpu-stopped-state", + rtas_query_cpu_stopped_state); + spapr_rtas_register("start-cpu", rtas_start_cpu); +#ifdef RTAS_CONSOLE + /* These are unused: We do console I/O via hcalls, not rtas. */ + spapr_rtas_register("put-term-char", rtas_put_term_char); + spapr_rtas_register("get-term-char", rtas_get_term_char); +#endif +}