hw/ppc/spapr_pci.c

   1 /*
   2  * QEMU sPAPR PCI host originated from Uninorth PCI host
   3  *
   4  * Copyright (c) 2011 Alexey Kardashevskiy, IBM Corporation.
   5  * Copyright (C) 2011 David Gibson, IBM Corporation.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25 #include "hw/hw.h"
  26 #include "hw/pci/pci.h"
  27 #include "hw/pci/msi.h"
  28 #include "hw/pci/msix.h"
  29 #include "hw/pci/pci_host.h"
  30 #include "hw/ppc/spapr.h"
  31 #include "hw/pci-host/spapr.h"
  32 #include "exec/address-spaces.h"
  33 #include <libfdt.h>
  34 #include "trace.h"
  35 #include "qemu/error-report.h"
  36 #include "qapi/qmp/qerror.h"
  37
  38 #include "hw/pci/pci_bus.h"
  39 #include "hw/ppc/spapr_drc.h"
  40 #include "sysemu/device_tree.h"
  41
  42 /* Copied from the kernel arch/powerpc/platforms/pseries/msi.c */
  43 #define RTAS_QUERY_FN           0
  44 #define RTAS_CHANGE_FN          1
  45 #define RTAS_RESET_FN           2
  46 #define RTAS_CHANGE_MSI_FN      3
  47 #define RTAS_CHANGE_MSIX_FN     4
  48
  49 /* Interrupt types to return on RTAS_CHANGE_* */
  50 #define RTAS_TYPE_MSI           1
  51 #define RTAS_TYPE_MSIX          2
  52
  53 #define _FDT(exp) \
  54     do { \
  55         int ret = (exp);                                           \
  56         if (ret < 0) {                                             \
  57             return ret;                                            \
  58         }                                                          \
  59     } while (0)
  60
  61 sPAPRPHBState *spapr_pci_find_phb(sPAPREnvironment *spapr, uint64_t buid)
  62 {
  63     sPAPRPHBState *sphb;
  64
  65     QLIST_FOREACH(sphb, &spapr->phbs, list) {
  66         if (sphb->buid != buid) {
  67             continue;
  68         }
  69         return sphb;
  70     }
  71
  72     return NULL;
  73 }
  74
  75 PCIDevice *spapr_pci_find_dev(sPAPREnvironment *spapr, uint64_t buid,
  76                               uint32_t config_addr)
  77 {
  78     sPAPRPHBState *sphb = spapr_pci_find_phb(spapr, buid);
  79     PCIHostState *phb = PCI_HOST_BRIDGE(sphb);
  80     int bus_num = (config_addr >> 16) & 0xFF;
  81     int devfn = (config_addr >> 8) & 0xFF;
  82
  83     if (!phb) {
  84         return NULL;
  85     }
  86
  87     return pci_find_device(phb->bus, bus_num, devfn);
  88 }
  89
  90 static uint32_t rtas_pci_cfgaddr(uint32_t arg)
  91 {
  92     /* This handles the encoding of extended config space addresses */
  93     return ((arg >> 20) & 0xf00) | (arg & 0xff);
  94 }
  95
  96 static void finish_read_pci_config(sPAPREnvironment *spapr, uint64_t buid,
  97                                    uint32_t addr, uint32_t size,
  98                                    target_ulong rets)
  99 {
 100     PCIDevice *pci_dev;
 101     uint32_t val;
 102
 103     if ((size != 1) && (size != 2) && (size != 4)) {
 104         /* access must be 1, 2 or 4 bytes */
 105         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 106         return;
 107     }
 108
 109     pci_dev = spapr_pci_find_dev(spapr, buid, addr);
 110     addr = rtas_pci_cfgaddr(addr);
 111
 112     if (!pci_dev || (addr % size) || (addr >= pci_config_size(pci_dev))) {
 113         /* Access must be to a valid device, within bounds and
 114          * naturally aligned */
 115         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 116         return;
 117     }
 118
 119     val = pci_host_config_read_common(pci_dev, addr,
 120                                       pci_config_size(pci_dev), size);
 121
 122     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 123     rtas_st(rets, 1, val);
 124 }
 125
 126 static void rtas_ibm_read_pci_config(PowerPCCPU *cpu, sPAPREnvironment *spapr,
 127                                      uint32_t token, uint32_t nargs,
 128                                      target_ulong args,
 129                                      uint32_t nret, target_ulong rets)
 130 {
 131     uint64_t buid;
 132     uint32_t size, addr;
 133
 134     if ((nargs != 4) || (nret != 2)) {
 135         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 136         return;
 137     }
 138
 139     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 140     size = rtas_ld(args, 3);
 141     addr = rtas_ld(args, 0);
 142
 143     finish_read_pci_config(spapr, buid, addr, size, rets);
 144 }
 145
 146 static void rtas_read_pci_config(PowerPCCPU *cpu, sPAPREnvironment *spapr,
 147                                  uint32_t token, uint32_t nargs,
 148                                  target_ulong args,
 149                                  uint32_t nret, target_ulong rets)
 150 {
 151     uint32_t size, addr;
 152
 153     if ((nargs != 2) || (nret != 2)) {
 154         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 155         return;
 156     }
 157
 158     size = rtas_ld(args, 1);
 159     addr = rtas_ld(args, 0);
 160
 161     finish_read_pci_config(spapr, 0, addr, size, rets);
 162 }
 163
 164 static void finish_write_pci_config(sPAPREnvironment *spapr, uint64_t buid,
 165                                     uint32_t addr, uint32_t size,
 166                                     uint32_t val, target_ulong rets)
 167 {
 168     PCIDevice *pci_dev;
 169
 170     if ((size != 1) && (size != 2) && (size != 4)) {
 171         /* access must be 1, 2 or 4 bytes */
 172         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 173         return;
 174     }
 175
 176     pci_dev = spapr_pci_find_dev(spapr, buid, addr);
 177     addr = rtas_pci_cfgaddr(addr);
 178
 179     if (!pci_dev || (addr % size) || (addr >= pci_config_size(pci_dev))) {
 180         /* Access must be to a valid device, within bounds and
 181          * naturally aligned */
 182         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 183         return;
 184     }
 185
 186     pci_host_config_write_common(pci_dev, addr, pci_config_size(pci_dev),
 187                                  val, size);
 188
 189     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 190 }
 191
 192 static void rtas_ibm_write_pci_config(PowerPCCPU *cpu, sPAPREnvironment *spapr,
 193                                       uint32_t token, uint32_t nargs,
 194                                       target_ulong args,
 195                                       uint32_t nret, target_ulong rets)
 196 {
 197     uint64_t buid;
 198     uint32_t val, size, addr;
 199
 200     if ((nargs != 5) || (nret != 1)) {
 201         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 202         return;
 203     }
 204
 205     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 206     val = rtas_ld(args, 4);
 207     size = rtas_ld(args, 3);
 208     addr = rtas_ld(args, 0);
 209
 210     finish_write_pci_config(spapr, buid, addr, size, val, rets);
 211 }
 212
 213 static void rtas_write_pci_config(PowerPCCPU *cpu, sPAPREnvironment *spapr,
 214                                   uint32_t token, uint32_t nargs,
 215                                   target_ulong args,
 216                                   uint32_t nret, target_ulong rets)
 217 {
 218     uint32_t val, size, addr;
 219
 220     if ((nargs != 3) || (nret != 1)) {
 221         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 222         return;
 223     }
 224
 225
 226     val = rtas_ld(args, 2);
 227     size = rtas_ld(args, 1);
 228     addr = rtas_ld(args, 0);
 229
 230     finish_write_pci_config(spapr, 0, addr, size, val, rets);
 231 }
 232
 233 /*
 234  * Set MSI/MSIX message data.
 235  * This is required for msi_notify()/msix_notify() which
 236  * will write at the addresses via spapr_msi_write().
 237  *
 238  * If hwaddr == 0, all entries will have .data == first_irq i.e.
 239  * table will be reset.
 240  */
 241 static void spapr_msi_setmsg(PCIDevice *pdev, hwaddr addr, bool msix,
 242                              unsigned first_irq, unsigned req_num)
 243 {
 244     unsigned i;
 245     MSIMessage msg = { .address = addr, .data = first_irq };
 246
 247     if (!msix) {
 248         msi_set_message(pdev, msg);
 249         trace_spapr_pci_msi_setup(pdev->name, 0, msg.address);
 250         return;
 251     }
 252
 253     for (i = 0; i < req_num; ++i) {
 254         msix_set_message(pdev, i, msg);
 255         trace_spapr_pci_msi_setup(pdev->name, i, msg.address);
 256         if (addr) {
 257             ++msg.data;
 258         }
 259     }
 260 }
 261
 262 static void rtas_ibm_change_msi(PowerPCCPU *cpu, sPAPREnvironment *spapr,
 263                                 uint32_t token, uint32_t nargs,
 264                                 target_ulong args, uint32_t nret,
 265                                 target_ulong rets)
 266 {
 267     uint32_t config_addr = rtas_ld(args, 0);
 268     uint64_t buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 269     unsigned int func = rtas_ld(args, 3);
 270     unsigned int req_num = rtas_ld(args, 4); /* 0 == remove all */
 271     unsigned int seq_num = rtas_ld(args, 5);
 272     unsigned int ret_intr_type;
 273     unsigned int irq, max_irqs = 0, num = 0;
 274     sPAPRPHBState *phb = NULL;
 275     PCIDevice *pdev = NULL;
 276     spapr_pci_msi *msi;
 277     int *config_addr_key;
 278
 279     switch (func) {
 280     case RTAS_CHANGE_MSI_FN:
 281     case RTAS_CHANGE_FN:
 282         ret_intr_type = RTAS_TYPE_MSI;
 283         break;
 284     case RTAS_CHANGE_MSIX_FN:
 285         ret_intr_type = RTAS_TYPE_MSIX;
 286         break;
 287     default:
 288         error_report("rtas_ibm_change_msi(%u) is not implemented", func);
 289         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 290         return;
 291     }
 292
 293     /* Fins sPAPRPHBState */
 294     phb = spapr_pci_find_phb(spapr, buid);
 295     if (phb) {
 296         pdev = spapr_pci_find_dev(spapr, buid, config_addr);
 297     }
 298     if (!phb || !pdev) {
 299         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 300         return;
 301     }
 302
 303     /* Releasing MSIs */
 304     if (!req_num) {
 305         msi = (spapr_pci_msi *) g_hash_table_lookup(phb->msi, &config_addr);
 306         if (!msi) {
 307             trace_spapr_pci_msi("Releasing wrong config", config_addr);
 308             rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 309             return;
 310         }
 311
 312         xics_free(spapr->icp, msi->first_irq, msi->num);
 313         if (msi_present(pdev)) {
 314             spapr_msi_setmsg(pdev, 0, false, 0, num);
 315         }
 316         if (msix_present(pdev)) {
 317             spapr_msi_setmsg(pdev, 0, true, 0, num);
 318         }
 319         g_hash_table_remove(phb->msi, &config_addr);
 320
 321         trace_spapr_pci_msi("Released MSIs", config_addr);
 322         rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 323         rtas_st(rets, 1, 0);
 324         return;
 325     }
 326
 327     /* Enabling MSI */
 328
 329     /* Check if the device supports as many IRQs as requested */
 330     if (ret_intr_type == RTAS_TYPE_MSI) {
 331         max_irqs = msi_nr_vectors_allocated(pdev);
 332     } else if (ret_intr_type == RTAS_TYPE_MSIX) {
 333         max_irqs = pdev->msix_entries_nr;
 334     }
 335     if (!max_irqs) {
 336         error_report("Requested interrupt type %d is not enabled for device %x",
 337                      ret_intr_type, config_addr);
 338         rtas_st(rets, 0, -1); /* Hardware error */
 339         return;
 340     }
 341     /* Correct the number if the guest asked for too many */
 342     if (req_num > max_irqs) {
 343         trace_spapr_pci_msi_retry(config_addr, req_num, max_irqs);
 344         req_num = max_irqs;
 345         irq = 0; /* to avoid misleading trace */
 346         goto out;
 347     }
 348
 349     /* Allocate MSIs */
 350     irq = xics_alloc_block(spapr->icp, 0, req_num, false,
 351                            ret_intr_type == RTAS_TYPE_MSI);
 352     if (!irq) {
 353         error_report("Cannot allocate MSIs for device %x", config_addr);
 354         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 355         return;
 356     }
 357
 358     /* Setup MSI/MSIX vectors in the device (via cfgspace or MSIX BAR) */
 359     spapr_msi_setmsg(pdev, SPAPR_PCI_MSI_WINDOW, ret_intr_type == RTAS_TYPE_MSIX,
 360                      irq, req_num);
 361
 362     /* Add MSI device to cache */
 363     msi = g_new(spapr_pci_msi, 1);
 364     msi->first_irq = irq;
 365     msi->num = req_num;
 366     config_addr_key = g_new(int, 1);
 367     *config_addr_key = config_addr;
 368     g_hash_table_insert(phb->msi, config_addr_key, msi);
 369
 370 out:
 371     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 372     rtas_st(rets, 1, req_num);
 373     rtas_st(rets, 2, ++seq_num);
 374     rtas_st(rets, 3, ret_intr_type);
 375
 376     trace_spapr_pci_rtas_ibm_change_msi(config_addr, func, req_num, irq);
 377 }
 378
 379 static void rtas_ibm_query_interrupt_source_number(PowerPCCPU *cpu,
 380                                                    sPAPREnvironment *spapr,
 381                                                    uint32_t token,
 382                                                    uint32_t nargs,
 383                                                    target_ulong args,
 384                                                    uint32_t nret,
 385                                                    target_ulong rets)
 386 {
 387     uint32_t config_addr = rtas_ld(args, 0);
 388     uint64_t buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 389     unsigned int intr_src_num = -1, ioa_intr_num = rtas_ld(args, 3);
 390     sPAPRPHBState *phb = NULL;
 391     PCIDevice *pdev = NULL;
 392     spapr_pci_msi *msi;
 393
 394     /* Find sPAPRPHBState */
 395     phb = spapr_pci_find_phb(spapr, buid);
 396     if (phb) {
 397         pdev = spapr_pci_find_dev(spapr, buid, config_addr);
 398     }
 399     if (!phb || !pdev) {
 400         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 401         return;
 402     }
 403
 404     /* Find device descriptor and start IRQ */
 405     msi = (spapr_pci_msi *) g_hash_table_lookup(phb->msi, &config_addr);
 406     if (!msi || !msi->first_irq || !msi->num || (ioa_intr_num >= msi->num)) {
 407         trace_spapr_pci_msi("Failed to return vector", config_addr);
 408         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 409         return;
 410     }
 411     intr_src_num = msi->first_irq + ioa_intr_num;
 412     trace_spapr_pci_rtas_ibm_query_interrupt_source_number(ioa_intr_num,
 413                                                            intr_src_num);
 414
 415     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 416     rtas_st(rets, 1, intr_src_num);
 417     rtas_st(rets, 2, 1);/* 0 == level; 1 == edge */
 418 }
 419
 420 static void rtas_ibm_set_eeh_option(PowerPCCPU *cpu,
 421                                     sPAPREnvironment *spapr,
 422                                     uint32_t token, uint32_t nargs,
 423                                     target_ulong args, uint32_t nret,
 424                                     target_ulong rets)
 425 {
 426     sPAPRPHBState *sphb;
 427     sPAPRPHBClass *spc;
 428     uint32_t addr, option;
 429     uint64_t buid;
 430     int ret;
 431
 432     if ((nargs != 4) || (nret != 1)) {
 433         goto param_error_exit;
 434     }
 435
 436     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 437     addr = rtas_ld(args, 0);
 438     option = rtas_ld(args, 3);
 439
 440     sphb = spapr_pci_find_phb(spapr, buid);
 441     if (!sphb) {
 442         goto param_error_exit;
 443     }
 444
 445     spc = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(sphb);
 446     if (!spc->eeh_set_option) {
 447         goto param_error_exit;
 448     }
 449
 450     ret = spc->eeh_set_option(sphb, addr, option);
 451     rtas_st(rets, 0, ret);
 452     return;
 453
 454 param_error_exit:
 455     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 456 }
 457
 458 static void rtas_ibm_get_config_addr_info2(PowerPCCPU *cpu,
 459                                            sPAPREnvironment *spapr,
 460                                            uint32_t token, uint32_t nargs,
 461                                            target_ulong args, uint32_t nret,
 462                                            target_ulong rets)
 463 {
 464     sPAPRPHBState *sphb;
 465     sPAPRPHBClass *spc;
 466     PCIDevice *pdev;
 467     uint32_t addr, option;
 468     uint64_t buid;
 469
 470     if ((nargs != 4) || (nret != 2)) {
 471         goto param_error_exit;
 472     }
 473
 474     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 475     sphb = spapr_pci_find_phb(spapr, buid);
 476     if (!sphb) {
 477         goto param_error_exit;
 478     }
 479
 480     spc = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(sphb);
 481     if (!spc->eeh_set_option) {
 482         goto param_error_exit;
 483     }
 484
 485     /*
 486      * We always have PE address of form "00BB0001". "BB"
 487      * represents the bus number of PE's primary bus.
 488      */
 489     option = rtas_ld(args, 3);
 490     switch (option) {
 491     case RTAS_GET_PE_ADDR:
 492         addr = rtas_ld(args, 0);
 493         pdev = spapr_pci_find_dev(spapr, buid, addr);
 494         if (!pdev) {
 495             goto param_error_exit;
 496         }
 497
 498         rtas_st(rets, 1, (pci_bus_num(pdev->bus) << 16) + 1);
 499         break;
 500     case RTAS_GET_PE_MODE:
 501         rtas_st(rets, 1, RTAS_PE_MODE_SHARED);
 502         break;
 503     default:
 504         goto param_error_exit;
 505     }
 506
 507     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 508     return;
 509
 510 param_error_exit:
 511     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 512 }
 513
 514 static void rtas_ibm_read_slot_reset_state2(PowerPCCPU *cpu,
 515                                             sPAPREnvironment *spapr,
 516                                             uint32_t token, uint32_t nargs,
 517                                             target_ulong args, uint32_t nret,
 518                                             target_ulong rets)
 519 {
 520     sPAPRPHBState *sphb;
 521     sPAPRPHBClass *spc;
 522     uint64_t buid;
 523     int state, ret;
 524
 525     if ((nargs != 3) || (nret != 4 && nret != 5)) {
 526         goto param_error_exit;
 527     }
 528
 529     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 530     sphb = spapr_pci_find_phb(spapr, buid);
 531     if (!sphb) {
 532         goto param_error_exit;
 533     }
 534
 535     spc = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(sphb);
 536     if (!spc->eeh_get_state) {
 537         goto param_error_exit;
 538     }
 539
 540     ret = spc->eeh_get_state(sphb, &state);
 541     rtas_st(rets, 0, ret);
 542     if (ret != RTAS_OUT_SUCCESS) {
 543         return;
 544     }
 545
 546     rtas_st(rets, 1, state);
 547     rtas_st(rets, 2, RTAS_EEH_SUPPORT);
 548     rtas_st(rets, 3, RTAS_EEH_PE_UNAVAIL_INFO);
 549     if (nret >= 5) {
 550         rtas_st(rets, 4, RTAS_EEH_PE_RECOVER_INFO);
 551     }
 552     return;
 553
 554 param_error_exit:
 555     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 556 }
 557
 558 static void rtas_ibm_set_slot_reset(PowerPCCPU *cpu,
 559                                     sPAPREnvironment *spapr,
 560                                     uint32_t token, uint32_t nargs,
 561                                     target_ulong args, uint32_t nret,
 562                                     target_ulong rets)
 563 {
 564     sPAPRPHBState *sphb;
 565     sPAPRPHBClass *spc;
 566     uint32_t option;
 567     uint64_t buid;
 568     int ret;
 569
 570     if ((nargs != 4) || (nret != 1)) {
 571         goto param_error_exit;
 572     }
 573
 574     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 575     option = rtas_ld(args, 3);
 576     sphb = spapr_pci_find_phb(spapr, buid);
 577     if (!sphb) {
 578         goto param_error_exit;
 579     }
 580
 581     spc = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(sphb);
 582     if (!spc->eeh_reset) {
 583         goto param_error_exit;
 584     }
 585
 586     ret = spc->eeh_reset(sphb, option);
 587     rtas_st(rets, 0, ret);
 588     return;
 589
 590 param_error_exit:
 591     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 592 }
 593
 594 static void rtas_ibm_configure_pe(PowerPCCPU *cpu,
 595                                   sPAPREnvironment *spapr,
 596                                   uint32_t token, uint32_t nargs,
 597                                   target_ulong args, uint32_t nret,
 598                                   target_ulong rets)
 599 {
 600     sPAPRPHBState *sphb;
 601     sPAPRPHBClass *spc;
 602     uint64_t buid;
 603     int ret;
 604
 605     if ((nargs != 3) || (nret != 1)) {
 606         goto param_error_exit;
 607     }
 608
 609     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 610     sphb = spapr_pci_find_phb(spapr, buid);
 611     if (!sphb) {
 612         goto param_error_exit;
 613     }
 614
 615     spc = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(sphb);
 616     if (!spc->eeh_configure) {
 617         goto param_error_exit;
 618     }
 619
 620     ret = spc->eeh_configure(sphb);
 621     rtas_st(rets, 0, ret);
 622     return;
 623
 624 param_error_exit:
 625     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 626 }
 627
 628 /* To support it later */
 629 static void rtas_ibm_slot_error_detail(PowerPCCPU *cpu,
 630                                        sPAPREnvironment *spapr,
 631                                        uint32_t token, uint32_t nargs,
 632                                        target_ulong args, uint32_t nret,
 633                                        target_ulong rets)
 634 {
 635     sPAPRPHBState *sphb;
 636     sPAPRPHBClass *spc;
 637     int option;
 638     uint64_t buid;
 639
 640     if ((nargs != 8) || (nret != 1)) {
 641         goto param_error_exit;
 642     }
 643
 644     buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2);
 645     sphb = spapr_pci_find_phb(spapr, buid);
 646     if (!sphb) {
 647         goto param_error_exit;
 648     }
 649
 650     spc = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(sphb);
 651     if (!spc->eeh_set_option) {
 652         goto param_error_exit;
 653     }
 654
 655     option = rtas_ld(args, 7);
 656     switch (option) {
 657     case RTAS_SLOT_TEMP_ERR_LOG:
 658     case RTAS_SLOT_PERM_ERR_LOG:
 659         break;
 660     default:
 661         goto param_error_exit;
 662     }
 663
 664     /* We don't have error log yet */
 665     rtas_st(rets, 0, RTAS_OUT_NO_ERRORS_FOUND);
 666     return;
 667
 668 param_error_exit:
 669     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 670 }
 671
 672 static int pci_spapr_swizzle(int slot, int pin)
 673 {
 674     return (slot + pin) % PCI_NUM_PINS;
 675 }
 676
 677 static int pci_spapr_map_irq(PCIDevice *pci_dev, int irq_num)
 678 {
 679     /*
 680      * Here we need to convert pci_dev + irq_num to some unique value
 681      * which is less than number of IRQs on the specific bus (4).  We
 682      * use standard PCI swizzling, that is (slot number + pin number)
 683      * % 4.
 684      */
 685     return pci_spapr_swizzle(PCI_SLOT(pci_dev->devfn), irq_num);
 686 }
 687
 688 static void pci_spapr_set_irq(void *opaque, int irq_num, int level)
 689 {
 690     /*
 691      * Here we use the number returned by pci_spapr_map_irq to find a
 692      * corresponding qemu_irq.
 693      */
 694     sPAPRPHBState *phb = opaque;
 695
 696     trace_spapr_pci_lsi_set(phb->dtbusname, irq_num, phb->lsi_table[irq_num].irq);
 697     qemu_set_irq(spapr_phb_lsi_qirq(phb, irq_num), level);
 698 }
 699
 700 static PCIINTxRoute spapr_route_intx_pin_to_irq(void *opaque, int pin)
 701 {
 702     sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(opaque);
 703     PCIINTxRoute route;
 704
 705     route.mode = PCI_INTX_ENABLED;
 706     route.irq = sphb->lsi_table[pin].irq;
 707
 708     return route;
 709 }
 710
 711 /*
 712  * MSI/MSIX memory region implementation.
 713  * The handler handles both MSI and MSIX.
 714  * For MSI-X, the vector number is encoded as a part of the address,
 715  * data is set to 0.
 716  * For MSI, the vector number is encoded in least bits in data.
 717  */
 718 static void spapr_msi_write(void *opaque, hwaddr addr,
 719                             uint64_t data, unsigned size)
 720 {
 721     uint32_t irq = data;
 722
 723     trace_spapr_pci_msi_write(addr, data, irq);
 724
 725     qemu_irq_pulse(xics_get_qirq(spapr->icp, irq));
 726 }
 727
 728 static const MemoryRegionOps spapr_msi_ops = {
 729     /* There is no .read as the read result is undefined by PCI spec */
 730     .read = NULL,
 731     .write = spapr_msi_write,
 732     .endianness = DEVICE_LITTLE_ENDIAN
 733 };
 734
 735 /*
 736  * PHB PCI device
 737  */
 738 static AddressSpace *spapr_pci_dma_iommu(PCIBus *bus, void *opaque, int devfn)
 739 {
 740     sPAPRPHBState *phb = opaque;
 741
 742     return &phb->iommu_as;
 743 }
 744
 745 /* Macros to operate with address in OF binding to PCI */
 746 #define b_x(x, p, l)    (((x) & ((1<<(l))-1)) << (p))
 747 #define b_n(x)          b_x((x), 31, 1) /* 0 if relocatable */
 748 #define b_p(x)          b_x((x), 30, 1) /* 1 if prefetchable */
 749 #define b_t(x)          b_x((x), 29, 1) /* 1 if the address is aliased */
 750 #define b_ss(x)         b_x((x), 24, 2) /* the space code */
 751 #define b_bbbbbbbb(x)   b_x((x), 16, 8) /* bus number */
 752 #define b_ddddd(x)      b_x((x), 11, 5) /* device number */
 753 #define b_fff(x)        b_x((x), 8, 3)  /* function number */
 754 #define b_rrrrrrrr(x)   b_x((x), 0, 8)  /* register number */
 755
 756 /* for 'reg'/'assigned-addresses' OF properties */
 757 #define RESOURCE_CELLS_SIZE 2
 758 #define RESOURCE_CELLS_ADDRESS 3
 759
 760 typedef struct ResourceFields {
 761     uint32_t phys_hi;
 762     uint32_t phys_mid;
 763     uint32_t phys_lo;
 764     uint32_t size_hi;
 765     uint32_t size_lo;
 766 } QEMU_PACKED ResourceFields;
 767
 768 typedef struct ResourceProps {
 769     ResourceFields reg[8];
 770     ResourceFields assigned[7];
 771     uint32_t reg_len;
 772     uint32_t assigned_len;
 773 } ResourceProps;
 774
 775 /* fill in the 'reg'/'assigned-resources' OF properties for
 776  * a PCI device. 'reg' describes resource requirements for a
 777  * device's IO/MEM regions, 'assigned-addresses' describes the
 778  * actual resource assignments.
 779  *
 780  * the properties are arrays of ('phys-addr', 'size') pairs describing
 781  * the addressable regions of the PCI device, where 'phys-addr' is a
 782  * RESOURCE_CELLS_ADDRESS-tuple of 32-bit integers corresponding to
 783  * (phys.hi, phys.mid, phys.lo), and 'size' is a
 784  * RESOURCE_CELLS_SIZE-tuple corresponding to (size.hi, size.lo).
 785  *
 786  * phys.hi = 0xYYXXXXZZ, where:
 787  *   0xYY = npt000ss
 788  *          |||   |
 789  *          |||   +-- space code: 1 if IO region, 2 if MEM region
 790  *          ||+------ for non-relocatable IO: 1 if aliased
 791  *          ||        for relocatable IO: 1 if below 64KB
 792  *          ||        for MEM: 1 if below 1MB
 793  *          |+------- 1 if region is prefetchable
 794  *          +-------- 1 if region is non-relocatable
 795  *   0xXXXX = bbbbbbbb dddddfff, encoding bus, slot, and function
 796  *            bits respectively
 797  *   0xZZ = rrrrrrrr, the register number of the BAR corresponding
 798  *          to the region
 799  *
 800  * phys.mid and phys.lo correspond respectively to the hi/lo portions
 801  * of the actual address of the region.
 802  *
 803  * how the phys-addr/size values are used differ slightly between
 804  * 'reg' and 'assigned-addresses' properties. namely, 'reg' has
 805  * an additional description for the config space region of the
 806  * device, and in the case of QEMU has n=0 and phys.mid=phys.lo=0
 807  * to describe the region as relocatable, with an address-mapping
 808  * that corresponds directly to the PHB's address space for the
 809  * resource. 'assigned-addresses' always has n=1 set with an absolute
 810  * address assigned for the resource. in general, 'assigned-addresses'
 811  * won't be populated, since addresses for PCI devices are generally
 812  * unmapped initially and left to the guest to assign.
 813  *
 814  * note also that addresses defined in these properties are, at least
 815  * for PAPR guests, relative to the PHBs IO/MEM windows, and
 816  * correspond directly to the addresses in the BARs.
 817  *
 818  * in accordance with PCI Bus Binding to Open Firmware,
 819  * IEEE Std 1275-1994, section 4.1.1, as implemented by PAPR+ v2.7,
 820  * Appendix C.
 821  */
 822 static void populate_resource_props(PCIDevice *d, ResourceProps *rp)
 823 {
 824     int bus_num = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(d))));
 825     uint32_t dev_id = (b_bbbbbbbb(bus_num) |
 826                        b_ddddd(PCI_SLOT(d->devfn)) |
 827                        b_fff(PCI_FUNC(d->devfn)));
 828     ResourceFields *reg, *assigned;
 829     int i, reg_idx = 0, assigned_idx = 0;
 830
 831     /* config space region */
 832     reg = &rp->reg[reg_idx++];
 833     reg->phys_hi = cpu_to_be32(dev_id);
 834     reg->phys_mid = 0;
 835     reg->phys_lo = 0;
 836     reg->size_hi = 0;
 837     reg->size_lo = 0;
 838
 839     for (i = 0; i < PCI_NUM_REGIONS; i++) {
 840         if (!d->io_regions[i].size) {
 841             continue;
 842         }
 843
 844         reg = &rp->reg[reg_idx++];
 845
 846         reg->phys_hi = cpu_to_be32(dev_id | b_rrrrrrrr(pci_bar(d, i)));
 847         if (d->io_regions[i].type & PCI_BASE_ADDRESS_SPACE_IO) {
 848             reg->phys_hi |= cpu_to_be32(b_ss(1));
 849         } else {
 850             reg->phys_hi |= cpu_to_be32(b_ss(2));
 851         }
 852         reg->phys_mid = 0;
 853         reg->phys_lo = 0;
 854         reg->size_hi = cpu_to_be32(d->io_regions[i].size >> 32);
 855         reg->size_lo = cpu_to_be32(d->io_regions[i].size);
 856
 857         if (d->io_regions[i].addr == PCI_BAR_UNMAPPED) {
 858             continue;
 859         }
 860
 861         assigned = &rp->assigned[assigned_idx++];
 862         assigned->phys_hi = cpu_to_be32(reg->phys_hi | b_n(1));
 863         assigned->phys_mid = cpu_to_be32(d->io_regions[i].addr >> 32);
 864         assigned->phys_lo = cpu_to_be32(d->io_regions[i].addr);
 865         assigned->size_hi = reg->size_hi;
 866         assigned->size_lo = reg->size_lo;
 867     }
 868
 869     rp->reg_len = reg_idx * sizeof(ResourceFields);
 870     rp->assigned_len = assigned_idx * sizeof(ResourceFields);
 871 }
 872
 873 static int spapr_populate_pci_child_dt(PCIDevice *dev, void *fdt, int offset,
 874                                        int phb_index, int drc_index,
 875                                        const char *drc_name)
 876 {
 877     ResourceProps rp;
 878     bool is_bridge = false;
 879     int pci_status;
 880
 881     if (pci_default_read_config(dev, PCI_HEADER_TYPE, 1) ==
 882         PCI_HEADER_TYPE_BRIDGE) {
 883         is_bridge = true;
 884     }
 885
 886     /* in accordance with PAPR+ v2.7 13.6.3, Table 181 */
 887     _FDT(fdt_setprop_cell(fdt, offset, "vendor-id",
 888                           pci_default_read_config(dev, PCI_VENDOR_ID, 2)));
 889     _FDT(fdt_setprop_cell(fdt, offset, "device-id",
 890                           pci_default_read_config(dev, PCI_DEVICE_ID, 2)));
 891     _FDT(fdt_setprop_cell(fdt, offset, "revision-id",
 892                           pci_default_read_config(dev, PCI_REVISION_ID, 1)));
 893     _FDT(fdt_setprop_cell(fdt, offset, "class-code",
 894                           pci_default_read_config(dev, PCI_CLASS_DEVICE, 2)
 895                             << 8));
 896     if (pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)) {
 897         _FDT(fdt_setprop_cell(fdt, offset, "interrupts",
 898                  pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)));
 899     }
 900
 901     if (!is_bridge) {
 902         _FDT(fdt_setprop_cell(fdt, offset, "min-grant",
 903             pci_default_read_config(dev, PCI_MIN_GNT, 1)));
 904         _FDT(fdt_setprop_cell(fdt, offset, "max-latency",
 905             pci_default_read_config(dev, PCI_MAX_LAT, 1)));
 906     }
 907
 908     if (pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)) {
 909         _FDT(fdt_setprop_cell(fdt, offset, "subsystem-id",
 910                  pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)));
 911     }
 912
 913     if (pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)) {
 914         _FDT(fdt_setprop_cell(fdt, offset, "subsystem-vendor-id",
 915                  pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)));
 916     }
 917
 918     _FDT(fdt_setprop_cell(fdt, offset, "cache-line-size",
 919         pci_default_read_config(dev, PCI_CACHE_LINE_SIZE, 1)));
 920
 921     /* the following fdt cells are masked off the pci status register */
 922     pci_status = pci_default_read_config(dev, PCI_STATUS, 2);
 923     _FDT(fdt_setprop_cell(fdt, offset, "devsel-speed",
 924                           PCI_STATUS_DEVSEL_MASK & pci_status));
 925
 926     if (pci_status & PCI_STATUS_FAST_BACK) {
 927         _FDT(fdt_setprop(fdt, offset, "fast-back-to-back", NULL, 0));
 928     }
 929     if (pci_status & PCI_STATUS_66MHZ) {
 930         _FDT(fdt_setprop(fdt, offset, "66mhz-capable", NULL, 0));
 931     }
 932     if (pci_status & PCI_STATUS_UDF) {
 933         _FDT(fdt_setprop(fdt, offset, "udf-supported", NULL, 0));
 934     }
 935
 936     /* NOTE: this is normally generated by firmware via path/unit name,
 937      * but in our case we must set it manually since it does not get
 938      * processed by OF beforehand
 939      */
 940     _FDT(fdt_setprop_string(fdt, offset, "name", "pci"));
 941     _FDT(fdt_setprop(fdt, offset, "ibm,loc-code", drc_name, strlen(drc_name)));
 942     _FDT(fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index));
 943
 944     _FDT(fdt_setprop_cell(fdt, offset, "#address-cells",
 945                           RESOURCE_CELLS_ADDRESS));
 946     _FDT(fdt_setprop_cell(fdt, offset, "#size-cells",
 947                           RESOURCE_CELLS_SIZE));
 948     _FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi-x",
 949                           RESOURCE_CELLS_SIZE));
 950
 951     populate_resource_props(dev, &rp);
 952     _FDT(fdt_setprop(fdt, offset, "reg", (uint8_t *)rp.reg, rp.reg_len));
 953     _FDT(fdt_setprop(fdt, offset, "assigned-addresses",
 954                      (uint8_t *)rp.assigned, rp.assigned_len));
 955
 956     return 0;
 957 }
 958
 959 /* create OF node for pci device and required OF DT properties */
 960 static void *spapr_create_pci_child_dt(sPAPRPHBState *phb, PCIDevice *dev,
 961                                        int drc_index, const char *drc_name,
 962                                        int *dt_offset)
 963 {
 964     void *fdt;
 965     int offset, ret, fdt_size;
 966     int slot = PCI_SLOT(dev->devfn);
 967     int func = PCI_FUNC(dev->devfn);
 968     char nodename[512];
 969
 970     fdt = create_device_tree(&fdt_size);
 971     if (func != 0) {
 972         sprintf(nodename, "pci@%d,%d", slot, func);
 973     } else {
 974         sprintf(nodename, "pci@%d", slot);
 975     }
 976     offset = fdt_add_subnode(fdt, 0, nodename);
 977     ret = spapr_populate_pci_child_dt(dev, fdt, offset, phb->index, drc_index,
 978                                       drc_name);
 979     g_assert(!ret);
 980
 981     *dt_offset = offset;
 982     return fdt;
 983 }
 984
 985 static void spapr_phb_add_pci_device(sPAPRDRConnector *drc,
 986                                      sPAPRPHBState *phb,
 987                                      PCIDevice *pdev,
 988                                      Error **errp)
 989 {
 990     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 991     DeviceState *dev = DEVICE(pdev);
 992     int drc_index = drck->get_index(drc);
 993     const char *drc_name = drck->get_name(drc);
 994     void *fdt = NULL;
 995     int fdt_start_offset = 0;
 996
 997     /* boot-time devices get their device tree node created by SLOF, but for
 998      * hotplugged devices we need QEMU to generate it so the guest can fetch
 999      * it via RTAS
1000      */
1001     if (dev->hotplugged) {
1002         fdt = spapr_create_pci_child_dt(phb, pdev, drc_index, drc_name,
1003                                         &fdt_start_offset);
1004     }
1005
1006     drck->attach(drc, DEVICE(pdev),
1007                  fdt, fdt_start_offset, !dev->hotplugged, errp);
1008     if (*errp) {
1009         g_free(fdt);
1010     }
1011 }
1012
1013 static void spapr_phb_remove_pci_device_cb(DeviceState *dev, void *opaque)
1014 {
1015     /* some version guests do not wait for completion of a device
1016      * cleanup (generally done asynchronously by the kernel) before
1017      * signaling to QEMU that the device is safe, but instead sleep
1018      * for some 'safe' period of time. unfortunately on a busy host
1019      * this sleep isn't guaranteed to be long enough, resulting in
1020      * bad things like IRQ lines being left asserted during final
1021      * device removal. to deal with this we call reset just prior
1022      * to finalizing the device, which will put the device back into
1023      * an 'idle' state, as the device cleanup code expects.
1024      */
1025     pci_device_reset(PCI_DEVICE(dev));
1026     object_unparent(OBJECT(dev));
1027 }
1028
1029 static void spapr_phb_remove_pci_device(sPAPRDRConnector *drc,
1030                                         sPAPRPHBState *phb,
1031                                         PCIDevice *pdev,
1032                                         Error **errp)
1033 {
1034     sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
1035
1036     drck->detach(drc, DEVICE(pdev), spapr_phb_remove_pci_device_cb, phb, errp);
1037 }
1038
1039 static sPAPRDRConnector *spapr_phb_get_pci_drc(sPAPRPHBState *phb,
1040                                                PCIDevice *pdev)
1041 {
1042     uint32_t busnr = pci_bus_num(PCI_BUS(qdev_get_parent_bus(DEVICE(pdev))));
1043     return spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_PCI,
1044                                     (phb->index << 16) |
1045                                     (busnr << 8) |
1046                                     pdev->devfn);
1047 }
1048
1049 static void spapr_phb_hot_plug_child(HotplugHandler *plug_handler,
1050                                      DeviceState *plugged_dev, Error **errp)
1051 {
1052     sPAPRPHBState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
1053     PCIDevice *pdev = PCI_DEVICE(plugged_dev);
1054     sPAPRDRConnector *drc = spapr_phb_get_pci_drc(phb, pdev);
1055     Error *local_err = NULL;
1056
1057     /* if DR is disabled we don't need to do anything in the case of
1058      * hotplug or coldplug callbacks
1059      */
1060     if (!phb->dr_enabled) {
1061         /* if this is a hotplug operation initiated by the user
1062          * we need to let them know it's not enabled
1063          */
1064         if (plugged_dev->hotplugged) {
1065             error_set(errp, QERR_BUS_NO_HOTPLUG,
1066                       object_get_typename(OBJECT(phb)));
1067         }
1068         return;
1069     }
1070
1071     g_assert(drc);
1072
1073     spapr_phb_add_pci_device(drc, phb, pdev, &local_err);
1074     if (local_err) {
1075         error_propagate(errp, local_err);
1076         return;
1077     }
1078     if (plugged_dev->hotplugged) {
1079         spapr_hotplug_req_add_event(drc);
1080     }
1081 }
1082
1083 static void spapr_phb_hot_unplug_child(HotplugHandler *plug_handler,
1084                                        DeviceState *plugged_dev, Error **errp)
1085 {
1086     sPAPRPHBState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
1087     PCIDevice *pdev = PCI_DEVICE(plugged_dev);
1088     sPAPRDRConnectorClass *drck;
1089     sPAPRDRConnector *drc = spapr_phb_get_pci_drc(phb, pdev);
1090     Error *local_err = NULL;
1091
1092     if (!phb->dr_enabled) {
1093         error_set(errp, QERR_BUS_NO_HOTPLUG,
1094                   object_get_typename(OBJECT(phb)));
1095         return;
1096     }
1097
1098     g_assert(drc);
1099
1100     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
1101     if (!drck->release_pending(drc)) {
1102         spapr_phb_remove_pci_device(drc, phb, pdev, &local_err);
1103         if (local_err) {
1104             error_propagate(errp, local_err);
1105             return;
1106         }
1107         spapr_hotplug_req_remove_event(drc);
1108     }
1109 }
1110
1111 static void spapr_phb_realize(DeviceState *dev, Error **errp)
1112 {
1113     SysBusDevice *s = SYS_BUS_DEVICE(dev);
1114     sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s);
1115     PCIHostState *phb = PCI_HOST_BRIDGE(s);
1116     sPAPRPHBClass *info = SPAPR_PCI_HOST_BRIDGE_GET_CLASS(s);
1117     char *namebuf;
1118     int i;
1119     PCIBus *bus;
1120     uint64_t msi_window_size = 4096;
1121
1122     if (sphb->index != (uint32_t)-1) {
1123         hwaddr windows_base;
1124
1125         if ((sphb->buid != (uint64_t)-1) || (sphb->dma_liobn != (uint32_t)-1)
1126             || (sphb->mem_win_addr != (hwaddr)-1)
1127             || (sphb->io_win_addr != (hwaddr)-1)) {
1128             error_setg(errp, "Either \"index\" or other parameters must"
1129                        " be specified for PAPR PHB, not both");
1130             return;
1131         }
1132
1133         if (sphb->index > SPAPR_PCI_MAX_INDEX) {
1134             error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)",
1135                        SPAPR_PCI_MAX_INDEX);
1136             return;
1137         }
1138
1139         sphb->buid = SPAPR_PCI_BASE_BUID + sphb->index;
1140         sphb->dma_liobn = SPAPR_PCI_LIOBN(sphb->index, 0);
1141
1142         windows_base = SPAPR_PCI_WINDOW_BASE
1143             + sphb->index * SPAPR_PCI_WINDOW_SPACING;
1144         sphb->mem_win_addr = windows_base + SPAPR_PCI_MMIO_WIN_OFF;
1145         sphb->io_win_addr = windows_base + SPAPR_PCI_IO_WIN_OFF;
1146     }
1147
1148     if (sphb->buid == (uint64_t)-1) {
1149         error_setg(errp, "BUID not specified for PHB");
1150         return;
1151     }
1152
1153     if (sphb->dma_liobn == (uint32_t)-1) {
1154         error_setg(errp, "LIOBN not specified for PHB");
1155         return;
1156     }
1157
1158     if (sphb->mem_win_addr == (hwaddr)-1) {
1159         error_setg(errp, "Memory window address not specified for PHB");
1160         return;
1161     }
1162
1163     if (sphb->io_win_addr == (hwaddr)-1) {
1164         error_setg(errp, "IO window address not specified for PHB");
1165         return;
1166     }
1167
1168     if (spapr_pci_find_phb(spapr, sphb->buid)) {
1169         error_setg(errp, "PCI host bridges must have unique BUIDs");
1170         return;
1171     }
1172
1173     sphb->dtbusname = g_strdup_printf("pci@%" PRIx64, sphb->buid);
1174
1175     namebuf = alloca(strlen(sphb->dtbusname) + 32);
1176
1177     /* Initialize memory regions */
1178     sprintf(namebuf, "%s.mmio", sphb->dtbusname);
1179     memory_region_init(&sphb->memspace, OBJECT(sphb), namebuf, UINT64_MAX);
1180
1181     sprintf(namebuf, "%s.mmio-alias", sphb->dtbusname);
1182     memory_region_init_alias(&sphb->memwindow, OBJECT(sphb),
1183                              namebuf, &sphb->memspace,
1184                              SPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);
1185     memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,
1186                                 &sphb->memwindow);
1187
1188     /* Initialize IO regions */
1189     sprintf(namebuf, "%s.io", sphb->dtbusname);
1190     memory_region_init(&sphb->iospace, OBJECT(sphb),
1191                        namebuf, SPAPR_PCI_IO_WIN_SIZE);
1192
1193     sprintf(namebuf, "%s.io-alias", sphb->dtbusname);
1194     memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), namebuf,
1195                              &sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);
1196     memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,
1197                                 &sphb->iowindow);
1198
1199     bus = pci_register_bus(dev, NULL,
1200                            pci_spapr_set_irq, pci_spapr_map_irq, sphb,
1201                            &sphb->memspace, &sphb->iospace,
1202                            PCI_DEVFN(0, 0), PCI_NUM_PINS, TYPE_PCI_BUS);
1203     phb->bus = bus;
1204     qbus_set_hotplug_handler(BUS(phb->bus), DEVICE(sphb), NULL);
1205
1206     /*
1207      * Initialize PHB address space.
1208      * By default there will be at least one subregion for default
1209      * 32bit DMA window.
1210      * Later the guest might want to create another DMA window
1211      * which will become another memory subregion.
1212      */
1213     sprintf(namebuf, "%s.iommu-root", sphb->dtbusname);
1214
1215     memory_region_init(&sphb->iommu_root, OBJECT(sphb),
1216                        namebuf, UINT64_MAX);
1217     address_space_init(&sphb->iommu_as, &sphb->iommu_root,
1218                        sphb->dtbusname);
1219
1220     /*
1221      * As MSI/MSIX interrupts trigger by writing at MSI/MSIX vectors,
1222      * we need to allocate some memory to catch those writes coming
1223      * from msi_notify()/msix_notify().
1224      * As MSIMessage:addr is going to be the same and MSIMessage:data
1225      * is going to be a VIRQ number, 4 bytes of the MSI MR will only
1226      * be used.
1227      *
1228      * For KVM we want to ensure that this memory is a full page so that
1229      * our memory slot is of page size granularity.
1230      */
1231 #ifdef CONFIG_KVM
1232     if (kvm_enabled()) {
1233         msi_window_size = getpagesize();
1234     }
1235 #endif
1236
1237     memory_region_init_io(&sphb->msiwindow, NULL, &spapr_msi_ops, spapr,
1238                           "msi", msi_window_size);
1239     memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,
1240                                 &sphb->msiwindow);
1241
1242     pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);
1243
1244     pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);
1245
1246     QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);
1247
1248     /* Initialize the LSI table */
1249     for (i = 0; i < PCI_NUM_PINS; i++) {
1250         uint32_t irq;
1251
1252         irq = xics_alloc_block(spapr->icp, 0, 1, true, false);
1253         if (!irq) {
1254             error_setg(errp, "spapr_allocate_lsi failed");
1255             return;
1256         }
1257
1258         sphb->lsi_table[i].irq = irq;
1259     }
1260
1261     /* allocate connectors for child PCI devices */
1262     if (sphb->dr_enabled) {
1263         for (i = 0; i < PCI_SLOT_MAX * 8; i++) {
1264             spapr_dr_connector_new(OBJECT(phb),
1265                                    SPAPR_DR_CONNECTOR_TYPE_PCI,
1266                                    (sphb->index << 16) | i);
1267         }
1268     }
1269
1270     if (!info->finish_realize) {
1271         error_setg(errp, "finish_realize not defined");
1272         return;
1273     }
1274
1275     info->finish_realize(sphb, errp);
1276
1277     sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
1278 }
1279
1280 static void spapr_phb_finish_realize(sPAPRPHBState *sphb, Error **errp)
1281 {
1282     sPAPRTCETable *tcet;
1283     uint32_t nb_table;
1284
1285     nb_table = SPAPR_PCI_DMA32_SIZE >> SPAPR_TCE_PAGE_SHIFT;
1286     tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn,
1287                                0, SPAPR_TCE_PAGE_SHIFT, nb_table, false);
1288     if (!tcet) {
1289         error_setg(errp, "Unable to create TCE table for %s",
1290                    sphb->dtbusname);
1291         return ;
1292     }
1293
1294     /* Register default 32bit DMA window */
1295     memory_region_add_subregion(&sphb->iommu_root, 0,
1296                                 spapr_tce_get_iommu(tcet));
1297 }
1298
1299 static int spapr_phb_children_reset(Object *child, void *opaque)
1300 {
1301     DeviceState *dev = (DeviceState *) object_dynamic_cast(child, TYPE_DEVICE);
1302
1303     if (dev) {
1304         device_reset(dev);
1305     }
1306
1307     return 0;
1308 }
1309
1310 static void spapr_phb_reset(DeviceState *qdev)
1311 {
1312     /* Reset the IOMMU state */
1313     object_child_foreach(OBJECT(qdev), spapr_phb_children_reset, NULL);
1314 }
1315
1316 static Property spapr_phb_properties[] = {
1317     DEFINE_PROP_UINT32("index", sPAPRPHBState, index, -1),
1318     DEFINE_PROP_UINT64("buid", sPAPRPHBState, buid, -1),
1319     DEFINE_PROP_UINT32("liobn", sPAPRPHBState, dma_liobn, -1),
1320     DEFINE_PROP_UINT64("mem_win_addr", sPAPRPHBState, mem_win_addr, -1),
1321     DEFINE_PROP_UINT64("mem_win_size", sPAPRPHBState, mem_win_size,
1322                        SPAPR_PCI_MMIO_WIN_SIZE),
1323     DEFINE_PROP_UINT64("io_win_addr", sPAPRPHBState, io_win_addr, -1),
1324     DEFINE_PROP_UINT64("io_win_size", sPAPRPHBState, io_win_size,
1325                        SPAPR_PCI_IO_WIN_SIZE),
1326     DEFINE_PROP_BOOL("dynamic-reconfiguration", sPAPRPHBState, dr_enabled,
1327                      true),
1328     DEFINE_PROP_END_OF_LIST(),
1329 };
1330
1331 static const VMStateDescription vmstate_spapr_pci_lsi = {
1332     .name = "spapr_pci/lsi",
1333     .version_id = 1,
1334     .minimum_version_id = 1,
1335     .fields = (VMStateField[]) {
1336         VMSTATE_UINT32_EQUAL(irq, struct spapr_pci_lsi),
1337
1338         VMSTATE_END_OF_LIST()
1339     },
1340 };
1341
1342 static const VMStateDescription vmstate_spapr_pci_msi = {
1343     .name = "spapr_pci/msi",
1344     .version_id = 1,
1345     .minimum_version_id = 1,
1346     .fields = (VMStateField []) {
1347         VMSTATE_UINT32(key, spapr_pci_msi_mig),
1348         VMSTATE_UINT32(value.first_irq, spapr_pci_msi_mig),
1349         VMSTATE_UINT32(value.num, spapr_pci_msi_mig),
1350         VMSTATE_END_OF_LIST()
1351     },
1352 };
1353
1354 static void spapr_pci_fill_msi_devs(gpointer key, gpointer value,
1355                                     gpointer opaque)
1356 {
1357     sPAPRPHBState *sphb = opaque;
1358
1359     sphb->msi_devs[sphb->msi_devs_num].key = *(uint32_t *)key;
1360     sphb->msi_devs[sphb->msi_devs_num].value = *(spapr_pci_msi *)value;
1361     sphb->msi_devs_num++;
1362 }
1363
1364 static void spapr_pci_pre_save(void *opaque)
1365 {
1366     sPAPRPHBState *sphb = opaque;
1367     int msi_devs_num;
1368
1369     if (sphb->msi_devs) {
1370         g_free(sphb->msi_devs);
1371         sphb->msi_devs = NULL;
1372     }
1373     sphb->msi_devs_num = 0;
1374     msi_devs_num = g_hash_table_size(sphb->msi);
1375     if (!msi_devs_num) {
1376         return;
1377     }
1378     sphb->msi_devs = g_malloc(msi_devs_num * sizeof(spapr_pci_msi_mig));
1379
1380     g_hash_table_foreach(sphb->msi, spapr_pci_fill_msi_devs, sphb);
1381     assert(sphb->msi_devs_num == msi_devs_num);
1382 }
1383
1384 static int spapr_pci_post_load(void *opaque, int version_id)
1385 {
1386     sPAPRPHBState *sphb = opaque;
1387     gpointer key, value;
1388     int i;
1389
1390     for (i = 0; i < sphb->msi_devs_num; ++i) {
1391         key = g_memdup(&sphb->msi_devs[i].key,
1392                        sizeof(sphb->msi_devs[i].key));
1393         value = g_memdup(&sphb->msi_devs[i].value,
1394                          sizeof(sphb->msi_devs[i].value));
1395         g_hash_table_insert(sphb->msi, key, value);
1396     }
1397     if (sphb->msi_devs) {
1398         g_free(sphb->msi_devs);
1399         sphb->msi_devs = NULL;
1400     }
1401     sphb->msi_devs_num = 0;
1402
1403     return 0;
1404 }
1405
1406 static const VMStateDescription vmstate_spapr_pci = {
1407     .name = "spapr_pci",
1408     .version_id = 2,
1409     .minimum_version_id = 2,
1410     .pre_save = spapr_pci_pre_save,
1411     .post_load = spapr_pci_post_load,
1412     .fields = (VMStateField[]) {
1413         VMSTATE_UINT64_EQUAL(buid, sPAPRPHBState),
1414         VMSTATE_UINT32_EQUAL(dma_liobn, sPAPRPHBState),
1415         VMSTATE_UINT64_EQUAL(mem_win_addr, sPAPRPHBState),
1416         VMSTATE_UINT64_EQUAL(mem_win_size, sPAPRPHBState),
1417         VMSTATE_UINT64_EQUAL(io_win_addr, sPAPRPHBState),
1418         VMSTATE_UINT64_EQUAL(io_win_size, sPAPRPHBState),
1419         VMSTATE_STRUCT_ARRAY(lsi_table, sPAPRPHBState, PCI_NUM_PINS, 0,
1420                              vmstate_spapr_pci_lsi, struct spapr_pci_lsi),
1421         VMSTATE_INT32(msi_devs_num, sPAPRPHBState),
1422         VMSTATE_STRUCT_VARRAY_ALLOC(msi_devs, sPAPRPHBState, msi_devs_num, 0,
1423                                     vmstate_spapr_pci_msi, spapr_pci_msi_mig),
1424         VMSTATE_END_OF_LIST()
1425     },
1426 };
1427
1428 static const char *spapr_phb_root_bus_path(PCIHostState *host_bridge,
1429                                            PCIBus *rootbus)
1430 {
1431     sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(host_bridge);
1432
1433     return sphb->dtbusname;
1434 }
1435
1436 static void spapr_phb_class_init(ObjectClass *klass, void *data)
1437 {
1438     PCIHostBridgeClass *hc = PCI_HOST_BRIDGE_CLASS(klass);
1439     DeviceClass *dc = DEVICE_CLASS(klass);
1440     sPAPRPHBClass *spc = SPAPR_PCI_HOST_BRIDGE_CLASS(klass);
1441     HotplugHandlerClass *hp = HOTPLUG_HANDLER_CLASS(klass);
1442
1443     hc->root_bus_path = spapr_phb_root_bus_path;
1444     dc->realize = spapr_phb_realize;
1445     dc->props = spapr_phb_properties;
1446     dc->reset = spapr_phb_reset;
1447     dc->vmsd = &vmstate_spapr_pci;
1448     set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
1449     dc->cannot_instantiate_with_device_add_yet = false;
1450     spc->finish_realize = spapr_phb_finish_realize;
1451     hp->plug = spapr_phb_hot_plug_child;
1452     hp->unplug = spapr_phb_hot_unplug_child;
1453 }
1454
1455 static const TypeInfo spapr_phb_info = {
1456     .name          = TYPE_SPAPR_PCI_HOST_BRIDGE,
1457     .parent        = TYPE_PCI_HOST_BRIDGE,
1458     .instance_size = sizeof(sPAPRPHBState),
1459     .class_init    = spapr_phb_class_init,
1460     .class_size    = sizeof(sPAPRPHBClass),
1461     .interfaces    = (InterfaceInfo[]) {
1462         { TYPE_HOTPLUG_HANDLER },
1463         { }
1464     }
1465 };
1466
1467 PCIHostState *spapr_create_phb(sPAPREnvironment *spapr, int index)
1468 {
1469     DeviceState *dev;
1470
1471     dev = qdev_create(NULL, TYPE_SPAPR_PCI_HOST_BRIDGE);
1472     qdev_prop_set_uint32(dev, "index", index);
1473     qdev_init_nofail(dev);
1474
1475     return PCI_HOST_BRIDGE(dev);
1476 }
1477
1478 int spapr_populate_pci_dt(sPAPRPHBState *phb,
1479                           uint32_t xics_phandle,
1480                           void *fdt)
1481 {
1482     int bus_off, i, j, ret;
1483     char nodename[256];
1484     uint32_t bus_range[] = { cpu_to_be32(0), cpu_to_be32(0xff) };
1485     const uint64_t mmiosize = memory_region_size(&phb->memwindow);
1486     const uint64_t w32max = (1ULL << 32) - SPAPR_PCI_MEM_WIN_BUS_OFFSET;
1487     const uint64_t w32size = MIN(w32max, mmiosize);
1488     const uint64_t w64size = (mmiosize > w32size) ? (mmiosize - w32size) : 0;
1489     struct {
1490         uint32_t hi;
1491         uint64_t child;
1492         uint64_t parent;
1493         uint64_t size;
1494     } QEMU_PACKED ranges[] = {
1495         {
1496             cpu_to_be32(b_ss(1)), cpu_to_be64(0),
1497             cpu_to_be64(phb->io_win_addr),
1498             cpu_to_be64(memory_region_size(&phb->iospace)),
1499         },
1500         {
1501             cpu_to_be32(b_ss(2)), cpu_to_be64(SPAPR_PCI_MEM_WIN_BUS_OFFSET),
1502             cpu_to_be64(phb->mem_win_addr),
1503             cpu_to_be64(w32size),
1504         },
1505         {
1506             cpu_to_be32(b_ss(3)), cpu_to_be64(1ULL << 32),
1507             cpu_to_be64(phb->mem_win_addr + w32size),
1508             cpu_to_be64(w64size)
1509         },
1510     };
1511     const unsigned sizeof_ranges = (w64size ? 3 : 2) * sizeof(ranges[0]);
1512     uint64_t bus_reg[] = { cpu_to_be64(phb->buid), 0 };
1513     uint32_t interrupt_map_mask[] = {
1514         cpu_to_be32(b_ddddd(-1)|b_fff(0)), 0x0, 0x0, cpu_to_be32(-1)};
1515     uint32_t interrupt_map[PCI_SLOT_MAX * PCI_NUM_PINS][7];
1516     sPAPRTCETable *tcet;
1517
1518     /* Start populating the FDT */
1519     sprintf(nodename, "pci@%" PRIx64, phb->buid);
1520     bus_off = fdt_add_subnode(fdt, 0, nodename);
1521     if (bus_off < 0) {
1522         return bus_off;
1523     }
1524
1525     /* Write PHB properties */
1526     _FDT(fdt_setprop_string(fdt, bus_off, "device_type", "pci"));
1527     _FDT(fdt_setprop_string(fdt, bus_off, "compatible", "IBM,Logical_PHB"));
1528     _FDT(fdt_setprop_cell(fdt, bus_off, "#address-cells", 0x3));
1529     _FDT(fdt_setprop_cell(fdt, bus_off, "#size-cells", 0x2));
1530     _FDT(fdt_setprop_cell(fdt, bus_off, "#interrupt-cells", 0x1));
1531     _FDT(fdt_setprop(fdt, bus_off, "used-by-rtas", NULL, 0));
1532     _FDT(fdt_setprop(fdt, bus_off, "bus-range", &bus_range, sizeof(bus_range)));
1533     _FDT(fdt_setprop(fdt, bus_off, "ranges", &ranges, sizeof_ranges));
1534     _FDT(fdt_setprop(fdt, bus_off, "reg", &bus_reg, sizeof(bus_reg)));
1535     _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pci-config-space-type", 0x1));
1536     _FDT(fdt_setprop_cell(fdt, bus_off, "ibm,pe-total-#msi", XICS_IRQS));
1537
1538     /* Build the interrupt-map, this must matches what is done
1539      * in pci_spapr_map_irq
1540      */
1541     _FDT(fdt_setprop(fdt, bus_off, "interrupt-map-mask",
1542                      &interrupt_map_mask, sizeof(interrupt_map_mask)));
1543     for (i = 0; i < PCI_SLOT_MAX; i++) {
1544         for (j = 0; j < PCI_NUM_PINS; j++) {
1545             uint32_t *irqmap = interrupt_map[i*PCI_NUM_PINS + j];
1546             int lsi_num = pci_spapr_swizzle(i, j);
1547
1548             irqmap[0] = cpu_to_be32(b_ddddd(i)|b_fff(0));
1549             irqmap[1] = 0;
1550             irqmap[2] = 0;
1551             irqmap[3] = cpu_to_be32(j+1);
1552             irqmap[4] = cpu_to_be32(xics_phandle);
1553             irqmap[5] = cpu_to_be32(phb->lsi_table[lsi_num].irq);
1554             irqmap[6] = cpu_to_be32(0x8);
1555         }
1556     }
1557     /* Write interrupt map */
1558     _FDT(fdt_setprop(fdt, bus_off, "interrupt-map", &interrupt_map,
1559                      sizeof(interrupt_map)));
1560
1561     tcet = spapr_tce_find_by_liobn(SPAPR_PCI_LIOBN(phb->index, 0));
1562     spapr_dma_dt(fdt, bus_off, "ibm,dma-window",
1563                  tcet->liobn, tcet->bus_offset,
1564                  tcet->nb_table << tcet->page_shift);
1565
1566     ret = spapr_drc_populate_dt(fdt, bus_off, OBJECT(phb),
1567                                 SPAPR_DR_CONNECTOR_TYPE_PCI);
1568     if (ret) {
1569         return ret;
1570     }
1571
1572     return 0;
1573 }
1574
1575 void spapr_pci_rtas_init(void)
1576 {
1577     spapr_rtas_register(RTAS_READ_PCI_CONFIG, "read-pci-config",
1578                         rtas_read_pci_config);
1579     spapr_rtas_register(RTAS_WRITE_PCI_CONFIG, "write-pci-config",
1580                         rtas_write_pci_config);
1581     spapr_rtas_register(RTAS_IBM_READ_PCI_CONFIG, "ibm,read-pci-config",
1582                         rtas_ibm_read_pci_config);
1583     spapr_rtas_register(RTAS_IBM_WRITE_PCI_CONFIG, "ibm,write-pci-config",
1584                         rtas_ibm_write_pci_config);
1585     if (msi_supported) {
1586         spapr_rtas_register(RTAS_IBM_QUERY_INTERRUPT_SOURCE_NUMBER,
1587                             "ibm,query-interrupt-source-number",
1588                             rtas_ibm_query_interrupt_source_number);
1589         spapr_rtas_register(RTAS_IBM_CHANGE_MSI, "ibm,change-msi",
1590                             rtas_ibm_change_msi);
1591     }
1592
1593     spapr_rtas_register(RTAS_IBM_SET_EEH_OPTION,
1594                         "ibm,set-eeh-option",
1595                         rtas_ibm_set_eeh_option);
1596     spapr_rtas_register(RTAS_IBM_GET_CONFIG_ADDR_INFO2,
1597                         "ibm,get-config-addr-info2",
1598                         rtas_ibm_get_config_addr_info2);
1599     spapr_rtas_register(RTAS_IBM_READ_SLOT_RESET_STATE2,
1600                         "ibm,read-slot-reset-state2",
1601                         rtas_ibm_read_slot_reset_state2);
1602     spapr_rtas_register(RTAS_IBM_SET_SLOT_RESET,
1603                         "ibm,set-slot-reset",
1604                         rtas_ibm_set_slot_reset);
1605     spapr_rtas_register(RTAS_IBM_CONFIGURE_PE,
1606                         "ibm,configure-pe",
1607                         rtas_ibm_configure_pe);
1608     spapr_rtas_register(RTAS_IBM_SLOT_ERROR_DETAIL,
1609                         "ibm,slot-error-detail",
1610                         rtas_ibm_slot_error_detail);
1611 }
1612
1613 static void spapr_pci_register_types(void)
1614 {
1615     type_register_static(&spapr_phb_info);
1616 }
1617
1618 type_init(spapr_pci_register_types)
1619
1620 static int spapr_switch_one_vga(DeviceState *dev, void *opaque)
1621 {
1622     bool be = *(bool *)opaque;
1623
1624     if (object_dynamic_cast(OBJECT(dev), "VGA")
1625         || object_dynamic_cast(OBJECT(dev), "secondary-vga")) {
1626         object_property_set_bool(OBJECT(dev), be, "big-endian-framebuffer",
1627                                  &error_abort);
1628     }
1629     return 0;
1630 }
1631
1632 void spapr_pci_switch_vga(bool big_endian)
1633 {
1634     sPAPRPHBState *sphb;
1635
1636     /*
1637      * For backward compatibility with existing guests, we switch
1638      * the endianness of the VGA controller when changing the guest
1639      * interrupt mode
1640      */
1641     QLIST_FOREACH(sphb, &spapr->phbs, list) {
1642         BusState *bus = &PCI_HOST_BRIDGE(sphb)->bus->qbus;
1643         qbus_walk_children(bus, spapr_switch_one_vga, NULL, NULL, NULL,
1644                            &big_endian);
1645     }
1646 }