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