2 * sPAPR CPU core device, acts as container of CPU thread devices.
4 * Copyright (C) 2016 Bharata B Rao <bharata@linux.vnet.ibm.com>
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
9 #include "hw/cpu/core.h"
10 #include "hw/ppc/spapr_cpu_core.h"
11 #include "target-ppc/cpu.h"
12 #include "hw/ppc/spapr.h"
13 #include "hw/boards.h"
14 #include "qapi/error.h"
15 #include <sysemu/cpus.h>
16 #include "target-ppc/kvm_ppc.h"
17 #include "hw/ppc/ppc.h"
18 #include "target-ppc/mmu-hash64.h"
19 #include <sysemu/numa.h>
21 static void spapr_cpu_reset(void *opaque
)
23 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
24 PowerPCCPU
*cpu
= opaque
;
25 CPUState
*cs
= CPU(cpu
);
26 CPUPPCState
*env
= &cpu
->env
;
30 /* All CPUs start halted. CPU0 is unhalted from the machine level
31 * reset code and the rest are explicitly started up by the guest
32 * using an RTAS call */
35 env
->spr
[SPR_HIOR
] = 0;
37 ppc_hash64_set_external_hpt(cpu
, spapr
->htab
, spapr
->htab_shift
,
41 static void spapr_cpu_destroy(PowerPCCPU
*cpu
)
43 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
45 xics_cpu_destroy(spapr
->xics
, cpu
);
46 qemu_unregister_reset(spapr_cpu_reset
, cpu
);
49 void spapr_cpu_init(sPAPRMachineState
*spapr
, PowerPCCPU
*cpu
, Error
**errp
)
51 CPUPPCState
*env
= &cpu
->env
;
52 CPUState
*cs
= CPU(cpu
);
55 /* Set time-base frequency to 512 MHz */
56 cpu_ppc_tb_init(env
, SPAPR_TIMEBASE_FREQ
);
58 /* Enable PAPR mode in TCG or KVM */
59 cpu_ppc_set_papr(cpu
);
61 if (cpu
->max_compat
) {
62 Error
*local_err
= NULL
;
64 ppc_set_compat(cpu
, cpu
->max_compat
, &local_err
);
66 error_propagate(errp
, local_err
);
71 /* Set NUMA node for the added CPUs */
72 for (i
= 0; i
< nb_numa_nodes
; i
++) {
73 if (test_bit(cs
->cpu_index
, numa_info
[i
].node_cpu
)) {
79 xics_cpu_setup(spapr
->xics
, cpu
);
81 qemu_register_reset(spapr_cpu_reset
, cpu
);
86 * Return the sPAPR CPU core type for @model which essentially is the CPU
87 * model specified with -cpu cmdline option.
89 char *spapr_get_cpu_core_type(const char *model
)
92 gchar
**model_pieces
= g_strsplit(model
, ",", 2);
94 core_type
= g_strdup_printf("%s-%s", model_pieces
[0], TYPE_SPAPR_CPU_CORE
);
95 g_strfreev(model_pieces
);
99 static void spapr_core_release(DeviceState
*dev
, void *opaque
)
101 sPAPRCPUCore
*sc
= SPAPR_CPU_CORE(OBJECT(dev
));
102 const char *typename
= object_class_get_name(sc
->cpu_class
);
103 size_t size
= object_type_get_instance_size(typename
);
104 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
105 CPUCore
*cc
= CPU_CORE(dev
);
106 int smt
= kvmppc_smt_threads();
109 for (i
= 0; i
< cc
->nr_threads
; i
++) {
110 void *obj
= sc
->threads
+ i
* size
;
111 DeviceState
*dev
= DEVICE(obj
);
112 CPUState
*cs
= CPU(dev
);
113 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
115 spapr_cpu_destroy(cpu
);
117 object_unparent(obj
);
120 spapr
->cores
[cc
->core_id
/ smt
] = NULL
;
123 object_unparent(OBJECT(dev
));
126 void spapr_core_unplug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
129 sPAPRCPUCore
*core
= SPAPR_CPU_CORE(OBJECT(dev
));
130 PowerPCCPU
*cpu
= POWERPC_CPU(core
->threads
);
131 int id
= ppc_get_vcpu_dt_id(cpu
);
132 sPAPRDRConnector
*drc
=
133 spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU
, id
);
134 sPAPRDRConnectorClass
*drck
;
135 Error
*local_err
= NULL
;
139 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
140 drck
->detach(drc
, dev
, spapr_core_release
, NULL
, &local_err
);
142 error_propagate(errp
, local_err
);
146 spapr_hotplug_req_remove_by_index(drc
);
149 void spapr_core_plug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
152 sPAPRMachineClass
*smc
= SPAPR_MACHINE_GET_CLASS(OBJECT(hotplug_dev
));
153 sPAPRMachineState
*spapr
= SPAPR_MACHINE(OBJECT(hotplug_dev
));
154 sPAPRCPUCore
*core
= SPAPR_CPU_CORE(OBJECT(dev
));
155 CPUCore
*cc
= CPU_CORE(dev
);
156 CPUState
*cs
= CPU(core
->threads
);
157 sPAPRDRConnector
*drc
;
158 sPAPRDRConnectorClass
*drck
;
159 Error
*local_err
= NULL
;
163 int smt
= kvmppc_smt_threads();
165 drc
= spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU
, cc
->core_id
);
166 index
= cc
->core_id
/ smt
;
167 spapr
->cores
[index
] = OBJECT(dev
);
169 if (!smc
->dr_cpu_enabled
) {
171 * This is a cold plugged CPU core but the machine doesn't support
172 * DR. So skip the hotplug path ensuring that the core is brought
173 * up online with out an associated DR connector.
181 * Setup CPU DT entries only for hotplugged CPUs. For boot time or
182 * coldplugged CPUs DT entries are setup in spapr_finalize_fdt().
184 if (dev
->hotplugged
) {
185 fdt
= spapr_populate_hotplug_cpu_dt(cs
, &fdt_offset
, spapr
);
188 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
189 drck
->attach(drc
, dev
, fdt
, fdt_offset
, !dev
->hotplugged
, &local_err
);
192 spapr
->cores
[index
] = NULL
;
193 error_propagate(errp
, local_err
);
197 if (dev
->hotplugged
) {
199 * Send hotplug notification interrupt to the guest only in case
200 * of hotplugged CPUs.
202 spapr_hotplug_req_add_by_index(drc
);
205 * Set the right DRC states for cold plugged CPU.
207 drck
->set_allocation_state(drc
, SPAPR_DR_ALLOCATION_STATE_USABLE
);
208 drck
->set_isolation_state(drc
, SPAPR_DR_ISOLATION_STATE_UNISOLATED
);
212 void spapr_core_pre_plug(HotplugHandler
*hotplug_dev
, DeviceState
*dev
,
215 MachineState
*machine
= MACHINE(OBJECT(hotplug_dev
));
216 sPAPRMachineClass
*smc
= SPAPR_MACHINE_GET_CLASS(OBJECT(hotplug_dev
));
217 sPAPRMachineState
*spapr
= SPAPR_MACHINE(OBJECT(hotplug_dev
));
218 int spapr_max_cores
= max_cpus
/ smp_threads
;
220 int smt
= kvmppc_smt_threads();
221 Error
*local_err
= NULL
;
222 CPUCore
*cc
= CPU_CORE(dev
);
223 char *base_core_type
= spapr_get_cpu_core_type(machine
->cpu_model
);
224 const char *type
= object_get_typename(OBJECT(dev
));
226 if (strcmp(base_core_type
, type
)) {
227 error_setg(&local_err
, "CPU core type should be %s", base_core_type
);
231 if (!smc
->dr_cpu_enabled
&& dev
->hotplugged
) {
232 error_setg(&local_err
, "CPU hotplug not supported for this machine");
236 if (cc
->nr_threads
!= smp_threads
) {
237 error_setg(&local_err
, "threads must be %d", smp_threads
);
241 if (cc
->core_id
% smt
) {
242 error_setg(&local_err
, "invalid core id %d\n", cc
->core_id
);
246 index
= cc
->core_id
/ smt
;
247 if (index
< 0 || index
>= spapr_max_cores
) {
248 error_setg(&local_err
, "core id %d out of range", cc
->core_id
);
252 if (spapr
->cores
[index
]) {
253 error_setg(&local_err
, "core %d already populated", cc
->core_id
);
258 g_free(base_core_type
);
259 error_propagate(errp
, local_err
);
262 static int spapr_cpu_core_realize_child(Object
*child
, void *opaque
)
264 Error
**errp
= opaque
, *local_err
= NULL
;
265 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
266 CPUState
*cs
= CPU(child
);
267 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
269 object_property_set_bool(child
, true, "realized", &local_err
);
271 error_propagate(errp
, local_err
);
275 spapr_cpu_init(spapr
, cpu
, &local_err
);
277 error_propagate(errp
, local_err
);
283 static void spapr_cpu_core_realize(DeviceState
*dev
, Error
**errp
)
285 sPAPRCPUCore
*sc
= SPAPR_CPU_CORE(OBJECT(dev
));
286 CPUCore
*cc
= CPU_CORE(OBJECT(dev
));
287 const char *typename
= object_class_get_name(sc
->cpu_class
);
288 size_t size
= object_type_get_instance_size(typename
);
289 Error
*local_err
= NULL
;
293 sc
->threads
= g_malloc0(size
* cc
->nr_threads
);
294 for (i
= 0; i
< cc
->nr_threads
; i
++) {
296 void *obj
= sc
->threads
+ i
* size
;
298 object_initialize(obj
, size
, typename
);
299 snprintf(id
, sizeof(id
), "thread[%d]", i
);
300 object_property_add_child(OBJECT(sc
), id
, obj
, &local_err
);
306 object_child_foreach(OBJECT(dev
), spapr_cpu_core_realize_child
, &local_err
);
315 obj
= sc
->threads
+ i
* size
;
316 object_unparent(obj
);
319 error_propagate(errp
, local_err
);
322 static void spapr_cpu_core_class_init(ObjectClass
*oc
, void *data
)
324 DeviceClass
*dc
= DEVICE_CLASS(oc
);
325 dc
->realize
= spapr_cpu_core_realize
;
329 * instance_init routines from different flavours of sPAPR CPU cores.
331 #define SPAPR_CPU_CORE_INITFN(_type, _fname) \
332 static void glue(glue(spapr_cpu_core_, _fname), _initfn(Object *obj)) \
334 sPAPRCPUCore *core = SPAPR_CPU_CORE(obj); \
335 char *name = g_strdup_printf("%s-" TYPE_POWERPC_CPU, stringify(_type)); \
336 ObjectClass *oc = object_class_by_name(name); \
338 g_free((void *)name); \
339 core->cpu_class = oc; \
342 SPAPR_CPU_CORE_INITFN(970mp_v1
.0
, 970MP_v10
);
343 SPAPR_CPU_CORE_INITFN(970mp_v1
.1
, 970MP_v11
);
344 SPAPR_CPU_CORE_INITFN(970_v2
.2
, 970);
345 SPAPR_CPU_CORE_INITFN(POWER5
+_v2
.1
, POWER5plus
);
346 SPAPR_CPU_CORE_INITFN(POWER7_v2
.3
, POWER7
);
347 SPAPR_CPU_CORE_INITFN(POWER7
+_v2
.1
, POWER7plus
);
348 SPAPR_CPU_CORE_INITFN(POWER8_v2
.0
, POWER8
);
349 SPAPR_CPU_CORE_INITFN(POWER8E_v2
.1
, POWER8E
);
350 SPAPR_CPU_CORE_INITFN(POWER8NVL_v1
.0
, POWER8NVL
);
352 typedef struct SPAPRCoreInfo
{
354 void (*initfn
)(Object
*obj
);
357 static const SPAPRCoreInfo spapr_cores
[] = {
359 { .name
= "970_v2.2", .initfn
= spapr_cpu_core_970_initfn
},
360 { .name
= "970", .initfn
= spapr_cpu_core_970_initfn
},
362 /* 970MP variants and aliases */
363 { .name
= "970MP_v1.0", .initfn
= spapr_cpu_core_970MP_v10_initfn
},
364 { .name
= "970mp_v1.0", .initfn
= spapr_cpu_core_970MP_v10_initfn
},
365 { .name
= "970MP_v1.1", .initfn
= spapr_cpu_core_970MP_v11_initfn
},
366 { .name
= "970mp_v1.1", .initfn
= spapr_cpu_core_970MP_v11_initfn
},
367 { .name
= "970mp", .initfn
= spapr_cpu_core_970MP_v11_initfn
},
369 /* POWER5 and aliases */
370 { .name
= "POWER5+_v2.1", .initfn
= spapr_cpu_core_POWER5plus_initfn
},
371 { .name
= "POWER5+", .initfn
= spapr_cpu_core_POWER5plus_initfn
},
373 /* POWER7 and aliases */
374 { .name
= "POWER7_v2.3", .initfn
= spapr_cpu_core_POWER7_initfn
},
375 { .name
= "POWER7", .initfn
= spapr_cpu_core_POWER7_initfn
},
377 /* POWER7+ and aliases */
378 { .name
= "POWER7+_v2.1", .initfn
= spapr_cpu_core_POWER7plus_initfn
},
379 { .name
= "POWER7+", .initfn
= spapr_cpu_core_POWER7plus_initfn
},
381 /* POWER8 and aliases */
382 { .name
= "POWER8_v2.0", .initfn
= spapr_cpu_core_POWER8_initfn
},
383 { .name
= "POWER8", .initfn
= spapr_cpu_core_POWER8_initfn
},
384 { .name
= "power8", .initfn
= spapr_cpu_core_POWER8_initfn
},
386 /* POWER8E and aliases */
387 { .name
= "POWER8E_v2.1", .initfn
= spapr_cpu_core_POWER8E_initfn
},
388 { .name
= "POWER8E", .initfn
= spapr_cpu_core_POWER8E_initfn
},
390 /* POWER8NVL and aliases */
391 { .name
= "POWER8NVL_v1.0", .initfn
= spapr_cpu_core_POWER8NVL_initfn
},
392 { .name
= "POWER8NVL", .initfn
= spapr_cpu_core_POWER8NVL_initfn
},
397 static void spapr_cpu_core_register(const SPAPRCoreInfo
*info
)
399 TypeInfo type_info
= {
400 .parent
= TYPE_SPAPR_CPU_CORE
,
401 .instance_size
= sizeof(sPAPRCPUCore
),
402 .instance_init
= info
->initfn
,
405 type_info
.name
= g_strdup_printf("%s-" TYPE_SPAPR_CPU_CORE
, info
->name
);
406 type_register(&type_info
);
407 g_free((void *)type_info
.name
);
410 static const TypeInfo spapr_cpu_core_type_info
= {
411 .name
= TYPE_SPAPR_CPU_CORE
,
412 .parent
= TYPE_CPU_CORE
,
414 .instance_size
= sizeof(sPAPRCPUCore
),
415 .class_init
= spapr_cpu_core_class_init
,
418 static void spapr_cpu_core_register_types(void)
420 const SPAPRCoreInfo
*info
= spapr_cores
;
422 type_register_static(&spapr_cpu_core_type_info
);
424 spapr_cpu_core_register(info
);
429 type_init(spapr_cpu_core_register_types
)