Archipelago » qemu

s390-zipl.rom \

spapr-rtas.bin

obj-ppc-y += spapr.o spapr_hcall.o spapr_rtas.o spapr_vio.o

if test "$cpu" = "ppc64" ; then

  roms="$roms spapr-rtas"

fi

#define RTAS_MAX_SIZE           0x10000

                              target_phys_addr_t rtas_addr,

                              target_phys_addr_t rtas_size,

    /* RTAS */

    ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size);

    if (ret < 0) {

        fprintf(stderr, "Couldn't set up RTAS device tree properties\n");

    }

    target_phys_addr_t fdt_addr, rtas_addr;

    long kernel_size, initrd_size, htab_size, rtas_size;

    char *filename;

    /* RTAS goes just below that */

    rtas_addr = fdt_addr - RTAS_MAX_SIZE;

    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin");

    rtas_size = load_image_targphys(filename, rtas_addr, ram_size - rtas_addr);

    if (rtas_size < 0) {

        hw_error("qemu: could not load LPAR rtas '%s'\n", filename);

        exit(1);

    }

    qemu_free(filename);

                           rtas_addr, rtas_size, pteg_shift + 7);

/* 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

static inline uint32_t rtas_ld(target_ulong phys, int n)

{

    return ldl_phys(phys + 4*n);

}

static inline void rtas_st(target_ulong phys, int n, uint32_t val)

{

    stl_phys(phys + 4*n, val);

}

typedef void (*spapr_rtas_fn)(sPAPREnvironment *spapr, 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(sPAPREnvironment *spapr,

                             uint32_t token, uint32_t nargs, target_ulong args,

                             uint32_t nret, target_ulong rets);

int spapr_rtas_device_tree_setup(void *fdt, target_phys_addr_t rtas_addr,

                                 target_phys_addr_t rtas_size);

static target_ulong h_rtas(CPUState *env, sPAPREnvironment *spapr,

                           target_ulong opcode, target_ulong *args)

{

    target_ulong rtas_r3 = args[0];

    uint32_t token = ldl_phys(rtas_r3);

    uint32_t nargs = ldl_phys(rtas_r3 + 4);

    uint32_t nret = ldl_phys(rtas_r3 + 8);

    return spapr_rtas_call(spapr, token, nargs, rtas_r3 + 12,

                           nret, rtas_r3 + 12 + 4*nargs);

}

spapr_hcall_fn papr_hypercall_table[(MAX_HCALL_OPCODE / 4) + 1];

spapr_hcall_fn kvmppc_hypercall_table[KVMPPC_HCALL_MAX - KVMPPC_HCALL_BASE];

    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;

        spapr_hcall_fn fn = papr_hypercall_table[opcode / 4];

        if (fn) {

            return fn(env, spapr, opcode, args);

        }

    } else if ((opcode >= KVMPPC_HCALL_BASE) &&

               (opcode <= KVMPPC_HCALL_MAX)) {

        spapr_hcall_fn fn = kvmppc_hypercall_table[opcode - KVMPPC_HCALL_BASE];

    /* qemu/KVM-PPC specific hcalls */

    spapr_register_hypercall(KVMPPC_H_RTAS, h_rtas);

/*

 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator

 *

 * Hypercall based emulated RTAS

 *

 * Copyright (c) 2010-2011 David Gibson, IBM Corporation.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 *

 */

#include "cpu.h"

#include "sysemu.h"

#include "qemu-char.h"

#include "hw/qdev.h"

#include "device_tree.h"

#include "hw/spapr.h"

#include "hw/spapr_vio.h"

#include <libfdt.h>

#define TOKEN_BASE      0x2000

#define TOKEN_MAX       0x100

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(sPAPREnvironment *spapr,

                             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(spapr, token, nargs, args, nret, rets);

            return H_SUCCESS;

        }

    }

    hcall_dprintf("Unknown RTAS token 0x%x\n", token);

    rtas_st(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++;

}

int spapr_rtas_device_tree_setup(void *fdt, target_phys_addr_t rtas_addr,

                                 target_phys_addr_t rtas_size)

{

    int ret;

    int i;

    ret = fdt_add_mem_rsv(fdt, rtas_addr, rtas_size);

    if (ret < 0) {

        fprintf(stderr, "Couldn't add RTAS reserve entry: %s\n",

                fdt_strerror(ret));

        return ret;

    }

    ret = qemu_devtree_setprop_cell(fdt, "/rtas", "linux,rtas-base",

                                    rtas_addr);

    if (ret < 0) {

        fprintf(stderr, "Couldn't add linux,rtas-base property: %s\n",

                fdt_strerror(ret));

        return ret;

    }

    ret = qemu_devtree_setprop_cell(fdt, "/rtas", "linux,rtas-entry",

                                    rtas_addr);

    if (ret < 0) {

        fprintf(stderr, "Couldn't add linux,rtas-entry property: %s\n",

                fdt_strerror(ret));

        return ret;

    }

    ret = qemu_devtree_setprop_cell(fdt, "/rtas", "rtas-size",

                                    rtas_size);

    if (ret < 0) {

        fprintf(stderr, "Couldn't add rtas-size property: %s\n",

                fdt_strerror(ret));

        return ret;

    }

    for (i = 0; i < TOKEN_MAX; i++) {

        struct rtas_call *call = &rtas_table[i];

        if (!call->fn) {

            continue;

        }

        ret = qemu_devtree_setprop_cell(fdt, "/rtas", call->name,

                                        i + TOKEN_BASE);

        if (ret < 0) {

            fprintf(stderr, "Couldn't add rtas token for %s: %s\n",

                    call->name, fdt_strerror(ret));

            return ret;

        }

    }

    return 0;

}

all: build-all

# Dummy command so that make thinks it has done something

	@true

include ../../config-host.mak

include $(SRC_PATH)/rules.mak

$(call set-vpath, $(SRC_PATH)/pc-bios/spapr-rtas)

.PHONY : all clean build-all

#CFLAGS += -I$(SRC_PATH)

#QEMU_CFLAGS = $(CFLAGS)

build-all: spapr-rtas.bin

%.img: %.o

	$(call quiet-command,$(CC) -nostdlib -o $@ $<,"  Building $(TARGET_DIR)$@")

%.bin: %.img

	$(call quiet-command,$(OBJCOPY) -O binary -j .text $< $@,"  Building $(TARGET_DIR)$@")

clean:

	rm -f *.o *.d *.img *.bin *~

/*

 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator

 *

 * Trivial in-partition RTAS implementation, based on a hypercall

 *

 * Copyright (c) 2010,2011 David Gibson, IBM Corporation.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 *

 */

#define KVMPPC_HCALL_BASE       0xf000

#define KVMPPC_H_RTAS           (KVMPPC_HCALL_BASE + 0x0)

.globl	_start

_start:

	mr	4,3

	lis	3,KVMPPC_H_RTAS@h

	ori	3,3,KVMPPC_H_RTAS@l

	sc	1

	blr