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 if (err) { 510 error_report_err(err); 511 object_unref(OBJECT(drc)); 512 } 513 g_free(child_name); 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 Error *err = NULL; 526 527 trace_spapr_drc_unrealize(spapr_drc_index(drc)); 528 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 529 snprintf(name, sizeof(name), "%x", spapr_drc_index(drc)); 530 object_property_del(root_container, name, &err); 531 if (err) { 532 error_report_err(err); 533 object_unref(OBJECT(drc)); 534 } 535 } 536 537 sPAPRDRConnector *spapr_dr_connector_new(Object *owner, const char *type, 538 uint32_t id) 539 { 540 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(object_new(type)); 541 char *prop_name; 542 543 drc->id = id; 544 drc->owner = owner; 545 prop_name = g_strdup_printf("dr-connector[%"PRIu32"]", 546 spapr_drc_index(drc)); 547 object_property_add_child(owner, prop_name, OBJECT(drc), NULL); 548 object_property_set_bool(OBJECT(drc), true, "realized", NULL); 549 g_free(prop_name); 550 551 return drc; 552 } 553 554 static void spapr_dr_connector_instance_init(Object *obj) 555 { 556 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); 557 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 558 559 object_property_add_uint32_ptr(obj, "id", &drc->id, NULL); 560 object_property_add(obj, "index", "uint32", prop_get_index, 561 NULL, NULL, NULL, NULL); 562 object_property_add(obj, "fdt", "struct", prop_get_fdt, 563 NULL, NULL, NULL, NULL); 564 drc->state = drck->empty_state; 565 } 566 567 static void spapr_dr_connector_class_init(ObjectClass *k, void *data) 568 { 569 DeviceClass *dk = DEVICE_CLASS(k); 570 571 dk->realize = realize; 572 dk->unrealize = unrealize; 573 /* 574 * Reason: it crashes FIXME find and document the real reason 575 */ 576 dk->user_creatable = false; 577 } 578 579 static bool drc_physical_needed(void *opaque) 580 { 581 sPAPRDRCPhysical *drcp = (sPAPRDRCPhysical *)opaque; 582 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(drcp); 583 584 if ((drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_ACTIVE)) 585 || (!drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_INACTIVE))) { 586 return false; 587 } 588 return true; 589 } 590 591 static const VMStateDescription vmstate_spapr_drc_physical = { 592 .name = "spapr_drc/physical", 593 .version_id = 1, 594 .minimum_version_id = 1, 595 .needed = drc_physical_needed, 596 .fields = (VMStateField []) { 597 VMSTATE_UINT32(dr_indicator, sPAPRDRCPhysical), 598 VMSTATE_END_OF_LIST() 599 } 600 }; 601 602 static void drc_physical_reset(void *opaque) 603 { 604 sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(opaque); 605 sPAPRDRCPhysical *drcp = SPAPR_DRC_PHYSICAL(drc); 606 607 if (drc->dev) { 608 drcp->dr_indicator = SPAPR_DR_INDICATOR_ACTIVE; 609 } else { 610 drcp->dr_indicator = SPAPR_DR_INDICATOR_INACTIVE; 611 } 612 } 613 614 static void realize_physical(DeviceState *d, Error **errp) 615 { 616 sPAPRDRCPhysical *drcp = SPAPR_DRC_PHYSICAL(d); 617 Error *local_err = NULL; 618 619 realize(d, &local_err); 620 if (local_err) { 621 error_propagate(errp, local_err); 622 return; 623 } 624 625 vmstate_register(DEVICE(drcp), spapr_drc_index(SPAPR_DR_CONNECTOR(drcp)), 626 &vmstate_spapr_drc_physical, drcp); 627 qemu_register_reset(drc_physical_reset, drcp); 628 } 629 630 static void spapr_drc_physical_class_init(ObjectClass *k, void *data) 631 { 632 DeviceClass *dk = DEVICE_CLASS(k); 633 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 634 635 dk->realize = realize_physical; 636 drck->dr_entity_sense = physical_entity_sense; 637 drck->isolate = drc_isolate_physical; 638 drck->unisolate = drc_unisolate_physical; 639 drck->ready_state = SPAPR_DRC_STATE_PHYSICAL_CONFIGURED; 640 drck->empty_state = SPAPR_DRC_STATE_PHYSICAL_POWERON; 641 } 642 643 static void spapr_drc_logical_class_init(ObjectClass *k, void *data) 644 { 645 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 646 647 drck->dr_entity_sense = logical_entity_sense; 648 drck->isolate = drc_isolate_logical; 649 drck->unisolate = drc_unisolate_logical; 650 drck->ready_state = SPAPR_DRC_STATE_LOGICAL_CONFIGURED; 651 drck->empty_state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE; 652 } 653 654 static void spapr_drc_cpu_class_init(ObjectClass *k, void *data) 655 { 656 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 657 658 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU; 659 drck->typename = "CPU"; 660 drck->drc_name_prefix = "CPU "; 661 drck->release = spapr_core_release; 662 } 663 664 static void spapr_drc_pci_class_init(ObjectClass *k, void *data) 665 { 666 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 667 668 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI; 669 drck->typename = "28"; 670 drck->drc_name_prefix = "C"; 671 drck->release = spapr_phb_remove_pci_device_cb; 672 } 673 674 static void spapr_drc_lmb_class_init(ObjectClass *k, void *data) 675 { 676 sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 677 678 drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB; 679 drck->typename = "MEM"; 680 drck->drc_name_prefix = "LMB "; 681 drck->release = spapr_lmb_release; 682 } 683 684 static const TypeInfo spapr_dr_connector_info = { 685 .name = TYPE_SPAPR_DR_CONNECTOR, 686 .parent = TYPE_DEVICE, 687 .instance_size = sizeof(sPAPRDRConnector), 688 .instance_init = spapr_dr_connector_instance_init, 689 .class_size = sizeof(sPAPRDRConnectorClass), 690 .class_init = spapr_dr_connector_class_init, 691 .abstract = true, 692 }; 693 694 static const TypeInfo spapr_drc_physical_info = { 695 .name = TYPE_SPAPR_DRC_PHYSICAL, 696 .parent = TYPE_SPAPR_DR_CONNECTOR, 697 .instance_size = sizeof(sPAPRDRCPhysical), 698 .class_init = spapr_drc_physical_class_init, 699 .abstract = true, 700 }; 701 702 static const TypeInfo spapr_drc_logical_info = { 703 .name = TYPE_SPAPR_DRC_LOGICAL, 704 .parent = TYPE_SPAPR_DR_CONNECTOR, 705 .class_init = spapr_drc_logical_class_init, 706 .abstract = true, 707 }; 708 709 static const TypeInfo spapr_drc_cpu_info = { 710 .name = TYPE_SPAPR_DRC_CPU, 711 .parent = TYPE_SPAPR_DRC_LOGICAL, 712 .class_init = spapr_drc_cpu_class_init, 713 }; 714 715 static const TypeInfo spapr_drc_pci_info = { 716 .name = TYPE_SPAPR_DRC_PCI, 717 .parent = TYPE_SPAPR_DRC_PHYSICAL, 718 .class_init = spapr_drc_pci_class_init, 719 }; 720 721 static const TypeInfo spapr_drc_lmb_info = { 722 .name = TYPE_SPAPR_DRC_LMB, 723 .parent = TYPE_SPAPR_DRC_LOGICAL, 724 .class_init = spapr_drc_lmb_class_init, 725 }; 726 727 /* helper functions for external users */ 728 729 sPAPRDRConnector *spapr_drc_by_index(uint32_t index) 730 { 731 Object *obj; 732 char name[256]; 733 734 snprintf(name, sizeof(name), "%s/%x", DRC_CONTAINER_PATH, index); 735 obj = object_resolve_path(name, NULL); 736 737 return !obj ? NULL : SPAPR_DR_CONNECTOR(obj); 738 } 739 740 sPAPRDRConnector *spapr_drc_by_id(const char *type, uint32_t id) 741 { 742 sPAPRDRConnectorClass *drck 743 = SPAPR_DR_CONNECTOR_CLASS(object_class_by_name(type)); 744 745 return spapr_drc_by_index(drck->typeshift << DRC_INDEX_TYPE_SHIFT 746 | (id & DRC_INDEX_ID_MASK)); 747 } 748 749 /** 750 * spapr_drc_populate_dt 751 * 752 * @fdt: libfdt device tree 753 * @path: path in the DT to generate properties 754 * @owner: parent Object/DeviceState for which to generate DRC 755 * descriptions for 756 * @drc_type_mask: mask of sPAPRDRConnectorType values corresponding 757 * to the types of DRCs to generate entries for 758 * 759 * generate OF properties to describe DRC topology/indices to guests 760 * 761 * as documented in PAPR+ v2.1, 13.5.2 762 */ 763 int spapr_drc_populate_dt(void *fdt, int fdt_offset, Object *owner, 764 uint32_t drc_type_mask) 765 { 766 Object *root_container; 767 ObjectProperty *prop; 768 ObjectPropertyIterator iter; 769 uint32_t drc_count = 0; 770 GArray *drc_indexes, *drc_power_domains; 771 GString *drc_names, *drc_types; 772 int ret; 773 774 /* the first entry of each properties is a 32-bit integer encoding 775 * the number of elements in the array. we won't know this until 776 * we complete the iteration through all the matching DRCs, but 777 * reserve the space now and set the offsets accordingly so we 778 * can fill them in later. 779 */ 780 drc_indexes = g_array_new(false, true, sizeof(uint32_t)); 781 drc_indexes = g_array_set_size(drc_indexes, 1); 782 drc_power_domains = g_array_new(false, true, sizeof(uint32_t)); 783 drc_power_domains = g_array_set_size(drc_power_domains, 1); 784 drc_names = g_string_set_size(g_string_new(NULL), sizeof(uint32_t)); 785 drc_types = g_string_set_size(g_string_new(NULL), sizeof(uint32_t)); 786 787 /* aliases for all DRConnector objects will be rooted in QOM 788 * composition tree at DRC_CONTAINER_PATH 789 */ 790 root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 791 792 object_property_iter_init(&iter, root_container); 793 while ((prop = object_property_iter_next(&iter))) { 794 Object *obj; 795 sPAPRDRConnector *drc; 796 sPAPRDRConnectorClass *drck; 797 uint32_t drc_index, drc_power_domain; 798 799 if (!strstart(prop->type, "link<", NULL)) { 800 continue; 801 } 802 803 obj = object_property_get_link(root_container, prop->name, NULL); 804 drc = SPAPR_DR_CONNECTOR(obj); 805 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 806 807 if (owner && (drc->owner != owner)) { 808 continue; 809 } 810 811 if ((spapr_drc_type(drc) & drc_type_mask) == 0) { 812 continue; 813 } 814 815 drc_count++; 816 817 /* ibm,drc-indexes */ 818 drc_index = cpu_to_be32(spapr_drc_index(drc)); 819 g_array_append_val(drc_indexes, drc_index); 820 821 /* ibm,drc-power-domains */ 822 drc_power_domain = cpu_to_be32(-1); 823 g_array_append_val(drc_power_domains, drc_power_domain); 824 825 /* ibm,drc-names */ 826 drc_names = g_string_append(drc_names, spapr_drc_name(drc)); 827 drc_names = g_string_insert_len(drc_names, -1, "\0", 1); 828 829 /* ibm,drc-types */ 830 drc_types = g_string_append(drc_types, drck->typename); 831 drc_types = g_string_insert_len(drc_types, -1, "\0", 1); 832 } 833 834 /* now write the drc count into the space we reserved at the 835 * beginning of the arrays previously 836 */ 837 *(uint32_t *)drc_indexes->data = cpu_to_be32(drc_count); 838 *(uint32_t *)drc_power_domains->data = cpu_to_be32(drc_count); 839 *(uint32_t *)drc_names->str = cpu_to_be32(drc_count); 840 *(uint32_t *)drc_types->str = cpu_to_be32(drc_count); 841 842 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-indexes", 843 drc_indexes->data, 844 drc_indexes->len * sizeof(uint32_t)); 845 if (ret) { 846 error_report("Couldn't create ibm,drc-indexes property"); 847 goto out; 848 } 849 850 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-power-domains", 851 drc_power_domains->data, 852 drc_power_domains->len * sizeof(uint32_t)); 853 if (ret) { 854 error_report("Couldn't finalize ibm,drc-power-domains property"); 855 goto out; 856 } 857 858 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-names", 859 drc_names->str, drc_names->len); 860 if (ret) { 861 error_report("Couldn't finalize ibm,drc-names property"); 862 goto out; 863 } 864 865 ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-types", 866 drc_types->str, drc_types->len); 867 if (ret) { 868 error_report("Couldn't finalize ibm,drc-types property"); 869 goto out; 870 } 871 872 out: 873 g_array_free(drc_indexes, true); 874 g_array_free(drc_power_domains, true); 875 g_string_free(drc_names, true); 876 g_string_free(drc_types, true); 877 878 return ret; 879 } 880 881 /* 882 * RTAS calls 883 */ 884 885 static uint32_t rtas_set_isolation_state(uint32_t idx, uint32_t state) 886 { 887 sPAPRDRConnector *drc = spapr_drc_by_index(idx); 888 sPAPRDRConnectorClass *drck; 889 890 if (!drc) { 891 return RTAS_OUT_NO_SUCH_INDICATOR; 892 } 893 894 trace_spapr_drc_set_isolation_state(spapr_drc_index(drc), state); 895 896 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 897 898 switch (state) { 899 case SPAPR_DR_ISOLATION_STATE_ISOLATED: 900 return drck->isolate(drc); 901 902 case SPAPR_DR_ISOLATION_STATE_UNISOLATED: 903 return drck->unisolate(drc); 904 905 default: 906 return RTAS_OUT_PARAM_ERROR; 907 } 908 } 909 910 static uint32_t rtas_set_allocation_state(uint32_t idx, uint32_t state) 911 { 912 sPAPRDRConnector *drc = spapr_drc_by_index(idx); 913 914 if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_LOGICAL)) { 915 return RTAS_OUT_NO_SUCH_INDICATOR; 916 } 917 918 trace_spapr_drc_set_allocation_state(spapr_drc_index(drc), state); 919 920 switch (state) { 921 case SPAPR_DR_ALLOCATION_STATE_USABLE: 922 return drc_set_usable(drc); 923 924 case SPAPR_DR_ALLOCATION_STATE_UNUSABLE: 925 return drc_set_unusable(drc); 926 927 default: 928 return RTAS_OUT_PARAM_ERROR; 929 } 930 } 931 932 static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state) 933 { 934 sPAPRDRConnector *drc = spapr_drc_by_index(idx); 935 936 if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_PHYSICAL)) { 937 return RTAS_OUT_NO_SUCH_INDICATOR; 938 } 939 if ((state != SPAPR_DR_INDICATOR_INACTIVE) 940 && (state != SPAPR_DR_INDICATOR_ACTIVE) 941 && (state != SPAPR_DR_INDICATOR_IDENTIFY) 942 && (state != SPAPR_DR_INDICATOR_ACTION)) { 943 return RTAS_OUT_PARAM_ERROR; /* bad state parameter */ 944 } 945 946 trace_spapr_drc_set_dr_indicator(idx, state); 947 SPAPR_DRC_PHYSICAL(drc)->dr_indicator = state; 948 return RTAS_OUT_SUCCESS; 949 } 950 951 static void rtas_set_indicator(PowerPCCPU *cpu, sPAPRMachineState *spapr, 952 uint32_t token, 953 uint32_t nargs, target_ulong args, 954 uint32_t nret, target_ulong rets) 955 { 956 uint32_t type, idx, state; 957 uint32_t ret = RTAS_OUT_SUCCESS; 958 959 if (nargs != 3 || nret != 1) { 960 ret = RTAS_OUT_PARAM_ERROR; 961 goto out; 962 } 963 964 type = rtas_ld(args, 0); 965 idx = rtas_ld(args, 1); 966 state = rtas_ld(args, 2); 967 968 switch (type) { 969 case RTAS_SENSOR_TYPE_ISOLATION_STATE: 970 ret = rtas_set_isolation_state(idx, state); 971 break; 972 case RTAS_SENSOR_TYPE_DR: 973 ret = rtas_set_dr_indicator(idx, state); 974 break; 975 case RTAS_SENSOR_TYPE_ALLOCATION_STATE: 976 ret = rtas_set_allocation_state(idx, state); 977 break; 978 default: 979 ret = RTAS_OUT_NOT_SUPPORTED; 980 } 981 982 out: 983 rtas_st(rets, 0, ret); 984 } 985 986 static void rtas_get_sensor_state(PowerPCCPU *cpu, sPAPRMachineState *spapr, 987 uint32_t token, uint32_t nargs, 988 target_ulong args, uint32_t nret, 989 target_ulong rets) 990 { 991 uint32_t sensor_type; 992 uint32_t sensor_index; 993 uint32_t sensor_state = 0; 994 sPAPRDRConnector *drc; 995 sPAPRDRConnectorClass *drck; 996 uint32_t ret = RTAS_OUT_SUCCESS; 997 998 if (nargs != 2 || nret != 2) { 999 ret = RTAS_OUT_PARAM_ERROR; 1000 goto out; 1001 } 1002 1003 sensor_type = rtas_ld(args, 0); 1004 sensor_index = rtas_ld(args, 1); 1005 1006 if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) { 1007 /* currently only DR-related sensors are implemented */ 1008 trace_spapr_rtas_get_sensor_state_not_supported(sensor_index, 1009 sensor_type); 1010 ret = RTAS_OUT_NOT_SUPPORTED; 1011 goto out; 1012 } 1013 1014 drc = spapr_drc_by_index(sensor_index); 1015 if (!drc) { 1016 trace_spapr_rtas_get_sensor_state_invalid(sensor_index); 1017 ret = RTAS_OUT_PARAM_ERROR; 1018 goto out; 1019 } 1020 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 1021 sensor_state = drck->dr_entity_sense(drc); 1022 1023 out: 1024 rtas_st(rets, 0, ret); 1025 rtas_st(rets, 1, sensor_state); 1026 } 1027 1028 /* configure-connector work area offsets, int32_t units for field 1029 * indexes, bytes for field offset/len values. 1030 * 1031 * as documented by PAPR+ v2.7, 13.5.3.5 1032 */ 1033 #define CC_IDX_NODE_NAME_OFFSET 2 1034 #define CC_IDX_PROP_NAME_OFFSET 2 1035 #define CC_IDX_PROP_LEN 3 1036 #define CC_IDX_PROP_DATA_OFFSET 4 1037 #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4) 1038 #define CC_WA_LEN 4096 1039 1040 static void configure_connector_st(target_ulong addr, target_ulong offset, 1041 const void *buf, size_t len) 1042 { 1043 cpu_physical_memory_write(ppc64_phys_to_real(addr + offset), 1044 buf, MIN(len, CC_WA_LEN - offset)); 1045 } 1046 1047 static void rtas_ibm_configure_connector(PowerPCCPU *cpu, 1048 sPAPRMachineState *spapr, 1049 uint32_t token, uint32_t nargs, 1050 target_ulong args, uint32_t nret, 1051 target_ulong rets) 1052 { 1053 uint64_t wa_addr; 1054 uint64_t wa_offset; 1055 uint32_t drc_index; 1056 sPAPRDRConnector *drc; 1057 sPAPRDRConnectorClass *drck; 1058 sPAPRDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE; 1059 int rc; 1060 1061 if (nargs != 2 || nret != 1) { 1062 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 1063 return; 1064 } 1065 1066 wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0); 1067 1068 drc_index = rtas_ld(wa_addr, 0); 1069 drc = spapr_drc_by_index(drc_index); 1070 if (!drc) { 1071 trace_spapr_rtas_ibm_configure_connector_invalid(drc_index); 1072 rc = RTAS_OUT_PARAM_ERROR; 1073 goto out; 1074 } 1075 1076 if ((drc->state != SPAPR_DRC_STATE_LOGICAL_UNISOLATE) 1077 && (drc->state != SPAPR_DRC_STATE_PHYSICAL_UNISOLATE)) { 1078 /* Need to unisolate the device before configuring */ 1079 rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE; 1080 goto out; 1081 } 1082 1083 g_assert(drc->fdt); 1084 1085 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 1086 1087 do { 1088 uint32_t tag; 1089 const char *name; 1090 const struct fdt_property *prop; 1091 int fdt_offset_next, prop_len; 1092 1093 tag = fdt_next_tag(drc->fdt, drc->ccs_offset, &fdt_offset_next); 1094 1095 switch (tag) { 1096 case FDT_BEGIN_NODE: 1097 drc->ccs_depth++; 1098 name = fdt_get_name(drc->fdt, drc->ccs_offset, NULL); 1099 1100 /* provide the name of the next OF node */ 1101 wa_offset = CC_VAL_DATA_OFFSET; 1102 rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset); 1103 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1); 1104 resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD; 1105 break; 1106 case FDT_END_NODE: 1107 drc->ccs_depth--; 1108 if (drc->ccs_depth == 0) { 1109 uint32_t drc_index = spapr_drc_index(drc); 1110 1111 /* done sending the device tree, move to configured state */ 1112 trace_spapr_drc_set_configured(drc_index); 1113 drc->state = drck->ready_state; 1114 drc->ccs_offset = -1; 1115 drc->ccs_depth = -1; 1116 resp = SPAPR_DR_CC_RESPONSE_SUCCESS; 1117 } else { 1118 resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT; 1119 } 1120 break; 1121 case FDT_PROP: 1122 prop = fdt_get_property_by_offset(drc->fdt, drc->ccs_offset, 1123 &prop_len); 1124 name = fdt_string(drc->fdt, fdt32_to_cpu(prop->nameoff)); 1125 1126 /* provide the name of the next OF property */ 1127 wa_offset = CC_VAL_DATA_OFFSET; 1128 rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset); 1129 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1); 1130 1131 /* provide the length and value of the OF property. data gets 1132 * placed immediately after NULL terminator of the OF property's 1133 * name string 1134 */ 1135 wa_offset += strlen(name) + 1, 1136 rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len); 1137 rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset); 1138 configure_connector_st(wa_addr, wa_offset, prop->data, prop_len); 1139 resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY; 1140 break; 1141 case FDT_END: 1142 resp = SPAPR_DR_CC_RESPONSE_ERROR; 1143 default: 1144 /* keep seeking for an actionable tag */ 1145 break; 1146 } 1147 if (drc->ccs_offset >= 0) { 1148 drc->ccs_offset = fdt_offset_next; 1149 } 1150 } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE); 1151 1152 rc = resp; 1153 out: 1154 rtas_st(rets, 0, rc); 1155 } 1156 1157 static void spapr_drc_register_types(void) 1158 { 1159 type_register_static(&spapr_dr_connector_info); 1160 type_register_static(&spapr_drc_physical_info); 1161 type_register_static(&spapr_drc_logical_info); 1162 type_register_static(&spapr_drc_cpu_info); 1163 type_register_static(&spapr_drc_pci_info); 1164 type_register_static(&spapr_drc_lmb_info); 1165 1166 spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator", 1167 rtas_set_indicator); 1168 spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state", 1169 rtas_get_sensor_state); 1170 spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector", 1171 rtas_ibm_configure_connector); 1172 } 1173 type_init(spapr_drc_register_types) 1174