/*
 * PPC64 processor support
 *
 * Copyright 2011 Matt Evans <matt@ozlabs.org>, 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-cpu.h"

#include "kvm/symbol.h"
#include "kvm/util.h"
#include "kvm/kvm.h"

#include "spapr.h"
#include "spapr_pci.h"
#include "xics.h"

#include <sys/ioctl.h>
#include <sys/mman.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <assert.h>

static int debug_fd;

void kvm_cpu__set_debug_fd(int fd)
{
	debug_fd = fd;
}

int kvm_cpu__get_debug_fd(void)
{
	return debug_fd;
}

static struct kvm_cpu *kvm_cpu__new(struct kvm *kvm)
{
	struct kvm_cpu *vcpu;

	vcpu		= calloc(1, sizeof *vcpu);
	if (!vcpu)
		return NULL;

	vcpu->kvm	= kvm;

	return vcpu;
}

void kvm_cpu__delete(struct kvm_cpu *vcpu)
{
	free(vcpu);
}

struct kvm_cpu *kvm_cpu__arch_init(struct kvm *kvm, unsigned long cpu_id)
{
	struct kvm_cpu *vcpu;
	int mmap_size;
	struct kvm_enable_cap papr_cap = { .cap = KVM_CAP_PPC_PAPR };

	vcpu		= kvm_cpu__new(kvm);
	if (!vcpu)
		return NULL;

	vcpu->cpu_id	= cpu_id;

	vcpu->vcpu_fd = ioctl(vcpu->kvm->vm_fd, KVM_CREATE_VCPU, cpu_id);
	if (vcpu->vcpu_fd < 0)
		die_perror("KVM_CREATE_VCPU ioctl");

	mmap_size = ioctl(vcpu->kvm->sys_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
	if (mmap_size < 0)
		die_perror("KVM_GET_VCPU_MMAP_SIZE ioctl");

	vcpu->kvm_run = mmap(NULL, mmap_size, PROT_RW, MAP_SHARED, vcpu->vcpu_fd, 0);
	if (vcpu->kvm_run == MAP_FAILED)
		die("unable to mmap vcpu fd");

	if (ioctl(vcpu->vcpu_fd, KVM_ENABLE_CAP, &papr_cap) < 0)
		die("unable to enable PAPR capability");

	/*
	 * We start all CPUs, directing non-primary threads into the kernel's
	 * secondary start point.  When we come to support SLOF, we will start
	 * only one and SLOF will RTAS call us to ask for others to be
	 * started.  (FIXME: make more generic & interface with whichever
	 * firmware a platform may be using.)
	 */
	vcpu->is_running = true;

	return vcpu;
}

static void kvm_cpu__setup_fpu(struct kvm_cpu *vcpu)
{
	/* Don't have to do anything, there's no expected FPU state. */
}

static void kvm_cpu__setup_regs(struct kvm_cpu *vcpu)
{
	/*
	 * FIXME: This assumes PPC64 and Linux guest.  It doesn't use the
	 * OpenFirmware entry method, but instead the "embedded" entry which
	 * passes the FDT address directly.
	 */
	struct kvm_regs *r = &vcpu->regs;

	if (vcpu->cpu_id == 0) {
		r->pc = KERNEL_START_ADDR;
		r->gpr[3] = vcpu->kvm->arch.fdt_gra;
		r->gpr[5] = 0;
	} else {
		r->pc = KERNEL_SECONDARY_START_ADDR;
		r->gpr[3] = vcpu->cpu_id;
	}
	r->msr = 0x8000000000001000UL; /* 64bit, non-HV, ME */

	if (ioctl(vcpu->vcpu_fd, KVM_SET_REGS, &vcpu->regs) < 0)
		die_perror("KVM_SET_REGS failed");
}

static void kvm_cpu__setup_sregs(struct kvm_cpu *vcpu)
{
	/*
	 * Some sregs setup to initialise SDR1/PVR/HIOR on PPC64 SPAPR
	 * platforms using PR KVM.  (Technically, this is all ignored on
	 * SPAPR HV KVM.)  Different setup is required for non-PV non-SPAPR
	 * platforms!  (FIXME.)
	 */
	struct kvm_sregs sregs;
	struct kvm_one_reg reg = {};
	u64 value;

	if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &sregs) < 0)
		die("KVM_GET_SREGS failed");

	sregs.u.s.sdr1 = vcpu->kvm->arch.sdr1;
	sregs.pvr = vcpu->kvm->arch.pvr;

	if (ioctl(vcpu->vcpu_fd, KVM_SET_SREGS, &sregs) < 0)
		die("KVM_SET_SREGS failed");

	reg.id = KVM_REG_PPC_HIOR;
	value = 0;
	reg.addr = (u64)(unsigned long)&value;
	if (ioctl(vcpu->vcpu_fd, KVM_SET_ONE_REG, &reg) < 0)
		die("KVM_SET_ONE_REG failed");
}

/**
 * kvm_cpu__reset_vcpu - reset virtual CPU to a known state
 */
void kvm_cpu__reset_vcpu(struct kvm_cpu *vcpu)
{
	kvm_cpu__setup_regs(vcpu);
	kvm_cpu__setup_sregs(vcpu);
	kvm_cpu__setup_fpu(vcpu);
}

