2020-09-01 03:38:59 +02:00
|
|
|
/*
|
|
|
|
* QEMU RISC-V Board Compatible with Microchip PolarFire SoC Icicle Kit
|
|
|
|
*
|
|
|
|
* Copyright (c) 2020 Wind River Systems, Inc.
|
|
|
|
*
|
|
|
|
* Author:
|
|
|
|
* Bin Meng <bin.meng@windriver.com>
|
|
|
|
*
|
|
|
|
* Provides a board compatible with the Microchip PolarFire SoC Icicle Kit
|
|
|
|
*
|
|
|
|
* 0) CLINT (Core Level Interruptor)
|
|
|
|
* 1) PLIC (Platform Level Interrupt Controller)
|
|
|
|
* 2) eNVM (Embedded Non-Volatile Memory)
|
2020-09-01 03:39:01 +02:00
|
|
|
* 3) MMUARTs (Multi-Mode UART)
|
2020-09-01 03:39:03 +02:00
|
|
|
* 4) Cadence eMMC/SDHC controller and an SD card connected to it
|
2020-09-01 03:39:05 +02:00
|
|
|
* 5) SiFive Platform DMA (Direct Memory Access Controller)
|
2020-09-01 03:39:08 +02:00
|
|
|
* 6) GEM (Gigabit Ethernet MAC Controller)
|
2020-10-28 06:30:03 +01:00
|
|
|
* 7) DMC (DDR Memory Controller)
|
2020-10-28 06:30:05 +01:00
|
|
|
* 8) IOSCB modules
|
2020-09-01 03:38:59 +02:00
|
|
|
*
|
|
|
|
* This board currently generates devicetree dynamically that indicates at least
|
|
|
|
* two harts and up to five harts.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2 or later, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "qemu/error-report.h"
|
|
|
|
#include "qemu/units.h"
|
|
|
|
#include "qemu/cutils.h"
|
|
|
|
#include "qapi/error.h"
|
|
|
|
#include "hw/boards.h"
|
|
|
|
#include "hw/loader.h"
|
|
|
|
#include "hw/sysbus.h"
|
2020-09-01 03:39:01 +02:00
|
|
|
#include "chardev/char.h"
|
2020-09-01 03:38:59 +02:00
|
|
|
#include "hw/cpu/cluster.h"
|
|
|
|
#include "target/riscv/cpu.h"
|
|
|
|
#include "hw/misc/unimp.h"
|
|
|
|
#include "hw/riscv/boot.h"
|
|
|
|
#include "hw/riscv/riscv_hart.h"
|
|
|
|
#include "hw/riscv/microchip_pfsoc.h"
|
2021-08-31 13:06:00 +02:00
|
|
|
#include "hw/intc/riscv_aclint.h"
|
2020-09-03 12:40:17 +02:00
|
|
|
#include "hw/intc/sifive_plic.h"
|
2021-04-30 09:13:02 +02:00
|
|
|
#include "sysemu/device_tree.h"
|
2020-09-01 03:39:01 +02:00
|
|
|
#include "sysemu/sysemu.h"
|
2020-09-01 03:38:59 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The BIOS image used by this machine is called Hart Software Services (HSS).
|
|
|
|
* See https://github.com/polarfire-soc/hart-software-services
|
|
|
|
*/
|
|
|
|
#define BIOS_FILENAME "hss.bin"
|
|
|
|
#define RESET_VECTOR 0x20220000
|
|
|
|
|
2020-09-01 03:39:10 +02:00
|
|
|
/* CLINT timebase frequency */
|
|
|
|
#define CLINT_TIMEBASE_FREQ 1000000
|
|
|
|
|
2020-09-01 03:39:08 +02:00
|
|
|
/* GEM version */
|
|
|
|
#define GEM_REVISION 0x0107010c
|
|
|
|
|
2020-10-28 06:30:01 +01:00
|
|
|
/*
|
|
|
|
* The complete description of the whole PolarFire SoC memory map is scattered
|
|
|
|
* in different documents. There are several places to look at for memory maps:
|
|
|
|
*
|
|
|
|
* 1 Chapter 11 "MSS Memory Map", in the doc "UG0880: PolarFire SoC FPGA
|
|
|
|
* Microprocessor Subsystem (MSS) User Guide", which can be downloaded from
|
|
|
|
* https://www.microsemi.com/document-portal/doc_download/
|
|
|
|
* 1244570-ug0880-polarfire-soc-fpga-microprocessor-subsystem-mss-user-guide,
|
|
|
|
* describes the whole picture of the PolarFire SoC memory map.
|
|
|
|
*
|
|
|
|
* 2 A zip file for PolarFire soC memory map, which can be downloaded from
|
|
|
|
* https://www.microsemi.com/document-portal/doc_download/
|
|
|
|
* 1244581-polarfire-soc-register-map, contains the following 2 major parts:
|
|
|
|
* - Register Map/PF_SoC_RegMap_V1_1/pfsoc_regmap.htm
|
|
|
|
* describes the complete integrated peripherals memory map
|
|
|
|
* - Register Map/PF_SoC_RegMap_V1_1/MPFS250T/mpfs250t_ioscb_memmap_dri.htm
|
|
|
|
* describes the complete IOSCB modules memory maps
|
|
|
|
*/
|
2021-02-20 15:48:04 +01:00
|
|
|
static const MemMapEntry microchip_pfsoc_memmap[] = {
|
2022-11-17 23:55:17 +01:00
|
|
|
[MICROCHIP_PFSOC_RSVD0] = { 0x0, 0x100 },
|
|
|
|
[MICROCHIP_PFSOC_DEBUG] = { 0x100, 0xf00 },
|
|
|
|
[MICROCHIP_PFSOC_E51_DTIM] = { 0x1000000, 0x2000 },
|
|
|
|
[MICROCHIP_PFSOC_BUSERR_UNIT0] = { 0x1700000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_BUSERR_UNIT1] = { 0x1701000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_BUSERR_UNIT2] = { 0x1702000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_BUSERR_UNIT3] = { 0x1703000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_BUSERR_UNIT4] = { 0x1704000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_CLINT] = { 0x2000000, 0x10000 },
|
|
|
|
[MICROCHIP_PFSOC_L2CC] = { 0x2010000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_DMA] = { 0x3000000, 0x100000 },
|
|
|
|
[MICROCHIP_PFSOC_L2LIM] = { 0x8000000, 0x2000000 },
|
|
|
|
[MICROCHIP_PFSOC_PLIC] = { 0xc000000, 0x4000000 },
|
|
|
|
[MICROCHIP_PFSOC_MMUART0] = { 0x20000000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_WDOG0] = { 0x20001000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_SYSREG] = { 0x20002000, 0x2000 },
|
|
|
|
[MICROCHIP_PFSOC_AXISW] = { 0x20004000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_MPUCFG] = { 0x20005000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_FMETER] = { 0x20006000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_DDR_SGMII_PHY] = { 0x20007000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_EMMC_SD] = { 0x20008000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_DDR_CFG] = { 0x20080000, 0x40000 },
|
|
|
|
[MICROCHIP_PFSOC_MMUART1] = { 0x20100000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_MMUART2] = { 0x20102000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_MMUART3] = { 0x20104000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_MMUART4] = { 0x20106000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_WDOG1] = { 0x20101000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_WDOG2] = { 0x20103000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_WDOG3] = { 0x20105000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_WDOG4] = { 0x20106000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_SPI0] = { 0x20108000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_SPI1] = { 0x20109000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_I2C0] = { 0x2010a000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_I2C1] = { 0x2010b000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_CAN0] = { 0x2010c000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_CAN1] = { 0x2010d000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_GEM0] = { 0x20110000, 0x2000 },
|
|
|
|
[MICROCHIP_PFSOC_GEM1] = { 0x20112000, 0x2000 },
|
|
|
|
[MICROCHIP_PFSOC_GPIO0] = { 0x20120000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_GPIO1] = { 0x20121000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_GPIO2] = { 0x20122000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_RTC] = { 0x20124000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_ENVM_CFG] = { 0x20200000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_ENVM_DATA] = { 0x20220000, 0x20000 },
|
|
|
|
[MICROCHIP_PFSOC_USB] = { 0x20201000, 0x1000 },
|
|
|
|
[MICROCHIP_PFSOC_QSPI_XIP] = { 0x21000000, 0x1000000 },
|
|
|
|
[MICROCHIP_PFSOC_IOSCB] = { 0x30000000, 0x10000000 },
|
|
|
|
[MICROCHIP_PFSOC_FABRIC_FIC0] = { 0x2000000000, 0x1000000000 },
|
|
|
|
[MICROCHIP_PFSOC_FABRIC_FIC1] = { 0x3000000000, 0x1000000000 },
|
|
|
|
[MICROCHIP_PFSOC_FABRIC_FIC3] = { 0x40000000, 0x20000000 },
|
|
|
|
[MICROCHIP_PFSOC_DRAM_LO] = { 0x80000000, 0x40000000 },
|
|
|
|
[MICROCHIP_PFSOC_DRAM_LO_ALIAS] = { 0xc0000000, 0x40000000 },
|
|
|
|
[MICROCHIP_PFSOC_DRAM_HI] = { 0x1000000000, 0x0 },
|
|
|
|
[MICROCHIP_PFSOC_DRAM_HI_ALIAS] = { 0x1400000000, 0x0 },
|
|
|
|
|
2020-09-01 03:38:59 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static void microchip_pfsoc_soc_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
MachineState *ms = MACHINE(qdev_get_machine());
|
|
|
|
MicrochipPFSoCState *s = MICROCHIP_PFSOC(obj);
|
|
|
|
|
|
|
|
object_initialize_child(obj, "e-cluster", &s->e_cluster, TYPE_CPU_CLUSTER);
|
|
|
|
qdev_prop_set_uint32(DEVICE(&s->e_cluster), "cluster-id", 0);
|
|
|
|
|
|
|
|
object_initialize_child(OBJECT(&s->e_cluster), "e-cpus", &s->e_cpus,
|
|
|
|
TYPE_RISCV_HART_ARRAY);
|
|
|
|
qdev_prop_set_uint32(DEVICE(&s->e_cpus), "num-harts", 1);
|
|
|
|
qdev_prop_set_uint32(DEVICE(&s->e_cpus), "hartid-base", 0);
|
|
|
|
qdev_prop_set_string(DEVICE(&s->e_cpus), "cpu-type",
|
|
|
|
TYPE_RISCV_CPU_SIFIVE_E51);
|
|
|
|
qdev_prop_set_uint64(DEVICE(&s->e_cpus), "resetvec", RESET_VECTOR);
|
|
|
|
|
|
|
|
object_initialize_child(obj, "u-cluster", &s->u_cluster, TYPE_CPU_CLUSTER);
|
|
|
|
qdev_prop_set_uint32(DEVICE(&s->u_cluster), "cluster-id", 1);
|
|
|
|
|
|
|
|
object_initialize_child(OBJECT(&s->u_cluster), "u-cpus", &s->u_cpus,
|
|
|
|
TYPE_RISCV_HART_ARRAY);
|
|
|
|
qdev_prop_set_uint32(DEVICE(&s->u_cpus), "num-harts", ms->smp.cpus - 1);
|
|
|
|
qdev_prop_set_uint32(DEVICE(&s->u_cpus), "hartid-base", 1);
|
|
|
|
qdev_prop_set_string(DEVICE(&s->u_cpus), "cpu-type",
|
|
|
|
TYPE_RISCV_CPU_SIFIVE_U54);
|
|
|
|
qdev_prop_set_uint64(DEVICE(&s->u_cpus), "resetvec", RESET_VECTOR);
|
2020-09-01 03:39:03 +02:00
|
|
|
|
2020-09-01 03:39:05 +02:00
|
|
|
object_initialize_child(obj, "dma-controller", &s->dma,
|
|
|
|
TYPE_SIFIVE_PDMA);
|
|
|
|
|
2020-10-28 06:30:07 +01:00
|
|
|
object_initialize_child(obj, "sysreg", &s->sysreg,
|
|
|
|
TYPE_MCHP_PFSOC_SYSREG);
|
|
|
|
|
2020-10-28 06:30:03 +01:00
|
|
|
object_initialize_child(obj, "ddr-sgmii-phy", &s->ddr_sgmii_phy,
|
|
|
|
TYPE_MCHP_PFSOC_DDR_SGMII_PHY);
|
|
|
|
object_initialize_child(obj, "ddr-cfg", &s->ddr_cfg,
|
|
|
|
TYPE_MCHP_PFSOC_DDR_CFG);
|
|
|
|
|
2020-09-01 03:39:08 +02:00
|
|
|
object_initialize_child(obj, "gem0", &s->gem0, TYPE_CADENCE_GEM);
|
|
|
|
object_initialize_child(obj, "gem1", &s->gem1, TYPE_CADENCE_GEM);
|
|
|
|
|
2020-09-01 03:39:03 +02:00
|
|
|
object_initialize_child(obj, "sd-controller", &s->sdhci,
|
|
|
|
TYPE_CADENCE_SDHCI);
|
2020-10-28 06:30:05 +01:00
|
|
|
|
|
|
|
object_initialize_child(obj, "ioscb", &s->ioscb, TYPE_MCHP_PFSOC_IOSCB);
|
2020-09-01 03:38:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void microchip_pfsoc_soc_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
MachineState *ms = MACHINE(qdev_get_machine());
|
|
|
|
MicrochipPFSoCState *s = MICROCHIP_PFSOC(dev);
|
2021-02-20 15:48:04 +01:00
|
|
|
const MemMapEntry *memmap = microchip_pfsoc_memmap;
|
2020-09-01 03:38:59 +02:00
|
|
|
MemoryRegion *system_memory = get_system_memory();
|
2020-10-28 06:30:08 +01:00
|
|
|
MemoryRegion *rsvd0_mem = g_new(MemoryRegion, 1);
|
2020-09-01 03:38:59 +02:00
|
|
|
MemoryRegion *e51_dtim_mem = g_new(MemoryRegion, 1);
|
|
|
|
MemoryRegion *l2lim_mem = g_new(MemoryRegion, 1);
|
|
|
|
MemoryRegion *envm_data = g_new(MemoryRegion, 1);
|
2020-11-12 08:49:51 +01:00
|
|
|
MemoryRegion *qspi_xip_mem = g_new(MemoryRegion, 1);
|
2020-09-01 03:38:59 +02:00
|
|
|
char *plic_hart_config;
|
2020-09-01 03:39:08 +02:00
|
|
|
NICInfo *nd;
|
2020-09-01 03:38:59 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->e_cpus), &error_abort);
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->u_cpus), &error_abort);
|
|
|
|
/*
|
|
|
|
* The cluster must be realized after the RISC-V hart array container,
|
|
|
|
* as the container's CPU object is only created on realize, and the
|
|
|
|
* CPU must exist and have been parented into the cluster before the
|
|
|
|
* cluster is realized.
|
|
|
|
*/
|
|
|
|
qdev_realize(DEVICE(&s->e_cluster), NULL, &error_abort);
|
|
|
|
qdev_realize(DEVICE(&s->u_cluster), NULL, &error_abort);
|
|
|
|
|
2020-10-28 06:30:08 +01:00
|
|
|
/* Reserved Memory at address 0 */
|
|
|
|
memory_region_init_ram(rsvd0_mem, NULL, "microchip.pfsoc.rsvd0_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_RSVD0].size, &error_fatal);
|
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_RSVD0].base,
|
|
|
|
rsvd0_mem);
|
|
|
|
|
2020-09-01 03:38:59 +02:00
|
|
|
/* E51 DTIM */
|
|
|
|
memory_region_init_ram(e51_dtim_mem, NULL, "microchip.pfsoc.e51_dtim_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_E51_DTIM].size, &error_fatal);
|
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_E51_DTIM].base,
|
|
|
|
e51_dtim_mem);
|
|
|
|
|
|
|
|
/* Bus Error Units */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.buserr_unit0_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT0].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.buserr_unit1_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT1].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.buserr_unit2_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT2].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT2].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.buserr_unit3_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT3].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT3].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.buserr_unit4_mem",
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT4].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_BUSERR_UNIT4].size);
|
|
|
|
|
|
|
|
/* CLINT */
|
2021-08-31 13:06:01 +02:00
|
|
|
riscv_aclint_swi_create(memmap[MICROCHIP_PFSOC_CLINT].base,
|
|
|
|
0, ms->smp.cpus, false);
|
|
|
|
riscv_aclint_mtimer_create(
|
|
|
|
memmap[MICROCHIP_PFSOC_CLINT].base + RISCV_ACLINT_SWI_SIZE,
|
|
|
|
RISCV_ACLINT_DEFAULT_MTIMER_SIZE, 0, ms->smp.cpus,
|
|
|
|
RISCV_ACLINT_DEFAULT_MTIMECMP, RISCV_ACLINT_DEFAULT_MTIME,
|
2020-09-01 03:39:10 +02:00
|
|
|
CLINT_TIMEBASE_FREQ, false);
|
2020-09-01 03:38:59 +02:00
|
|
|
|
|
|
|
/* L2 cache controller */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.l2cc",
|
|
|
|
memmap[MICROCHIP_PFSOC_L2CC].base, memmap[MICROCHIP_PFSOC_L2CC].size);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add L2-LIM at reset size.
|
|
|
|
* This should be reduced in size as the L2 Cache Controller WayEnable
|
|
|
|
* register is incremented. Unfortunately I don't see a nice (or any) way
|
|
|
|
* to handle reducing or blocking out the L2 LIM while still allowing it
|
|
|
|
* be re returned to all enabled after a reset. For the time being, just
|
|
|
|
* leave it enabled all the time. This won't break anything, but will be
|
|
|
|
* too generous to misbehaving guests.
|
|
|
|
*/
|
|
|
|
memory_region_init_ram(l2lim_mem, NULL, "microchip.pfsoc.l2lim",
|
|
|
|
memmap[MICROCHIP_PFSOC_L2LIM].size, &error_fatal);
|
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_L2LIM].base,
|
|
|
|
l2lim_mem);
|
|
|
|
|
|
|
|
/* create PLIC hart topology configuration string */
|
2021-10-22 08:01:32 +02:00
|
|
|
plic_hart_config = riscv_plic_hart_config_string(ms->smp.cpus);
|
2020-09-01 03:38:59 +02:00
|
|
|
|
|
|
|
/* PLIC */
|
|
|
|
s->plic = sifive_plic_create(memmap[MICROCHIP_PFSOC_PLIC].base,
|
2021-08-30 07:35:02 +02:00
|
|
|
plic_hart_config, ms->smp.cpus, 0,
|
2020-09-01 03:38:59 +02:00
|
|
|
MICROCHIP_PFSOC_PLIC_NUM_SOURCES,
|
|
|
|
MICROCHIP_PFSOC_PLIC_NUM_PRIORITIES,
|
|
|
|
MICROCHIP_PFSOC_PLIC_PRIORITY_BASE,
|
|
|
|
MICROCHIP_PFSOC_PLIC_PENDING_BASE,
|
|
|
|
MICROCHIP_PFSOC_PLIC_ENABLE_BASE,
|
|
|
|
MICROCHIP_PFSOC_PLIC_ENABLE_STRIDE,
|
|
|
|
MICROCHIP_PFSOC_PLIC_CONTEXT_BASE,
|
|
|
|
MICROCHIP_PFSOC_PLIC_CONTEXT_STRIDE,
|
|
|
|
memmap[MICROCHIP_PFSOC_PLIC].size);
|
|
|
|
g_free(plic_hart_config);
|
|
|
|
|
2020-09-01 03:39:05 +02:00
|
|
|
/* DMA */
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->dma), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->dma), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_DMA].base);
|
|
|
|
for (i = 0; i < SIFIVE_PDMA_IRQS; i++) {
|
|
|
|
sysbus_connect_irq(SYS_BUS_DEVICE(&s->dma), i,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic),
|
|
|
|
MICROCHIP_PFSOC_DMA_IRQ0 + i));
|
|
|
|
}
|
|
|
|
|
2020-09-01 03:38:59 +02:00
|
|
|
/* SYSREG */
|
2020-10-28 06:30:07 +01:00
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->sysreg), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sysreg), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_SYSREG].base);
|
2022-11-17 23:55:18 +01:00
|
|
|
sysbus_connect_irq(SYS_BUS_DEVICE(&s->sysreg), 0,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic),
|
|
|
|
MICROCHIP_PFSOC_MAILBOX_IRQ));
|
2020-09-01 03:38:59 +02:00
|
|
|
|
2022-08-13 15:51:27 +02:00
|
|
|
/* AXISW */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.axisw",
|
|
|
|
memmap[MICROCHIP_PFSOC_AXISW].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_AXISW].size);
|
|
|
|
|
2020-09-01 03:38:59 +02:00
|
|
|
/* MPUCFG */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.mpucfg",
|
|
|
|
memmap[MICROCHIP_PFSOC_MPUCFG].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_MPUCFG].size);
|
|
|
|
|
2022-08-13 15:51:27 +02:00
|
|
|
/* FMETER */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.fmeter",
|
|
|
|
memmap[MICROCHIP_PFSOC_FMETER].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_FMETER].size);
|
|
|
|
|
2020-10-28 06:30:03 +01:00
|
|
|
/* DDR SGMII PHY */
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->ddr_sgmii_phy), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ddr_sgmii_phy), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_DDR_SGMII_PHY].base);
|
|
|
|
|
|
|
|
/* DDR CFG */
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->ddr_cfg), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ddr_cfg), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_DDR_CFG].base);
|
|
|
|
|
2020-09-01 03:39:03 +02:00
|
|
|
/* SDHCI */
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->sdhci), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_EMMC_SD].base);
|
|
|
|
sysbus_connect_irq(SYS_BUS_DEVICE(&s->sdhci), 0,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_EMMC_SD_IRQ));
|
|
|
|
|
2020-09-01 03:39:01 +02:00
|
|
|
/* MMUARTs */
|
|
|
|
s->serial0 = mchp_pfsoc_mmuart_create(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_MMUART0].base,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_MMUART0_IRQ),
|
|
|
|
serial_hd(0));
|
|
|
|
s->serial1 = mchp_pfsoc_mmuart_create(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_MMUART1].base,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_MMUART1_IRQ),
|
|
|
|
serial_hd(1));
|
|
|
|
s->serial2 = mchp_pfsoc_mmuart_create(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_MMUART2].base,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_MMUART2_IRQ),
|
|
|
|
serial_hd(2));
|
|
|
|
s->serial3 = mchp_pfsoc_mmuart_create(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_MMUART3].base,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_MMUART3_IRQ),
|
|
|
|
serial_hd(3));
|
|
|
|
s->serial4 = mchp_pfsoc_mmuart_create(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_MMUART4].base,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_MMUART4_IRQ),
|
|
|
|
serial_hd(4));
|
|
|
|
|
2022-08-13 15:51:27 +02:00
|
|
|
/* Watchdogs */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.watchdog0",
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG0].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.watchdog1",
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG1].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.watchdog2",
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG2].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG2].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.watchdog3",
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG3].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG3].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.watchdog4",
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG4].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_WDOG4].size);
|
|
|
|
|
2020-11-12 08:49:51 +01:00
|
|
|
/* SPI */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.spi0",
|
|
|
|
memmap[MICROCHIP_PFSOC_SPI0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_SPI0].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.spi1",
|
|
|
|
memmap[MICROCHIP_PFSOC_SPI1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_SPI1].size);
|
|
|
|
|
2022-08-13 15:51:27 +02:00
|
|
|
/* I2C */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.i2c0",
|
|
|
|
memmap[MICROCHIP_PFSOC_I2C0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_I2C0].size);
|
2020-10-28 06:30:10 +01:00
|
|
|
create_unimplemented_device("microchip.pfsoc.i2c1",
|
|
|
|
memmap[MICROCHIP_PFSOC_I2C1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_I2C1].size);
|
|
|
|
|
2022-08-13 15:51:27 +02:00
|
|
|
/* CAN */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.can0",
|
|
|
|
memmap[MICROCHIP_PFSOC_CAN0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_CAN0].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.can1",
|
|
|
|
memmap[MICROCHIP_PFSOC_CAN1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_CAN1].size);
|
|
|
|
|
|
|
|
/* USB */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.usb",
|
|
|
|
memmap[MICROCHIP_PFSOC_USB].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_USB].size);
|
|
|
|
|
2020-09-01 03:39:08 +02:00
|
|
|
/* GEMs */
|
|
|
|
|
|
|
|
nd = &nd_table[0];
|
|
|
|
if (nd->used) {
|
|
|
|
qemu_check_nic_model(nd, TYPE_CADENCE_GEM);
|
|
|
|
qdev_set_nic_properties(DEVICE(&s->gem0), nd);
|
|
|
|
}
|
|
|
|
nd = &nd_table[1];
|
|
|
|
if (nd->used) {
|
|
|
|
qemu_check_nic_model(nd, TYPE_CADENCE_GEM);
|
|
|
|
qdev_set_nic_properties(DEVICE(&s->gem1), nd);
|
|
|
|
}
|
|
|
|
|
|
|
|
object_property_set_int(OBJECT(&s->gem0), "revision", GEM_REVISION, errp);
|
|
|
|
object_property_set_int(OBJECT(&s->gem0), "phy-addr", 8, errp);
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->gem0), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gem0), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_GEM0].base);
|
|
|
|
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gem0), 0,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_GEM0_IRQ));
|
|
|
|
|
|
|
|
object_property_set_int(OBJECT(&s->gem1), "revision", GEM_REVISION, errp);
|
|
|
|
object_property_set_int(OBJECT(&s->gem1), "phy-addr", 9, errp);
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->gem1), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gem1), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_GEM1].base);
|
|
|
|
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gem1), 0,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic), MICROCHIP_PFSOC_GEM1_IRQ));
|
|
|
|
|
2020-09-01 03:39:09 +02:00
|
|
|
/* GPIOs */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.gpio0",
|
|
|
|
memmap[MICROCHIP_PFSOC_GPIO0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_GPIO0].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.gpio1",
|
|
|
|
memmap[MICROCHIP_PFSOC_GPIO1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_GPIO1].size);
|
|
|
|
create_unimplemented_device("microchip.pfsoc.gpio2",
|
|
|
|
memmap[MICROCHIP_PFSOC_GPIO2].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_GPIO2].size);
|
|
|
|
|
2020-09-01 03:38:59 +02:00
|
|
|
/* eNVM */
|
|
|
|
memory_region_init_rom(envm_data, OBJECT(dev), "microchip.pfsoc.envm.data",
|
|
|
|
memmap[MICROCHIP_PFSOC_ENVM_DATA].size,
|
|
|
|
&error_fatal);
|
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_ENVM_DATA].base,
|
|
|
|
envm_data);
|
|
|
|
|
2020-10-28 06:30:05 +01:00
|
|
|
/* IOSCB */
|
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->ioscb), errp);
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ioscb), 0,
|
|
|
|
memmap[MICROCHIP_PFSOC_IOSCB].base);
|
2022-11-17 23:55:18 +01:00
|
|
|
sysbus_connect_irq(SYS_BUS_DEVICE(&s->ioscb), 0,
|
|
|
|
qdev_get_gpio_in(DEVICE(s->plic),
|
|
|
|
MICROCHIP_PFSOC_MAILBOX_IRQ));
|
2020-11-12 08:49:51 +01:00
|
|
|
|
2022-08-13 15:51:27 +02:00
|
|
|
/* FPGA Fabric */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.fabricfic3",
|
|
|
|
memmap[MICROCHIP_PFSOC_FABRIC_FIC3].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_FABRIC_FIC3].size);
|
2022-11-17 23:55:17 +01:00
|
|
|
/* FPGA Fabric */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.fabricfic0",
|
|
|
|
memmap[MICROCHIP_PFSOC_FABRIC_FIC0].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_FABRIC_FIC0].size);
|
|
|
|
/* FPGA Fabric */
|
|
|
|
create_unimplemented_device("microchip.pfsoc.fabricfic1",
|
|
|
|
memmap[MICROCHIP_PFSOC_FABRIC_FIC1].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_FABRIC_FIC1].size);
|
2021-03-22 08:52:47 +01:00
|
|
|
|
2020-11-12 08:49:51 +01:00
|
|
|
/* QSPI Flash */
|
|
|
|
memory_region_init_rom(qspi_xip_mem, OBJECT(dev),
|
|
|
|
"microchip.pfsoc.qspi_xip",
|
|
|
|
memmap[MICROCHIP_PFSOC_QSPI_XIP].size,
|
|
|
|
&error_fatal);
|
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_QSPI_XIP].base,
|
|
|
|
qspi_xip_mem);
|
2020-09-01 03:38:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void microchip_pfsoc_soc_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(oc);
|
|
|
|
|
|
|
|
dc->realize = microchip_pfsoc_soc_realize;
|
|
|
|
/* Reason: Uses serial_hds in realize function, thus can't be used twice */
|
|
|
|
dc->user_creatable = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo microchip_pfsoc_soc_type_info = {
|
|
|
|
.name = TYPE_MICROCHIP_PFSOC,
|
|
|
|
.parent = TYPE_DEVICE,
|
|
|
|
.instance_size = sizeof(MicrochipPFSoCState),
|
|
|
|
.instance_init = microchip_pfsoc_soc_instance_init,
|
|
|
|
.class_init = microchip_pfsoc_soc_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void microchip_pfsoc_soc_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(µchip_pfsoc_soc_type_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(microchip_pfsoc_soc_register_types)
|
|
|
|
|
|
|
|
static void microchip_icicle_kit_machine_init(MachineState *machine)
|
|
|
|
{
|
|
|
|
MachineClass *mc = MACHINE_GET_CLASS(machine);
|
2021-02-20 15:48:04 +01:00
|
|
|
const MemMapEntry *memmap = microchip_pfsoc_memmap;
|
2020-09-01 03:38:59 +02:00
|
|
|
MicrochipIcicleKitState *s = MICROCHIP_ICICLE_KIT_MACHINE(machine);
|
|
|
|
MemoryRegion *system_memory = get_system_memory();
|
2020-11-01 18:05:38 +01:00
|
|
|
MemoryRegion *mem_low = g_new(MemoryRegion, 1);
|
|
|
|
MemoryRegion *mem_low_alias = g_new(MemoryRegion, 1);
|
|
|
|
MemoryRegion *mem_high = g_new(MemoryRegion, 1);
|
|
|
|
MemoryRegion *mem_high_alias = g_new(MemoryRegion, 1);
|
2021-10-20 03:41:07 +02:00
|
|
|
uint64_t mem_low_size, mem_high_size;
|
2021-04-30 09:13:02 +02:00
|
|
|
hwaddr firmware_load_addr;
|
|
|
|
const char *firmware_name;
|
|
|
|
bool kernel_as_payload = false;
|
|
|
|
target_ulong firmware_end_addr, kernel_start_addr;
|
|
|
|
uint64_t kernel_entry;
|
|
|
|
uint32_t fdt_load_addr;
|
2021-11-17 17:33:58 +01:00
|
|
|
DriveInfo *dinfo = drive_get(IF_SD, 0, 0);
|
2020-09-01 03:38:59 +02:00
|
|
|
|
|
|
|
/* Sanity check on RAM size */
|
|
|
|
if (machine->ram_size < mc->default_ram_size) {
|
|
|
|
char *sz = size_to_str(mc->default_ram_size);
|
|
|
|
error_report("Invalid RAM size, should be bigger than %s", sz);
|
|
|
|
g_free(sz);
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize SoC */
|
|
|
|
object_initialize_child(OBJECT(machine), "soc", &s->soc,
|
|
|
|
TYPE_MICROCHIP_PFSOC);
|
2022-01-05 22:39:36 +01:00
|
|
|
qdev_realize(DEVICE(&s->soc), NULL, &error_fatal);
|
2020-09-01 03:38:59 +02:00
|
|
|
|
2021-10-20 03:41:07 +02:00
|
|
|
/* Split RAM into low and high regions using aliases to machine->ram */
|
|
|
|
mem_low_size = memmap[MICROCHIP_PFSOC_DRAM_LO].size;
|
|
|
|
mem_high_size = machine->ram_size - mem_low_size;
|
|
|
|
memory_region_init_alias(mem_low, NULL,
|
|
|
|
"microchip.icicle.kit.ram_low", machine->ram,
|
|
|
|
0, mem_low_size);
|
|
|
|
memory_region_init_alias(mem_high, NULL,
|
|
|
|
"microchip.icicle.kit.ram_high", machine->ram,
|
|
|
|
mem_low_size, mem_high_size);
|
|
|
|
|
2020-09-01 03:38:59 +02:00
|
|
|
/* Register RAM */
|
2020-11-01 18:05:38 +01:00
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_DRAM_LO].base,
|
|
|
|
mem_low);
|
2021-10-20 03:41:07 +02:00
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_DRAM_HI].base,
|
|
|
|
mem_high);
|
|
|
|
|
|
|
|
/* Create aliases for the low and high RAM regions */
|
|
|
|
memory_region_init_alias(mem_low_alias, NULL,
|
|
|
|
"microchip.icicle.kit.ram_low.alias",
|
|
|
|
mem_low, 0, mem_low_size);
|
2020-09-01 03:38:59 +02:00
|
|
|
memory_region_add_subregion(system_memory,
|
2020-11-01 18:05:38 +01:00
|
|
|
memmap[MICROCHIP_PFSOC_DRAM_LO_ALIAS].base,
|
|
|
|
mem_low_alias);
|
|
|
|
memory_region_init_alias(mem_high_alias, NULL,
|
|
|
|
"microchip.icicle.kit.ram_high.alias",
|
|
|
|
mem_high, 0, mem_high_size);
|
|
|
|
memory_region_add_subregion(system_memory,
|
|
|
|
memmap[MICROCHIP_PFSOC_DRAM_HI_ALIAS].base,
|
|
|
|
mem_high_alias);
|
2020-09-01 03:38:59 +02:00
|
|
|
|
2020-09-01 03:39:03 +02:00
|
|
|
/* Attach an SD card */
|
|
|
|
if (dinfo) {
|
|
|
|
CadenceSDHCIState *sdhci = &(s->soc.sdhci);
|
|
|
|
DeviceState *card = qdev_new(TYPE_SD_CARD);
|
|
|
|
|
|
|
|
qdev_prop_set_drive_err(card, "drive", blk_by_legacy_dinfo(dinfo),
|
|
|
|
&error_fatal);
|
|
|
|
qdev_realize_and_unref(card, sdhci->bus, &error_fatal);
|
|
|
|
}
|
2021-04-30 09:13:02 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We follow the following table to select which payload we execute.
|
|
|
|
*
|
|
|
|
* -bios | -kernel | payload
|
|
|
|
* -------+------------+--------
|
|
|
|
* N | N | HSS
|
|
|
|
* Y | don't care | HSS
|
|
|
|
* N | Y | kernel
|
|
|
|
*
|
|
|
|
* This ensures backwards compatibility with how we used to expose -bios
|
|
|
|
* to users but allows them to run through direct kernel booting as well.
|
|
|
|
*
|
|
|
|
* When -kernel is used for direct boot, -dtb must be present to provide
|
|
|
|
* a valid device tree for the board, as we don't generate device tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (machine->kernel_filename && machine->dtb) {
|
|
|
|
int fdt_size;
|
|
|
|
machine->fdt = load_device_tree(machine->dtb, &fdt_size);
|
|
|
|
if (!machine->fdt) {
|
|
|
|
error_report("load_device_tree() failed");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
firmware_name = RISCV64_BIOS_BIN;
|
|
|
|
firmware_load_addr = memmap[MICROCHIP_PFSOC_DRAM_LO].base;
|
|
|
|
kernel_as_payload = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!kernel_as_payload) {
|
|
|
|
firmware_name = BIOS_FILENAME;
|
|
|
|
firmware_load_addr = RESET_VECTOR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Load the firmware */
|
|
|
|
firmware_end_addr = riscv_find_and_load_firmware(machine, firmware_name,
|
|
|
|
firmware_load_addr, NULL);
|
|
|
|
|
|
|
|
if (kernel_as_payload) {
|
|
|
|
kernel_start_addr = riscv_calc_kernel_start_addr(&s->soc.u_cpus,
|
|
|
|
firmware_end_addr);
|
|
|
|
|
2023-02-06 15:00:20 +01:00
|
|
|
kernel_entry = riscv_load_kernel(machine, &s->soc.u_cpus,
|
|
|
|
kernel_start_addr, NULL);
|
2021-04-30 09:13:02 +02:00
|
|
|
|
|
|
|
if (machine->initrd_filename) {
|
2023-01-02 12:52:38 +01:00
|
|
|
riscv_load_initrd(machine, kernel_entry);
|
2021-04-30 09:13:02 +02:00
|
|
|
}
|
|
|
|
|
2022-04-21 07:56:29 +02:00
|
|
|
if (machine->kernel_cmdline && *machine->kernel_cmdline) {
|
2021-04-30 09:13:02 +02:00
|
|
|
qemu_fdt_setprop_string(machine->fdt, "/chosen",
|
|
|
|
"bootargs", machine->kernel_cmdline);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Compute the fdt load address in dram */
|
2023-02-01 18:12:11 +01:00
|
|
|
fdt_load_addr = riscv_compute_fdt_addr(memmap[MICROCHIP_PFSOC_DRAM_LO].base,
|
hw/riscv: change riscv_compute_fdt_addr() semantics
As it is now, riscv_compute_fdt_addr() is receiving a dram_base, a
mem_size (which is defaulted to MachineState::ram_size in all boards)
and the FDT pointer. And it makes a very important assumption: the DRAM
interval dram_base + mem_size is contiguous. This is indeed the case for
most boards that use a FDT.
The Icicle Kit board works with 2 distinct RAM banks that are separated
by a gap. We have a lower bank with 1GiB size, a gap follows, then at
64GiB the high memory starts. MachineClass::default_ram_size for this
board is set to 1.5Gb, and machine_init() is enforcing it as minimal RAM
size, meaning that there we'll always have at least 512 MiB in the Hi
RAM area.
Using riscv_compute_fdt_addr() in this board is weird because not only
the board has sparse RAM, and it's calling it using the base address of
the Lo RAM area, but it's also using a mem_size that we have guarantees
that it will go up to the Hi RAM. All the function assumptions doesn't
work for this board.
In fact, what makes the function works at all in this case is a
coincidence. Commit 1a475d39ef54 introduced a 3GB boundary for the FDT,
down from 4Gb, that is enforced if dram_base is lower than 3072 MiB. For
the Icicle Kit board, memmap[MICROCHIP_PFSOC_DRAM_LO].base is 0x80000000
(2 Gb) and it has a 1Gb size, so it will fall in the conditions to put
the FDT under a 3Gb address, which happens to be exactly at the end of
DRAM_LO. If the base address of the Lo area started later than 3Gb this
function would be unusable by the board. Changing any assumptions inside
riscv_compute_fdt_addr() can also break it by accident as well.
Let's change riscv_compute_fdt_addr() semantics to be appropriate to the
Icicle Kit board and for future boards that might have sparse RAM
topologies to worry about:
- relieve the condition that the dram_base + mem_size area is contiguous,
since this is already not the case today;
- receive an extra 'dram_size' size attribute that refers to a contiguous
RAM block that the board wants the FDT to reside on.
Together with 'mem_size' and 'fdt', which are now now being consumed by a
MachineState pointer, we're able to make clear assumptions based on the
DRAM block and total mem_size available to ensure that the FDT will be put
in a valid RAM address.
Signed-off-by: Daniel Henrique Barboza <dbarboza@ventanamicro.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Message-Id: <20230201171212.1219375-4-dbarboza@ventanamicro.com>
Signed-off-by: Alistair Francis <alistair.francis@wdc.com>
2023-02-01 18:12:12 +01:00
|
|
|
memmap[MICROCHIP_PFSOC_DRAM_LO].size,
|
|
|
|
machine);
|
2023-02-01 18:12:11 +01:00
|
|
|
riscv_load_fdt(fdt_load_addr, machine->fdt);
|
|
|
|
|
2021-04-30 09:13:02 +02:00
|
|
|
/* Load the reset vector */
|
|
|
|
riscv_setup_rom_reset_vec(machine, &s->soc.u_cpus, firmware_load_addr,
|
|
|
|
memmap[MICROCHIP_PFSOC_ENVM_DATA].base,
|
|
|
|
memmap[MICROCHIP_PFSOC_ENVM_DATA].size,
|
2022-07-28 20:19:26 +02:00
|
|
|
kernel_entry, fdt_load_addr);
|
2021-04-30 09:13:02 +02:00
|
|
|
}
|
2020-09-01 03:38:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void microchip_icicle_kit_machine_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
|
|
|
MachineClass *mc = MACHINE_CLASS(oc);
|
|
|
|
|
|
|
|
mc->desc = "Microchip PolarFire SoC Icicle Kit";
|
|
|
|
mc->init = microchip_icicle_kit_machine_init;
|
|
|
|
mc->max_cpus = MICROCHIP_PFSOC_MANAGEMENT_CPU_COUNT +
|
|
|
|
MICROCHIP_PFSOC_COMPUTE_CPU_COUNT;
|
|
|
|
mc->min_cpus = MICROCHIP_PFSOC_MANAGEMENT_CPU_COUNT + 1;
|
|
|
|
mc->default_cpus = mc->min_cpus;
|
2021-10-20 03:41:07 +02:00
|
|
|
mc->default_ram_id = "microchip.icicle.kit.ram";
|
2020-11-01 18:05:38 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Map 513 MiB high memory, the mimimum required high memory size, because
|
|
|
|
* HSS will do memory test against the high memory address range regardless
|
|
|
|
* of physical memory installed.
|
|
|
|
*
|
|
|
|
* See memory_tests() in mss_ddr.c in the HSS source code.
|
|
|
|
*/
|
|
|
|
mc->default_ram_size = 1537 * MiB;
|
2020-09-01 03:38:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo microchip_icicle_kit_machine_typeinfo = {
|
|
|
|
.name = MACHINE_TYPE_NAME("microchip-icicle-kit"),
|
|
|
|
.parent = TYPE_MACHINE,
|
|
|
|
.class_init = microchip_icicle_kit_machine_class_init,
|
|
|
|
.instance_size = sizeof(MicrochipIcicleKitState),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void microchip_icicle_kit_machine_init_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(µchip_icicle_kit_machine_typeinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(microchip_icicle_kit_machine_init_register_types)
|