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 "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" /* for RTAS return codes */ 23 #include "hw/pci-host/spapr.h" /* spapr_phb_remove_pci_device_cb callback */ 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 30 sPAPRDRConnectorType spapr_drc_type(sPAPRDRConnector *drc) 31 { 32 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 33 34 return 1 << drck->typeshift; 35 } 36 37 uint32_t spapr_drc_index(sPAPRDRConnector *drc) 38 { 39 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 40 41 /* no set format for a drc index: it only needs to be globally 42 * unique. this is how we encode the DRC type on bare-metal 43 * however, so might as well do that here 44 */ 45 return (drck->typeshift << DRC_INDEX_TYPE_SHIFT) 46 | (drc->id & DRC_INDEX_ID_MASK); 47 } 48 49 static uint32_t drc_isolate_physical(sPAPRDRConnector *drc) 50 { 51 switch (drc->state) { 52 case SPAPR_DRC_STATE_PHYSICAL_POWERON: 53 return RTAS_OUT_SUCCESS; /* Nothing to do */ 54 case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED: 55 break; /* see below */ 56 case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE: 57 return RTAS_OUT_PARAM_ERROR; /* not allowed */ 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 73 static 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; /* Nothing to do */ 79 case SPAPR_DRC_STATE_PHYSICAL_POWERON: 80 break; /* see below */ 81 default: 82 g_assert_not_reached(); 83 } 84 85 /* cannot unisolate a non-existent resource, and, or resources 86 * which are in an 'UNUSABLE' allocation state. (PAPR 2.7, 87 * 13.5.3.5) 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 100 static 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; /* Nothing to do */ 106 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 107 break; /* see below */ 108 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 109 return RTAS_OUT_PARAM_ERROR; /* not allowed */ 110 default: 111 g_assert_not_reached(); 112 } 113 114 /* 115 * Fail any requests to ISOLATE the LMB DRC if this LMB doesn't 116 * belong to a DIMM device that is marked for removal. 117 * 118 * Currently the guest userspace tool drmgr that drives the memory 119 * hotplug/unplug will just try to remove a set of 'removable' LMBs 120 * in response to a hot unplug request that is based on drc-count. 121 * If the LMB being removed doesn't belong to a DIMM device that is 122 * actually being unplugged, fail the isolation request here. 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 /* if we're awaiting release, but still in an unconfigured state, 132 * it's likely the guest is still in the process of configuring 133 * the device and is transitioning the devices to an ISOLATED 134 * state as a part of that process. so we only complete the 135 * removal when this transition happens for a device in a 136 * configured state, as suggested by the state diagram from PAPR+ 137 * 2.7, 13.4 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 147 static 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; /* Nothing to do */ 153 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 154 break; /* see below */ 155 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 156 return RTAS_OUT_NO_SUCH_INDICATOR; /* not allowed */ 157 default: 158 g_assert_not_reached(); 159 } 160 161 /* Move to AVAILABLE state should have ensured device was present */ 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 171 static 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; /* Nothing to do */ 178 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 179 break; /* see below */ 180 default: 181 g_assert_not_reached(); 182 } 183 184 /* if there's no resource/device associated with the DRC, there's 185 * no way for us to put it in an allocation state consistent with 186 * being 'USABLE'. PAPR 2.7, 13.5.3.4 documents that this should 187 * result in an RTAS return code of -3 / "no such indicator" 188 */ 189 if (!drc->dev) { 190 return RTAS_OUT_NO_SUCH_INDICATOR; 191 } 192 if (drc->unplug_requested) { 193 /* Don't allow the guest to move a device away from UNUSABLE 194 * state when we want to unplug it */ 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 203 static uint32_t drc_set_unusable(sPAPRDRConnector *drc) 204 { 205 switch (drc->state) { 206 case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 207 return RTAS_OUT_SUCCESS; /* Nothing to do */ 208 case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 209 break; /* see below */ 210 case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 211 case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 212 return RTAS_OUT_NO_SUCH_INDICATOR; /* not allowed */ 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 227 static const char *spapr_drc_name(sPAPRDRConnector *drc) 228 { 229 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 230 231 /* human-readable name for a DRC to encode into the DT 232 * description. this is mainly only used within a guest in place 233 * of the unique DRC index. 234 * 235 * in the case of VIO/PCI devices, it corresponds to a "location 236 * code" that maps a logical device/function (DRC index) to a 237 * physical (or virtual in the case of VIO) location in the system 238 * by chaining together the "location label" for each 239 * encapsulating component. 240 * 241 * since this is more to do with diagnosing physical hardware 242 * issues than guest compatibility, we choose location codes/DRC 243 * names that adhere to the documented format, but avoid encoding 244 * the entire topology information into the label/code, instead 245 * just using the location codes based on the labels for the 246 * endpoints (VIO/PCI adaptor connectors), which is basically just 247 * "C" followed by an integer ID. 248 * 249 * DRC names as documented by PAPR+ v2.7, 13.5.2.4 250 * location codes as documented by PAPR+ v2.7, 12.3.1.5 251 */ 252 return g_strdup_printf("%s%d", drck->drc_name_prefix, drc->id); 253 } 254 255 /* 256 * dr-entity-sense sensor value 257 * returned via get-sensor-state RTAS calls 258 * as expected by state diagram in PAPR+ 2.7, 13.4 259 * based on the current allocation/indicator/power states 260 * for the DR connector. 261 */ 262 static sPAPRDREntitySense physical_entity_sense(sPAPRDRConnector *drc) 263 { 264 /* this assumes all PCI devices are assigned to a 'live insertion' 265 * power domain, where QEMU manages power state automatically as 266 * opposed to the guest. present, non-PCI resources are unaffected 267 * by power state. 268 */ 269 return drc->dev ? SPAPR_DR_ENTITY_SENSE_PRESENT 270 : SPAPR_DR_ENTITY_SENSE_EMPTY; 271 } 272 273 static 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 288 static 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 296 static 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 /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ 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 374 void 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 397 static 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 411 void 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 429 void 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 /* immediately upon reset we can safely assume DRCs whose devices 436 * are pending removal can be safely removed. 437 */ 438 if (drc->unplug_requested) { 439 spapr_drc_release(drc); 440 } 441 442 if (drc->dev) { 443 /* A device present at reset is ready to go, same as coldplugged */ 444 drc->state = drck->ready_state; 445 } else { 446 drc->state = drck->empty_state; 447 } 448 449 drc->ccs_offset = -1; 450 drc->ccs_depth = -1; 451 } 452 453 static void drc_reset(void *opaque) 454 { 455 spapr_drc_reset(SPAPR_DR_CONNECTOR(opaque)); 456 } 457 458 static bool spapr_drc_needed(void *opaque) 459 { 460 sPAPRDRConnector *drc = (sPAPRDRConnector *)opaque; 461 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 462 sPAPRDREntitySense value = drck->dr_entity_sense(drc); 463 464 /* If no dev is plugged in there is no need to migrate the DRC state */ 465 if (value != SPAPR_DR_ENTITY_SENSE_PRESENT) { 466 return false; 467 } 468 469 /* 470 * We need to migrate the state if it's not equal to the expected 471 * long-term state, which is the same as the coldplugged initial 472 * state */ 473 return (drc->state != drck->ready_state); 474 } 475 476 static const VMStateDescription vmstate_spapr_drc = { 477 .name = "spapr_drc", 478 .version_id = 1, 479 .minimum_version_id = 1, 480 .needed = spapr_drc_needed, 481 .fields = (VMStateField []) { 482 VMSTATE_UINT32(state, sPAPRDRConnector), 483 VMSTATE_END_OF_LIST() 484 } 485 }; 486 487 static void realize(DeviceState *d, Error **errp) 488 { 489 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d); 490 Object *root_container; 491 char link_name[256]; 492 gchar *child_name; 493 Error *err = NULL; 494 495 trace_spapr_drc_realize(spapr_drc_index(drc)); 496 /* NOTE: we do this as part of realize/unrealize due to the fact 497 * that the guest will communicate with the DRC via RTAS calls 498 * referencing the global DRC index. By unlinking the DRC 499 * from DRC_CONTAINER_PATH/<drc_index> we effectively make it 500 * inaccessible by the guest, since lookups rely on this path 501 * existing in the composition tree 502 */ 503 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 504 snprintf(link_name, sizeof(link_name), "%x", spapr_drc_index(drc)); 505 child_name = object_get_canonical_path_component(OBJECT(drc)); 506 trace_spapr_drc_realize_child(spapr_drc_index(drc), child_name); 507 object_property_add_alias(root_container, link_name, 508 drc->owner, child_name, &err); 509 g_free(child_name); 510 if (err) { 511 error_propagate(errp, err); 512 return; 513 } 514 vmstate_register(DEVICE(drc), spapr_drc_index(drc), &vmstate_spapr_drc, 515 drc); 516 qemu_register_reset(drc_reset, drc); 517 trace_spapr_drc_realize_complete(spapr_drc_index(drc)); 518 } 519 520 static void unrealize(DeviceState *d, Error **errp) 521 { 522 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d); 523 Object *root_container; 524 char name[256]; 525 526 trace_spapr_drc_unrealize(spapr_drc_index(drc)); 527 qemu_unregister_reset(drc_reset, drc); 528 vmstate_unregister(DEVICE(drc), &vmstate_spapr_drc, drc); 529 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 530 snprintf(name, sizeof(name), "%x", spapr_drc_index(drc)); 531 object_property_del(root_container, name, errp); 532 } 533 534 sPAPRDRConnector *spapr_dr_connector_new(Object *owner, const char *type, 535 uint32_t id) 536 { 537 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(object_new(type)); 538 char *prop_name; 539 540 drc->id = id; 541 drc->owner = owner; 542 prop_name = g_strdup_printf("dr-connector[%"PRIu32"]", 543 spapr_drc_index(drc)); 544 object_property_add_child(owner, prop_name, OBJECT(drc), NULL); 545 object_property_set_bool(OBJECT(drc), true, "realized", NULL); 546 g_free(prop_name); 547 548 return drc; 549 } 550 551 static void spapr_dr_connector_instance_init(Object *obj) 552 { 553 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); 554 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 555 556 object_property_add_uint32_ptr(obj, "id", &drc->id, NULL); 557 object_property_add(obj, "index", "uint32", prop_get_index, 558 NULL, NULL, NULL, NULL); 559 object_property_add(obj, "fdt", "struct", prop_get_fdt, 560 NULL, NULL, NULL, NULL); 561 drc->state = drck->empty_state; 562 } 563 564 static void spapr_dr_connector_class_init(ObjectClass *k, void *data) 565 { 566 DeviceClass *dk = DEVICE_CLASS(k); 567 568 dk->realize = realize; 569 dk->unrealize = unrealize; 570 /* 571 * Reason: it crashes FIXME find and document the real reason 572 */ 573 dk->user_creatable = false; 574 } 575 576 static bool drc_physical_needed(void *opaque) 577 { 578 sPAPRDRCPhysical *drcp = (sPAPRDRCPhysical *)opaque; 579 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(drcp); 580 581 if ((drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_ACTIVE)) 582 || (!drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_INACTIVE))) { 583 return false; 584 } 585 return true; 586 } 587 588 static const VMStateDescription vmstate_spapr_drc_physical = { 589 .name = "spapr_drc/physical", 590 .version_id = 1, 591 .minimum_version_id = 1, 592 .needed = drc_physical_needed, 593 .fields = (VMStateField []) { 594 VMSTATE_UINT32(dr_indicator, sPAPRDRCPhysical), 595 VMSTATE_END_OF_LIST() 596 } 597 }; 598 599 static void drc_physical_reset(void *opaque) 600 { 601 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(opaque); 602 sPAPRDRCPhysical *drcp = SPAPR_DRC_PHYSICAL(drc); 603 604 if (drc->dev) { 605 drcp->dr_indicator = SPAPR_DR_INDICATOR_ACTIVE; 606 } else { 607 drcp->dr_indicator = SPAPR_DR_INDICATOR_INACTIVE; 608 } 609 } 610 611 static void realize_physical(DeviceState *d, Error **errp) 612 { 613 sPAPRDRCPhysical *drcp = SPAPR_DRC_PHYSICAL(d); 614 Error *local_err = NULL; 615 616 realize(d, &local_err); 617 if (local_err) { 618 error_propagate(errp, local_err); 619 return; 620 } 621 622 vmstate_register(DEVICE(drcp), spapr_drc_index(SPAPR_DR_CONNECTOR(drcp)), 623 &vmstate_spapr_drc_physical, drcp); 624 qemu_register_reset(drc_physical_reset, drcp); 625 } 626 627 static void spapr_drc_physical_class_init(ObjectClass *k, void *data) 628 { 629 DeviceClass *dk = DEVICE_CLASS(k); 630 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 631 632 dk->realize = realize_physical; 633 drck->dr_entity_sense = physical_entity_sense; 634 drck->isolate = drc_isolate_physical; 635 drck->unisolate = drc_unisolate_physical; 636 drck->ready_state = SPAPR_DRC_STATE_PHYSICAL_CONFIGURED; 637 drck->empty_state = SPAPR_DRC_STATE_PHYSICAL_POWERON; 638 } 639 640 static void spapr_drc_logical_class_init(ObjectClass *k, void *data) 641 { 642 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 643 644 drck->dr_entity_sense = logical_entity_sense; 645 drck->isolate = drc_isolate_logical; 646 drck->unisolate = drc_unisolate_logical; 647 drck->ready_state = SPAPR_DRC_STATE_LOGICAL_CONFIGURED; 648 drck->empty_state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE; 649 } 650 651 static void spapr_drc_cpu_class_init(ObjectClass *k, void *data) 652 { 653 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 654 655 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU; 656 drck->typename = "CPU"; 657 drck->drc_name_prefix = "CPU "; 658 drck->release = spapr_core_release; 659 } 660 661 static void spapr_drc_pci_class_init(ObjectClass *k, void *data) 662 { 663 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 664 665 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI; 666 drck->typename = "28"; 667 drck->drc_name_prefix = "C"; 668 drck->release = spapr_phb_remove_pci_device_cb; 669 } 670 671 static void spapr_drc_lmb_class_init(ObjectClass *k, void *data) 672 { 673 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 674 675 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB; 676 drck->typename = "MEM"; 677 drck->drc_name_prefix = "LMB "; 678 drck->release = spapr_lmb_release; 679 } 680 681 static const TypeInfo spapr_dr_connector_info = { 682 .name = TYPE_SPAPR_DR_CONNECTOR, 683 .parent = TYPE_DEVICE, 684 .instance_size = sizeof(sPAPRDRConnector), 685 .instance_init = spapr_dr_connector_instance_init, 686 .class_size = sizeof(sPAPRDRConnectorClass), 687 .class_init = spapr_dr_connector_class_init, 688 .abstract = true, 689 }; 690 691 static const TypeInfo spapr_drc_physical_info = { 692 .name = TYPE_SPAPR_DRC_PHYSICAL, 693 .parent = TYPE_SPAPR_DR_CONNECTOR, 694 .instance_size = sizeof(sPAPRDRCPhysical), 695 .class_init = spapr_drc_physical_class_init, 696 .abstract = true, 697 }; 698 699 static const TypeInfo spapr_drc_logical_info = { 700 .name = TYPE_SPAPR_DRC_LOGICAL, 701 .parent = TYPE_SPAPR_DR_CONNECTOR, 702 .class_init = spapr_drc_logical_class_init, 703 .abstract = true, 704 }; 705 706 static const TypeInfo spapr_drc_cpu_info = { 707 .name = TYPE_SPAPR_DRC_CPU, 708 .parent = TYPE_SPAPR_DRC_LOGICAL, 709 .class_init = spapr_drc_cpu_class_init, 710 }; 711 712 static const TypeInfo spapr_drc_pci_info = { 713 .name = TYPE_SPAPR_DRC_PCI, 714 .parent = TYPE_SPAPR_DRC_PHYSICAL, 715 .class_init = spapr_drc_pci_class_init, 716 }; 717 718 static const TypeInfo spapr_drc_lmb_info = { 719 .name = TYPE_SPAPR_DRC_LMB, 720 .parent = TYPE_SPAPR_DRC_LOGICAL, 721 .class_init = spapr_drc_lmb_class_init, 722 }; 723 724 /* helper functions for external users */ 725 726 sPAPRDRConnector *spapr_drc_by_index(uint32_t index) 727 { 728 Object *obj; 729 char name[256]; 730 731 snprintf(name, sizeof(name), "%s/%x", DRC_CONTAINER_PATH, index); 732 obj = object_resolve_path(name, NULL); 733 734 return !obj ? NULL : SPAPR_DR_CONNECTOR(obj); 735 } 736 737 sPAPRDRConnector *spapr_drc_by_id(const char *type, uint32_t id) 738 { 739 sPAPRDRConnectorClass *drck 740 = SPAPR_DR_CONNECTOR_CLASS(object_class_by_name(type)); 741 742 return spapr_drc_by_index(drck->typeshift << DRC_INDEX_TYPE_SHIFT 743 | (id & DRC_INDEX_ID_MASK)); 744 } 745 746 /** 747 * spapr_drc_populate_dt 748 * 749 * @fdt: libfdt device tree 750 * @path: path in the DT to generate properties 751 * @owner: parent Object/DeviceState for which to generate DRC 752 * descriptions for 753 * @drc_type_mask: mask of sPAPRDRConnectorType values corresponding 754 * to the types of DRCs to generate entries for 755 * 756 * generate OF properties to describe DRC topology/indices to guests 757 * 758 * as documented in PAPR+ v2.1, 13.5.2 759 */ 760 int spapr_drc_populate_dt(void *fdt, int fdt_offset, Object *owner, 761 uint32_t drc_type_mask) 762 { 763 Object *root_container; 764 ObjectProperty *prop; 765 ObjectPropertyIterator iter; 766 uint32_t drc_count = 0; 767 GArray *drc_indexes, *drc_power_domains; 768 GString *drc_names, *drc_types; 769 int ret; 770 771 /* the first entry of each properties is a 32-bit integer encoding 772 * the number of elements in the array. we won't know this until 773 * we complete the iteration through all the matching DRCs, but 774 * reserve the space now and set the offsets accordingly so we 775 * can fill them in later. 776 */ 777 drc_indexes = g_array_new(false, true, sizeof(uint32_t)); 778 drc_indexes = g_array_set_size(drc_indexes, 1); 779 drc_power_domains = g_array_new(false, true, sizeof(uint32_t)); 780 drc_power_domains = g_array_set_size(drc_power_domains, 1); 781 drc_names = g_string_set_size(g_string_new(NULL), sizeof(uint32_t)); 782 drc_types = g_string_set_size(g_string_new(NULL), sizeof(uint32_t)); 783 784 /* aliases for all DRConnector objects will be rooted in QOM 785 * composition tree at DRC_CONTAINER_PATH 786 */ 787 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 788 789 object_property_iter_init(&iter, root_container); 790 while ((prop = object_property_iter_next(&iter))) { 791 Object *obj; 792 sPAPRDRConnector *drc; 793 sPAPRDRConnectorClass *drck; 794 uint32_t drc_index, drc_power_domain; 795 796 if (!strstart(prop->type, "link<", NULL)) { 797 continue; 798 } 799 800 obj = object_property_get_link(root_container, prop->name, NULL); 801 drc = SPAPR_DR_CONNECTOR(obj); 802 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 803 804 if (owner && (drc->owner != owner)) { 805 continue; 806 } 807 808 if ((spapr_drc_type(drc) & drc_type_mask) == 0) { 809 continue; 810 } 811 812 drc_count++; 813 814 /* ibm,drc-indexes */ 815 drc_index = cpu_to_be32(spapr_drc_index(drc)); 816 g_array_append_val(drc_indexes, drc_index); 817 818 /* ibm,drc-power-domains */ 819 drc_power_domain = cpu_to_be32(-1); 820 g_array_append_val(drc_power_domains, drc_power_domain); 821 822 /* ibm,drc-names */ 823 drc_names = g_string_append(drc_names, spapr_drc_name(drc)); 824 drc_names = g_string_insert_len(drc_names, -1, "\0", 1); 825 826 /* ibm,drc-types */ 827 drc_types = g_string_append(drc_types, drck->typename); 828 drc_types = g_string_insert_len(drc_types, -1, "\0", 1); 829 } 830 831 /* now write the drc count into the space we reserved at the 832 * beginning of the arrays previously 833 */ 834 *(uint32_t *)drc_indexes->data = cpu_to_be32(drc_count); 835 *(uint32_t *)drc_power_domains->data = cpu_to_be32(drc_count); 836 *(uint32_t *)drc_names->str = cpu_to_be32(drc_count); 837 *(uint32_t *)drc_types->str = cpu_to_be32(drc_count); 838 839 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-indexes", 840 drc_indexes->data, 841 drc_indexes->len * sizeof(uint32_t)); 842 if (ret) { 843 error_report("Couldn't create ibm,drc-indexes property"); 844 goto out; 845 } 846 847 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-power-domains", 848 drc_power_domains->data, 849 drc_power_domains->len * sizeof(uint32_t)); 850 if (ret) { 851 error_report("Couldn't finalize ibm,drc-power-domains property"); 852 goto out; 853 } 854 855 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-names", 856 drc_names->str, drc_names->len); 857 if (ret) { 858 error_report("Couldn't finalize ibm,drc-names property"); 859 goto out; 860 } 861 862 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-types", 863 drc_types->str, drc_types->len); 864 if (ret) { 865 error_report("Couldn't finalize ibm,drc-types property"); 866 goto out; 867 } 868 869 out: 870 g_array_free(drc_indexes, true); 871 g_array_free(drc_power_domains, true); 872 g_string_free(drc_names, true); 873 g_string_free(drc_types, true); 874 875 return ret; 876 } 877 878 /* 879 * RTAS calls 880 */ 881 882 static uint32_t rtas_set_isolation_state(uint32_t idx, uint32_t state) 883 { 884 sPAPRDRConnector *drc = spapr_drc_by_index(idx); 885 sPAPRDRConnectorClass *drck; 886 887 if (!drc) { 888 return RTAS_OUT_NO_SUCH_INDICATOR; 889 } 890 891 trace_spapr_drc_set_isolation_state(spapr_drc_index(drc), state); 892 893 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 894 895 switch (state) { 896 case SPAPR_DR_ISOLATION_STATE_ISOLATED: 897 return drck->isolate(drc); 898 899 case SPAPR_DR_ISOLATION_STATE_UNISOLATED: 900 return drck->unisolate(drc); 901 902 default: 903 return RTAS_OUT_PARAM_ERROR; 904 } 905 } 906 907 static uint32_t rtas_set_allocation_state(uint32_t idx, uint32_t state) 908 { 909 sPAPRDRConnector *drc = spapr_drc_by_index(idx); 910 911 if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_LOGICAL)) { 912 return RTAS_OUT_NO_SUCH_INDICATOR; 913 } 914 915 trace_spapr_drc_set_allocation_state(spapr_drc_index(drc), state); 916 917 switch (state) { 918 case SPAPR_DR_ALLOCATION_STATE_USABLE: 919 return drc_set_usable(drc); 920 921 case SPAPR_DR_ALLOCATION_STATE_UNUSABLE: 922 return drc_set_unusable(drc); 923 924 default: 925 return RTAS_OUT_PARAM_ERROR; 926 } 927 } 928 929 static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state) 930 { 931 sPAPRDRConnector *drc = spapr_drc_by_index(idx); 932 933 if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_PHYSICAL)) { 934 return RTAS_OUT_NO_SUCH_INDICATOR; 935 } 936 if ((state != SPAPR_DR_INDICATOR_INACTIVE) 937 && (state != SPAPR_DR_INDICATOR_ACTIVE) 938 && (state != SPAPR_DR_INDICATOR_IDENTIFY) 939 && (state != SPAPR_DR_INDICATOR_ACTION)) { 940 return RTAS_OUT_PARAM_ERROR; /* bad state parameter */ 941 } 942 943 trace_spapr_drc_set_dr_indicator(idx, state); 944 SPAPR_DRC_PHYSICAL(drc)->dr_indicator = state; 945 return RTAS_OUT_SUCCESS; 946 } 947 948 static void rtas_set_indicator(PowerPCCPU *cpu, sPAPRMachineState *spapr, 949 uint32_t token, 950 uint32_t nargs, target_ulong args, 951 uint32_t nret, target_ulong rets) 952 { 953 uint32_t type, idx, state; 954 uint32_t ret = RTAS_OUT_SUCCESS; 955 956 if (nargs != 3 || nret != 1) { 957 ret = RTAS_OUT_PARAM_ERROR; 958 goto out; 959 } 960 961 type = rtas_ld(args, 0); 962 idx = rtas_ld(args, 1); 963 state = rtas_ld(args, 2); 964 965 switch (type) { 966 case RTAS_SENSOR_TYPE_ISOLATION_STATE: 967 ret = rtas_set_isolation_state(idx, state); 968 break; 969 case RTAS_SENSOR_TYPE_DR: 970 ret = rtas_set_dr_indicator(idx, state); 971 break; 972 case RTAS_SENSOR_TYPE_ALLOCATION_STATE: 973 ret = rtas_set_allocation_state(idx, state); 974 break; 975 default: 976 ret = RTAS_OUT_NOT_SUPPORTED; 977 } 978 979 out: 980 rtas_st(rets, 0, ret); 981 } 982 983 static void rtas_get_sensor_state(PowerPCCPU *cpu, sPAPRMachineState *spapr, 984 uint32_t token, uint32_t nargs, 985 target_ulong args, uint32_t nret, 986 target_ulong rets) 987 { 988 uint32_t sensor_type; 989 uint32_t sensor_index; 990 uint32_t sensor_state = 0; 991 sPAPRDRConnector *drc; 992 sPAPRDRConnectorClass *drck; 993 uint32_t ret = RTAS_OUT_SUCCESS; 994 995 if (nargs != 2 || nret != 2) { 996 ret = RTAS_OUT_PARAM_ERROR; 997 goto out; 998 } 999 1000 sensor_type = rtas_ld(args, 0); 1001 sensor_index = rtas_ld(args, 1); 1002 1003 if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) { 1004 /* currently only DR-related sensors are implemented */ 1005 trace_spapr_rtas_get_sensor_state_not_supported(sensor_index, 1006 sensor_type); 1007 ret = RTAS_OUT_NOT_SUPPORTED; 1008 goto out; 1009 } 1010 1011 drc = spapr_drc_by_index(sensor_index); 1012 if (!drc) { 1013 trace_spapr_rtas_get_sensor_state_invalid(sensor_index); 1014 ret = RTAS_OUT_PARAM_ERROR; 1015 goto out; 1016 } 1017 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 1018 sensor_state = drck->dr_entity_sense(drc); 1019 1020 out: 1021 rtas_st(rets, 0, ret); 1022 rtas_st(rets, 1, sensor_state); 1023 } 1024 1025 /* configure-connector work area offsets, int32_t units for field 1026 * indexes, bytes for field offset/len values. 1027 * 1028 * as documented by PAPR+ v2.7, 13.5.3.5 1029 */ 1030 #define CC_IDX_NODE_NAME_OFFSET 2 1031 #define CC_IDX_PROP_NAME_OFFSET 2 1032 #define CC_IDX_PROP_LEN 3 1033 #define CC_IDX_PROP_DATA_OFFSET 4 1034 #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4) 1035 #define CC_WA_LEN 4096 1036 1037 static void configure_connector_st(target_ulong addr, target_ulong offset, 1038 const void *buf, size_t len) 1039 { 1040 cpu_physical_memory_write(ppc64_phys_to_real(addr + offset), 1041 buf, MIN(len, CC_WA_LEN - offset)); 1042 } 1043 1044 static void rtas_ibm_configure_connector(PowerPCCPU *cpu, 1045 sPAPRMachineState *spapr, 1046 uint32_t token, uint32_t nargs, 1047 target_ulong args, uint32_t nret, 1048 target_ulong rets) 1049 { 1050 uint64_t wa_addr; 1051 uint64_t wa_offset; 1052 uint32_t drc_index; 1053 sPAPRDRConnector *drc; 1054 sPAPRDRConnectorClass *drck; 1055 sPAPRDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE; 1056 int rc; 1057 1058 if (nargs != 2 || nret != 1) { 1059 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 1060 return; 1061 } 1062 1063 wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0); 1064 1065 drc_index = rtas_ld(wa_addr, 0); 1066 drc = spapr_drc_by_index(drc_index); 1067 if (!drc) { 1068 trace_spapr_rtas_ibm_configure_connector_invalid(drc_index); 1069 rc = RTAS_OUT_PARAM_ERROR; 1070 goto out; 1071 } 1072 1073 if ((drc->state != SPAPR_DRC_STATE_LOGICAL_UNISOLATE) 1074 && (drc->state != SPAPR_DRC_STATE_PHYSICAL_UNISOLATE)) { 1075 /* Need to unisolate the device before configuring */ 1076 rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE; 1077 goto out; 1078 } 1079 1080 g_assert(drc->fdt); 1081 1082 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 1083 1084 do { 1085 uint32_t tag; 1086 const char *name; 1087 const struct fdt_property *prop; 1088 int fdt_offset_next, prop_len; 1089 1090 tag = fdt_next_tag(drc->fdt, drc->ccs_offset, &fdt_offset_next); 1091 1092 switch (tag) { 1093 case FDT_BEGIN_NODE: 1094 drc->ccs_depth++; 1095 name = fdt_get_name(drc->fdt, drc->ccs_offset, NULL); 1096 1097 /* provide the name of the next OF node */ 1098 wa_offset = CC_VAL_DATA_OFFSET; 1099 rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset); 1100 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1); 1101 resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD; 1102 break; 1103 case FDT_END_NODE: 1104 drc->ccs_depth--; 1105 if (drc->ccs_depth == 0) { 1106 uint32_t drc_index = spapr_drc_index(drc); 1107 1108 /* done sending the device tree, move to configured state */ 1109 trace_spapr_drc_set_configured(drc_index); 1110 drc->state = drck->ready_state; 1111 drc->ccs_offset = -1; 1112 drc->ccs_depth = -1; 1113 resp = SPAPR_DR_CC_RESPONSE_SUCCESS; 1114 } else { 1115 resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT; 1116 } 1117 break; 1118 case FDT_PROP: 1119 prop = fdt_get_property_by_offset(drc->fdt, drc->ccs_offset, 1120 &prop_len); 1121 name = fdt_string(drc->fdt, fdt32_to_cpu(prop->nameoff)); 1122 1123 /* provide the name of the next OF property */ 1124 wa_offset = CC_VAL_DATA_OFFSET; 1125 rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset); 1126 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1); 1127 1128 /* provide the length and value of the OF property. data gets 1129 * placed immediately after NULL terminator of the OF property's 1130 * name string 1131 */ 1132 wa_offset += strlen(name) + 1, 1133 rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len); 1134 rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset); 1135 configure_connector_st(wa_addr, wa_offset, prop->data, prop_len); 1136 resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY; 1137 break; 1138 case FDT_END: 1139 resp = SPAPR_DR_CC_RESPONSE_ERROR; 1140 default: 1141 /* keep seeking for an actionable tag */ 1142 break; 1143 } 1144 if (drc->ccs_offset >= 0) { 1145 drc->ccs_offset = fdt_offset_next; 1146 } 1147 } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE); 1148 1149 rc = resp; 1150 out: 1151 rtas_st(rets, 0, rc); 1152 } 1153 1154 static void spapr_drc_register_types(void) 1155 { 1156 type_register_static(&spapr_dr_connector_info); 1157 type_register_static(&spapr_drc_physical_info); 1158 type_register_static(&spapr_drc_logical_info); 1159 type_register_static(&spapr_drc_cpu_info); 1160 type_register_static(&spapr_drc_pci_info); 1161 type_register_static(&spapr_drc_lmb_info); 1162 1163 spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator", 1164 rtas_set_indicator); 1165 spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state", 1166 rtas_get_sensor_state); 1167 spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector", 1168 rtas_ibm_configure_connector); 1169 } 1170 type_init(spapr_drc_register_types) 1171