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