1. Toy模板网首页
  2. > Toy博客

在WIN从零开始在QMUE上添加一块自己的开发板（二）

10月前 作者：电子宁采臣 分类：Toy博客 阅读(51) 违法举报

这篇具有很好参考价值的文章主要介绍了在WIN从零开始在QMUE上添加一块自己的开发板（二）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、前言

笔者这篇博客作为平时学习时的笔记记录，如有不对还望指正，本博客大量借鉴资料，笔者只是拾人牙慧的小屁孩。
QEMU是一种通用的开源计算机仿真器和虚拟器。而QUME内置支持了一些开发板，我们可以基于这些内置的板子来做操作系统等软件的配置，但是实际市面上很多板子QUME中是没有提供支持的，这需要我们根据QUME的源码自定义一些开发板，然后再重新编译。

往期回顾

在WIN从零开始在QMUE上添加一块自己的开发板（一）

二、CPU虚拟化

（一）相关源码

QEMU中RISC-V CPU的支持
QOM的TYPE定义
target/riscv/cpu.h:

#define TYPE_RISCV_CPU "riscv-cpu"

#define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU
#define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX)
#define CPU_RESOLVING_TYPE TYPE_RISCV_CPU

#define TYPE_RISCV_CPU_ANY RISCV_CPU_TYPE_NAME("any")
#define TYPE_RISCV_CPU_BASE32 RISCV_CPU_TYPE_NAME("rv32")
#define TYPE_RISCV_CPU_BASE64 RISCV_CPU_TYPE_NAME("rv64")
#define TYPE_RISCV_CPU_IBEX RISCV_CPU_TYPE_NAME("lowrisc-ibex")
#define TYPE_RISCV_CPU_SIFIVE_E31 RISCV_CPU_TYPE_NAME("sifive-e31")
#define TYPE_RISCV_CPU_SIFIVE_E34 RISCV_CPU_TYPE_NAME("sifive-e34")
#define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51")
#define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34")
#define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54")

TYPE用于hash表的key（GHashTable.key），而hash表的值也就是ObjectClass、Object。

Class
RISCVCPUClass继承于CPUClass，然后继承于DeviceClass。
CPUClass中有很多接口:

struct CPUClass {
	DeviceClass parent_class;
	ObjectClass *(*class_by_name)();
	void (*parse_features)();
	int reset_dump_flags;
	bool (*has_work)();
	bool (*virtio_is_big_endian)();
	int (*memory_rw_debug)();
	void (*dump_state)();
	GuestPanicInformation* (*get_crash_info)();
	void (*dump_statistics)();
	int64_t (*get_arch_id)();
	bool (*get_paging_enabled)();
	void (*get_memory_mapping)();
	void (*set_pc)();
	hwaddr (*get_phys_page_debug)();
	hwaddr (*get_phys_page_attrs_debug)();
	int (*asidx_from_attrs)();
	int (*gdb_read_register)();
	int (*gdb_write_register)();
	int (*write_elf64_note)();
	int (*write_elf64_qemunote)();
	int (*write_elf32_note)();
	int (*write_elf32_qemunote)();
	const VMStateDescription *vmsd;
	const char *gdb_core_xml_file;
	gchar * (*gdb_arch_name)();
	const char * (*gdb_get_dynamic_xml)();
	void (*disas_set_info)();
	const char *deprecation_note;
	int gdb_num_core_regs;
	bool gdb_stop_before_watchpoint;
	struct AccelCPUClass *accel_cpu;
	struct TCGCPUOps *tcg_ops;
};

我们着重看一下struct TCGCPUOps：

struct TCGCPUOps {
	void (*initialize)(void);
	void (*synchronize_from_tb)(CPUState *cpu, const TranslationBlock *tb);
	void (*cpu_exec_enter)(CPUState *cpu);
	void (*cpu_exec_exit)(CPUState *cpu);
	bool (*cpu_exec_interrupt)(CPUState *cpu, int interrupt_request);
	void (*do_interrupt)(CPUState *cpu);
	bool (*tlb_fill)(CPUState *cpu, vaddr address, int size,
	MMUAccessType access_type, int mmu_idx,
	bool probe, uintptr_t retaddr);
	void (*debug_excp_handler)(CPUState *cpu);
#ifdef NEED_CPU_H
#ifdef CONFIG_SOFTMMU
	void (*do_transaction_failed)(CPUState *cpu, hwaddr physaddr, vaddr addr,
	unsigned size, MMUAccessType access_type,
	int mmu_idx, MemTxAttrs attrs,
	MemTxResult response, uintptr_t retaddr);
	void (*do_unaligned_access)(CPUState *cpu, vaddr addr,
	MMUAccessType access_type,
	int mmu_idx, uintptr_t retaddr);
	vaddr (*adjust_watchpoint_address)(CPUState *cpu, vaddr addr, int len);
	bool (*debug_check_watchpoint)(CPUState *cpu, CPUWatchpoint *wp);
	bool (*io_recompile_replay_branch)(CPUState *cpu,
	const TranslationBlock *tb);
#endif /* CONFIG_SOFTMMU */
#endif /* NEED_CPU_H */
};

可以看见里面有很多CPU运行时的接口。
在不同架构中，我们进行相应的实现，对于RISCVCPU，已经有相应的实现了：

static struct TCGCPUOps riscv_tcg_ops = {
	.initialize = riscv_translate_init,
	.synchronize_from_tb = riscv_cpu_synchronize_from_tb,
	.cpu_exec_interrupt = riscv_cpu_exec_interrupt,
	.tlb_fill = riscv_cpu_tlb_fill,
#ifndef CONFIG_USER_ONLY
	.do_interrupt = riscv_cpu_do_interrupt,
	.do_transaction_failed = riscv_cpu_do_transaction_failed,
	.do_unaligned_access = riscv_cpu_do_unaligned_access,
#endif /* !CONFIG_USER_ONLY */
};

