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 "hw/ppc/spapr_drc.h"
14 #include "qom/object.h"
16 #include "qapi/visitor.h"
17 #include "qemu/error-report.h"
18 #include "hw/ppc/spapr.h" /* for RTAS return codes */
20 /* #define DEBUG_SPAPR_DRC */
22 #ifdef DEBUG_SPAPR_DRC
23 #define DPRINTF(fmt, ...) \
24 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
25 #define DPRINTFN(fmt, ...) \
26 do { DPRINTF(fmt, ## __VA_ARGS__); fprintf(stderr, "\n"); } while (0)
28 #define DPRINTF(fmt, ...) \
30 #define DPRINTFN(fmt, ...) \
34 #define DRC_CONTAINER_PATH "/dr-connector"
35 #define DRC_INDEX_TYPE_SHIFT 28
36 #define DRC_INDEX_ID_MASK ((1ULL << DRC_INDEX_TYPE_SHIFT) - 1)
38 static sPAPRDRConnectorTypeShift
get_type_shift(sPAPRDRConnectorType type
)
42 /* make sure this isn't SPAPR_DR_CONNECTOR_TYPE_ANY, or some
45 g_assert(is_power_of_2(type
));
47 while (type
!= (1 << shift
)) {
53 static uint32_t get_index(sPAPRDRConnector
*drc
)
55 /* no set format for a drc index: it only needs to be globally
56 * unique. this is how we encode the DRC type on bare-metal
57 * however, so might as well do that here
59 return (get_type_shift(drc
->type
) << DRC_INDEX_TYPE_SHIFT
) |
60 (drc
->id
& DRC_INDEX_ID_MASK
);
63 static uint32_t set_isolation_state(sPAPRDRConnector
*drc
,
64 sPAPRDRIsolationState state
)
66 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
68 DPRINTFN("drc: %x, set_isolation_state: %x", get_index(drc
), state
);
70 if (state
== SPAPR_DR_ISOLATION_STATE_UNISOLATED
) {
71 /* cannot unisolate a non-existant resource, and, or resources
72 * which are in an 'UNUSABLE' allocation state. (PAPR 2.7, 13.5.3.5)
75 drc
->allocation_state
== SPAPR_DR_ALLOCATION_STATE_UNUSABLE
) {
76 return RTAS_OUT_NO_SUCH_INDICATOR
;
80 drc
->isolation_state
= state
;
82 if (drc
->isolation_state
== SPAPR_DR_ISOLATION_STATE_ISOLATED
) {
83 /* if we're awaiting release, but still in an unconfigured state,
84 * it's likely the guest is still in the process of configuring
85 * the device and is transitioning the devices to an ISOLATED
86 * state as a part of that process. so we only complete the
87 * removal when this transition happens for a device in a
88 * configured state, as suggested by the state diagram from
91 if (drc
->awaiting_release
) {
92 if (drc
->configured
) {
93 DPRINTFN("finalizing device removal");
94 drck
->detach(drc
, DEVICE(drc
->dev
), drc
->detach_cb
,
95 drc
->detach_cb_opaque
, NULL
);
97 DPRINTFN("deferring device removal on unconfigured device\n");
100 drc
->configured
= false;
103 return RTAS_OUT_SUCCESS
;
106 static uint32_t set_indicator_state(sPAPRDRConnector
*drc
,
107 sPAPRDRIndicatorState state
)
109 DPRINTFN("drc: %x, set_indicator_state: %x", get_index(drc
), state
);
110 drc
->indicator_state
= state
;
111 return RTAS_OUT_SUCCESS
;
114 static uint32_t set_allocation_state(sPAPRDRConnector
*drc
,
115 sPAPRDRAllocationState state
)
117 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
119 DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc
), state
);
121 if (state
== SPAPR_DR_ALLOCATION_STATE_USABLE
) {
122 /* if there's no resource/device associated with the DRC, there's
123 * no way for us to put it in an allocation state consistent with
124 * being 'USABLE'. PAPR 2.7, 13.5.3.4 documents that this should
125 * result in an RTAS return code of -3 / "no such indicator"
128 return RTAS_OUT_NO_SUCH_INDICATOR
;
132 if (drc
->type
!= SPAPR_DR_CONNECTOR_TYPE_PCI
) {
133 drc
->allocation_state
= state
;
134 if (drc
->awaiting_release
&&
135 drc
->allocation_state
== SPAPR_DR_ALLOCATION_STATE_UNUSABLE
) {
136 DPRINTFN("finalizing device removal");
137 drck
->detach(drc
, DEVICE(drc
->dev
), drc
->detach_cb
,
138 drc
->detach_cb_opaque
, NULL
);
141 return RTAS_OUT_SUCCESS
;
144 static uint32_t get_type(sPAPRDRConnector
*drc
)
149 static const char *get_name(sPAPRDRConnector
*drc
)
154 static const void *get_fdt(sPAPRDRConnector
*drc
, int *fdt_start_offset
)
156 if (fdt_start_offset
) {
157 *fdt_start_offset
= drc
->fdt_start_offset
;
162 static void set_configured(sPAPRDRConnector
*drc
)
164 DPRINTFN("drc: %x, set_configured", get_index(drc
));
166 if (drc
->isolation_state
!= SPAPR_DR_ISOLATION_STATE_UNISOLATED
) {
167 /* guest should be not configuring an isolated device */
168 DPRINTFN("drc: %x, set_configured: skipping isolated device",
172 drc
->configured
= true;
176 * dr-entity-sense sensor value
177 * returned via get-sensor-state RTAS calls
178 * as expected by state diagram in PAPR+ 2.7, 13.4
179 * based on the current allocation/indicator/power states
180 * for the DR connector.
182 static uint32_t entity_sense(sPAPRDRConnector
*drc
, sPAPRDREntitySense
*state
)
185 if (drc
->type
!= SPAPR_DR_CONNECTOR_TYPE_PCI
&&
186 drc
->allocation_state
== SPAPR_DR_ALLOCATION_STATE_UNUSABLE
) {
187 /* for logical DR, we return a state of UNUSABLE
188 * iff the allocation state UNUSABLE.
189 * Otherwise, report the state as USABLE/PRESENT,
190 * as we would for PCI.
192 *state
= SPAPR_DR_ENTITY_SENSE_UNUSABLE
;
194 /* this assumes all PCI devices are assigned to
195 * a 'live insertion' power domain, where QEMU
196 * manages power state automatically as opposed
197 * to the guest. present, non-PCI resources are
198 * unaffected by power state.
200 *state
= SPAPR_DR_ENTITY_SENSE_PRESENT
;
203 if (drc
->type
== SPAPR_DR_CONNECTOR_TYPE_PCI
) {
204 /* PCI devices, and only PCI devices, use EMPTY
205 * in cases where we'd otherwise use UNUSABLE
207 *state
= SPAPR_DR_ENTITY_SENSE_EMPTY
;
209 *state
= SPAPR_DR_ENTITY_SENSE_UNUSABLE
;
213 DPRINTFN("drc: %x, entity_sense: %x", get_index(drc
), state
);
214 return RTAS_OUT_SUCCESS
;
217 static void prop_get_index(Object
*obj
, Visitor
*v
, void *opaque
,
218 const char *name
, Error
**errp
)
220 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
221 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
222 uint32_t value
= (uint32_t)drck
->get_index(drc
);
223 visit_type_uint32(v
, &value
, name
, errp
);
226 static void prop_get_type(Object
*obj
, Visitor
*v
, void *opaque
,
227 const char *name
, Error
**errp
)
229 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
230 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
231 uint32_t value
= (uint32_t)drck
->get_type(drc
);
232 visit_type_uint32(v
, &value
, name
, errp
);
235 static char *prop_get_name(Object
*obj
, Error
**errp
)
237 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
238 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
239 return g_strdup(drck
->get_name(drc
));
242 static void prop_get_entity_sense(Object
*obj
, Visitor
*v
, void *opaque
,
243 const char *name
, Error
**errp
)
245 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
246 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
249 drck
->entity_sense(drc
, &value
);
250 visit_type_uint32(v
, &value
, name
, errp
);
253 static void prop_get_fdt(Object
*obj
, Visitor
*v
, void *opaque
,
254 const char *name
, Error
**errp
)
256 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
258 int fdt_offset_next
, fdt_offset
, fdt_depth
;
262 visit_start_struct(v
, NULL
, NULL
, name
, 0, &err
);
264 visit_end_struct(v
, &err
);
266 error_propagate(errp
, err
);
271 fdt_offset
= drc
->fdt_start_offset
;
275 const char *name
= NULL
;
276 const struct fdt_property
*prop
= NULL
;
277 int prop_len
= 0, name_len
= 0;
280 tag
= fdt_next_tag(fdt
, fdt_offset
, &fdt_offset_next
);
284 name
= fdt_get_name(fdt
, fdt_offset
, &name_len
);
285 visit_start_struct(v
, NULL
, NULL
, name
, 0, &err
);
287 error_propagate(errp
, err
);
292 /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */
293 g_assert(fdt_depth
> 0);
294 visit_end_struct(v
, &err
);
296 error_propagate(errp
, err
);
303 prop
= fdt_get_property_by_offset(fdt
, fdt_offset
, &prop_len
);
304 name
= fdt_string(fdt
, fdt32_to_cpu(prop
->nameoff
));
305 visit_start_list(v
, name
, &err
);
307 error_propagate(errp
, err
);
310 for (i
= 0; i
< prop_len
; i
++) {
311 visit_type_uint8(v
, (uint8_t *)&prop
->data
[i
], NULL
, &err
);
313 error_propagate(errp
, err
);
317 visit_end_list(v
, &err
);
319 error_propagate(errp
, err
);
325 error_setg(&error_abort
, "device FDT in unexpected state: %d", tag
);
327 fdt_offset
= fdt_offset_next
;
328 } while (fdt_depth
!= 0);
331 static void attach(sPAPRDRConnector
*drc
, DeviceState
*d
, void *fdt
,
332 int fdt_start_offset
, bool coldplug
, Error
**errp
)
334 DPRINTFN("drc: %x, attach", get_index(drc
));
336 if (drc
->isolation_state
!= SPAPR_DR_ISOLATION_STATE_ISOLATED
) {
337 error_setg(errp
, "an attached device is still awaiting release");
340 if (drc
->type
== SPAPR_DR_CONNECTOR_TYPE_PCI
) {
341 g_assert(drc
->allocation_state
== SPAPR_DR_ALLOCATION_STATE_USABLE
);
343 g_assert(fdt
|| coldplug
);
345 /* NOTE: setting initial isolation state to UNISOLATED means we can't
346 * detach unless guest has a userspace/kernel that moves this state
347 * back to ISOLATED in response to an unplug event, or this is done
348 * manually by the admin prior. if we force things while the guest
349 * may be accessing the device, we can easily crash the guest, so we
350 * we defer completion of removal in such cases to the reset() hook.
352 if (drc
->type
== SPAPR_DR_CONNECTOR_TYPE_PCI
) {
353 drc
->isolation_state
= SPAPR_DR_ISOLATION_STATE_UNISOLATED
;
355 drc
->indicator_state
= SPAPR_DR_INDICATOR_STATE_ACTIVE
;
359 drc
->fdt_start_offset
= fdt_start_offset
;
360 drc
->configured
= coldplug
;
362 object_property_add_link(OBJECT(drc
), "device",
363 object_get_typename(OBJECT(drc
->dev
)),
364 (Object
**)(&drc
->dev
),
368 static void detach(sPAPRDRConnector
*drc
, DeviceState
*d
,
369 spapr_drc_detach_cb
*detach_cb
,
370 void *detach_cb_opaque
, Error
**errp
)
372 DPRINTFN("drc: %x, detach", get_index(drc
));
374 drc
->detach_cb
= detach_cb
;
375 drc
->detach_cb_opaque
= detach_cb_opaque
;
377 if (drc
->isolation_state
!= SPAPR_DR_ISOLATION_STATE_ISOLATED
) {
378 DPRINTFN("awaiting transition to isolated state before removal");
379 drc
->awaiting_release
= true;
383 if (drc
->type
!= SPAPR_DR_CONNECTOR_TYPE_PCI
&&
384 drc
->allocation_state
!= SPAPR_DR_ALLOCATION_STATE_UNUSABLE
) {
385 DPRINTFN("awaiting transition to unusable state before removal");
386 drc
->awaiting_release
= true;
390 drc
->indicator_state
= SPAPR_DR_INDICATOR_STATE_INACTIVE
;
392 if (drc
->detach_cb
) {
393 drc
->detach_cb(drc
->dev
, drc
->detach_cb_opaque
);
396 drc
->awaiting_release
= false;
399 drc
->fdt_start_offset
= 0;
400 object_property_del(OBJECT(drc
), "device", NULL
);
402 drc
->detach_cb
= NULL
;
403 drc
->detach_cb_opaque
= NULL
;
406 static bool release_pending(sPAPRDRConnector
*drc
)
408 return drc
->awaiting_release
;
411 static void reset(DeviceState
*d
)
413 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(d
);
414 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
416 DPRINTFN("drc reset: %x", drck
->get_index(drc
));
417 /* immediately upon reset we can safely assume DRCs whose devices
418 * are pending removal can be safely removed, and that they will
419 * subsequently be left in an ISOLATED state. move the DRC to this
420 * state in these cases (which will in turn complete any pending
423 if (drc
->awaiting_release
) {
424 drck
->set_isolation_state(drc
, SPAPR_DR_ISOLATION_STATE_ISOLATED
);
425 /* generally this should also finalize the removal, but if the device
426 * hasn't yet been configured we normally defer removal under the
427 * assumption that this transition is taking place as part of device
428 * configuration. so check if we're still waiting after this, and
429 * force removal if we are
431 if (drc
->awaiting_release
) {
432 drck
->detach(drc
, DEVICE(drc
->dev
), drc
->detach_cb
,
433 drc
->detach_cb_opaque
, NULL
);
436 /* non-PCI devices may be awaiting a transition to UNUSABLE */
437 if (drc
->type
!= SPAPR_DR_CONNECTOR_TYPE_PCI
&&
438 drc
->awaiting_release
) {
439 drck
->set_allocation_state(drc
, SPAPR_DR_ALLOCATION_STATE_UNUSABLE
);
444 static void realize(DeviceState
*d
, Error
**errp
)
446 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(d
);
447 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
448 Object
*root_container
;
453 DPRINTFN("drc realize: %x", drck
->get_index(drc
));
454 /* NOTE: we do this as part of realize/unrealize due to the fact
455 * that the guest will communicate with the DRC via RTAS calls
456 * referencing the global DRC index. By unlinking the DRC
457 * from DRC_CONTAINER_PATH/<drc_index> we effectively make it
458 * inaccessible by the guest, since lookups rely on this path
459 * existing in the composition tree
461 root_container
= container_get(object_get_root(), DRC_CONTAINER_PATH
);
462 snprintf(link_name
, sizeof(link_name
), "%x", drck
->get_index(drc
));
463 child_name
= object_get_canonical_path_component(OBJECT(drc
));
464 DPRINTFN("drc child name: %s", child_name
);
465 object_property_add_alias(root_container
, link_name
,
466 drc
->owner
, child_name
, &err
);
468 error_report("%s", error_get_pretty(err
));
470 object_unref(OBJECT(drc
));
473 DPRINTFN("drc realize complete");
476 static void unrealize(DeviceState
*d
, Error
**errp
)
478 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(d
);
479 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
480 Object
*root_container
;
484 DPRINTFN("drc unrealize: %x", drck
->get_index(drc
));
485 root_container
= container_get(object_get_root(), DRC_CONTAINER_PATH
);
486 snprintf(name
, sizeof(name
), "%x", drck
->get_index(drc
));
487 object_property_del(root_container
, name
, &err
);
489 error_report("%s", error_get_pretty(err
));
491 object_unref(OBJECT(drc
));
495 sPAPRDRConnector
*spapr_dr_connector_new(Object
*owner
,
496 sPAPRDRConnectorType type
,
499 sPAPRDRConnector
*drc
=
500 SPAPR_DR_CONNECTOR(object_new(TYPE_SPAPR_DR_CONNECTOR
));
508 prop_name
= g_strdup_printf("dr-connector[%"PRIu32
"]", get_index(drc
));
509 object_property_add_child(owner
, prop_name
, OBJECT(drc
), NULL
);
510 object_property_set_bool(OBJECT(drc
), true, "realized", NULL
);
513 /* human-readable name for a DRC to encode into the DT
514 * description. this is mainly only used within a guest in place
515 * of the unique DRC index.
517 * in the case of VIO/PCI devices, it corresponds to a
518 * "location code" that maps a logical device/function (DRC index)
519 * to a physical (or virtual in the case of VIO) location in the
520 * system by chaining together the "location label" for each
521 * encapsulating component.
523 * since this is more to do with diagnosing physical hardware
524 * issues than guest compatibility, we choose location codes/DRC
525 * names that adhere to the documented format, but avoid encoding
526 * the entire topology information into the label/code, instead
527 * just using the location codes based on the labels for the
528 * endpoints (VIO/PCI adaptor connectors), which is basically
529 * just "C" followed by an integer ID.
531 * DRC names as documented by PAPR+ v2.7, 13.5.2.4
532 * location codes as documented by PAPR+ v2.7, 12.3.1.5
535 case SPAPR_DR_CONNECTOR_TYPE_CPU
:
536 drc
->name
= g_strdup_printf("CPU %d", id
);
538 case SPAPR_DR_CONNECTOR_TYPE_PHB
:
539 drc
->name
= g_strdup_printf("PHB %d", id
);
541 case SPAPR_DR_CONNECTOR_TYPE_VIO
:
542 case SPAPR_DR_CONNECTOR_TYPE_PCI
:
543 drc
->name
= g_strdup_printf("C%d", id
);
545 case SPAPR_DR_CONNECTOR_TYPE_LMB
:
546 drc
->name
= g_strdup_printf("LMB %d", id
);
552 /* PCI slot always start in a USABLE state, and stay there */
553 if (drc
->type
== SPAPR_DR_CONNECTOR_TYPE_PCI
) {
554 drc
->allocation_state
= SPAPR_DR_ALLOCATION_STATE_USABLE
;
560 static void spapr_dr_connector_instance_init(Object
*obj
)
562 sPAPRDRConnector
*drc
= SPAPR_DR_CONNECTOR(obj
);
564 object_property_add_uint32_ptr(obj
, "isolation-state",
565 &drc
->isolation_state
, NULL
);
566 object_property_add_uint32_ptr(obj
, "indicator-state",
567 &drc
->indicator_state
, NULL
);
568 object_property_add_uint32_ptr(obj
, "allocation-state",
569 &drc
->allocation_state
, NULL
);
570 object_property_add_uint32_ptr(obj
, "id", &drc
->id
, NULL
);
571 object_property_add(obj
, "index", "uint32", prop_get_index
,
572 NULL
, NULL
, NULL
, NULL
);
573 object_property_add(obj
, "connector_type", "uint32", prop_get_type
,
574 NULL
, NULL
, NULL
, NULL
);
575 object_property_add_str(obj
, "name", prop_get_name
, NULL
, NULL
);
576 object_property_add(obj
, "entity-sense", "uint32", prop_get_entity_sense
,
577 NULL
, NULL
, NULL
, NULL
);
578 object_property_add(obj
, "fdt", "struct", prop_get_fdt
,
579 NULL
, NULL
, NULL
, NULL
);
582 static void spapr_dr_connector_class_init(ObjectClass
*k
, void *data
)
584 DeviceClass
*dk
= DEVICE_CLASS(k
);
585 sPAPRDRConnectorClass
*drck
= SPAPR_DR_CONNECTOR_CLASS(k
);
588 dk
->realize
= realize
;
589 dk
->unrealize
= unrealize
;
590 drck
->set_isolation_state
= set_isolation_state
;
591 drck
->set_indicator_state
= set_indicator_state
;
592 drck
->set_allocation_state
= set_allocation_state
;
593 drck
->get_index
= get_index
;
594 drck
->get_type
= get_type
;
595 drck
->get_name
= get_name
;
596 drck
->get_fdt
= get_fdt
;
597 drck
->set_configured
= set_configured
;
598 drck
->entity_sense
= entity_sense
;
599 drck
->attach
= attach
;
600 drck
->detach
= detach
;
601 drck
->release_pending
= release_pending
;
603 * Reason: it crashes FIXME find and document the real reason
605 dk
->cannot_instantiate_with_device_add_yet
= true;
608 static const TypeInfo spapr_dr_connector_info
= {
609 .name
= TYPE_SPAPR_DR_CONNECTOR
,
610 .parent
= TYPE_DEVICE
,
611 .instance_size
= sizeof(sPAPRDRConnector
),
612 .instance_init
= spapr_dr_connector_instance_init
,
613 .class_size
= sizeof(sPAPRDRConnectorClass
),
614 .class_init
= spapr_dr_connector_class_init
,
617 static void spapr_drc_register_types(void)
619 type_register_static(&spapr_dr_connector_info
);
622 type_init(spapr_drc_register_types
)
624 /* helper functions for external users */
626 sPAPRDRConnector
*spapr_dr_connector_by_index(uint32_t index
)
631 snprintf(name
, sizeof(name
), "%s/%x", DRC_CONTAINER_PATH
, index
);
632 obj
= object_resolve_path(name
, NULL
);
634 return !obj
? NULL
: SPAPR_DR_CONNECTOR(obj
);
637 sPAPRDRConnector
*spapr_dr_connector_by_id(sPAPRDRConnectorType type
,
640 return spapr_dr_connector_by_index(
641 (get_type_shift(type
) << DRC_INDEX_TYPE_SHIFT
) |
642 (id
& DRC_INDEX_ID_MASK
));
645 /* generate a string the describes the DRC to encode into the
648 * as documented by PAPR+ v2.7, 13.5.2.6 and C.6.1
650 static const char *spapr_drc_get_type_str(sPAPRDRConnectorType type
)
653 case SPAPR_DR_CONNECTOR_TYPE_CPU
:
655 case SPAPR_DR_CONNECTOR_TYPE_PHB
:
657 case SPAPR_DR_CONNECTOR_TYPE_VIO
:
659 case SPAPR_DR_CONNECTOR_TYPE_PCI
:
661 case SPAPR_DR_CONNECTOR_TYPE_LMB
:
671 * spapr_drc_populate_dt
673 * @fdt: libfdt device tree
674 * @path: path in the DT to generate properties
675 * @owner: parent Object/DeviceState for which to generate DRC
677 * @drc_type_mask: mask of sPAPRDRConnectorType values corresponding
678 * to the types of DRCs to generate entries for
680 * generate OF properties to describe DRC topology/indices to guests
682 * as documented in PAPR+ v2.1, 13.5.2
684 int spapr_drc_populate_dt(void *fdt
, int fdt_offset
, Object
*owner
,
685 uint32_t drc_type_mask
)
687 Object
*root_container
;
688 ObjectProperty
*prop
;
689 ObjectPropertyIterator
*iter
;
690 uint32_t drc_count
= 0;
691 GArray
*drc_indexes
, *drc_power_domains
;
692 GString
*drc_names
, *drc_types
;
695 /* the first entry of each properties is a 32-bit integer encoding
696 * the number of elements in the array. we won't know this until
697 * we complete the iteration through all the matching DRCs, but
698 * reserve the space now and set the offsets accordingly so we
699 * can fill them in later.
701 drc_indexes
= g_array_new(false, true, sizeof(uint32_t));
702 drc_indexes
= g_array_set_size(drc_indexes
, 1);
703 drc_power_domains
= g_array_new(false, true, sizeof(uint32_t));
704 drc_power_domains
= g_array_set_size(drc_power_domains
, 1);
705 drc_names
= g_string_set_size(g_string_new(NULL
), sizeof(uint32_t));
706 drc_types
= g_string_set_size(g_string_new(NULL
), sizeof(uint32_t));
708 /* aliases for all DRConnector objects will be rooted in QOM
709 * composition tree at DRC_CONTAINER_PATH
711 root_container
= container_get(object_get_root(), DRC_CONTAINER_PATH
);
713 iter
= object_property_iter_init(root_container
);
714 while ((prop
= object_property_iter_next(iter
))) {
716 sPAPRDRConnector
*drc
;
717 sPAPRDRConnectorClass
*drck
;
718 uint32_t drc_index
, drc_power_domain
;
720 if (!strstart(prop
->type
, "link<", NULL
)) {
724 obj
= object_property_get_link(root_container
, prop
->name
, NULL
);
725 drc
= SPAPR_DR_CONNECTOR(obj
);
726 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
728 if (owner
&& (drc
->owner
!= owner
)) {
732 if ((drc
->type
& drc_type_mask
) == 0) {
738 /* ibm,drc-indexes */
739 drc_index
= cpu_to_be32(drck
->get_index(drc
));
740 g_array_append_val(drc_indexes
, drc_index
);
742 /* ibm,drc-power-domains */
743 drc_power_domain
= cpu_to_be32(-1);
744 g_array_append_val(drc_power_domains
, drc_power_domain
);
747 drc_names
= g_string_append(drc_names
, drck
->get_name(drc
));
748 drc_names
= g_string_insert_len(drc_names
, -1, "\0", 1);
751 drc_types
= g_string_append(drc_types
,
752 spapr_drc_get_type_str(drc
->type
));
753 drc_types
= g_string_insert_len(drc_types
, -1, "\0", 1);
755 object_property_iter_free(iter
);
757 /* now write the drc count into the space we reserved at the
758 * beginning of the arrays previously
760 *(uint32_t *)drc_indexes
->data
= cpu_to_be32(drc_count
);
761 *(uint32_t *)drc_power_domains
->data
= cpu_to_be32(drc_count
);
762 *(uint32_t *)drc_names
->str
= cpu_to_be32(drc_count
);
763 *(uint32_t *)drc_types
->str
= cpu_to_be32(drc_count
);
765 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-indexes",
767 drc_indexes
->len
* sizeof(uint32_t));
769 fprintf(stderr
, "Couldn't create ibm,drc-indexes property\n");
773 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-power-domains",
774 drc_power_domains
->data
,
775 drc_power_domains
->len
* sizeof(uint32_t));
777 fprintf(stderr
, "Couldn't finalize ibm,drc-power-domains property\n");
781 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-names",
782 drc_names
->str
, drc_names
->len
);
784 fprintf(stderr
, "Couldn't finalize ibm,drc-names property\n");
788 ret
= fdt_setprop(fdt
, fdt_offset
, "ibm,drc-types",
789 drc_types
->str
, drc_types
->len
);
791 fprintf(stderr
, "Couldn't finalize ibm,drc-types property\n");
796 g_array_free(drc_indexes
, true);
797 g_array_free(drc_power_domains
, true);
798 g_string_free(drc_names
, true);
799 g_string_free(drc_types
, true);