Archipelago » qemu

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, version 2, as

 * published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, see <http://www.gnu.org/licenses/>.

 *

 * Copyright IBM Corp. 2008

 *

 * Authors: Hollis Blanchard <hollisb@us.ibm.com>

 */

/* This file implements emulation of the 32-bit PCI controller found in some

 * 4xx SoCs, such as the 440EP. */

#include "hw.h"

#include "ppc.h"

#include "ppc4xx.h"

typedef target_phys_addr_t pci_addr_t;

#include "pci.h"

#include "pci_host.h"

#include "bswap.h"

#undef DEBUG

#ifdef DEBUG

#define DPRINTF(fmt, ...) do { printf(fmt, ## __VA_ARGS__); } while (0)

#else

#define DPRINTF(fmt, ...)

#endif /* DEBUG */

struct PCIMasterMap {

    uint32_t la;

    uint32_t ma;

    uint32_t pcila;

    uint32_t pciha;

};

struct PCITargetMap {

    uint32_t ms;

    uint32_t la;

};

#define PPC4xx_PCI_NR_PMMS 3

#define PPC4xx_PCI_NR_PTMS 2

struct PPC4xxPCIState {

    struct PCIMasterMap pmm[PPC4xx_PCI_NR_PMMS];

    struct PCITargetMap ptm[PPC4xx_PCI_NR_PTMS];

    PCIHostState pci_state;

    PCIDevice *pci_dev;

};

typedef struct PPC4xxPCIState PPC4xxPCIState;

#define PCIC0_CFGADDR       0x0

#define PCIC0_CFGDATA       0x4

/* PLB Memory Map (PMM) registers specify which PLB addresses are translated to

 * PCI accesses. */

#define PCIL0_PMM0LA        0x0

#define PCIL0_PMM0MA        0x4

#define PCIL0_PMM0PCILA     0x8

#define PCIL0_PMM0PCIHA     0xc

#define PCIL0_PMM1LA        0x10

#define PCIL0_PMM1MA        0x14

#define PCIL0_PMM1PCILA     0x18

#define PCIL0_PMM1PCIHA     0x1c

#define PCIL0_PMM2LA        0x20

#define PCIL0_PMM2MA        0x24

#define PCIL0_PMM2PCILA     0x28

#define PCIL0_PMM2PCIHA     0x2c

/* PCI Target Map (PTM) registers specify which PCI addresses are translated to

 * PLB accesses. */

#define PCIL0_PTM1MS        0x30

#define PCIL0_PTM1LA        0x34

#define PCIL0_PTM2MS        0x38

#define PCIL0_PTM2LA        0x3c

#define PCI_REG_SIZE        0x40

static uint32_t pci4xx_cfgaddr_readl(void *opaque, target_phys_addr_t addr)

{

    PPC4xxPCIState *ppc4xx_pci = opaque;

    return ppc4xx_pci->pci_state.config_reg;

}

static CPUReadMemoryFunc * const pci4xx_cfgaddr_read[] = {

    &pci4xx_cfgaddr_readl,

    &pci4xx_cfgaddr_readl,

    &pci4xx_cfgaddr_readl,

};

static void pci4xx_cfgaddr_writel(void *opaque, target_phys_addr_t addr,

                                  uint32_t value)

{

    PPC4xxPCIState *ppc4xx_pci = opaque;

#ifdef TARGET_WORDS_BIGENDIAN

    value = bswap32(value);

#endif

    ppc4xx_pci->pci_state.config_reg = value & ~0x3;

}

static CPUWriteMemoryFunc * const pci4xx_cfgaddr_write[] = {

    &pci4xx_cfgaddr_writel,

    &pci4xx_cfgaddr_writel,

    &pci4xx_cfgaddr_writel,

};

static CPUReadMemoryFunc * const pci4xx_cfgdata_read[] = {

    &pci_host_data_readb,

    &pci_host_data_readw,

    &pci_host_data_readl,

};

static CPUWriteMemoryFunc * const pci4xx_cfgdata_write[] = {

    &pci_host_data_writeb,

    &pci_host_data_writew,

    &pci_host_data_writel,

};

static void ppc4xx_pci_reg_write4(void *opaque, target_phys_addr_t offset,

                                  uint32_t value)