Object
对于CPU中寄存器的定义都在Object中：

struct CPURISCVState {
	target_ulong gpr[32];
	uint64_t fpr[32]; /* assume both F and D extensions */
	/* vector coprocessor state. */
	uint64_t vreg[32 * RV_VLEN_MAX / 64] QEMU_ALIGNED(16);
	//vector reg
	target_ulong pc;
	target_ulong misa;
	uint32_t features;
	/* Hypervisor CSRs */
	/* Virtual CSRs */
	/* HS Backup CSRs */
	/* temporary htif regs */
	/* physical memory protection */
	/* machine specific rdtime callback */
	/* True if in debugger mode. */
	bool debugger;
	float_status fp_status;
	/* Fields from here on are preserved across CPU reset. */
	QEMUTimer *timer; /* Internal timer */
};

实例化

	struct RISCVCPU {
	/*< private >*/
	CPUState parent_obj;
	/*< public >*/
	CPUNegativeOffsetState neg;
	CPURISCVState env;
	char *dyn_csr_xml;
	/* Configuration Settings */
	struct {
	……
	} cfg;
};

RISCV CPU TypeInfo注册：

.instance_init = riscv_cpu_init,
.class_init = riscv_cpu_class_init,

特殊的CPU使用特殊的函数进行实例

.instance_init = rvxx_sifive_e_cpu_init,
.class_init = riscv_cpu_class_init,

在特殊的函数中，将会针对不同CPU的特性进行个性化实例：

static void rvxx_sifive_e_cpu_init(Object *obj)
{
	CPURISCVState *env = &RISCV_CPU(obj)->env;
	set_misa(env, RVXLEN | RVI | RVM | RVA | RVC | RVU);
	set_priv_version(env, PRIV_VERSION_1_10_0);
	set_resetvec(env, 0x1004);
	qdev_prop_set_bit(DEVICE(obj), "mmu", false);
}

（二）举个例子

我们为之前创建的开发板增加CPU。
我们去target\riscv\cpu-qom.h，添加一个我们自己的CPU：

...
#define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU
#define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX)

#define TYPE_RISCV_CPU_ANY              RISCV_CPU_TYPE_NAME("any")
#define TYPE_RISCV_CPU_MAX              RISCV_CPU_TYPE_NAME("max")
#define TYPE_RISCV_CPU_BASE32           RISCV_CPU_TYPE_NAME("rv32")
#define TYPE_RISCV_CPU_BASE64           RISCV_CPU_TYPE_NAME("rv64")
#define TYPE_RISCV_CPU_BASE128          RISCV_CPU_TYPE_NAME("x-rv128")
#define TYPE_RISCV_CPU_IBEX             RISCV_CPU_TYPE_NAME("lowrisc-ibex")
#define TYPE_RISCV_CPU_SHAKTI_C         RISCV_CPU_TYPE_NAME("shakti-c")
#define TYPE_RISCV_CPU_SIFIVE_E31       RISCV_CPU_TYPE_NAME("sifive-e31")
#define TYPE_RISCV_CPU_SIFIVE_E34       RISCV_CPU_TYPE_NAME("sifive-e34")
#define TYPE_RISCV_CPU_SIFIVE_E51       RISCV_CPU_TYPE_NAME("sifive-e51")
#define TYPE_RISCV_CPU_SIFIVE_U34       RISCV_CPU_TYPE_NAME("sifive-u34")
#define TYPE_RISCV_CPU_SIFIVE_U54       RISCV_CPU_TYPE_NAME("sifive-u54")
#define TYPE_RISCV_CPU_THEAD_C906       RISCV_CPU_TYPE_NAME("thead-c906")
#define TYPE_RISCV_CPU_VEYRON_V1        RISCV_CPU_TYPE_NAME("veyron-v1")
#define TYPE_RISCV_CPU_HOST             RISCV_CPU_TYPE_NAME("host")
/* 添加自己的CPU */
#define TYPE_RISCV_CPU_NUCLEI_N600       RISCV_CPU_TYPE_NAME("nuclei-n600")

并在./target/riscv/cpu.c中，添加其初始化函数：

#if defined(TARGET_RISCV32)
/* 自己的CPU */
static void rv32_nuclei_n_cpu_init(Object *obj)
{
    CPURISCVState *env = &RISCV_CPU(obj)->env;
    RISCVCPU *cpu = RISCV_CPU(obj);
    riscv_cpu_set_misa(env, MXL_RV32, RVI | RVM | RVA | RVC | RVF | RVD | RVU);
    env->priv_ver=  PRIV_VERSION_1_10_0;
    #ifndef CONFIG_USER_ONLY
    set_satp_mode_max_supported(cpu, VM_1_10_MBARE);
#endif

    /* inherited from parent obj via riscv_cpu_init() */
    cpu->cfg.ext_zifencei = true;
    cpu->cfg.ext_zicsr = true;
    cpu->cfg.pmp = true;
}
#endif

并在riscv_cpu_type_infos中添加DEFINE

static const TypeInfo riscv_cpu_type_infos[] = {
    {
        .name = TYPE_RISCV_CPU,
        .parent = TYPE_CPU,
        .instance_size = sizeof(RISCVCPU),
        .instance_align = __alignof(RISCVCPU),
        .instance_init = riscv_cpu_init,
        .instance_post_init = riscv_cpu_post_init,
        .abstract = true,
        .class_size = sizeof(RISCVCPUClass),
        .class_init = riscv_cpu_class_init,
    },
    {
        .name = TYPE_RISCV_DYNAMIC_CPU,
        .parent = TYPE_RISCV_CPU,
        .abstract = true,
    },
    DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_ANY,      riscv_any_cpu_init),
    DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_MAX,      riscv_max_cpu_init),
