xref: /openbmc/qemu/hw/ppc/spapr_drc.c (revision 078ddbc9)
1 /*
2  * QEMU SPAPR Dynamic Reconfiguration Connector Implementation
3  *
4  * Copyright IBM Corp. 2014
5  *
6  * Authors:
7  *  Michael Roth      <mdroth@linux.vnet.ibm.com>
8  *
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.
11  */
12 
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qapi/qmp/qnull.h"
16 #include "qemu/cutils.h"
17 #include "hw/ppc/spapr_drc.h"
18 #include "qom/object.h"
19 #include "migration/vmstate.h"
20 #include "qapi/qapi-events-qdev.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 "hw/ppc/spapr_nvdimm.h"
26 #include "sysemu/device_tree.h"
27 #include "sysemu/reset.h"
28 #include "trace.h"
29 
30 #define DRC_CONTAINER_PATH "/dr-connector"
31 #define DRC_INDEX_TYPE_SHIFT 28
32 #define DRC_INDEX_ID_MASK ((1ULL << DRC_INDEX_TYPE_SHIFT) - 1)
33 
spapr_drc_type(SpaprDrc * drc)34 SpaprDrcType spapr_drc_type(SpaprDrc *drc)
35 {
36     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
37 
38     return 1 << drck->typeshift;
39 }
40 
spapr_drc_index(SpaprDrc * drc)41 uint32_t spapr_drc_index(SpaprDrc *drc)
42 {
43     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
44 
45     /* no set format for a drc index: it only needs to be globally
46      * unique. this is how we encode the DRC type on bare-metal
47      * however, so might as well do that here
48      */
49     return (drck->typeshift << DRC_INDEX_TYPE_SHIFT)
50         | (drc->id & DRC_INDEX_ID_MASK);
51 }
52 
spapr_drc_release(SpaprDrc * drc)53 static void spapr_drc_release(SpaprDrc *drc)
54 {
55     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
56 
57     drck->release(drc->dev);
58 
59     drc->unplug_requested = false;
60     g_free(drc->fdt);
61     drc->fdt = NULL;
62     drc->fdt_start_offset = 0;
63     object_property_del(OBJECT(drc), "device");
64     drc->dev = NULL;
65 }
66 
drc_isolate_physical(SpaprDrc * drc)67 static uint32_t drc_isolate_physical(SpaprDrc *drc)
68 {
69     switch (drc->state) {
70     case SPAPR_DRC_STATE_PHYSICAL_POWERON:
71         return RTAS_OUT_SUCCESS; /* Nothing to do */
72     case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED:
73         break; /* see below */
74     case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE:
75         return RTAS_OUT_PARAM_ERROR; /* not allowed */
76     default:
77         g_assert_not_reached();
78     }
79 
80     drc->state = SPAPR_DRC_STATE_PHYSICAL_POWERON;
81 
82     if (drc->unplug_requested) {
83         uint32_t drc_index = spapr_drc_index(drc);
84         trace_spapr_drc_set_isolation_state_finalizing(drc_index);
85         spapr_drc_release(drc);
86     }
87 
88     return RTAS_OUT_SUCCESS;
89 }
90 
drc_unisolate_physical(SpaprDrc * drc)91 static uint32_t drc_unisolate_physical(SpaprDrc *drc)
92 {
93     switch (drc->state) {
94     case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE:
95     case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED:
96         return RTAS_OUT_SUCCESS; /* Nothing to do */
97     case SPAPR_DRC_STATE_PHYSICAL_POWERON:
98         break; /* see below */
99     default:
100         g_assert_not_reached();
101     }
102 
103     /* cannot unisolate a non-existent resource, and, or resources
104      * which are in an 'UNUSABLE' allocation state. (PAPR 2.7,
105      * 13.5.3.5)
106      */
107     if (!drc->dev) {
108         return RTAS_OUT_NO_SUCH_INDICATOR;
109     }
110 
111     drc->state = SPAPR_DRC_STATE_PHYSICAL_UNISOLATE;
112     drc->ccs_offset = drc->fdt_start_offset;
113     drc->ccs_depth = 0;
114 
115     return RTAS_OUT_SUCCESS;
116 }
117 
drc_isolate_logical(SpaprDrc * drc)118 static uint32_t drc_isolate_logical(SpaprDrc *drc)
119 {
120     switch (drc->state) {
121     case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
122     case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
123         return RTAS_OUT_SUCCESS; /* Nothing to do */
124     case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
125         break; /* see below */
126     case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
127         return RTAS_OUT_PARAM_ERROR; /* not allowed */
128     default:
129         g_assert_not_reached();
130     }
131 
132     /*
133      * Fail any requests to ISOLATE the LMB DRC if this LMB doesn't
134      * belong to a DIMM device that is marked for removal.
135      *
136      * Currently the guest userspace tool drmgr that drives the memory
137      * hotplug/unplug will just try to remove a set of 'removable' LMBs
138      * in response to a hot unplug request that is based on drc-count.
139      * If the LMB being removed doesn't belong to a DIMM device that is
140      * actually being unplugged, fail the isolation request here.
141      */
142     if (spapr_drc_type(drc) == SPAPR_DR_CONNECTOR_TYPE_LMB
143         && !drc->unplug_requested) {
144         return RTAS_OUT_HW_ERROR;
145     }
146 
147     drc->state = SPAPR_DRC_STATE_LOGICAL_AVAILABLE;
148 
149     return RTAS_OUT_SUCCESS;
150 }
151 
drc_unisolate_logical(SpaprDrc * drc)152 static uint32_t drc_unisolate_logical(SpaprDrc *drc)
153 {
154     SpaprMachineState *spapr = NULL;
155 
156     switch (drc->state) {
157     case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
158     case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
159         /*
160          * Unisolating a logical DRC that was marked for unplug
161          * means that the kernel is refusing the removal.
162          */
163         if (drc->unplug_requested && drc->dev) {
164             if (spapr_drc_type(drc) == SPAPR_DR_CONNECTOR_TYPE_LMB) {
165                 spapr = SPAPR_MACHINE(qdev_get_machine());
166 
167                 spapr_memory_unplug_rollback(spapr, drc->dev);
168             }
169 
170             drc->unplug_requested = false;
171 
172             if (drc->dev->id) {
173                 error_report("Device hotunplug rejected by the guest "
174                              "for device %s", drc->dev->id);
175             }
176 
177             qapi_event_send_device_unplug_guest_error(drc->dev->id,
178                                                       drc->dev->canonical_path);
179         }
180 
181         return RTAS_OUT_SUCCESS; /* Nothing to do */
182     case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
183         break; /* see below */
184     case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
185         return RTAS_OUT_NO_SUCH_INDICATOR; /* not allowed */
186     default:
187         g_assert_not_reached();
188     }
189 
190     /* Move to AVAILABLE state should have ensured device was present */
191     g_assert(drc->dev);
192 
193     drc->state = SPAPR_DRC_STATE_LOGICAL_UNISOLATE;
194     drc->ccs_offset = drc->fdt_start_offset;
195     drc->ccs_depth = 0;
196 
197     return RTAS_OUT_SUCCESS;
198 }
199 
drc_set_usable(SpaprDrc * drc)200 static uint32_t drc_set_usable(SpaprDrc *drc)
201 {
202     switch (drc->state) {
203     case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
204     case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
205     case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
206         return RTAS_OUT_SUCCESS; /* Nothing to do */
207     case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
208         break; /* see below */
209     default:
210         g_assert_not_reached();
211     }
212 
213     /* if there's no resource/device associated with the DRC, there's
214      * no way for us to put it in an allocation state consistent with
215      * being 'USABLE'. PAPR 2.7, 13.5.3.4 documents that this should
216      * result in an RTAS return code of -3 / "no such indicator"
217      */
218     if (!drc->dev) {
219         return RTAS_OUT_NO_SUCH_INDICATOR;
220     }
221     if (drc->unplug_requested) {
222         /* Don't allow the guest to move a device away from UNUSABLE
223          * state when we want to unplug it */
224         return RTAS_OUT_NO_SUCH_INDICATOR;
225     }
226 
227     drc->state = SPAPR_DRC_STATE_LOGICAL_AVAILABLE;
228 
229     return RTAS_OUT_SUCCESS;
230 }
231 
drc_set_unusable(SpaprDrc * drc)232 static uint32_t drc_set_unusable(SpaprDrc *drc)
233 {
234     switch (drc->state) {
235     case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
236         return RTAS_OUT_SUCCESS; /* Nothing to do */
237     case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
238         break; /* see below */
239     case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
240     case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
241         return RTAS_OUT_NO_SUCH_INDICATOR; /* not allowed */
242     default:
243         g_assert_not_reached();
244     }
245 
246     drc->state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE;
247     if (drc->unplug_requested) {
248         uint32_t drc_index = spapr_drc_index(drc);
249         trace_spapr_drc_set_allocation_state_finalizing(drc_index);
250         spapr_drc_release(drc);
251     }
252 
253     return RTAS_OUT_SUCCESS;
254 }
255 
spapr_drc_name(SpaprDrc * drc)256 static char *spapr_drc_name(SpaprDrc *drc)
257 {
258     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
259 
260     /* human-readable name for a DRC to encode into the DT
261      * description. this is mainly only used within a guest in place
262      * of the unique DRC index.
263      *
264      * in the case of VIO/PCI devices, it corresponds to a "location
265      * code" that maps a logical device/function (DRC index) to a
266      * physical (or virtual in the case of VIO) location in the system
267      * by chaining together the "location label" for each
268      * encapsulating component.
269      *
270      * since this is more to do with diagnosing physical hardware
271      * issues than guest compatibility, we choose location codes/DRC
272      * names that adhere to the documented format, but avoid encoding
273      * the entire topology information into the label/code, instead
274      * just using the location codes based on the labels for the
275      * endpoints (VIO/PCI adaptor connectors), which is basically just
276      * "C" followed by an integer ID.
277      *
278      * DRC names as documented by PAPR+ v2.7, 13.5.2.4
279      * location codes as documented by PAPR+ v2.7, 12.3.1.5
280      */
281     return g_strdup_printf("%s%d", drck->drc_name_prefix, drc->id);
282 }
283 
284 /*
285  * dr-entity-sense sensor value
286  * returned via get-sensor-state RTAS calls
287  * as expected by state diagram in PAPR+ 2.7, 13.4
288  * based on the current allocation/indicator/power states
289  * for the DR connector.
290  */
physical_entity_sense(SpaprDrc * drc)291 static SpaprDREntitySense physical_entity_sense(SpaprDrc *drc)
292 {
293     /* this assumes all PCI devices are assigned to a 'live insertion'
294      * power domain, where QEMU manages power state automatically as
295      * opposed to the guest. present, non-PCI resources are unaffected
296      * by power state.
297      */
298     return drc->dev ? SPAPR_DR_ENTITY_SENSE_PRESENT
299         : SPAPR_DR_ENTITY_SENSE_EMPTY;
300 }
301 
logical_entity_sense(SpaprDrc * drc)302 static SpaprDREntitySense logical_entity_sense(SpaprDrc *drc)
303 {
304     switch (drc->state) {
305     case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
306         return SPAPR_DR_ENTITY_SENSE_UNUSABLE;
307     case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
308     case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
309     case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
310         g_assert(drc->dev);
311         return SPAPR_DR_ENTITY_SENSE_PRESENT;
312     default:
313         g_assert_not_reached();
314     }
315 }
316 
prop_get_index(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)317 static void prop_get_index(Object *obj, Visitor *v, const char *name,
318                            void *opaque, Error **errp)
319 {
320     SpaprDrc *drc = SPAPR_DR_CONNECTOR(obj);
321     uint32_t value = spapr_drc_index(drc);
322     visit_type_uint32(v, name, &value, errp);
323 }
324 
prop_get_fdt(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)325 static void prop_get_fdt(Object *obj, Visitor *v, const char *name,
326                          void *opaque, Error **errp)
327 {
328     SpaprDrc *drc = SPAPR_DR_CONNECTOR(obj);
329     QNull *null = NULL;
330     int fdt_offset_next, fdt_offset, fdt_depth;
331     void *fdt;
332 
333     if (!drc->fdt) {
334         visit_type_null(v, NULL, &null, errp);
335         qobject_unref(null);
336         return;
337     }
338 
339     fdt = drc->fdt;
340     fdt_offset = drc->fdt_start_offset;
341     fdt_depth = 0;
342 
343     do {
344         const char *dt_name = NULL;
345         const struct fdt_property *prop = NULL;
346         int prop_len = 0, name_len = 0;
347         uint32_t tag;
348         bool ok;
349 
350         tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next);
351         switch (tag) {
352         case FDT_BEGIN_NODE:
353             fdt_depth++;
354             dt_name = fdt_get_name(fdt, fdt_offset, &name_len);
355             if (!visit_start_struct(v, dt_name, NULL, 0, errp)) {
356                 return;
357             }
358             break;
359         case FDT_END_NODE:
360             /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */
361             g_assert(fdt_depth > 0);
362             ok = visit_check_struct(v, errp);
363             visit_end_struct(v, NULL);
364             if (!ok) {
365                 return;
366             }
367             fdt_depth--;
368             break;
369         case FDT_PROP: {
370             int i;
371             prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len);
372             dt_name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
373             if (!visit_start_list(v, dt_name, NULL, 0, errp)) {
374                 return;
375             }
376             for (i = 0; i < prop_len; i++) {
377                 if (!visit_type_uint8(v, NULL, (uint8_t *)&prop->data[i],
378                                       errp)) {
379                     return;
380                 }
381             }
382             ok = visit_check_list(v, errp);
383             visit_end_list(v, NULL);
384             if (!ok) {
385                 return;
386             }
387             break;
388         }
389         default:
390             error_report("device FDT in unexpected state: %d", tag);
391             abort();
392         }
393         fdt_offset = fdt_offset_next;
394     } while (fdt_depth != 0);
395 }
396 
spapr_drc_attach(SpaprDrc * drc,DeviceState * d)397 void spapr_drc_attach(SpaprDrc *drc, DeviceState *d)
398 {
399     trace_spapr_drc_attach(spapr_drc_index(drc));
400 
401     g_assert(!drc->dev);
402     g_assert((drc->state == SPAPR_DRC_STATE_LOGICAL_UNUSABLE)
403              || (drc->state == SPAPR_DRC_STATE_PHYSICAL_POWERON));
404 
405     drc->dev = d;
406 
407     object_property_add_link(OBJECT(drc), "device",
408                              object_get_typename(OBJECT(drc->dev)),
409                              (Object **)(&drc->dev),
410                              NULL, 0);
411 }
412 
spapr_drc_unplug_request(SpaprDrc * drc)413 void spapr_drc_unplug_request(SpaprDrc *drc)
414 {
415     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
416 
417     trace_spapr_drc_unplug_request(spapr_drc_index(drc));
418 
419     g_assert(drc->dev);
420 
421     drc->unplug_requested = true;
422 
423     if (drc->state != drck->empty_state) {
424         trace_spapr_drc_awaiting_quiesce(spapr_drc_index(drc));
425         return;
426     }
427 
428     spapr_drc_release(drc);
429 }
430 
spapr_drc_reset(SpaprDrc * drc)431 bool spapr_drc_reset(SpaprDrc *drc)
432 {
433     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
434     bool unplug_completed = false;
435 
436     trace_spapr_drc_reset(spapr_drc_index(drc));
437 
438     /* immediately upon reset we can safely assume DRCs whose devices
439      * are pending removal can be safely removed.
440      */
441     if (drc->unplug_requested) {
442         spapr_drc_release(drc);
443         unplug_completed = true;
444     }
445 
446     if (drc->dev) {
447         /* A device present at reset is ready to go, same as coldplugged */
448         drc->state = drck->ready_state;
449         /*
450          * Ensure that we are able to send the FDT fragment again
451          * via configure-connector call if the guest requests.
452          */
453         drc->ccs_offset = drc->fdt_start_offset;
454         drc->ccs_depth = 0;
455     } else {
456         drc->state = drck->empty_state;
457         drc->ccs_offset = -1;
458         drc->ccs_depth = -1;
459     }
460 
461     return unplug_completed;
462 }
463 
spapr_drc_unplug_requested_needed(void * opaque)464 static bool spapr_drc_unplug_requested_needed(void *opaque)
465 {
466     return spapr_drc_unplug_requested(opaque);
467 }
468 
469 static const VMStateDescription vmstate_spapr_drc_unplug_requested = {
470     .name = "spapr_drc/unplug_requested",
471     .version_id = 1,
472     .minimum_version_id = 1,
473     .needed = spapr_drc_unplug_requested_needed,
474     .fields  = (const VMStateField []) {
475         VMSTATE_BOOL(unplug_requested, SpaprDrc),
476         VMSTATE_END_OF_LIST()
477     }
478 };
479 
spapr_drc_needed(void * opaque)480 static bool spapr_drc_needed(void *opaque)
481 {
482     SpaprDrc *drc = opaque;
483     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
484 
485     /*
486      * If no dev is plugged in there is no need to migrate the DRC state
487      * nor to reset the DRC at CAS.
488      */
489     if (!drc->dev) {
490         return false;
491     }
492 
493     /*
494      * We need to reset the DRC at CAS or to migrate the DRC state if it's
495      * not equal to the expected long-term state, which is the same as the
496      * coldplugged initial state, or if an unplug request is pending.
497      */
498     return drc->state != drck->ready_state ||
499         spapr_drc_unplug_requested(drc);
500 }
501 
502 static const VMStateDescription vmstate_spapr_drc = {
503     .name = "spapr_drc",
504     .version_id = 1,
505     .minimum_version_id = 1,
506     .needed = spapr_drc_needed,
507     .fields  = (const VMStateField []) {
508         VMSTATE_UINT32(state, SpaprDrc),
509         VMSTATE_END_OF_LIST()
510     },
511     .subsections = (const VMStateDescription * const []) {
512         &vmstate_spapr_drc_unplug_requested,
513         NULL
514     }
515 };
516 
drc_realize(DeviceState * d,Error ** errp)517 static void drc_realize(DeviceState *d, Error **errp)
518 {
519     SpaprDrc *drc = SPAPR_DR_CONNECTOR(d);
520     g_autofree gchar *link_name = g_strdup_printf("%x", spapr_drc_index(drc));
521     Object *root_container;
522     const char *child_name;
523 
524     trace_spapr_drc_realize(spapr_drc_index(drc));
525     /* NOTE: we do this as part of realize/unrealize due to the fact
526      * that the guest will communicate with the DRC via RTAS calls
527      * referencing the global DRC index. By unlinking the DRC
528      * from DRC_CONTAINER_PATH/<drc_index> we effectively make it
529      * inaccessible by the guest, since lookups rely on this path
530      * existing in the composition tree
531      */
532     root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
533     child_name = object_get_canonical_path_component(OBJECT(drc));
534     trace_spapr_drc_realize_child(spapr_drc_index(drc), child_name);
535     object_property_add_alias(root_container, link_name,
536                               drc->owner, child_name);
537     vmstate_register(VMSTATE_IF(drc), spapr_drc_index(drc), &vmstate_spapr_drc,
538                      drc);
539     trace_spapr_drc_realize_complete(spapr_drc_index(drc));
540 }
541 
drc_unrealize(DeviceState * d)542 static void drc_unrealize(DeviceState *d)
543 {
544     SpaprDrc *drc = SPAPR_DR_CONNECTOR(d);
545     g_autofree gchar *name = g_strdup_printf("%x", spapr_drc_index(drc));
546     Object *root_container;
547 
548     trace_spapr_drc_unrealize(spapr_drc_index(drc));
549     vmstate_unregister(VMSTATE_IF(drc), &vmstate_spapr_drc, drc);
550     root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
551     object_property_del(root_container, name);
552 }
553 
spapr_dr_connector_new(Object * owner,const char * type,uint32_t id)554 SpaprDrc *spapr_dr_connector_new(Object *owner, const char *type,
555                                          uint32_t id)
556 {
557     SpaprDrc *drc = SPAPR_DR_CONNECTOR(object_new(type));
558     g_autofree char *prop_name = NULL;
559 
560     drc->id = id;
561     drc->owner = owner;
562     prop_name = g_strdup_printf("dr-connector[%"PRIu32"]",
563                                 spapr_drc_index(drc));
564     object_property_add_child(owner, prop_name, OBJECT(drc));
565     object_unref(OBJECT(drc));
566     qdev_realize(DEVICE(drc), NULL, NULL);
567 
568     return drc;
569 }
570 
spapr_dr_connector_instance_init(Object * obj)571 static void spapr_dr_connector_instance_init(Object *obj)
572 {
573     SpaprDrc *drc = SPAPR_DR_CONNECTOR(obj);
574     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
575 
576     object_property_add_uint32_ptr(obj, "id", &drc->id, OBJ_PROP_FLAG_READ);
577     object_property_add(obj, "index", "uint32", prop_get_index,
578                         NULL, NULL, NULL);
579     object_property_add(obj, "fdt", "struct", prop_get_fdt,
580                         NULL, NULL, NULL);
581     drc->state = drck->empty_state;
582 }
583 
spapr_dr_connector_class_init(ObjectClass * k,void * data)584 static void spapr_dr_connector_class_init(ObjectClass *k, void *data)
585 {
586     DeviceClass *dk = DEVICE_CLASS(k);
587 
588     dk->realize = drc_realize;
589     dk->unrealize = drc_unrealize;
590     /*
591      * Reason: DR connector needs to be wired to either the machine or to a
592      * PHB in spapr_dr_connector_new().
593      */
594     dk->user_creatable = false;
595 }
596 
drc_physical_needed(void * opaque)597 static bool drc_physical_needed(void *opaque)
598 {
599     SpaprDrcPhysical *drcp = (SpaprDrcPhysical *)opaque;
600     SpaprDrc *drc = SPAPR_DR_CONNECTOR(drcp);
601 
602     if ((drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_ACTIVE))
603         || (!drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_INACTIVE))) {
604         return false;
605     }
606     return true;
607 }
608 
609 static const VMStateDescription vmstate_spapr_drc_physical = {
610     .name = "spapr_drc/physical",
611     .version_id = 1,
612     .minimum_version_id = 1,
613     .needed = drc_physical_needed,
614     .fields  = (const VMStateField []) {
615         VMSTATE_UINT32(dr_indicator, SpaprDrcPhysical),
616         VMSTATE_END_OF_LIST()
617     }
618 };
619 
drc_physical_reset(void * opaque)620 static void drc_physical_reset(void *opaque)
621 {
622     SpaprDrc *drc = SPAPR_DR_CONNECTOR(opaque);
623     SpaprDrcPhysical *drcp = SPAPR_DRC_PHYSICAL(drc);
624 
625     if (drc->dev) {
626         drcp->dr_indicator = SPAPR_DR_INDICATOR_ACTIVE;
627     } else {
628         drcp->dr_indicator = SPAPR_DR_INDICATOR_INACTIVE;
629     }
630 }
631 
realize_physical(DeviceState * d,Error ** errp)632 static void realize_physical(DeviceState *d, Error **errp)
633 {
634     SpaprDrcPhysical *drcp = SPAPR_DRC_PHYSICAL(d);
635     Error *local_err = NULL;
636 
637     drc_realize(d, &local_err);
638     if (local_err) {
639         error_propagate(errp, local_err);
640         return;
641     }
642 
643     vmstate_register(VMSTATE_IF(drcp),
644                      spapr_drc_index(SPAPR_DR_CONNECTOR(drcp)),
645                      &vmstate_spapr_drc_physical, drcp);
646     qemu_register_reset(drc_physical_reset, drcp);
647 }
648 
unrealize_physical(DeviceState * d)649 static void unrealize_physical(DeviceState *d)
650 {
651     SpaprDrcPhysical *drcp = SPAPR_DRC_PHYSICAL(d);
652 
653     drc_unrealize(d);
654     vmstate_unregister(VMSTATE_IF(drcp), &vmstate_spapr_drc_physical, drcp);
655     qemu_unregister_reset(drc_physical_reset, drcp);
656 }
657 
spapr_drc_physical_class_init(ObjectClass * k,void * data)658 static void spapr_drc_physical_class_init(ObjectClass *k, void *data)
659 {
660     DeviceClass *dk = DEVICE_CLASS(k);
661     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
662 
663     dk->realize = realize_physical;
664     dk->unrealize = unrealize_physical;
665     drck->dr_entity_sense = physical_entity_sense;
666     drck->isolate = drc_isolate_physical;
667     drck->unisolate = drc_unisolate_physical;
668     drck->ready_state = SPAPR_DRC_STATE_PHYSICAL_CONFIGURED;
669     drck->empty_state = SPAPR_DRC_STATE_PHYSICAL_POWERON;
670 }
671 
spapr_drc_logical_class_init(ObjectClass * k,void * data)672 static void spapr_drc_logical_class_init(ObjectClass *k, void *data)
673 {
674     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
675 
676     drck->dr_entity_sense = logical_entity_sense;
677     drck->isolate = drc_isolate_logical;
678     drck->unisolate = drc_unisolate_logical;
679     drck->ready_state = SPAPR_DRC_STATE_LOGICAL_CONFIGURED;
680     drck->empty_state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE;
681 }
682 
spapr_drc_cpu_class_init(ObjectClass * k,void * data)683 static void spapr_drc_cpu_class_init(ObjectClass *k, void *data)
684 {
685     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
686 
687     drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU;
688     drck->typename = "CPU";
689     drck->drc_name_prefix = "CPU ";
690     drck->release = spapr_core_release;
691     drck->dt_populate = spapr_core_dt_populate;
692 }
693 
spapr_drc_pci_class_init(ObjectClass * k,void * data)694 static void spapr_drc_pci_class_init(ObjectClass *k, void *data)
695 {
696     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
697 
698     drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI;
699     drck->typename = "28";
700     drck->drc_name_prefix = "C";
701     drck->release = spapr_phb_remove_pci_device_cb;
702     drck->dt_populate = spapr_pci_dt_populate;
703 }
704 
spapr_drc_lmb_class_init(ObjectClass * k,void * data)705 static void spapr_drc_lmb_class_init(ObjectClass *k, void *data)
706 {
707     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
708 
709     drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB;
710     drck->typename = "MEM";
711     drck->drc_name_prefix = "LMB ";
712     drck->release = spapr_lmb_release;
713     drck->dt_populate = spapr_lmb_dt_populate;
714 }
715 
spapr_drc_phb_class_init(ObjectClass * k,void * data)716 static void spapr_drc_phb_class_init(ObjectClass *k, void *data)
717 {
718     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
719 
720     drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PHB;
721     drck->typename = "PHB";
722     drck->drc_name_prefix = "PHB ";
723     drck->release = spapr_phb_release;
724     drck->dt_populate = spapr_phb_dt_populate;
725 }
726 
spapr_drc_pmem_class_init(ObjectClass * k,void * data)727 static void spapr_drc_pmem_class_init(ObjectClass *k, void *data)
728 {
729     SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
730 
731     drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PMEM;
732     drck->typename = "PMEM";
733     drck->drc_name_prefix = "PMEM ";
734     drck->release = NULL;
735     drck->dt_populate = spapr_pmem_dt_populate;
736 }
737 
738 static const TypeInfo spapr_dr_connector_info = {
739     .name          = TYPE_SPAPR_DR_CONNECTOR,
740     .parent        = TYPE_DEVICE,
741     .instance_size = sizeof(SpaprDrc),
742     .instance_init = spapr_dr_connector_instance_init,
743     .class_size    = sizeof(SpaprDrcClass),
744     .class_init    = spapr_dr_connector_class_init,
745     .abstract      = true,
746 };
747 
748 static const TypeInfo spapr_drc_physical_info = {
749     .name          = TYPE_SPAPR_DRC_PHYSICAL,
750     .parent        = TYPE_SPAPR_DR_CONNECTOR,
751     .instance_size = sizeof(SpaprDrcPhysical),
752     .class_init    = spapr_drc_physical_class_init,
753     .abstract      = true,
754 };
755 
756 static const TypeInfo spapr_drc_logical_info = {
757     .name          = TYPE_SPAPR_DRC_LOGICAL,
758     .parent        = TYPE_SPAPR_DR_CONNECTOR,
759     .class_init    = spapr_drc_logical_class_init,
760     .abstract      = true,
761 };
762 
763 static const TypeInfo spapr_drc_cpu_info = {
764     .name          = TYPE_SPAPR_DRC_CPU,
765     .parent        = TYPE_SPAPR_DRC_LOGICAL,
766     .class_init    = spapr_drc_cpu_class_init,
767 };
768 
769 static const TypeInfo spapr_drc_pci_info = {
770     .name          = TYPE_SPAPR_DRC_PCI,
771     .parent        = TYPE_SPAPR_DRC_PHYSICAL,
772     .class_init    = spapr_drc_pci_class_init,
773 };
774 
775 static const TypeInfo spapr_drc_lmb_info = {
776     .name          = TYPE_SPAPR_DRC_LMB,
777     .parent        = TYPE_SPAPR_DRC_LOGICAL,
778     .class_init    = spapr_drc_lmb_class_init,
779 };
780 
781 static const TypeInfo spapr_drc_phb_info = {
782     .name          = TYPE_SPAPR_DRC_PHB,
783     .parent        = TYPE_SPAPR_DRC_LOGICAL,
784     .instance_size = sizeof(SpaprDrc),
785     .class_init    = spapr_drc_phb_class_init,
786 };
787 
788 static const TypeInfo spapr_drc_pmem_info = {
789     .name          = TYPE_SPAPR_DRC_PMEM,
790     .parent        = TYPE_SPAPR_DRC_LOGICAL,
791     .class_init    = spapr_drc_pmem_class_init,
792 };
793 
794 /* helper functions for external users */
795 
spapr_drc_by_index(uint32_t index)796 SpaprDrc *spapr_drc_by_index(uint32_t index)
797 {
798     Object *obj;
799     g_autofree gchar *name = g_strdup_printf("%s/%x", DRC_CONTAINER_PATH,
800                                              index);
801     obj = object_resolve_path(name, NULL);
802 
803     return !obj ? NULL : SPAPR_DR_CONNECTOR(obj);
804 }
805 
spapr_drc_by_id(const char * type,uint32_t id)806 SpaprDrc *spapr_drc_by_id(const char *type, uint32_t id)
807 {
808     SpaprDrcClass *drck
809         = SPAPR_DR_CONNECTOR_CLASS(object_class_by_name(type));
810 
811     return spapr_drc_by_index(drck->typeshift << DRC_INDEX_TYPE_SHIFT
812                               | (id & DRC_INDEX_ID_MASK));
813 }
814 
815 /**
816  * spapr_dt_drc
817  *
818  * @fdt: libfdt device tree
819  * @path: path in the DT to generate properties
820  * @owner: parent Object/DeviceState for which to generate DRC
821  *         descriptions for
822  * @drc_type_mask: mask of SpaprDrcType values corresponding
823  *   to the types of DRCs to generate entries for
824  *
825  * generate OF properties to describe DRC topology/indices to guests
826  *
827  * as documented in PAPR+ v2.1, 13.5.2
828  */
spapr_dt_drc(void * fdt,int offset,Object * owner,uint32_t drc_type_mask)829 int spapr_dt_drc(void *fdt, int offset, Object *owner, uint32_t drc_type_mask)
830 {
831     Object *root_container;
832     ObjectProperty *prop;
833     ObjectPropertyIterator iter;
834     uint32_t drc_count = 0;
835     g_autoptr(GArray) drc_indexes = g_array_new(false, true,
836                                                 sizeof(uint32_t));
837     g_autoptr(GArray) drc_power_domains = g_array_new(false, true,
838                                                       sizeof(uint32_t));
839     g_autoptr(GString) drc_names = g_string_set_size(g_string_new(NULL),
840                                                      sizeof(uint32_t));
841     g_autoptr(GString) drc_types = g_string_set_size(g_string_new(NULL),
842                                                      sizeof(uint32_t));
843     int ret;
844 
845     /*
846      * This should really be only called once per node since it overwrites
847      * the OF properties if they already exist.
848      */
849     g_assert(!fdt_get_property(fdt, offset, "ibm,drc-indexes", NULL));
850 
851     /* the first entry of each properties is a 32-bit integer encoding
852      * the number of elements in the array. we won't know this until
853      * we complete the iteration through all the matching DRCs, but
854      * reserve the space now and set the offsets accordingly so we
855      * can fill them in later.
856      */
857     drc_indexes = g_array_set_size(drc_indexes, 1);
858     drc_power_domains = g_array_set_size(drc_power_domains, 1);
859 
860     /* aliases for all DRConnector objects will be rooted in QOM
861      * composition tree at DRC_CONTAINER_PATH
862      */
863     root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
864 
865     object_property_iter_init(&iter, root_container);
866     while ((prop = object_property_iter_next(&iter))) {
867         Object *obj;
868         SpaprDrc *drc;
869         SpaprDrcClass *drck;
870         g_autofree char *drc_name = NULL;
871         uint32_t drc_index, drc_power_domain;
872 
873         if (!strstart(prop->type, "link<", NULL)) {
874             continue;
875         }
876 
877         obj = object_property_get_link(root_container, prop->name,
878                                        &error_abort);
879         drc = SPAPR_DR_CONNECTOR(obj);
880         drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
881 
882         if (owner && (drc->owner != owner)) {
883             continue;
884         }
885 
886         if ((spapr_drc_type(drc) & drc_type_mask) == 0) {
887             continue;
888         }
889 
890         drc_count++;
891 
892         /* ibm,drc-indexes */
893         drc_index = cpu_to_be32(spapr_drc_index(drc));
894         g_array_append_val(drc_indexes, drc_index);
895 
896         /* ibm,drc-power-domains */
897         drc_power_domain = cpu_to_be32(-1);
898         g_array_append_val(drc_power_domains, drc_power_domain);
899 
900         /* ibm,drc-names */
901         drc_name = spapr_drc_name(drc);
902         drc_names = g_string_append(drc_names, drc_name);
903         drc_names = g_string_insert_len(drc_names, -1, "\0", 1);
904 
905         /* ibm,drc-types */
906         drc_types = g_string_append(drc_types, drck->typename);
907         drc_types = g_string_insert_len(drc_types, -1, "\0", 1);
908     }
909 
910     /* now write the drc count into the space we reserved at the
911      * beginning of the arrays previously
912      */
913     *(uint32_t *)drc_indexes->data = cpu_to_be32(drc_count);
914     *(uint32_t *)drc_power_domains->data = cpu_to_be32(drc_count);
915     *(uint32_t *)drc_names->str = cpu_to_be32(drc_count);
916     *(uint32_t *)drc_types->str = cpu_to_be32(drc_count);
917 
918     ret = fdt_setprop(fdt, offset, "ibm,drc-indexes",
919                       drc_indexes->data,
920                       drc_indexes->len * sizeof(uint32_t));
921     if (ret) {
922         error_report("Couldn't create ibm,drc-indexes property");
923         return ret;
924     }
925 
926     ret = fdt_setprop(fdt, offset, "ibm,drc-power-domains",
927                       drc_power_domains->data,
928                       drc_power_domains->len * sizeof(uint32_t));
929     if (ret) {
930         error_report("Couldn't finalize ibm,drc-power-domains property");
931         return ret;
932     }
933 
934     ret = fdt_setprop(fdt, offset, "ibm,drc-names",
935                       drc_names->str, drc_names->len);
936     if (ret) {
937         error_report("Couldn't finalize ibm,drc-names property");
938         return ret;
939     }
940 
941     ret = fdt_setprop(fdt, offset, "ibm,drc-types",
942                       drc_types->str, drc_types->len);
943     if (ret) {
944         error_report("Couldn't finalize ibm,drc-types property");
945     }
946 
947     return ret;
948 }
949 
spapr_drc_reset_all(SpaprMachineState * spapr)950 void spapr_drc_reset_all(SpaprMachineState *spapr)
951 {
952     Object *drc_container;
953     ObjectProperty *prop;
954     ObjectPropertyIterator iter;
955 
956     drc_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
957 restart:
958     object_property_iter_init(&iter, drc_container);
959     while ((prop = object_property_iter_next(&iter))) {
960         SpaprDrc *drc;
961 
962         if (!strstart(prop->type, "link<", NULL)) {
963             continue;
964         }
965         drc = SPAPR_DR_CONNECTOR(object_property_get_link(drc_container,
966                                                           prop->name,
967                                                           &error_abort));
968 
969         /*
970          * This will complete any pending plug/unplug requests.
971          * In case of a unplugged PHB or PCI bridge, this will
972          * cause some DRCs to be destroyed and thus potentially
973          * invalidate the iterator.
974          */
975         if (spapr_drc_reset(drc)) {
976             goto restart;
977         }
978     }
979 }
980 
981 /*
982  * RTAS calls
983  */
984 
rtas_set_isolation_state(uint32_t idx,uint32_t state)985 static uint32_t rtas_set_isolation_state(uint32_t idx, uint32_t state)
986 {
987     SpaprDrc *drc = spapr_drc_by_index(idx);
988     SpaprDrcClass *drck;
989 
990     if (!drc) {
991         return RTAS_OUT_NO_SUCH_INDICATOR;
992     }
993 
994     trace_spapr_drc_set_isolation_state(spapr_drc_index(drc), state);
995 
996     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
997 
998     switch (state) {
999     case SPAPR_DR_ISOLATION_STATE_ISOLATED:
1000         return drck->isolate(drc);
1001 
1002     case SPAPR_DR_ISOLATION_STATE_UNISOLATED:
1003         return drck->unisolate(drc);
1004 
1005     default:
1006         return RTAS_OUT_PARAM_ERROR;
1007     }
1008 }
1009 
rtas_set_allocation_state(uint32_t idx,uint32_t state)1010 static uint32_t rtas_set_allocation_state(uint32_t idx, uint32_t state)
1011 {
1012     SpaprDrc *drc = spapr_drc_by_index(idx);
1013 
1014     if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_LOGICAL)) {
1015         return RTAS_OUT_NO_SUCH_INDICATOR;
1016     }
1017 
1018     trace_spapr_drc_set_allocation_state(spapr_drc_index(drc), state);
1019 
1020     switch (state) {
1021     case SPAPR_DR_ALLOCATION_STATE_USABLE:
1022         return drc_set_usable(drc);
1023 
1024     case SPAPR_DR_ALLOCATION_STATE_UNUSABLE:
1025         return drc_set_unusable(drc);
1026 
1027     default:
1028         return RTAS_OUT_PARAM_ERROR;
1029     }
1030 }
1031 
rtas_set_dr_indicator(uint32_t idx,uint32_t state)1032 static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state)
1033 {
1034     SpaprDrc *drc = spapr_drc_by_index(idx);
1035 
1036     if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_PHYSICAL)) {
1037         return RTAS_OUT_NO_SUCH_INDICATOR;
1038     }
1039     if ((state != SPAPR_DR_INDICATOR_INACTIVE)
1040         && (state != SPAPR_DR_INDICATOR_ACTIVE)
1041         && (state != SPAPR_DR_INDICATOR_IDENTIFY)
1042         && (state != SPAPR_DR_INDICATOR_ACTION)) {
1043         return RTAS_OUT_PARAM_ERROR; /* bad state parameter */
1044     }
1045 
1046     trace_spapr_drc_set_dr_indicator(idx, state);
1047     SPAPR_DRC_PHYSICAL(drc)->dr_indicator = state;
1048     return RTAS_OUT_SUCCESS;
1049 }
1050 
rtas_set_indicator(PowerPCCPU * cpu,SpaprMachineState * spapr,uint32_t token,uint32_t nargs,target_ulong args,uint32_t nret,target_ulong rets)1051 static void rtas_set_indicator(PowerPCCPU *cpu, SpaprMachineState *spapr,
1052                                uint32_t token,
1053                                uint32_t nargs, target_ulong args,
1054                                uint32_t nret, target_ulong rets)
1055 {
1056     uint32_t type, idx, state;
1057     uint32_t ret = RTAS_OUT_SUCCESS;
1058 
1059     if (nargs != 3 || nret != 1) {
1060         ret = RTAS_OUT_PARAM_ERROR;
1061         goto out;
1062     }
1063 
1064     type = rtas_ld(args, 0);
1065     idx = rtas_ld(args, 1);
1066     state = rtas_ld(args, 2);
1067 
1068     switch (type) {
1069     case RTAS_SENSOR_TYPE_ISOLATION_STATE:
1070         ret = rtas_set_isolation_state(idx, state);
1071         break;
1072     case RTAS_SENSOR_TYPE_DR:
1073         ret = rtas_set_dr_indicator(idx, state);
1074         break;
1075     case RTAS_SENSOR_TYPE_ALLOCATION_STATE:
1076         ret = rtas_set_allocation_state(idx, state);
1077         break;
1078     default:
1079         ret = RTAS_OUT_NOT_SUPPORTED;
1080     }
1081 
1082 out:
1083     rtas_st(rets, 0, ret);
1084 }
1085 
rtas_get_sensor_state(PowerPCCPU * cpu,SpaprMachineState * spapr,uint32_t token,uint32_t nargs,target_ulong args,uint32_t nret,target_ulong rets)1086 static void rtas_get_sensor_state(PowerPCCPU *cpu, SpaprMachineState *spapr,
1087                                   uint32_t token, uint32_t nargs,
1088                                   target_ulong args, uint32_t nret,
1089                                   target_ulong rets)
1090 {
1091     uint32_t sensor_type;
1092     uint32_t sensor_index;
1093     uint32_t sensor_state = 0;
1094     SpaprDrc *drc;
1095     SpaprDrcClass *drck;
1096     uint32_t ret = RTAS_OUT_SUCCESS;
1097 
1098     if (nargs != 2 || nret != 2) {
1099         ret = RTAS_OUT_PARAM_ERROR;
1100         goto out;
1101     }
1102 
1103     sensor_type = rtas_ld(args, 0);
1104     sensor_index = rtas_ld(args, 1);
1105 
1106     if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) {
1107         /* currently only DR-related sensors are implemented */
1108         trace_spapr_rtas_get_sensor_state_not_supported(sensor_index,
1109                                                         sensor_type);
1110         ret = RTAS_OUT_NOT_SUPPORTED;
1111         goto out;
1112     }
1113 
1114     drc = spapr_drc_by_index(sensor_index);
1115     if (!drc) {
1116         trace_spapr_rtas_get_sensor_state_invalid(sensor_index);
1117         ret = RTAS_OUT_PARAM_ERROR;
1118         goto out;
1119     }
1120     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
1121     sensor_state = drck->dr_entity_sense(drc);
1122 
1123 out:
1124     rtas_st(rets, 0, ret);
1125     rtas_st(rets, 1, sensor_state);
1126 }
1127 
1128 /* configure-connector work area offsets, int32_t units for field
1129  * indexes, bytes for field offset/len values.
1130  *
1131  * as documented by PAPR+ v2.7, 13.5.3.5
1132  */
1133 #define CC_IDX_NODE_NAME_OFFSET 2
1134 #define CC_IDX_PROP_NAME_OFFSET 2
1135 #define CC_IDX_PROP_LEN 3
1136 #define CC_IDX_PROP_DATA_OFFSET 4
1137 #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4)
1138 #define CC_WA_LEN 4096
1139 
configure_connector_st(target_ulong addr,target_ulong offset,const void * buf,size_t len)1140 static void configure_connector_st(target_ulong addr, target_ulong offset,
1141                                    const void *buf, size_t len)
1142 {
1143     cpu_physical_memory_write(ppc64_phys_to_real(addr + offset),
1144                               buf, MIN(len, CC_WA_LEN - offset));
1145 }
1146 
rtas_ibm_configure_connector(PowerPCCPU * cpu,SpaprMachineState * spapr,uint32_t token,uint32_t nargs,target_ulong args,uint32_t nret,target_ulong rets)1147 static void rtas_ibm_configure_connector(PowerPCCPU *cpu,
1148                                          SpaprMachineState *spapr,
1149                                          uint32_t token, uint32_t nargs,
1150                                          target_ulong args, uint32_t nret,
1151                                          target_ulong rets)
1152 {
1153     uint64_t wa_addr;
1154     uint64_t wa_offset;
1155     uint32_t drc_index;
1156     SpaprDrc *drc;
1157     SpaprDrcClass *drck;
1158     SpaprDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE;
1159     int rc;
1160 
1161     if (nargs != 2 || nret != 1) {
1162         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
1163         return;
1164     }
1165 
1166     wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0);
1167 
1168     drc_index = rtas_ld(wa_addr, 0);
1169     drc = spapr_drc_by_index(drc_index);
1170     if (!drc) {
1171         trace_spapr_rtas_ibm_configure_connector_invalid(drc_index);
1172         rc = RTAS_OUT_PARAM_ERROR;
1173         goto out;
1174     }
1175 
1176     if ((drc->state != SPAPR_DRC_STATE_LOGICAL_UNISOLATE)
1177         && (drc->state != SPAPR_DRC_STATE_PHYSICAL_UNISOLATE)
1178         && (drc->state != SPAPR_DRC_STATE_LOGICAL_CONFIGURED)
1179         && (drc->state != SPAPR_DRC_STATE_PHYSICAL_CONFIGURED)) {
1180         /*
1181          * Need to unisolate the device before configuring
1182          * or it should already be in configured state to
1183          * allow configure-connector be called repeatedly.
1184          */
1185         rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE;
1186         goto out;
1187     }
1188 
1189     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
1190 
1191     /*
1192      * This indicates that the kernel is reconfiguring a LMB due to
1193      * a failed hotunplug. Rollback the DIMM unplug process.
1194      */
1195     if (spapr_drc_type(drc) == SPAPR_DR_CONNECTOR_TYPE_LMB &&
1196         drc->unplug_requested) {
1197         spapr_memory_unplug_rollback(spapr, drc->dev);
1198     }
1199 
1200     if (!drc->fdt) {
1201         void *fdt;
1202         int fdt_size;
1203 
1204         fdt = create_device_tree(&fdt_size);
1205 
1206         if (drck->dt_populate(drc, spapr, fdt, &drc->fdt_start_offset,
1207                               NULL)) {
1208             g_free(fdt);
1209             rc = SPAPR_DR_CC_RESPONSE_ERROR;
1210             goto out;
1211         }
1212 
1213         drc->fdt = fdt;
1214         drc->ccs_offset = drc->fdt_start_offset;
1215         drc->ccs_depth = 0;
1216     }
1217 
1218     do {
1219         uint32_t tag;
1220         const char *name;
1221         const struct fdt_property *prop;
1222         int fdt_offset_next, prop_len;
1223 
1224         tag = fdt_next_tag(drc->fdt, drc->ccs_offset, &fdt_offset_next);
1225 
1226         switch (tag) {
1227         case FDT_BEGIN_NODE:
1228             drc->ccs_depth++;
1229             name = fdt_get_name(drc->fdt, drc->ccs_offset, NULL);
1230 
1231             /* provide the name of the next OF node */
1232             wa_offset = CC_VAL_DATA_OFFSET;
1233             rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset);
1234             configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
1235             resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD;
1236             break;
1237         case FDT_END_NODE:
1238             drc->ccs_depth--;
1239             if (drc->ccs_depth == 0) {
1240                 /* done sending the device tree, move to configured state */
1241                 trace_spapr_drc_set_configured(drc_index);
1242                 drc->state = drck->ready_state;
1243                 /*
1244                  * Ensure that we are able to send the FDT fragment
1245                  * again via configure-connector call if the guest requests.
1246                  */
1247                 drc->ccs_offset = drc->fdt_start_offset;
1248                 drc->ccs_depth = 0;
1249                 fdt_offset_next = drc->fdt_start_offset;
1250                 resp = SPAPR_DR_CC_RESPONSE_SUCCESS;
1251             } else {
1252                 resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT;
1253             }
1254             break;
1255         case FDT_PROP:
1256             prop = fdt_get_property_by_offset(drc->fdt, drc->ccs_offset,
1257                                               &prop_len);
1258             name = fdt_string(drc->fdt, fdt32_to_cpu(prop->nameoff));
1259 
1260             /* provide the name of the next OF property */
1261             wa_offset = CC_VAL_DATA_OFFSET;
1262             rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset);
1263             configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
1264 
1265             /* provide the length and value of the OF property. data gets
1266              * placed immediately after NULL terminator of the OF property's
1267              * name string
1268              */
1269             wa_offset += strlen(name) + 1,
1270             rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len);
1271             rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset);
1272             configure_connector_st(wa_addr, wa_offset, prop->data, prop_len);
1273             resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY;
1274             break;
1275         case FDT_END:
1276             resp = SPAPR_DR_CC_RESPONSE_ERROR;
1277         default:
1278             /* keep seeking for an actionable tag */
1279             break;
1280         }
1281         if (drc->ccs_offset >= 0) {
1282             drc->ccs_offset = fdt_offset_next;
1283         }
1284     } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE);
1285 
1286     rc = resp;
1287 out:
1288     rtas_st(rets, 0, rc);
1289 }
1290 
spapr_drc_register_types(void)1291 static void spapr_drc_register_types(void)
1292 {
1293     type_register_static(&spapr_dr_connector_info);
1294     type_register_static(&spapr_drc_physical_info);
1295     type_register_static(&spapr_drc_logical_info);
1296     type_register_static(&spapr_drc_cpu_info);
1297     type_register_static(&spapr_drc_pci_info);
1298     type_register_static(&spapr_drc_lmb_info);
1299     type_register_static(&spapr_drc_phb_info);
1300     type_register_static(&spapr_drc_pmem_info);
1301 
1302     spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator",
1303                         rtas_set_indicator);
1304     spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state",
1305                         rtas_get_sensor_state);
1306     spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector",
1307                         rtas_ibm_configure_connector);
1308 }
1309 type_init(spapr_drc_register_types)
1310