hw/ppc/spapr_drc.c

   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 "hw/ppc/spapr_drc.h"
  14 #include "qom/object.h"
  15 #include "hw/qdev.h"
  16 #include "qapi/visitor.h"
  17 #include "qemu/error-report.h"
  18
  19 /* #define DEBUG_SPAPR_DRC */
  20
  21 #ifdef DEBUG_SPAPR_DRC
  22 #define DPRINTF(fmt, ...) \
  23     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  24 #define DPRINTFN(fmt, ...) \
  25     do { DPRINTF(fmt, ## __VA_ARGS__); fprintf(stderr, "\n"); } while (0)
  26 #else
  27 #define DPRINTF(fmt, ...) \
  28     do { } while (0)
  29 #define DPRINTFN(fmt, ...) \
  30     do { } while (0)
  31 #endif
  32
  33 #define DRC_CONTAINER_PATH "/dr-connector"
  34 #define DRC_INDEX_TYPE_SHIFT 28
  35 #define DRC_INDEX_ID_MASK ((1ULL << DRC_INDEX_TYPE_SHIFT) - 1)
  36
  37 static sPAPRDRConnectorTypeShift get_type_shift(sPAPRDRConnectorType type)
  38 {
  39     uint32_t shift = 0;
  40
  41     /* make sure this isn't SPAPR_DR_CONNECTOR_TYPE_ANY, or some
  42      * other wonky value.
  43      */
  44     g_assert(is_power_of_2(type));
  45
  46     while (type != (1 << shift)) {
  47         shift++;
  48     }
  49     return shift;
  50 }
  51
  52 static uint32_t get_index(sPAPRDRConnector *drc)
  53 {
  54     /* no set format for a drc index: it only needs to be globally
  55      * unique. this is how we encode the DRC type on bare-metal
  56      * however, so might as well do that here
  57      */
  58     return (get_type_shift(drc->type) << DRC_INDEX_TYPE_SHIFT) |
  59             (drc->id & DRC_INDEX_ID_MASK);
  60 }
  61
  62 static int set_isolation_state(sPAPRDRConnector *drc,
  63                                sPAPRDRIsolationState state)
  64 {
  65     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
  66
  67     DPRINTFN("drc: %x, set_isolation_state: %x", get_index(drc), state);
  68
  69     drc->isolation_state = state;
  70
  71     if (drc->isolation_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) {
  72         /* if we're awaiting release, but still in an unconfigured state,
  73          * it's likely the guest is still in the process of configuring
  74          * the device and is transitioning the devices to an ISOLATED
  75          * state as a part of that process. so we only complete the
  76          * removal when this transition happens for a device in a
  77          * configured state, as suggested by the state diagram from
  78          * PAPR+ 2.7, 13.4
  79          */
  80         if (drc->awaiting_release) {
  81             if (drc->configured) {
  82                 DPRINTFN("finalizing device removal");
  83                 drck->detach(drc, DEVICE(drc->dev), drc->detach_cb,
  84                              drc->detach_cb_opaque, NULL);
  85             } else {
  86                 DPRINTFN("deferring device removal on unconfigured device\n");
  87             }
  88         }
  89         drc->configured = false;
  90     }
  91
  92     return 0;
  93 }
  94
  95 static int set_indicator_state(sPAPRDRConnector *drc,
  96                                sPAPRDRIndicatorState state)
  97 {
  98     DPRINTFN("drc: %x, set_indicator_state: %x", get_index(drc), state);
  99     drc->indicator_state = state;
 100     return 0;
 101 }
 102
 103 static int set_allocation_state(sPAPRDRConnector *drc,
 104                                 sPAPRDRAllocationState state)
 105 {
 106     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 107
 108     DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc), state);
 109
 110     if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI) {
 111         drc->allocation_state = state;
 112         if (drc->awaiting_release &&
 113             drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {
 114             DPRINTFN("finalizing device removal");
 115             drck->detach(drc, DEVICE(drc->dev), drc->detach_cb,
 116                          drc->detach_cb_opaque, NULL);
 117         }
 118     }
 119     return 0;
 120 }
 121
 122 static uint32_t get_type(sPAPRDRConnector *drc)
 123 {
 124     return drc->type;
 125 }
 126
 127 static const char *get_name(sPAPRDRConnector *drc)
 128 {
 129     return drc->name;
 130 }
 131
 132 static const void *get_fdt(sPAPRDRConnector *drc, int *fdt_start_offset)
 133 {
 134     if (fdt_start_offset) {
 135         *fdt_start_offset = drc->fdt_start_offset;
 136     }
 137     return drc->fdt;
 138 }
 139
 140 static void set_configured(sPAPRDRConnector *drc)
 141 {
 142     DPRINTFN("drc: %x, set_configured", get_index(drc));
 143
 144     if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_UNISOLATED) {
 145         /* guest should be not configuring an isolated device */
 146         DPRINTFN("drc: %x, set_configured: skipping isolated device",
 147                  get_index(drc));
 148         return;
 149     }
 150     drc->configured = true;
 151 }
 152
 153 /*
 154  * dr-entity-sense sensor value
 155  * returned via get-sensor-state RTAS calls
 156  * as expected by state diagram in PAPR+ 2.7, 13.4
 157  * based on the current allocation/indicator/power states
 158  * for the DR connector.
 159  */
 160 static sPAPRDREntitySense entity_sense(sPAPRDRConnector *drc)
 161 {
 162     sPAPRDREntitySense state;
 163
 164     if (drc->dev) {
 165         if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI &&
 166             drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {
 167             /* for logical DR, we return a state of UNUSABLE
 168              * iff the allocation state UNUSABLE.
 169              * Otherwise, report the state as USABLE/PRESENT,
 170              * as we would for PCI.
 171              */
 172             state = SPAPR_DR_ENTITY_SENSE_UNUSABLE;
 173         } else {
 174             /* this assumes all PCI devices are assigned to
 175              * a 'live insertion' power domain, where QEMU
 176              * manages power state automatically as opposed
 177              * to the guest. present, non-PCI resources are
 178              * unaffected by power state.
 179              */
 180             state = SPAPR_DR_ENTITY_SENSE_PRESENT;
 181         }
 182     } else {
 183         if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) {
 184             /* PCI devices, and only PCI devices, use EMPTY
 185              * in cases where we'd otherwise use UNUSABLE
 186              */
 187             state = SPAPR_DR_ENTITY_SENSE_EMPTY;
 188         } else {
 189             state = SPAPR_DR_ENTITY_SENSE_UNUSABLE;
 190         }
 191     }
 192
 193     DPRINTFN("drc: %x, entity_sense: %x", get_index(drc), state);
 194     return state;
 195 }
 196
 197 static void prop_get_index(Object *obj, Visitor *v, void *opaque,
 198                                   const char *name, Error **errp)
 199 {
 200     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
 201     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 202     uint32_t value = (uint32_t)drck->get_index(drc);
 203     visit_type_uint32(v, &value, name, errp);
 204 }
 205
 206 static void prop_get_type(Object *obj, Visitor *v, void *opaque,
 207                           const char *name, Error **errp)
 208 {
 209     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
 210     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 211     uint32_t value = (uint32_t)drck->get_type(drc);
 212     visit_type_uint32(v, &value, name, errp);
 213 }
 214
 215 static char *prop_get_name(Object *obj, Error **errp)
 216 {
 217     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
 218     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 219     return g_strdup(drck->get_name(drc));
 220 }
 221
 222 static void prop_get_entity_sense(Object *obj, Visitor *v, void *opaque,
 223                                   const char *name, Error **errp)
 224 {
 225     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
 226     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 227     uint32_t value = (uint32_t)drck->entity_sense(drc);
 228     visit_type_uint32(v, &value, name, errp);
 229 }
 230
 231 static void prop_get_fdt(Object *obj, Visitor *v, void *opaque,
 232                         const char *name, Error **errp)
 233 {
 234     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
 235     int fdt_offset_next, fdt_offset, fdt_depth;
 236     void *fdt;
 237
 238     if (!drc->fdt) {
 239         return;
 240     }
 241
 242     fdt = drc->fdt;
 243     fdt_offset = drc->fdt_start_offset;
 244     fdt_depth = 0;
 245
 246     do {
 247         const char *name = NULL;
 248         const struct fdt_property *prop = NULL;
 249         int prop_len = 0, name_len = 0;
 250         uint32_t tag;
 251
 252         tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next);
 253         switch (tag) {
 254         case FDT_BEGIN_NODE:
 255             fdt_depth++;
 256             name = fdt_get_name(fdt, fdt_offset, &name_len);
 257             visit_start_struct(v, NULL, NULL, name, 0, NULL);
 258             break;
 259         case FDT_END_NODE:
 260             /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */
 261             g_assert(fdt_depth > 0);
 262             visit_end_struct(v, NULL);
 263             fdt_depth--;
 264             break;
 265         case FDT_PROP: {
 266             int i;
 267             prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len);
 268             name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
 269             visit_start_list(v, name, NULL);
 270             for (i = 0; i < prop_len; i++) {
 271                 visit_type_uint8(v, (uint8_t *)&prop->data[i], NULL, NULL);
 272
 273             }
 274             visit_end_list(v, NULL);
 275             break;
 276         }
 277         default:
 278             error_setg(&error_abort, "device FDT in unexpected state: %d", tag);
 279         }
 280         fdt_offset = fdt_offset_next;
 281     } while (fdt_depth != 0);
 282 }
 283
 284 static void attach(sPAPRDRConnector *drc, DeviceState *d, void *fdt,
 285                    int fdt_start_offset, bool coldplug, Error **errp)
 286 {
 287     DPRINTFN("drc: %x, attach", get_index(drc));
 288
 289     if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
 290         error_setg(errp, "an attached device is still awaiting release");
 291         return;
 292     }
 293     if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) {
 294         g_assert(drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_USABLE);
 295     }
 296     g_assert(fdt || coldplug);
 297
 298     /* NOTE: setting initial isolation state to UNISOLATED means we can't
 299      * detach unless guest has a userspace/kernel that moves this state
 300      * back to ISOLATED in response to an unplug event, or this is done
 301      * manually by the admin prior. if we force things while the guest
 302      * may be accessing the device, we can easily crash the guest, so we
 303      * we defer completion of removal in such cases to the reset() hook.
 304      */
 305     if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) {
 306         drc->isolation_state = SPAPR_DR_ISOLATION_STATE_UNISOLATED;
 307     }
 308     drc->indicator_state = SPAPR_DR_INDICATOR_STATE_ACTIVE;
 309
 310     drc->dev = d;
 311     drc->fdt = fdt;
 312     drc->fdt_start_offset = fdt_start_offset;
 313     drc->configured = false;
 314
 315     object_property_add_link(OBJECT(drc), "device",
 316                              object_get_typename(OBJECT(drc->dev)),
 317                              (Object **)(&drc->dev),
 318                              NULL, 0, NULL);
 319 }
 320
 321 static void detach(sPAPRDRConnector *drc, DeviceState *d,
 322                    spapr_drc_detach_cb *detach_cb,
 323                    void *detach_cb_opaque, Error **errp)
 324 {
 325     DPRINTFN("drc: %x, detach", get_index(drc));
 326
 327     drc->detach_cb = detach_cb;
 328     drc->detach_cb_opaque = detach_cb_opaque;
 329
 330     if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
 331         DPRINTFN("awaiting transition to isolated state before removal");
 332         drc->awaiting_release = true;
 333         return;
 334     }
 335
 336     if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI &&
 337         drc->allocation_state != SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {
 338         DPRINTFN("awaiting transition to unusable state before removal");
 339         drc->awaiting_release = true;
 340         return;
 341     }
 342
 343     drc->indicator_state = SPAPR_DR_INDICATOR_STATE_INACTIVE;
 344
 345     if (drc->detach_cb) {
 346         drc->detach_cb(drc->dev, drc->detach_cb_opaque);
 347     }
 348
 349     drc->awaiting_release = false;
 350     g_free(drc->fdt);
 351     drc->fdt = NULL;
 352     drc->fdt_start_offset = 0;
 353     object_property_del(OBJECT(drc), "device", NULL);
 354     drc->dev = NULL;
 355     drc->detach_cb = NULL;
 356     drc->detach_cb_opaque = NULL;
 357 }
 358
 359 static bool release_pending(sPAPRDRConnector *drc)
 360 {
 361     return drc->awaiting_release;
 362 }
 363
 364 static void reset(DeviceState *d)
 365 {
 366     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);
 367     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 368
 369     DPRINTFN("drc reset: %x", drck->get_index(drc));
 370     /* immediately upon reset we can safely assume DRCs whose devices
 371      * are pending removal can be safely removed, and that they will
 372      * subsequently be left in an ISOLATED state. move the DRC to this
 373      * state in these cases (which will in turn complete any pending
 374      * device removals)
 375      */
 376     if (drc->awaiting_release) {
 377         drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_ISOLATED);
 378         /* generally this should also finalize the removal, but if the device
 379          * hasn't yet been configured we normally defer removal under the
 380          * assumption that this transition is taking place as part of device
 381          * configuration. so check if we're still waiting after this, and
 382          * force removal if we are
 383          */
 384         if (drc->awaiting_release) {
 385             drck->detach(drc, DEVICE(drc->dev), drc->detach_cb,
 386                          drc->detach_cb_opaque, NULL);
 387         }
 388
 389         /* non-PCI devices may be awaiting a transition to UNUSABLE */
 390         if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI &&
 391             drc->awaiting_release) {
 392             drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_UNUSABLE);
 393         }
 394     }
 395 }
 396
 397 static void realize(DeviceState *d, Error **errp)
 398 {
 399     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);
 400     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 401     Object *root_container;
 402     char link_name[256];
 403     gchar *child_name;
 404     Error *err = NULL;
 405
 406     DPRINTFN("drc realize: %x", drck->get_index(drc));
 407     /* NOTE: we do this as part of realize/unrealize due to the fact
 408      * that the guest will communicate with the DRC via RTAS calls
 409      * referencing the global DRC index. By unlinking the DRC
 410      * from DRC_CONTAINER_PATH/<drc_index> we effectively make it
 411      * inaccessible by the guest, since lookups rely on this path
 412      * existing in the composition tree
 413      */
 414     root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
 415     snprintf(link_name, sizeof(link_name), "%x", drck->get_index(drc));
 416     child_name = object_get_canonical_path_component(OBJECT(drc));
 417     DPRINTFN("drc child name: %s", child_name);
 418     object_property_add_alias(root_container, link_name,
 419                               drc->owner, child_name, &err);
 420     if (err) {
 421         error_report("%s", error_get_pretty(err));
 422         error_free(err);
 423         object_unref(OBJECT(drc));
 424     }
 425     g_free(child_name);
 426     DPRINTFN("drc realize complete");
 427 }
 428
 429 static void unrealize(DeviceState *d, Error **errp)
 430 {
 431     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);
 432     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 433     Object *root_container;
 434     char name[256];
 435     Error *err = NULL;
 436
 437     DPRINTFN("drc unrealize: %x", drck->get_index(drc));
 438     root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
 439     snprintf(name, sizeof(name), "%x", drck->get_index(drc));
 440     object_property_del(root_container, name, &err);
 441     if (err) {
 442         error_report("%s", error_get_pretty(err));
 443         error_free(err);
 444         object_unref(OBJECT(drc));
 445     }
 446 }
 447
 448 sPAPRDRConnector *spapr_dr_connector_new(Object *owner,
 449                                          sPAPRDRConnectorType type,
 450                                          uint32_t id)
 451 {
 452     sPAPRDRConnector *drc =
 453         SPAPR_DR_CONNECTOR(object_new(TYPE_SPAPR_DR_CONNECTOR));
 454
 455     g_assert(type);
 456
 457     drc->type = type;
 458     drc->id = id;
 459     drc->owner = owner;
 460     object_property_add_child(owner, "dr-connector[*]", OBJECT(drc), NULL);
 461     object_property_set_bool(OBJECT(drc), true, "realized", NULL);
 462
 463     /* human-readable name for a DRC to encode into the DT
 464      * description. this is mainly only used within a guest in place
 465      * of the unique DRC index.
 466      *
 467      * in the case of VIO/PCI devices, it corresponds to a
 468      * "location code" that maps a logical device/function (DRC index)
 469      * to a physical (or virtual in the case of VIO) location in the
 470      * system by chaining together the "location label" for each
 471      * encapsulating component.
 472      *
 473      * since this is more to do with diagnosing physical hardware
 474      * issues than guest compatibility, we choose location codes/DRC
 475      * names that adhere to the documented format, but avoid encoding
 476      * the entire topology information into the label/code, instead
 477      * just using the location codes based on the labels for the
 478      * endpoints (VIO/PCI adaptor connectors), which is basically
 479      * just "C" followed by an integer ID.
 480      *
 481      * DRC names as documented by PAPR+ v2.7, 13.5.2.4
 482      * location codes as documented by PAPR+ v2.7, 12.3.1.5
 483      */
 484     switch (drc->type) {
 485     case SPAPR_DR_CONNECTOR_TYPE_CPU:
 486         drc->name = g_strdup_printf("CPU %d", id);
 487         break;
 488     case SPAPR_DR_CONNECTOR_TYPE_PHB:
 489         drc->name = g_strdup_printf("PHB %d", id);
 490         break;
 491     case SPAPR_DR_CONNECTOR_TYPE_VIO:
 492     case SPAPR_DR_CONNECTOR_TYPE_PCI:
 493         drc->name = g_strdup_printf("C%d", id);
 494         break;
 495     case SPAPR_DR_CONNECTOR_TYPE_LMB:
 496         drc->name = g_strdup_printf("LMB %d", id);
 497         break;
 498     default:
 499         g_assert(false);
 500     }
 501
 502     /* PCI slot always start in a USABLE state, and stay there */
 503     if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) {
 504         drc->allocation_state = SPAPR_DR_ALLOCATION_STATE_USABLE;
 505     }
 506
 507     return drc;
 508 }
 509
 510 static void spapr_dr_connector_instance_init(Object *obj)
 511 {
 512     sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj);
 513
 514     object_property_add_uint32_ptr(obj, "isolation-state",
 515                                    &drc->isolation_state, NULL);
 516     object_property_add_uint32_ptr(obj, "indicator-state",
 517                                    &drc->indicator_state, NULL);
 518     object_property_add_uint32_ptr(obj, "allocation-state",
 519                                    &drc->allocation_state, NULL);
 520     object_property_add_uint32_ptr(obj, "id", &drc->id, NULL);
 521     object_property_add(obj, "index", "uint32", prop_get_index,
 522                         NULL, NULL, NULL, NULL);
 523     object_property_add(obj, "connector_type", "uint32", prop_get_type,
 524                         NULL, NULL, NULL, NULL);
 525     object_property_add_str(obj, "name", prop_get_name, NULL, NULL);
 526     object_property_add(obj, "entity-sense", "uint32", prop_get_entity_sense,
 527                         NULL, NULL, NULL, NULL);
 528     object_property_add(obj, "fdt", "struct", prop_get_fdt,
 529                         NULL, NULL, NULL, NULL);
 530 }
 531
 532 static void spapr_dr_connector_class_init(ObjectClass *k, void *data)
 533 {
 534     DeviceClass *dk = DEVICE_CLASS(k);
 535     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k);
 536
 537     dk->reset = reset;
 538     dk->realize = realize;
 539     dk->unrealize = unrealize;
 540     drck->set_isolation_state = set_isolation_state;
 541     drck->set_indicator_state = set_indicator_state;
 542     drck->set_allocation_state = set_allocation_state;
 543     drck->get_index = get_index;
 544     drck->get_type = get_type;
 545     drck->get_name = get_name;
 546     drck->get_fdt = get_fdt;
 547     drck->set_configured = set_configured;
 548     drck->entity_sense = entity_sense;
 549     drck->attach = attach;
 550     drck->detach = detach;
 551     drck->release_pending = release_pending;
 552 }
 553
 554 static const TypeInfo spapr_dr_connector_info = {
 555     .name          = TYPE_SPAPR_DR_CONNECTOR,
 556     .parent        = TYPE_DEVICE,
 557     .instance_size = sizeof(sPAPRDRConnector),
 558     .instance_init = spapr_dr_connector_instance_init,
 559     .class_size    = sizeof(sPAPRDRConnectorClass),
 560     .class_init    = spapr_dr_connector_class_init,
 561 };
 562
 563 static void spapr_drc_register_types(void)
 564 {
 565     type_register_static(&spapr_dr_connector_info);
 566 }
 567
 568 type_init(spapr_drc_register_types)
 569
 570 /* helper functions for external users */
 571
 572 sPAPRDRConnector *spapr_dr_connector_by_index(uint32_t index)
 573 {
 574     Object *obj;
 575     char name[256];
 576
 577     snprintf(name, sizeof(name), "%s/%x", DRC_CONTAINER_PATH, index);
 578     obj = object_resolve_path(name, NULL);
 579
 580     return !obj ? NULL : SPAPR_DR_CONNECTOR(obj);
 581 }
 582
 583 sPAPRDRConnector *spapr_dr_connector_by_id(sPAPRDRConnectorType type,
 584                                            uint32_t id)
 585 {
 586     return spapr_dr_connector_by_index(
 587             (get_type_shift(type) << DRC_INDEX_TYPE_SHIFT) |
 588             (id & DRC_INDEX_ID_MASK));
 589 }
 590
 591 /* generate a string the describes the DRC to encode into the
 592  * device tree.
 593  *
 594  * as documented by PAPR+ v2.7, 13.5.2.6 and C.6.1
 595  */
 596 static const char *spapr_drc_get_type_str(sPAPRDRConnectorType type)
 597 {
 598     switch (type) {
 599     case SPAPR_DR_CONNECTOR_TYPE_CPU:
 600         return "CPU";
 601     case SPAPR_DR_CONNECTOR_TYPE_PHB:
 602         return "PHB";
 603     case SPAPR_DR_CONNECTOR_TYPE_VIO:
 604         return "SLOT";
 605     case SPAPR_DR_CONNECTOR_TYPE_PCI:
 606         return "28";
 607     case SPAPR_DR_CONNECTOR_TYPE_LMB:
 608         return "MEM";
 609     default:
 610         g_assert(false);
 611     }
 612
 613     return NULL;
 614 }
 615
 616 /**
 617  * spapr_drc_populate_dt
 618  *
 619  * @fdt: libfdt device tree
 620  * @path: path in the DT to generate properties
 621  * @owner: parent Object/DeviceState for which to generate DRC
 622  *         descriptions for
 623  * @drc_type_mask: mask of sPAPRDRConnectorType values corresponding
 624  *   to the types of DRCs to generate entries for
 625  *
 626  * generate OF properties to describe DRC topology/indices to guests
 627  *
 628  * as documented in PAPR+ v2.1, 13.5.2
 629  */
 630 int spapr_drc_populate_dt(void *fdt, int fdt_offset, Object *owner,
 631                           uint32_t drc_type_mask)
 632 {
 633     Object *root_container;
 634     ObjectProperty *prop;
 635     uint32_t drc_count = 0;
 636     GArray *drc_indexes, *drc_power_domains;
 637     GString *drc_names, *drc_types;
 638     int ret;
 639
 640     /* the first entry of each properties is a 32-bit integer encoding
 641      * the number of elements in the array. we won't know this until
 642      * we complete the iteration through all the matching DRCs, but
 643      * reserve the space now and set the offsets accordingly so we
 644      * can fill them in later.
 645      */
 646     drc_indexes = g_array_new(false, true, sizeof(uint32_t));
 647     drc_indexes = g_array_set_size(drc_indexes, 1);
 648     drc_power_domains = g_array_new(false, true, sizeof(uint32_t));
 649     drc_power_domains = g_array_set_size(drc_power_domains, 1);
 650     drc_names = g_string_set_size(g_string_new(NULL), sizeof(uint32_t));
 651     drc_types = g_string_set_size(g_string_new(NULL), sizeof(uint32_t));
 652
 653     /* aliases for all DRConnector objects will be rooted in QOM
 654      * composition tree at DRC_CONTAINER_PATH
 655      */
 656     root_container = container_get(object_get_root(), DRC_CONTAINER_PATH);
 657
 658     QTAILQ_FOREACH(prop, &root_container->properties, node) {
 659         Object *obj;
 660         sPAPRDRConnector *drc;
 661         sPAPRDRConnectorClass *drck;
 662         uint32_t drc_index, drc_power_domain;
 663
 664         if (!strstart(prop->type, "link<", NULL)) {
 665             continue;
 666         }
 667
 668         obj = object_property_get_link(root_container, prop->name, NULL);
 669         drc = SPAPR_DR_CONNECTOR(obj);
 670         drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 671
 672         if (owner && (drc->owner != owner)) {
 673             continue;
 674         }
 675
 676         if ((drc->type & drc_type_mask) == 0) {
 677             continue;
 678         }
 679
 680         drc_count++;
 681
 682         /* ibm,drc-indexes */
 683         drc_index = cpu_to_be32(drck->get_index(drc));
 684         g_array_append_val(drc_indexes, drc_index);
 685
 686         /* ibm,drc-power-domains */
 687         drc_power_domain = cpu_to_be32(-1);
 688         g_array_append_val(drc_power_domains, drc_power_domain);
 689
 690         /* ibm,drc-names */
 691         drc_names = g_string_append(drc_names, drck->get_name(drc));
 692         drc_names = g_string_insert_len(drc_names, -1, "\0", 1);
 693
 694         /* ibm,drc-types */
 695         drc_types = g_string_append(drc_types,
 696                                     spapr_drc_get_type_str(drc->type));
 697         drc_types = g_string_insert_len(drc_types, -1, "\0", 1);
 698     }
 699
 700     /* now write the drc count into the space we reserved at the
 701      * beginning of the arrays previously
 702      */
 703     *(uint32_t *)drc_indexes->data = cpu_to_be32(drc_count);
 704     *(uint32_t *)drc_power_domains->data = cpu_to_be32(drc_count);
 705     *(uint32_t *)drc_names->str = cpu_to_be32(drc_count);
 706     *(uint32_t *)drc_types->str = cpu_to_be32(drc_count);
 707
 708     ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-indexes",
 709                       drc_indexes->data,
 710                       drc_indexes->len * sizeof(uint32_t));
 711     if (ret) {
 712         fprintf(stderr, "Couldn't create ibm,drc-indexes property\n");
 713         goto out;
 714     }
 715
 716     ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-power-domains",
 717                       drc_power_domains->data,
 718                       drc_power_domains->len * sizeof(uint32_t));
 719     if (ret) {
 720         fprintf(stderr, "Couldn't finalize ibm,drc-power-domains property\n");
 721         goto out;
 722     }
 723
 724     ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-names",
 725                       drc_names->str, drc_names->len);
 726     if (ret) {
 727         fprintf(stderr, "Couldn't finalize ibm,drc-names property\n");
 728         goto out;
 729     }
 730
 731     ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-types",
 732                       drc_types->str, drc_types->len);
 733     if (ret) {
 734         fprintf(stderr, "Couldn't finalize ibm,drc-types property\n");
 735         goto out;
 736     }
 737
 738 out:
 739     g_array_free(drc_indexes, true);
 740     g_array_free(drc_power_domains, true);
 741     g_string_free(drc_names, true);
 742     g_string_free(drc_types, true);
 743
 744     return ret;
 745 }