#if defined(TARGET_RISCV32)
    DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE32,   rv32_base_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_IBEX,             rv32_ibex_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E31,       rv32_sifive_e_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E34,       rv32_imafcu_nommu_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_U34,       rv32_sifive_u_cpu_init),
    /* 自己的CPU */
    DEFINE_CPU(TYPE_RISCV_CPU_NUCLEI_N600,      rv32_nuclei_n_cpu_init),
    
#elif defined(TARGET_RISCV64)
    DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE64,   rv64_base_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E51,       rv64_sifive_e_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_U54,       rv64_sifive_u_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_SHAKTI_C,         rv64_sifive_u_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_THEAD_C906,       rv64_thead_c906_cpu_init),
    DEFINE_CPU(TYPE_RISCV_CPU_VEYRON_V1,        rv64_veyron_v1_cpu_init),
    DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE128,  rv128_base_cpu_init),
#endif
};

接着我们回到我们的开发板文件，
这里讲个小技巧，也就是从include\hw\riscv\virt.h（官方虚拟开发板的例程）看相关的引用，从而确定相关头文件的所在位置和相关代码的实现。
在我们的nuclei_n.h中（请注意，为了方便理解，这里对往期变量及函数的名字进行了更改）：
引入头文件

#include "hw/riscv/riscv_hart.h"

并在SOC中添加CPU

/* CPU 定义 */
#define NUCLEI_N_CPU TYPE_RISCV_CPU_NUCLEI_N600

typedef struct NucLeiNSoCState
{
	/*< private >*/
	SysBusDevice parent_obj;
	/*< public >*/
	RISCVHartArrayState cpus;
} NucLeiNSoCState;

以及一些TYPE：

#define NUCLEI_N_CPU 						TYPE_RISCV_CPU_NUCLEI_N600

之后我们在Machine的Class里面增加最小CPU个数和默认CPU的TYPE：

static void nuclei_machine_class_init(ObjectClass *oc, void *data)
{
	qemu_log(">>nuclei_machine_class_init \n");
	MachineClass *mc = MACHINE_CLASS(oc);
    mc->desc = "Nuclei MCU 200T FPGA Evaluation Kit";
	mc->init = nuclei_mcu_machine_init;
	mc->max_cpus = 1;
    mc->default_cpu_type = NUCLEI_N_CPU;
}

我们在SOC实例初始化函数中，对CPU初始化：

static void nuclei_n_soc_instance_init(Object *obj)
{
	qemu_log(">>nuclei_n_soc_instance_init \n");
	NucLeiNSoCState *s = NUCLEI_N_SOC(obj);
	object_initialize_child(obj, "cpus", &s->cpus, TYPE_RISCV_HART_ARRAY);  //初始化CPU
}

并在SOC实现中（nuclei_n_soc_realize）进行CPU的实现：

static void nuclei_n_soc_realize(DeviceState *dev, Error **errp)
{
	qemu_log(">>nuclei_n_soc_realize \n");
	MachineState *ms = MACHINE(qdev_get_machine());
    NucLeiNSoCState *s = NUCLEI_N_SOC(dev);

    object_property_set_str(OBJECT(&s->cpus), "cpu-type", ms->cpu_type, &error_abort);      
    object_property_set_int(OBJECT(&s->cpus), "num-harts", ms->smp.cpus, &error_abort);
    sysbus_realize(SYS_BUS_DEVICE(&s->cpus), &error_abort);  //CPU实例化
}

附上完整：

nuclei_n.h:

#include "hw/sysbus.h"
#include "hw/riscv/riscv_hart.h"

#define TYPE_NUCLEI_N_SOC "riscv.nuclei.n.soc"
#define NUCLEI_N_SOC(obj) \
    OBJECT_CHECK(NucLeiNSoCState, (obj), TYPE_NUCLEI_N_SOC)

/* CPU 定义 */
#define NUCLEI_N_CPU TYPE_RISCV_CPU_NUCLEI_N600

typedef struct NucLeiNSoCState
{
	/*< private >*/
	SysBusDevice parent_obj;
	/*< public >*/
	RISCVHartArrayState cpus;
} NucLeiNSoCState;


/* Machine state定义 */
#define TYPE_NUCLEI_MCU_FPGA_MACHINE MACHINE_TYPE_NAME("mcu_200t")
#define MCU_FPGA_MACHINE(obj) \
    OBJECT_CHECK(NucLeiNState, (obj), TYPE_NUCLEI_MCU_FPGA_MACHINE)

typedef struct NucLeiNState
{
	/*< private >*/
	SysBusDevice parent_obj;
	/*< public >*/
	NucLeiNSoCState soc;
} NucLeiNState;

nuclei_n.c:

#include "qemu/osdep.h"
#include "qemu/log.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "hw/riscv/nuclei_n.h"
#include "hw/boards.h"


static void nuclei_n_soc_instance_init(Object *obj)
{
	qemu_log(">>nuclei_n_soc_instance_init \n");
	NucLeiNSoCState *s = NUCLEI_N_SOC(obj);
	object_initialize_child(obj, "cpus", &s->cpus, TYPE_RISCV_HART_ARRAY);  //初始化CPU
}

static void nuclei_n_soc_realize(DeviceState *dev, Error **errp)
{
	qemu_log(">>nuclei_n_soc_realize \n");
	MachineState *ms = MACHINE(qdev_get_machine());
    NucLeiNSoCState *s = NUCLEI_N_SOC(dev);

    object_property_set_str(OBJECT(&s->cpus), "cpu-type", ms->cpu_type, &error_abort);      
    object_property_set_int(OBJECT(&s->cpus), "num-harts", ms->smp.cpus, &error_abort);
    sysbus_realize(SYS_BUS_DEVICE(&s->cpus), &error_abort);            //CPU实例化
}
static void nuclei_n_soc_class_init(ObjectClass *oc, void *data)
{
	qemu_log(">>nuclei_n_soc_class_init \n");
	DeviceClass *dc = DEVICE_CLASS(oc);
	dc->realize = nuclei_n_soc_realize;
	dc->user_creatable = false;
}

