1bbf5c878SMichael Roth /* 2bbf5c878SMichael Roth * QEMU SPAPR Dynamic Reconfiguration Connector Implementation 3bbf5c878SMichael Roth * 4bbf5c878SMichael Roth * Copyright IBM Corp. 2014 5bbf5c878SMichael Roth * 6bbf5c878SMichael Roth * Authors: 7bbf5c878SMichael Roth * Michael Roth <mdroth@linux.vnet.ibm.com> 8bbf5c878SMichael Roth * 9bbf5c878SMichael Roth * This work is licensed under the terms of the GNU GPL, version 2 or later. 10bbf5c878SMichael Roth * See the COPYING file in the top-level directory. 11bbf5c878SMichael Roth */ 12bbf5c878SMichael Roth 130d75590dSPeter Maydell #include "qemu/osdep.h" 14da34e65cSMarkus Armbruster #include "qapi/error.h" 1515280c36SMarkus Armbruster #include "qapi/qmp/qnull.h" 164771d756SPaolo Bonzini #include "cpu.h" 17f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 18bbf5c878SMichael Roth #include "hw/ppc/spapr_drc.h" 19bbf5c878SMichael Roth #include "qom/object.h" 20bbf5c878SMichael Roth #include "hw/qdev.h" 21bbf5c878SMichael Roth #include "qapi/visitor.h" 22bbf5c878SMichael Roth #include "qemu/error-report.h" 230cb688d2SMichael Roth #include "hw/ppc/spapr.h" /* for RTAS return codes */ 2431834723SDaniel Henrique Barboza #include "hw/pci-host/spapr.h" /* spapr_phb_remove_pci_device_cb callback */ 25d9c95c71SGreg Kurz #include "sysemu/device_tree.h" 26*71e8a915SMarkus Armbruster #include "sysemu/reset.h" 2724ac7755SLaurent Vivier #include "trace.h" 28bbf5c878SMichael Roth 29bbf5c878SMichael Roth #define DRC_CONTAINER_PATH "/dr-connector" 30bbf5c878SMichael Roth #define DRC_INDEX_TYPE_SHIFT 28 31627c2ef7SDavid Gibson #define DRC_INDEX_ID_MASK ((1ULL << DRC_INDEX_TYPE_SHIFT) - 1) 32bbf5c878SMichael Roth 33ce2918cbSDavid Gibson SpaprDrcType spapr_drc_type(SpaprDrc *drc) 342d335818SDavid Gibson { 35ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 362d335818SDavid Gibson 372d335818SDavid Gibson return 1 << drck->typeshift; 382d335818SDavid Gibson } 392d335818SDavid Gibson 40ce2918cbSDavid Gibson uint32_t spapr_drc_index(SpaprDrc *drc) 41bbf5c878SMichael Roth { 42ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 432d335818SDavid Gibson 44bbf5c878SMichael Roth /* no set format for a drc index: it only needs to be globally 45bbf5c878SMichael Roth * unique. this is how we encode the DRC type on bare-metal 46bbf5c878SMichael Roth * however, so might as well do that here 47bbf5c878SMichael Roth */ 482d335818SDavid Gibson return (drck->typeshift << DRC_INDEX_TYPE_SHIFT) 492d335818SDavid Gibson | (drc->id & DRC_INDEX_ID_MASK); 50bbf5c878SMichael Roth } 51bbf5c878SMichael Roth 52ce2918cbSDavid Gibson static uint32_t drc_isolate_physical(SpaprDrc *drc) 53bbf5c878SMichael Roth { 549d4c0f4fSDavid Gibson switch (drc->state) { 559d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_PHYSICAL_POWERON: 569d4c0f4fSDavid Gibson return RTAS_OUT_SUCCESS; /* Nothing to do */ 579d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED: 589d4c0f4fSDavid Gibson break; /* see below */ 599d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE: 609d4c0f4fSDavid Gibson return RTAS_OUT_PARAM_ERROR; /* not allowed */ 619d4c0f4fSDavid Gibson default: 629d4c0f4fSDavid Gibson g_assert_not_reached(); 639d4c0f4fSDavid Gibson } 649d4c0f4fSDavid Gibson 659d4c0f4fSDavid Gibson drc->state = SPAPR_DRC_STATE_PHYSICAL_POWERON; 669d1852ceSMichael Roth 67f1c52354SDavid Gibson if (drc->unplug_requested) { 680b55aa91SDavid Gibson uint32_t drc_index = spapr_drc_index(drc); 690b55aa91SDavid Gibson trace_spapr_drc_set_isolation_state_finalizing(drc_index); 70a8dc47fdSDavid Gibson spapr_drc_detach(drc); 71bbf5c878SMichael Roth } 720dfabd39SDavid Gibson 730dfabd39SDavid Gibson return RTAS_OUT_SUCCESS; 74bbf5c878SMichael Roth } 75bbf5c878SMichael Roth 76ce2918cbSDavid Gibson static uint32_t drc_unisolate_physical(SpaprDrc *drc) 770dfabd39SDavid Gibson { 789d4c0f4fSDavid Gibson switch (drc->state) { 799d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_PHYSICAL_UNISOLATE: 809d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_PHYSICAL_CONFIGURED: 819d4c0f4fSDavid Gibson return RTAS_OUT_SUCCESS; /* Nothing to do */ 829d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_PHYSICAL_POWERON: 839d4c0f4fSDavid Gibson break; /* see below */ 849d4c0f4fSDavid Gibson default: 859d4c0f4fSDavid Gibson g_assert_not_reached(); 869d4c0f4fSDavid Gibson } 879d4c0f4fSDavid Gibson 880dfabd39SDavid Gibson /* cannot unisolate a non-existent resource, and, or resources 890dfabd39SDavid Gibson * which are in an 'UNUSABLE' allocation state. (PAPR 2.7, 900dfabd39SDavid Gibson * 13.5.3.5) 910dfabd39SDavid Gibson */ 920dfabd39SDavid Gibson if (!drc->dev) { 930dfabd39SDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; 940dfabd39SDavid Gibson } 950dfabd39SDavid Gibson 969d4c0f4fSDavid Gibson drc->state = SPAPR_DRC_STATE_PHYSICAL_UNISOLATE; 974445b1d2SDavid Gibson drc->ccs_offset = drc->fdt_start_offset; 984445b1d2SDavid Gibson drc->ccs_depth = 0; 990dfabd39SDavid Gibson 1000dfabd39SDavid Gibson return RTAS_OUT_SUCCESS; 1010dfabd39SDavid Gibson } 1020dfabd39SDavid Gibson 103ce2918cbSDavid Gibson static uint32_t drc_isolate_logical(SpaprDrc *drc) 1040dfabd39SDavid Gibson { 1059d4c0f4fSDavid Gibson switch (drc->state) { 1069d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 1079d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 1089d4c0f4fSDavid Gibson return RTAS_OUT_SUCCESS; /* Nothing to do */ 1099d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 1109d4c0f4fSDavid Gibson break; /* see below */ 1119d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 1129d4c0f4fSDavid Gibson return RTAS_OUT_PARAM_ERROR; /* not allowed */ 1139d4c0f4fSDavid Gibson default: 1149d4c0f4fSDavid Gibson g_assert_not_reached(); 1159d4c0f4fSDavid Gibson } 1169d4c0f4fSDavid Gibson 1170dfabd39SDavid Gibson /* 1180dfabd39SDavid Gibson * Fail any requests to ISOLATE the LMB DRC if this LMB doesn't 1190dfabd39SDavid Gibson * belong to a DIMM device that is marked for removal. 1200dfabd39SDavid Gibson * 1210dfabd39SDavid Gibson * Currently the guest userspace tool drmgr that drives the memory 1220dfabd39SDavid Gibson * hotplug/unplug will just try to remove a set of 'removable' LMBs 1230dfabd39SDavid Gibson * in response to a hot unplug request that is based on drc-count. 1240dfabd39SDavid Gibson * If the LMB being removed doesn't belong to a DIMM device that is 1250dfabd39SDavid Gibson * actually being unplugged, fail the isolation request here. 1260dfabd39SDavid Gibson */ 1270dfabd39SDavid Gibson if (spapr_drc_type(drc) == SPAPR_DR_CONNECTOR_TYPE_LMB 128f1c52354SDavid Gibson && !drc->unplug_requested) { 1290dfabd39SDavid Gibson return RTAS_OUT_HW_ERROR; 1300dfabd39SDavid Gibson } 1310dfabd39SDavid Gibson 1329d4c0f4fSDavid Gibson drc->state = SPAPR_DRC_STATE_LOGICAL_AVAILABLE; 1330dfabd39SDavid Gibson 1340dfabd39SDavid Gibson /* if we're awaiting release, but still in an unconfigured state, 1350dfabd39SDavid Gibson * it's likely the guest is still in the process of configuring 1360dfabd39SDavid Gibson * the device and is transitioning the devices to an ISOLATED 1370dfabd39SDavid Gibson * state as a part of that process. so we only complete the 1380dfabd39SDavid Gibson * removal when this transition happens for a device in a 1390dfabd39SDavid Gibson * configured state, as suggested by the state diagram from PAPR+ 1400dfabd39SDavid Gibson * 2.7, 13.4 1410dfabd39SDavid Gibson */ 142f1c52354SDavid Gibson if (drc->unplug_requested) { 1430dfabd39SDavid Gibson uint32_t drc_index = spapr_drc_index(drc); 1440dfabd39SDavid Gibson trace_spapr_drc_set_isolation_state_finalizing(drc_index); 145a8dc47fdSDavid Gibson spapr_drc_detach(drc); 1460dfabd39SDavid Gibson } 1470dfabd39SDavid Gibson return RTAS_OUT_SUCCESS; 1480dfabd39SDavid Gibson } 1490dfabd39SDavid Gibson 150ce2918cbSDavid Gibson static uint32_t drc_unisolate_logical(SpaprDrc *drc) 1510dfabd39SDavid Gibson { 1529d4c0f4fSDavid Gibson switch (drc->state) { 1539d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 1549d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 1559d4c0f4fSDavid Gibson return RTAS_OUT_SUCCESS; /* Nothing to do */ 1569d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 1579d4c0f4fSDavid Gibson break; /* see below */ 1589d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 1599d4c0f4fSDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; /* not allowed */ 1609d4c0f4fSDavid Gibson default: 1619d4c0f4fSDavid Gibson g_assert_not_reached(); 1620dfabd39SDavid Gibson } 1630dfabd39SDavid Gibson 1649d4c0f4fSDavid Gibson /* Move to AVAILABLE state should have ensured device was present */ 1659d4c0f4fSDavid Gibson g_assert(drc->dev); 1660dfabd39SDavid Gibson 1679d4c0f4fSDavid Gibson drc->state = SPAPR_DRC_STATE_LOGICAL_UNISOLATE; 1684445b1d2SDavid Gibson drc->ccs_offset = drc->fdt_start_offset; 1694445b1d2SDavid Gibson drc->ccs_depth = 0; 1704445b1d2SDavid Gibson 1710cb688d2SMichael Roth return RTAS_OUT_SUCCESS; 172bbf5c878SMichael Roth } 173bbf5c878SMichael Roth 174ce2918cbSDavid Gibson static uint32_t drc_set_usable(SpaprDrc *drc) 175bbf5c878SMichael Roth { 1769d4c0f4fSDavid Gibson switch (drc->state) { 1779d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 1789d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 1799d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 1809d4c0f4fSDavid Gibson return RTAS_OUT_SUCCESS; /* Nothing to do */ 1819d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 1829d4c0f4fSDavid Gibson break; /* see below */ 1839d4c0f4fSDavid Gibson default: 1849d4c0f4fSDavid Gibson g_assert_not_reached(); 1859d4c0f4fSDavid Gibson } 1869d4c0f4fSDavid Gibson 1879d1852ceSMichael Roth /* if there's no resource/device associated with the DRC, there's 1889d1852ceSMichael Roth * no way for us to put it in an allocation state consistent with 1899d1852ceSMichael Roth * being 'USABLE'. PAPR 2.7, 13.5.3.4 documents that this should 1909d1852ceSMichael Roth * result in an RTAS return code of -3 / "no such indicator" 1919d1852ceSMichael Roth */ 1929d1852ceSMichael Roth if (!drc->dev) { 1939d1852ceSMichael Roth return RTAS_OUT_NO_SUCH_INDICATOR; 1949d1852ceSMichael Roth } 195f1c52354SDavid Gibson if (drc->unplug_requested) { 19682a93a1dSDavid Gibson /* Don't allow the guest to move a device away from UNUSABLE 19782a93a1dSDavid Gibson * state when we want to unplug it */ 19861736732SDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; 1999d1852ceSMichael Roth } 2009d1852ceSMichael Roth 2019d4c0f4fSDavid Gibson drc->state = SPAPR_DRC_STATE_LOGICAL_AVAILABLE; 20261736732SDavid Gibson 20361736732SDavid Gibson return RTAS_OUT_SUCCESS; 20461736732SDavid Gibson } 20561736732SDavid Gibson 206ce2918cbSDavid Gibson static uint32_t drc_set_unusable(SpaprDrc *drc) 20761736732SDavid Gibson { 2089d4c0f4fSDavid Gibson switch (drc->state) { 2099d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 2109d4c0f4fSDavid Gibson return RTAS_OUT_SUCCESS; /* Nothing to do */ 2119d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 2129d4c0f4fSDavid Gibson break; /* see below */ 2139d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 2149d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 2159d4c0f4fSDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; /* not allowed */ 2169d4c0f4fSDavid Gibson default: 2179d4c0f4fSDavid Gibson g_assert_not_reached(); 2189d4c0f4fSDavid Gibson } 2199d4c0f4fSDavid Gibson 2209d4c0f4fSDavid Gibson drc->state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE; 221f1c52354SDavid Gibson if (drc->unplug_requested) { 2220b55aa91SDavid Gibson uint32_t drc_index = spapr_drc_index(drc); 2230b55aa91SDavid Gibson trace_spapr_drc_set_allocation_state_finalizing(drc_index); 224a8dc47fdSDavid Gibson spapr_drc_detach(drc); 225bbf5c878SMichael Roth } 22661736732SDavid Gibson 2270cb688d2SMichael Roth return RTAS_OUT_SUCCESS; 228bbf5c878SMichael Roth } 229bbf5c878SMichael Roth 230ce2918cbSDavid Gibson static const char *spapr_drc_name(SpaprDrc *drc) 231bbf5c878SMichael Roth { 232ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 23379808336SDavid Gibson 23479808336SDavid Gibson /* human-readable name for a DRC to encode into the DT 23579808336SDavid Gibson * description. this is mainly only used within a guest in place 23679808336SDavid Gibson * of the unique DRC index. 23779808336SDavid Gibson * 23879808336SDavid Gibson * in the case of VIO/PCI devices, it corresponds to a "location 23979808336SDavid Gibson * code" that maps a logical device/function (DRC index) to a 24079808336SDavid Gibson * physical (or virtual in the case of VIO) location in the system 24179808336SDavid Gibson * by chaining together the "location label" for each 24279808336SDavid Gibson * encapsulating component. 24379808336SDavid Gibson * 24479808336SDavid Gibson * since this is more to do with diagnosing physical hardware 24579808336SDavid Gibson * issues than guest compatibility, we choose location codes/DRC 24679808336SDavid Gibson * names that adhere to the documented format, but avoid encoding 24779808336SDavid Gibson * the entire topology information into the label/code, instead 24879808336SDavid Gibson * just using the location codes based on the labels for the 24979808336SDavid Gibson * endpoints (VIO/PCI adaptor connectors), which is basically just 25079808336SDavid Gibson * "C" followed by an integer ID. 25179808336SDavid Gibson * 25279808336SDavid Gibson * DRC names as documented by PAPR+ v2.7, 13.5.2.4 25379808336SDavid Gibson * location codes as documented by PAPR+ v2.7, 12.3.1.5 25479808336SDavid Gibson */ 25579808336SDavid Gibson return g_strdup_printf("%s%d", drck->drc_name_prefix, drc->id); 256bbf5c878SMichael Roth } 257bbf5c878SMichael Roth 258bbf5c878SMichael Roth /* 259bbf5c878SMichael Roth * dr-entity-sense sensor value 260bbf5c878SMichael Roth * returned via get-sensor-state RTAS calls 261bbf5c878SMichael Roth * as expected by state diagram in PAPR+ 2.7, 13.4 262bbf5c878SMichael Roth * based on the current allocation/indicator/power states 263bbf5c878SMichael Roth * for the DR connector. 264bbf5c878SMichael Roth */ 265ce2918cbSDavid Gibson static SpaprDREntitySense physical_entity_sense(SpaprDrc *drc) 266bbf5c878SMichael Roth { 267f224d35bSDavid Gibson /* this assumes all PCI devices are assigned to a 'live insertion' 268f224d35bSDavid Gibson * power domain, where QEMU manages power state automatically as 269f224d35bSDavid Gibson * opposed to the guest. present, non-PCI resources are unaffected 270f224d35bSDavid Gibson * by power state. 271bbf5c878SMichael Roth */ 272f224d35bSDavid Gibson return drc->dev ? SPAPR_DR_ENTITY_SENSE_PRESENT 273f224d35bSDavid Gibson : SPAPR_DR_ENTITY_SENSE_EMPTY; 274bbf5c878SMichael Roth } 275bbf5c878SMichael Roth 276ce2918cbSDavid Gibson static SpaprDREntitySense logical_entity_sense(SpaprDrc *drc) 277f224d35bSDavid Gibson { 2789d4c0f4fSDavid Gibson switch (drc->state) { 2799d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNUSABLE: 280f224d35bSDavid Gibson return SPAPR_DR_ENTITY_SENSE_UNUSABLE; 2819d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_AVAILABLE: 2829d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_UNISOLATE: 2839d4c0f4fSDavid Gibson case SPAPR_DRC_STATE_LOGICAL_CONFIGURED: 2849d4c0f4fSDavid Gibson g_assert(drc->dev); 2859d4c0f4fSDavid Gibson return SPAPR_DR_ENTITY_SENSE_PRESENT; 2869d4c0f4fSDavid Gibson default: 2879d4c0f4fSDavid Gibson g_assert_not_reached(); 288f224d35bSDavid Gibson } 289bbf5c878SMichael Roth } 290bbf5c878SMichael Roth 291d7bce999SEric Blake static void prop_get_index(Object *obj, Visitor *v, const char *name, 292d7bce999SEric Blake void *opaque, Error **errp) 293bbf5c878SMichael Roth { 294ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(obj); 2950b55aa91SDavid Gibson uint32_t value = spapr_drc_index(drc); 29651e72bc1SEric Blake visit_type_uint32(v, name, &value, errp); 297bbf5c878SMichael Roth } 298bbf5c878SMichael Roth 299d7bce999SEric Blake static void prop_get_fdt(Object *obj, Visitor *v, const char *name, 300d7bce999SEric Blake void *opaque, Error **errp) 301bbf5c878SMichael Roth { 302ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(obj); 303d2f95f4dSMarkus Armbruster QNull *null = NULL; 304c75304a1SMarkus Armbruster Error *err = NULL; 305bbf5c878SMichael Roth int fdt_offset_next, fdt_offset, fdt_depth; 306bbf5c878SMichael Roth void *fdt; 307bbf5c878SMichael Roth 308bbf5c878SMichael Roth if (!drc->fdt) { 309d2f95f4dSMarkus Armbruster visit_type_null(v, NULL, &null, errp); 310cb3e7f08SMarc-André Lureau qobject_unref(null); 311bbf5c878SMichael Roth return; 312bbf5c878SMichael Roth } 313bbf5c878SMichael Roth 314bbf5c878SMichael Roth fdt = drc->fdt; 315bbf5c878SMichael Roth fdt_offset = drc->fdt_start_offset; 316bbf5c878SMichael Roth fdt_depth = 0; 317bbf5c878SMichael Roth 318bbf5c878SMichael Roth do { 319bbf5c878SMichael Roth const char *name = NULL; 320bbf5c878SMichael Roth const struct fdt_property *prop = NULL; 321bbf5c878SMichael Roth int prop_len = 0, name_len = 0; 322bbf5c878SMichael Roth uint32_t tag; 323bbf5c878SMichael Roth 324bbf5c878SMichael Roth tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next); 325bbf5c878SMichael Roth switch (tag) { 326bbf5c878SMichael Roth case FDT_BEGIN_NODE: 327bbf5c878SMichael Roth fdt_depth++; 328bbf5c878SMichael Roth name = fdt_get_name(fdt, fdt_offset, &name_len); 329337283dfSEric Blake visit_start_struct(v, name, NULL, 0, &err); 330c75304a1SMarkus Armbruster if (err) { 331c75304a1SMarkus Armbruster error_propagate(errp, err); 332c75304a1SMarkus Armbruster return; 333c75304a1SMarkus Armbruster } 334bbf5c878SMichael Roth break; 335bbf5c878SMichael Roth case FDT_END_NODE: 336bbf5c878SMichael Roth /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ 337bbf5c878SMichael Roth g_assert(fdt_depth > 0); 33815c2f669SEric Blake visit_check_struct(v, &err); 3391158bb2aSEric Blake visit_end_struct(v, NULL); 340c75304a1SMarkus Armbruster if (err) { 341c75304a1SMarkus Armbruster error_propagate(errp, err); 342c75304a1SMarkus Armbruster return; 343c75304a1SMarkus Armbruster } 344bbf5c878SMichael Roth fdt_depth--; 345bbf5c878SMichael Roth break; 346bbf5c878SMichael Roth case FDT_PROP: { 347bbf5c878SMichael Roth int i; 348bbf5c878SMichael Roth prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len); 349bbf5c878SMichael Roth name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff)); 350d9f62ddeSEric Blake visit_start_list(v, name, NULL, 0, &err); 351c75304a1SMarkus Armbruster if (err) { 352c75304a1SMarkus Armbruster error_propagate(errp, err); 353c75304a1SMarkus Armbruster return; 354bbf5c878SMichael Roth } 355c75304a1SMarkus Armbruster for (i = 0; i < prop_len; i++) { 35651e72bc1SEric Blake visit_type_uint8(v, NULL, (uint8_t *)&prop->data[i], &err); 357c75304a1SMarkus Armbruster if (err) { 358c75304a1SMarkus Armbruster error_propagate(errp, err); 359c75304a1SMarkus Armbruster return; 360c75304a1SMarkus Armbruster } 361c75304a1SMarkus Armbruster } 362a4a1c70dSMarkus Armbruster visit_check_list(v, &err); 3631158bb2aSEric Blake visit_end_list(v, NULL); 364a4a1c70dSMarkus Armbruster if (err) { 365a4a1c70dSMarkus Armbruster error_propagate(errp, err); 366a4a1c70dSMarkus Armbruster return; 367a4a1c70dSMarkus Armbruster } 368bbf5c878SMichael Roth break; 369bbf5c878SMichael Roth } 370bbf5c878SMichael Roth default: 371e20c6314SPhilippe Mathieu-Daudé error_report("device FDT in unexpected state: %d", tag); 372e20c6314SPhilippe Mathieu-Daudé abort(); 373bbf5c878SMichael Roth } 374bbf5c878SMichael Roth fdt_offset = fdt_offset_next; 375bbf5c878SMichael Roth } while (fdt_depth != 0); 376bbf5c878SMichael Roth } 377bbf5c878SMichael Roth 378ce2918cbSDavid Gibson void spapr_drc_attach(SpaprDrc *drc, DeviceState *d, Error **errp) 379bbf5c878SMichael Roth { 3800b55aa91SDavid Gibson trace_spapr_drc_attach(spapr_drc_index(drc)); 381bbf5c878SMichael Roth 3829d4c0f4fSDavid Gibson if (drc->dev) { 383bbf5c878SMichael Roth error_setg(errp, "an attached device is still awaiting release"); 384bbf5c878SMichael Roth return; 385bbf5c878SMichael Roth } 3869d4c0f4fSDavid Gibson g_assert((drc->state == SPAPR_DRC_STATE_LOGICAL_UNUSABLE) 3879d4c0f4fSDavid Gibson || (drc->state == SPAPR_DRC_STATE_PHYSICAL_POWERON)); 388bbf5c878SMichael Roth 389bbf5c878SMichael Roth drc->dev = d; 390d9c95c71SGreg Kurz 391bbf5c878SMichael Roth object_property_add_link(OBJECT(drc), "device", 392bbf5c878SMichael Roth object_get_typename(OBJECT(drc->dev)), 393bbf5c878SMichael Roth (Object **)(&drc->dev), 394bbf5c878SMichael Roth NULL, 0, NULL); 395bbf5c878SMichael Roth } 396bbf5c878SMichael Roth 397ce2918cbSDavid Gibson static void spapr_drc_release(SpaprDrc *drc) 398bbf5c878SMichael Roth { 399ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 4006b762f29SDavid Gibson 4016b762f29SDavid Gibson drck->release(drc->dev); 402bbf5c878SMichael Roth 403f1c52354SDavid Gibson drc->unplug_requested = false; 404bbf5c878SMichael Roth g_free(drc->fdt); 405bbf5c878SMichael Roth drc->fdt = NULL; 406bbf5c878SMichael Roth drc->fdt_start_offset = 0; 407ba50822fSDavid Gibson object_property_del(OBJECT(drc), "device", &error_abort); 408bbf5c878SMichael Roth drc->dev = NULL; 409bbf5c878SMichael Roth } 410bbf5c878SMichael Roth 411ce2918cbSDavid Gibson void spapr_drc_detach(SpaprDrc *drc) 4129c914e53SDavid Gibson { 413ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 4149d4c0f4fSDavid Gibson 4159c914e53SDavid Gibson trace_spapr_drc_detach(spapr_drc_index(drc)); 4169c914e53SDavid Gibson 4179d4c0f4fSDavid Gibson g_assert(drc->dev); 4189d4c0f4fSDavid Gibson 419f1c52354SDavid Gibson drc->unplug_requested = true; 420a8dc47fdSDavid Gibson 4219d4c0f4fSDavid Gibson if (drc->state != drck->empty_state) { 4229d4c0f4fSDavid Gibson trace_spapr_drc_awaiting_quiesce(spapr_drc_index(drc)); 4239c914e53SDavid Gibson return; 4249c914e53SDavid Gibson } 4259c914e53SDavid Gibson 4269c914e53SDavid Gibson spapr_drc_release(drc); 4279c914e53SDavid Gibson } 4289c914e53SDavid Gibson 429ce2918cbSDavid Gibson void spapr_drc_reset(SpaprDrc *drc) 430bbf5c878SMichael Roth { 431ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 4329d4c0f4fSDavid Gibson 4330b55aa91SDavid Gibson trace_spapr_drc_reset(spapr_drc_index(drc)); 434b8fdd530SDavid Gibson 435bbf5c878SMichael Roth /* immediately upon reset we can safely assume DRCs whose devices 4364f9242fcSDavid Gibson * are pending removal can be safely removed. 437bbf5c878SMichael Roth */ 438f1c52354SDavid Gibson if (drc->unplug_requested) { 4394f9242fcSDavid Gibson spapr_drc_release(drc); 440bbf5c878SMichael Roth } 441bbf5c878SMichael Roth 4424f9242fcSDavid Gibson if (drc->dev) { 4439d4c0f4fSDavid Gibson /* A device present at reset is ready to go, same as coldplugged */ 4449d4c0f4fSDavid Gibson drc->state = drck->ready_state; 445188bfe1bSBharata B Rao /* 446188bfe1bSBharata B Rao * Ensure that we are able to send the FDT fragment again 447188bfe1bSBharata B Rao * via configure-connector call if the guest requests. 448188bfe1bSBharata B Rao */ 449188bfe1bSBharata B Rao drc->ccs_offset = drc->fdt_start_offset; 450188bfe1bSBharata B Rao drc->ccs_depth = 0; 4514f9242fcSDavid Gibson } else { 4529d4c0f4fSDavid Gibson drc->state = drck->empty_state; 4534445b1d2SDavid Gibson drc->ccs_offset = -1; 4544445b1d2SDavid Gibson drc->ccs_depth = -1; 455bbf5c878SMichael Roth } 456188bfe1bSBharata B Rao } 457bbf5c878SMichael Roth 45810f12e64SDaniel Henrique Barboza bool spapr_drc_needed(void *opaque) 459a50919ddSDaniel Henrique Barboza { 460ce2918cbSDavid Gibson SpaprDrc *drc = (SpaprDrc *)opaque; 461ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 462a50919ddSDaniel Henrique Barboza 463a50919ddSDaniel Henrique Barboza /* If no dev is plugged in there is no need to migrate the DRC state */ 464c618e300SDaniel Henrique Barboza if (!drc->dev) { 465a50919ddSDaniel Henrique Barboza return false; 466a50919ddSDaniel Henrique Barboza } 467a50919ddSDaniel Henrique Barboza 468a50919ddSDaniel Henrique Barboza /* 4699d4c0f4fSDavid Gibson * We need to migrate the state if it's not equal to the expected 4709d4c0f4fSDavid Gibson * long-term state, which is the same as the coldplugged initial 4719d4c0f4fSDavid Gibson * state */ 4729d4c0f4fSDavid Gibson return (drc->state != drck->ready_state); 473a50919ddSDaniel Henrique Barboza } 474a50919ddSDaniel Henrique Barboza 475a50919ddSDaniel Henrique Barboza static const VMStateDescription vmstate_spapr_drc = { 476a50919ddSDaniel Henrique Barboza .name = "spapr_drc", 477a50919ddSDaniel Henrique Barboza .version_id = 1, 478a50919ddSDaniel Henrique Barboza .minimum_version_id = 1, 479a50919ddSDaniel Henrique Barboza .needed = spapr_drc_needed, 480a50919ddSDaniel Henrique Barboza .fields = (VMStateField []) { 481ce2918cbSDavid Gibson VMSTATE_UINT32(state, SpaprDrc), 482a50919ddSDaniel Henrique Barboza VMSTATE_END_OF_LIST() 483a50919ddSDaniel Henrique Barboza } 484a50919ddSDaniel Henrique Barboza }; 485a50919ddSDaniel Henrique Barboza 486bbf5c878SMichael Roth static void realize(DeviceState *d, Error **errp) 487bbf5c878SMichael Roth { 488ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(d); 489bbf5c878SMichael Roth Object *root_container; 490f5babeacSGreg Kurz gchar *link_name; 491bbf5c878SMichael Roth gchar *child_name; 492bbf5c878SMichael Roth Error *err = NULL; 493bbf5c878SMichael Roth 4940b55aa91SDavid Gibson trace_spapr_drc_realize(spapr_drc_index(drc)); 495bbf5c878SMichael Roth /* NOTE: we do this as part of realize/unrealize due to the fact 496bbf5c878SMichael Roth * that the guest will communicate with the DRC via RTAS calls 497bbf5c878SMichael Roth * referencing the global DRC index. By unlinking the DRC 498bbf5c878SMichael Roth * from DRC_CONTAINER_PATH/<drc_index> we effectively make it 499bbf5c878SMichael Roth * inaccessible by the guest, since lookups rely on this path 500bbf5c878SMichael Roth * existing in the composition tree 501bbf5c878SMichael Roth */ 502bbf5c878SMichael Roth root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 503f5babeacSGreg Kurz link_name = g_strdup_printf("%x", spapr_drc_index(drc)); 504bbf5c878SMichael Roth child_name = object_get_canonical_path_component(OBJECT(drc)); 5050b55aa91SDavid Gibson trace_spapr_drc_realize_child(spapr_drc_index(drc), child_name); 506bbf5c878SMichael Roth object_property_add_alias(root_container, link_name, 507bbf5c878SMichael Roth drc->owner, child_name, &err); 508586d2142SGonglei g_free(child_name); 509f5babeacSGreg Kurz g_free(link_name); 510bf26ae32SGreg Kurz if (err) { 511bf26ae32SGreg Kurz error_propagate(errp, err); 512bf26ae32SGreg Kurz return; 513bf26ae32SGreg Kurz } 5140b55aa91SDavid Gibson vmstate_register(DEVICE(drc), spapr_drc_index(drc), &vmstate_spapr_drc, 515a50919ddSDaniel Henrique Barboza drc); 5160b55aa91SDavid Gibson trace_spapr_drc_realize_complete(spapr_drc_index(drc)); 517bbf5c878SMichael Roth } 518bbf5c878SMichael Roth 519bbf5c878SMichael Roth static void unrealize(DeviceState *d, Error **errp) 520bbf5c878SMichael Roth { 521ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(d); 522bbf5c878SMichael Roth Object *root_container; 523f5babeacSGreg Kurz gchar *name; 524bbf5c878SMichael Roth 5250b55aa91SDavid Gibson trace_spapr_drc_unrealize(spapr_drc_index(drc)); 526bf26ae32SGreg Kurz vmstate_unregister(DEVICE(drc), &vmstate_spapr_drc, drc); 527bbf5c878SMichael Roth root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 528f5babeacSGreg Kurz name = g_strdup_printf("%x", spapr_drc_index(drc)); 529bf26ae32SGreg Kurz object_property_del(root_container, name, errp); 530f5babeacSGreg Kurz g_free(name); 531bbf5c878SMichael Roth } 532bbf5c878SMichael Roth 533ce2918cbSDavid Gibson SpaprDrc *spapr_dr_connector_new(Object *owner, const char *type, 534bbf5c878SMichael Roth uint32_t id) 535bbf5c878SMichael Roth { 536ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(object_new(type)); 53794649d42SDavid Gibson char *prop_name; 538bbf5c878SMichael Roth 539bbf5c878SMichael Roth drc->id = id; 540bbf5c878SMichael Roth drc->owner = owner; 5410b55aa91SDavid Gibson prop_name = g_strdup_printf("dr-connector[%"PRIu32"]", 5420b55aa91SDavid Gibson spapr_drc_index(drc)); 543325837caSGreg Kurz object_property_add_child(owner, prop_name, OBJECT(drc), &error_abort); 544f3f41030SMichael Roth object_unref(OBJECT(drc)); 545bbf5c878SMichael Roth object_property_set_bool(OBJECT(drc), true, "realized", NULL); 54694649d42SDavid Gibson g_free(prop_name); 547bbf5c878SMichael Roth 548bbf5c878SMichael Roth return drc; 549bbf5c878SMichael Roth } 550bbf5c878SMichael Roth 551bbf5c878SMichael Roth static void spapr_dr_connector_instance_init(Object *obj) 552bbf5c878SMichael Roth { 553ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(obj); 554ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 555bbf5c878SMichael Roth 556bbf5c878SMichael Roth object_property_add_uint32_ptr(obj, "id", &drc->id, NULL); 557bbf5c878SMichael Roth object_property_add(obj, "index", "uint32", prop_get_index, 558bbf5c878SMichael Roth NULL, NULL, NULL, NULL); 559bbf5c878SMichael Roth object_property_add(obj, "fdt", "struct", prop_get_fdt, 560bbf5c878SMichael Roth NULL, NULL, NULL, NULL); 5619d4c0f4fSDavid Gibson drc->state = drck->empty_state; 562bbf5c878SMichael Roth } 563bbf5c878SMichael Roth 564bbf5c878SMichael Roth static void spapr_dr_connector_class_init(ObjectClass *k, void *data) 565bbf5c878SMichael Roth { 566bbf5c878SMichael Roth DeviceClass *dk = DEVICE_CLASS(k); 567bbf5c878SMichael Roth 568bbf5c878SMichael Roth dk->realize = realize; 569bbf5c878SMichael Roth dk->unrealize = unrealize; 570c401ae8cSMarkus Armbruster /* 571c401ae8cSMarkus Armbruster * Reason: it crashes FIXME find and document the real reason 572c401ae8cSMarkus Armbruster */ 573e90f2a8cSEduardo Habkost dk->user_creatable = false; 574bbf5c878SMichael Roth } 575bbf5c878SMichael Roth 57667fea71bSDavid Gibson static bool drc_physical_needed(void *opaque) 57767fea71bSDavid Gibson { 578ce2918cbSDavid Gibson SpaprDrcPhysical *drcp = (SpaprDrcPhysical *)opaque; 579ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(drcp); 58067fea71bSDavid Gibson 58167fea71bSDavid Gibson if ((drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_ACTIVE)) 58267fea71bSDavid Gibson || (!drc->dev && (drcp->dr_indicator == SPAPR_DR_INDICATOR_INACTIVE))) { 58367fea71bSDavid Gibson return false; 58467fea71bSDavid Gibson } 58567fea71bSDavid Gibson return true; 58667fea71bSDavid Gibson } 58767fea71bSDavid Gibson 58867fea71bSDavid Gibson static const VMStateDescription vmstate_spapr_drc_physical = { 58967fea71bSDavid Gibson .name = "spapr_drc/physical", 59067fea71bSDavid Gibson .version_id = 1, 59167fea71bSDavid Gibson .minimum_version_id = 1, 59267fea71bSDavid Gibson .needed = drc_physical_needed, 59367fea71bSDavid Gibson .fields = (VMStateField []) { 594ce2918cbSDavid Gibson VMSTATE_UINT32(dr_indicator, SpaprDrcPhysical), 59567fea71bSDavid Gibson VMSTATE_END_OF_LIST() 59667fea71bSDavid Gibson } 59767fea71bSDavid Gibson }; 59867fea71bSDavid Gibson 59967fea71bSDavid Gibson static void drc_physical_reset(void *opaque) 60067fea71bSDavid Gibson { 601ce2918cbSDavid Gibson SpaprDrc *drc = SPAPR_DR_CONNECTOR(opaque); 602ce2918cbSDavid Gibson SpaprDrcPhysical *drcp = SPAPR_DRC_PHYSICAL(drc); 60367fea71bSDavid Gibson 60467fea71bSDavid Gibson if (drc->dev) { 60567fea71bSDavid Gibson drcp->dr_indicator = SPAPR_DR_INDICATOR_ACTIVE; 60667fea71bSDavid Gibson } else { 60767fea71bSDavid Gibson drcp->dr_indicator = SPAPR_DR_INDICATOR_INACTIVE; 60867fea71bSDavid Gibson } 60967fea71bSDavid Gibson } 61067fea71bSDavid Gibson 61167fea71bSDavid Gibson static void realize_physical(DeviceState *d, Error **errp) 61267fea71bSDavid Gibson { 613ce2918cbSDavid Gibson SpaprDrcPhysical *drcp = SPAPR_DRC_PHYSICAL(d); 61467fea71bSDavid Gibson Error *local_err = NULL; 61567fea71bSDavid Gibson 61667fea71bSDavid Gibson realize(d, &local_err); 61767fea71bSDavid Gibson if (local_err) { 61867fea71bSDavid Gibson error_propagate(errp, local_err); 61967fea71bSDavid Gibson return; 62067fea71bSDavid Gibson } 62167fea71bSDavid Gibson 62267fea71bSDavid Gibson vmstate_register(DEVICE(drcp), spapr_drc_index(SPAPR_DR_CONNECTOR(drcp)), 62367fea71bSDavid Gibson &vmstate_spapr_drc_physical, drcp); 62467fea71bSDavid Gibson qemu_register_reset(drc_physical_reset, drcp); 62567fea71bSDavid Gibson } 62667fea71bSDavid Gibson 627379ae096SGreg Kurz static void unrealize_physical(DeviceState *d, Error **errp) 628379ae096SGreg Kurz { 629ce2918cbSDavid Gibson SpaprDrcPhysical *drcp = SPAPR_DRC_PHYSICAL(d); 630379ae096SGreg Kurz Error *local_err = NULL; 631379ae096SGreg Kurz 632379ae096SGreg Kurz unrealize(d, &local_err); 633379ae096SGreg Kurz if (local_err) { 634379ae096SGreg Kurz error_propagate(errp, local_err); 635379ae096SGreg Kurz return; 636379ae096SGreg Kurz } 637379ae096SGreg Kurz 638379ae096SGreg Kurz vmstate_unregister(DEVICE(drcp), &vmstate_spapr_drc_physical, drcp); 639379ae096SGreg Kurz qemu_unregister_reset(drc_physical_reset, drcp); 640379ae096SGreg Kurz } 641379ae096SGreg Kurz 642f224d35bSDavid Gibson static void spapr_drc_physical_class_init(ObjectClass *k, void *data) 643f224d35bSDavid Gibson { 64467fea71bSDavid Gibson DeviceClass *dk = DEVICE_CLASS(k); 645ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 646f224d35bSDavid Gibson 64767fea71bSDavid Gibson dk->realize = realize_physical; 648379ae096SGreg Kurz dk->unrealize = unrealize_physical; 649f224d35bSDavid Gibson drck->dr_entity_sense = physical_entity_sense; 6500dfabd39SDavid Gibson drck->isolate = drc_isolate_physical; 6510dfabd39SDavid Gibson drck->unisolate = drc_unisolate_physical; 6529d4c0f4fSDavid Gibson drck->ready_state = SPAPR_DRC_STATE_PHYSICAL_CONFIGURED; 6539d4c0f4fSDavid Gibson drck->empty_state = SPAPR_DRC_STATE_PHYSICAL_POWERON; 654f224d35bSDavid Gibson } 655f224d35bSDavid Gibson 656f224d35bSDavid Gibson static void spapr_drc_logical_class_init(ObjectClass *k, void *data) 657f224d35bSDavid Gibson { 658ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 659f224d35bSDavid Gibson 660f224d35bSDavid Gibson drck->dr_entity_sense = logical_entity_sense; 6610dfabd39SDavid Gibson drck->isolate = drc_isolate_logical; 6620dfabd39SDavid Gibson drck->unisolate = drc_unisolate_logical; 6639d4c0f4fSDavid Gibson drck->ready_state = SPAPR_DRC_STATE_LOGICAL_CONFIGURED; 6649d4c0f4fSDavid Gibson drck->empty_state = SPAPR_DRC_STATE_LOGICAL_UNUSABLE; 665f224d35bSDavid Gibson } 666f224d35bSDavid Gibson 6672d335818SDavid Gibson static void spapr_drc_cpu_class_init(ObjectClass *k, void *data) 6682d335818SDavid Gibson { 669ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 6702d335818SDavid Gibson 6712d335818SDavid Gibson drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU; 6721693ea16SDavid Gibson drck->typename = "CPU"; 67379808336SDavid Gibson drck->drc_name_prefix = "CPU "; 6746b762f29SDavid Gibson drck->release = spapr_core_release; 675345b12b9SGreg Kurz drck->dt_populate = spapr_core_dt_populate; 6762d335818SDavid Gibson } 6772d335818SDavid Gibson 6782d335818SDavid Gibson static void spapr_drc_pci_class_init(ObjectClass *k, void *data) 6792d335818SDavid Gibson { 680ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 6812d335818SDavid Gibson 6822d335818SDavid Gibson drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI; 6831693ea16SDavid Gibson drck->typename = "28"; 68479808336SDavid Gibson drck->drc_name_prefix = "C"; 6856b762f29SDavid Gibson drck->release = spapr_phb_remove_pci_device_cb; 68646fd0299SGreg Kurz drck->dt_populate = spapr_pci_dt_populate; 6872d335818SDavid Gibson } 6882d335818SDavid Gibson 6892d335818SDavid Gibson static void spapr_drc_lmb_class_init(ObjectClass *k, void *data) 6902d335818SDavid Gibson { 691ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 6922d335818SDavid Gibson 6932d335818SDavid Gibson drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB; 6941693ea16SDavid Gibson drck->typename = "MEM"; 69579808336SDavid Gibson drck->drc_name_prefix = "LMB "; 6966b762f29SDavid Gibson drck->release = spapr_lmb_release; 69762d38c9bSGreg Kurz drck->dt_populate = spapr_lmb_dt_populate; 6982d335818SDavid Gibson } 6992d335818SDavid Gibson 700962b6c36SMichael Roth static void spapr_drc_phb_class_init(ObjectClass *k, void *data) 701962b6c36SMichael Roth { 702ce2918cbSDavid Gibson SpaprDrcClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); 703962b6c36SMichael Roth 704962b6c36SMichael Roth drck->typeshift = SPAPR_DR_CONNECTOR_TYPE_SHIFT_PHB; 705962b6c36SMichael Roth drck->typename = "PHB"; 706962b6c36SMichael Roth drck->drc_name_prefix = "PHB "; 707bb2bdd81SGreg Kurz drck->release = spapr_phb_release; 708bb2bdd81SGreg Kurz drck->dt_populate = spapr_phb_dt_populate; 709962b6c36SMichael Roth } 710962b6c36SMichael Roth 711bbf5c878SMichael Roth static const TypeInfo spapr_dr_connector_info = { 712bbf5c878SMichael Roth .name = TYPE_SPAPR_DR_CONNECTOR, 713bbf5c878SMichael Roth .parent = TYPE_DEVICE, 714ce2918cbSDavid Gibson .instance_size = sizeof(SpaprDrc), 715bbf5c878SMichael Roth .instance_init = spapr_dr_connector_instance_init, 716ce2918cbSDavid Gibson .class_size = sizeof(SpaprDrcClass), 717bbf5c878SMichael Roth .class_init = spapr_dr_connector_class_init, 7182d335818SDavid Gibson .abstract = true, 7192d335818SDavid Gibson }; 7202d335818SDavid Gibson 7212d335818SDavid Gibson static const TypeInfo spapr_drc_physical_info = { 7222d335818SDavid Gibson .name = TYPE_SPAPR_DRC_PHYSICAL, 7232d335818SDavid Gibson .parent = TYPE_SPAPR_DR_CONNECTOR, 724ce2918cbSDavid Gibson .instance_size = sizeof(SpaprDrcPhysical), 725f224d35bSDavid Gibson .class_init = spapr_drc_physical_class_init, 7262d335818SDavid Gibson .abstract = true, 7272d335818SDavid Gibson }; 7282d335818SDavid Gibson 7292d335818SDavid Gibson static const TypeInfo spapr_drc_logical_info = { 7302d335818SDavid Gibson .name = TYPE_SPAPR_DRC_LOGICAL, 7312d335818SDavid Gibson .parent = TYPE_SPAPR_DR_CONNECTOR, 732f224d35bSDavid Gibson .class_init = spapr_drc_logical_class_init, 7332d335818SDavid Gibson .abstract = true, 7342d335818SDavid Gibson }; 7352d335818SDavid Gibson 7362d335818SDavid Gibson static const TypeInfo spapr_drc_cpu_info = { 7372d335818SDavid Gibson .name = TYPE_SPAPR_DRC_CPU, 7382d335818SDavid Gibson .parent = TYPE_SPAPR_DRC_LOGICAL, 7392d335818SDavid Gibson .class_init = spapr_drc_cpu_class_init, 7402d335818SDavid Gibson }; 7412d335818SDavid Gibson 7422d335818SDavid Gibson static const TypeInfo spapr_drc_pci_info = { 7432d335818SDavid Gibson .name = TYPE_SPAPR_DRC_PCI, 7442d335818SDavid Gibson .parent = TYPE_SPAPR_DRC_PHYSICAL, 7452d335818SDavid Gibson .class_init = spapr_drc_pci_class_init, 7462d335818SDavid Gibson }; 7472d335818SDavid Gibson 7482d335818SDavid Gibson static const TypeInfo spapr_drc_lmb_info = { 7492d335818SDavid Gibson .name = TYPE_SPAPR_DRC_LMB, 7502d335818SDavid Gibson .parent = TYPE_SPAPR_DRC_LOGICAL, 7512d335818SDavid Gibson .class_init = spapr_drc_lmb_class_init, 752bbf5c878SMichael Roth }; 753bbf5c878SMichael Roth 754962b6c36SMichael Roth static const TypeInfo spapr_drc_phb_info = { 755962b6c36SMichael Roth .name = TYPE_SPAPR_DRC_PHB, 756962b6c36SMichael Roth .parent = TYPE_SPAPR_DRC_LOGICAL, 757ce2918cbSDavid Gibson .instance_size = sizeof(SpaprDrc), 758962b6c36SMichael Roth .class_init = spapr_drc_phb_class_init, 759962b6c36SMichael Roth }; 760962b6c36SMichael Roth 761bbf5c878SMichael Roth /* helper functions for external users */ 762bbf5c878SMichael Roth 763ce2918cbSDavid Gibson SpaprDrc *spapr_drc_by_index(uint32_t index) 764bbf5c878SMichael Roth { 765bbf5c878SMichael Roth Object *obj; 766f5babeacSGreg Kurz gchar *name; 767bbf5c878SMichael Roth 768f5babeacSGreg Kurz name = g_strdup_printf("%s/%x", DRC_CONTAINER_PATH, index); 769bbf5c878SMichael Roth obj = object_resolve_path(name, NULL); 770f5babeacSGreg Kurz g_free(name); 771bbf5c878SMichael Roth 772bbf5c878SMichael Roth return !obj ? NULL : SPAPR_DR_CONNECTOR(obj); 773bbf5c878SMichael Roth } 774bbf5c878SMichael Roth 775ce2918cbSDavid Gibson SpaprDrc *spapr_drc_by_id(const char *type, uint32_t id) 776bbf5c878SMichael Roth { 777ce2918cbSDavid Gibson SpaprDrcClass *drck 778fbf55397SDavid Gibson = SPAPR_DR_CONNECTOR_CLASS(object_class_by_name(type)); 779fbf55397SDavid Gibson 780fbf55397SDavid Gibson return spapr_drc_by_index(drck->typeshift << DRC_INDEX_TYPE_SHIFT 781fbf55397SDavid Gibson | (id & DRC_INDEX_ID_MASK)); 782bbf5c878SMichael Roth } 783e4b798bbSMichael Roth 784e4b798bbSMichael Roth /** 7859e7d38e8SDavid Gibson * spapr_dt_drc 786e4b798bbSMichael Roth * 787e4b798bbSMichael Roth * @fdt: libfdt device tree 788e4b798bbSMichael Roth * @path: path in the DT to generate properties 789e4b798bbSMichael Roth * @owner: parent Object/DeviceState for which to generate DRC 790e4b798bbSMichael Roth * descriptions for 791ce2918cbSDavid Gibson * @drc_type_mask: mask of SpaprDrcType values corresponding 792e4b798bbSMichael Roth * to the types of DRCs to generate entries for 793e4b798bbSMichael Roth * 794e4b798bbSMichael Roth * generate OF properties to describe DRC topology/indices to guests 795e4b798bbSMichael Roth * 796e4b798bbSMichael Roth * as documented in PAPR+ v2.1, 13.5.2 797e4b798bbSMichael Roth */ 7989e7d38e8SDavid Gibson int spapr_dt_drc(void *fdt, int offset, Object *owner, uint32_t drc_type_mask) 799e4b798bbSMichael Roth { 800e4b798bbSMichael Roth Object *root_container; 801e4b798bbSMichael Roth ObjectProperty *prop; 8027746abd8SDaniel P. Berrange ObjectPropertyIterator iter; 803e4b798bbSMichael Roth uint32_t drc_count = 0; 804e4b798bbSMichael Roth GArray *drc_indexes, *drc_power_domains; 805e4b798bbSMichael Roth GString *drc_names, *drc_types; 806e4b798bbSMichael Roth int ret; 807e4b798bbSMichael Roth 808e4b798bbSMichael Roth /* the first entry of each properties is a 32-bit integer encoding 809e4b798bbSMichael Roth * the number of elements in the array. we won't know this until 810e4b798bbSMichael Roth * we complete the iteration through all the matching DRCs, but 811e4b798bbSMichael Roth * reserve the space now and set the offsets accordingly so we 812e4b798bbSMichael Roth * can fill them in later. 813e4b798bbSMichael Roth */ 814e4b798bbSMichael Roth drc_indexes = g_array_new(false, true, sizeof(uint32_t)); 815e4b798bbSMichael Roth drc_indexes = g_array_set_size(drc_indexes, 1); 816e4b798bbSMichael Roth drc_power_domains = g_array_new(false, true, sizeof(uint32_t)); 817e4b798bbSMichael Roth drc_power_domains = g_array_set_size(drc_power_domains, 1); 818e4b798bbSMichael Roth drc_names = g_string_set_size(g_string_new(NULL), sizeof(uint32_t)); 819e4b798bbSMichael Roth drc_types = g_string_set_size(g_string_new(NULL), sizeof(uint32_t)); 820e4b798bbSMichael Roth 821e4b798bbSMichael Roth /* aliases for all DRConnector objects will be rooted in QOM 822e4b798bbSMichael Roth * composition tree at DRC_CONTAINER_PATH 823e4b798bbSMichael Roth */ 824e4b798bbSMichael Roth root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); 825e4b798bbSMichael Roth 8267746abd8SDaniel P. Berrange object_property_iter_init(&iter, root_container); 8277746abd8SDaniel P. Berrange while ((prop = object_property_iter_next(&iter))) { 828e4b798bbSMichael Roth Object *obj; 829ce2918cbSDavid Gibson SpaprDrc *drc; 830ce2918cbSDavid Gibson SpaprDrcClass *drck; 831e4b798bbSMichael Roth uint32_t drc_index, drc_power_domain; 832e4b798bbSMichael Roth 833e4b798bbSMichael Roth if (!strstart(prop->type, "link<", NULL)) { 834e4b798bbSMichael Roth continue; 835e4b798bbSMichael Roth } 836e4b798bbSMichael Roth 837e4b798bbSMichael Roth obj = object_property_get_link(root_container, prop->name, NULL); 838e4b798bbSMichael Roth drc = SPAPR_DR_CONNECTOR(obj); 839e4b798bbSMichael Roth drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 840e4b798bbSMichael Roth 841e4b798bbSMichael Roth if (owner && (drc->owner != owner)) { 842e4b798bbSMichael Roth continue; 843e4b798bbSMichael Roth } 844e4b798bbSMichael Roth 8452d335818SDavid Gibson if ((spapr_drc_type(drc) & drc_type_mask) == 0) { 846e4b798bbSMichael Roth continue; 847e4b798bbSMichael Roth } 848e4b798bbSMichael Roth 849e4b798bbSMichael Roth drc_count++; 850e4b798bbSMichael Roth 851e4b798bbSMichael Roth /* ibm,drc-indexes */ 8520b55aa91SDavid Gibson drc_index = cpu_to_be32(spapr_drc_index(drc)); 853e4b798bbSMichael Roth g_array_append_val(drc_indexes, drc_index); 854e4b798bbSMichael Roth 855e4b798bbSMichael Roth /* ibm,drc-power-domains */ 856e4b798bbSMichael Roth drc_power_domain = cpu_to_be32(-1); 857e4b798bbSMichael Roth g_array_append_val(drc_power_domains, drc_power_domain); 858e4b798bbSMichael Roth 859e4b798bbSMichael Roth /* ibm,drc-names */ 86079808336SDavid Gibson drc_names = g_string_append(drc_names, spapr_drc_name(drc)); 861e4b798bbSMichael Roth drc_names = g_string_insert_len(drc_names, -1, "\0", 1); 862e4b798bbSMichael Roth 863e4b798bbSMichael Roth /* ibm,drc-types */ 8641693ea16SDavid Gibson drc_types = g_string_append(drc_types, drck->typename); 865e4b798bbSMichael Roth drc_types = g_string_insert_len(drc_types, -1, "\0", 1); 866e4b798bbSMichael Roth } 867e4b798bbSMichael Roth 868e4b798bbSMichael Roth /* now write the drc count into the space we reserved at the 869e4b798bbSMichael Roth * beginning of the arrays previously 870e4b798bbSMichael Roth */ 871e4b798bbSMichael Roth *(uint32_t *)drc_indexes->data = cpu_to_be32(drc_count); 872e4b798bbSMichael Roth *(uint32_t *)drc_power_domains->data = cpu_to_be32(drc_count); 873e4b798bbSMichael Roth *(uint32_t *)drc_names->str = cpu_to_be32(drc_count); 874e4b798bbSMichael Roth *(uint32_t *)drc_types->str = cpu_to_be32(drc_count); 875e4b798bbSMichael Roth 8769e7d38e8SDavid Gibson ret = fdt_setprop(fdt, offset, "ibm,drc-indexes", 877e4b798bbSMichael Roth drc_indexes->data, 878e4b798bbSMichael Roth drc_indexes->len * sizeof(uint32_t)); 879e4b798bbSMichael Roth if (ret) { 880ce9863b7SCédric Le Goater error_report("Couldn't create ibm,drc-indexes property"); 881e4b798bbSMichael Roth goto out; 882e4b798bbSMichael Roth } 883e4b798bbSMichael Roth 8849e7d38e8SDavid Gibson ret = fdt_setprop(fdt, offset, "ibm,drc-power-domains", 885e4b798bbSMichael Roth drc_power_domains->data, 886e4b798bbSMichael Roth drc_power_domains->len * sizeof(uint32_t)); 887e4b798bbSMichael Roth if (ret) { 888ce9863b7SCédric Le Goater error_report("Couldn't finalize ibm,drc-power-domains property"); 889e4b798bbSMichael Roth goto out; 890e4b798bbSMichael Roth } 891e4b798bbSMichael Roth 8929e7d38e8SDavid Gibson ret = fdt_setprop(fdt, offset, "ibm,drc-names", 893e4b798bbSMichael Roth drc_names->str, drc_names->len); 894e4b798bbSMichael Roth if (ret) { 895ce9863b7SCédric Le Goater error_report("Couldn't finalize ibm,drc-names property"); 896e4b798bbSMichael Roth goto out; 897e4b798bbSMichael Roth } 898e4b798bbSMichael Roth 8999e7d38e8SDavid Gibson ret = fdt_setprop(fdt, offset, "ibm,drc-types", 900e4b798bbSMichael Roth drc_types->str, drc_types->len); 901e4b798bbSMichael Roth if (ret) { 902ce9863b7SCédric Le Goater error_report("Couldn't finalize ibm,drc-types property"); 903e4b798bbSMichael Roth goto out; 904e4b798bbSMichael Roth } 905e4b798bbSMichael Roth 906e4b798bbSMichael Roth out: 907e4b798bbSMichael Roth g_array_free(drc_indexes, true); 908e4b798bbSMichael Roth g_array_free(drc_power_domains, true); 909e4b798bbSMichael Roth g_string_free(drc_names, true); 910e4b798bbSMichael Roth g_string_free(drc_types, true); 911e4b798bbSMichael Roth 912e4b798bbSMichael Roth return ret; 913e4b798bbSMichael Roth } 914b89b3d39SDavid Gibson 915b89b3d39SDavid Gibson /* 916b89b3d39SDavid Gibson * RTAS calls 917b89b3d39SDavid Gibson */ 918b89b3d39SDavid Gibson 9197b7258f8SDavid Gibson static uint32_t rtas_set_isolation_state(uint32_t idx, uint32_t state) 920b89b3d39SDavid Gibson { 921ce2918cbSDavid Gibson SpaprDrc *drc = spapr_drc_by_index(idx); 922ce2918cbSDavid Gibson SpaprDrcClass *drck; 9237b7258f8SDavid Gibson 9247b7258f8SDavid Gibson if (!drc) { 9250dfabd39SDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; 926b89b3d39SDavid Gibson } 927b89b3d39SDavid Gibson 9280dfabd39SDavid Gibson trace_spapr_drc_set_isolation_state(spapr_drc_index(drc), state); 9290dfabd39SDavid Gibson 9307b7258f8SDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 9310dfabd39SDavid Gibson 9320dfabd39SDavid Gibson switch (state) { 9330dfabd39SDavid Gibson case SPAPR_DR_ISOLATION_STATE_ISOLATED: 9340dfabd39SDavid Gibson return drck->isolate(drc); 9350dfabd39SDavid Gibson 9360dfabd39SDavid Gibson case SPAPR_DR_ISOLATION_STATE_UNISOLATED: 9370dfabd39SDavid Gibson return drck->unisolate(drc); 9380dfabd39SDavid Gibson 9390dfabd39SDavid Gibson default: 9400dfabd39SDavid Gibson return RTAS_OUT_PARAM_ERROR; 9410dfabd39SDavid Gibson } 9427b7258f8SDavid Gibson } 9437b7258f8SDavid Gibson 9447b7258f8SDavid Gibson static uint32_t rtas_set_allocation_state(uint32_t idx, uint32_t state) 9457b7258f8SDavid Gibson { 946ce2918cbSDavid Gibson SpaprDrc *drc = spapr_drc_by_index(idx); 9477b7258f8SDavid Gibson 94861736732SDavid Gibson if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_LOGICAL)) { 94961736732SDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; 9507b7258f8SDavid Gibson } 9517b7258f8SDavid Gibson 95261736732SDavid Gibson trace_spapr_drc_set_allocation_state(spapr_drc_index(drc), state); 95361736732SDavid Gibson 95461736732SDavid Gibson switch (state) { 95561736732SDavid Gibson case SPAPR_DR_ALLOCATION_STATE_USABLE: 95661736732SDavid Gibson return drc_set_usable(drc); 95761736732SDavid Gibson 95861736732SDavid Gibson case SPAPR_DR_ALLOCATION_STATE_UNUSABLE: 95961736732SDavid Gibson return drc_set_unusable(drc); 96061736732SDavid Gibson 96161736732SDavid Gibson default: 96261736732SDavid Gibson return RTAS_OUT_PARAM_ERROR; 96361736732SDavid Gibson } 9647b7258f8SDavid Gibson } 9657b7258f8SDavid Gibson 966cd74d27eSDavid Gibson static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state) 9677b7258f8SDavid Gibson { 968ce2918cbSDavid Gibson SpaprDrc *drc = spapr_drc_by_index(idx); 9697b7258f8SDavid Gibson 97067fea71bSDavid Gibson if (!drc || !object_dynamic_cast(OBJECT(drc), TYPE_SPAPR_DRC_PHYSICAL)) { 97167fea71bSDavid Gibson return RTAS_OUT_NO_SUCH_INDICATOR; 97267fea71bSDavid Gibson } 97367fea71bSDavid Gibson if ((state != SPAPR_DR_INDICATOR_INACTIVE) 97467fea71bSDavid Gibson && (state != SPAPR_DR_INDICATOR_ACTIVE) 97567fea71bSDavid Gibson && (state != SPAPR_DR_INDICATOR_IDENTIFY) 97667fea71bSDavid Gibson && (state != SPAPR_DR_INDICATOR_ACTION)) { 97767fea71bSDavid Gibson return RTAS_OUT_PARAM_ERROR; /* bad state parameter */ 9787b7258f8SDavid Gibson } 9797b7258f8SDavid Gibson 980cd74d27eSDavid Gibson trace_spapr_drc_set_dr_indicator(idx, state); 98167fea71bSDavid Gibson SPAPR_DRC_PHYSICAL(drc)->dr_indicator = state; 982cd74d27eSDavid Gibson return RTAS_OUT_SUCCESS; 983b89b3d39SDavid Gibson } 984b89b3d39SDavid Gibson 985ce2918cbSDavid Gibson static void rtas_set_indicator(PowerPCCPU *cpu, SpaprMachineState *spapr, 9867b7258f8SDavid Gibson uint32_t token, 9877b7258f8SDavid Gibson uint32_t nargs, target_ulong args, 9887b7258f8SDavid Gibson uint32_t nret, target_ulong rets) 989b89b3d39SDavid Gibson { 9907b7258f8SDavid Gibson uint32_t type, idx, state; 991b89b3d39SDavid Gibson uint32_t ret = RTAS_OUT_SUCCESS; 992b89b3d39SDavid Gibson 993b89b3d39SDavid Gibson if (nargs != 3 || nret != 1) { 994b89b3d39SDavid Gibson ret = RTAS_OUT_PARAM_ERROR; 995b89b3d39SDavid Gibson goto out; 996b89b3d39SDavid Gibson } 997b89b3d39SDavid Gibson 9987b7258f8SDavid Gibson type = rtas_ld(args, 0); 9997b7258f8SDavid Gibson idx = rtas_ld(args, 1); 10007b7258f8SDavid Gibson state = rtas_ld(args, 2); 1001b89b3d39SDavid Gibson 10027b7258f8SDavid Gibson switch (type) { 1003b89b3d39SDavid Gibson case RTAS_SENSOR_TYPE_ISOLATION_STATE: 10047b7258f8SDavid Gibson ret = rtas_set_isolation_state(idx, state); 1005b89b3d39SDavid Gibson break; 1006b89b3d39SDavid Gibson case RTAS_SENSOR_TYPE_DR: 1007cd74d27eSDavid Gibson ret = rtas_set_dr_indicator(idx, state); 1008b89b3d39SDavid Gibson break; 1009b89b3d39SDavid Gibson case RTAS_SENSOR_TYPE_ALLOCATION_STATE: 10107b7258f8SDavid Gibson ret = rtas_set_allocation_state(idx, state); 1011b89b3d39SDavid Gibson break; 1012b89b3d39SDavid Gibson default: 10137b7258f8SDavid Gibson ret = RTAS_OUT_NOT_SUPPORTED; 1014b89b3d39SDavid Gibson } 1015b89b3d39SDavid Gibson 1016b89b3d39SDavid Gibson out: 1017b89b3d39SDavid Gibson rtas_st(rets, 0, ret); 1018b89b3d39SDavid Gibson } 1019b89b3d39SDavid Gibson 1020ce2918cbSDavid Gibson static void rtas_get_sensor_state(PowerPCCPU *cpu, SpaprMachineState *spapr, 1021b89b3d39SDavid Gibson uint32_t token, uint32_t nargs, 1022b89b3d39SDavid Gibson target_ulong args, uint32_t nret, 1023b89b3d39SDavid Gibson target_ulong rets) 1024b89b3d39SDavid Gibson { 1025b89b3d39SDavid Gibson uint32_t sensor_type; 1026b89b3d39SDavid Gibson uint32_t sensor_index; 1027b89b3d39SDavid Gibson uint32_t sensor_state = 0; 1028ce2918cbSDavid Gibson SpaprDrc *drc; 1029ce2918cbSDavid Gibson SpaprDrcClass *drck; 1030b89b3d39SDavid Gibson uint32_t ret = RTAS_OUT_SUCCESS; 1031b89b3d39SDavid Gibson 1032b89b3d39SDavid Gibson if (nargs != 2 || nret != 2) { 1033b89b3d39SDavid Gibson ret = RTAS_OUT_PARAM_ERROR; 1034b89b3d39SDavid Gibson goto out; 1035b89b3d39SDavid Gibson } 1036b89b3d39SDavid Gibson 1037b89b3d39SDavid Gibson sensor_type = rtas_ld(args, 0); 1038b89b3d39SDavid Gibson sensor_index = rtas_ld(args, 1); 1039b89b3d39SDavid Gibson 1040b89b3d39SDavid Gibson if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) { 1041b89b3d39SDavid Gibson /* currently only DR-related sensors are implemented */ 1042b89b3d39SDavid Gibson trace_spapr_rtas_get_sensor_state_not_supported(sensor_index, 1043b89b3d39SDavid Gibson sensor_type); 1044b89b3d39SDavid Gibson ret = RTAS_OUT_NOT_SUPPORTED; 1045b89b3d39SDavid Gibson goto out; 1046b89b3d39SDavid Gibson } 1047b89b3d39SDavid Gibson 1048fbf55397SDavid Gibson drc = spapr_drc_by_index(sensor_index); 1049b89b3d39SDavid Gibson if (!drc) { 1050b89b3d39SDavid Gibson trace_spapr_rtas_get_sensor_state_invalid(sensor_index); 1051b89b3d39SDavid Gibson ret = RTAS_OUT_PARAM_ERROR; 1052b89b3d39SDavid Gibson goto out; 1053b89b3d39SDavid Gibson } 1054b89b3d39SDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 1055f224d35bSDavid Gibson sensor_state = drck->dr_entity_sense(drc); 1056b89b3d39SDavid Gibson 1057b89b3d39SDavid Gibson out: 1058b89b3d39SDavid Gibson rtas_st(rets, 0, ret); 1059b89b3d39SDavid Gibson rtas_st(rets, 1, sensor_state); 1060b89b3d39SDavid Gibson } 1061b89b3d39SDavid Gibson 1062b89b3d39SDavid Gibson /* configure-connector work area offsets, int32_t units for field 1063b89b3d39SDavid Gibson * indexes, bytes for field offset/len values. 1064b89b3d39SDavid Gibson * 1065b89b3d39SDavid Gibson * as documented by PAPR+ v2.7, 13.5.3.5 1066b89b3d39SDavid Gibson */ 1067b89b3d39SDavid Gibson #define CC_IDX_NODE_NAME_OFFSET 2 1068b89b3d39SDavid Gibson #define CC_IDX_PROP_NAME_OFFSET 2 1069b89b3d39SDavid Gibson #define CC_IDX_PROP_LEN 3 1070b89b3d39SDavid Gibson #define CC_IDX_PROP_DATA_OFFSET 4 1071b89b3d39SDavid Gibson #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4) 1072b89b3d39SDavid Gibson #define CC_WA_LEN 4096 1073b89b3d39SDavid Gibson 1074b89b3d39SDavid Gibson static void configure_connector_st(target_ulong addr, target_ulong offset, 1075b89b3d39SDavid Gibson const void *buf, size_t len) 1076b89b3d39SDavid Gibson { 1077b89b3d39SDavid Gibson cpu_physical_memory_write(ppc64_phys_to_real(addr + offset), 1078b89b3d39SDavid Gibson buf, MIN(len, CC_WA_LEN - offset)); 1079b89b3d39SDavid Gibson } 1080b89b3d39SDavid Gibson 1081b89b3d39SDavid Gibson static void rtas_ibm_configure_connector(PowerPCCPU *cpu, 1082ce2918cbSDavid Gibson SpaprMachineState *spapr, 1083b89b3d39SDavid Gibson uint32_t token, uint32_t nargs, 1084b89b3d39SDavid Gibson target_ulong args, uint32_t nret, 1085b89b3d39SDavid Gibson target_ulong rets) 1086b89b3d39SDavid Gibson { 1087b89b3d39SDavid Gibson uint64_t wa_addr; 1088b89b3d39SDavid Gibson uint64_t wa_offset; 1089b89b3d39SDavid Gibson uint32_t drc_index; 1090ce2918cbSDavid Gibson SpaprDrc *drc; 1091ce2918cbSDavid Gibson SpaprDrcClass *drck; 1092ce2918cbSDavid Gibson SpaprDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE; 1093b89b3d39SDavid Gibson int rc; 1094b89b3d39SDavid Gibson 1095b89b3d39SDavid Gibson if (nargs != 2 || nret != 1) { 1096b89b3d39SDavid Gibson rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 1097b89b3d39SDavid Gibson return; 1098b89b3d39SDavid Gibson } 1099b89b3d39SDavid Gibson 1100b89b3d39SDavid Gibson wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0); 1101b89b3d39SDavid Gibson 1102b89b3d39SDavid Gibson drc_index = rtas_ld(wa_addr, 0); 1103fbf55397SDavid Gibson drc = spapr_drc_by_index(drc_index); 1104b89b3d39SDavid Gibson if (!drc) { 1105b89b3d39SDavid Gibson trace_spapr_rtas_ibm_configure_connector_invalid(drc_index); 1106b89b3d39SDavid Gibson rc = RTAS_OUT_PARAM_ERROR; 1107b89b3d39SDavid Gibson goto out; 1108b89b3d39SDavid Gibson } 1109b89b3d39SDavid Gibson 11109d4c0f4fSDavid Gibson if ((drc->state != SPAPR_DRC_STATE_LOGICAL_UNISOLATE) 1111188bfe1bSBharata B Rao && (drc->state != SPAPR_DRC_STATE_PHYSICAL_UNISOLATE) 1112188bfe1bSBharata B Rao && (drc->state != SPAPR_DRC_STATE_LOGICAL_CONFIGURED) 1113188bfe1bSBharata B Rao && (drc->state != SPAPR_DRC_STATE_PHYSICAL_CONFIGURED)) { 1114188bfe1bSBharata B Rao /* 1115188bfe1bSBharata B Rao * Need to unisolate the device before configuring 1116188bfe1bSBharata B Rao * or it should already be in configured state to 1117188bfe1bSBharata B Rao * allow configure-connector be called repeatedly. 1118188bfe1bSBharata B Rao */ 1119b89b3d39SDavid Gibson rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE; 1120b89b3d39SDavid Gibson goto out; 1121b89b3d39SDavid Gibson } 1122b89b3d39SDavid Gibson 11239d4c0f4fSDavid Gibson drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); 11249d4c0f4fSDavid Gibson 1125d9c95c71SGreg Kurz if (!drc->fdt) { 1126d9c95c71SGreg Kurz Error *local_err = NULL; 1127d9c95c71SGreg Kurz void *fdt; 1128d9c95c71SGreg Kurz int fdt_size; 1129d9c95c71SGreg Kurz 1130d9c95c71SGreg Kurz fdt = create_device_tree(&fdt_size); 1131d9c95c71SGreg Kurz 1132d9c95c71SGreg Kurz if (drck->dt_populate(drc, spapr, fdt, &drc->fdt_start_offset, 1133d9c95c71SGreg Kurz &local_err)) { 1134d9c95c71SGreg Kurz g_free(fdt); 1135d9c95c71SGreg Kurz error_free(local_err); 1136d9c95c71SGreg Kurz rc = SPAPR_DR_CC_RESPONSE_ERROR; 1137d9c95c71SGreg Kurz goto out; 1138d9c95c71SGreg Kurz } 1139d9c95c71SGreg Kurz 1140d9c95c71SGreg Kurz drc->fdt = fdt; 1141d9c95c71SGreg Kurz drc->ccs_offset = drc->fdt_start_offset; 1142d9c95c71SGreg Kurz drc->ccs_depth = 0; 1143d9c95c71SGreg Kurz } 1144d9c95c71SGreg Kurz 1145b89b3d39SDavid Gibson do { 1146b89b3d39SDavid Gibson uint32_t tag; 1147b89b3d39SDavid Gibson const char *name; 1148b89b3d39SDavid Gibson const struct fdt_property *prop; 1149b89b3d39SDavid Gibson int fdt_offset_next, prop_len; 1150b89b3d39SDavid Gibson 11514445b1d2SDavid Gibson tag = fdt_next_tag(drc->fdt, drc->ccs_offset, &fdt_offset_next); 1152b89b3d39SDavid Gibson 1153b89b3d39SDavid Gibson switch (tag) { 1154b89b3d39SDavid Gibson case FDT_BEGIN_NODE: 11554445b1d2SDavid Gibson drc->ccs_depth++; 11564445b1d2SDavid Gibson name = fdt_get_name(drc->fdt, drc->ccs_offset, NULL); 1157b89b3d39SDavid Gibson 1158b89b3d39SDavid Gibson /* provide the name of the next OF node */ 1159b89b3d39SDavid Gibson wa_offset = CC_VAL_DATA_OFFSET; 1160b89b3d39SDavid Gibson rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset); 1161b89b3d39SDavid Gibson configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1); 1162b89b3d39SDavid Gibson resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD; 1163b89b3d39SDavid Gibson break; 1164b89b3d39SDavid Gibson case FDT_END_NODE: 11654445b1d2SDavid Gibson drc->ccs_depth--; 11664445b1d2SDavid Gibson if (drc->ccs_depth == 0) { 11670b55aa91SDavid Gibson uint32_t drc_index = spapr_drc_index(drc); 11689d4c0f4fSDavid Gibson 11699d4c0f4fSDavid Gibson /* done sending the device tree, move to configured state */ 11700b55aa91SDavid Gibson trace_spapr_drc_set_configured(drc_index); 11719d4c0f4fSDavid Gibson drc->state = drck->ready_state; 1172188bfe1bSBharata B Rao /* 1173188bfe1bSBharata B Rao * Ensure that we are able to send the FDT fragment 1174188bfe1bSBharata B Rao * again via configure-connector call if the guest requests. 1175188bfe1bSBharata B Rao */ 1176188bfe1bSBharata B Rao drc->ccs_offset = drc->fdt_start_offset; 1177188bfe1bSBharata B Rao drc->ccs_depth = 0; 1178188bfe1bSBharata B Rao fdt_offset_next = drc->fdt_start_offset; 1179b89b3d39SDavid Gibson resp = SPAPR_DR_CC_RESPONSE_SUCCESS; 1180b89b3d39SDavid Gibson } else { 1181b89b3d39SDavid Gibson resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT; 1182b89b3d39SDavid Gibson } 1183b89b3d39SDavid Gibson break; 1184b89b3d39SDavid Gibson case FDT_PROP: 11854445b1d2SDavid Gibson prop = fdt_get_property_by_offset(drc->fdt, drc->ccs_offset, 1186b89b3d39SDavid Gibson &prop_len); 118788af6ea5SDavid Gibson name = fdt_string(drc->fdt, fdt32_to_cpu(prop->nameoff)); 1188b89b3d39SDavid Gibson 1189b89b3d39SDavid Gibson /* provide the name of the next OF property */ 1190b89b3d39SDavid Gibson wa_offset = CC_VAL_DATA_OFFSET; 1191b89b3d39SDavid Gibson rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset); 1192b89b3d39SDavid Gibson configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1); 1193b89b3d39SDavid Gibson 1194b89b3d39SDavid Gibson /* provide the length and value of the OF property. data gets 1195b89b3d39SDavid Gibson * placed immediately after NULL terminator of the OF property's 1196b89b3d39SDavid Gibson * name string 1197b89b3d39SDavid Gibson */ 1198b89b3d39SDavid Gibson wa_offset += strlen(name) + 1, 1199b89b3d39SDavid Gibson rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len); 1200b89b3d39SDavid Gibson rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset); 1201b89b3d39SDavid Gibson configure_connector_st(wa_addr, wa_offset, prop->data, prop_len); 1202b89b3d39SDavid Gibson resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY; 1203b89b3d39SDavid Gibson break; 1204b89b3d39SDavid Gibson case FDT_END: 1205b89b3d39SDavid Gibson resp = SPAPR_DR_CC_RESPONSE_ERROR; 1206b89b3d39SDavid Gibson default: 1207b89b3d39SDavid Gibson /* keep seeking for an actionable tag */ 1208b89b3d39SDavid Gibson break; 1209b89b3d39SDavid Gibson } 12104445b1d2SDavid Gibson if (drc->ccs_offset >= 0) { 12114445b1d2SDavid Gibson drc->ccs_offset = fdt_offset_next; 1212b89b3d39SDavid Gibson } 1213b89b3d39SDavid Gibson } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE); 1214b89b3d39SDavid Gibson 1215b89b3d39SDavid Gibson rc = resp; 1216b89b3d39SDavid Gibson out: 1217b89b3d39SDavid Gibson rtas_st(rets, 0, rc); 1218b89b3d39SDavid Gibson } 1219b89b3d39SDavid Gibson 1220b89b3d39SDavid Gibson static void spapr_drc_register_types(void) 1221b89b3d39SDavid Gibson { 1222b89b3d39SDavid Gibson type_register_static(&spapr_dr_connector_info); 12232d335818SDavid Gibson type_register_static(&spapr_drc_physical_info); 12242d335818SDavid Gibson type_register_static(&spapr_drc_logical_info); 12252d335818SDavid Gibson type_register_static(&spapr_drc_cpu_info); 12262d335818SDavid Gibson type_register_static(&spapr_drc_pci_info); 12272d335818SDavid Gibson type_register_static(&spapr_drc_lmb_info); 1228962b6c36SMichael Roth type_register_static(&spapr_drc_phb_info); 1229b89b3d39SDavid Gibson 1230b89b3d39SDavid Gibson spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator", 1231b89b3d39SDavid Gibson rtas_set_indicator); 1232b89b3d39SDavid Gibson spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state", 1233b89b3d39SDavid Gibson rtas_get_sensor_state); 1234b89b3d39SDavid Gibson spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector", 1235b89b3d39SDavid Gibson rtas_ibm_configure_connector); 1236b89b3d39SDavid Gibson } 1237b89b3d39SDavid Gibson type_init(spapr_drc_register_types) 1238