openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'ppc-for-upstream' of git://repo.or.cz/qemu/agraf 

* 'ppc-for-upstream' of git://repo.or.cz/qemu/agraf:
  PPC: Fix openpic with relative memregions
  pseries: Configure PCI bridge using properties
  PPC: KVM: Synchronize regs on CPU dump
  kvm: Comparison with ioctl number macros needs to be unsigned
  ppc: Correctly define POWERPC_INSNS2_DEFAULT
  pseries: Add support for level interrupts to XICS
  PPC: Fix large page support in TCG
  PPC: Add PIR register to POWER7 CPU
  pseries: Remove PCI device from PCI host bridge code
  pseries: Remove unused constant from PCI code
  pseries: Update SLOF firmware image
  PPC64: Add support for ldbrx and stdbrx instructions
  pseries: Don't try to munmap() a malloc()ed TCE table
  ppc: Add missing 'static' to spin_rw_ops
  PPC: 405: Fix ppc405ep initialization
  Bad zero comparison for sas_ss_flags on powerpc
This commit is contained in:
Blue Swirl 2012-03-17 12:59:23 +00:00
parent 1329d1896c 38ae51a804
commit cb76e9c7b7
20 changed files with 304 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
hw/openpic.c
View File

@ -713,7 +713,7 @@ static void openpic_timer_write (void *opaque, uint32_t addr, uint32_t val)
DPRINTF("%s: addr %08x <= %08x\n", __func__, addr, val); DPRINTF("%s: addr %08x <= %08x\n", __func__, addr, val);
if (addr & 0xF) if (addr & 0xF)
return; return;
addr -= 0x1100; addr -= 0x10;
addr &= 0xFFFF; addr &= 0xFFFF;
idx = (addr & 0xFFF0) >> 6; idx = (addr & 0xFFF0) >> 6;
addr = addr & 0x30; addr = addr & 0x30;
@ -746,7 +746,7 @@ static uint32_t openpic_timer_read (void *opaque, uint32_t addr)
retval = 0xFFFFFFFF; retval = 0xFFFFFFFF;
if (addr & 0xF) if (addr & 0xF)
return retval; return retval;
addr -= 0x1100; addr -= 0x10;
addr &= 0xFFFF; addr &= 0xFFFF;
idx = (addr & 0xFFF0) >> 6; idx = (addr & 0xFFF0) >> 6;
addr = addr & 0x30; addr = addr & 0x30;
@ -1361,7 +1361,6 @@ static void mpic_src_ext_write (void *opaque, target_phys_addr_t addr,
if (addr & 0xF) if (addr & 0xF)
return; return;
addr -= MPIC_EXT_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_EXT_REG_SIZE) { if (addr < MPIC_EXT_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1385,7 +1384,6 @@ static uint32_t mpic_src_ext_read (void *opaque, target_phys_addr_t addr)
if (addr & 0xF) if (addr & 0xF)
return retval; return retval;
addr -= MPIC_EXT_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_EXT_REG_SIZE) { if (addr < MPIC_EXT_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1411,7 +1409,6 @@ static void mpic_src_int_write (void *opaque, target_phys_addr_t addr,
if (addr & 0xF) if (addr & 0xF)
return; return;
addr -= MPIC_INT_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_INT_REG_SIZE) { if (addr < MPIC_INT_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1435,7 +1432,6 @@ static uint32_t mpic_src_int_read (void *opaque, target_phys_addr_t addr)
if (addr & 0xF) if (addr & 0xF)
return retval; return retval;
addr -= MPIC_INT_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_INT_REG_SIZE) { if (addr < MPIC_INT_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1461,7 +1457,6 @@ static void mpic_src_msg_write (void *opaque, target_phys_addr_t addr,
if (addr & 0xF) if (addr & 0xF)
return; return;
addr -= MPIC_MSG_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_MSG_REG_SIZE) { if (addr < MPIC_MSG_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1485,7 +1480,6 @@ static uint32_t mpic_src_msg_read (void *opaque, target_phys_addr_t addr)
if (addr & 0xF) if (addr & 0xF)
return retval; return retval;
addr -= MPIC_MSG_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_MSG_REG_SIZE) { if (addr < MPIC_MSG_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1511,7 +1505,6 @@ static void mpic_src_msi_write (void *opaque, target_phys_addr_t addr,
if (addr & 0xF) if (addr & 0xF)
return; return;
addr -= MPIC_MSI_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_MSI_REG_SIZE) { if (addr < MPIC_MSI_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {
@ -1534,7 +1527,6 @@ static uint32_t mpic_src_msi_read (void *opaque, target_phys_addr_t addr)
if (addr & 0xF) if (addr & 0xF)
return retval; return retval;
addr -= MPIC_MSI_REG_START & (OPENPIC_PAGE_SIZE - 1);
if (addr < MPIC_MSI_REG_SIZE) { if (addr < MPIC_MSI_REG_SIZE) {
idx += (addr & 0xFFF0) >> 5; idx += (addr & 0xFFF0) >> 5;
if (addr & 0x10) { if (addr & 0x10) {

2
hw/ppc405_uc.c
View File

@ -2471,6 +2471,8 @@ CPUPPCState *ppc405ep_init(MemoryRegion *address_space_mem,
ppc4xx_pob_init(env); ppc4xx_pob_init(env);
/* OBP arbitrer */ /* OBP arbitrer */
ppc4xx_opba_init(0xef600600); ppc4xx_opba_init(0xef600600);
/* Initialize timers */
ppc_booke_timers_init(env, sysclk, 0);
/* Universal interrupt controller */ /* Universal interrupt controller */
irqs = g_malloc0(sizeof(qemu_irq) * PPCUIC_OUTPUT_NB); irqs = g_malloc0(sizeof(qemu_irq) * PPCUIC_OUTPUT_NB);
irqs[PPCUIC_OUTPUT_INT] = irqs[PPCUIC_OUTPUT_INT] =

2
hw/ppce500_spin.c
View File

@ -182,7 +182,7 @@ static uint64_t spin_read(void *opaque, target_phys_addr_t addr, unsigned len)
} }
} }
const MemoryRegionOps spin_rw_ops = { static const MemoryRegionOps spin_rw_ops = {
.read = spin_read, .read = spin_read,
.write = spin_write, .write = spin_write,
.endianness = DEVICE_BIG_ENDIAN, .endianness = DEVICE_BIG_ENDIAN,

5
hw/spapr.c
View File

@ -83,7 +83,8 @@
sPAPREnvironment *spapr; sPAPREnvironment *spapr;
qemu_irq spapr_allocate_irq(uint32_t hint, uint32_t *irq_num) qemu_irq spapr_allocate_irq(uint32_t hint, uint32_t *irq_num,
enum xics_irq_type type)
{ {
uint32_t irq; uint32_t irq;
qemu_irq qirq; qemu_irq qirq;
@ -95,7 +96,7 @@ qemu_irq spapr_allocate_irq(uint32_t hint, uint32_t *irq_num)
irq = spapr->next_irq++; irq = spapr->next_irq++;
} }
qirq = xics_find_qirq(spapr->icp, irq); qirq = xics_assign_irq(spapr->icp, irq, type);
if (!qirq) { if (!qirq) {
return NULL; return NULL;
} }

13
hw/spapr.h
View File

@ -286,7 +286,18 @@ void spapr_register_hypercall(target_ulong opcode, spapr_hcall_fn fn);
target_ulong spapr_hypercall(CPUPPCState *env, target_ulong opcode, target_ulong spapr_hypercall(CPUPPCState *env, target_ulong opcode,
target_ulong *args); target_ulong *args);
qemu_irq spapr_allocate_irq(uint32_t hint, uint32_t *irq_num); qemu_irq spapr_allocate_irq(uint32_t hint, uint32_t *irq_num,
enum xics_irq_type type);
static inline qemu_irq spapr_allocate_msi(uint32_t hint, uint32_t *irq_num)
{
return spapr_allocate_irq(hint, irq_num, XICS_MSI);
}
static inline qemu_irq spapr_allocate_lsi(uint32_t hint, uint32_t *irq_num)
{
return spapr_allocate_irq(hint, irq_num, XICS_LSI);
}
static inline uint32_t rtas_ld(target_ulong phys, int n) static inline uint32_t rtas_ld(target_ulong phys, int n)
{ {

193
hw/spapr_pci.c
View File

@ -32,13 +32,6 @@
#include "hw/pci_internals.h" #include "hw/pci_internals.h"
static const uint32_t bars[] = {
PCI_BASE_ADDRESS_0, PCI_BASE_ADDRESS_1,
PCI_BASE_ADDRESS_2, PCI_BASE_ADDRESS_3,
PCI_BASE_ADDRESS_4, PCI_BASE_ADDRESS_5
/*, PCI_ROM_ADDRESS*/
};
static PCIDevice *find_dev(sPAPREnvironment *spapr, static PCIDevice *find_dev(sPAPREnvironment *spapr,
uint64_t buid, uint32_t config_addr) uint64_t buid, uint32_t config_addr)
{ {
@ -187,69 +180,6 @@ static void pci_spapr_set_irq(void *opaque, int irq_num, int level)
qemu_set_irq(phb->lsi_table[irq_num].qirq, level); qemu_set_irq(phb->lsi_table[irq_num].qirq, level);
} }
static int spapr_phb_init(SysBusDevice *s)
{
sPAPRPHBState *phb = FROM_SYSBUS(sPAPRPHBState, s);
int i;
/* Initialize the LSI table */
for (i = 0; i < SPAPR_PCI_NUM_LSI; i++) {
qemu_irq qirq;
uint32_t num;
qirq = spapr_allocate_irq(0, &num);
if (!qirq) {
return -1;
}
phb->lsi_table[i].dt_irq = num;
phb->lsi_table[i].qirq = qirq;
}
return 0;
}
static int spapr_main_pci_host_init(PCIDevice *d)
{
return 0;
}
static void spapr_main_pci_host_class_init(ObjectClass *klass, void *data)
{
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->init = spapr_main_pci_host_init;
}
static TypeInfo spapr_main_pci_host_info = {
.name = "spapr-pci-host-bridge-pci",
.parent = TYPE_PCI_DEVICE,
.instance_size = sizeof(PCIDevice),
.class_init = spapr_main_pci_host_class_init,
};
static void spapr_phb_class_init(ObjectClass *klass, void *data)
{
SysBusDeviceClass *sdc = SYS_BUS_DEVICE_CLASS(klass);
sdc->init = spapr_phb_init;
}
static TypeInfo spapr_phb_info = {
.name = "spapr-pci-host-bridge",
.parent = TYPE_SYS_BUS_DEVICE,
.instance_size = sizeof(sPAPRPHBState),
.class_init = spapr_phb_class_init,
};
static void spapr_register_types(void)
{
type_register_static(&spapr_phb_info);
type_register_static(&spapr_main_pci_host_info);
}
type_init(spapr_register_types)
static uint64_t spapr_io_read(void *opaque, target_phys_addr_t addr, static uint64_t spapr_io_read(void *opaque, target_phys_addr_t addr,
unsigned size) unsigned size)
{ {
@ -287,35 +217,29 @@ static const MemoryRegionOps spapr_io_ops = {
.write = spapr_io_write .write = spapr_io_write
}; };
void spapr_create_phb(sPAPREnvironment *spapr, /*
const char *busname, uint64_t buid, * PHB PCI device
uint64_t mem_win_addr, uint64_t mem_win_size, */
uint64_t io_win_addr) static int spapr_phb_init(SysBusDevice *s)
{ {
DeviceState *dev; sPAPRPHBState *phb = FROM_SYSBUS(sPAPRPHBState, s);
SysBusDevice *s; char *namebuf;
sPAPRPHBState *phb; int i;
PCIBus *bus; PCIBus *bus;
char namebuf[strlen(busname)+11];
dev = qdev_create(NULL, "spapr-pci-host-bridge"); phb->dtbusname = g_strdup_printf("pci@%" PRIx64, phb->buid);
qdev_init_nofail(dev); namebuf = alloca(strlen(phb->dtbusname) + 32);
s = sysbus_from_qdev(dev);
phb = FROM_SYSBUS(sPAPRPHBState, s);
phb->mem_win_addr = mem_win_addr; /* Initialize memory regions */
sprintf(namebuf, "%s.mmio", phb->dtbusname);
sprintf(namebuf, "%s-mem", busname);
memory_region_init(&phb->memspace, namebuf, INT64_MAX); memory_region_init(&phb->memspace, namebuf, INT64_MAX);
sprintf(namebuf, "%s-memwindow", busname); sprintf(namebuf, "%s.mmio-alias", phb->dtbusname);
memory_region_init_alias(&phb->memwindow, namebuf, &phb->memspace, memory_region_init_alias(&phb->memwindow, namebuf, &phb->memspace,
SPAPR_PCI_MEM_WIN_BUS_OFFSET, mem_win_size); SPAPR_PCI_MEM_WIN_BUS_OFFSET, phb->mem_win_size);
memory_region_add_subregion(get_system_memory(), mem_win_addr, memory_region_add_subregion(get_system_memory(), phb->mem_win_addr,
&phb->memwindow); &phb->memwindow);
phb->io_win_addr = io_win_addr;
/* On ppc, we only have MMIO no specific IO space from the CPU /* On ppc, we only have MMIO no specific IO space from the CPU
* perspective. In theory we ought to be able to embed the PCI IO * perspective. In theory we ought to be able to embed the PCI IO
* memory region direction in the system memory space. However, * memory region direction in the system memory space. However,
@ -324,33 +248,92 @@ void spapr_create_phb(sPAPREnvironment *spapr,
* system io address space. This hack to bounce things via * system io address space. This hack to bounce things via
* system_io works around the problem until all the users of * system_io works around the problem until all the users of
* old_portion are updated */ * old_portion are updated */
sprintf(namebuf, "%s-io", busname); sprintf(namebuf, "%s.io", phb->dtbusname);
memory_region_init(&phb->iospace, namebuf, SPAPR_PCI_IO_WIN_SIZE); memory_region_init(&phb->iospace, namebuf, SPAPR_PCI_IO_WIN_SIZE);
/* FIXME: fix to support multiple PHBs */ /* FIXME: fix to support multiple PHBs */
memory_region_add_subregion(get_system_io(), 0, &phb->iospace); memory_region_add_subregion(get_system_io(), 0, &phb->iospace);
sprintf(namebuf, "%s-iowindow", busname); sprintf(namebuf, "%s.io-alias", phb->dtbusname);
memory_region_init_io(&phb->iowindow, &spapr_io_ops, phb, memory_region_init_io(&phb->iowindow, &spapr_io_ops, phb,
namebuf, SPAPR_PCI_IO_WIN_SIZE); namebuf, SPAPR_PCI_IO_WIN_SIZE);
memory_region_add_subregion(get_system_memory(), io_win_addr, memory_region_add_subregion(get_system_memory(), phb->io_win_addr,
&phb->iowindow); &phb->iowindow);
phb->host_state.bus = bus = pci_register_bus(&phb->busdev.qdev, busname, bus = pci_register_bus(&phb->busdev.qdev,
pci_spapr_set_irq, phb->busname ? phb->busname : phb->dtbusname,
pci_spapr_map_irq, pci_spapr_set_irq, pci_spapr_map_irq, phb,
phb, &phb->memspace, &phb->iospace,
&phb->memspace, &phb->iospace, PCI_DEVFN(0, 0), SPAPR_PCI_NUM_LSI);
PCI_DEVFN(0, 0), phb->host_state.bus = bus;
SPAPR_PCI_NUM_LSI);
QLIST_INSERT_HEAD(&spapr->phbs, phb, list);
/* Initialize the LSI table */
for (i = 0; i < SPAPR_PCI_NUM_LSI; i++) {
qemu_irq qirq;
uint32_t num;
qirq = spapr_allocate_lsi(0, &num);
if (!qirq) {
return -1;
}
phb->lsi_table[i].dt_irq = num;
phb->lsi_table[i].qirq = qirq;
}
return 0;
}
static Property spapr_phb_properties[] = {
DEFINE_PROP_HEX64("buid", sPAPRPHBState, buid, 0),
DEFINE_PROP_STRING("busname", sPAPRPHBState, busname),
DEFINE_PROP_HEX64("mem_win_addr", sPAPRPHBState, mem_win_addr, 0),
DEFINE_PROP_HEX64("mem_win_size", sPAPRPHBState, mem_win_size, 0x20000000),
DEFINE_PROP_HEX64("io_win_addr", sPAPRPHBState, io_win_addr, 0),
DEFINE_PROP_HEX64("io_win_size", sPAPRPHBState, io_win_size, 0x10000),
DEFINE_PROP_END_OF_LIST(),
};
static void spapr_phb_class_init(ObjectClass *klass, void *data)
{
SysBusDeviceClass *sdc = SYS_BUS_DEVICE_CLASS(klass);
DeviceClass *dc = DEVICE_CLASS(klass);
sdc->init = spapr_phb_init;
dc->props = spapr_phb_properties;
spapr_rtas_register("read-pci-config", rtas_read_pci_config); spapr_rtas_register("read-pci-config", rtas_read_pci_config);
spapr_rtas_register("write-pci-config", rtas_write_pci_config); spapr_rtas_register("write-pci-config", rtas_write_pci_config);
spapr_rtas_register("ibm,read-pci-config", rtas_ibm_read_pci_config); spapr_rtas_register("ibm,read-pci-config", rtas_ibm_read_pci_config);
spapr_rtas_register("ibm,write-pci-config", rtas_ibm_write_pci_config); spapr_rtas_register("ibm,write-pci-config", rtas_ibm_write_pci_config);
}
QLIST_INSERT_HEAD(&spapr->phbs, phb, list); static TypeInfo spapr_phb_info = {
.name = "spapr-pci-host-bridge",
.parent = TYPE_SYS_BUS_DEVICE,
.instance_size = sizeof(sPAPRPHBState),
.class_init = spapr_phb_class_init,
};
/* pci_bus_set_mem_base(bus, mem_va_start - SPAPR_PCI_MEM_BAR_START); */ void spapr_create_phb(sPAPREnvironment *spapr,
const char *busname, uint64_t buid,
uint64_t mem_win_addr, uint64_t mem_win_size,
uint64_t io_win_addr)
{
DeviceState *dev;
dev = qdev_create(NULL, spapr_phb_info.name);
if (busname) {
qdev_prop_set_string(dev, "busname", g_strdup(busname));
}
qdev_prop_set_uint64(dev, "buid", buid);
qdev_prop_set_uint64(dev, "mem_win_addr", mem_win_addr);
qdev_prop_set_uint64(dev, "mem_win_size", mem_win_size);
qdev_prop_set_uint64(dev, "io_win_addr", io_win_addr);
qdev_init_nofail(dev);
} }
/* Macros to operate with address in OF binding to PCI */ /* Macros to operate with address in OF binding to PCI */
@ -442,3 +425,9 @@ int spapr_populate_pci_devices(sPAPRPHBState *phb,
return 0; return 0;
} }
static void register_types(void)
{
type_register_static(&spapr_phb_info);
}
type_init(register_types)

4
hw/spapr_pci.h
View File

@ -33,9 +33,11 @@ typedef struct sPAPRPHBState {
PCIHostState host_state; PCIHostState host_state;
uint64_t buid; uint64_t buid;
char *busname;
char *dtbusname;
MemoryRegion memspace, iospace; MemoryRegion memspace, iospace;
target_phys_addr_t mem_win_addr, io_win_addr; target_phys_addr_t mem_win_addr, mem_win_size, io_win_addr, io_win_size;
MemoryRegion memwindow, iowindow; MemoryRegion memwindow, iowindow;
struct { struct {

2
hw/spapr_vio.c
View File

@ -670,7 +670,7 @@ static int spapr_vio_busdev_init(DeviceState *qdev)
dev->qdev.id = id; dev->qdev.id = id;
} }
dev->qirq = spapr_allocate_irq(dev->vio_irq_num, &dev->vio_irq_num); dev->qirq = spapr_allocate_msi(dev->vio_irq_num, &dev->vio_irq_num);
if (!dev->qirq) { if (!dev->qirq) {
return -1; return -1;
} }

145
hw/xics.c
View File

@ -132,9 +132,9 @@ static void icp_eoi(struct icp_state *icp, int server, uint32_t xirr)
{ {
struct icp_server_state *ss = icp->ss + server; struct icp_server_state *ss = icp->ss + server;
ics_eoi(icp->ics, xirr & XISR_MASK);
/* Send EOI -> ICS */ /* Send EOI -> ICS */
ss->xirr = (ss->xirr & ~CPPR_MASK) | (xirr & CPPR_MASK); ss->xirr = (ss->xirr & ~CPPR_MASK) | (xirr & CPPR_MASK);
ics_eoi(icp->ics, xirr & XISR_MASK);
if (!XISR(ss)) { if (!XISR(ss)) {
icp_resend(icp, server); icp_resend(icp, server);
} }
@ -165,8 +165,9 @@ struct ics_irq_state {
int server; int server;
uint8_t priority; uint8_t priority;
uint8_t saved_priority; uint8_t saved_priority;
/* int pending:1; */ enum xics_irq_type type;
/* int presented:1; */ int asserted:1;
int sent:1;
int rejected:1; int rejected:1;
int masked_pending:1; int masked_pending:1;
}; };
@ -185,9 +186,32 @@ static int ics_valid_irq(struct ics_state *ics, uint32_t nr)
&& (nr < (ics->offset + ics->nr_irqs)); && (nr < (ics->offset + ics->nr_irqs));
} }
static void ics_set_irq_msi(void *opaque, int srcno, int val) static void resend_msi(struct ics_state *ics, int srcno)
{
struct ics_irq_state *irq = ics->irqs + srcno;
/* FIXME: filter by server#? */
if (irq->rejected) {
irq->rejected = 0;
if (irq->priority != 0xff) {
icp_irq(ics->icp, irq->server, srcno + ics->offset,
irq->priority);
}
}
}
static void resend_lsi(struct ics_state *ics, int srcno)
{
struct ics_irq_state *irq = ics->irqs + srcno;
if ((irq->priority != 0xff) && irq->asserted && !irq->sent) {
irq->sent = 1;
icp_irq(ics->icp, irq->server, srcno + ics->offset, irq->priority);
}
}
static void set_irq_msi(struct ics_state *ics, int srcno, int val)
{ {
struct ics_state *ics = (struct ics_state *)opaque;
struct ics_irq_state *irq = ics->irqs + srcno; struct ics_irq_state *irq = ics->irqs + srcno;
if (val) { if (val) {
@ -200,14 +224,68 @@ static void ics_set_irq_msi(void *opaque, int srcno, int val)
} }
} }
static void ics_reject_msi(struct ics_state *ics, int nr) static void set_irq_lsi(struct ics_state *ics, int srcno, int val)
{
struct ics_irq_state *irq = ics->irqs + srcno;
irq->asserted = val;
resend_lsi(ics, srcno);
}
static void ics_set_irq(void *opaque, int srcno, int val)
{
struct ics_state *ics = (struct ics_state *)opaque;
struct ics_irq_state *irq = ics->irqs + srcno;
if (irq->type == XICS_LSI) {
set_irq_lsi(ics, srcno, val);
} else {
set_irq_msi(ics, srcno, val);
}
}
static void write_xive_msi(struct ics_state *ics, int srcno)
{
struct ics_irq_state *irq = ics->irqs + srcno;
if (!irq->masked_pending || (irq->priority == 0xff)) {
return;
}
irq->masked_pending = 0;
icp_irq(ics->icp, irq->server, srcno + ics->offset, irq->priority);
}
static void write_xive_lsi(struct ics_state *ics, int srcno)
{
resend_lsi(ics, srcno);
}
static void ics_write_xive(struct ics_state *ics, int nr, int server,
uint8_t priority)
{
int srcno = nr - ics->offset;
struct ics_irq_state *irq = ics->irqs + srcno;
irq->server = server;
irq->priority = priority;
if (irq->type == XICS_LSI) {
write_xive_lsi(ics, srcno);
} else {
write_xive_msi(ics, srcno);
}
}
static void ics_reject(struct ics_state *ics, int nr)
{ {
struct ics_irq_state *irq = ics->irqs + nr - ics->offset; struct ics_irq_state *irq = ics->irqs + nr - ics->offset;
irq->rejected = 1; irq->rejected = 1; /* Irrelevant but harmless for LSI */
irq->sent = 0; /* Irrelevant but harmless for MSI */
} }
static void ics_resend_msi(struct ics_state *ics) static void ics_resend(struct ics_state *ics)
{ {
int i; int i;
@ -215,56 +293,39 @@ static void ics_resend_msi(struct ics_state *ics)
struct ics_irq_state *irq = ics->irqs + i; struct ics_irq_state *irq = ics->irqs + i;
/* FIXME: filter by server#? */ /* FIXME: filter by server#? */
if (irq->rejected) { if (irq->type == XICS_LSI) {
irq->rejected = 0; resend_lsi(ics, i);
if (irq->priority != 0xff) { } else {
icp_irq(ics->icp, irq->server, i + ics->offset, irq->priority); resend_msi(ics, i);
}
} }
} }
} }
static void ics_write_xive_msi(struct ics_state *ics, int nr, int server,
uint8_t priority)
{
struct ics_irq_state *irq = ics->irqs + nr - ics->offset;
irq->server = server;
irq->priority = priority;
if (!irq->masked_pending || (priority == 0xff)) {
return;
}
irq->masked_pending = 0;
icp_irq(ics->icp, server, nr, priority);
}
static void ics_reject(struct ics_state *ics, int nr)
{
ics_reject_msi(ics, nr);
}
static void ics_resend(struct ics_state *ics)
{
ics_resend_msi(ics);
}
static void ics_eoi(struct ics_state *ics, int nr) static void ics_eoi(struct ics_state *ics, int nr)
{ {
int srcno = nr - ics->offset;
struct ics_irq_state *irq = ics->irqs + srcno;
if (irq->type == XICS_LSI) {
irq->sent = 0;
}
} }
/* /*
* Exported functions * Exported functions
*/ */
qemu_irq xics_find_qirq(struct icp_state *icp, int irq) qemu_irq xics_assign_irq(struct icp_state *icp, int irq,
enum xics_irq_type type)
{ {
if ((irq < icp->ics->offset) if ((irq < icp->ics->offset)
|| (irq >= (icp->ics->offset + icp->ics->nr_irqs))) { || (irq >= (icp->ics->offset + icp->ics->nr_irqs))) {
return NULL; return NULL;
} }
assert((type == XICS_MSI) || (type == XICS_LSI));
icp->ics->irqs[irq - icp->ics->offset].type = type;
return icp->ics->qirqs[irq - icp->ics->offset]; return icp->ics->qirqs[irq - icp->ics->offset];
} }
@ -332,7 +393,7 @@ static void rtas_set_xive(sPAPREnvironment *spapr, uint32_t token,
return; return;
} }
ics_write_xive_msi(ics, nr, server, priority); ics_write_xive(ics, nr, server, priority);
rtas_st(rets, 0, 0); /* Success */ rtas_st(rets, 0, 0); /* Success */
} }
@ -477,7 +538,7 @@ struct icp_state *xics_system_init(int nr_irqs)
ics->irqs[i].saved_priority = 0xff; ics->irqs[i].saved_priority = 0xff;
} }
ics->qirqs = qemu_allocate_irqs(ics_set_irq_msi, ics, nr_irqs); ics->qirqs = qemu_allocate_irqs(ics_set_irq, ics, nr_irqs);
spapr_register_hypercall(H_CPPR, h_cppr); spapr_register_hypercall(H_CPPR, h_cppr);
spapr_register_hypercall(H_IPI, h_ipi); spapr_register_hypercall(H_IPI, h_ipi);

8
hw/xics.h
View File

@ -31,7 +31,13 @@
struct icp_state; struct icp_state;
qemu_irq xics_find_qirq(struct icp_state *icp, int irq); enum xics_irq_type {
XICS_MSI, /* Message-signalled (edge) interrupt */
XICS_LSI, /* Level-signalled interrupt */
};
qemu_irq xics_assign_irq(struct icp_state *icp, int irq,
enum xics_irq_type type);
struct icp_state *xics_system_init(int nr_irqs); struct icp_state *xics_system_init(int nr_irqs);

5
kvm-all.c
View File

@ -79,7 +79,10 @@ struct KVMState
int pit_state2; int pit_state2;
int xsave, xcrs; int xsave, xcrs;
int many_ioeventfds; int many_ioeventfds;
int irqchip_inject_ioctl; /* The man page (and posix) say ioctl numbers are signed int, but
* they're not. Linux, glibc and *BSD all treat ioctl numbers as
* unsigned, and treating them as signed here can break things */
unsigned irqchip_inject_ioctl;
#ifdef KVM_CAP_IRQ_ROUTING #ifdef KVM_CAP_IRQ_ROUTING
struct kvm_irq_routing *irq_routes; struct kvm_irq_routing *irq_routes;
int nr_allocated_irq_routes; int nr_allocated_irq_routes;

2
linux-user/signal.c
View File

@ -4118,7 +4118,7 @@ static target_ulong get_sigframe(struct target_sigaction *ka,
oldsp = env->gpr[1]; oldsp = env->gpr[1];
if ((ka->sa_flags & TARGET_SA_ONSTACK) && if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
(sas_ss_flags(oldsp))) { (sas_ss_flags(oldsp) == 0)) {
oldsp = (target_sigaltstack_used.ss_sp oldsp = (target_sigaltstack_used.ss_sp
+ target_sigaltstack_used.ss_size); + target_sigaltstack_used.ss_size);
} }

2
pc-bios/README
View File

@ -17,7 +17,7 @@
- SLOF (Slimline Open Firmware) is a free IEEE 1275 Open Firmware - SLOF (Slimline Open Firmware) is a free IEEE 1275 Open Firmware
implementation for certain IBM POWER hardware. The sources are at implementation for certain IBM POWER hardware. The sources are at
https://github.com/dgibson/SLOF, and the image currently in qemu is https://github.com/dgibson/SLOF, and the image currently in qemu is
built from git tag qemu-slof-20120111.1. built from git tag qemu-slof-20120217.
- sgabios (the Serial Graphics Adapter option ROM) provides a means for - sgabios (the Serial Graphics Adapter option ROM) provides a means for
legacy x86 software to communicate with an attached serial console as legacy x86 software to communicate with an attached serial console as

BIN
pc-bios/slof.bin
View File

Binary file not shown.

2
roms/SLOF

@ -1 +1 @@
Subproject commit ab062ff3b37c39649f2b0d94ed607adc6f6b3c7d Subproject commit d153364253548d6cd91403711f84996e6a7dab31

4
target-ppc/cpu.h
View File

@ -1918,8 +1918,10 @@ enum {
PPC2_DFP = 0x0000000000000004ULL, PPC2_DFP = 0x0000000000000004ULL,
/* Embedded.Processor Control */ /* Embedded.Processor Control */
PPC2_PRCNTL = 0x0000000000000008ULL, PPC2_PRCNTL = 0x0000000000000008ULL,
/* Byte-reversed, indexed, double-word load and store */
PPC2_DBRX = 0x0000000000000010ULL,
#define PPC_TCG_INSNS2 (PPC2_BOOKE206 | PPC2_PRCNTL) #define PPC_TCG_INSNS2 (PPC2_BOOKE206 | PPC2_PRCNTL | PPC2_DBRX)
}; };
/*****************************************************************************/ /*****************************************************************************/

12
target-ppc/helper.c
View File

@ -591,12 +591,6 @@ static inline int _find_pte(CPUPPCState *env, mmu_ctx_t *ctx, int is_64b, int h,
pte1 = ldq_phys(env->htab_base + pteg_off + (i * 16) + 8); pte1 = ldq_phys(env->htab_base + pteg_off + (i * 16) + 8);
} }
/* We have a TLB that saves 4K pages, so let's
* split a huge page to 4k chunks */
if (target_page_bits != TARGET_PAGE_BITS)
pte1 |= (ctx->eaddr & (( 1 << target_page_bits ) - 1))
& TARGET_PAGE_MASK;
r = pte64_check(ctx, pte0, pte1, h, rw, type); r = pte64_check(ctx, pte0, pte1, h, rw, type);
LOG_MMU("Load pte from " TARGET_FMT_lx " => " TARGET_FMT_lx " " LOG_MMU("Load pte from " TARGET_FMT_lx " => " TARGET_FMT_lx " "
TARGET_FMT_lx " %d %d %d " TARGET_FMT_lx "\n", TARGET_FMT_lx " %d %d %d " TARGET_FMT_lx "\n",
@ -672,6 +666,12 @@ static inline int _find_pte(CPUPPCState *env, mmu_ctx_t *ctx, int is_64b, int h,
} }
} }
/* We have a TLB that saves 4K pages, so let's
* split a huge page to 4k chunks */
if (target_page_bits != TARGET_PAGE_BITS) {
ctx->raddr |= (ctx->eaddr & ((1 << target_page_bits) - 1))
& TARGET_PAGE_MASK;
}
return ret; return ret;
} }

12
target-ppc/kvm.c
View File

@ -843,12 +843,18 @@ void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t window_size, int *pfd)
int fd; int fd;
void *table; void *table;
/* Must set fd to -1 so we don't try to munmap when called for
* destroying the table, which the upper layers -will- do
*/
*pfd = -1;
if (!cap_spapr_tce) { if (!cap_spapr_tce) {
return NULL; return NULL;
} }
fd = kvm_vm_ioctl(kvm_state, KVM_CREATE_SPAPR_TCE, &args); fd = kvm_vm_ioctl(kvm_state, KVM_CREATE_SPAPR_TCE, &args);
if (fd < 0) { if (fd < 0) {
fprintf(stderr, "KVM: Failed to create TCE table for liobn 0x%x\n",
liobn);
return NULL; return NULL;
} }
@ -857,6 +863,8 @@ void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t window_size, int *pfd)
table = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); table = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (table == MAP_FAILED) { if (table == MAP_FAILED) {
fprintf(stderr, "KVM: Failed to map TCE table for liobn 0x%x\n",
liobn);
close(fd); close(fd);
return NULL; return NULL;
} }
@ -876,8 +884,8 @@ int kvmppc_remove_spapr_tce(void *table, int fd, uint32_t window_size)
len = (window_size / SPAPR_VIO_TCE_PAGE_SIZE)*sizeof(VIOsPAPR_RTCE); len = (window_size / SPAPR_VIO_TCE_PAGE_SIZE)*sizeof(VIOsPAPR_RTCE);
if ((munmap(table, len) < 0) || if ((munmap(table, len) < 0) ||
(close(fd) < 0)) { (close(fd) < 0)) {
fprintf(stderr, "KVM: Unexpected error removing KVM SPAPR TCE " fprintf(stderr, "KVM: Unexpected error removing TCE table: %s",
"table: %s", strerror(errno)); strerror(errno));
/* Leak the table */ /* Leak the table */
} }

54
target-ppc/translate.c
View File

@ -2650,7 +2650,7 @@ static void glue(gen_, name##ux)(DisasContext *ctx)
tcg_temp_free(EA); \ tcg_temp_free(EA); \
} }
#define GEN_LDX(name, ldop, opc2, opc3, type) \ #define GEN_LDX_E(name, ldop, opc2, opc3, type, type2) \
static void glue(gen_, name##x)(DisasContext *ctx) \ static void glue(gen_, name##x)(DisasContext *ctx) \
{ \ { \
TCGv EA; \ TCGv EA; \
@ -2660,6 +2660,8 @@ static void glue(gen_, name##x)(DisasContext *ctx) \
gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA); \ gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA); \
tcg_temp_free(EA); \ tcg_temp_free(EA); \
} }
#define GEN_LDX(name, ldop, opc2, opc3, type) \
GEN_LDX_E(name, ldop, opc2, opc3, type, PPC_NONE)
#define GEN_LDS(name, ldop, op, type) \ #define GEN_LDS(name, ldop, op, type) \
GEN_LD(name, ldop, op | 0x20, type); \ GEN_LD(name, ldop, op | 0x20, type); \
@ -2793,8 +2795,8 @@ static void glue(gen_, name##ux)(DisasContext *ctx)
tcg_temp_free(EA); \ tcg_temp_free(EA); \
} }
#define GEN_STX(name, stop, opc2, opc3, type) \ #define GEN_STX_E(name, stop, opc2, opc3, type, type2) \
static void glue(gen_, name##x)(DisasContext *ctx) \ static void glue(gen_, name##x)(DisasContext *ctx) \
{ \ { \
TCGv EA; \ TCGv EA; \
gen_set_access_type(ctx, ACCESS_INT); \ gen_set_access_type(ctx, ACCESS_INT); \
@ -2803,6 +2805,8 @@ static void glue(gen_, name##x)(DisasContext *ctx)
gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA); \ gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA); \
tcg_temp_free(EA); \ tcg_temp_free(EA); \
} }
#define GEN_STX(name, stop, opc2, opc3, type) \
GEN_STX_E(name, stop, opc2, opc3, type, PPC_NONE)
#define GEN_STS(name, stop, op, type) \ #define GEN_STS(name, stop, op, type) \
GEN_ST(name, stop, op | 0x20, type); \ GEN_ST(name, stop, op | 0x20, type); \
@ -2891,6 +2895,18 @@ static inline void gen_qemu_ld32ur(DisasContext *ctx, TCGv arg1, TCGv arg2)
} }
GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER); GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER);
#if defined(TARGET_PPC64)
/* ldbrx */
static inline void gen_qemu_ld64ur(DisasContext *ctx, TCGv arg1, TCGv arg2)
{
tcg_gen_qemu_ld64(arg1, arg2, ctx->mem_idx);
if (likely(!ctx->le_mode)) {
tcg_gen_bswap64_tl(arg1, arg1);
}
}
GEN_LDX_E(ldbr, ld64ur, 0x14, 0x10, PPC_NONE, PPC2_DBRX);
#endif /* TARGET_PPC64 */
/* sthbrx */ /* sthbrx */
static inline void gen_qemu_st16r(DisasContext *ctx, TCGv arg1, TCGv arg2) static inline void gen_qemu_st16r(DisasContext *ctx, TCGv arg1, TCGv arg2)
{ {
@ -2921,6 +2937,22 @@ static inline void gen_qemu_st32r(DisasContext *ctx, TCGv arg1, TCGv arg2)
} }
GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER); GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER);
#if defined(TARGET_PPC64)
/* stdbrx */
static inline void gen_qemu_st64r(DisasContext *ctx, TCGv arg1, TCGv arg2)
{
if (likely(!ctx->le_mode)) {
TCGv t0 = tcg_temp_new();
tcg_gen_bswap64_tl(t0, arg1);
tcg_gen_qemu_st64(t0, arg2, ctx->mem_idx);
tcg_temp_free(t0);
} else {
tcg_gen_qemu_st64(arg1, arg2, ctx->mem_idx);
}
}
GEN_STX_E(stdbr, st64r, 0x14, 0x14, PPC_NONE, PPC2_DBRX);
#endif /* TARGET_PPC64 */
/*** Integer load and store multiple ***/ /*** Integer load and store multiple ***/
/* lmw */ /* lmw */
@ -8818,7 +8850,7 @@ GEN_FLOAT_B(neg, 0x08, 0x01, 0, PPC_FLOAT),
#undef GEN_LD #undef GEN_LD
#undef GEN_LDU #undef GEN_LDU
#undef GEN_LDUX #undef GEN_LDUX
#undef GEN_LDX #undef GEN_LDX_E
#undef GEN_LDS #undef GEN_LDS
#define GEN_LD(name, ldop, opc, type) \ #define GEN_LD(name, ldop, opc, type) \
GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type), GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
@ -8826,8 +8858,8 @@ GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type), GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type),
#define GEN_LDUX(name, ldop, opc2, opc3, type) \ #define GEN_LDUX(name, ldop, opc2, opc3, type) \
GEN_HANDLER(name##ux, 0x1F, opc2, opc3, 0x00000001, type), GEN_HANDLER(name##ux, 0x1F, opc2, opc3, 0x00000001, type),
#define GEN_LDX(name, ldop, opc2, opc3, type) \ #define GEN_LDX_E(name, ldop, opc2, opc3, type, type2) \
GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type), GEN_HANDLER_E(name##x, 0x1F, opc2, opc3, 0x00000001, type, type2),
#define GEN_LDS(name, ldop, op, type) \ #define GEN_LDS(name, ldop, op, type) \
GEN_LD(name, ldop, op | 0x20, type) \ GEN_LD(name, ldop, op | 0x20, type) \
GEN_LDU(name, ldop, op | 0x21, type) \ GEN_LDU(name, ldop, op | 0x21, type) \
@ -8843,6 +8875,7 @@ GEN_LDUX(lwa, ld32s, 0x15, 0x0B, PPC_64B)
GEN_LDX(lwa, ld32s, 0x15, 0x0A, PPC_64B) GEN_LDX(lwa, ld32s, 0x15, 0x0A, PPC_64B)
GEN_LDUX(ld, ld64, 0x15, 0x01, PPC_64B) GEN_LDUX(ld, ld64, 0x15, 0x01, PPC_64B)
GEN_LDX(ld, ld64, 0x15, 0x00, PPC_64B) GEN_LDX(ld, ld64, 0x15, 0x00, PPC_64B)
GEN_LDX_E(ldbr, ld64ur, 0x14, 0x10, PPC_NONE, PPC2_DBRX)
#endif #endif
GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER) GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER)
GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER) GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER)
@ -8850,7 +8883,7 @@ GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER)
#undef GEN_ST #undef GEN_ST
#undef GEN_STU #undef GEN_STU
#undef GEN_STUX #undef GEN_STUX
#undef GEN_STX #undef GEN_STX_E
#undef GEN_STS #undef GEN_STS
#define GEN_ST(name, stop, opc, type) \ #define GEN_ST(name, stop, opc, type) \
GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type), GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
@ -8858,8 +8891,8 @@ GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
GEN_HANDLER(stop##u, opc, 0xFF, 0xFF, 0x00000000, type), GEN_HANDLER(stop##u, opc, 0xFF, 0xFF, 0x00000000, type),
#define GEN_STUX(name, stop, opc2, opc3, type) \ #define GEN_STUX(name, stop, opc2, opc3, type) \
GEN_HANDLER(name##ux, 0x1F, opc2, opc3, 0x00000001, type), GEN_HANDLER(name##ux, 0x1F, opc2, opc3, 0x00000001, type),
#define GEN_STX(name, stop, opc2, opc3, type) \ #define GEN_STX_E(name, stop, opc2, opc3, type, type2) \
GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type), GEN_HANDLER_E(name##x, 0x1F, opc2, opc3, 0x00000001, type, type2),
#define GEN_STS(name, stop, op, type) \ #define GEN_STS(name, stop, op, type) \
GEN_ST(name, stop, op | 0x20, type) \ GEN_ST(name, stop, op | 0x20, type) \
GEN_STU(name, stop, op | 0x21, type) \ GEN_STU(name, stop, op | 0x21, type) \
@ -8872,6 +8905,7 @@ GEN_STS(stw, st32, 0x04, PPC_INTEGER)
#if defined(TARGET_PPC64) #if defined(TARGET_PPC64)
GEN_STUX(std, st64, 0x15, 0x05, PPC_64B) GEN_STUX(std, st64, 0x15, 0x05, PPC_64B)
GEN_STX(std, st64, 0x15, 0x04, PPC_64B) GEN_STX(std, st64, 0x15, 0x04, PPC_64B)
GEN_STX_E(stdbr, st64r, 0x14, 0x14, PPC_NONE, PPC2_DBRX)
#endif #endif
GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER) GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER)
GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER) GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER)
@ -9285,6 +9319,8 @@ void cpu_dump_state (CPUPPCState *env, FILE *f, fprintf_function cpu_fprintf,
int i; int i;
cpu_synchronize_state(env);
cpu_fprintf(f, "NIP " TARGET_FMT_lx " LR " TARGET_FMT_lx " CTR " cpu_fprintf(f, "NIP " TARGET_FMT_lx " LR " TARGET_FMT_lx " CTR "
TARGET_FMT_lx " XER " TARGET_FMT_lx "\n", TARGET_FMT_lx " XER " TARGET_FMT_lx "\n",
env->nip, env->lr, env->ctr, env->xer); env->nip, env->lr, env->ctr, env->xer);

11
target-ppc/translate_init.c
View File

@ -6571,7 +6571,7 @@ static void init_proc_970MP (CPUPPCState *env)
PPC_64B | PPC_ALTIVEC | \ PPC_64B | PPC_ALTIVEC | \
PPC_SEGMENT_64B | PPC_SLBI | \ PPC_SEGMENT_64B | PPC_SLBI | \
PPC_POPCNTB | PPC_POPCNTWD) PPC_POPCNTB | PPC_POPCNTWD)
#define POWERPC_INSNS2_POWER7 (PPC2_VSX | PPC2_DFP) #define POWERPC_INSNS2_POWER7 (PPC2_VSX | PPC2_DFP | PPC2_DBRX)
#define POWERPC_MSRM_POWER7 (0x800000000204FF36ULL) #define POWERPC_MSRM_POWER7 (0x800000000204FF36ULL)
#define POWERPC_MMU_POWER7 (POWERPC_MMU_2_06) #define POWERPC_MMU_POWER7 (POWERPC_MMU_2_06)
#define POWERPC_EXCP_POWER7 (POWERPC_EXCP_POWER7) #define POWERPC_EXCP_POWER7 (POWERPC_EXCP_POWER7)
@ -6588,6 +6588,11 @@ static void init_proc_POWER7 (CPUPPCState *env)
gen_spr_7xx(env); gen_spr_7xx(env);
/* Time base */ /* Time base */
gen_tbl(env); gen_tbl(env);
/* Processor identification */
spr_register(env, SPR_PIR, "PIR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_pir,
0x00000000);
#if !defined(CONFIG_USER_ONLY) #if !defined(CONFIG_USER_ONLY)
/* PURR & SPURR: Hack - treat these as aliases for the TB for now */ /* PURR & SPURR: Hack - treat these as aliases for the TB for now */
spr_register(env, SPR_PURR, "PURR", spr_register(env, SPR_PURR, "PURR",
@ -6713,7 +6718,7 @@ static void init_proc_620 (CPUPPCState *env)
#if defined (TARGET_PPC64) && 0 // XXX: TODO #if defined (TARGET_PPC64) && 0 // XXX: TODO
#define CPU_POWERPC_DEFAULT CPU_POWERPC_PPC64 #define CPU_POWERPC_DEFAULT CPU_POWERPC_PPC64
#define POWERPC_INSNS_DEFAULT POWERPC_INSNS_PPC64 #define POWERPC_INSNS_DEFAULT POWERPC_INSNS_PPC64
#define POWERPC_INSNS2_DEFAULT POWERPC_INSNS_PPC64 #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS2_PPC64
#define POWERPC_MSRM_DEFAULT POWERPC_MSRM_PPC64 #define POWERPC_MSRM_DEFAULT POWERPC_MSRM_PPC64
#define POWERPC_MMU_DEFAULT POWERPC_MMU_PPC64 #define POWERPC_MMU_DEFAULT POWERPC_MMU_PPC64
#define POWERPC_EXCP_DEFAULT POWERPC_EXCP_PPC64 #define POWERPC_EXCP_DEFAULT POWERPC_EXCP_PPC64
@ -6725,7 +6730,7 @@ static void init_proc_620 (CPUPPCState *env)
#else #else
#define CPU_POWERPC_DEFAULT CPU_POWERPC_PPC32 #define CPU_POWERPC_DEFAULT CPU_POWERPC_PPC32
#define POWERPC_INSNS_DEFAULT POWERPC_INSNS_PPC32 #define POWERPC_INSNS_DEFAULT POWERPC_INSNS_PPC32
#define POWERPC_INSNS2_DEFAULT POWERPC_INSNS_PPC32 #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS2_PPC32
#define POWERPC_MSRM_DEFAULT POWERPC_MSRM_PPC32 #define POWERPC_MSRM_DEFAULT POWERPC_MSRM_PPC32
#define POWERPC_MMU_DEFAULT POWERPC_MMU_PPC32 #define POWERPC_MMU_DEFAULT POWERPC_MMU_PPC32
#define POWERPC_EXCP_DEFAULT POWERPC_EXCP_PPC32 #define POWERPC_EXCP_DEFAULT POWERPC_EXCP_PPC32