static const TypeInfo nuclei_n_soc_type_info = {
	.name = TYPE_NUCLEI_N_SOC,
	.parent = TYPE_DEVICE,
	.instance_size = sizeof(NucLeiNSoCState),
	.instance_init = nuclei_n_soc_instance_init,
	.class_init = nuclei_n_soc_class_init,
};
static void nuclei_n_soc_register_types(void)
{
	type_register_static(&nuclei_n_soc_type_info);
}
type_init(nuclei_n_soc_register_types)

static void nuclei_mcu_machine_init(MachineState *machine)
{
	NucLeiNState *s = MCU_FPGA_MACHINE(machine);
	qemu_log(">>nuclei_mcu_machine_init \n");
	/* Initialize SOC */
	object_initialize_child(OBJECT(machine), "soc", &s->soc, TYPE_NUCLEI_N_SOC);
	qdev_realize(DEVICE(&s->soc), NULL, &error_abort);
}
static void nuclei_machine_instance_init(Object *obj)
{
	qemu_log(">>nuclei_machine_instance_init \n");
}
static void nuclei_machine_class_init(ObjectClass *oc, void *data)
{
	qemu_log(">>nuclei_machine_class_init \n");
	MachineClass *mc = MACHINE_CLASS(oc);
    mc->desc = "Nuclei MCU 200T FPGA Evaluation Kit";
	mc->init = nuclei_mcu_machine_init;
	mc->max_cpus = 1;
    mc->default_cpu_type = NUCLEI_N_CPU;
}

static const TypeInfo nuclei_machine_typeinfo = {
	.name = TYPE_NUCLEI_MCU_FPGA_MACHINE,
	.parent = TYPE_MACHINE,
	.class_init = nuclei_machine_class_init,
	.instance_init = nuclei_machine_instance_init,
	.instance_size = sizeof(NucLeiNState),
};
static void nuclei_machine_init_register_types(void)
{
	type_register_static(&nuclei_machine_typeinfo);
}
type_init(nuclei_machine_init_register_types)

不用忘记在./target/riscv/cpu.c去定义CPU哦。

（三）测试

执行run.sh:

SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
$SHELL_FOLDER/output/qemu/qemu-system-riscv32.exe \
-M mcu_200t

得到以下效果：
在WIN从零开始在QMUE上添加一块自己的开发板（二）,虚拟机开发,c语言,c++,risc-v

三、内存虚拟化

（一）相关源码

有了之前的开发经验，我们这次直接看相关API：

Types of regions initialize
RAM memory_region_init_ram()
MMIO memory_region_init_io()
ROM memory_region_init_rom()
ROM_evice memory_region_init_rom_device()
IOMMU region memory_region_init_iommu()
container memory_region_init()
alias memory_region_init_alias()
reservation region memory_region_init_io()

其次是添加硬件的地址和映射的地址长度的结构体：
（注意这里的长度不能为0，不然会报错）

typedef struct MemMapEntry {
    hwaddr base; //基址
    hwaddr size; //长度
} MemMapEntry;

然后是关于ROM的指令初始化：

/* reset vector */
uint32_t reset_vec[8] = {
	0x00000297, /* 1: auipc t0, %pcrel_hi(dtb) */
	0x02028593, /* addi a1, t0, %pcrel_lo(1b) */
	0xf1402573, /* csrr a0, mhartid */
	#if defined(TARGET_RISCV32)
	0x0182a283, /* lw t0, 24(t0) */
	#elif defined(TARGET_RISCV64)
	0x0182b283, /* ld t0, 24(t0) */
	#endif
	0x00028067, /* jr t0 */
	0x00000000,
	start_addr, /* start: .dword DRAM_BASE */
	0x00000000,
};
/* copy in the reset vector in little_endian byte order */
for (i = 0; i < sizeof(reset_vec) >> 2; i++)
{
	reset_vec[i] = cpu_to_le32(reset_vec[i]);
}
rom_add_blob_fixed_as("mrom.reset", reset_vec, sizeof(reset_vec),memmap[NUCLEI_N_ROM].base, &address_space_memory);
/* boot rom */
if (machine->kernel_filename)
{
	riscv_load_kernel(machine>kernel_filename, start_addr, NULL);
}

这种是手动执行指令初始化，当然，因为我们使用的RISCV架构，直接使用riscv_setup_rom_reset_vec进行指令初始化也是可以的。

这里我们再讲一下内存模拟的一个步骤：

  1. 执行初始化函数，例如ROM的就是memory_region_init_rom；
  2. 分配/挂载，memory_region_add_subregion，当然还会用上系统根节点获取get_system_memory；
  3. ROM设置（指令初始化）或者加载kernel

（二）举个例子

根据SOC指定地址编写MemMapEntry
在WIN从零开始在QMUE上添加一块自己的开发板（二）,虚拟机开发,c语言,c++,risc-v

enum
{
    NUCLEI_N_DEBUG,
    NUCLEI_N_ROM,
    NUCLEI_N_TIMER,
    NUCLEI_N_ECLIC,
    NUCLEI_N_GPIO,
    NUCLEI_N_UART0,
    NUCLEI_N_QSPI0,
    NUCLEI_N_PWM0,
    NUCLEI_N_UART1,
    NUCLEI_N_QSPI1,
    NUCLEI_N_PWM1,
    NUCLEI_N_QSPI2,
    NUCLEI_N_PWM2,
    NUCLEI_N_XIP,
    NUCLEI_N_DRAM,
    NUCLEI_N_ILM,
    NUCLEI_N_DLM
};

