2016-10-22 12:46:35 +03:00
|
|
|
/*
|
|
|
|
* QEMU PowerPC PowerNV machine model
|
|
|
|
*
|
|
|
|
* Copyright (c) 2016, IBM Corporation.
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library 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
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
2018-06-25 15:41:58 +03:00
|
|
|
#include "qemu/units.h"
|
2016-10-22 12:46:35 +03:00
|
|
|
#include "qapi/error.h"
|
|
|
|
#include "sysemu/sysemu.h"
|
|
|
|
#include "sysemu/numa.h"
|
2017-03-03 14:01:16 +03:00
|
|
|
#include "sysemu/cpus.h"
|
2016-10-22 12:46:35 +03:00
|
|
|
#include "hw/hw.h"
|
2016-10-11 09:56:52 +03:00
|
|
|
#include "target/ppc/cpu.h"
|
2016-10-22 12:46:35 +03:00
|
|
|
#include "qemu/log.h"
|
|
|
|
#include "hw/ppc/fdt.h"
|
|
|
|
#include "hw/ppc/ppc.h"
|
|
|
|
#include "hw/ppc/pnv.h"
|
2016-10-22 12:46:39 +03:00
|
|
|
#include "hw/ppc/pnv_core.h"
|
2016-10-22 12:46:35 +03:00
|
|
|
#include "hw/loader.h"
|
|
|
|
#include "exec/address-spaces.h"
|
2016-10-22 12:46:36 +03:00
|
|
|
#include "qapi/visitor.h"
|
2017-04-03 10:46:02 +03:00
|
|
|
#include "monitor/monitor.h"
|
|
|
|
#include "hw/intc/intc.h"
|
2017-04-11 18:30:05 +03:00
|
|
|
#include "hw/ipmi/ipmi.h"
|
2018-03-23 06:11:07 +03:00
|
|
|
#include "target/ppc/mmu-hash64.h"
|
2016-10-22 12:46:35 +03:00
|
|
|
|
2017-04-03 10:46:01 +03:00
|
|
|
#include "hw/ppc/xics.h"
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
#include "hw/ppc/pnv_xscom.h"
|
|
|
|
|
2016-10-22 12:46:43 +03:00
|
|
|
#include "hw/isa/isa.h"
|
|
|
|
#include "hw/char/serial.h"
|
|
|
|
#include "hw/timer/mc146818rtc.h"
|
|
|
|
|
2016-10-22 12:46:35 +03:00
|
|
|
#include <libfdt.h>
|
|
|
|
|
2019-02-25 20:01:55 +03:00
|
|
|
#define FDT_MAX_SIZE (1 * MiB)
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
#define FW_FILE_NAME "skiboot.lid"
|
|
|
|
#define FW_LOAD_ADDR 0x0
|
2019-02-25 20:01:55 +03:00
|
|
|
#define FW_MAX_SIZE (4 * MiB)
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
#define KERNEL_LOAD_ADDR 0x20000000
|
2019-02-25 20:01:53 +03:00
|
|
|
#define KERNEL_MAX_SIZE (256 * MiB)
|
2018-01-15 21:04:05 +03:00
|
|
|
#define INITRD_LOAD_ADDR 0x60000000
|
2019-02-25 20:01:54 +03:00
|
|
|
#define INITRD_MAX_SIZE (256 * MiB)
|
2016-10-22 12:46:35 +03:00
|
|
|
|
2017-10-09 22:51:10 +03:00
|
|
|
static const char *pnv_chip_core_typename(const PnvChip *o)
|
|
|
|
{
|
|
|
|
const char *chip_type = object_class_get_name(object_get_class(OBJECT(o)));
|
|
|
|
int len = strlen(chip_type) - strlen(PNV_CHIP_TYPE_SUFFIX);
|
|
|
|
char *s = g_strdup_printf(PNV_CORE_TYPE_NAME("%.*s"), len, chip_type);
|
|
|
|
const char *core_type = object_class_get_name(object_class_by_name(s));
|
|
|
|
g_free(s);
|
|
|
|
return core_type;
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:35 +03:00
|
|
|
/*
|
|
|
|
* On Power Systems E880 (POWER8), the max cpus (threads) should be :
|
|
|
|
* 4 * 4 sockets * 12 cores * 8 threads = 1536
|
|
|
|
* Let's make it 2^11
|
|
|
|
*/
|
|
|
|
#define MAX_CPUS 2048
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Memory nodes are created by hostboot, one for each range of memory
|
|
|
|
* that has a different "affinity". In practice, it means one range
|
|
|
|
* per chip.
|
|
|
|
*/
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_dt_memory(void *fdt, int chip_id, hwaddr start, hwaddr size)
|
2016-10-22 12:46:35 +03:00
|
|
|
{
|
|
|
|
char *mem_name;
|
|
|
|
uint64_t mem_reg_property[2];
|
|
|
|
int off;
|
|
|
|
|
|
|
|
mem_reg_property[0] = cpu_to_be64(start);
|
|
|
|
mem_reg_property[1] = cpu_to_be64(size);
|
|
|
|
|
|
|
|
mem_name = g_strdup_printf("memory@%"HWADDR_PRIx, start);
|
|
|
|
off = fdt_add_subnode(fdt, 0, mem_name);
|
|
|
|
g_free(mem_name);
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_string(fdt, off, "device_type", "memory")));
|
|
|
|
_FDT((fdt_setprop(fdt, off, "reg", mem_reg_property,
|
|
|
|
sizeof(mem_reg_property))));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, off, "ibm,chip-id", chip_id)));
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:39 +03:00
|
|
|
static int get_cpus_node(void *fdt)
|
|
|
|
{
|
|
|
|
int cpus_offset = fdt_path_offset(fdt, "/cpus");
|
|
|
|
|
|
|
|
if (cpus_offset < 0) {
|
2017-10-03 17:13:11 +03:00
|
|
|
cpus_offset = fdt_add_subnode(fdt, 0, "cpus");
|
2016-10-22 12:46:39 +03:00
|
|
|
if (cpus_offset) {
|
|
|
|
_FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_FDT(cpus_offset);
|
|
|
|
return cpus_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The PowerNV cores (and threads) need to use real HW ids and not an
|
|
|
|
* incremental index like it has been done on other platforms. This HW
|
|
|
|
* id is stored in the CPU PIR, it is used to create cpu nodes in the
|
|
|
|
* device tree, used in XSCOM to address cores and in interrupt
|
|
|
|
* servers.
|
|
|
|
*/
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_dt_core(PnvChip *chip, PnvCore *pc, void *fdt)
|
2016-10-22 12:46:39 +03:00
|
|
|
{
|
2018-06-13 04:57:37 +03:00
|
|
|
PowerPCCPU *cpu = pc->threads[0];
|
|
|
|
CPUState *cs = CPU(cpu);
|
2016-10-22 12:46:39 +03:00
|
|
|
DeviceClass *dc = DEVICE_GET_CLASS(cs);
|
2016-11-01 02:25:29 +03:00
|
|
|
int smt_threads = CPU_CORE(pc)->nr_threads;
|
2016-10-22 12:46:39 +03:00
|
|
|
CPUPPCState *env = &cpu->env;
|
|
|
|
PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
|
|
|
|
uint32_t servers_prop[smt_threads];
|
|
|
|
int i;
|
|
|
|
uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
|
|
|
|
0xffffffff, 0xffffffff};
|
|
|
|
uint32_t tbfreq = PNV_TIMEBASE_FREQ;
|
|
|
|
uint32_t cpufreq = 1000000000;
|
|
|
|
uint32_t page_sizes_prop[64];
|
|
|
|
size_t page_sizes_prop_size;
|
|
|
|
const uint8_t pa_features[] = { 24, 0,
|
|
|
|
0xf6, 0x3f, 0xc7, 0xc0, 0x80, 0xf0,
|
|
|
|
0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
|
|
|
|
0x80, 0x00, 0x80, 0x00, 0x80, 0x00 };
|
|
|
|
int offset;
|
|
|
|
char *nodename;
|
|
|
|
int cpus_offset = get_cpus_node(fdt);
|
|
|
|
|
|
|
|
nodename = g_strdup_printf("%s@%x", dc->fw_name, pc->pir);
|
|
|
|
offset = fdt_add_subnode(fdt, cpus_offset, nodename);
|
|
|
|
_FDT(offset);
|
|
|
|
g_free(nodename);
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id", chip->chip_id)));
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "reg", pc->pir)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "ibm,pir", pc->pir)));
|
|
|
|
_FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu")));
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR])));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size",
|
|
|
|
env->dcache_line_size)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size",
|
|
|
|
env->dcache_line_size)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size",
|
|
|
|
env->icache_line_size)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size",
|
|
|
|
env->icache_line_size)));
|
|
|
|
|
|
|
|
if (pcc->l1_dcache_size) {
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "d-cache-size",
|
|
|
|
pcc->l1_dcache_size)));
|
|
|
|
} else {
|
2017-07-12 16:57:41 +03:00
|
|
|
warn_report("Unknown L1 dcache size for cpu");
|
2016-10-22 12:46:39 +03:00
|
|
|
}
|
|
|
|
if (pcc->l1_icache_size) {
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "i-cache-size",
|
|
|
|
pcc->l1_icache_size)));
|
|
|
|
} else {
|
2017-07-12 16:57:41 +03:00
|
|
|
warn_report("Unknown L1 icache size for cpu");
|
2016-10-22 12:46:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq)));
|
2018-03-29 10:29:38 +03:00
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", cpu->hash64_opts->slb_size)));
|
2016-10-22 12:46:39 +03:00
|
|
|
_FDT((fdt_setprop_string(fdt, offset, "status", "okay")));
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0)));
|
|
|
|
|
|
|
|
if (env->spr_cb[SPR_PURR].oea_read) {
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0)));
|
|
|
|
}
|
|
|
|
|
2018-03-23 06:11:07 +03:00
|
|
|
if (ppc_hash64_has(cpu, PPC_HASH64_1TSEG)) {
|
2016-10-22 12:46:39 +03:00
|
|
|
_FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes",
|
|
|
|
segs, sizeof(segs))));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Advertise VMX/VSX (vector extensions) if available
|
|
|
|
* 0 / no property == no vector extensions
|
|
|
|
* 1 == VMX / Altivec available
|
|
|
|
* 2 == VSX available */
|
|
|
|
if (env->insns_flags & PPC_ALTIVEC) {
|
|
|
|
uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1;
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Advertise DFP (Decimal Floating Point) if available
|
|
|
|
* 0 / no property == no DFP
|
|
|
|
* 1 == DFP available */
|
|
|
|
if (env->insns_flags2 & PPC2_DFP) {
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1)));
|
|
|
|
}
|
|
|
|
|
2018-03-22 08:18:40 +03:00
|
|
|
page_sizes_prop_size = ppc_create_page_sizes_prop(cpu, page_sizes_prop,
|
|
|
|
sizeof(page_sizes_prop));
|
2016-10-22 12:46:39 +03:00
|
|
|
if (page_sizes_prop_size) {
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes",
|
|
|
|
page_sizes_prop, page_sizes_prop_size)));
|
|
|
|
}
|
|
|
|
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "ibm,pa-features",
|
|
|
|
pa_features, sizeof(pa_features))));
|
|
|
|
|
|
|
|
/* Build interrupt servers properties */
|
|
|
|
for (i = 0; i < smt_threads; i++) {
|
|
|
|
servers_prop[i] = cpu_to_be32(pc->pir + i);
|
|
|
|
}
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s",
|
|
|
|
servers_prop, sizeof(servers_prop))));
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_dt_icp(PnvChip *chip, void *fdt, uint32_t pir,
|
|
|
|
uint32_t nr_threads)
|
2017-04-03 10:46:05 +03:00
|
|
|
{
|
|
|
|
uint64_t addr = PNV_ICP_BASE(chip) | (pir << 12);
|
|
|
|
char *name;
|
|
|
|
const char compat[] = "IBM,power8-icp\0IBM,ppc-xicp";
|
|
|
|
uint32_t irange[2], i, rsize;
|
|
|
|
uint64_t *reg;
|
|
|
|
int offset;
|
|
|
|
|
|
|
|
irange[0] = cpu_to_be32(pir);
|
|
|
|
irange[1] = cpu_to_be32(nr_threads);
|
|
|
|
|
|
|
|
rsize = sizeof(uint64_t) * 2 * nr_threads;
|
|
|
|
reg = g_malloc(rsize);
|
|
|
|
for (i = 0; i < nr_threads; i++) {
|
|
|
|
reg[i * 2] = cpu_to_be64(addr | ((pir + i) * 0x1000));
|
|
|
|
reg[i * 2 + 1] = cpu_to_be64(0x1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
name = g_strdup_printf("interrupt-controller@%"PRIX64, addr);
|
|
|
|
offset = fdt_add_subnode(fdt, 0, name);
|
|
|
|
_FDT(offset);
|
|
|
|
g_free(name);
|
|
|
|
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "compatible", compat, sizeof(compat))));
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "reg", reg, rsize)));
|
|
|
|
_FDT((fdt_setprop_string(fdt, offset, "device_type",
|
|
|
|
"PowerPC-External-Interrupt-Presentation")));
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "interrupt-controller", NULL, 0)));
|
|
|
|
_FDT((fdt_setprop(fdt, offset, "ibm,interrupt-server-ranges",
|
|
|
|
irange, sizeof(irange))));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "#interrupt-cells", 1)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, offset, "#address-cells", 0)));
|
|
|
|
g_free(reg);
|
|
|
|
}
|
|
|
|
|
2019-03-06 11:50:12 +03:00
|
|
|
static void pnv_chip_power8_dt_populate(PnvChip *chip, void *fdt)
|
2016-10-22 12:46:36 +03:00
|
|
|
{
|
2017-10-09 22:51:10 +03:00
|
|
|
const char *typename = pnv_chip_core_typename(chip);
|
2016-10-22 12:46:39 +03:00
|
|
|
size_t typesize = object_type_get_instance_size(typename);
|
|
|
|
int i;
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_xscom(chip, fdt, 0);
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
|
2016-10-22 12:46:39 +03:00
|
|
|
for (i = 0; i < chip->nr_cores; i++) {
|
|
|
|
PnvCore *pnv_core = PNV_CORE(chip->cores + i * typesize);
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_core(chip, pnv_core, fdt);
|
2017-04-03 10:46:05 +03:00
|
|
|
|
|
|
|
/* Interrupt Control Presenters (ICP). One per core. */
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_icp(chip, fdt, pnv_core->pir, CPU_CORE(pnv_core)->nr_threads);
|
2016-10-22 12:46:39 +03:00
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:36 +03:00
|
|
|
if (chip->ram_size) {
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_memory(fdt, chip->chip_id, chip->ram_start, chip->ram_size);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-06 11:50:12 +03:00
|
|
|
static void pnv_chip_power9_dt_populate(PnvChip *chip, void *fdt)
|
|
|
|
{
|
|
|
|
const char *typename = pnv_chip_core_typename(chip);
|
|
|
|
size_t typesize = object_type_get_instance_size(typename);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
pnv_dt_xscom(chip, fdt, 0);
|
|
|
|
|
|
|
|
for (i = 0; i < chip->nr_cores; i++) {
|
|
|
|
PnvCore *pnv_core = PNV_CORE(chip->cores + i * typesize);
|
|
|
|
|
|
|
|
pnv_dt_core(chip, pnv_core, fdt);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (chip->ram_size) {
|
|
|
|
pnv_dt_memory(fdt, chip->chip_id, chip->ram_start, chip->ram_size);
|
|
|
|
}
|
2019-03-08 01:35:39 +03:00
|
|
|
|
|
|
|
pnv_dt_lpc(chip, fdt, 0);
|
2019-03-06 11:50:12 +03:00
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_dt_rtc(ISADevice *d, void *fdt, int lpc_off)
|
2017-04-11 18:30:02 +03:00
|
|
|
{
|
|
|
|
uint32_t io_base = d->ioport_id;
|
|
|
|
uint32_t io_regs[] = {
|
|
|
|
cpu_to_be32(1),
|
|
|
|
cpu_to_be32(io_base),
|
|
|
|
cpu_to_be32(2)
|
|
|
|
};
|
|
|
|
char *name;
|
|
|
|
int node;
|
|
|
|
|
|
|
|
name = g_strdup_printf("%s@i%x", qdev_fw_name(DEVICE(d)), io_base);
|
|
|
|
node = fdt_add_subnode(fdt, lpc_off, name);
|
|
|
|
_FDT(node);
|
|
|
|
g_free(name);
|
|
|
|
|
|
|
|
_FDT((fdt_setprop(fdt, node, "reg", io_regs, sizeof(io_regs))));
|
|
|
|
_FDT((fdt_setprop_string(fdt, node, "compatible", "pnpPNP,b00")));
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_dt_serial(ISADevice *d, void *fdt, int lpc_off)
|
2017-04-11 18:30:03 +03:00
|
|
|
{
|
|
|
|
const char compatible[] = "ns16550\0pnpPNP,501";
|
|
|
|
uint32_t io_base = d->ioport_id;
|
|
|
|
uint32_t io_regs[] = {
|
|
|
|
cpu_to_be32(1),
|
|
|
|
cpu_to_be32(io_base),
|
|
|
|
cpu_to_be32(8)
|
|
|
|
};
|
|
|
|
char *name;
|
|
|
|
int node;
|
|
|
|
|
|
|
|
name = g_strdup_printf("%s@i%x", qdev_fw_name(DEVICE(d)), io_base);
|
|
|
|
node = fdt_add_subnode(fdt, lpc_off, name);
|
|
|
|
_FDT(node);
|
|
|
|
g_free(name);
|
|
|
|
|
|
|
|
_FDT((fdt_setprop(fdt, node, "reg", io_regs, sizeof(io_regs))));
|
|
|
|
_FDT((fdt_setprop(fdt, node, "compatible", compatible,
|
|
|
|
sizeof(compatible))));
|
|
|
|
|
|
|
|
_FDT((fdt_setprop_cell(fdt, node, "clock-frequency", 1843200)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, node, "current-speed", 115200)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, node, "interrupts", d->isairq[0])));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, node, "interrupt-parent",
|
|
|
|
fdt_get_phandle(fdt, lpc_off))));
|
|
|
|
|
|
|
|
/* This is needed by Linux */
|
|
|
|
_FDT((fdt_setprop_string(fdt, node, "device_type", "serial")));
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_dt_ipmi_bt(ISADevice *d, void *fdt, int lpc_off)
|
2017-04-11 18:30:04 +03:00
|
|
|
{
|
|
|
|
const char compatible[] = "bt\0ipmi-bt";
|
|
|
|
uint32_t io_base;
|
|
|
|
uint32_t io_regs[] = {
|
|
|
|
cpu_to_be32(1),
|
|
|
|
0, /* 'io_base' retrieved from the 'ioport' property of 'isa-ipmi-bt' */
|
|
|
|
cpu_to_be32(3)
|
|
|
|
};
|
|
|
|
uint32_t irq;
|
|
|
|
char *name;
|
|
|
|
int node;
|
|
|
|
|
|
|
|
io_base = object_property_get_int(OBJECT(d), "ioport", &error_fatal);
|
|
|
|
io_regs[1] = cpu_to_be32(io_base);
|
|
|
|
|
|
|
|
irq = object_property_get_int(OBJECT(d), "irq", &error_fatal);
|
|
|
|
|
|
|
|
name = g_strdup_printf("%s@i%x", qdev_fw_name(DEVICE(d)), io_base);
|
|
|
|
node = fdt_add_subnode(fdt, lpc_off, name);
|
|
|
|
_FDT(node);
|
|
|
|
g_free(name);
|
|
|
|
|
2017-06-05 18:44:21 +03:00
|
|
|
_FDT((fdt_setprop(fdt, node, "reg", io_regs, sizeof(io_regs))));
|
|
|
|
_FDT((fdt_setprop(fdt, node, "compatible", compatible,
|
|
|
|
sizeof(compatible))));
|
2017-04-11 18:30:04 +03:00
|
|
|
|
|
|
|
/* Mark it as reserved to avoid Linux trying to claim it */
|
|
|
|
_FDT((fdt_setprop_string(fdt, node, "status", "reserved")));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, node, "interrupts", irq)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, node, "interrupt-parent",
|
|
|
|
fdt_get_phandle(fdt, lpc_off))));
|
|
|
|
}
|
|
|
|
|
2017-04-11 18:30:01 +03:00
|
|
|
typedef struct ForeachPopulateArgs {
|
|
|
|
void *fdt;
|
|
|
|
int offset;
|
|
|
|
} ForeachPopulateArgs;
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static int pnv_dt_isa_device(DeviceState *dev, void *opaque)
|
2017-04-11 18:30:01 +03:00
|
|
|
{
|
2017-04-11 18:30:02 +03:00
|
|
|
ForeachPopulateArgs *args = opaque;
|
|
|
|
ISADevice *d = ISA_DEVICE(dev);
|
|
|
|
|
|
|
|
if (object_dynamic_cast(OBJECT(dev), TYPE_MC146818_RTC)) {
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_rtc(d, args->fdt, args->offset);
|
2017-04-11 18:30:03 +03:00
|
|
|
} else if (object_dynamic_cast(OBJECT(dev), TYPE_ISA_SERIAL)) {
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_serial(d, args->fdt, args->offset);
|
2017-04-11 18:30:04 +03:00
|
|
|
} else if (object_dynamic_cast(OBJECT(dev), "isa-ipmi-bt")) {
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_ipmi_bt(d, args->fdt, args->offset);
|
2017-04-11 18:30:02 +03:00
|
|
|
} else {
|
|
|
|
error_report("unknown isa device %s@i%x", qdev_fw_name(dev),
|
|
|
|
d->ioport_id);
|
|
|
|
}
|
|
|
|
|
2017-04-11 18:30:01 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-06-18 20:05:40 +03:00
|
|
|
/* The default LPC bus of a multichip system is on chip 0. It's
|
|
|
|
* recognized by the firmware (skiboot) using a "primary" property.
|
|
|
|
*/
|
|
|
|
static void pnv_dt_isa(PnvMachineState *pnv, void *fdt)
|
|
|
|
{
|
2019-03-08 01:35:38 +03:00
|
|
|
int isa_offset = fdt_path_offset(fdt, pnv->chips[0]->dt_isa_nodename);
|
2017-04-11 18:30:01 +03:00
|
|
|
ForeachPopulateArgs args = {
|
|
|
|
.fdt = fdt,
|
2018-06-18 20:05:40 +03:00
|
|
|
.offset = isa_offset,
|
2017-04-11 18:30:01 +03:00
|
|
|
};
|
|
|
|
|
2018-06-18 20:05:40 +03:00
|
|
|
_FDT((fdt_setprop(fdt, isa_offset, "primary", NULL, 0)));
|
|
|
|
|
2017-04-11 18:30:01 +03:00
|
|
|
/* ISA devices are not necessarily parented to the ISA bus so we
|
|
|
|
* can not use object_child_foreach() */
|
2018-06-18 20:05:40 +03:00
|
|
|
qbus_walk_children(BUS(pnv->isa_bus), pnv_dt_isa_device, NULL, NULL, NULL,
|
|
|
|
&args);
|
2017-04-11 18:30:01 +03:00
|
|
|
}
|
|
|
|
|
2019-03-08 01:35:47 +03:00
|
|
|
static void pnv_dt_power_mgt(void *fdt)
|
|
|
|
{
|
|
|
|
int off;
|
|
|
|
|
|
|
|
off = fdt_add_subnode(fdt, 0, "ibm,opal");
|
|
|
|
off = fdt_add_subnode(fdt, off, "power-mgt");
|
|
|
|
|
|
|
|
_FDT(fdt_setprop_cell(fdt, off, "ibm,enabled-stop-levels", 0xc0000000));
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void *pnv_dt_create(MachineState *machine)
|
2016-10-22 12:46:35 +03:00
|
|
|
{
|
2019-05-27 10:17:49 +03:00
|
|
|
const char plat_compat8[] = "qemu,powernv8\0qemu,powernv\0ibm,powernv";
|
|
|
|
const char plat_compat9[] = "qemu,powernv9\0ibm,powernv";
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(machine);
|
2016-10-22 12:46:35 +03:00
|
|
|
void *fdt;
|
|
|
|
char *buf;
|
|
|
|
int off;
|
2016-10-22 12:46:36 +03:00
|
|
|
int i;
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
fdt = g_malloc0(FDT_MAX_SIZE);
|
|
|
|
_FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE)));
|
|
|
|
|
|
|
|
/* Root node */
|
|
|
|
_FDT((fdt_setprop_cell(fdt, 0, "#address-cells", 0x2)));
|
|
|
|
_FDT((fdt_setprop_cell(fdt, 0, "#size-cells", 0x2)));
|
|
|
|
_FDT((fdt_setprop_string(fdt, 0, "model",
|
|
|
|
"IBM PowerNV (emulated by qemu)")));
|
2019-05-27 10:17:49 +03:00
|
|
|
if (pnv_is_power9(pnv)) {
|
|
|
|
_FDT((fdt_setprop(fdt, 0, "compatible", plat_compat9,
|
|
|
|
sizeof(plat_compat9))));
|
|
|
|
} else {
|
|
|
|
_FDT((fdt_setprop(fdt, 0, "compatible", plat_compat8,
|
|
|
|
sizeof(plat_compat8))));
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
buf = qemu_uuid_unparse_strdup(&qemu_uuid);
|
|
|
|
_FDT((fdt_setprop_string(fdt, 0, "vm,uuid", buf)));
|
|
|
|
if (qemu_uuid_set) {
|
|
|
|
_FDT((fdt_property_string(fdt, "system-id", buf)));
|
|
|
|
}
|
|
|
|
g_free(buf);
|
|
|
|
|
|
|
|
off = fdt_add_subnode(fdt, 0, "chosen");
|
|
|
|
if (machine->kernel_cmdline) {
|
|
|
|
_FDT((fdt_setprop_string(fdt, off, "bootargs",
|
|
|
|
machine->kernel_cmdline)));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pnv->initrd_size) {
|
|
|
|
uint32_t start_prop = cpu_to_be32(pnv->initrd_base);
|
|
|
|
uint32_t end_prop = cpu_to_be32(pnv->initrd_base + pnv->initrd_size);
|
|
|
|
|
|
|
|
_FDT((fdt_setprop(fdt, off, "linux,initrd-start",
|
|
|
|
&start_prop, sizeof(start_prop))));
|
|
|
|
_FDT((fdt_setprop(fdt, off, "linux,initrd-end",
|
|
|
|
&end_prop, sizeof(end_prop))));
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:36 +03:00
|
|
|
/* Populate device tree for each chip */
|
|
|
|
for (i = 0; i < pnv->num_chips; i++) {
|
2019-03-06 11:50:12 +03:00
|
|
|
PNV_CHIP_GET_CLASS(pnv->chips[i])->dt_populate(pnv->chips[i], fdt);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
2017-04-11 18:30:01 +03:00
|
|
|
|
|
|
|
/* Populate ISA devices on chip 0 */
|
2018-06-18 20:05:40 +03:00
|
|
|
pnv_dt_isa(pnv, fdt);
|
2017-04-11 18:30:05 +03:00
|
|
|
|
|
|
|
if (pnv->bmc) {
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_dt_bmc_sensors(pnv->bmc, fdt);
|
2017-04-11 18:30:05 +03:00
|
|
|
}
|
|
|
|
|
2019-03-08 01:35:47 +03:00
|
|
|
/* Create an extra node for power management on Power9 */
|
|
|
|
if (pnv_is_power9(pnv)) {
|
|
|
|
pnv_dt_power_mgt(fdt);
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:35 +03:00
|
|
|
return fdt;
|
|
|
|
}
|
|
|
|
|
2017-04-11 18:30:06 +03:00
|
|
|
static void pnv_powerdown_notify(Notifier *n, void *opaque)
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(qdev_get_machine());
|
2017-04-11 18:30:06 +03:00
|
|
|
|
|
|
|
if (pnv->bmc) {
|
|
|
|
pnv_bmc_powerdown(pnv->bmc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_reset(void)
|
2016-10-22 12:46:35 +03:00
|
|
|
{
|
|
|
|
MachineState *machine = MACHINE(qdev_get_machine());
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(machine);
|
2016-10-22 12:46:35 +03:00
|
|
|
void *fdt;
|
2017-04-11 18:30:05 +03:00
|
|
|
Object *obj;
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
qemu_devices_reset();
|
|
|
|
|
2017-04-11 18:30:05 +03:00
|
|
|
/* OpenPOWER systems have a BMC, which can be defined on the
|
|
|
|
* command line with:
|
|
|
|
*
|
|
|
|
* -device ipmi-bmc-sim,id=bmc0
|
|
|
|
*
|
|
|
|
* This is the internal simulator but it could also be an external
|
|
|
|
* BMC.
|
|
|
|
*/
|
ppc/pnv: restrict BMC object to the BMC simulator
Today, when a PowerNV guest runs, it uses the sensor definitions of
the BMC simulator to populate the device tree. But an external IPMI
BMC could also be used and, in that case, it is not (yet) possible to
retrieve the sensor list. Generating the OEM SEL event for shutdown or
reboot also does not make sense as it should be generated on the BMC
side.
This change allows a guest to use an 'ipmi-bmc-extern' backend to the
'isa-ipmi-bt' device and a 'chardev' for transport such as :
-chardev socket,id=ipmi0,host=localhost,port=9002,reconnect=10 \
-device ipmi-bmc-extern,id=bmc0,chardev=ipmi0 \
-device isa-ipmi-bt,bmc=bmc0,irq=10
and connect to a BMC simulator, the OpenIPMI ipmi_sim simulator for
instance.
Signed-off-by: Cédric Le Goater <clg@kaod.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2017-04-28 11:26:31 +03:00
|
|
|
obj = object_resolve_path_type("", "ipmi-bmc-sim", NULL);
|
2017-04-11 18:30:05 +03:00
|
|
|
if (obj) {
|
|
|
|
pnv->bmc = IPMI_BMC(obj);
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
fdt = pnv_dt_create(machine);
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
/* Pack resulting tree */
|
|
|
|
_FDT((fdt_pack(fdt)));
|
|
|
|
|
|
|
|
cpu_physical_memory_write(PNV_FDT_ADDR, fdt, fdt_totalsize(fdt));
|
|
|
|
}
|
|
|
|
|
2018-06-15 18:25:34 +03:00
|
|
|
static ISABus *pnv_chip_power8_isa_create(PnvChip *chip, Error **errp)
|
2016-10-22 12:46:43 +03:00
|
|
|
{
|
2018-06-18 20:05:39 +03:00
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(chip);
|
|
|
|
return pnv_lpc_isa_create(&chip8->lpc, true, errp);
|
2018-06-15 18:25:34 +03:00
|
|
|
}
|
2016-10-22 12:46:43 +03:00
|
|
|
|
2018-06-15 18:25:34 +03:00
|
|
|
static ISABus *pnv_chip_power8nvl_isa_create(PnvChip *chip, Error **errp)
|
|
|
|
{
|
2018-06-18 20:05:39 +03:00
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(chip);
|
|
|
|
return pnv_lpc_isa_create(&chip8->lpc, false, errp);
|
2018-06-15 18:25:34 +03:00
|
|
|
}
|
2016-10-22 12:46:43 +03:00
|
|
|
|
2018-06-15 18:25:34 +03:00
|
|
|
static ISABus *pnv_chip_power9_isa_create(PnvChip *chip, Error **errp)
|
|
|
|
{
|
2019-03-08 01:35:39 +03:00
|
|
|
Pnv9Chip *chip9 = PNV9_CHIP(chip);
|
|
|
|
return pnv_lpc_isa_create(&chip9->lpc, false, errp);
|
2018-06-15 18:25:34 +03:00
|
|
|
}
|
2016-10-22 12:46:43 +03:00
|
|
|
|
2018-06-15 18:25:34 +03:00
|
|
|
static ISABus *pnv_isa_create(PnvChip *chip, Error **errp)
|
|
|
|
{
|
|
|
|
return PNV_CHIP_GET_CLASS(chip)->isa_create(chip, errp);
|
2016-10-22 12:46:43 +03:00
|
|
|
}
|
|
|
|
|
2019-03-06 11:50:13 +03:00
|
|
|
static void pnv_chip_power8_pic_print_info(PnvChip *chip, Monitor *mon)
|
|
|
|
{
|
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(chip);
|
|
|
|
|
|
|
|
ics_pic_print_info(&chip8->psi.ics, mon);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_power9_pic_print_info(PnvChip *chip, Monitor *mon)
|
|
|
|
{
|
|
|
|
Pnv9Chip *chip9 = PNV9_CHIP(chip);
|
|
|
|
|
|
|
|
pnv_xive_pic_print_info(&chip9->xive, mon);
|
2019-03-08 01:35:35 +03:00
|
|
|
pnv_psi_pic_print_info(&chip9->psi, mon);
|
2019-03-06 11:50:13 +03:00
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_init(MachineState *machine)
|
2016-10-22 12:46:35 +03:00
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(machine);
|
2016-10-22 12:46:35 +03:00
|
|
|
MemoryRegion *ram;
|
|
|
|
char *fw_filename;
|
|
|
|
long fw_size;
|
2016-10-22 12:46:36 +03:00
|
|
|
int i;
|
|
|
|
char *chip_typename;
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
/* allocate RAM */
|
2018-06-25 15:41:57 +03:00
|
|
|
if (machine->ram_size < (1 * GiB)) {
|
2017-07-12 16:57:41 +03:00
|
|
|
warn_report("skiboot may not work with < 1GB of RAM");
|
2016-10-22 12:46:35 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
ram = g_new(MemoryRegion, 1);
|
2017-12-15 16:56:01 +03:00
|
|
|
memory_region_allocate_system_memory(ram, NULL, "pnv.ram",
|
2016-10-22 12:46:35 +03:00
|
|
|
machine->ram_size);
|
|
|
|
memory_region_add_subregion(get_system_memory(), 0, ram);
|
|
|
|
|
|
|
|
/* load skiboot firmware */
|
|
|
|
if (bios_name == NULL) {
|
|
|
|
bios_name = FW_FILE_NAME;
|
|
|
|
}
|
|
|
|
|
|
|
|
fw_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
|
2017-09-25 11:58:25 +03:00
|
|
|
if (!fw_filename) {
|
|
|
|
error_report("Could not find OPAL firmware '%s'", bios_name);
|
|
|
|
exit(1);
|
|
|
|
}
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
fw_size = load_image_targphys(fw_filename, FW_LOAD_ADDR, FW_MAX_SIZE);
|
|
|
|
if (fw_size < 0) {
|
2017-09-25 11:58:25 +03:00
|
|
|
error_report("Could not load OPAL firmware '%s'", fw_filename);
|
2016-10-22 12:46:35 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
g_free(fw_filename);
|
|
|
|
|
|
|
|
/* load kernel */
|
|
|
|
if (machine->kernel_filename) {
|
|
|
|
long kernel_size;
|
|
|
|
|
|
|
|
kernel_size = load_image_targphys(machine->kernel_filename,
|
2019-02-25 20:01:53 +03:00
|
|
|
KERNEL_LOAD_ADDR, KERNEL_MAX_SIZE);
|
2016-10-22 12:46:35 +03:00
|
|
|
if (kernel_size < 0) {
|
2017-02-08 21:31:57 +03:00
|
|
|
error_report("Could not load kernel '%s'",
|
2017-02-01 14:03:10 +03:00
|
|
|
machine->kernel_filename);
|
2016-10-22 12:46:35 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* load initrd */
|
|
|
|
if (machine->initrd_filename) {
|
|
|
|
pnv->initrd_base = INITRD_LOAD_ADDR;
|
|
|
|
pnv->initrd_size = load_image_targphys(machine->initrd_filename,
|
2019-02-25 20:01:54 +03:00
|
|
|
pnv->initrd_base, INITRD_MAX_SIZE);
|
2016-10-22 12:46:35 +03:00
|
|
|
if (pnv->initrd_size < 0) {
|
2017-02-08 21:31:57 +03:00
|
|
|
error_report("Could not load initial ram disk '%s'",
|
2016-10-22 12:46:35 +03:00
|
|
|
machine->initrd_filename);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2016-10-22 12:46:36 +03:00
|
|
|
|
|
|
|
/* Create the processor chips */
|
2017-10-09 22:51:06 +03:00
|
|
|
i = strlen(machine->cpu_type) - strlen(POWERPC_CPU_TYPE_SUFFIX);
|
2017-10-09 22:51:07 +03:00
|
|
|
chip_typename = g_strdup_printf(PNV_CHIP_TYPE_NAME("%.*s"),
|
2017-10-09 22:51:06 +03:00
|
|
|
i, machine->cpu_type);
|
2016-10-22 12:46:36 +03:00
|
|
|
if (!object_class_by_name(chip_typename)) {
|
2017-10-09 22:51:06 +03:00
|
|
|
error_report("invalid CPU model '%.*s' for %s machine",
|
|
|
|
i, machine->cpu_type, MACHINE_GET_CLASS(machine)->name);
|
2016-10-22 12:46:36 +03:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
pnv->chips = g_new0(PnvChip *, pnv->num_chips);
|
|
|
|
for (i = 0; i < pnv->num_chips; i++) {
|
|
|
|
char chip_name[32];
|
|
|
|
Object *chip = object_new(chip_typename);
|
|
|
|
|
|
|
|
pnv->chips[i] = PNV_CHIP(chip);
|
|
|
|
|
|
|
|
/* TODO: put all the memory in one node on chip 0 until we find a
|
|
|
|
* way to specify different ranges for each chip
|
|
|
|
*/
|
|
|
|
if (i == 0) {
|
|
|
|
object_property_set_int(chip, machine->ram_size, "ram-size",
|
|
|
|
&error_fatal);
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(chip_name, sizeof(chip_name), "chip[%d]", PNV_CHIP_HWID(i));
|
|
|
|
object_property_add_child(OBJECT(pnv), chip_name, chip, &error_fatal);
|
|
|
|
object_property_set_int(chip, PNV_CHIP_HWID(i), "chip-id",
|
|
|
|
&error_fatal);
|
2016-10-22 12:46:37 +03:00
|
|
|
object_property_set_int(chip, smp_cores, "nr-cores", &error_fatal);
|
2016-10-22 12:46:36 +03:00
|
|
|
object_property_set_bool(chip, true, "realized", &error_fatal);
|
|
|
|
}
|
|
|
|
g_free(chip_typename);
|
2016-10-22 12:46:43 +03:00
|
|
|
|
|
|
|
/* Instantiate ISA bus on chip 0 */
|
2018-06-15 18:25:34 +03:00
|
|
|
pnv->isa_bus = pnv_isa_create(pnv->chips[0], &error_fatal);
|
2016-10-22 12:46:43 +03:00
|
|
|
|
|
|
|
/* Create serial port */
|
2018-04-20 17:52:46 +03:00
|
|
|
serial_hds_isa_init(pnv->isa_bus, 0, MAX_ISA_SERIAL_PORTS);
|
2016-10-22 12:46:43 +03:00
|
|
|
|
|
|
|
/* Create an RTC ISA device too */
|
2017-10-17 19:44:16 +03:00
|
|
|
mc146818_rtc_init(pnv->isa_bus, 2000, NULL);
|
2017-04-11 18:30:06 +03:00
|
|
|
|
|
|
|
/* OpenPOWER systems use a IPMI SEL Event message to notify the
|
|
|
|
* host to powerdown */
|
|
|
|
pnv->powerdown_notifier.notify = pnv_powerdown_notify;
|
|
|
|
qemu_register_powerdown_notifier(&pnv->powerdown_notifier);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:38 +03:00
|
|
|
/*
|
|
|
|
* 0:21 Reserved - Read as zeros
|
|
|
|
* 22:24 Chip ID
|
|
|
|
* 25:28 Core number
|
|
|
|
* 29:31 Thread ID
|
|
|
|
*/
|
|
|
|
static uint32_t pnv_chip_core_pir_p8(PnvChip *chip, uint32_t core_id)
|
|
|
|
{
|
|
|
|
return (chip->chip_id << 7) | (core_id << 3);
|
|
|
|
}
|
|
|
|
|
2019-01-02 08:57:34 +03:00
|
|
|
static void pnv_chip_power8_intc_create(PnvChip *chip, PowerPCCPU *cpu,
|
|
|
|
Error **errp)
|
2018-06-15 18:25:33 +03:00
|
|
|
{
|
2019-01-02 08:57:34 +03:00
|
|
|
Error *local_err = NULL;
|
|
|
|
Object *obj;
|
2019-01-17 10:53:25 +03:00
|
|
|
PnvCPUState *pnv_cpu = pnv_cpu_state(cpu);
|
2019-01-02 08:57:34 +03:00
|
|
|
|
|
|
|
obj = icp_create(OBJECT(cpu), TYPE_PNV_ICP, XICS_FABRIC(qdev_get_machine()),
|
|
|
|
&local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-06 11:50:10 +03:00
|
|
|
pnv_cpu->intc = obj;
|
2018-06-15 18:25:33 +03:00
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:38 +03:00
|
|
|
/*
|
|
|
|
* 0:48 Reserved - Read as zeroes
|
|
|
|
* 49:52 Node ID
|
|
|
|
* 53:55 Chip ID
|
|
|
|
* 56 Reserved - Read as zero
|
|
|
|
* 57:61 Core number
|
|
|
|
* 62:63 Thread ID
|
|
|
|
*
|
|
|
|
* We only care about the lower bits. uint32_t is fine for the moment.
|
|
|
|
*/
|
|
|
|
static uint32_t pnv_chip_core_pir_p9(PnvChip *chip, uint32_t core_id)
|
|
|
|
{
|
|
|
|
return (chip->chip_id << 8) | (core_id << 2);
|
|
|
|
}
|
|
|
|
|
2019-01-02 08:57:34 +03:00
|
|
|
static void pnv_chip_power9_intc_create(PnvChip *chip, PowerPCCPU *cpu,
|
|
|
|
Error **errp)
|
2018-06-15 18:25:33 +03:00
|
|
|
{
|
2019-03-06 11:50:11 +03:00
|
|
|
Pnv9Chip *chip9 = PNV9_CHIP(chip);
|
|
|
|
Error *local_err = NULL;
|
|
|
|
Object *obj;
|
|
|
|
PnvCPUState *pnv_cpu = pnv_cpu_state(cpu);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The core creates its interrupt presenter but the XIVE interrupt
|
|
|
|
* controller object is initialized afterwards. Hopefully, it's
|
|
|
|
* only used at runtime.
|
|
|
|
*/
|
2019-03-13 17:54:01 +03:00
|
|
|
obj = xive_tctx_create(OBJECT(cpu), XIVE_ROUTER(&chip9->xive), &local_err);
|
2019-03-06 11:50:11 +03:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pnv_cpu->intc = obj;
|
2018-06-15 18:25:33 +03:00
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:37 +03:00
|
|
|
/* Allowed core identifiers on a POWER8 Processor Chip :
|
|
|
|
*
|
|
|
|
* <EX0 reserved>
|
|
|
|
* EX1 - Venice only
|
|
|
|
* EX2 - Venice only
|
|
|
|
* EX3 - Venice only
|
|
|
|
* EX4
|
|
|
|
* EX5
|
|
|
|
* EX6
|
|
|
|
* <EX7,8 reserved> <reserved>
|
|
|
|
* EX9 - Venice only
|
|
|
|
* EX10 - Venice only
|
|
|
|
* EX11 - Venice only
|
|
|
|
* EX12
|
|
|
|
* EX13
|
|
|
|
* EX14
|
|
|
|
* <EX15 reserved>
|
|
|
|
*/
|
|
|
|
#define POWER8E_CORE_MASK (0x7070ull)
|
|
|
|
#define POWER8_CORE_MASK (0x7e7eull)
|
|
|
|
|
|
|
|
/*
|
2018-01-15 21:04:02 +03:00
|
|
|
* POWER9 has 24 cores, ids starting at 0x0
|
2016-10-22 12:46:37 +03:00
|
|
|
*/
|
2018-01-15 21:04:02 +03:00
|
|
|
#define POWER9_CORE_MASK (0xffffffffffffffull)
|
2016-10-22 12:46:37 +03:00
|
|
|
|
2018-06-18 20:05:39 +03:00
|
|
|
static void pnv_chip_power8_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(obj);
|
|
|
|
|
2019-02-21 14:24:48 +03:00
|
|
|
object_initialize_child(obj, "psi", &chip8->psi, sizeof(chip8->psi),
|
2019-03-08 01:35:34 +03:00
|
|
|
TYPE_PNV8_PSI, &error_abort, NULL);
|
2018-06-18 20:05:39 +03:00
|
|
|
object_property_add_const_link(OBJECT(&chip8->psi), "xics",
|
|
|
|
OBJECT(qdev_get_machine()), &error_abort);
|
|
|
|
|
2019-02-21 14:24:48 +03:00
|
|
|
object_initialize_child(obj, "lpc", &chip8->lpc, sizeof(chip8->lpc),
|
2019-03-08 01:35:37 +03:00
|
|
|
TYPE_PNV8_LPC, &error_abort, NULL);
|
2018-06-18 20:05:39 +03:00
|
|
|
object_property_add_const_link(OBJECT(&chip8->lpc), "psi",
|
|
|
|
OBJECT(&chip8->psi), &error_abort);
|
|
|
|
|
2019-02-21 14:24:48 +03:00
|
|
|
object_initialize_child(obj, "occ", &chip8->occ, sizeof(chip8->occ),
|
2019-03-08 01:35:41 +03:00
|
|
|
TYPE_PNV8_OCC, &error_abort, NULL);
|
2018-06-18 20:05:39 +03:00
|
|
|
object_property_add_const_link(OBJECT(&chip8->occ), "psi",
|
|
|
|
OBJECT(&chip8->psi), &error_abort);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_icp_realize(Pnv8Chip *chip8, Error **errp)
|
|
|
|
{
|
|
|
|
PnvChip *chip = PNV_CHIP(chip8);
|
|
|
|
PnvChipClass *pcc = PNV_CHIP_GET_CLASS(chip);
|
|
|
|
const char *typename = pnv_chip_core_typename(chip);
|
|
|
|
size_t typesize = object_type_get_instance_size(typename);
|
|
|
|
int i, j;
|
|
|
|
char *name;
|
|
|
|
XICSFabric *xi = XICS_FABRIC(qdev_get_machine());
|
|
|
|
|
|
|
|
name = g_strdup_printf("icp-%x", chip->chip_id);
|
|
|
|
memory_region_init(&chip8->icp_mmio, OBJECT(chip), name, PNV_ICP_SIZE);
|
|
|
|
sysbus_init_mmio(SYS_BUS_DEVICE(chip), &chip8->icp_mmio);
|
|
|
|
g_free(name);
|
|
|
|
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(chip), 1, PNV_ICP_BASE(chip));
|
|
|
|
|
|
|
|
/* Map the ICP registers for each thread */
|
|
|
|
for (i = 0; i < chip->nr_cores; i++) {
|
|
|
|
PnvCore *pnv_core = PNV_CORE(chip->cores + i * typesize);
|
|
|
|
int core_hwid = CPU_CORE(pnv_core)->core_id;
|
|
|
|
|
|
|
|
for (j = 0; j < CPU_CORE(pnv_core)->nr_threads; j++) {
|
|
|
|
uint32_t pir = pcc->core_pir(chip, core_hwid) + j;
|
|
|
|
PnvICPState *icp = PNV_ICP(xics_icp_get(xi, pir));
|
|
|
|
|
|
|
|
memory_region_add_subregion(&chip8->icp_mmio, pir << 12,
|
|
|
|
&icp->mmio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_power8_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
PnvChipClass *pcc = PNV_CHIP_GET_CLASS(dev);
|
|
|
|
PnvChip *chip = PNV_CHIP(dev);
|
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(dev);
|
2019-03-08 01:35:34 +03:00
|
|
|
Pnv8Psi *psi8 = &chip8->psi;
|
2018-06-18 20:05:39 +03:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
pcc->parent_realize(dev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Processor Service Interface (PSI) Host Bridge */
|
|
|
|
object_property_set_int(OBJECT(&chip8->psi), PNV_PSIHB_BASE(chip),
|
|
|
|
"bar", &error_fatal);
|
|
|
|
object_property_set_bool(OBJECT(&chip8->psi), true, "realized", &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2019-03-08 01:35:34 +03:00
|
|
|
pnv_xscom_add_subregion(chip, PNV_XSCOM_PSIHB_BASE,
|
|
|
|
&PNV_PSI(psi8)->xscom_regs);
|
2018-06-18 20:05:39 +03:00
|
|
|
|
|
|
|
/* Create LPC controller */
|
|
|
|
object_property_set_bool(OBJECT(&chip8->lpc), true, "realized",
|
|
|
|
&error_fatal);
|
|
|
|
pnv_xscom_add_subregion(chip, PNV_XSCOM_LPC_BASE, &chip8->lpc.xscom_regs);
|
|
|
|
|
2019-03-08 01:35:38 +03:00
|
|
|
chip->dt_isa_nodename = g_strdup_printf("/xscom@%" PRIx64 "/isa@%x",
|
|
|
|
(uint64_t) PNV_XSCOM_BASE(chip),
|
|
|
|
PNV_XSCOM_LPC_BASE);
|
|
|
|
|
2018-06-18 20:05:39 +03:00
|
|
|
/* Interrupt Management Area. This is the memory region holding
|
|
|
|
* all the Interrupt Control Presenter (ICP) registers */
|
|
|
|
pnv_chip_icp_realize(chip8, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create the simplified OCC model */
|
|
|
|
object_property_set_bool(OBJECT(&chip8->occ), true, "realized", &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pnv_xscom_add_subregion(chip, PNV_XSCOM_OCC_BASE, &chip8->occ.xscom_regs);
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:36 +03:00
|
|
|
static void pnv_chip_power8e_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
PnvChipClass *k = PNV_CHIP_CLASS(klass);
|
|
|
|
|
|
|
|
k->chip_type = PNV_CHIP_POWER8E;
|
|
|
|
k->chip_cfam_id = 0x221ef04980000000ull; /* P8 Murano DD2.1 */
|
2016-10-22 12:46:37 +03:00
|
|
|
k->cores_mask = POWER8E_CORE_MASK;
|
2016-10-22 12:46:38 +03:00
|
|
|
k->core_pir = pnv_chip_core_pir_p8;
|
2018-06-15 18:25:33 +03:00
|
|
|
k->intc_create = pnv_chip_power8_intc_create;
|
2018-06-15 18:25:34 +03:00
|
|
|
k->isa_create = pnv_chip_power8_isa_create;
|
2019-03-06 11:50:12 +03:00
|
|
|
k->dt_populate = pnv_chip_power8_dt_populate;
|
2019-03-06 11:50:13 +03:00
|
|
|
k->pic_print_info = pnv_chip_power8_pic_print_info;
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
k->xscom_base = 0x003fc0000000000ull;
|
2016-10-22 12:46:36 +03:00
|
|
|
dc->desc = "PowerNV Chip POWER8E";
|
2018-06-18 20:05:39 +03:00
|
|
|
|
|
|
|
device_class_set_parent_realize(dc, pnv_chip_power8_realize,
|
|
|
|
&k->parent_realize);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_power8_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
PnvChipClass *k = PNV_CHIP_CLASS(klass);
|
|
|
|
|
|
|
|
k->chip_type = PNV_CHIP_POWER8;
|
|
|
|
k->chip_cfam_id = 0x220ea04980000000ull; /* P8 Venice DD2.0 */
|
2016-10-22 12:46:37 +03:00
|
|
|
k->cores_mask = POWER8_CORE_MASK;
|
2016-10-22 12:46:38 +03:00
|
|
|
k->core_pir = pnv_chip_core_pir_p8;
|
2018-06-15 18:25:33 +03:00
|
|
|
k->intc_create = pnv_chip_power8_intc_create;
|
2018-06-15 18:25:34 +03:00
|
|
|
k->isa_create = pnv_chip_power8_isa_create;
|
2019-03-06 11:50:12 +03:00
|
|
|
k->dt_populate = pnv_chip_power8_dt_populate;
|
2019-03-06 11:50:13 +03:00
|
|
|
k->pic_print_info = pnv_chip_power8_pic_print_info;
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
k->xscom_base = 0x003fc0000000000ull;
|
2016-10-22 12:46:36 +03:00
|
|
|
dc->desc = "PowerNV Chip POWER8";
|
2018-06-18 20:05:39 +03:00
|
|
|
|
|
|
|
device_class_set_parent_realize(dc, pnv_chip_power8_realize,
|
|
|
|
&k->parent_realize);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_power8nvl_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
PnvChipClass *k = PNV_CHIP_CLASS(klass);
|
|
|
|
|
|
|
|
k->chip_type = PNV_CHIP_POWER8NVL;
|
|
|
|
k->chip_cfam_id = 0x120d304980000000ull; /* P8 Naples DD1.0 */
|
2016-10-22 12:46:37 +03:00
|
|
|
k->cores_mask = POWER8_CORE_MASK;
|
2016-10-22 12:46:38 +03:00
|
|
|
k->core_pir = pnv_chip_core_pir_p8;
|
2018-06-15 18:25:33 +03:00
|
|
|
k->intc_create = pnv_chip_power8_intc_create;
|
2018-06-15 18:25:34 +03:00
|
|
|
k->isa_create = pnv_chip_power8nvl_isa_create;
|
2019-03-06 11:50:12 +03:00
|
|
|
k->dt_populate = pnv_chip_power8_dt_populate;
|
2019-03-06 11:50:13 +03:00
|
|
|
k->pic_print_info = pnv_chip_power8_pic_print_info;
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
k->xscom_base = 0x003fc0000000000ull;
|
2016-10-22 12:46:36 +03:00
|
|
|
dc->desc = "PowerNV Chip POWER8NVL";
|
2018-06-18 20:05:39 +03:00
|
|
|
|
|
|
|
device_class_set_parent_realize(dc, pnv_chip_power8_realize,
|
|
|
|
&k->parent_realize);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_power9_instance_init(Object *obj)
|
|
|
|
{
|
2019-03-06 11:50:11 +03:00
|
|
|
Pnv9Chip *chip9 = PNV9_CHIP(obj);
|
|
|
|
|
|
|
|
object_initialize_child(obj, "xive", &chip9->xive, sizeof(chip9->xive),
|
|
|
|
TYPE_PNV_XIVE, &error_abort, NULL);
|
|
|
|
object_property_add_const_link(OBJECT(&chip9->xive), "chip", obj,
|
|
|
|
&error_abort);
|
2019-03-08 01:35:35 +03:00
|
|
|
|
|
|
|
object_initialize_child(obj, "psi", &chip9->psi, sizeof(chip9->psi),
|
|
|
|
TYPE_PNV9_PSI, &error_abort, NULL);
|
|
|
|
object_property_add_const_link(OBJECT(&chip9->psi), "chip", obj,
|
|
|
|
&error_abort);
|
2019-03-08 01:35:39 +03:00
|
|
|
|
|
|
|
object_initialize_child(obj, "lpc", &chip9->lpc, sizeof(chip9->lpc),
|
|
|
|
TYPE_PNV9_LPC, &error_abort, NULL);
|
|
|
|
object_property_add_const_link(OBJECT(&chip9->lpc), "psi",
|
|
|
|
OBJECT(&chip9->psi), &error_abort);
|
2019-03-08 01:35:42 +03:00
|
|
|
|
|
|
|
object_initialize_child(obj, "occ", &chip9->occ, sizeof(chip9->occ),
|
|
|
|
TYPE_PNV9_OCC, &error_abort, NULL);
|
|
|
|
object_property_add_const_link(OBJECT(&chip9->occ), "psi",
|
|
|
|
OBJECT(&chip9->psi), &error_abort);
|
2018-06-18 20:05:39 +03:00
|
|
|
}
|
|
|
|
|
2019-03-08 01:35:44 +03:00
|
|
|
static void pnv_chip_quad_realize(Pnv9Chip *chip9, Error **errp)
|
|
|
|
{
|
|
|
|
PnvChip *chip = PNV_CHIP(chip9);
|
|
|
|
const char *typename = pnv_chip_core_typename(chip);
|
|
|
|
size_t typesize = object_type_get_instance_size(typename);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
chip9->nr_quads = DIV_ROUND_UP(chip->nr_cores, 4);
|
|
|
|
chip9->quads = g_new0(PnvQuad, chip9->nr_quads);
|
|
|
|
|
|
|
|
for (i = 0; i < chip9->nr_quads; i++) {
|
|
|
|
char eq_name[32];
|
|
|
|
PnvQuad *eq = &chip9->quads[i];
|
|
|
|
PnvCore *pnv_core = PNV_CORE(chip->cores + (i * 4) * typesize);
|
|
|
|
int core_id = CPU_CORE(pnv_core)->core_id;
|
|
|
|
|
|
|
|
snprintf(eq_name, sizeof(eq_name), "eq[%d]", core_id);
|
hw/ppc/pnv: Use object_initialize_child for correct reference counting
As explained in commit aff39be0ed97:
Both functions, object_initialize() and object_property_add_child()
increase the reference counter of the new object, so one of the
references has to be dropped afterwards to get the reference
counting right. Otherwise the child object will not be properly
cleaned up when the parent gets destroyed.
Thus let's use now object_initialize_child() instead to get the
reference counting here right.
This patch was generated using the following Coccinelle script
(with a bit of manual fix-up for overly long lines):
@use_object_initialize_child@
expression parent_obj;
expression child_ptr;
expression child_name;
expression child_type;
expression child_size;
expression errp;
@@
(
- object_initialize(child_ptr, child_size, child_type);
+ object_initialize_child(parent_obj, child_name, child_ptr, child_size,
+ child_type, &error_abort, NULL);
... when != parent_obj
- object_property_add_child(parent_obj, child_name, OBJECT(child_ptr), NULL);
...
?- object_unref(OBJECT(child_ptr));
|
- object_initialize(child_ptr, child_size, child_type);
+ object_initialize_child(parent_obj, child_name, child_ptr, child_size,
+ child_type, errp, NULL);
... when != parent_obj
- object_property_add_child(parent_obj, child_name, OBJECT(child_ptr), errp);
...
?- object_unref(OBJECT(child_ptr));
)
While the object_initialize() function doesn't take an
'Error *errp' argument, the object_initialize_child() does.
Since this code is used when a machine is created (and is not
yet running), we deliberately choose to use the &error_abort
argument instead of ignoring errors if an object creation failed.
Suggested-by: Eduardo Habkost <ehabkost@redhat.com>
Inspired-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20190507163416.24647-2-philmd@redhat.com>
Acked-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2019-05-07 19:34:01 +03:00
|
|
|
object_initialize_child(OBJECT(chip), eq_name, eq, sizeof(*eq),
|
|
|
|
TYPE_PNV_QUAD, &error_fatal, NULL);
|
2019-03-08 01:35:44 +03:00
|
|
|
|
|
|
|
object_property_set_int(OBJECT(eq), core_id, "id", &error_fatal);
|
|
|
|
object_property_set_bool(OBJECT(eq), true, "realized", &error_fatal);
|
|
|
|
|
|
|
|
pnv_xscom_add_subregion(chip, PNV9_XSCOM_EQ_BASE(eq->id),
|
|
|
|
&eq->xscom_regs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-18 20:05:39 +03:00
|
|
|
static void pnv_chip_power9_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
PnvChipClass *pcc = PNV_CHIP_GET_CLASS(dev);
|
2019-03-06 11:50:11 +03:00
|
|
|
Pnv9Chip *chip9 = PNV9_CHIP(dev);
|
|
|
|
PnvChip *chip = PNV_CHIP(dev);
|
2019-03-08 01:35:35 +03:00
|
|
|
Pnv9Psi *psi9 = &chip9->psi;
|
2018-06-18 20:05:39 +03:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
pcc->parent_realize(dev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2019-03-06 11:50:11 +03:00
|
|
|
|
2019-03-08 01:35:44 +03:00
|
|
|
pnv_chip_quad_realize(chip9, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-06 11:50:11 +03:00
|
|
|
/* XIVE interrupt controller (POWER9) */
|
|
|
|
object_property_set_int(OBJECT(&chip9->xive), PNV9_XIVE_IC_BASE(chip),
|
|
|
|
"ic-bar", &error_fatal);
|
|
|
|
object_property_set_int(OBJECT(&chip9->xive), PNV9_XIVE_VC_BASE(chip),
|
|
|
|
"vc-bar", &error_fatal);
|
|
|
|
object_property_set_int(OBJECT(&chip9->xive), PNV9_XIVE_PC_BASE(chip),
|
|
|
|
"pc-bar", &error_fatal);
|
|
|
|
object_property_set_int(OBJECT(&chip9->xive), PNV9_XIVE_TM_BASE(chip),
|
|
|
|
"tm-bar", &error_fatal);
|
|
|
|
object_property_set_bool(OBJECT(&chip9->xive), true, "realized",
|
|
|
|
&local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pnv_xscom_add_subregion(chip, PNV9_XSCOM_XIVE_BASE,
|
|
|
|
&chip9->xive.xscom_regs);
|
2019-03-08 01:35:35 +03:00
|
|
|
|
|
|
|
/* Processor Service Interface (PSI) Host Bridge */
|
|
|
|
object_property_set_int(OBJECT(&chip9->psi), PNV9_PSIHB_BASE(chip),
|
|
|
|
"bar", &error_fatal);
|
|
|
|
object_property_set_bool(OBJECT(&chip9->psi), true, "realized", &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pnv_xscom_add_subregion(chip, PNV9_XSCOM_PSIHB_BASE,
|
|
|
|
&PNV_PSI(psi9)->xscom_regs);
|
2019-03-08 01:35:39 +03:00
|
|
|
|
|
|
|
/* LPC */
|
|
|
|
object_property_set_bool(OBJECT(&chip9->lpc), true, "realized", &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memory_region_add_subregion(get_system_memory(), PNV9_LPCM_BASE(chip),
|
|
|
|
&chip9->lpc.xscom_regs);
|
|
|
|
|
|
|
|
chip->dt_isa_nodename = g_strdup_printf("/lpcm-opb@%" PRIx64 "/lpc@0",
|
|
|
|
(uint64_t) PNV9_LPCM_BASE(chip));
|
2019-03-08 01:35:42 +03:00
|
|
|
|
|
|
|
/* Create the simplified OCC model */
|
|
|
|
object_property_set_bool(OBJECT(&chip9->occ), true, "realized", &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pnv_xscom_add_subregion(chip, PNV9_XSCOM_OCC_BASE, &chip9->occ.xscom_regs);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_power9_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
PnvChipClass *k = PNV_CHIP_CLASS(klass);
|
|
|
|
|
|
|
|
k->chip_type = PNV_CHIP_POWER9;
|
2018-01-15 21:04:01 +03:00
|
|
|
k->chip_cfam_id = 0x220d104900008000ull; /* P9 Nimbus DD2.0 */
|
2016-10-22 12:46:37 +03:00
|
|
|
k->cores_mask = POWER9_CORE_MASK;
|
2016-10-22 12:46:38 +03:00
|
|
|
k->core_pir = pnv_chip_core_pir_p9;
|
2018-06-15 18:25:33 +03:00
|
|
|
k->intc_create = pnv_chip_power9_intc_create;
|
2018-06-15 18:25:34 +03:00
|
|
|
k->isa_create = pnv_chip_power9_isa_create;
|
2019-03-06 11:50:12 +03:00
|
|
|
k->dt_populate = pnv_chip_power9_dt_populate;
|
2019-03-06 11:50:13 +03:00
|
|
|
k->pic_print_info = pnv_chip_power9_pic_print_info;
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
k->xscom_base = 0x00603fc00000000ull;
|
2016-10-22 12:46:36 +03:00
|
|
|
dc->desc = "PowerNV Chip POWER9";
|
2018-06-18 20:05:39 +03:00
|
|
|
|
|
|
|
device_class_set_parent_realize(dc, pnv_chip_power9_realize,
|
|
|
|
&k->parent_realize);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:37 +03:00
|
|
|
static void pnv_chip_core_sanitize(PnvChip *chip, Error **errp)
|
|
|
|
{
|
|
|
|
PnvChipClass *pcc = PNV_CHIP_GET_CLASS(chip);
|
|
|
|
int cores_max;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No custom mask for this chip, let's use the default one from *
|
|
|
|
* the chip class
|
|
|
|
*/
|
|
|
|
if (!chip->cores_mask) {
|
|
|
|
chip->cores_mask = pcc->cores_mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* filter alien core ids ! some are reserved */
|
|
|
|
if ((chip->cores_mask & pcc->cores_mask) != chip->cores_mask) {
|
|
|
|
error_setg(errp, "warning: invalid core mask for chip Ox%"PRIx64" !",
|
|
|
|
chip->cores_mask);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
chip->cores_mask &= pcc->cores_mask;
|
|
|
|
|
|
|
|
/* now that we have a sane layout, let check the number of cores */
|
2016-11-14 12:12:57 +03:00
|
|
|
cores_max = ctpop64(chip->cores_mask);
|
2016-10-22 12:46:37 +03:00
|
|
|
if (chip->nr_cores > cores_max) {
|
|
|
|
error_setg(errp, "warning: too many cores for chip ! Limit is %d",
|
|
|
|
cores_max);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-18 20:05:39 +03:00
|
|
|
static void pnv_chip_instance_init(Object *obj)
|
ppc/pnv: add XSCOM infrastructure
On a real POWER8 system, the Pervasive Interconnect Bus (PIB) serves
as a backbone to connect different units of the system. The host
firmware connects to the PIB through a bridge unit, the
Alter-Display-Unit (ADU), which gives him access to all the chiplets
on the PCB network (Pervasive Connect Bus), the PIB acting as the root
of this network.
XSCOM (serial communication) is the interface to the sideband bus
provided by the POWER8 pervasive unit to read and write to chiplets
resources. This is needed by the host firmware, OPAL and to a lesser
extent, Linux. This is among others how the PCI Host bridges get
configured at boot or how the LPC bus is accessed.
To represent the ADU of a real system, we introduce a specific
AddressSpace to dispatch XSCOM accesses to the targeted chiplets. The
translation of an XSCOM address into a PCB register address is
slightly different between the P9 and the P8. This is handled before
the dispatch using a 8byte alignment for all.
To customize the device tree, a QOM InterfaceClass, PnvXScomInterface,
is provided with a populate() handler. The chip populates the device
tree by simply looping on its children. Therefore, each model needing
custom nodes should not forget to declare itself as a child at
instantiation time.
Based on previous work done by :
Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Cédric Le Goater <clg@kaod.org>
[dwg: Added cpu parameter to xscom_complete()]
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-10-22 12:46:40 +03:00
|
|
|
{
|
2018-06-18 20:05:39 +03:00
|
|
|
PNV_CHIP(obj)->xscom_base = PNV_CHIP_GET_CLASS(obj)->xscom_base;
|
2017-04-03 10:46:05 +03:00
|
|
|
}
|
|
|
|
|
2018-06-14 17:00:41 +03:00
|
|
|
static void pnv_chip_core_realize(PnvChip *chip, Error **errp)
|
2016-10-22 12:46:36 +03:00
|
|
|
{
|
2016-10-22 12:46:37 +03:00
|
|
|
Error *error = NULL;
|
2016-10-22 12:46:39 +03:00
|
|
|
PnvChipClass *pcc = PNV_CHIP_GET_CLASS(chip);
|
2017-10-09 22:51:10 +03:00
|
|
|
const char *typename = pnv_chip_core_typename(chip);
|
2016-10-22 12:46:39 +03:00
|
|
|
size_t typesize = object_type_get_instance_size(typename);
|
|
|
|
int i, core_hwid;
|
|
|
|
|
|
|
|
if (!object_class_by_name(typename)) {
|
|
|
|
error_setg(errp, "Unable to find PowerNV CPU Core '%s'", typename);
|
|
|
|
return;
|
|
|
|
}
|
2016-10-22 12:46:37 +03:00
|
|
|
|
2016-10-22 12:46:39 +03:00
|
|
|
/* Cores */
|
2016-10-22 12:46:37 +03:00
|
|
|
pnv_chip_core_sanitize(chip, &error);
|
|
|
|
if (error) {
|
|
|
|
error_propagate(errp, error);
|
|
|
|
return;
|
|
|
|
}
|
2016-10-22 12:46:39 +03:00
|
|
|
|
|
|
|
chip->cores = g_malloc0(typesize * chip->nr_cores);
|
|
|
|
|
|
|
|
for (i = 0, core_hwid = 0; (core_hwid < sizeof(chip->cores_mask) * 8)
|
|
|
|
&& (i < chip->nr_cores); core_hwid++) {
|
|
|
|
char core_name[32];
|
|
|
|
void *pnv_core = chip->cores + i * typesize;
|
2018-01-15 21:04:04 +03:00
|
|
|
uint64_t xscom_core_base;
|
2016-10-22 12:46:39 +03:00
|
|
|
|
|
|
|
if (!(chip->cores_mask & (1ull << core_hwid))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(core_name, sizeof(core_name), "core[%d]", core_hwid);
|
hw/ppc/pnv: Use object_initialize_child for correct reference counting
As explained in commit aff39be0ed97:
Both functions, object_initialize() and object_property_add_child()
increase the reference counter of the new object, so one of the
references has to be dropped afterwards to get the reference
counting right. Otherwise the child object will not be properly
cleaned up when the parent gets destroyed.
Thus let's use now object_initialize_child() instead to get the
reference counting here right.
This patch was generated using the following Coccinelle script
(with a bit of manual fix-up for overly long lines):
@use_object_initialize_child@
expression parent_obj;
expression child_ptr;
expression child_name;
expression child_type;
expression child_size;
expression errp;
@@
(
- object_initialize(child_ptr, child_size, child_type);
+ object_initialize_child(parent_obj, child_name, child_ptr, child_size,
+ child_type, &error_abort, NULL);
... when != parent_obj
- object_property_add_child(parent_obj, child_name, OBJECT(child_ptr), NULL);
...
?- object_unref(OBJECT(child_ptr));
|
- object_initialize(child_ptr, child_size, child_type);
+ object_initialize_child(parent_obj, child_name, child_ptr, child_size,
+ child_type, errp, NULL);
... when != parent_obj
- object_property_add_child(parent_obj, child_name, OBJECT(child_ptr), errp);
...
?- object_unref(OBJECT(child_ptr));
)
While the object_initialize() function doesn't take an
'Error *errp' argument, the object_initialize_child() does.
Since this code is used when a machine is created (and is not
yet running), we deliberately choose to use the &error_abort
argument instead of ignoring errors if an object creation failed.
Suggested-by: Eduardo Habkost <ehabkost@redhat.com>
Inspired-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20190507163416.24647-2-philmd@redhat.com>
Acked-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2019-05-07 19:34:01 +03:00
|
|
|
object_initialize_child(OBJECT(chip), core_name, pnv_core, typesize,
|
|
|
|
typename, &error_fatal, NULL);
|
2016-10-22 12:46:39 +03:00
|
|
|
object_property_set_int(OBJECT(pnv_core), smp_threads, "nr-threads",
|
|
|
|
&error_fatal);
|
|
|
|
object_property_set_int(OBJECT(pnv_core), core_hwid,
|
|
|
|
CPU_CORE_PROP_CORE_ID, &error_fatal);
|
|
|
|
object_property_set_int(OBJECT(pnv_core),
|
|
|
|
pcc->core_pir(chip, core_hwid),
|
|
|
|
"pir", &error_fatal);
|
2018-06-15 18:25:33 +03:00
|
|
|
object_property_add_const_link(OBJECT(pnv_core), "chip",
|
|
|
|
OBJECT(chip), &error_fatal);
|
2016-10-22 12:46:39 +03:00
|
|
|
object_property_set_bool(OBJECT(pnv_core), true, "realized",
|
|
|
|
&error_fatal);
|
2016-10-22 12:46:41 +03:00
|
|
|
|
|
|
|
/* Each core has an XSCOM MMIO region */
|
2018-01-15 21:04:04 +03:00
|
|
|
if (!pnv_chip_is_power9(chip)) {
|
|
|
|
xscom_core_base = PNV_XSCOM_EX_BASE(core_hwid);
|
|
|
|
} else {
|
2019-03-08 01:35:44 +03:00
|
|
|
xscom_core_base = PNV9_XSCOM_EC_BASE(core_hwid);
|
2018-01-15 21:04:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
pnv_xscom_add_subregion(chip, xscom_core_base,
|
2016-10-22 12:46:41 +03:00
|
|
|
&PNV_CORE(pnv_core)->xscom_regs);
|
2016-10-22 12:46:39 +03:00
|
|
|
i++;
|
|
|
|
}
|
2018-06-14 17:00:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_chip_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
PnvChip *chip = PNV_CHIP(dev);
|
|
|
|
Error *error = NULL;
|
|
|
|
|
|
|
|
/* XSCOM bridge */
|
|
|
|
pnv_xscom_realize(chip, &error);
|
|
|
|
if (error) {
|
|
|
|
error_propagate(errp, error);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sysbus_mmio_map(SYS_BUS_DEVICE(chip), 0, PNV_XSCOM_BASE(chip));
|
|
|
|
|
|
|
|
/* Cores */
|
|
|
|
pnv_chip_core_realize(chip, &error);
|
|
|
|
if (error) {
|
|
|
|
error_propagate(errp, error);
|
|
|
|
return;
|
|
|
|
}
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static Property pnv_chip_properties[] = {
|
|
|
|
DEFINE_PROP_UINT32("chip-id", PnvChip, chip_id, 0),
|
|
|
|
DEFINE_PROP_UINT64("ram-start", PnvChip, ram_start, 0),
|
|
|
|
DEFINE_PROP_UINT64("ram-size", PnvChip, ram_size, 0),
|
2016-10-22 12:46:37 +03:00
|
|
|
DEFINE_PROP_UINT32("nr-cores", PnvChip, nr_cores, 1),
|
|
|
|
DEFINE_PROP_UINT64("cores-mask", PnvChip, cores_mask, 0x0),
|
2016-10-22 12:46:36 +03:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void pnv_chip_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
|
2017-03-09 21:37:53 +03:00
|
|
|
set_bit(DEVICE_CATEGORY_CPU, dc->categories);
|
2016-10-22 12:46:36 +03:00
|
|
|
dc->realize = pnv_chip_realize;
|
|
|
|
dc->props = pnv_chip_properties;
|
|
|
|
dc->desc = "PowerNV Chip";
|
|
|
|
}
|
|
|
|
|
2017-04-05 15:41:26 +03:00
|
|
|
static ICSState *pnv_ics_get(XICSFabric *xi, int irq)
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(xi);
|
2017-04-05 15:41:26 +03:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < pnv->num_chips; i++) {
|
2018-06-18 20:05:39 +03:00
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(pnv->chips[i]);
|
|
|
|
|
|
|
|
if (ics_valid_irq(&chip8->psi.ics, irq)) {
|
|
|
|
return &chip8->psi.ics;
|
2017-04-05 15:41:26 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_ics_resend(XICSFabric *xi)
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(xi);
|
2017-04-05 15:41:26 +03:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < pnv->num_chips; i++) {
|
2018-06-18 20:05:39 +03:00
|
|
|
Pnv8Chip *chip8 = PNV8_CHIP(pnv->chips[i]);
|
|
|
|
ics_resend(&chip8->psi.ics);
|
2017-04-05 15:41:26 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-03 10:46:01 +03:00
|
|
|
static ICPState *pnv_icp_get(XICSFabric *xi, int pir)
|
|
|
|
{
|
|
|
|
PowerPCCPU *cpu = ppc_get_vcpu_by_pir(pir);
|
|
|
|
|
2019-03-06 11:50:10 +03:00
|
|
|
return cpu ? ICP(pnv_cpu_state(cpu)->intc) : NULL;
|
2017-04-03 10:46:01 +03:00
|
|
|
}
|
|
|
|
|
2017-04-03 10:46:02 +03:00
|
|
|
static void pnv_pic_print_info(InterruptStatsProvider *obj,
|
|
|
|
Monitor *mon)
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(obj);
|
2017-04-05 15:41:26 +03:00
|
|
|
int i;
|
2017-04-03 10:46:02 +03:00
|
|
|
CPUState *cs;
|
|
|
|
|
|
|
|
CPU_FOREACH(cs) {
|
|
|
|
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
|
|
|
|
2019-03-06 11:50:13 +03:00
|
|
|
if (pnv_chip_is_power9(pnv->chips[0])) {
|
|
|
|
xive_tctx_pic_print_info(XIVE_TCTX(pnv_cpu_state(cpu)->intc), mon);
|
|
|
|
} else {
|
|
|
|
icp_pic_print_info(ICP(pnv_cpu_state(cpu)->intc), mon);
|
|
|
|
}
|
2017-04-03 10:46:02 +03:00
|
|
|
}
|
2017-04-05 15:41:26 +03:00
|
|
|
|
|
|
|
for (i = 0; i < pnv->num_chips; i++) {
|
2019-03-06 11:50:13 +03:00
|
|
|
PNV_CHIP_GET_CLASS(pnv->chips[i])->pic_print_info(pnv->chips[i], mon);
|
2017-04-05 15:41:26 +03:00
|
|
|
}
|
2017-04-03 10:46:02 +03:00
|
|
|
}
|
|
|
|
|
2016-10-22 12:46:36 +03:00
|
|
|
static void pnv_get_num_chips(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
visit_type_uint32(v, name, &PNV_MACHINE(obj)->num_chips, errp);
|
2016-10-22 12:46:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pnv_set_num_chips(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(obj);
|
2016-10-22 12:46:36 +03:00
|
|
|
uint32_t num_chips;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
visit_type_uint32(v, name, &num_chips, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: should we decide on how many chips we can create based
|
|
|
|
* on #cores and Venice vs. Murano vs. Naples chip type etc...,
|
|
|
|
*/
|
|
|
|
if (!is_power_of_2(num_chips) || num_chips > 4) {
|
|
|
|
error_setg(errp, "invalid number of chips: '%d'", num_chips);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pnv->num_chips = num_chips;
|
|
|
|
}
|
|
|
|
|
2018-06-18 20:05:39 +03:00
|
|
|
static void pnv_machine_instance_init(Object *obj)
|
2016-10-22 12:46:36 +03:00
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
PnvMachineState *pnv = PNV_MACHINE(obj);
|
2016-10-22 12:46:36 +03:00
|
|
|
pnv->num_chips = 1;
|
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_machine_class_props_init(ObjectClass *oc)
|
2016-10-22 12:46:36 +03:00
|
|
|
{
|
2017-06-07 19:36:06 +03:00
|
|
|
object_class_property_add(oc, "num-chips", "uint32",
|
2016-10-22 12:46:36 +03:00
|
|
|
pnv_get_num_chips, pnv_set_num_chips,
|
|
|
|
NULL, NULL, NULL);
|
|
|
|
object_class_property_set_description(oc, "num-chips",
|
|
|
|
"Specifies the number of processor chips",
|
|
|
|
NULL);
|
2016-10-22 12:46:35 +03:00
|
|
|
}
|
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
static void pnv_machine_class_init(ObjectClass *oc, void *data)
|
2016-10-22 12:46:35 +03:00
|
|
|
{
|
|
|
|
MachineClass *mc = MACHINE_CLASS(oc);
|
2017-04-03 10:46:01 +03:00
|
|
|
XICSFabricClass *xic = XICS_FABRIC_CLASS(oc);
|
2017-04-03 10:46:02 +03:00
|
|
|
InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc);
|
2016-10-22 12:46:35 +03:00
|
|
|
|
|
|
|
mc->desc = "IBM PowerNV (Non-Virtualized)";
|
2017-12-15 16:56:01 +03:00
|
|
|
mc->init = pnv_init;
|
|
|
|
mc->reset = pnv_reset;
|
2016-10-22 12:46:35 +03:00
|
|
|
mc->max_cpus = MAX_CPUS;
|
2017-10-09 22:51:06 +03:00
|
|
|
mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power8_v2.0");
|
2016-10-22 12:46:35 +03:00
|
|
|
mc->block_default_type = IF_IDE; /* Pnv provides a AHCI device for
|
|
|
|
* storage */
|
|
|
|
mc->no_parallel = 1;
|
|
|
|
mc->default_boot_order = NULL;
|
2018-06-25 15:41:57 +03:00
|
|
|
mc->default_ram_size = 1 * GiB;
|
2017-04-03 10:46:01 +03:00
|
|
|
xic->icp_get = pnv_icp_get;
|
2017-04-05 15:41:26 +03:00
|
|
|
xic->ics_get = pnv_ics_get;
|
|
|
|
xic->ics_resend = pnv_ics_resend;
|
2017-04-03 10:46:02 +03:00
|
|
|
ispc->print_info = pnv_pic_print_info;
|
2016-10-22 12:46:36 +03:00
|
|
|
|
2017-12-15 16:56:01 +03:00
|
|
|
pnv_machine_class_props_init(oc);
|
2016-10-22 12:46:35 +03:00
|
|
|
}
|
|
|
|
|
2018-06-18 20:05:39 +03:00
|
|
|
#define DEFINE_PNV8_CHIP_TYPE(type, class_initfn) \
|
|
|
|
{ \
|
|
|
|
.name = type, \
|
|
|
|
.class_init = class_initfn, \
|
|
|
|
.parent = TYPE_PNV8_CHIP, \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DEFINE_PNV9_CHIP_TYPE(type, class_initfn) \
|
|
|
|
{ \
|
|
|
|
.name = type, \
|
|
|
|
.class_init = class_initfn, \
|
|
|
|
.parent = TYPE_PNV9_CHIP, \
|
2017-10-09 22:51:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo types[] = {
|
|
|
|
{
|
2017-12-15 16:56:01 +03:00
|
|
|
.name = TYPE_PNV_MACHINE,
|
2017-10-09 22:51:11 +03:00
|
|
|
.parent = TYPE_MACHINE,
|
|
|
|
.instance_size = sizeof(PnvMachineState),
|
2018-06-18 20:05:39 +03:00
|
|
|
.instance_init = pnv_machine_instance_init,
|
2017-12-15 16:56:01 +03:00
|
|
|
.class_init = pnv_machine_class_init,
|
2017-10-09 22:51:11 +03:00
|
|
|
.interfaces = (InterfaceInfo[]) {
|
|
|
|
{ TYPE_XICS_FABRIC },
|
|
|
|
{ TYPE_INTERRUPT_STATS_PROVIDER },
|
|
|
|
{ },
|
|
|
|
},
|
2017-04-03 10:46:01 +03:00
|
|
|
},
|
2017-10-09 22:51:11 +03:00
|
|
|
{
|
|
|
|
.name = TYPE_PNV_CHIP,
|
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
|
|
.class_init = pnv_chip_class_init,
|
2018-06-18 20:05:39 +03:00
|
|
|
.instance_init = pnv_chip_instance_init,
|
2017-10-09 22:51:11 +03:00
|
|
|
.instance_size = sizeof(PnvChip),
|
|
|
|
.class_size = sizeof(PnvChipClass),
|
|
|
|
.abstract = true,
|
|
|
|
},
|
2018-06-18 20:05:39 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* P9 chip and variants
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.name = TYPE_PNV9_CHIP,
|
|
|
|
.parent = TYPE_PNV_CHIP,
|
|
|
|
.instance_init = pnv_chip_power9_instance_init,
|
|
|
|
.instance_size = sizeof(Pnv9Chip),
|
|
|
|
},
|
|
|
|
DEFINE_PNV9_CHIP_TYPE(TYPE_PNV_CHIP_POWER9, pnv_chip_power9_class_init),
|
|
|
|
|
|
|
|
/*
|
|
|
|
* P8 chip and variants
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.name = TYPE_PNV8_CHIP,
|
|
|
|
.parent = TYPE_PNV_CHIP,
|
|
|
|
.instance_init = pnv_chip_power8_instance_init,
|
|
|
|
.instance_size = sizeof(Pnv8Chip),
|
|
|
|
},
|
|
|
|
DEFINE_PNV8_CHIP_TYPE(TYPE_PNV_CHIP_POWER8, pnv_chip_power8_class_init),
|
|
|
|
DEFINE_PNV8_CHIP_TYPE(TYPE_PNV_CHIP_POWER8E, pnv_chip_power8e_class_init),
|
|
|
|
DEFINE_PNV8_CHIP_TYPE(TYPE_PNV_CHIP_POWER8NVL,
|
|
|
|
pnv_chip_power8nvl_class_init),
|
2016-10-22 12:46:35 +03:00
|
|
|
};
|
|
|
|
|
2017-10-09 22:51:11 +03:00
|
|
|
DEFINE_TYPES(types)
|