Diff for /qemu/hw/pcie_host.c between versions 1.1.1.4 and 1.1.1.5

version 1.1.1.4, 2018/04/24 18:59:44 version 1.1.1.5, 2018/04/24 19:27:20
Line 22 Line 22
 #include "hw.h"  #include "hw.h"
 #include "pci.h"  #include "pci.h"
 #include "pcie_host.h"  #include "pcie_host.h"
   #include "exec-memory.h"
   
 /*  /*
  * PCI express mmcfig address   * PCI express mmcfig address
Line 52  static inline PCIDevice *pcie_dev_find_b Line 53  static inline PCIDevice *pcie_dev_find_b
                            PCIE_MMCFG_DEVFN(mmcfg_addr));                             PCIE_MMCFG_DEVFN(mmcfg_addr));
 }  }
   
 static void pcie_mmcfg_data_write(PCIBus *s,  static void pcie_mmcfg_data_write(void *opaque, target_phys_addr_t mmcfg_addr,
                                   uint32_t mmcfg_addr, uint32_t val, int len)                                    uint64_t val, unsigned len)
 {  {
       PCIExpressHost *e = opaque;
       PCIBus *s = e->pci.bus;
     PCIDevice *pci_dev = pcie_dev_find_by_mmcfg_addr(s, mmcfg_addr);      PCIDevice *pci_dev = pcie_dev_find_by_mmcfg_addr(s, mmcfg_addr);
       uint32_t addr;
       uint32_t limit;
   
     if (!pci_dev)      if (!pci_dev) {
         return;          return;
       }
     pci_dev->config_write(pci_dev,      addr = PCIE_MMCFG_CONFOFFSET(mmcfg_addr);
                           PCIE_MMCFG_CONFOFFSET(mmcfg_addr), val, len);      limit = pci_config_size(pci_dev);
       if (limit <= addr) {
           /* conventional pci device can be behind pcie-to-pci bridge.
              256 <= addr < 4K has no effects. */
           return;
       }
       pci_host_config_write_common(pci_dev, addr, limit, val, len);
 }  }
   
 static uint32_t pcie_mmcfg_data_read(PCIBus *s, uint32_t addr, int len)  static uint64_t pcie_mmcfg_data_read(void *opaque,
                                        target_phys_addr_t mmcfg_addr,
                                        unsigned len)
 {  {
     PCIDevice *pci_dev = pcie_dev_find_by_mmcfg_addr(s, addr);      PCIExpressHost *e = opaque;
       PCIBus *s = e->pci.bus;
       PCIDevice *pci_dev = pcie_dev_find_by_mmcfg_addr(s, mmcfg_addr);
       uint32_t addr;
       uint32_t limit;
   
     assert(len == 1 || len == 2 || len == 4);  
     if (!pci_dev) {      if (!pci_dev) {
         return ~0x0;          return ~0x0;
     }      }
     return pci_dev->config_read(pci_dev, PCIE_MMCFG_CONFOFFSET(addr), len);      addr = PCIE_MMCFG_CONFOFFSET(mmcfg_addr);
 }      limit = pci_config_size(pci_dev);
       if (limit <= addr) {
 static void pcie_mmcfg_data_writeb(void *opaque,          /* conventional pci device can be behind pcie-to-pci bridge.
                                    target_phys_addr_t addr, uint32_t value)             256 <= addr < 4K has no effects. */
 {          return ~0x0;
     PCIExpressHost *e = opaque;      }
     pcie_mmcfg_data_write(e->pci.bus, addr - e->base_addr, value, 1);      return pci_host_config_read_common(pci_dev, addr, limit, len);
 }  
   
 static void pcie_mmcfg_data_writew(void *opaque,  
                                    target_phys_addr_t addr, uint32_t value)  
 {  
     PCIExpressHost *e = opaque;  
     pcie_mmcfg_data_write(e->pci.bus, addr - e->base_addr, value, 2);  
 }  
   
 static void pcie_mmcfg_data_writel(void *opaque,  
                                    target_phys_addr_t addr, uint32_t value)  
 {  
     PCIExpressHost *e = opaque;  
     pcie_mmcfg_data_write(e->pci.bus, addr - e->base_addr, value, 4);  
 }  
   
 static uint32_t pcie_mmcfg_data_readb(void *opaque, target_phys_addr_t addr)  
 {  
     PCIExpressHost *e = opaque;  
     return pcie_mmcfg_data_read(e->pci.bus, addr - e->base_addr, 1);  
 }  
   
 static uint32_t pcie_mmcfg_data_readw(void *opaque, target_phys_addr_t addr)  
 {  
     PCIExpressHost *e = opaque;  
     return pcie_mmcfg_data_read(e->pci.bus, addr - e->base_addr, 2);  
 }  
   
 static uint32_t pcie_mmcfg_data_readl(void *opaque, target_phys_addr_t addr)  
 {  
     PCIExpressHost *e = opaque;  
     return pcie_mmcfg_data_read(e->pci.bus, addr - e->base_addr, 4);  
 }  }
   
   static const MemoryRegionOps pcie_mmcfg_ops = {
 static CPUWriteMemoryFunc * const pcie_mmcfg_write[] =      .read = pcie_mmcfg_data_read,
 {      .write = pcie_mmcfg_data_write,
     pcie_mmcfg_data_writeb,      .endianness = DEVICE_NATIVE_ENDIAN,
     pcie_mmcfg_data_writew,  
     pcie_mmcfg_data_writel,  
 };  
   
 static CPUReadMemoryFunc * const pcie_mmcfg_read[] =  
 {  
     pcie_mmcfg_data_readb,  
     pcie_mmcfg_data_readw,  
     pcie_mmcfg_data_readl,  
 };  };
   
 /* pcie_host::base_addr == PCIE_BASE_ADDR_UNMAPPED when it isn't mapped. */  /* pcie_host::base_addr == PCIE_BASE_ADDR_UNMAPPED when it isn't mapped. */
 #define PCIE_BASE_ADDR_UNMAPPED  ((target_phys_addr_t)-1ULL)  #define PCIE_BASE_ADDR_UNMAPPED  ((target_phys_addr_t)-1ULL)
   
 int pcie_host_init(PCIExpressHost *e)  int pcie_host_init(PCIExpressHost *e, uint32_t size)
 {  {
       assert(!(size & (size - 1)));       /* power of 2 */
       assert(size >= PCIE_MMCFG_SIZE_MIN);
       assert(size <= PCIE_MMCFG_SIZE_MAX);
     e->base_addr = PCIE_BASE_ADDR_UNMAPPED;      e->base_addr = PCIE_BASE_ADDR_UNMAPPED;
     e->mmio_index =      e->size = size;
         cpu_register_io_memory(pcie_mmcfg_read, pcie_mmcfg_write, e,      memory_region_init_io(&e->mmio, &pcie_mmcfg_ops, e, "pcie-mmcfg", e->size);
                                DEVICE_NATIVE_ENDIAN);  
     if (e->mmio_index < 0) {  
         return -1;  
     }  
   
     return 0;      return 0;
 }  }
Line 148  int pcie_host_init(PCIExpressHost *e) Line 122  int pcie_host_init(PCIExpressHost *e)
 void pcie_host_mmcfg_unmap(PCIExpressHost *e)  void pcie_host_mmcfg_unmap(PCIExpressHost *e)
 {  {
     if (e->base_addr != PCIE_BASE_ADDR_UNMAPPED) {      if (e->base_addr != PCIE_BASE_ADDR_UNMAPPED) {
         cpu_register_physical_memory(e->base_addr, e->size, IO_MEM_UNASSIGNED);          memory_region_del_subregion(get_system_memory(), &e->mmio);
         e->base_addr = PCIE_BASE_ADDR_UNMAPPED;          e->base_addr = PCIE_BASE_ADDR_UNMAPPED;
     }      }
 }  }
   
 void pcie_host_mmcfg_map(PCIExpressHost *e,  void pcie_host_mmcfg_map(PCIExpressHost *e, target_phys_addr_t addr)
                          target_phys_addr_t addr, uint32_t size)  
 {  {
     assert(!(size & (size - 1)));       /* power of 2 */  
     assert(size >= PCIE_MMCFG_SIZE_MIN);  
     assert(size <= PCIE_MMCFG_SIZE_MAX);  
   
     e->base_addr = addr;      e->base_addr = addr;
     e->size = size;      memory_region_add_subregion(get_system_memory(), e->base_addr, &e->mmio);
     cpu_register_physical_memory(e->base_addr, e->size, e->mmio_index);  
 }  }
   
 void pcie_host_mmcfg_update(PCIExpressHost *e,  void pcie_host_mmcfg_update(PCIExpressHost *e,
                             int enable,                              int enable,
                             target_phys_addr_t addr, uint32_t size)                              target_phys_addr_t addr)
 {  {
     pcie_host_mmcfg_unmap(e);      pcie_host_mmcfg_unmap(e);
     if (enable) {      if (enable) {
         pcie_host_mmcfg_map(e, addr, size);          pcie_host_mmcfg_map(e, addr);
     }      }
 }  }

Removed from v.1.1.1.4  
changed lines
  Added in v.1.1.1.5


unix.superglobalmegacorp.com