riscv
/
qemu
mirror of https://gitea.goldendeliverer.com/riscv/qemu.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

hw/arm: Add NPCM8XX SoC 

Signed-off-by: Hao Wu <wuhaotsh@google.com>
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Message-id: 20250219184609.1839281-16-wuhaotsh@google.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
pull/291/head
Hao Wu 1 year ago
committed by Peter Maydell
parent
3d107d36f9
commit
ae0c4d1a12
5 changed files with 926 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      configs/devices/aarch64-softmmu/default.mak
  2. 13
      hw/arm/Kconfig
  3. 1
      hw/arm/meson.build
  4. 805
      hw/arm/npcm8xx.c
  5. 106
      include/hw/arm/npcm8xx.h

1
configs/devices/aarch64-softmmu/default.mak
View File

@ -8,3 +8,4 @@ include ../arm-softmmu/default.mak
# CONFIG_XLNX_ZYNQMP_ARM=n
# CONFIG_XLNX_VERSAL=n
# CONFIG_SBSA_REF=n
# CONFIG_NPCM8XX=n

13
hw/arm/Kconfig
View File

@ -481,6 +481,19 @@ config NPCM7XX
select PCA954X
select USB_OHCI_SYSBUS
config NPCM8XX
bool
default y
depends on TCG && AARCH64
select ARM_GIC
select SMBUS
select PL310 # cache controller
select NPCM7XX
select SERIAL
select SSI
select UNIMP
config FSL_IMX25
bool
default y

1
hw/arm/meson.build
View File

@ -12,6 +12,7 @@ arm_ss.add(when: 'CONFIG_MUSICPAL', if_true: files('musicpal.c'))
arm_ss.add(when: 'CONFIG_NETDUINOPLUS2', if_true: files('netduinoplus2.c'))
arm_ss.add(when: 'CONFIG_OLIMEX_STM32_H405', if_true: files('olimex-stm32-h405.c'))
arm_ss.add(when: 'CONFIG_NPCM7XX', if_true: files('npcm7xx.c', 'npcm7xx_boards.c'))
arm_ss.add(when: 'CONFIG_NPCM8XX', if_true: files('npcm8xx.c'))
arm_ss.add(when: 'CONFIG_REALVIEW', if_true: files('realview.c'))
arm_ss.add(when: 'CONFIG_SBSA_REF', if_true: files('sbsa-ref.c'))
arm_ss.add(when: 'CONFIG_STELLARIS', if_true: files('stellaris.c'))

805
hw/arm/npcm8xx.c
View File