static MemMapEntry nuclei_n_memmap[] = {
    [NUCLEI_N_DEBUG] 	= 	{0x0, 0x1000},
    [NUCLEI_N_ROM] 		= 	{0x1000, 0x1000},
    [NUCLEI_N_TIMER] 	= 	{0x2000000, 0x1000},
    [NUCLEI_N_ECLIC] 	= 	{0xc000000, 0x10000},
    [NUCLEI_N_GPIO] 	= 	{0x10012000, 0x1000},
    [NUCLEI_N_UART0] 	= 	{0x10013000, 0x1000},
    [NUCLEI_N_QSPI0] 	= 	{0x10014000, 0x1000},
    [NUCLEI_N_PWM0] 	= 	{0x10015000, 0x1000},
    [NUCLEI_N_UART1] 	= 	{0x10023000, 0x1000},
    [NUCLEI_N_QSPI1] 	= 	{0x10024000, 0x1000},
    [NUCLEI_N_PWM1] 	= 	{0x10025000, 0x1000},
    [NUCLEI_N_QSPI2] 	= 	{0x10034000, 0x1000},
    [NUCLEI_N_PWM2] 	= 	{0x10035000, 0x1000},
    [NUCLEI_N_XIP] 		= 	{0x20000000, 0x10000000},
    [NUCLEI_N_DRAM] 	= 	{0xa0000000, 0x0},
    [NUCLEI_N_ILM] 		= 	{0x80000000, 0x20000},
    [NUCLEI_N_DLM] 		= 	rub{0x90000000, 0x20000},
};

之后我们初始化ROM地址：

/* Internal ROM */
	memory_region_init_rom(&s->internal_rom, OBJECT(obj), "riscv.nuclei.n.irom", memmap[NUCLEI_N_ROM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_ROM].base, &s->internal_rom);

这里我们假设idlm和ROM都为Soc外设：
于是我们编写相关函数：

static void nuclei_n_soc_memory_create(Object *obj)
{
	NucLeiNSoCState *s = NUCLEI_N_SOC(obj);
	const MemMapEntry *memmap = nuclei_n_memmap;
	MemoryRegion *sys_mem = get_system_memory();

	/* Internal ROM */
	memory_region_init_rom(&s->internal_rom, OBJECT(obj), "riscv.nuclei.n.irom", memmap[NUCLEI_N_ROM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_ROM].base, &s->internal_rom);

		
	/* Initialize ilm dlm */
    memory_region_init_ram(&s->ilm, NULL, "riscv.nuclei.n.ilm", memmap[NUCLEI_N_ILM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_ILM].base, &s->ilm);
    memory_region_init_ram(&s->dlm, NULL, "riscv.nuclei.n.dlm", memmap[NUCLEI_N_DLM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_DLM].base, &s->dlm);

	 /* SysTimer */
    create_unimplemented_device("riscv.nuclei.n.timer", memmap[NUCLEI_N_TIMER].base, memmap[NUCLEI_N_TIMER].size);
    /* Eclic */
    create_unimplemented_device("riscv.nuclei.n.eclic", memmap[NUCLEI_N_ECLIC].base, memmap[NUCLEI_N_ECLIC].size);
    /* GPIO */
    create_unimplemented_device("riscv.nuclei.n.gpio", memmap[NUCLEI_N_GPIO].base, memmap[NUCLEI_N_GPIO].size);
}

因为还没有实现一些设备，所以我们创建unimplemented设备来占用内存：

	 /* SysTimer */
    create_unimplemented_device("riscv.nuclei.n.timer", memmap[NUCLEI_N_TIMER].base, memmap[NUCLEI_N_TIMER].size);
    /* Eclic */
    create_unimplemented_device("riscv.nuclei.n.eclic", memmap[NUCLEI_N_ECLIC].base, memmap[NUCLEI_N_ECLIC].size);
    /* GPIO */
    create_unimplemented_device("riscv.nuclei.n.gpio", memmap[NUCLEI_N_GPIO].base, memmap[NUCLEI_N_GPIO].size);

这次我们把CPU的初始化和实例化也类似封装成一个函数：

static void nuclei_n_soc_cpu_create(Object *obj)
{
	MachineState *ms = MACHINE(qdev_get_machine());
	NucLeiNSoCState *s = NUCLEI_N_SOC(obj);
	object_initialize_child(obj, "cpus", &s->cpus, TYPE_RISCV_HART_ARRAY);  //初始化CPU

    object_property_set_str(OBJECT(&s->cpus), "cpu-type", ms->cpu_type, &error_abort);      
    object_property_set_int(OBJECT(&s->cpus), "num-harts", ms->smp.cpus, &error_abort);
    sysbus_realize(SYS_BUS_DEVICE(&s->cpus), &error_abort);            		//CPU实例化
}

然后我们在nuclei_n_soc_instance_init中调用：

static void nuclei_n_soc_instance_init(Object *obj)
{
	/* SOC CPU */
	nuclei_n_soc_cpu_create(obj);
	/* SOC Memory */
	nuclei_n_soc_memory_create(obj);
}

其次是设置ROM和加载kernel，我们在整个Machine实例中进行初始化：

