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