@ -0,0 +1,805 @@
/*
* Nuvoton NPCM8xx SoC family.
*
* Copyright 2022 Google LLC
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that 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.
*/
#include "qemu/osdep.h"
#include "hw/boards.h"
#include "hw/arm/boot.h"
#include "hw/arm/bsa.h"
#include "hw/arm/npcm8xx.h"
#include "hw/char/serial-mm.h"
#include "hw/intc/arm_gic.h"
#include "hw/loader.h"
#include "hw/misc/unimp.h"
#include "hw/qdev-clock.h"
#include "hw/qdev-properties.h"
#include "qapi/error.h"
#include "qemu/units.h"
#include "system/system.h"
/*
* This covers the whole MMIO space. We'll use this to catch any MMIO accesses
* that aren't handled by a device.
*/
#define NPCM8XX_MMIO_BA 0x80000000
#define NPCM8XX_MMIO_SZ 0x7ffd0000
/* OTP fuse array */
#define NPCM8XX_OTP_BA 0xf0189000
/* GIC Distributor */
#define NPCM8XX_GICD_BA 0xdfff9000
#define NPCM8XX_GICC_BA 0xdfffa000
/* Core system modules. */
#define NPCM8XX_CPUP_BA 0xf03fe000
#define NPCM8XX_GCR_BA 0xf0800000
#define NPCM8XX_CLK_BA 0xf0801000
#define NPCM8XX_MC_BA 0xf0824000
#define NPCM8XX_RNG_BA 0xf000b000
/* ADC Module */
#define NPCM8XX_ADC_BA 0xf000c000
/* Internal AHB SRAM */
#define NPCM8XX_RAM3_BA 0xc0008000
#define NPCM8XX_RAM3_SZ (4 * KiB)
/* Memory blocks at the end of the address space */
#define NPCM8XX_RAM2_BA 0xfffb0000
#define NPCM8XX_RAM2_SZ (256 * KiB)
#define NPCM8XX_ROM_BA 0xffff0100
#define NPCM8XX_ROM_SZ (64 * KiB)
/* SDHCI Modules */
#define NPCM8XX_MMC_BA 0xf0842000
/* Run PLL1 at 1600 MHz */
#define NPCM8XX_PLLCON1_FIXUP_VAL 0x00402101
/* Run the CPU from PLL1 and UART from PLL2 */
#define NPCM8XX_CLKSEL_FIXUP_VAL 0x004aaba9
/* Clock configuration values to be fixed up when bypassing bootloader */
/*
* Interrupt lines going into the GIC. This does not include internal Cortex-A35
* interrupts.
*/
enum NPCM8xxInterrupt {
NPCM8XX_ADC_IRQ = 0,
NPCM8XX_PECI_IRQ = 6,
NPCM8XX_KCS_HIB_IRQ = 9,
NPCM8XX_MMC_IRQ = 26,
NPCM8XX_TIMER0_IRQ = 32, /* Timer Module 0 */
NPCM8XX_TIMER1_IRQ,
NPCM8XX_TIMER2_IRQ,
NPCM8XX_TIMER3_IRQ,
NPCM8XX_TIMER4_IRQ,
NPCM8XX_TIMER5_IRQ, /* Timer Module 1 */
NPCM8XX_TIMER6_IRQ,
NPCM8XX_TIMER7_IRQ,
NPCM8XX_TIMER8_IRQ,
NPCM8XX_TIMER9_IRQ,
NPCM8XX_TIMER10_IRQ, /* Timer Module 2 */
NPCM8XX_TIMER11_IRQ,
NPCM8XX_TIMER12_IRQ,
NPCM8XX_TIMER13_IRQ,
NPCM8XX_TIMER14_IRQ,
NPCM8XX_WDG0_IRQ = 47, /* Timer Module 0 Watchdog */
NPCM8XX_WDG1_IRQ, /* Timer Module 1 Watchdog */
NPCM8XX_WDG2_IRQ, /* Timer Module 2 Watchdog */
NPCM8XX_EHCI1_IRQ = 61,
NPCM8XX_OHCI1_IRQ,
NPCM8XX_EHCI2_IRQ,
NPCM8XX_OHCI2_IRQ,
NPCM8XX_PWM0_IRQ = 93, /* PWM module 0 */
NPCM8XX_PWM1_IRQ, /* PWM module 1 */
NPCM8XX_MFT0_IRQ = 96, /* MFT module 0 */
NPCM8XX_MFT1_IRQ, /* MFT module 1 */
NPCM8XX_MFT2_IRQ, /* MFT module 2 */
NPCM8XX_MFT3_IRQ, /* MFT module 3 */
NPCM8XX_MFT4_IRQ, /* MFT module 4 */
NPCM8XX_MFT5_IRQ, /* MFT module 5 */
NPCM8XX_MFT6_IRQ, /* MFT module 6 */
NPCM8XX_MFT7_IRQ, /* MFT module 7 */
NPCM8XX_PCI_MBOX1_IRQ = 105,
NPCM8XX_PCI_MBOX2_IRQ,
NPCM8XX_GPIO0_IRQ = 116,
NPCM8XX_GPIO1_IRQ,
NPCM8XX_GPIO2_IRQ,
NPCM8XX_GPIO3_IRQ,
NPCM8XX_GPIO4_IRQ,
NPCM8XX_GPIO5_IRQ,
NPCM8XX_GPIO6_IRQ,
NPCM8XX_GPIO7_IRQ,
NPCM8XX_SMBUS0_IRQ = 128,
NPCM8XX_SMBUS1_IRQ,
NPCM8XX_SMBUS2_IRQ,
NPCM8XX_SMBUS3_IRQ,
NPCM8XX_SMBUS4_IRQ,
NPCM8XX_SMBUS5_IRQ,
NPCM8XX_SMBUS6_IRQ,
NPCM8XX_SMBUS7_IRQ,
NPCM8XX_SMBUS8_IRQ,
NPCM8XX_SMBUS9_IRQ,
NPCM8XX_SMBUS10_IRQ,
NPCM8XX_SMBUS11_IRQ,
NPCM8XX_SMBUS12_IRQ,
NPCM8XX_SMBUS13_IRQ,
NPCM8XX_SMBUS14_IRQ,
NPCM8XX_SMBUS15_IRQ,
NPCM8XX_SMBUS16_IRQ,
NPCM8XX_SMBUS17_IRQ,
NPCM8XX_SMBUS18_IRQ,
NPCM8XX_SMBUS19_IRQ,
NPCM8XX_SMBUS20_IRQ,
NPCM8XX_SMBUS21_IRQ,
NPCM8XX_SMBUS22_IRQ,
NPCM8XX_SMBUS23_IRQ,
NPCM8XX_SMBUS24_IRQ,
NPCM8XX_SMBUS25_IRQ,
NPCM8XX_SMBUS26_IRQ,
NPCM8XX_UART0_IRQ = 192,
NPCM8XX_UART1_IRQ,
NPCM8XX_UART2_IRQ,
NPCM8XX_UART3_IRQ,
NPCM8XX_UART4_IRQ,
NPCM8XX_UART5_IRQ,
NPCM8XX_UART6_IRQ,
};
/* Total number of GIC interrupts, including internal Cortex-A35 interrupts. */
#define NPCM8XX_NUM_IRQ (288)
#define NPCM8XX_PPI_BASE(cpu) \
((NPCM8XX_NUM_IRQ - GIC_INTERNAL) + (cpu) * GIC_INTERNAL)
/* Register base address for each Timer Module */
static const hwaddr npcm8xx_tim_addr[] = {
0xf0008000,
0xf0009000,
0xf000a000,
};
/* Register base address for each 16550 UART */
static const hwaddr npcm8xx_uart_addr[] = {
0xf0000000,
0xf0001000,
0xf0002000,
0xf0003000,
0xf0004000,
0xf0005000,
0xf0006000,
};
/* Direct memory-mapped access to SPI0 CS0-1. */
static const hwaddr npcm8xx_fiu0_flash_addr[] = {
0x80000000, /* CS0 */
0x88000000, /* CS1 */
};
/* Direct memory-mapped access to SPI1 CS0-3. */
static const hwaddr npcm8xx_fiu1_flash_addr[] = {
0x90000000, /* CS0 */
0x91000000, /* CS1 */
0x92000000, /* CS2 */
0x93000000, /* CS3 */
};
/* Direct memory-mapped access to SPI3 CS0-3. */
static const hwaddr npcm8xx_fiu3_flash_addr[] = {
0xa0000000, /* CS0 */
0xa8000000, /* CS1 */
0xb0000000, /* CS2 */
0xb8000000, /* CS3 */
};
/* Register base address for each PWM Module */
static const hwaddr npcm8xx_pwm_addr[] = {
0xf0103000,
0xf0104000,
0xf0105000,
};
/* Register base address for each MFT Module */
static const hwaddr npcm8xx_mft_addr[] = {
0xf0180000,
0xf0181000,
0xf0182000,
0xf0183000,
0xf0184000,
0xf0185000,
0xf0186000,
0xf0187000,
};
/* Direct memory-mapped access to each SMBus Module. */
static const hwaddr npcm8xx_smbus_addr[] = {
0xf0080000,
0xf0081000,
0xf0082000,
0xf0083000,
0xf0084000,
0xf0085000,
0xf0086000,
0xf0087000,
0xf0088000,
0xf0089000,
0xf008a000,
0xf008b000,
0xf008c000,
0xf008d000,
0xf008e000,
0xf008f000,
0xfff00000,
0xfff01000,
0xfff02000,
0xfff03000,
0xfff04000,
0xfff05000,
0xfff06000,
0xfff07000,
0xfff08000,
0xfff09000,
0xfff0a000,
};
/* Register base address for each USB host EHCI registers */
static const hwaddr npcm8xx_ehci_addr[] = {
0xf0828100,
0xf082a100,
};
/* Register base address for each USB host OHCI registers */
static const hwaddr npcm8xx_ohci_addr[] = {
0xf0829000,
0xf082b000,
};
static const struct {
hwaddr regs_addr;
uint32_t reset_pu;
uint32_t reset_pd;
uint32_t reset_osrc;
uint32_t reset_odsc;
} npcm8xx_gpio[] = {
{
.regs_addr = 0xf0010000,
.reset_pu = 0x00000300,
.reset_pd = 0x000f0000,
}, {
.regs_addr = 0xf0011000,
.reset_pu = 0xe0fefe01,
.reset_pd = 0x07000000,
}, {
.regs_addr = 0xf0012000,
.reset_pu = 0xc00fffff,
.reset_pd = 0x3ff00000,
}, {
.regs_addr = 0xf0013000,
.reset_pd = 0x00003000,
}, {
.regs_addr = 0xf0014000,
.reset_pu = 0xffff0000,
}, {
.regs_addr = 0xf0015000,
.reset_pu = 0xff8387fe,
.reset_pd = 0x007c0001,
.reset_osrc = 0x08000000,
}, {
.regs_addr = 0xf0016000,
.reset_pu = 0x00000801,
.reset_pd = 0x00000302,
}, {
.regs_addr = 0xf0017000,
.reset_pu = 0x000002ff,
.reset_pd = 0x00000c00,
},
};
static const struct {
const char *name;
hwaddr regs_addr;
int cs_count;
const hwaddr *flash_addr;
size_t flash_size;
} npcm8xx_fiu[] = {
{
.name = "fiu0",
.regs_addr = 0xfb000000,
.cs_count = ARRAY_SIZE(npcm8xx_fiu0_flash_addr),
.flash_addr = npcm8xx_fiu0_flash_addr,
.flash_size = 128 * MiB,
},
{
.name = "fiu1",
.regs_addr = 0xfb002000,
.cs_count = ARRAY_SIZE(npcm8xx_fiu1_flash_addr),
.flash_addr = npcm8xx_fiu1_flash_addr,
.flash_size = 16 * MiB,
}, {
.name = "fiu3",
.regs_addr = 0xc0000000,
.cs_count = ARRAY_SIZE(npcm8xx_fiu3_flash_addr),
.flash_addr = npcm8xx_fiu3_flash_addr,
.flash_size = 128 * MiB,
},
};
static struct arm_boot_info npcm8xx_binfo = {
.loader_start = NPCM8XX_LOADER_START,
.smp_loader_start = NPCM8XX_SMP_LOADER_START,
.smp_bootreg_addr = NPCM8XX_SMP_BOOTREG_ADDR,
.gic_cpu_if_addr = NPCM8XX_GICC_BA,
.secure_boot = false,
.board_id = -1,
.board_setup_addr = NPCM8XX_BOARD_SETUP_ADDR,
};
void npcm8xx_load_kernel(MachineState *machine, NPCM8xxState *soc)
{
npcm8xx_binfo.ram_size = machine->ram_size;
arm_load_kernel(&soc->cpu[0], machine, &npcm8xx_binfo);
}
static void npcm8xx_init_fuses(NPCM8xxState *s)
{
NPCM8xxClass *nc = NPCM8XX_GET_CLASS(s);
uint32_t value;
/*
* The initial mask of disabled modules indicates the chip derivative (e.g.
* NPCM750 or NPCM730).
*/
value = cpu_to_le32(nc->disabled_modules);
npcm7xx_otp_array_write(&s->fuse_array, &value, NPCM7XX_FUSE_DERIVATIVE,
sizeof(value));
}
static void npcm8xx_write_adc_calibration(NPCM8xxState *s)
{
/* Both ADC and the fuse array must have realized. */
QEMU_BUILD_BUG_ON(sizeof(s->adc.calibration_r_values) != 4);
npcm7xx_otp_array_write(&s->fuse_array, s->adc.calibration_r_values,
NPCM7XX_FUSE_ADC_CALIB, sizeof(s->adc.calibration_r_values));
}
static qemu_irq npcm8xx_irq(NPCM8xxState *s, int n)
{
return qdev_get_gpio_in(DEVICE(&s->gic), n);
}
static void npcm8xx_init(Object *obj)
{
NPCM8xxState *s = NPCM8XX(obj);
int i;
object_initialize_child(obj, "cpu-cluster", &s->cpu_cluster,
TYPE_CPU_CLUSTER);
for (i = 0; i < NPCM8XX_MAX_NUM_CPUS; i++) {
object_initialize_child(OBJECT(&s->cpu_cluster), "cpu[*]", &s->cpu[i],
ARM_CPU_TYPE_NAME("cortex-a35"));
}
object_initialize_child(obj, "gic", &s->gic, TYPE_ARM_GIC);
object_initialize_child(obj, "gcr", &s->gcr, TYPE_NPCM8XX_GCR);
object_property_add_alias(obj, "power-on-straps", OBJECT(&s->gcr),
"power-on-straps");
object_initialize_child(obj, "clk", &s->clk, TYPE_NPCM8XX_CLK);
object_initialize_child(obj, "otp", &s->fuse_array,
TYPE_NPCM7XX_FUSE_ARRAY);
object_initialize_child(obj, "mc", &s->mc, TYPE_NPCM7XX_MC);
object_initialize_child(obj, "rng", &s->rng, TYPE_NPCM7XX_RNG);
object_initialize_child(obj, "adc", &s->adc, TYPE_NPCM7XX_ADC);
for (i = 0; i < ARRAY_SIZE(s->tim); i++) {
object_initialize_child(obj, "tim[*]", &s->tim[i], TYPE_NPCM7XX_TIMER);
}
for (i = 0; i < ARRAY_SIZE(s->gpio); i++) {
object_initialize_child(obj, "gpio[*]", &s->gpio[i], TYPE_NPCM7XX_GPIO);
}
for (i = 0; i < ARRAY_SIZE(s->smbus); i++) {
object_initialize_child(obj, "smbus[*]", &s->smbus[i],
TYPE_NPCM7XX_SMBUS);
DEVICE(&s->smbus[i])->id = g_strdup_printf("smbus[%d]", i);
}
for (i = 0; i < ARRAY_SIZE(s->ehci); i++) {
object_initialize_child(obj, "ehci[*]", &s->ehci[i], TYPE_NPCM7XX_EHCI);
}
for (i = 0; i < ARRAY_SIZE(s->ohci); i++) {
object_initialize_child(obj, "ohci[*]", &s->ohci[i], TYPE_SYSBUS_OHCI);
}
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_fiu) != ARRAY_SIZE(s->fiu));
for (i = 0; i < ARRAY_SIZE(s->fiu); i++) {
object_initialize_child(obj, npcm8xx_fiu[i].name, &s->fiu[i],
TYPE_NPCM7XX_FIU);
}
for (i = 0; i < ARRAY_SIZE(s->pwm); i++) {
object_initialize_child(obj, "pwm[*]", &s->pwm[i], TYPE_NPCM7XX_PWM);
}
for (i = 0; i < ARRAY_SIZE(s->mft); i++) {
object_initialize_child(obj, "mft[*]", &s->mft[i], TYPE_NPCM7XX_MFT);
}
object_initialize_child(obj, "mmc", &s->mmc, TYPE_NPCM7XX_SDHCI);
}
static void npcm8xx_realize(DeviceState *dev, Error **errp)
{
NPCM8xxState *s = NPCM8XX(dev);
NPCM8xxClass *nc = NPCM8XX_GET_CLASS(s);
int i;
if (memory_region_size(s->dram) > NPCM8XX_DRAM_SZ) {
error_setg(errp, "%s: NPCM8xx cannot address more than %" PRIu64
" MiB of DRAM", __func__, NPCM8XX_DRAM_SZ / MiB);
return;
}
/* CPUs */
for (i = 0; i < nc->num_cpus; i++) {
object_property_set_int(OBJECT(&s->cpu[i]), "mp-affinity",
arm_build_mp_affinity(i, NPCM8XX_MAX_NUM_CPUS),
&error_abort);
object_property_set_bool(OBJECT(&s->cpu[i]), "reset-hivecs", true,
&error_abort);
object_property_set_int(OBJECT(&s->cpu[i]), "core-count",
nc->num_cpus, &error_abort);
/* Disable security extensions. */
object_property_set_bool(OBJECT(&s->cpu[i]), "has_el3", false,
&error_abort);
if (!qdev_realize(DEVICE(&s->cpu[i]), NULL, errp)) {
return;
}
}
/* ARM GIC for Cortex A35. Can only fail if we pass bad parameters here. */
object_property_set_uint(OBJECT(&s->gic), "num-cpu", nc->num_cpus, errp);
object_property_set_uint(OBJECT(&s->gic), "num-irq", NPCM8XX_NUM_IRQ, errp);
object_property_set_uint(OBJECT(&s->gic), "revision", 2, errp);
object_property_set_bool(OBJECT(&s->gic), "has-security-extensions", true,
errp);
if (!sysbus_realize(SYS_BUS_DEVICE(&s->gic), errp)) {
return;
}
for (i = 0; i < nc->num_cpus; i++) {
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gic), i,
qdev_get_gpio_in(DEVICE(&s->cpu[i]), ARM_CPU_IRQ));
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gic), i + nc->num_cpus,
qdev_get_gpio_in(DEVICE(&s->cpu[i]), ARM_CPU_FIQ));
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gic), i + nc->num_cpus * 2,
qdev_get_gpio_in(DEVICE(&s->cpu[i]), ARM_CPU_VIRQ));
sysbus_connect_irq(SYS_BUS_DEVICE(&s->gic), i + nc->num_cpus * 3,
qdev_get_gpio_in(DEVICE(&s->cpu[i]), ARM_CPU_VFIQ));
qdev_connect_gpio_out(DEVICE(&s->cpu[i]), GTIMER_PHYS,
qdev_get_gpio_in(DEVICE(&s->gic),
NPCM8XX_PPI_BASE(i) + ARCH_TIMER_NS_EL1_IRQ));
qdev_connect_gpio_out(DEVICE(&s->cpu[i]), GTIMER_VIRT,
qdev_get_gpio_in(DEVICE(&s->gic),
NPCM8XX_PPI_BASE(i) + ARCH_TIMER_VIRT_IRQ));
qdev_connect_gpio_out(DEVICE(&s->cpu[i]), GTIMER_HYP,
qdev_get_gpio_in(DEVICE(&s->gic),
NPCM8XX_PPI_BASE(i) + ARCH_TIMER_NS_EL2_IRQ));
qdev_connect_gpio_out(DEVICE(&s->cpu[i]), GTIMER_SEC,
qdev_get_gpio_in(DEVICE(&s->gic),
NPCM8XX_PPI_BASE(i) + ARCH_TIMER_S_EL1_IRQ));
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gic), 0, NPCM8XX_GICD_BA);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gic), 1, NPCM8XX_GICC_BA);
/* CPU cluster */
qdev_prop_set_uint32(DEVICE(&s->cpu_cluster), "cluster-id", 0);
qdev_realize(DEVICE(&s->cpu_cluster), NULL, &error_fatal);
/* System Global Control Registers (GCR). Can fail due to user input. */
object_property_set_int(OBJECT(&s->gcr), "disabled-modules",
nc->disabled_modules, &error_abort);
object_property_add_const_link(OBJECT(&s->gcr), "dram-mr", OBJECT(s->dram));
if (!sysbus_realize(SYS_BUS_DEVICE(&s->gcr), errp)) {
return;
}
sysbus_mmio_map(SYS_BUS_DEVICE(&s->gcr), 0, NPCM8XX_GCR_BA);
/* Clock Control Registers (CLK). Cannot fail. */
sysbus_realize(SYS_BUS_DEVICE(&s->clk), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->clk), 0, NPCM8XX_CLK_BA);
/* OTP fuse strap array. Cannot fail. */
sysbus_realize(SYS_BUS_DEVICE(&s->fuse_array), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->fuse_array), 0, NPCM8XX_OTP_BA);
npcm8xx_init_fuses(s);
/* Fake Memory Controller (MC). Cannot fail. */
sysbus_realize(SYS_BUS_DEVICE(&s->mc), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->mc), 0, NPCM8XX_MC_BA);
/* ADC Modules. Cannot fail. */
qdev_connect_clock_in(DEVICE(&s->adc), "clock", qdev_get_clock_out(
DEVICE(&s->clk), "adc-clock"));
sysbus_realize(SYS_BUS_DEVICE(&s->adc), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->adc), 0, NPCM8XX_ADC_BA);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->adc), 0,
npcm8xx_irq(s, NPCM8XX_ADC_IRQ));
npcm8xx_write_adc_calibration(s);
/* Timer Modules (TIM). Cannot fail. */
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_tim_addr) != ARRAY_SIZE(s->tim));
for (i = 0; i < ARRAY_SIZE(s->tim); i++) {
SysBusDevice *sbd = SYS_BUS_DEVICE(&s->tim[i]);
int first_irq;
int j;
/* Connect the timer clock. */
qdev_connect_clock_in(DEVICE(&s->tim[i]), "clock", qdev_get_clock_out(
DEVICE(&s->clk), "timer-clock"));
sysbus_realize(sbd, &error_abort);
sysbus_mmio_map(sbd, 0, npcm8xx_tim_addr[i]);
first_irq = NPCM8XX_TIMER0_IRQ + i * NPCM7XX_TIMERS_PER_CTRL;
for (j = 0; j < NPCM7XX_TIMERS_PER_CTRL; j++) {
qemu_irq irq = npcm8xx_irq(s, first_irq + j);
sysbus_connect_irq(sbd, j, irq);
}
/* IRQ for watchdogs */
sysbus_connect_irq(sbd, NPCM7XX_TIMERS_PER_CTRL,
npcm8xx_irq(s, NPCM8XX_WDG0_IRQ + i));
/* GPIO that connects clk module with watchdog */
qdev_connect_gpio_out_named(DEVICE(&s->tim[i]),
NPCM7XX_WATCHDOG_RESET_GPIO_OUT, 0,
qdev_get_gpio_in_named(DEVICE(&s->clk),
NPCM7XX_WATCHDOG_RESET_GPIO_IN, i));
}
/* UART0..6 (16550 compatible) */
for (i = 0; i < ARRAY_SIZE(npcm8xx_uart_addr); i++) {
serial_mm_init(get_system_memory(), npcm8xx_uart_addr[i], 2,
npcm8xx_irq(s, NPCM8XX_UART0_IRQ + i), 115200,
serial_hd(i), DEVICE_LITTLE_ENDIAN);
}
/* Random Number Generator. Cannot fail. */
sysbus_realize(SYS_BUS_DEVICE(&s->rng), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->rng), 0, NPCM8XX_RNG_BA);
/* GPIO modules. Cannot fail. */
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_gpio) != ARRAY_SIZE(s->gpio));
for (i = 0; i < ARRAY_SIZE(s->gpio); i++) {
Object *obj = OBJECT(&s->gpio[i]);
object_property_set_uint(obj, "reset-pullup",
npcm8xx_gpio[i].reset_pu, &error_abort);
object_property_set_uint(obj, "reset-pulldown",
npcm8xx_gpio[i].reset_pd, &error_abort);
object_property_set_uint(obj, "reset-osrc",
npcm8xx_gpio[i].reset_osrc, &error_abort);
object_property_set_uint(obj, "reset-odsc",
npcm8xx_gpio[i].reset_odsc, &error_abort);
sysbus_realize(SYS_BUS_DEVICE(obj), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(obj), 0, npcm8xx_gpio[i].regs_addr);
sysbus_connect_irq(SYS_BUS_DEVICE(obj), 0,
npcm8xx_irq(s, NPCM8XX_GPIO0_IRQ + i));
}
/* SMBus modules. Cannot fail. */
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_smbus_addr) != ARRAY_SIZE(s->smbus));
for (i = 0; i < ARRAY_SIZE(s->smbus); i++) {
Object *obj = OBJECT(&s->smbus[i]);
sysbus_realize(SYS_BUS_DEVICE(obj), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(obj), 0, npcm8xx_smbus_addr[i]);
sysbus_connect_irq(SYS_BUS_DEVICE(obj), 0,
npcm8xx_irq(s, NPCM8XX_SMBUS0_IRQ + i));
}
/* USB Host */
QEMU_BUILD_BUG_ON(ARRAY_SIZE(s->ohci) != ARRAY_SIZE(s->ehci));
for (i = 0; i < ARRAY_SIZE(s->ehci); i++) {
object_property_set_bool(OBJECT(&s->ehci[i]), "companion-enable", true,
&error_abort);
sysbus_realize(SYS_BUS_DEVICE(&s->ehci[i]), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ehci[i]), 0, npcm8xx_ehci_addr[i]);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->ehci[i]), 0,
npcm8xx_irq(s, NPCM8XX_EHCI1_IRQ + 2 * i));
}
for (i = 0; i < ARRAY_SIZE(s->ohci); i++) {
object_property_set_str(OBJECT(&s->ohci[i]), "masterbus", "usb-bus.0",
&error_abort);
object_property_set_uint(OBJECT(&s->ohci[i]), "num-ports", 1,
&error_abort);
object_property_set_uint(OBJECT(&s->ohci[i]), "firstport", i,
&error_abort);
sysbus_realize(SYS_BUS_DEVICE(&s->ohci[i]), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->ohci[i]), 0, npcm8xx_ohci_addr[i]);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->ohci[i]), 0,
npcm8xx_irq(s, NPCM8XX_OHCI1_IRQ + 2 * i));
}
/* PWM Modules. Cannot fail. */
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_pwm_addr) != ARRAY_SIZE(s->pwm));
for (i = 0; i < ARRAY_SIZE(s->pwm); i++) {
SysBusDevice *sbd = SYS_BUS_DEVICE(&s->pwm[i]);
qdev_connect_clock_in(DEVICE(&s->pwm[i]), "clock", qdev_get_clock_out(
DEVICE(&s->clk), "apb3-clock"));
sysbus_realize(sbd, &error_abort);
sysbus_mmio_map(sbd, 0, npcm8xx_pwm_addr[i]);
sysbus_connect_irq(sbd, i, npcm8xx_irq(s, NPCM8XX_PWM0_IRQ + i));
}
/* MFT Modules. Cannot fail. */
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_mft_addr) != ARRAY_SIZE(s->mft));
for (i = 0; i < ARRAY_SIZE(s->mft); i++) {
SysBusDevice *sbd = SYS_BUS_DEVICE(&s->mft[i]);
qdev_connect_clock_in(DEVICE(&s->mft[i]), "clock-in",
qdev_get_clock_out(DEVICE(&s->clk),
"apb4-clock"));
sysbus_realize(sbd, &error_abort);
sysbus_mmio_map(sbd, 0, npcm8xx_mft_addr[i]);
sysbus_connect_irq(sbd, 0, npcm8xx_irq(s, NPCM8XX_MFT0_IRQ + i));
}
/*
* Flash Interface Unit (FIU). Can fail if incorrect number of chip selects
* specified, but this is a programming error.
*/
QEMU_BUILD_BUG_ON(ARRAY_SIZE(npcm8xx_fiu) != ARRAY_SIZE(s->fiu));
for (i = 0; i < ARRAY_SIZE(s->fiu); i++) {
SysBusDevice *sbd = SYS_BUS_DEVICE(&s->fiu[i]);
int j;
object_property_set_int(OBJECT(sbd), "cs-count",
npcm8xx_fiu[i].cs_count, &error_abort);
object_property_set_int(OBJECT(sbd), "flash-size",
npcm8xx_fiu[i].flash_size, &error_abort);
sysbus_realize(sbd, &error_abort);
sysbus_mmio_map(sbd, 0, npcm8xx_fiu[i].regs_addr);
for (j = 0; j < npcm8xx_fiu[i].cs_count; j++) {
sysbus_mmio_map(sbd, j + 1, npcm8xx_fiu[i].flash_addr[j]);
}
}
/* RAM2 (SRAM) */
memory_region_init_ram(&s->sram, OBJECT(dev), "ram2",
NPCM8XX_RAM2_SZ, &error_abort);
memory_region_add_subregion(get_system_memory(), NPCM8XX_RAM2_BA, &s->sram);
/* RAM3 (SRAM) */
memory_region_init_ram(&s->ram3, OBJECT(dev), "ram3",
NPCM8XX_RAM3_SZ, &error_abort);
memory_region_add_subregion(get_system_memory(), NPCM8XX_RAM3_BA, &s->ram3);
/* Internal ROM */
memory_region_init_rom(&s->irom, OBJECT(dev), "irom", NPCM8XX_ROM_SZ,
&error_abort);
memory_region_add_subregion(get_system_memory(), NPCM8XX_ROM_BA, &s->irom);
/* SDHCI */
sysbus_realize(SYS_BUS_DEVICE(&s->mmc), &error_abort);
sysbus_mmio_map(SYS_BUS_DEVICE(&s->mmc), 0, NPCM8XX_MMC_BA);
sysbus_connect_irq(SYS_BUS_DEVICE(&s->mmc), 0,
npcm8xx_irq(s, NPCM8XX_MMC_IRQ));
create_unimplemented_device("npcm8xx.shm", 0xc0001000, 4 * KiB);
create_unimplemented_device("npcm8xx.gicextra", 0xdfffa000, 24 * KiB);
create_unimplemented_device("npcm8xx.vdmx", 0xe0800000, 4 * KiB);
create_unimplemented_device("npcm8xx.pcierc", 0xe1000000, 64 * KiB);
create_unimplemented_device("npcm8xx.rootc", 0xe8000000, 128 * MiB);
create_unimplemented_device("npcm8xx.kcs", 0xf0007000, 4 * KiB);
create_unimplemented_device("npcm8xx.gfxi", 0xf000e000, 4 * KiB);
create_unimplemented_device("npcm8xx.fsw", 0xf000f000, 4 * KiB);
create_unimplemented_device("npcm8xx.bt", 0xf0030000, 4 * KiB);
create_unimplemented_device("npcm8xx.espi", 0xf009f000, 4 * KiB);
create_unimplemented_device("npcm8xx.peci", 0xf0100000, 4 * KiB);
create_unimplemented_device("npcm8xx.siox[1]", 0xf0101000, 4 * KiB);
create_unimplemented_device("npcm8xx.siox[2]", 0xf0102000, 4 * KiB);
create_unimplemented_device("npcm8xx.tmps", 0xf0188000, 4 * KiB);
create_unimplemented_device("npcm8xx.pspi", 0xf0201000, 4 * KiB);
create_unimplemented_device("npcm8xx.viru1", 0xf0204000, 4 * KiB);
create_unimplemented_device("npcm8xx.viru2", 0xf0205000, 4 * KiB);
create_unimplemented_device("npcm8xx.jtm1", 0xf0208000, 4 * KiB);
create_unimplemented_device("npcm8xx.jtm2", 0xf0209000, 4 * KiB);
create_unimplemented_device("npcm8xx.flm0", 0xf0210000, 4 * KiB);
create_unimplemented_device("npcm8xx.flm1", 0xf0211000, 4 * KiB);
create_unimplemented_device("npcm8xx.flm2", 0xf0212000, 4 * KiB);
create_unimplemented_device("npcm8xx.flm3", 0xf0213000, 4 * KiB);
create_unimplemented_device("npcm8xx.ahbpci", 0xf0400000, 1 * MiB);
create_unimplemented_device("npcm8xx.dap", 0xf0500000, 960 * KiB);
create_unimplemented_device("npcm8xx.mcphy", 0xf05f0000, 64 * KiB);
create_unimplemented_device("npcm8xx.pcs", 0xf0780000, 256 * KiB);
create_unimplemented_device("npcm8xx.tsgen", 0xf07fc000, 8 * KiB);
create_unimplemented_device("npcm8xx.gmac1", 0xf0802000, 8 * KiB);
create_unimplemented_device("npcm8xx.gmac2", 0xf0804000, 8 * KiB);
create_unimplemented_device("npcm8xx.gmac3", 0xf0806000, 8 * KiB);
create_unimplemented_device("npcm8xx.gmac4", 0xf0808000, 8 * KiB);
create_unimplemented_device("npcm8xx.copctl", 0xf080c000, 4 * KiB);
create_unimplemented_device("npcm8xx.tipctl", 0xf080d000, 4 * KiB);
create_unimplemented_device("npcm8xx.rst", 0xf080e000, 4 * KiB);
create_unimplemented_device("npcm8xx.vcd", 0xf0810000, 64 * KiB);
create_unimplemented_device("npcm8xx.ece", 0xf0820000, 8 * KiB);
create_unimplemented_device("npcm8xx.vdma", 0xf0822000, 8 * KiB);
create_unimplemented_device("npcm8xx.usbd[0]", 0xf0830000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[1]", 0xf0831000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[2]", 0xf0832000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[3]", 0xf0833000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[4]", 0xf0834000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[5]", 0xf0835000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[6]", 0xf0836000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[7]", 0xf0837000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[8]", 0xf0838000, 4 * KiB);
create_unimplemented_device("npcm8xx.usbd[9]", 0xf0839000, 4 * KiB);
create_unimplemented_device("npcm8xx.pci_mbox1", 0xf0848000, 64 * KiB);
create_unimplemented_device("npcm8xx.gdma0", 0xf0850000, 4 * KiB);
create_unimplemented_device("npcm8xx.gdma1", 0xf0851000, 4 * KiB);
create_unimplemented_device("npcm8xx.gdma2", 0xf0852000, 4 * KiB);
create_unimplemented_device("npcm8xx.aes", 0xf0858000, 4 * KiB);
create_unimplemented_device("npcm8xx.des", 0xf0859000, 4 * KiB);
create_unimplemented_device("npcm8xx.sha", 0xf085a000, 4 * KiB);
create_unimplemented_device("npcm8xx.pci_mbox2", 0xf0868000, 64 * KiB);
create_unimplemented_device("npcm8xx.i3c0", 0xfff10000, 4 * KiB);
create_unimplemented_device("npcm8xx.i3c1", 0xfff11000, 4 * KiB);
create_unimplemented_device("npcm8xx.i3c2", 0xfff12000, 4 * KiB);
create_unimplemented_device("npcm8xx.i3c3", 0xfff13000, 4 * KiB);
create_unimplemented_device("npcm8xx.i3c4", 0xfff14000, 4 * KiB);
create_unimplemented_device("npcm8xx.i3c5", 0xfff15000, 4 * KiB);
create_unimplemented_device("npcm8xx.spixcs0", 0xf8000000, 16 * MiB);
create_unimplemented_device("npcm8xx.spixcs1", 0xf9000000, 16 * MiB);
create_unimplemented_device("npcm8xx.spix", 0xfb001000, 4 * KiB);
create_unimplemented_device("npcm8xx.vect", 0xffff0000, 256);
}
static const Property npcm8xx_properties[] = {
DEFINE_PROP_LINK("dram-mr", NPCM8xxState, dram, TYPE_MEMORY_REGION,
MemoryRegion *),
};
static void npcm8xx_class_init(ObjectClass *oc, void *data)
{
DeviceClass *dc = DEVICE_CLASS(oc);
NPCM8xxClass *nc = NPCM8XX_CLASS(oc);
dc->realize = npcm8xx_realize;
dc->user_creatable = false;
nc->disabled_modules = 0x00000000;
nc->num_cpus = NPCM8XX_MAX_NUM_CPUS;
device_class_set_props(dc, npcm8xx_properties);
}
static const TypeInfo npcm8xx_soc_types[] = {
{
.name = TYPE_NPCM8XX,
.parent = TYPE_DEVICE,
.instance_size = sizeof(NPCM8xxState),
.instance_init = npcm8xx_init,
.class_size = sizeof(NPCM8xxClass),
.class_init = npcm8xx_class_init,
},
};
DEFINE_TYPES(npcm8xx_soc_types);