static void nuclei_mcu_machine_init(MachineState *machine)
{
	NucLeiNState *s = MCU_FPGA_MACHINE(machine);
	const MemMapEntry *memmap = nuclei_n_memmap;
    target_ulong start_addr;
	int i;

	/* Initialize SOC */
	object_initialize_child(OBJECT(machine), "soc", &s->soc, TYPE_NUCLEI_N_SOC);
	qdev_realize(DEVICE(&s->soc), NULL, &error_abort);

	//选择启动方式
     switch (s->msel)
    {
    case MSEL_ILM:
        start_addr = memmap[NUCLEI_N_ILM].base;
        break;
    case MSEL_FLASH:
        start_addr = memmap[NUCLEI_N_XIP].base;
        break;
    case MSEL_FLASHXIP:
        start_addr = memmap[NUCLEI_N_XIP].base;
        break;
    case MSEL_DDR:
        start_addr = memmap[NUCLEI_N_DRAM].base;
        break;
    default:
        start_addr = memmap[NUCLEI_N_ILM].base;
        break;
    }

       /* reset vector */
    uint32_t reset_vec[8] = {
        0x00000297, /* 1:  auipc  t0, %pcrel_hi(dtb) */
        0x02028593, /*     addi   a1, t0, %pcrel_lo(1b) */
        0xf1402573, /*     csrr   a0, mhartid  */
#if defined(TARGET_RISCV32)
        0x0182a283, /*     lw     t0, 24(t0) */
#elif defined(TARGET_RISCV64)
        0x0182b283, /*     ld     t0, 24(t0) */
#endif
        0x00028067, /*     jr     t0 */
        0x00000000,
        start_addr, /* start: .dword DRAM_BASE */
        0x00000000,
    };

    /* copy in the reset vector in little_endian byte order */
    for (i = 0; i < sizeof(reset_vec) >> 2; i++)
    {
        reset_vec[i] = cpu_to_le32(reset_vec[i]);
    }
    rom_add_blob_fixed_as("mrom.reset", reset_vec, sizeof(reset_vec),
                          memmap[NUCLEI_N_ROM].base, &address_space_memory); //CPU初始化地址

    /* boot rom */
    if (machine->kernel_filename)
    {
		riscv_load_kernel(machine, &s->soc.cpus, start_addr, true, NULL);	//将裸机代码加载到地址start_addr
       // riscv_load_kernel(machine->kernel_filename, start_addr, NULL);  
    }
}

测试

我们进行测试：
编译完成后运行程序并执行：

info mtree

在WIN从零开始在QMUE上添加一块自己的开发板（二）,虚拟机开发,c语言,c++,risc-v

结尾附上完整代码：
nuclei_n.h：

#include "hw/boards.h"
#include "hw/riscv/riscv_hart.h"
#include "hw/sysbus.h"

#define TYPE_NUCLEI_N_SOC "riscv.nuclei.n.soc"
#define NUCLEI_N_SOC(obj) \
    OBJECT_CHECK(NucLeiNSoCState, (obj), TYPE_NUCLEI_N_SOC)

/* CPU 定义 */
#define NUCLEI_N_CPU TYPE_RISCV_CPU_NUCLEI_N600

typedef struct NucLeiNSoCState
{
	/*< private >*/
	DeviceState parent_obj;
	/*< public >*/
	RISCVHartArrayState cpus;

	MemoryRegion internal_rom;
    MemoryRegion ilm;
    MemoryRegion dlm;
    MemoryRegion xip_mem;
} NucLeiNSoCState;


/* Machine state定义 */
#define TYPE_NUCLEI_MCU_FPGA_MACHINE MACHINE_TYPE_NAME("mcu_200t")
#define MCU_FPGA_MACHINE(obj) \
    OBJECT_CHECK(NucLeiNState, (obj), TYPE_NUCLEI_MCU_FPGA_MACHINE)

typedef struct NucLeiNState
{
	/*< private >*/
	MachineState parent;
	/*< public >*/
	NucLeiNSoCState soc;
	
	 uint32_t msel;
} NucLeiNState;

enum
{
    MSEL_ILM = 1,
    MSEL_FLASH = 2,
    MSEL_FLASHXIP = 3,
    MSEL_DDR = 4
};

enum
{
    NUCLEI_N_DEBUG,
    NUCLEI_N_ROM,
    NUCLEI_N_TIMER,
    NUCLEI_N_ECLIC,
    NUCLEI_N_GPIO,
    NUCLEI_N_UART0,
    NUCLEI_N_QSPI0,
    NUCLEI_N_PWM0,
    NUCLEI_N_UART1,
    NUCLEI_N_QSPI1,
    NUCLEI_N_PWM1,
    NUCLEI_N_QSPI2,
    NUCLEI_N_PWM2,
    NUCLEI_N_XIP,
    NUCLEI_N_DRAM,
    NUCLEI_N_ILM,
    NUCLEI_N_DLM
};

nuclei_n.c：文章来源地址https://www.toymoban.com/news/detail-811400.html

#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "hw/riscv/nuclei_n.h"
#include "qapi/visitor.h"
#include "hw/boards.h"
#include "hw/loader.h"
#include "hw/sysbus.h"
#include "target/riscv/cpu.h"
#include "hw/misc/unimp.h"
#include "hw/riscv/riscv_hart.h"
#include "hw/riscv/boot.h"


static MemMapEntry nuclei_n_memmap[] = {
    [NUCLEI_N_DEBUG] 	= 	{0x0, 0x1000},
    [NUCLEI_N_ROM] 		= 	{0x1000, 0x1000},
    [NUCLEI_N_TIMER] 	= 	{0x2000000, 0x1000},
    [NUCLEI_N_ECLIC] 	= 	{0xc000000, 0x10000},
    [NUCLEI_N_GPIO] 	= 	{0x10012000, 0x1000},
    [NUCLEI_N_UART0] 	= 	{0x10013000, 0x1000},
    [NUCLEI_N_QSPI0] 	= 	{0x10014000, 0x1000},
    [NUCLEI_N_PWM0] 	= 	{0x10015000, 0x1000},
    [NUCLEI_N_UART1] 	= 	{0x10023000, 0x1000},
    [NUCLEI_N_QSPI1] 	= 	{0x10024000, 0x1000},
    [NUCLEI_N_PWM1] 	= 	{0x10025000, 0x1000},
    [NUCLEI_N_QSPI2] 	= 	{0x10034000, 0x1000},
    [NUCLEI_N_PWM2] 	= 	{0x10035000, 0x1000},
    [NUCLEI_N_XIP] 		= 	{0x20000000, 0x10000000},
    [NUCLEI_N_DRAM] 	= 	{0xa0000000, 0x0},
    [NUCLEI_N_ILM] 		= 	{0x80000000, 0x20000},
    [NUCLEI_N_DLM] 		= 	{0x90000000, 0x20000},
};