{

    struct PPC4xxPCIState *pci = opaque;

#ifdef TARGET_WORDS_BIGENDIAN

    value = bswap32(value);

#endif

    /* We ignore all target attempts at PCI configuration, effectively

     * assuming a bidirectional 1:1 mapping of PLB and PCI space. */

    switch (offset) {

    case PCIL0_PMM0LA:

        pci->pmm[0].la = value;

        break;

    case PCIL0_PMM0MA:

        pci->pmm[0].ma = value;

        break;

    case PCIL0_PMM0PCIHA:

        pci->pmm[0].pciha = value;

        break;

    case PCIL0_PMM0PCILA:

        pci->pmm[0].pcila = value;

        break;

    case PCIL0_PMM1LA:

        pci->pmm[1].la = value;

        break;

    case PCIL0_PMM1MA:

        pci->pmm[1].ma = value;

        break;

    case PCIL0_PMM1PCIHA:

        pci->pmm[1].pciha = value;

        break;

    case PCIL0_PMM1PCILA:

        pci->pmm[1].pcila = value;

        break;

    case PCIL0_PMM2LA:

        pci->pmm[2].la = value;

        break;

    case PCIL0_PMM2MA:

        pci->pmm[2].ma = value;

        break;

    case PCIL0_PMM2PCIHA:

        pci->pmm[2].pciha = value;

        break;

    case PCIL0_PMM2PCILA:

        pci->pmm[2].pcila = value;

        break;

    case PCIL0_PTM1MS:

        pci->ptm[0].ms = value;

        break;

    case PCIL0_PTM1LA:

        pci->ptm[0].la = value;

        break;

    case PCIL0_PTM2MS:

        pci->ptm[1].ms = value;

        break;

    case PCIL0_PTM2LA:

        pci->ptm[1].la = value;

        break;

    default:

        printf("%s: unhandled PCI internal register 0x%lx\n", __func__,

               (unsigned long)offset);

        break;

    }

}

static uint32_t ppc4xx_pci_reg_read4(void *opaque, target_phys_addr_t offset)

{

    struct PPC4xxPCIState *pci = opaque;

    uint32_t value;

    switch (offset) {

    case PCIL0_PMM0LA:

        value = pci->pmm[0].la;

        break;

    case PCIL0_PMM0MA:

        value = pci->pmm[0].ma;

        break;

    case PCIL0_PMM0PCIHA:

        value = pci->pmm[0].pciha;

        break;

    case PCIL0_PMM0PCILA:

        value = pci->pmm[0].pcila;

        break;

    case PCIL0_PMM1LA:

        value = pci->pmm[1].la;

        break;

    case PCIL0_PMM1MA:

        value = pci->pmm[1].ma;

        break;

    case PCIL0_PMM1PCIHA:

        value = pci->pmm[1].pciha;

        break;

    case PCIL0_PMM1PCILA:

        value = pci->pmm[1].pcila;

        break;

    case PCIL0_PMM2LA:

        value = pci->pmm[2].la;

        break;

    case PCIL0_PMM2MA:

        value = pci->pmm[2].ma;

        break;

    case PCIL0_PMM2PCIHA:

        value = pci->pmm[2].pciha;

        break;

    case PCIL0_PMM2PCILA:

        value = pci->pmm[2].pcila;

        break;

    case PCIL0_PTM1MS:

        value = pci->ptm[0].ms;

        break;

    case PCIL0_PTM1LA:

        value = pci->ptm[0].la;

        break;

    case PCIL0_PTM2MS:

        value = pci->ptm[1].ms;

        break;

    case PCIL0_PTM2LA:

        value = pci->ptm[1].la;

        break;

    default:

        printf("%s: invalid PCI internal register 0x%lx\n", __func__,

               (unsigned long)offset);

        value = 0;

    }

#ifdef TARGET_WORDS_BIGENDIAN

    value = bswap32(value);

#endif

    return value;

}

static CPUReadMemoryFunc * const pci_reg_read[] = {

    &ppc4xx_pci_reg_read4,

    &ppc4xx_pci_reg_read4,

    &ppc4xx_pci_reg_read4,

};

static CPUWriteMemoryFunc * const pci_reg_write[] = {

    &ppc4xx_pci_reg_write4,

    &ppc4xx_pci_reg_write4,

    &ppc4xx_pci_reg_write4,

};

static void ppc4xx_pci_reset(void *opaque)

{

    struct PPC4xxPCIState *pci = opaque;

    memset(pci->pmm, 0, sizeof(pci->pmm));

    memset(pci->ptm, 0, sizeof(pci->ptm));

}

/* On Bamboo, all pins from each slot are tied to a single board IRQ. This

 * may need further refactoring for other boards. */

