Archipelago » qemu

#include "kvm_arm.h"

/* We track all the KVM devices which need their memory addresses

 * passing to the kernel in a list of these structures.

 * When board init is complete we run through the list and

 * tell the kernel the base addresses of the memory regions.

 * We use a MemoryListener to track mapping and unmapping of

 * the regions during board creation, so the board models don't

 * need to do anything special for the KVM case.

 */

typedef struct KVMDevice {

    struct kvm_arm_device_addr kda;

    MemoryRegion *mr;

    QSLIST_ENTRY(KVMDevice) entries;

} KVMDevice;

static QSLIST_HEAD(kvm_devices_head, KVMDevice) kvm_devices_head;

static void kvm_arm_devlistener_add(MemoryListener *listener,

                                    MemoryRegionSection *section)

{

    KVMDevice *kd;

    QSLIST_FOREACH(kd, &kvm_devices_head, entries) {

        if (section->mr == kd->mr) {

            kd->kda.addr = section->offset_within_address_space;

        }

    }

}

static void kvm_arm_devlistener_del(MemoryListener *listener,

                                    MemoryRegionSection *section)

{

    KVMDevice *kd;

    QSLIST_FOREACH(kd, &kvm_devices_head, entries) {

        if (section->mr == kd->mr) {

            kd->kda.addr = -1;

        }

    }

}

static MemoryListener devlistener = {

    .region_add = kvm_arm_devlistener_add,

    .region_del = kvm_arm_devlistener_del,

};

static void kvm_arm_machine_init_done(Notifier *notifier, void *data)

{

    KVMDevice *kd, *tkd;

    memory_listener_unregister(&devlistener);

    QSLIST_FOREACH_SAFE(kd, &kvm_devices_head, entries, tkd) {

        if (kd->kda.addr != -1) {

            if (kvm_vm_ioctl(kvm_state, KVM_ARM_SET_DEVICE_ADDR,

                             &kd->kda) < 0) {

                fprintf(stderr, "KVM_ARM_SET_DEVICE_ADDRESS failed: %s\n",

                        strerror(errno));

                abort();

            }

        }

        g_free(kd);

    }

}

static Notifier notify = {

    .notify = kvm_arm_machine_init_done,

};

void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid)

{

    KVMDevice *kd;

    if (!kvm_irqchip_in_kernel()) {

        return;

    }

    if (QSLIST_EMPTY(&kvm_devices_head)) {

        memory_listener_register(&devlistener, NULL);

        qemu_add_machine_init_done_notifier(&notify);

    }

    kd = g_new0(KVMDevice, 1);

    kd->mr = mr;

    kd->kda.id = devid;

    kd->kda.addr = -1;

    QSLIST_INSERT_HEAD(&kvm_devices_head, kd, entries);

}

/*

 * QEMU KVM support -- ARM specific functions.

 *

 * Copyright (c) 2012 Linaro Limited

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 *

 */

#ifndef QEMU_KVM_ARM_H

#define QEMU_KVM_ARM_H

#include "sysemu/kvm.h"

#include "exec/memory.h"

/**

 * kvm_arm_register_device:

 * @mr: memory region for this device

 * @devid: the KVM device ID

 *

 * Remember the memory region @mr, and when it is mapped by the

 * machine model, tell the kernel that base address using the

 * KVM_SET_DEVICE_ADDRESS ioctl. @devid should be the ID of

 * the device as defined by KVM_SET_DEVICE_ADDRESS.

 * The machine model may map and unmap the device multiple times;

 * the kernel will only be told the final address at the point

 * where machine init is complete.

 */

void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid);

#endif