static void nuclei_n_soc_cpu_create(Object *obj)
{
	MachineState *ms = MACHINE(qdev_get_machine());
	NucLeiNSoCState *s = NUCLEI_N_SOC(obj);
	object_initialize_child(obj, "cpus", &s->cpus, TYPE_RISCV_HART_ARRAY);  //初始化CPU

    object_property_set_str(OBJECT(&s->cpus), "cpu-type", ms->cpu_type, &error_abort);      
    object_property_set_int(OBJECT(&s->cpus), "num-harts", ms->smp.cpus, &error_abort);
    sysbus_realize(SYS_BUS_DEVICE(&s->cpus), &error_abort);            		//CPU实例化
}

static void nuclei_n_soc_memory_create(Object *obj)
{
	NucLeiNSoCState *s = NUCLEI_N_SOC(obj);
	const MemMapEntry *memmap = nuclei_n_memmap;
	MemoryRegion *sys_mem = get_system_memory();

	/* Internal ROM */
	memory_region_init_rom(&s->internal_rom, OBJECT(obj), "riscv.nuclei.n.irom", memmap[NUCLEI_N_ROM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_ROM].base, &s->internal_rom);

		
	/* Initialize ilm dlm */
    memory_region_init_ram(&s->ilm, NULL, "riscv.nuclei.n.ilm", memmap[NUCLEI_N_ILM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_ILM].base, &s->ilm);
    memory_region_init_ram(&s->dlm, NULL, "riscv.nuclei.n.dlm", memmap[NUCLEI_N_DLM].size, &error_fatal);
    memory_region_add_subregion(sys_mem, memmap[NUCLEI_N_DLM].base, &s->dlm);

	 /* SysTimer */
    create_unimplemented_device("riscv.nuclei.n.timer",
    memmap[NUCLEI_N_TIMER].base, memmap[NUCLEI_N_TIMER].size);
    /* Eclic */
    create_unimplemented_device("riscv.nuclei.n.eclic",
    memmap[NUCLEI_N_ECLIC].base, memmap[NUCLEI_N_ECLIC].size);
    /* GPIO */
    create_unimplemented_device("riscv.nuclei.n.gpio",
    memmap[NUCLEI_N_GPIO].base, memmap[NUCLEI_N_GPIO].size);
}

static void nuclei_n_soc_instance_init(Object *obj)
{
	/* SOC CPU */
	nuclei_n_soc_cpu_create(obj);
	/* SOC Memory */
	nuclei_n_soc_memory_create(obj);
}

static void nuclei_n_soc_class_init(ObjectClass *oc, void *data)
{
	DeviceClass *dc = DEVICE_CLASS(oc);
	dc->user_creatable = false;
}

static const TypeInfo nuclei_n_soc_type_info = {
	.name = TYPE_NUCLEI_N_SOC,
	.parent = TYPE_DEVICE,
	.instance_size = sizeof(NucLeiNSoCState),
	.instance_init = nuclei_n_soc_instance_init,
	.class_init = nuclei_n_soc_class_init,
};
static void nuclei_n_soc_register_types(void)
{
	type_register_static(&nuclei_n_soc_type_info);
}
type_init(nuclei_n_soc_register_types)

static void nuclei_mcu_machine_init(MachineState *machine)
{
	NucLeiNState *s = MCU_FPGA_MACHINE(machine);
	const MemMapEntry *memmap = nuclei_n_memmap;
    target_ulong start_addr;
	int i;

	/* Initialize SOC */
	object_initialize_child(OBJECT(machine), "soc", &s->soc, TYPE_NUCLEI_N_SOC);
	qdev_realize(DEVICE(&s->soc), NULL, &error_abort);

	//选择启动方式
     switch (s->msel)
    {
    case MSEL_ILM:
        start_addr = memmap[NUCLEI_N_ILM].base;
        break;
    case MSEL_FLASH:
        start_addr = memmap[NUCLEI_N_XIP].base;
        break;
    case MSEL_FLASHXIP:
        start_addr = memmap[NUCLEI_N_XIP].base;
        break;
    case MSEL_DDR:
        start_addr = memmap[NUCLEI_N_DRAM].base;
        break;
    default:
        start_addr = memmap[NUCLEI_N_ILM].base;
        break;
    }

       /* reset vector */
    uint32_t reset_vec[8] = {
        0x00000297, /* 1:  auipc  t0, %pcrel_hi(dtb) */
        0x02028593, /*     addi   a1, t0, %pcrel_lo(1b) */
        0xf1402573, /*     csrr   a0, mhartid  */
#if defined(TARGET_RISCV32)
        0x0182a283, /*     lw     t0, 24(t0) */
#elif defined(TARGET_RISCV64)
        0x0182b283, /*     ld     t0, 24(t0) */
#endif
        0x00028067, /*     jr     t0 */
        0x00000000,
        start_addr, /* start: .dword DRAM_BASE */
        0x00000000,
    };

    /* copy in the reset vector in little_endian byte order */
    for (i = 0; i < sizeof(reset_vec) >> 2; i++)
    {
        reset_vec[i] = cpu_to_le32(reset_vec[i]);
    }
    rom_add_blob_fixed_as("mrom.reset", reset_vec, sizeof(reset_vec),
                          memmap[NUCLEI_N_ROM].base, &address_space_memory); //CPU初始化地址

    /* boot rom */
    if (machine->kernel_filename)
    {
		riscv_load_kernel(machine, &s->soc.cpus, start_addr, true, NULL);	//将裸机代码加载到地址start_addr
       // riscv_load_kernel(machine->kernel_filename, start_addr, NULL);  
    }
}