106
include/hw/arm/npcm8xx.h
View File

@ -0,0 +1,106 @@
/*
* Nuvoton NPCM8xx SoC family.
*
* Copyright 2022 Google LLC
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that 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.
*/
#ifndef NPCM8XX_H
#define NPCM8XX_H
#include "hw/adc/npcm7xx_adc.h"
#include "hw/core/split-irq.h"
#include "hw/cpu/cluster.h"
#include "hw/gpio/npcm7xx_gpio.h"
#include "hw/i2c/npcm7xx_smbus.h"
#include "hw/intc/arm_gic_common.h"
#include "hw/mem/npcm7xx_mc.h"
#include "hw/misc/npcm_clk.h"
#include "hw/misc/npcm_gcr.h"
#include "hw/misc/npcm7xx_mft.h"
#include "hw/misc/npcm7xx_pwm.h"
#include "hw/misc/npcm7xx_rng.h"
#include "hw/net/npcm7xx_emc.h"
#include "hw/nvram/npcm7xx_otp.h"
#include "hw/sd/npcm7xx_sdhci.h"
#include "hw/timer/npcm7xx_timer.h"
#include "hw/ssi/npcm7xx_fiu.h"
#include "hw/usb/hcd-ehci.h"
#include "hw/usb/hcd-ohci.h"
#include "target/arm/cpu.h"
#define NPCM8XX_MAX_NUM_CPUS (4)
/* The first half of the address space is reserved for DDR4 DRAM. */
#define NPCM8XX_DRAM_BA (0x00000000)
#define NPCM8XX_DRAM_SZ (2 * GiB)
/* Magic addresses for setting up direct kernel booting and SMP boot stubs. */
#define NPCM8XX_LOADER_START (0x00000000) /* Start of SDRAM */
#define NPCM8XX_SMP_LOADER_START (0xffff0000) /* Boot ROM */
#define NPCM8XX_SMP_BOOTREG_ADDR (0xf080013c) /* GCR.SCRPAD */
#define NPCM8XX_BOARD_SETUP_ADDR (0xffff1000) /* Boot ROM */
#define NPCM8XX_NR_PWM_MODULES 3
struct NPCM8xxState {
DeviceState parent_obj;
ARMCPU cpu[NPCM8XX_MAX_NUM_CPUS];
CPUClusterState cpu_cluster;
GICState gic;
MemoryRegion sram;
MemoryRegion irom;
MemoryRegion ram3;
MemoryRegion *dram;
NPCMGCRState gcr;
NPCMCLKState clk;
NPCM7xxTimerCtrlState tim[3];
NPCM7xxADCState adc;
NPCM7xxPWMState pwm[NPCM8XX_NR_PWM_MODULES];
NPCM7xxMFTState mft[8];
NPCM7xxOTPState fuse_array;
NPCM7xxMCState mc;
NPCM7xxRNGState rng;
NPCM7xxGPIOState gpio[8];
NPCM7xxSMBusState smbus[27];
EHCISysBusState ehci[2];
OHCISysBusState ohci[2];
NPCM7xxFIUState fiu[3];
NPCM7xxSDHCIState mmc;
};
struct NPCM8xxClass {
DeviceClass parent_class;
/* Bitmask of modules that are permanently disabled on this chip. */
uint32_t disabled_modules;
/* Number of CPU cores enabled in this SoC class. */
uint32_t num_cpus;
};
#define TYPE_NPCM8XX "npcm8xx"
OBJECT_DECLARE_TYPE(NPCM8xxState, NPCM8xxClass, NPCM8XX)
/**
* npcm8xx_load_kernel - Loads memory with everything needed to boot
* @machine - The machine containing the SoC to be booted.
* @soc - The SoC containing the CPU to be booted.
*
* This will set up the ARM boot info structure for the specific NPCM8xx
* derivative and call arm_load_kernel() to set up loading of the kernel, etc.
* into memory, if requested by the user.
*/
void npcm8xx_load_kernel(MachineState *machine, NPCM8xxState *soc);
#endif /* NPCM8XX_H */
Write Preview
Loading…
Cancel
Save