1
2
3
4
5
6
7
8
9
10
11
12
13#include "qemu/osdep.h"
14#include "qapi/error.h"
15#include "cpu.h"
16#include "qemu/cutils.h"
17#include "hw/ppc/spapr_drc.h"
18#include "qom/object.h"
19#include "hw/qdev.h"
20#include "qapi/visitor.h"
21#include "qemu/error-report.h"
22#include "hw/ppc/spapr.h"
23#include "hw/pci-host/spapr.h"
24#include "trace.h"
25
26#define DRC_CONTAINER_PATH "/dr-connector"
27#define DRC_INDEX_TYPE_SHIFT 28
28#define DRC_INDEX_ID_MASK ((1ULL << DRC_INDEX_TYPE_SHIFT) - 1)
29
30sPAPRDRConnectorType spapr_drc_type(sPAPRDRConnector *drc)
31{
32 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
33
34 return 1 << drck->typeshift;
35}
36
37uint32_t spapr_drc_index(sPAPRDRConnector *drc)
38{
39 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
40
41
42
43
44
45 return (drck->typeshift << DRC_INDEX_TYPE_SHIFT)
46 | (drc->id & DRC_INDEX_ID_MASK);
47}
48
49static uint32_t drc_isolate_physical(sPAPRDRConnector *drc)
50{
51 switch (drc->state) {
52 case SPAPR_DRC_STATE_PHYSICAL_POWERON:
53 return RTAS_OUT_SUCCESS;
54 case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED:
55 break;
56 case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE:
57 return RTAS_OUT_PARAM_ERROR;
58 default:
59 g_assert_not_reached();
60 }
61
62 drc->state = SPAPR_DRC_STATE_PHYSICAL_POWERON;
63
64 if (drc->unplug_requested) {
65 uint32_t drc_index = spapr_drc_index(drc);
66 trace_spapr_drc_set_isolation_state_finalizing(drc_index);
67 spapr_drc_detach(drc);
68 }
69
70 return RTAS_OUT_SUCCESS;
71}
72
73static uint32_t drc_unisolate_physical(sPAPRDRConnector *drc)
74{
75 switch (drc->state) {
76 case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE:
77 case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED:
78 return RTAS_OUT_SUCCESS;
79 case SPAPR_DRC_STATE_PHYSICAL_POWERON:
80 break;
81 default:
82 g_assert_not_reached();
83 }
84
85
86
87
88
89 if (!drc->dev) {
90 return RTAS_OUT_NO_SUCH_INDICATOR;
91 }
92
93 drc->state = SPAPR_DRC_STATE_PHYSICAL_UNISOLATE;
94 drc->ccs_offset = drc->fdt_start_offset;
95 drc->ccs_depth = 0;
96
97 return RTAS_OUT_SUCCESS;
98}
99
100static uint32_t drc_isolate_logical(sPAPRDRConnector *drc)
101{
102 switch (drc->state) {
103 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
104 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
105 return RTAS_OUT_SUCCESS;
106 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
107 break;
108 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
109 return RTAS_OUT_PARAM_ERROR;
110 default:
111 g_assert_not_reached();
112 }
113
114
115
116
117
118
119
120
121
122
123
124 if (spapr_drc_type(drc) == SPAPR_DR_CONNECTOR_TYPE_LMB
125 && !drc->unplug_requested) {
126 return RTAS_OUT_HW_ERROR;
127 }
128
129 drc->state = SPAPR_DRC_STATE_LOGICAL_AVAILABLE;
130
131
132
133
134
135
136
137
138
139 if (drc->unplug_requested) {
140 uint32_t drc_index = spapr_drc_index(drc);
141 trace_spapr_drc_set_isolation_state_finalizing(drc_index);
142 spapr_drc_detach(drc);
143 }
144 return RTAS_OUT_SUCCESS;
145}
146
147static uint32_t drc_unisolate_logical(sPAPRDRConnector *drc)
148{
149 switch (drc->state) {
150 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
151 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
152 return RTAS_OUT_SUCCESS;
153 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
154 break;
155 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
156 return RTAS_OUT_NO_SUCH_INDICATOR;
157 default:
158 g_assert_not_reached();
159 }
160
161
162 g_assert(drc->dev);
163
164 drc->state = SPAPR_DRC_STATE_LOGICAL_UNISOLATE;
165 drc->ccs_offset = drc->fdt_start_offset;
166 drc->ccs_depth = 0;
167
168 return RTAS_OUT_SUCCESS;
169}
170
171static uint32_t drc_set_usable(sPAPRDRConnector *drc)
172{
173 switch (drc->state) {
174 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
175 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
176 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
177 return RTAS_OUT_SUCCESS;
178 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
179 break;
180 default:
181 g_assert_not_reached();
182 }
183
184
185
186
187
188
189 if (!drc->dev) {
190 return RTAS_OUT_NO_SUCH_INDICATOR;
191 }
192 if (drc->unplug_requested) {
193
194
195 return RTAS_OUT_NO_SUCH_INDICATOR;
196 }
197
198 drc->state = SPAPR_DRC_STATE_LOGICAL_AVAILABLE;
199
200 return RTAS_OUT_SUCCESS;
201}
202
203static uint32_t drc_set_unusable(sPAPRDRConnector *drc)
204{
205 switch (drc->state) {
206 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
207 return RTAS_OUT_SUCCESS;
208 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
209 break;
210 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
211 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
212 return RTAS_OUT_NO_SUCH_INDICATOR;
213 default:
214 g_assert_not_reached();
215 }
216
217 drc->state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE;
218 if (drc->unplug_requested) {
219 uint32_t drc_index = spapr_drc_index(drc);
220 trace_spapr_drc_set_allocation_state_finalizing(drc_index);
221 spapr_drc_detach(drc);
222 }
223
224 return RTAS_OUT_SUCCESS;
225}
226
227static const char *spapr_drc_name(sPAPRDRConnector *drc)
228{
229 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252 return g_strdup_printf("%s%d", drck->drc_name_prefix, drc->id);
253}
254
255
256
257
258
259
260
261
262static sPAPRDREntitySense physical_entity_sense(sPAPRDRConnector *drc)
263{
264
265
266
267
268
269 return drc->dev ? SPAPR_DR_ENTITY_SENSE_PRESENT
270 : SPAPR_DR_ENTITY_SENSE_EMPTY;
271}
272
273static sPAPRDREntitySense logical_entity_sense(sPAPRDRConnector *drc)
274{
275 switch (drc->state) {
276 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE:
277 return SPAPR_DR_ENTITY_SENSE_UNUSABLE;
278 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE:
279 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE:
280 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED:
281 g_assert(drc->dev);
282 return SPAPR_DR_ENTITY_SENSE_PRESENT;
283 default:
284 g_assert_not_reached();
285 }
286}
287
288static void prop_get_index(Object *obj, Visitor *v, const char *name,
289 void *opaque, Error **errp)
290{
291 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
292 uint32_t value = spapr_drc_index(drc);
293 visit_type_uint32(v, name, &value, errp);
294}
295
296static void prop_get_fdt(Object *obj, Visitor *v, const char *name,
297 void *opaque, Error **errp)
298{
299 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
300 QNull *null = NULL;
301 Error *err = NULL;
302 int fdt_offset_next, fdt_offset, fdt_depth;
303 void *fdt;
304
305 if (!drc->fdt) {
306 visit_type_null(v, NULL, &null, errp);
307 QDECREF(null);
308 return;
309 }
310
311 fdt = drc->fdt;
312 fdt_offset = drc->fdt_start_offset;
313 fdt_depth = 0;
314
315 do {
316 const char *name = NULL;
317 const struct fdt_property *prop = NULL;
318 int prop_len = 0, name_len = 0;
319 uint32_t tag;
320
321 tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next);
322 switch (tag) {
323 case FDT_BEGIN_NODE:
324 fdt_depth++;
325 name = fdt_get_name(fdt, fdt_offset, &name_len);
326 visit_start_struct(v, name, NULL, 0, &err);
327 if (err) {
328 error_propagate(errp, err);
329 return;
330 }
331 break;
332 case FDT_END_NODE:
333
334 g_assert(fdt_depth > 0);
335 visit_check_struct(v, &err);
336 visit_end_struct(v, NULL);
337 if (err) {
338 error_propagate(errp, err);
339 return;
340 }
341 fdt_depth--;
342 break;
343 case FDT_PROP: {
344 int i;
345 prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len);
346 name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
347 visit_start_list(v, name, NULL, 0, &err);
348 if (err) {
349 error_propagate(errp, err);
350 return;
351 }
352 for (i = 0; i < prop_len; i++) {
353 visit_type_uint8(v, NULL, (uint8_t *)&prop->data[i], &err);
354 if (err) {
355 error_propagate(errp, err);
356 return;
357 }
358 }
359 visit_check_list(v, &err);
360 visit_end_list(v, NULL);
361 if (err) {
362 error_propagate(errp, err);
363 return;
364 }
365 break;
366 }
367 default:
368 error_setg(&error_abort, "device FDT in unexpected state: %d", tag);
369 }
370 fdt_offset = fdt_offset_next;
371 } while (fdt_depth != 0);
372}
373
374void spapr_drc_attach(sPAPRDRConnector *drc, DeviceState *d, void *fdt,
375 int fdt_start_offset, Error **errp)
376{
377 trace_spapr_drc_attach(spapr_drc_index(drc));
378
379 if (drc->dev) {
380 error_setg(errp, "an attached device is still awaiting release");
381 return;
382 }
383 g_assert((drc->state == SPAPR_DRC_STATE_LOGICAL_UNUSABLE)
384 || (drc->state == SPAPR_DRC_STATE_PHYSICAL_POWERON));
385 g_assert(fdt);
386
387 drc->dev = d;
388 drc->fdt = fdt;
389 drc->fdt_start_offset = fdt_start_offset;
390
391 object_property_add_link(OBJECT(drc), "device",
392 object_get_typename(OBJECT(drc->dev)),
393 (Object **)(&drc->dev),
394 NULL, 0, NULL);
395}
396
397static void spapr_drc_release(sPAPRDRConnector *drc)
398{
399 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
400
401 drck->release(drc->dev);
402
403 drc->unplug_requested = false;
404 g_free(drc->fdt);
405 drc->fdt = NULL;
406 drc->fdt_start_offset = 0;
407 object_property_del(OBJECT(drc), "device", &error_abort);
408 drc->dev = NULL;
409}
410
411void spapr_drc_detach(sPAPRDRConnector *drc)
412{
413 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
414
415 trace_spapr_drc_detach(spapr_drc_index(drc));
416
417 g_assert(drc->dev);
418
419 drc->unplug_requested = true;
420
421 if (drc->state != drck->empty_state) {
422 trace_spapr_drc_awaiting_quiesce(spapr_drc_index(drc));
423 return;
424 }
425
426 spapr_drc_release(drc);
427}
428
429void spapr_drc_reset(sPAPRDRConnector *drc)
430{
431 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
432
433 trace_spapr_drc_reset(spapr_drc_index(drc));
434
435
436
437
438 if (drc->unplug_requested) {
439 spapr_drc_release(drc);
440 }
441
442 if (drc->dev) {
443
444 drc->state = drck->ready_state;
445
446
447
448
449 drc->ccs_offset = drc->fdt_start_offset;
450 drc->ccs_depth = 0;
451 } else {
452 drc->state = drck->empty_state;
453 drc->ccs_offset = -1;
454 drc->ccs_depth = -1;
455 }
456}
457
458static void drc_reset(void *opaque)
459{
460 spapr_drc_reset(SPAPR_DR_CONNECTOR(opaque));
461}
462
463static bool spapr_drc_needed(void *opaque)
464{
465 sPAPRDRConnector *drc = (sPAPRDRConnector *)opaque;
466 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
467 sPAPRDREntitySense value = drck->dr_entity_sense(drc);
468
469
470 if (value != SPAPR_DR_ENTITY_SENSE_PRESENT) {
471 return false;
472 }
473
474
475
476
477
478 return (drc->state != drck->ready_state);
479}
480
481static const VMStateDescription vmstate_spapr_drc = {
482 .name = "spapr_drc",
483 .version_id = 1,
484 .minimum_version_id = 1,
485 .needed = spapr_drc_needed,
486 .fields = (VMStateField []) {
487 VMSTATE_UINT32(state, sPAPRDRConnector),
488 VMSTATE_END_OF_LIST()
489 }
490};
491
492static void realize(DeviceState *d, Error **errp)
493{
494 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);
495 Object *root_container;
496 char link_name[256];
497 gchar *child_name;
498 Error *err = NULL;
499
500 trace_spapr_drc_realize(spapr_drc_index(drc));
501
502
503
504
505
506
507
508 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
509 snprintf(link_name, sizeof(link_name), "%x", spapr_drc_index(drc));
510 child_name = object_get_canonical_path_component(OBJECT(drc));
511 trace_spapr_drc_realize_child(spapr_drc_index(drc), child_name);
512 object_property_add_alias(root_container, link_name,
513 drc->owner, child_name, &err);
514 g_free(child_name);
515 if (err) {
516 error_propagate(errp, err);
517 return;
518 }
519 vmstate_register(DEVICE(drc), spapr_drc_index(drc), &vmstate_spapr_drc,
520 drc);
521 qemu_register_reset(drc_reset, drc);
522 trace_spapr_drc_realize_complete(spapr_drc_index(drc));
523}
524
525static void unrealize(DeviceState *d, Error **errp)
526{
527 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);
528 Object *root_container;
529 char name[256];
530
531 trace_spapr_drc_unrealize(spapr_drc_index(drc));
532 qemu_unregister_reset(drc_reset, drc);
533 vmstate_unregister(DEVICE(drc), &vmstate_spapr_drc, drc);
534 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
535 snprintf(name, sizeof(name), "%x", spapr_drc_index(drc));
536 object_property_del(root_container, name, errp);
537}
538
539sPAPRDRConnector *spapr_dr_connector_new(Object *owner, const char *type,
540 uint32_t id)
541{
542 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(object_new(type));
543 char *prop_name;
544
545 drc->id = id;
546 drc->owner = owner;
547 prop_name = g_strdup_printf("dr-connector[%"PRIu32"]",
548 spapr_drc_index(drc));
549 object_property_add_child(owner, prop_name, OBJECT(drc), &error_abort);
550 object_property_set_bool(OBJECT(drc), true, "realized", NULL);
551 g_free(prop_name);
552
553 return drc;
554}
555
556static void spapr_dr_connector_instance_init(Object *obj)
557{
558 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
559 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
560
561 object_property_add_uint32_ptr(obj, "id", &drc->id, NULL);
562 object_property_add(obj, "index", "uint32", prop_get_index,
563 NULL, NULL, NULL, NULL);
564 object_property_add(obj, "fdt", "struct", prop_get_fdt,
565 NULL, NULL, NULL, NULL);
566 drc->state = drck->empty_state;
567}
568
569static void spapr_dr_connector_class_init(ObjectClass *k, void *data)
570{
571 DeviceClass *dk = DEVICE_CLASS(k);
572
573 dk->realize = realize;
574 dk->unrealize = unrealize;
575
576
577
578 dk->user_creatable = false;
579}
580
581static bool drc_physical_needed(void *opaque)
582{
583 sPAPRDRCPhysical *drcp = (sPAPRDRCPhysical *)opaque;
584 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(drcp);
585
586 if ((drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_ACTIVE))
587 || (!drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_INACTIVE))) {
588 return false;
589 }
590 return true;
591}
592
593static const VMStateDescription vmstate_spapr_drc_physical = {
594 .name = "spapr_drc/physical",
595 .version_id = 1,
596 .minimum_version_id = 1,
597 .needed = drc_physical_needed,
598 .fields = (VMStateField []) {
599 VMSTATE_UINT32(dr_indicator, sPAPRDRCPhysical),
600 VMSTATE_END_OF_LIST()
601 }
602};
603
604static void drc_physical_reset(void *opaque)
605{
606 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(opaque);
607 sPAPRDRCPhysical *drcp = SPAPR_DRC_PHYSICAL(drc);
608
609 if (drc->dev) {
610 drcp->dr_indicator = SPAPR_DR_INDICATOR_ACTIVE;
611 } else {
612 drcp->dr_indicator = SPAPR_DR_INDICATOR_INACTIVE;
613 }
614}
615
616static void realize_physical(DeviceState *d, Error **errp)
617{
618 sPAPRDRCPhysical *drcp = SPAPR_DRC_PHYSICAL(d);
619 Error *local_err = NULL;
620
621 realize(d, &local_err);
622 if (local_err) {
623 error_propagate(errp, local_err);
624 return;
625 }
626
627 vmstate_register(DEVICE(drcp), spapr_drc_index(SPAPR_DR_CONNECTOR(drcp)),
628 &vmstate_spapr_drc_physical, drcp);
629 qemu_register_reset(drc_physical_reset, drcp);
630}
631
632static void spapr_drc_physical_class_init(ObjectClass *k, void *data)
633{
634 DeviceClass *dk = DEVICE_CLASS(k);
635 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
636
637 dk->realize = realize_physical;
638 drck->dr_entity_sense = physical_entity_sense;
639 drck->isolate = drc_isolate_physical;
640 drck->unisolate = drc_unisolate_physical;
641 drck->ready_state = SPAPR_DRC_STATE_PHYSICAL_CONFIGURED;
642 drck->empty_state = SPAPR_DRC_STATE_PHYSICAL_POWERON;
643}
644
645static void spapr_drc_logical_class_init(ObjectClass *k, void *data)
646{
647 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
648
649 drck->dr_entity_sense = logical_entity_sense;
650 drck->isolate = drc_isolate_logical;
651 drck->unisolate = drc_unisolate_logical;
652 drck->ready_state = SPAPR_DRC_STATE_LOGICAL_CONFIGURED;
653 drck->empty_state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE;
654}
655
656static void spapr_drc_cpu_class_init(ObjectClass *k, void *data)
657{
658 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
659
660 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU;
661 drck->typename = "CPU";
662 drck->drc_name_prefix = "CPU ";
663 drck->release = spapr_core_release;
664}
665
666static void spapr_drc_pci_class_init(ObjectClass *k, void *data)
667{
668 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
669
670 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI;
671 drck->typename = "28";
672 drck->drc_name_prefix = "C";
673 drck->release = spapr_phb_remove_pci_device_cb;
674}
675
676static void spapr_drc_lmb_class_init(ObjectClass *k, void *data)
677{
678 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
679
680 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB;
681 drck->typename = "MEM";
682 drck->drc_name_prefix = "LMB ";
683 drck->release = spapr_lmb_release;
684}
685
686static const TypeInfo spapr_dr_connector_info = {
687 .name = TYPE_SPAPR_DR_CONNECTOR,
688 .parent = TYPE_DEVICE,
689 .instance_size = sizeof(sPAPRDRConnector),
690 .instance_init = spapr_dr_connector_instance_init,
691 .class_size = sizeof(sPAPRDRConnectorClass),
692 .class_init = spapr_dr_connector_class_init,
693 .abstract = true,
694};
695
696static const TypeInfo spapr_drc_physical_info = {
697 .name = TYPE_SPAPR_DRC_PHYSICAL,
698 .parent = TYPE_SPAPR_DR_CONNECTOR,
699 .instance_size = sizeof(sPAPRDRCPhysical),
700 .class_init = spapr_drc_physical_class_init,
701 .abstract = true,
702};
703
704static const TypeInfo spapr_drc_logical_info = {
705 .name = TYPE_SPAPR_DRC_LOGICAL,
706 .parent = TYPE_SPAPR_DR_CONNECTOR,
707 .class_init = spapr_drc_logical_class_init,
708 .abstract = true,
709};
710
711static const TypeInfo spapr_drc_cpu_info = {
712 .name = TYPE_SPAPR_DRC_CPU,
713 .parent = TYPE_SPAPR_DRC_LOGICAL,
714 .class_init = spapr_drc_cpu_class_init,
715};
716
717static const TypeInfo spapr_drc_pci_info = {
718 .name = TYPE_SPAPR_DRC_PCI,
719 .parent = TYPE_SPAPR_DRC_PHYSICAL,
720 .class_init = spapr_drc_pci_class_init,
721};
722
723static const TypeInfo spapr_drc_lmb_info = {
724 .name = TYPE_SPAPR_DRC_LMB,
725 .parent = TYPE_SPAPR_DRC_LOGICAL,
726 .class_init = spapr_drc_lmb_class_init,
727};
728
729
730
731sPAPRDRConnector *spapr_drc_by_index(uint32_t index)
732{
733 Object *obj;
734 char name[256];
735
736 snprintf(name, sizeof(name), "%s/%x", DRC_CONTAINER_PATH, index);
737 obj = object_resolve_path(name, NULL);
738
739 return !obj ? NULL : SPAPR_DR_CONNECTOR(obj);
740}
741
742sPAPRDRConnector *spapr_drc_by_id(const char *type, uint32_t id)
743{
744 sPAPRDRConnectorClass *drck
745 = SPAPR_DR_CONNECTOR_CLASS(object_class_by_name(type));
746
747 return spapr_drc_by_index(drck->typeshift << DRC_INDEX_TYPE_SHIFT
748 | (id & DRC_INDEX_ID_MASK));
749}
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765int spapr_drc_populate_dt(void *fdt, int fdt_offset, Object *owner,
766 uint32_t drc_type_mask)
767{
768 Object *root_container;
769 ObjectProperty *prop;
770 ObjectPropertyIterator iter;
771 uint32_t drc_count = 0;
772 GArray *drc_indexes, *drc_power_domains;
773 GString *drc_names, *drc_types;
774 int ret;
775
776
777
778
779
780
781
782 drc_indexes = g_array_new(false, true, sizeof(uint32_t));
783 drc_indexes = g_array_set_size(drc_indexes, 1);
784 drc_power_domains = g_array_new(false, true, sizeof(uint32_t));
785 drc_power_domains = g_array_set_size(drc_power_domains, 1);
786 drc_names = g_string_set_size(g_string_new(NULL), sizeof(uint32_t));
787 drc_types = g_string_set_size(g_string_new(NULL), sizeof(uint32_t));
788
789
790
791
792 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
793
794 object_property_iter_init(&iter, root_container);
795 while ((prop = object_property_iter_next(&iter))) {
796 Object *obj;
797 sPAPRDRConnector *drc;
798 sPAPRDRConnectorClass *drck;
799 uint32_t drc_index, drc_power_domain;
800
801 if (!strstart(prop->type, "link<", NULL)) {
802 continue;
803 }
804
805 obj = object_property_get_link(root_container, prop->name, NULL);
806 drc = SPAPR_DR_CONNECTOR(obj);
807 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
808
809 if (owner && (drc->owner != owner)) {
810 continue;
811 }
812
813 if ((spapr_drc_type(drc) & drc_type_mask) == 0) {
814 continue;
815 }
816
817 drc_count++;
818
819
820 drc_index = cpu_to_be32(spapr_drc_index(drc));
821 g_array_append_val(drc_indexes, drc_index);
822
823
824 drc_power_domain = cpu_to_be32(-1);
825 g_array_append_val(drc_power_domains, drc_power_domain);
826
827
828 drc_names = g_string_append(drc_names, spapr_drc_name(drc));
829 drc_names = g_string_insert_len(drc_names, -1, "\0", 1);
830
831
832 drc_types = g_string_append(drc_types, drck->typename);
833 drc_types = g_string_insert_len(drc_types, -1, "\0", 1);
834 }
835
836
837
838
839 *(uint32_t *)drc_indexes->data = cpu_to_be32(drc_count);
840 *(uint32_t *)drc_power_domains->data = cpu_to_be32(drc_count);
841 *(uint32_t *)drc_names->str = cpu_to_be32(drc_count);
842 *(uint32_t *)drc_types->str = cpu_to_be32(drc_count);
843
844 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-indexes",
845 drc_indexes->data,
846 drc_indexes->len * sizeof(uint32_t));
847 if (ret) {
848 error_report("Couldn't create ibm,drc-indexes property");
849 goto out;
850 }
851
852 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-power-domains",
853 drc_power_domains->data,
854 drc_power_domains->len * sizeof(uint32_t));
855 if (ret) {
856 error_report("Couldn't finalize ibm,drc-power-domains property");
857 goto out;
858 }
859
860 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-names",
861 drc_names->str, drc_names->len);
862 if (ret) {
863 error_report("Couldn't finalize ibm,drc-names property");
864 goto out;
865 }
866
867 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-types",
868 drc_types->str, drc_types->len);
869 if (ret) {
870 error_report("Couldn't finalize ibm,drc-types property");
871 goto out;
872 }
873
874out:
875 g_array_free(drc_indexes, true);
876 g_array_free(drc_power_domains, true);
877 g_string_free(drc_names, true);
878 g_string_free(drc_types, true);
879
880 return ret;
881}
882
883
884
885
886
887static uint32_t rtas_set_isolation_state(uint32_t idx, uint32_t state)
888{
889 sPAPRDRConnector *drc = spapr_drc_by_index(idx);
890 sPAPRDRConnectorClass *drck;
891
892 if (!drc) {
893 return RTAS_OUT_NO_SUCH_INDICATOR;
894 }
895
896 trace_spapr_drc_set_isolation_state(spapr_drc_index(drc), state);
897
898 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
899
900 switch (state) {
901 case SPAPR_DR_ISOLATION_STATE_ISOLATED:
902 return drck->isolate(drc);
903
904 case SPAPR_DR_ISOLATION_STATE_UNISOLATED:
905 return drck->unisolate(drc);
906
907 default:
908 return RTAS_OUT_PARAM_ERROR;
909 }
910}
911
912static uint32_t rtas_set_allocation_state(uint32_t idx, uint32_t state)
913{
914 sPAPRDRConnector *drc = spapr_drc_by_index(idx);
915
916 if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_LOGICAL)) {
917 return RTAS_OUT_NO_SUCH_INDICATOR;
918 }
919
920 trace_spapr_drc_set_allocation_state(spapr_drc_index(drc), state);
921
922 switch (state) {
923 case SPAPR_DR_ALLOCATION_STATE_USABLE:
924 return drc_set_usable(drc);
925
926 case SPAPR_DR_ALLOCATION_STATE_UNUSABLE:
927 return drc_set_unusable(drc);
928
929 default:
930 return RTAS_OUT_PARAM_ERROR;
931 }
932}
933
934static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state)
935{
936 sPAPRDRConnector *drc = spapr_drc_by_index(idx);
937
938 if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_PHYSICAL)) {
939 return RTAS_OUT_NO_SUCH_INDICATOR;
940 }
941 if ((state != SPAPR_DR_INDICATOR_INACTIVE)
942 && (state != SPAPR_DR_INDICATOR_ACTIVE)
943 && (state != SPAPR_DR_INDICATOR_IDENTIFY)
944 && (state != SPAPR_DR_INDICATOR_ACTION)) {
945 return RTAS_OUT_PARAM_ERROR;
946 }
947
948 trace_spapr_drc_set_dr_indicator(idx, state);
949 SPAPR_DRC_PHYSICAL(drc)->dr_indicator = state;
950 return RTAS_OUT_SUCCESS;
951}
952
953static void rtas_set_indicator(PowerPCCPU *cpu, sPAPRMachineState *spapr,
954 uint32_t token,
955 uint32_t nargs, target_ulong args,
956 uint32_t nret, target_ulong rets)
957{
958 uint32_t type, idx, state;
959 uint32_t ret = RTAS_OUT_SUCCESS;
960
961 if (nargs != 3 || nret != 1) {
962 ret = RTAS_OUT_PARAM_ERROR;
963 goto out;
964 }
965
966 type = rtas_ld(args, 0);
967 idx = rtas_ld(args, 1);
968 state = rtas_ld(args, 2);
969
970 switch (type) {
971 case RTAS_SENSOR_TYPE_ISOLATION_STATE:
972 ret = rtas_set_isolation_state(idx, state);
973 break;
974 case RTAS_SENSOR_TYPE_DR:
975 ret = rtas_set_dr_indicator(idx, state);
976 break;
977 case RTAS_SENSOR_TYPE_ALLOCATION_STATE:
978 ret = rtas_set_allocation_state(idx, state);
979 break;
980 default:
981 ret = RTAS_OUT_NOT_SUPPORTED;
982 }
983
984out:
985 rtas_st(rets, 0, ret);
986}
987
988static void rtas_get_sensor_state(PowerPCCPU *cpu, sPAPRMachineState *spapr,
989 uint32_t token, uint32_t nargs,
990 target_ulong args, uint32_t nret,
991 target_ulong rets)
992{
993 uint32_t sensor_type;
994 uint32_t sensor_index;
995 uint32_t sensor_state = 0;
996 sPAPRDRConnector *drc;
997 sPAPRDRConnectorClass *drck;
998 uint32_t ret = RTAS_OUT_SUCCESS;
999
1000 if (nargs != 2 || nret != 2) {
1001 ret = RTAS_OUT_PARAM_ERROR;
1002 goto out;
1003 }
1004
1005 sensor_type = rtas_ld(args, 0);
1006 sensor_index = rtas_ld(args, 1);
1007
1008 if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) {
1009
1010 trace_spapr_rtas_get_sensor_state_not_supported(sensor_index,
1011 sensor_type);
1012 ret = RTAS_OUT_NOT_SUPPORTED;
1013 goto out;
1014 }
1015
1016 drc = spapr_drc_by_index(sensor_index);
1017 if (!drc) {
1018 trace_spapr_rtas_get_sensor_state_invalid(sensor_index);
1019 ret = RTAS_OUT_PARAM_ERROR;
1020 goto out;
1021 }
1022 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
1023 sensor_state = drck->dr_entity_sense(drc);
1024
1025out:
1026 rtas_st(rets, 0, ret);
1027 rtas_st(rets, 1, sensor_state);
1028}
1029
1030
1031
1032
1033
1034
1035#define CC_IDX_NODE_NAME_OFFSET 2
1036#define CC_IDX_PROP_NAME_OFFSET 2
1037#define CC_IDX_PROP_LEN 3
1038#define CC_IDX_PROP_DATA_OFFSET 4
1039#define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4)
1040#define CC_WA_LEN 4096
1041
1042static void configure_connector_st(target_ulong addr, target_ulong offset,
1043 const void *buf, size_t len)
1044{
1045 cpu_physical_memory_write(ppc64_phys_to_real(addr + offset),
1046 buf, MIN(len, CC_WA_LEN - offset));
1047}
1048
1049static void rtas_ibm_configure_connector(PowerPCCPU *cpu,
1050 sPAPRMachineState *spapr,
1051 uint32_t token, uint32_t nargs,
1052 target_ulong args, uint32_t nret,
1053 target_ulong rets)
1054{
1055 uint64_t wa_addr;
1056 uint64_t wa_offset;
1057 uint32_t drc_index;
1058 sPAPRDRConnector *drc;
1059 sPAPRDRConnectorClass *drck;
1060 sPAPRDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE;
1061 int rc;
1062
1063 if (nargs != 2 || nret != 1) {
1064 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
1065 return;
1066 }
1067
1068 wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0);
1069
1070 drc_index = rtas_ld(wa_addr, 0);
1071 drc = spapr_drc_by_index(drc_index);
1072 if (!drc) {
1073 trace_spapr_rtas_ibm_configure_connector_invalid(drc_index);
1074 rc = RTAS_OUT_PARAM_ERROR;
1075 goto out;
1076 }
1077
1078 if ((drc->state != SPAPR_DRC_STATE_LOGICAL_UNISOLATE)
1079 && (drc->state != SPAPR_DRC_STATE_PHYSICAL_UNISOLATE)
1080 && (drc->state != SPAPR_DRC_STATE_LOGICAL_CONFIGURED)
1081 && (drc->state != SPAPR_DRC_STATE_PHYSICAL_CONFIGURED)) {
1082
1083
1084
1085
1086
1087 rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE;
1088 goto out;
1089 }
1090
1091 g_assert(drc->fdt);
1092
1093 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
1094
1095 do {
1096 uint32_t tag;
1097 const char *name;
1098 const struct fdt_property *prop;
1099 int fdt_offset_next, prop_len;
1100
1101 tag = fdt_next_tag(drc->fdt, drc->ccs_offset, &fdt_offset_next);
1102
1103 switch (tag) {
1104 case FDT_BEGIN_NODE:
1105 drc->ccs_depth++;
1106 name = fdt_get_name(drc->fdt, drc->ccs_offset, NULL);
1107
1108
1109 wa_offset = CC_VAL_DATA_OFFSET;
1110 rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset);
1111 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
1112 resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD;
1113 break;
1114 case FDT_END_NODE:
1115 drc->ccs_depth--;
1116 if (drc->ccs_depth == 0) {
1117 uint32_t drc_index = spapr_drc_index(drc);
1118
1119
1120 trace_spapr_drc_set_configured(drc_index);
1121 drc->state = drck->ready_state;
1122
1123
1124
1125
1126 drc->ccs_offset = drc->fdt_start_offset;
1127 drc->ccs_depth = 0;
1128 fdt_offset_next = drc->fdt_start_offset;
1129 resp = SPAPR_DR_CC_RESPONSE_SUCCESS;
1130 } else {
1131 resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT;
1132 }
1133 break;
1134 case FDT_PROP:
1135 prop = fdt_get_property_by_offset(drc->fdt, drc->ccs_offset,
1136 &prop_len);
1137 name = fdt_string(drc->fdt, fdt32_to_cpu(prop->nameoff));
1138
1139
1140 wa_offset = CC_VAL_DATA_OFFSET;
1141 rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset);
1142 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
1143
1144
1145
1146
1147
1148 wa_offset += strlen(name) + 1,
1149 rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len);
1150 rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset);
1151 configure_connector_st(wa_addr, wa_offset, prop->data, prop_len);
1152 resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY;
1153 break;
1154 case FDT_END:
1155 resp = SPAPR_DR_CC_RESPONSE_ERROR;
1156 default:
1157
1158 break;
1159 }
1160 if (drc->ccs_offset >= 0) {
1161 drc->ccs_offset = fdt_offset_next;
1162 }
1163 } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE);
1164
1165 rc = resp;
1166out:
1167 rtas_st(rets, 0, rc);
1168}
1169
1170static void spapr_drc_register_types(void)
1171{
1172 type_register_static(&spapr_dr_connector_info);
1173 type_register_static(&spapr_drc_physical_info);
1174 type_register_static(&spapr_drc_logical_info);
1175 type_register_static(&spapr_drc_cpu_info);
1176 type_register_static(&spapr_drc_pci_info);
1177 type_register_static(&spapr_drc_lmb_info);
1178
1179 spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator",
1180 rtas_set_indicator);
1181 spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state",
1182 rtas_get_sensor_state);
1183 spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector",
1184 rtas_ibm_configure_connector);
1185}
1186type_init(spapr_drc_register_types)
1187