static void nuclei_machine_class_init(ObjectClass *oc, void *data)
{
	MachineClass *mc = MACHINE_CLASS(oc);
    mc->desc = "Nuclei MCU 200T FPGA Evaluation Kit";
	mc->init = nuclei_mcu_machine_init;
	mc->max_cpus = 1;
    mc->default_cpu_type = NUCLEI_N_CPU;
}

static const TypeInfo nuclei_machine_typeinfo = {
	.name = TYPE_NUCLEI_MCU_FPGA_MACHINE,
	.parent = TYPE_MACHINE,
	.class_init = nuclei_machine_class_init,
	.instance_size = sizeof(NucLeiNState),
};
static void nuclei_machine_init_register_types(void)
{
	type_register_static(&nuclei_machine_typeinfo);
}
type_init(nuclei_machine_init_register_types)

参考资料

  1. [完结]从零开始的RISC-V模拟器开发·第一季·2021春季
  2. 新建quard-star开发板

到了这里，关于在WIN从零开始在QMUE上添加一块自己的开发板（二）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • LeetCode 刷题记录——从零开始记录自己一些不会的

    LeetCode 刷题记录——从零开始记录自己一些不会的

    1. 最多可以摧毁的敌人城堡数目 题意 思路 两层循环，太low了 用一个变量记录前一个位置 代码 2. 到达终点的数字 题意 思路 代码 3. 单词的压缩编码 题意 思路 代码 思路2 去找到是否不同的单词具有相同的后缀，我们可以将其反序之后插入字典树中。例如，我们有 “time”

    2024年02月09日
    浏览(67)
  • 一篇SEO指南：新手如何从零开始优化自己的网站

    一篇SEO指南：新手如何从零开始优化自己的网站

    在如今的数字时代，拥有一个优化良好的网站对于任何企业或个人来说都是至关重要的。但是，对于SEO新手来说，如何从零开始优化自己的网站可能是一项看似艰巨的任务。在本文中，我们将为您提供一份SEO指南，帮助您了解从零开始优化自己的网站的过程。 确定您的目标关

    2024年02月02日
    浏览(112)
  • 从零开始画自己的DAG作业依赖图(一)--前期准备

    从零开始画自己的DAG作业依赖图(一)--前期准备

    背景： 由于业务场景需要展示作业之间的依赖关系，由于一些开源的插件和当前的业务逻辑有一些冲突，个人打算尝试从零开始，一点点实现自己的DAG图。同时用博客记录自己实现过程和总结，不正确的地方，欢迎指正提升。 场景分析： 数据开发中常常有作业之间的依赖，

    2024年02月05日
    浏览(52)
  • 构建自己的ChatGPT：从零开始构建个性化语言模型

    构建自己的ChatGPT：从零开始构建个性化语言模型

    🌷🍁 博主 libin9iOak带您 Go to New World.✨🍁 🦄 个人主页——libin9iOak的博客🎐 🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍》学会IDEA常用操作，工作效率翻倍~💐 🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬

    2024年02月15日
    浏览(48)
  • 记录自己从零开始创建个人小程序到发布的大致过程

    记录自己从零开始创建个人小程序到发布的大致过程

    首先不管是要创建个人小程序还是公众号等，都要打开微信公众平台。本文以微信小程序为例，创建一个手工花名片。本文只用于自己学习记录。参考微信社区 1、打开微信公众，点击注册 链接：https://mp.weixin.qq.com/ 2、点击注册后，跳转页面，点击小程序 3、填写注册小程序

    2024年02月12日
    浏览(53)
  • 从零开始复现seaformer(语义分割)训练自己的数据集——linux

    从零开始复现seaformer(语义分割)训练自己的数据集——linux

    出于模型轻量化需求，需对原有的皮肤分割模型进行重新研发。seaformer是作为今年复旦大学和腾讯联合提出的轻量级语义分割算法，具有很好的参考价值。因此，作者基于seaformer算法对自研数据集进行训练，完成轻量级皮肤分割模型的开发。 1.下载地址：https://github.com/fudan

    2024年04月12日
    浏览(36)

  • 深入浅出Python：从零开始搭建自己的Web服务器

    第一部分：前言与环境准备 1. 前言 随着互联网的发展，越来越多的应用都运行在Web上，而Web服务器则成为了支撑这一切的关键。在本文中，我们将利用Python来创建自己的简易Web服务器。通过这个过程，你不仅可以深入了解Web服务器的工作原理，还能够掌握Python的基础知识。

    2024年02月03日
    浏览(63)
  • 从零开始使用C#做一个自己的UDP传输JSON数据应用

    从零开始使用C#做一个自己的UDP传输JSON数据应用

    2024年04月10日
    浏览(61)
  • 【SpringBoot】从零开始封装自己的starter并且引入到其他项目中使用

    【SpringBoot】从零开始封装自己的starter并且引入到其他项目中使用

    简介 本文将介绍如何从零开始封装自己的starter并且引入到其他项目中使用 为什么要自己封装starter？ 这样可以对spring以及其他第三方提供的starter做二次封装或者封装一些自己需要的内容提供给其他项目使用，提高项目级的代码复用性。 一、创建一个新的spring-boot项目 首先我

    2024年02月16日
    浏览(61)
  • Python 从零开始制作自己的声音 - wave模块读写wav文件详解

    Python 从零开始制作自己的声音 - wave模块读写wav文件详解

    计算机经常被用于处理音频这种真实世界中的数据。声音经过采样，量化和编码后，存储在音频文件，如wav文件中。 文章首先介绍wave模块的基础用法; 再通过生成一定频率声波的算法实现，来深入讲解wave库的使用。 wave 模块提供了一个处理 wav 声音格式的便利接口, 可获取

    2023年04月09日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包