2 * QEMU SPAPR Dynamic Reconfiguration Connector Implementation
4 * Copyright IBM Corp. 2014
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qapi/qmp/qnull.h"
17 #include "qemu/cutils.h"
18 #include "hw/ppc/spapr_drc.h"
19 #include "qom/object.h"
21 #include "qapi/visitor.h"
22 #include "qemu/error-report.h"
23 #include "hw/ppc/spapr.h" /* for RTAS return codes */
24 #include "hw/pci-host/spapr.h" /* spapr_phb_remove_pci_device_cb callback */
25 #include "sysemu/device_tree.h"
28 #define DRC_CONTAINER_PATH "/dr-connector"
29 #define DRC_INDEX_TYPE_SHIFT 28
30 #define DRC_INDEX_ID_MASK ((1ULL << DRC_INDEX_TYPE_SHIFT) - 1)
32 sPAPRDRConnectorType
spapr_drc_type(sPAPRDRConnector
*drc
)
34 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
36 return 1 << drck
->typeshift
;
39 uint32_t spapr_drc_index(sPAPRDRConnector
*drc
)
41 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
43 /* no set format for a drc index: it only needs to be globally
44 * unique. this is how we encode the DRC type on bare-metal
45 * however, so might as well do that here
47 return (drck
->typeshift
<< DRC_INDEX_TYPE_SHIFT
)
48 | (drc
->id
& DRC_INDEX_ID_MASK
);
51 static uint32_t drc_isolate_physical(sPAPRDRConnector
*drc
)
54 case SPAPR_DRC_STATE_PHYSICAL_POWERON
:
55 return RTAS_OUT_SUCCESS
; /* Nothing to do */
56 case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED
:
57 break; /* see below */
58 case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE
:
59 return RTAS_OUT_PARAM_ERROR
; /* not allowed */
61 g_assert_not_reached();
64 drc
->state
= SPAPR_DRC_STATE_PHYSICAL_POWERON
;
66 if (drc
->unplug_requested
) {
67 uint32_t drc_index
= spapr_drc_index(drc
);
68 trace_spapr_drc_set_isolation_state_finalizing(drc_index
);
69 spapr_drc_detach(drc
);
72 return RTAS_OUT_SUCCESS
;
75 static uint32_t drc_unisolate_physical(sPAPRDRConnector
*drc
)
78 case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE
:
79 case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED
:
80 return RTAS_OUT_SUCCESS
; /* Nothing to do */
81 case SPAPR_DRC_STATE_PHYSICAL_POWERON
:
82 break; /* see below */
84 g_assert_not_reached();
87 /* cannot unisolate a non-existent resource, and, or resources
88 * which are in an 'UNUSABLE' allocation state. (PAPR 2.7,
92 return RTAS_OUT_NO_SUCH_INDICATOR
;
95 drc
->state
= SPAPR_DRC_STATE_PHYSICAL_UNISOLATE
;
96 drc
->ccs_offset
= drc
->fdt_start_offset
;
99 return RTAS_OUT_SUCCESS
;
102 static uint32_t drc_isolate_logical(sPAPRDRConnector
*drc
)
104 switch (drc
->state
) {
105 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE
:
106 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE
:
107 return RTAS_OUT_SUCCESS
; /* Nothing to do */
108 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED
:
109 break; /* see below */
110 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE
:
111 return RTAS_OUT_PARAM_ERROR
; /* not allowed */
113 g_assert_not_reached();
117 * Fail any requests to ISOLATE the LMB DRC if this LMB doesn't
118 * belong to a DIMM device that is marked for removal.
120 * Currently the guest userspace tool drmgr that drives the memory
121 * hotplug/unplug will just try to remove a set of 'removable' LMBs
122 * in response to a hot unplug request that is based on drc-count.
123 * If the LMB being removed doesn't belong to a DIMM device that is
124 * actually being unplugged, fail the isolation request here.
126 if (spapr_drc_type(drc
) == SPAPR_DR_CONNECTOR_TYPE_LMB
127 && !drc
->unplug_requested
) {
128 return RTAS_OUT_HW_ERROR
;
131 drc
->state
= SPAPR_DRC_STATE_LOGICAL_AVAILABLE
;
133 /* if we're awaiting release, but still in an unconfigured state,
134 * it's likely the guest is still in the process of configuring
135 * the device and is transitioning the devices to an ISOLATED
136 * state as a part of that process. so we only complete the
137 * removal when this transition happens for a device in a
138 * configured state, as suggested by the state diagram from PAPR+
141 if (drc
->unplug_requested
) {
142 uint32_t drc_index
= spapr_drc_index(drc
);
143 trace_spapr_drc_set_isolation_state_finalizing(drc_index
);
144 spapr_drc_detach(drc
);
146 return RTAS_OUT_SUCCESS
;
149 static uint32_t drc_unisolate_logical(sPAPRDRConnector
*drc
)
151 switch (drc
->state
) {
152 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE
:
153 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED
:
154 return RTAS_OUT_SUCCESS
; /* Nothing to do */
155 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE
:
156 break; /* see below */
157 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE
:
158 return RTAS_OUT_NO_SUCH_INDICATOR
; /* not allowed */
160 g_assert_not_reached();
163 /* Move to AVAILABLE state should have ensured device was present */
166 drc
->state
= SPAPR_DRC_STATE_LOGICAL_UNISOLATE
;
167 drc
->ccs_offset
= drc
->fdt_start_offset
;
170 return RTAS_OUT_SUCCESS
;
173 static uint32_t drc_set_usable(sPAPRDRConnector
*drc
)
175 switch (drc
->state
) {
176 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE
:
177 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE
:
178 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED
:
179 return RTAS_OUT_SUCCESS
; /* Nothing to do */
180 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE
:
181 break; /* see below */
183 g_assert_not_reached();
186 /* if there's no resource/device associated with the DRC, there's
187 * no way for us to put it in an allocation state consistent with
188 * being 'USABLE'. PAPR 2.7, 13.5.3.4 documents that this should
189 * result in an RTAS return code of -3 / "no such indicator"
192 return RTAS_OUT_NO_SUCH_INDICATOR
;
194 if (drc
->unplug_requested
) {
195 /* Don't allow the guest to move a device away from UNUSABLE
196 * state when we want to unplug it */
197 return RTAS_OUT_NO_SUCH_INDICATOR
;
200 drc
->state
= SPAPR_DRC_STATE_LOGICAL_AVAILABLE
;
202 return RTAS_OUT_SUCCESS
;
205 static uint32_t drc_set_unusable(sPAPRDRConnector
*drc
)
207 switch (drc
->state
) {
208 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE
:
209 return RTAS_OUT_SUCCESS
; /* Nothing to do */
210 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE
:
211 break; /* see below */
212 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE
:
213 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED
:
214 return RTAS_OUT_NO_SUCH_INDICATOR
; /* not allowed */
216 g_assert_not_reached();
219 drc
->state
= SPAPR_DRC_STATE_LOGICAL_UNUSABLE
;
220 if (drc
->unplug_requested
) {
221 uint32_t drc_index
= spapr_drc_index(drc
);
222 trace_spapr_drc_set_allocation_state_finalizing(drc_index
);
223 spapr_drc_detach(drc
);
226 return RTAS_OUT_SUCCESS
;
229 static const char *spapr_drc_name(sPAPRDRConnector
*drc
)
231 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
233 /* human-readable name for a DRC to encode into the DT
234 * description. this is mainly only used within a guest in place
235 * of the unique DRC index.
237 * in the case of VIO/PCI devices, it corresponds to a "location
238 * code" that maps a logical device/function (DRC index) to a
239 * physical (or virtual in the case of VIO) location in the system
240 * by chaining together the "location label" for each
241 * encapsulating component.
243 * since this is more to do with diagnosing physical hardware
244 * issues than guest compatibility, we choose location codes/DRC
245 * names that adhere to the documented format, but avoid encoding
246 * the entire topology information into the label/code, instead
247 * just using the location codes based on the labels for the
248 * endpoints (VIO/PCI adaptor connectors), which is basically just
249 * "C" followed by an integer ID.
251 * DRC names as documented by PAPR+ v2.7, 13.5.2.4
252 * location codes as documented by PAPR+ v2.7, 12.3.1.5
254 return g_strdup_printf("%s%d", drck
->drc_name_prefix
, drc
->id
);
258 * dr-entity-sense sensor value
259 * returned via get-sensor-state RTAS calls
260 * as expected by state diagram in PAPR+ 2.7, 13.4
261 * based on the current allocation/indicator/power states
262 * for the DR connector.
264 static sPAPRDREntitySense
physical_entity_sense(sPAPRDRConnector
*drc
)
266 /* this assumes all PCI devices are assigned to a 'live insertion'
267 * power domain, where QEMU manages power state automatically as
268 * opposed to the guest. present, non-PCI resources are unaffected
271 return drc
->dev
? SPAPR_DR_ENTITY_SENSE_PRESENT
272 : SPAPR_DR_ENTITY_SENSE_EMPTY
;
275 static sPAPRDREntitySense
logical_entity_sense(sPAPRDRConnector
*drc
)
277 switch (drc
->state
) {
278 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE
:
279 return SPAPR_DR_ENTITY_SENSE_UNUSABLE
;
280 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE
:
281 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE
:
282 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED
:
284 return SPAPR_DR_ENTITY_SENSE_PRESENT
;
286 g_assert_not_reached();
290 static void prop_get_index(Object
*obj
, Visitor
*v
, const char *name
,
291 void *opaque
, Error
**errp
)
293 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
294 uint32_t value
= spapr_drc_index(drc
);
295 visit_type_uint32(v
, name
, &value
, errp
);
298 static void prop_get_fdt(Object
*obj
, Visitor
*v
, const char *name
,
299 void *opaque
, Error
**errp
)
301 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
304 int fdt_offset_next
, fdt_offset
, fdt_depth
;
308 visit_type_null(v
, NULL
, &null
, errp
);
314 fdt_offset
= drc
->fdt_start_offset
;
318 const char *name
= NULL
;
319 const struct fdt_property
*prop
= NULL
;
320 int prop_len
= 0, name_len
= 0;
323 tag
= fdt_next_tag(fdt
, fdt_offset
, &fdt_offset_next
);
327 name
= fdt_get_name(fdt
, fdt_offset
, &name_len
);
328 visit_start_struct(v
, name
, NULL
, 0, &err
);
330 error_propagate(errp
, err
);
335 /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */
336 g_assert(fdt_depth
> 0);
337 visit_check_struct(v
, &err
);
338 visit_end_struct(v
, NULL
);
340 error_propagate(errp
, err
);
347 prop
= fdt_get_property_by_offset(fdt
, fdt_offset
, &prop_len
);
348 name
= fdt_string(fdt
, fdt32_to_cpu(prop
->nameoff
));
349 visit_start_list(v
, name
, NULL
, 0, &err
);
351 error_propagate(errp
, err
);
354 for (i
= 0; i
< prop_len
; i
++) {
355 visit_type_uint8(v
, NULL
, (uint8_t *)&prop
->data
[i
], &err
);
357 error_propagate(errp
, err
);
361 visit_check_list(v
, &err
);
362 visit_end_list(v
, NULL
);
364 error_propagate(errp
, err
);
370 error_report("device FDT in unexpected state: %d", tag
);
373 fdt_offset
= fdt_offset_next
;
374 } while (fdt_depth
!= 0);
377 void spapr_drc_attach(sPAPRDRConnector
*drc
, DeviceState
*d
, Error
**errp
)
379 trace_spapr_drc_attach(spapr_drc_index(drc
));
382 error_setg(errp
, "an attached device is still awaiting release");
385 g_assert((drc
->state
== SPAPR_DRC_STATE_LOGICAL_UNUSABLE
)
386 || (drc
->state
== SPAPR_DRC_STATE_PHYSICAL_POWERON
));
390 object_property_add_link(OBJECT(drc
), "device",
391 object_get_typename(OBJECT(drc
->dev
)),
392 (Object
**)(&drc
->dev
),
396 static void spapr_drc_release(sPAPRDRConnector
*drc
)
398 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
400 drck
->release(drc
->dev
);
402 drc
->unplug_requested
= false;
405 drc
->fdt_start_offset
= 0;
406 object_property_del(OBJECT(drc
), "device", &error_abort
);
410 void spapr_drc_detach(sPAPRDRConnector
*drc
)
412 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
414 trace_spapr_drc_detach(spapr_drc_index(drc
));
418 drc
->unplug_requested
= true;
420 if (drc
->state
!= drck
->empty_state
) {
421 trace_spapr_drc_awaiting_quiesce(spapr_drc_index(drc
));
425 spapr_drc_release(drc
);
428 void spapr_drc_reset(sPAPRDRConnector
*drc
)
430 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
432 trace_spapr_drc_reset(spapr_drc_index(drc
));
434 /* immediately upon reset we can safely assume DRCs whose devices
435 * are pending removal can be safely removed.
437 if (drc
->unplug_requested
) {
438 spapr_drc_release(drc
);
442 /* A device present at reset is ready to go, same as coldplugged */
443 drc
->state
= drck
->ready_state
;
445 * Ensure that we are able to send the FDT fragment again
446 * via configure-connector call if the guest requests.
448 drc
->ccs_offset
= drc
->fdt_start_offset
;
451 drc
->state
= drck
->empty_state
;
452 drc
->ccs_offset
= -1;
457 bool spapr_drc_needed(void *opaque
)
459 sPAPRDRConnector
*drc
= (sPAPRDRConnector
*)opaque
;
460 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
462 /* If no dev is plugged in there is no need to migrate the DRC state */
468 * We need to migrate the state if it's not equal to the expected
469 * long-term state, which is the same as the coldplugged initial
471 return (drc
->state
!= drck
->ready_state
);
474 static const VMStateDescription vmstate_spapr_drc
= {
477 .minimum_version_id
= 1,
478 .needed
= spapr_drc_needed
,
479 .fields
= (VMStateField
[]) {
480 VMSTATE_UINT32(state
, sPAPRDRConnector
),
481 VMSTATE_END_OF_LIST()
485 static void realize(DeviceState
*d
, Error
**errp
)
487 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(d
);
488 Object
*root_container
;
493 trace_spapr_drc_realize(spapr_drc_index(drc
));
494 /* NOTE: we do this as part of realize/unrealize due to the fact
495 * that the guest will communicate with the DRC via RTAS calls
496 * referencing the global DRC index. By unlinking the DRC
497 * from DRC_CONTAINER_PATH/<drc_index> we effectively make it
498 * inaccessible by the guest, since lookups rely on this path
499 * existing in the composition tree
501 root_container
= container_get(object_get_root(), DRC_CONTAINER_PATH
);
502 link_name
= g_strdup_printf("%x", spapr_drc_index(drc
));
503 child_name
= object_get_canonical_path_component(OBJECT(drc
));
504 trace_spapr_drc_realize_child(spapr_drc_index(drc
), child_name
);
505 object_property_add_alias(root_container
, link_name
,
506 drc
->owner
, child_name
, &err
);
510 error_propagate(errp
, err
);
513 vmstate_register(DEVICE(drc
), spapr_drc_index(drc
), &vmstate_spapr_drc
,
515 trace_spapr_drc_realize_complete(spapr_drc_index(drc
));
518 static void unrealize(DeviceState
*d
, Error
**errp
)
520 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(d
);
521 Object
*root_container
;
524 trace_spapr_drc_unrealize(spapr_drc_index(drc
));
525 vmstate_unregister(DEVICE(drc
), &vmstate_spapr_drc
, drc
);
526 root_container
= container_get(object_get_root(), DRC_CONTAINER_PATH
);
527 name
= g_strdup_printf("%x", spapr_drc_index(drc
));
528 object_property_del(root_container
, name
, errp
);
532 sPAPRDRConnector
*spapr_dr_connector_new(Object
*owner
, const char *type
,
535 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(object_new(type
));
540 prop_name
= g_strdup_printf("dr-connector[%"PRIu32
"]",
541 spapr_drc_index(drc
));
542 object_property_add_child(owner
, prop_name
, OBJECT(drc
), &error_abort
);
543 object_unref(OBJECT(drc
));
544 object_property_set_bool(OBJECT(drc
), true, "realized", NULL
);
550 static void spapr_dr_connector_instance_init(Object
*obj
)
552 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
553 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
555 object_property_add_uint32_ptr(obj
, "id", &drc
->id
, NULL
);
556 object_property_add(obj
, "index", "uint32", prop_get_index
,
557 NULL
, NULL
, NULL
, NULL
);
558 object_property_add(obj
, "fdt", "struct", prop_get_fdt
,
559 NULL
, NULL
, NULL
, NULL
);
560 drc
->state
= drck
->empty_state
;
563 static void spapr_dr_connector_class_init(ObjectClass
*k
, void *data
)
565 DeviceClass
*dk
= DEVICE_CLASS(k
);
567 dk
->realize
= realize
;
568 dk
->unrealize
= unrealize
;
570 * Reason: it crashes FIXME find and document the real reason
572 dk
->user_creatable
= false;
575 static bool drc_physical_needed(void *opaque
)
577 sPAPRDRCPhysical
*drcp
= (sPAPRDRCPhysical
*)opaque
;
578 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(drcp
);
580 if ((drc
->dev
&& (drcp
->dr_indicator
== SPAPR_DR_INDICATOR_ACTIVE
))
581 || (!drc
->dev
&& (drcp
->dr_indicator
== SPAPR_DR_INDICATOR_INACTIVE
))) {
587 static const VMStateDescription vmstate_spapr_drc_physical
= {
588 .name
= "spapr_drc/physical",
590 .minimum_version_id
= 1,
591 .needed
= drc_physical_needed
,
592 .fields
= (VMStateField
[]) {
593 VMSTATE_UINT32(dr_indicator
, sPAPRDRCPhysical
),
594 VMSTATE_END_OF_LIST()
598 static void drc_physical_reset(void *opaque
)
600 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(opaque
);
601 sPAPRDRCPhysical
*drcp
= SPAPR_DRC_PHYSICAL(drc
);
604 drcp
->dr_indicator
= SPAPR_DR_INDICATOR_ACTIVE
;
606 drcp
->dr_indicator
= SPAPR_DR_INDICATOR_INACTIVE
;
610 static void realize_physical(DeviceState
*d
, Error
**errp
)
612 sPAPRDRCPhysical
*drcp
= SPAPR_DRC_PHYSICAL(d
);
613 Error
*local_err
= NULL
;
615 realize(d
, &local_err
);
617 error_propagate(errp
, local_err
);
621 vmstate_register(DEVICE(drcp
), spapr_drc_index(SPAPR_DR_CONNECTOR(drcp
)),
622 &vmstate_spapr_drc_physical
, drcp
);
623 qemu_register_reset(drc_physical_reset
, drcp
);
626 static void unrealize_physical(DeviceState
*d
, Error
**errp
)
628 sPAPRDRCPhysical
*drcp
= SPAPR_DRC_PHYSICAL(d
);
629 Error
*local_err
= NULL
;
631 unrealize(d
, &local_err
);
633 error_propagate(errp
, local_err
);
637 vmstate_unregister(DEVICE(drcp
), &vmstate_spapr_drc_physical
, drcp
);
638 qemu_unregister_reset(drc_physical_reset
, drcp
);
641 static void spapr_drc_physical_class_init(ObjectClass
*k
, void *data
)
643 DeviceClass
*dk
= DEVICE_CLASS(k
);
644 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_CLASS(k
);
646 dk
->realize
= realize_physical
;
647 dk
->unrealize
= unrealize_physical
;
648 drck
->dr_entity_sense
= physical_entity_sense
;
649 drck
->isolate
= drc_isolate_physical
;
650 drck
->unisolate
= drc_unisolate_physical
;
651 drck
->ready_state
= SPAPR_DRC_STATE_PHYSICAL_CONFIGURED
;
652 drck
->empty_state
= SPAPR_DRC_STATE_PHYSICAL_POWERON
;
655 static void spapr_drc_logical_class_init(ObjectClass
*k
, void *data
)
657 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_CLASS(k
);
659 drck
->dr_entity_sense
= logical_entity_sense
;
660 drck
->isolate
= drc_isolate_logical
;
661 drck
->unisolate
= drc_unisolate_logical
;
662 drck
->ready_state
= SPAPR_DRC_STATE_LOGICAL_CONFIGURED
;
663 drck
->empty_state
= SPAPR_DRC_STATE_LOGICAL_UNUSABLE
;
666 static void spapr_drc_cpu_class_init(ObjectClass
*k
, void *data
)
668 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_CLASS(k
);
670 drck
->typeshift
= SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU
;
671 drck
->typename
= "CPU";
672 drck
->drc_name_prefix
= "CPU ";
673 drck
->release
= spapr_core_release
;
674 drck
->dt_populate
= spapr_core_dt_populate
;
677 static void spapr_drc_pci_class_init(ObjectClass
*k
, void *data
)
679 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_CLASS(k
);
681 drck
->typeshift
= SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI
;
682 drck
->typename
= "28";
683 drck
->drc_name_prefix
= "C";
684 drck
->release
= spapr_phb_remove_pci_device_cb
;
685 drck
->dt_populate
= spapr_pci_dt_populate
;
688 static void spapr_drc_lmb_class_init(ObjectClass
*k
, void *data
)
690 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_CLASS(k
);
692 drck
->typeshift
= SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB
;
693 drck
->typename
= "MEM";
694 drck
->drc_name_prefix
= "LMB ";
695 drck
->release
= spapr_lmb_release
;
696 drck
->dt_populate
= spapr_lmb_dt_populate
;
699 static const TypeInfo spapr_dr_connector_info
= {
700 .name
= TYPE_SPAPR_DR_CONNECTOR
,
701 .parent
= TYPE_DEVICE
,
702 .instance_size
= sizeof(sPAPRDRConnector
),
703 .instance_init
= spapr_dr_connector_instance_init
,
704 .class_size
= sizeof(sPAPRDRConnectorClass
),
705 .class_init
= spapr_dr_connector_class_init
,
709 static const TypeInfo spapr_drc_physical_info
= {
710 .name
= TYPE_SPAPR_DRC_PHYSICAL
,
711 .parent
= TYPE_SPAPR_DR_CONNECTOR
,
712 .instance_size
= sizeof(sPAPRDRCPhysical
),
713 .class_init
= spapr_drc_physical_class_init
,
717 static const TypeInfo spapr_drc_logical_info
= {
718 .name
= TYPE_SPAPR_DRC_LOGICAL
,
719 .parent
= TYPE_SPAPR_DR_CONNECTOR
,
720 .class_init
= spapr_drc_logical_class_init
,
724 static const TypeInfo spapr_drc_cpu_info
= {
725 .name
= TYPE_SPAPR_DRC_CPU
,
726 .parent
= TYPE_SPAPR_DRC_LOGICAL
,
727 .class_init
= spapr_drc_cpu_class_init
,
730 static const TypeInfo spapr_drc_pci_info
= {
731 .name
= TYPE_SPAPR_DRC_PCI
,
732 .parent
= TYPE_SPAPR_DRC_PHYSICAL
,
733 .class_init
= spapr_drc_pci_class_init
,
736 static const TypeInfo spapr_drc_lmb_info
= {
737 .name
= TYPE_SPAPR_DRC_LMB
,
738 .parent
= TYPE_SPAPR_DRC_LOGICAL
,
739 .class_init
= spapr_drc_lmb_class_init
,
742 /* helper functions for external users */
744 sPAPRDRConnector
*spapr_drc_by_index(uint32_t index
)
749 name
= g_strdup_printf("%s/%x", DRC_CONTAINER_PATH
, index
);
750 obj
= object_resolve_path(name
, NULL
);
753 return !obj
? NULL
: SPAPR_DR_CONNECTOR(obj
);
756 sPAPRDRConnector
*spapr_drc_by_id(const char *type
, uint32_t id
)
758 sPAPRDRConnectorClass
*drck
759 = SPAPR_DR_CONNECTOR_CLASS(object_class_by_name(type
));
761 return spapr_drc_by_index(drck
->typeshift
<< DRC_INDEX_TYPE_SHIFT
762 | (id
& DRC_INDEX_ID_MASK
));
766 * spapr_drc_populate_dt
768 * @fdt: libfdt device tree
769 * @path: path in the DT to generate properties
770 * @owner: parent Object/DeviceState for which to generate DRC
772 * @drc_type_mask: mask of sPAPRDRConnectorType values corresponding
773 * to the types of DRCs to generate entries for
775 * generate OF properties to describe DRC topology/indices to guests
777 * as documented in PAPR+ v2.1, 13.5.2
779 int spapr_drc_populate_dt(void *fdt
, int fdt_offset
, Object
*owner
,
780 uint32_t drc_type_mask
)
782 Object
*root_container
;
783 ObjectProperty
*prop
;
784 ObjectPropertyIterator iter
;
785 uint32_t drc_count
= 0;
786 GArray
*drc_indexes
, *drc_power_domains
;
787 GString
*drc_names
, *drc_types
;
790 /* the first entry of each properties is a 32-bit integer encoding
791 * the number of elements in the array. we won't know this until
792 * we complete the iteration through all the matching DRCs, but
793 * reserve the space now and set the offsets accordingly so we
794 * can fill them in later.
796 drc_indexes
= g_array_new(false, true, sizeof(uint32_t));
797 drc_indexes
= g_array_set_size(drc_indexes
, 1);
798 drc_power_domains
= g_array_new(false, true, sizeof(uint32_t));
799 drc_power_domains
= g_array_set_size(drc_power_domains
, 1);
800 drc_names
= g_string_set_size(g_string_new(NULL
), sizeof(uint32_t));
801 drc_types
= g_string_set_size(g_string_new(NULL
), sizeof(uint32_t));
803 /* aliases for all DRConnector objects will be rooted in QOM
804 * composition tree at DRC_CONTAINER_PATH
806 root_container
= container_get(object_get_root(), DRC_CONTAINER_PATH
);
808 object_property_iter_init(&iter
, root_container
);
809 while ((prop
= object_property_iter_next(&iter
))) {
811 sPAPRDRConnector
*drc
;
812 sPAPRDRConnectorClass
*drck
;
813 uint32_t drc_index
, drc_power_domain
;
815 if (!strstart(prop
->type
, "link<", NULL
)) {
819 obj
= object_property_get_link(root_container
, prop
->name
, NULL
);
820 drc
= SPAPR_DR_CONNECTOR(obj
);
821 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
823 if (owner
&& (drc
->owner
!= owner
)) {
827 if ((spapr_drc_type(drc
) & drc_type_mask
) == 0) {
833 /* ibm,drc-indexes */
834 drc_index
= cpu_to_be32(spapr_drc_index(drc
));
835 g_array_append_val(drc_indexes
, drc_index
);
837 /* ibm,drc-power-domains */
838 drc_power_domain
= cpu_to_be32(-1);
839 g_array_append_val(drc_power_domains
, drc_power_domain
);
842 drc_names
= g_string_append(drc_names
, spapr_drc_name(drc
));
843 drc_names
= g_string_insert_len(drc_names
, -1, "\0", 1);
846 drc_types
= g_string_append(drc_types
, drck
->typename
);
847 drc_types
= g_string_insert_len(drc_types
, -1, "\0", 1);
850 /* now write the drc count into the space we reserved at the
851 * beginning of the arrays previously
853 *(uint32_t *)drc_indexes
->data
= cpu_to_be32(drc_count
);
854 *(uint32_t *)drc_power_domains
->data
= cpu_to_be32(drc_count
);
855 *(uint32_t *)drc_names
->str
= cpu_to_be32(drc_count
);
856 *(uint32_t *)drc_types
->str
= cpu_to_be32(drc_count
);
858 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-indexes",
860 drc_indexes
->len
* sizeof(uint32_t));
862 error_report("Couldn't create ibm,drc-indexes property");
866 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-power-domains",
867 drc_power_domains
->data
,
868 drc_power_domains
->len
* sizeof(uint32_t));
870 error_report("Couldn't finalize ibm,drc-power-domains property");
874 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-names",
875 drc_names
->str
, drc_names
->len
);
877 error_report("Couldn't finalize ibm,drc-names property");
881 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-types",
882 drc_types
->str
, drc_types
->len
);
884 error_report("Couldn't finalize ibm,drc-types property");
889 g_array_free(drc_indexes
, true);
890 g_array_free(drc_power_domains
, true);
891 g_string_free(drc_names
, true);
892 g_string_free(drc_types
, true);
901 static uint32_t rtas_set_isolation_state(uint32_t idx
, uint32_t state
)
903 sPAPRDRConnector
*drc
= spapr_drc_by_index(idx
);
904 sPAPRDRConnectorClass
*drck
;
907 return RTAS_OUT_NO_SUCH_INDICATOR
;
910 trace_spapr_drc_set_isolation_state(spapr_drc_index(drc
), state
);
912 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
915 case SPAPR_DR_ISOLATION_STATE_ISOLATED
:
916 return drck
->isolate(drc
);
918 case SPAPR_DR_ISOLATION_STATE_UNISOLATED
:
919 return drck
->unisolate(drc
);
922 return RTAS_OUT_PARAM_ERROR
;
926 static uint32_t rtas_set_allocation_state(uint32_t idx
, uint32_t state
)
928 sPAPRDRConnector
*drc
= spapr_drc_by_index(idx
);
930 if (!drc
|| !object_dynamic_cast(OBJECT(drc
), TYPE_SPAPR_DRC_LOGICAL
)) {
931 return RTAS_OUT_NO_SUCH_INDICATOR
;
934 trace_spapr_drc_set_allocation_state(spapr_drc_index(drc
), state
);
937 case SPAPR_DR_ALLOCATION_STATE_USABLE
:
938 return drc_set_usable(drc
);
940 case SPAPR_DR_ALLOCATION_STATE_UNUSABLE
:
941 return drc_set_unusable(drc
);
944 return RTAS_OUT_PARAM_ERROR
;
948 static uint32_t rtas_set_dr_indicator(uint32_t idx
, uint32_t state
)
950 sPAPRDRConnector
*drc
= spapr_drc_by_index(idx
);
952 if (!drc
|| !object_dynamic_cast(OBJECT(drc
), TYPE_SPAPR_DRC_PHYSICAL
)) {
953 return RTAS_OUT_NO_SUCH_INDICATOR
;
955 if ((state
!= SPAPR_DR_INDICATOR_INACTIVE
)
956 && (state
!= SPAPR_DR_INDICATOR_ACTIVE
)
957 && (state
!= SPAPR_DR_INDICATOR_IDENTIFY
)
958 && (state
!= SPAPR_DR_INDICATOR_ACTION
)) {
959 return RTAS_OUT_PARAM_ERROR
; /* bad state parameter */
962 trace_spapr_drc_set_dr_indicator(idx
, state
);
963 SPAPR_DRC_PHYSICAL(drc
)->dr_indicator
= state
;
964 return RTAS_OUT_SUCCESS
;
967 static void rtas_set_indicator(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
969 uint32_t nargs
, target_ulong args
,
970 uint32_t nret
, target_ulong rets
)
972 uint32_t type
, idx
, state
;
973 uint32_t ret
= RTAS_OUT_SUCCESS
;
975 if (nargs
!= 3 || nret
!= 1) {
976 ret
= RTAS_OUT_PARAM_ERROR
;
980 type
= rtas_ld(args
, 0);
981 idx
= rtas_ld(args
, 1);
982 state
= rtas_ld(args
, 2);
985 case RTAS_SENSOR_TYPE_ISOLATION_STATE
:
986 ret
= rtas_set_isolation_state(idx
, state
);
988 case RTAS_SENSOR_TYPE_DR
:
989 ret
= rtas_set_dr_indicator(idx
, state
);
991 case RTAS_SENSOR_TYPE_ALLOCATION_STATE
:
992 ret
= rtas_set_allocation_state(idx
, state
);
995 ret
= RTAS_OUT_NOT_SUPPORTED
;
999 rtas_st(rets
, 0, ret
);
1002 static void rtas_get_sensor_state(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
1003 uint32_t token
, uint32_t nargs
,
1004 target_ulong args
, uint32_t nret
,
1007 uint32_t sensor_type
;
1008 uint32_t sensor_index
;
1009 uint32_t sensor_state
= 0;
1010 sPAPRDRConnector
*drc
;
1011 sPAPRDRConnectorClass
*drck
;
1012 uint32_t ret
= RTAS_OUT_SUCCESS
;
1014 if (nargs
!= 2 || nret
!= 2) {
1015 ret
= RTAS_OUT_PARAM_ERROR
;
1019 sensor_type
= rtas_ld(args
, 0);
1020 sensor_index
= rtas_ld(args
, 1);
1022 if (sensor_type
!= RTAS_SENSOR_TYPE_ENTITY_SENSE
) {
1023 /* currently only DR-related sensors are implemented */
1024 trace_spapr_rtas_get_sensor_state_not_supported(sensor_index
,
1026 ret
= RTAS_OUT_NOT_SUPPORTED
;
1030 drc
= spapr_drc_by_index(sensor_index
);
1032 trace_spapr_rtas_get_sensor_state_invalid(sensor_index
);
1033 ret
= RTAS_OUT_PARAM_ERROR
;
1036 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
1037 sensor_state
= drck
->dr_entity_sense(drc
);
1040 rtas_st(rets
, 0, ret
);
1041 rtas_st(rets
, 1, sensor_state
);
1044 /* configure-connector work area offsets, int32_t units for field
1045 * indexes, bytes for field offset/len values.
1047 * as documented by PAPR+ v2.7, 13.5.3.5
1049 #define CC_IDX_NODE_NAME_OFFSET 2
1050 #define CC_IDX_PROP_NAME_OFFSET 2
1051 #define CC_IDX_PROP_LEN 3
1052 #define CC_IDX_PROP_DATA_OFFSET 4
1053 #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4)
1054 #define CC_WA_LEN 4096
1056 static void configure_connector_st(target_ulong addr
, target_ulong offset
,
1057 const void *buf
, size_t len
)
1059 cpu_physical_memory_write(ppc64_phys_to_real(addr
+ offset
),
1060 buf
, MIN(len
, CC_WA_LEN
- offset
));
1063 static void rtas_ibm_configure_connector(PowerPCCPU
*cpu
,
1064 sPAPRMachineState
*spapr
,
1065 uint32_t token
, uint32_t nargs
,
1066 target_ulong args
, uint32_t nret
,
1072 sPAPRDRConnector
*drc
;
1073 sPAPRDRConnectorClass
*drck
;
1074 sPAPRDRCCResponse resp
= SPAPR_DR_CC_RESPONSE_CONTINUE
;
1077 if (nargs
!= 2 || nret
!= 1) {
1078 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
1082 wa_addr
= ((uint64_t)rtas_ld(args
, 1) << 32) | rtas_ld(args
, 0);
1084 drc_index
= rtas_ld(wa_addr
, 0);
1085 drc
= spapr_drc_by_index(drc_index
);
1087 trace_spapr_rtas_ibm_configure_connector_invalid(drc_index
);
1088 rc
= RTAS_OUT_PARAM_ERROR
;
1092 if ((drc
->state
!= SPAPR_DRC_STATE_LOGICAL_UNISOLATE
)
1093 && (drc
->state
!= SPAPR_DRC_STATE_PHYSICAL_UNISOLATE
)
1094 && (drc
->state
!= SPAPR_DRC_STATE_LOGICAL_CONFIGURED
)
1095 && (drc
->state
!= SPAPR_DRC_STATE_PHYSICAL_CONFIGURED
)) {
1097 * Need to unisolate the device before configuring
1098 * or it should already be in configured state to
1099 * allow configure-connector be called repeatedly.
1101 rc
= SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE
;
1105 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
1108 Error
*local_err
= NULL
;
1112 fdt
= create_device_tree(&fdt_size
);
1114 if (drck
->dt_populate(drc
, spapr
, fdt
, &drc
->fdt_start_offset
,
1117 error_free(local_err
);
1118 rc
= SPAPR_DR_CC_RESPONSE_ERROR
;
1123 drc
->ccs_offset
= drc
->fdt_start_offset
;
1130 const struct fdt_property
*prop
;
1131 int fdt_offset_next
, prop_len
;
1133 tag
= fdt_next_tag(drc
->fdt
, drc
->ccs_offset
, &fdt_offset_next
);
1136 case FDT_BEGIN_NODE
:
1138 name
= fdt_get_name(drc
->fdt
, drc
->ccs_offset
, NULL
);
1140 /* provide the name of the next OF node */
1141 wa_offset
= CC_VAL_DATA_OFFSET
;
1142 rtas_st(wa_addr
, CC_IDX_NODE_NAME_OFFSET
, wa_offset
);
1143 configure_connector_st(wa_addr
, wa_offset
, name
, strlen(name
) + 1);
1144 resp
= SPAPR_DR_CC_RESPONSE_NEXT_CHILD
;
1148 if (drc
->ccs_depth
== 0) {
1149 uint32_t drc_index
= spapr_drc_index(drc
);
1151 /* done sending the device tree, move to configured state */
1152 trace_spapr_drc_set_configured(drc_index
);
1153 drc
->state
= drck
->ready_state
;
1155 * Ensure that we are able to send the FDT fragment
1156 * again via configure-connector call if the guest requests.
1158 drc
->ccs_offset
= drc
->fdt_start_offset
;
1160 fdt_offset_next
= drc
->fdt_start_offset
;
1161 resp
= SPAPR_DR_CC_RESPONSE_SUCCESS
;
1163 resp
= SPAPR_DR_CC_RESPONSE_PREV_PARENT
;
1167 prop
= fdt_get_property_by_offset(drc
->fdt
, drc
->ccs_offset
,
1169 name
= fdt_string(drc
->fdt
, fdt32_to_cpu(prop
->nameoff
));
1171 /* provide the name of the next OF property */
1172 wa_offset
= CC_VAL_DATA_OFFSET
;
1173 rtas_st(wa_addr
, CC_IDX_PROP_NAME_OFFSET
, wa_offset
);
1174 configure_connector_st(wa_addr
, wa_offset
, name
, strlen(name
) + 1);
1176 /* provide the length and value of the OF property. data gets
1177 * placed immediately after NULL terminator of the OF property's
1180 wa_offset
+= strlen(name
) + 1,
1181 rtas_st(wa_addr
, CC_IDX_PROP_LEN
, prop_len
);
1182 rtas_st(wa_addr
, CC_IDX_PROP_DATA_OFFSET
, wa_offset
);
1183 configure_connector_st(wa_addr
, wa_offset
, prop
->data
, prop_len
);
1184 resp
= SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY
;
1187 resp
= SPAPR_DR_CC_RESPONSE_ERROR
;
1189 /* keep seeking for an actionable tag */
1192 if (drc
->ccs_offset
>= 0) {
1193 drc
->ccs_offset
= fdt_offset_next
;
1195 } while (resp
== SPAPR_DR_CC_RESPONSE_CONTINUE
);
1199 rtas_st(rets
, 0, rc
);
1202 static void spapr_drc_register_types(void)
1204 type_register_static(&spapr_dr_connector_info
);
1205 type_register_static(&spapr_drc_physical_info
);
1206 type_register_static(&spapr_drc_logical_info
);
1207 type_register_static(&spapr_drc_cpu_info
);
1208 type_register_static(&spapr_drc_pci_info
);
1209 type_register_static(&spapr_drc_lmb_info
);
1211 spapr_rtas_register(RTAS_SET_INDICATOR
, "set-indicator",
1212 rtas_set_indicator
);
1213 spapr_rtas_register(RTAS_GET_SENSOR_STATE
, "get-sensor-state",
1214 rtas_get_sensor_state
);
1215 spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR
, "ibm,configure-connector",
1216 rtas_ibm_configure_connector
);
1218 type_init(spapr_drc_register_types
)