/* kvm_cpu__irq - set KVM's IRQ flag on this vcpu */
void kvm_cpu__irq(struct kvm_cpu *vcpu, int pin, int level)
{
	unsigned int virq = level ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET;

	/* FIXME: POWER-specific */
	if (pin != POWER7_EXT_IRQ)
		return;
	if (ioctl(vcpu->vcpu_fd, KVM_INTERRUPT, &virq) < 0)
		pr_warning("Could not KVM_INTERRUPT.");
}

void kvm_cpu__arch_nmi(struct kvm_cpu *cpu)
{
}

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,
						      (target_ulong*)run->papr_hcall.args);
		break;
	default:
		ret = false;
	}
	return ret;
}

bool kvm_cpu__emulate_mmio(struct kvm_cpu *vcpu, u64 phys_addr, u8 *data, u32 len, u8 is_write)
{
	/*
	 * FIXME: This function will need to be split in order to support
	 * various PowerPC platforms/PHB types, etc.  It currently assumes SPAPR
	 * PPC64 guest.
	 */
	bool ret = false;

	if ((phys_addr >= SPAPR_PCI_WIN_START) &&
	    (phys_addr < SPAPR_PCI_WIN_END)) {
		ret = spapr_phb_mmio(vcpu, phys_addr, data, len, is_write);
	} else {
		pr_warning("MMIO %s unknown address %llx (size %d)!\n",
			   is_write ? "write to" : "read from",
			   phys_addr, len);
	}
	return ret;
}

#define CONDSTR_BIT(m, b) (((m) & MSR_##b) ? #b" " : "")

void kvm_cpu__show_registers(struct kvm_cpu *vcpu)
{
	struct kvm_regs regs;
	struct kvm_sregs sregs;
	int r;

	if (ioctl(vcpu->vcpu_fd, KVM_GET_REGS, &regs) < 0)
		die("KVM_GET_REGS failed");
        if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &sregs) < 0)
		die("KVM_GET_SREGS failed");

	dprintf(debug_fd, "\n Registers:\n");
	dprintf(debug_fd, " NIP:   %016llx  MSR:   %016llx "
		"( %s%s%s%s%s%s%s%s%s%s%s%s)\n",
		regs.pc, regs.msr,
		CONDSTR_BIT(regs.msr, SF),
		CONDSTR_BIT(regs.msr, HV), /* ! */
		CONDSTR_BIT(regs.msr, VEC),
		CONDSTR_BIT(regs.msr, VSX),
		CONDSTR_BIT(regs.msr, EE),
		CONDSTR_BIT(regs.msr, PR),
		CONDSTR_BIT(regs.msr, FP),
		CONDSTR_BIT(regs.msr, ME),
		CONDSTR_BIT(regs.msr, IR),
		CONDSTR_BIT(regs.msr, DR),
		CONDSTR_BIT(regs.msr, RI),
		CONDSTR_BIT(regs.msr, LE));
	dprintf(debug_fd, " CTR:   %016llx  LR:    %016llx  CR:   %08llx\n",
		regs.ctr, regs.lr, regs.cr);
	dprintf(debug_fd, " SRR0:  %016llx  SRR1:  %016llx  XER:  %016llx\n",
		regs.srr0, regs.srr1, regs.xer);
	dprintf(debug_fd, " SPRG0: %016llx  SPRG1: %016llx\n",
		regs.sprg0, regs.sprg1);
	dprintf(debug_fd, " SPRG2: %016llx  SPRG3: %016llx\n",
		regs.sprg2, regs.sprg3);
	dprintf(debug_fd, " SPRG4: %016llx  SPRG5: %016llx\n",
		regs.sprg4, regs.sprg5);
	dprintf(debug_fd, " SPRG6: %016llx  SPRG7: %016llx\n",
		regs.sprg6, regs.sprg7);
	dprintf(debug_fd, " GPRs:\n ");
	for (r = 0; r < 32; r++) {
		dprintf(debug_fd, "%016llx  ", regs.gpr[r]);
		if ((r & 3) == 3)
			dprintf(debug_fd, "\n ");
	}
	dprintf(debug_fd, "\n");

	/* FIXME: Assumes SLB-based (book3s) guest */
	for (r = 0; r < 32; r++) {
		dprintf(debug_fd, " SLB%02d  %016llx %016llx\n", r,
			sregs.u.s.ppc64.slb[r].slbe,
			sregs.u.s.ppc64.slb[r].slbv);
	}
	dprintf(debug_fd, "----------\n");
}

void kvm_cpu__show_code(struct kvm_cpu *vcpu)
{
	if (ioctl(vcpu->vcpu_fd, KVM_GET_REGS, &vcpu->regs) < 0)
		die("KVM_GET_REGS failed");

	/* FIXME: Dump/disassemble some code...! */

	dprintf(debug_fd, "\n Stack:\n");
	dprintf(debug_fd,   " ------\n");
	/* Only works in real mode: */
	kvm__dump_mem(vcpu->kvm, vcpu->regs.gpr[1], 32, debug_fd);
}

void kvm_cpu__show_page_tables(struct kvm_cpu *vcpu)
{
	/* Does nothing yet */
}