static int ppc4xx_pci_map_irq(PCIDevice *pci_dev, int irq_num)

{

    int slot = pci_dev->devfn >> 3;

    DPRINTF("%s: devfn %x irq %d -> %d\n", __func__,

            pci_dev->devfn, irq_num, slot);

    return slot - 1;

}

static void ppc4xx_pci_set_irq(void *opaque, int irq_num, int level)

{

    qemu_irq *pci_irqs = opaque;

    DPRINTF("%s: PCI irq %d\n", __func__, irq_num);

    qemu_set_irq(pci_irqs[irq_num], level);

}

static void ppc4xx_pci_save(QEMUFile *f, void *opaque)

{

    PPC4xxPCIState *controller = opaque;

    int i;

    pci_device_save(controller->pci_dev, f);

    for (i = 0; i < PPC4xx_PCI_NR_PMMS; i++) {

        qemu_put_be32s(f, &controller->pmm[i].la);

        qemu_put_be32s(f, &controller->pmm[i].ma);

        qemu_put_be32s(f, &controller->pmm[i].pcila);

        qemu_put_be32s(f, &controller->pmm[i].pciha);

    }

    for (i = 0; i < PPC4xx_PCI_NR_PTMS; i++) {

        qemu_put_be32s(f, &controller->ptm[i].ms);

        qemu_put_be32s(f, &controller->ptm[i].la);

    }

}

static int ppc4xx_pci_load(QEMUFile *f, void *opaque, int version_id)

{

    PPC4xxPCIState *controller = opaque;

    int i;

    if (version_id != 1)

        return -EINVAL;

    pci_device_load(controller->pci_dev, f);

    for (i = 0; i < PPC4xx_PCI_NR_PMMS; i++) {

        qemu_get_be32s(f, &controller->pmm[i].la);

        qemu_get_be32s(f, &controller->pmm[i].ma);

        qemu_get_be32s(f, &controller->pmm[i].pcila);

        qemu_get_be32s(f, &controller->pmm[i].pciha);

    }

    for (i = 0; i < PPC4xx_PCI_NR_PTMS; i++) {

        qemu_get_be32s(f, &controller->ptm[i].ms);

        qemu_get_be32s(f, &controller->ptm[i].la);

    }

    return 0;

}

/* XXX Interrupt acknowledge cycles not supported. */

PCIBus *ppc4xx_pci_init(CPUState *env, qemu_irq pci_irqs[4],

                        target_phys_addr_t config_space,

                        target_phys_addr_t int_ack,

                        target_phys_addr_t special_cycle,

                        target_phys_addr_t registers)

{

    PPC4xxPCIState *controller;

    int index;

    static int ppc4xx_pci_id;

    uint8_t *pci_conf;

    controller = qemu_mallocz(sizeof(PPC4xxPCIState));

    controller->pci_state.bus = pci_register_bus(NULL, "pci",

                                                 ppc4xx_pci_set_irq,

                                                 ppc4xx_pci_map_irq,

                                                 pci_irqs, 0, 4);

    controller->pci_dev = pci_register_device(controller->pci_state.bus,

                                              "host bridge", sizeof(PCIDevice),

                                              0, NULL, NULL);

    pci_conf = controller->pci_dev->config;

    pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_IBM);

    pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_IBM_440GX);

    pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_OTHER);

    /* CFGADDR */

    index = cpu_register_io_memory(pci4xx_cfgaddr_read,

                                   pci4xx_cfgaddr_write, controller);

    if (index < 0)

        goto free;

    cpu_register_physical_memory(config_space + PCIC0_CFGADDR, 4, index);

    /* CFGDATA */

    index = cpu_register_io_memory(pci4xx_cfgdata_read,

                                   pci4xx_cfgdata_write,

                                   &controller->pci_state);

    if (index < 0)

        goto free;

    cpu_register_physical_memory(config_space + PCIC0_CFGDATA, 4, index);

    /* Internal registers */

    index = cpu_register_io_memory(pci_reg_read, pci_reg_write, controller);

    if (index < 0)

        goto free;

    cpu_register_physical_memory(registers, PCI_REG_SIZE, index);

    qemu_register_reset(ppc4xx_pci_reset, controller);

    /* XXX load/save code not tested. */

    register_savevm("ppc4xx_pci", ppc4xx_pci_id++, 1,

                    ppc4xx_pci_save, ppc4xx_pci_load, controller);

    return controller->pci_state.bus;

free:

    printf("%s error\n", __func__);

    qemu_free(controller);

    return NULL;

}