git.maemo.org Git - qemu/blob - hw/versatile_pci.c

   1 /*
   2  * ARM Versatile/PB PCI host controller
   3  *
   4  * Copyright (c) 2006-2009 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the LGPL.
   8  */
   9
  10 #include "sysbus.h"
  11 #include "pci.h"
  12
  13 typedef struct {
  14     SysBusDevice busdev;
  15     qemu_irq irq[4];
  16     int realview;
  17     int mem_config;
  18 } PCIVPBState;
  19
  20 static inline uint32_t vpb_pci_config_addr(target_phys_addr_t addr)
  21 {
  22     return addr & 0xffffff;
  23 }
  24
  25 static void pci_vpb_config_writeb (void *opaque, target_phys_addr_t addr,
  26                                    uint32_t val)
  27 {
  28     pci_data_write(opaque, vpb_pci_config_addr (addr), val, 1);
  29 }
  30
  31 static void pci_vpb_config_writew (void *opaque, target_phys_addr_t addr,
  32                                    uint32_t val)
  33 {
  34 #ifdef TARGET_WORDS_BIGENDIAN
  35     val = bswap16(val);
  36 #endif
  37     pci_data_write(opaque, vpb_pci_config_addr (addr), val, 2);
  38 }
  39
  40 static void pci_vpb_config_writel (void *opaque, target_phys_addr_t addr,
  41                                    uint32_t val)
  42 {
  43 #ifdef TARGET_WORDS_BIGENDIAN
  44     val = bswap32(val);
  45 #endif
  46     pci_data_write(opaque, vpb_pci_config_addr (addr), val, 4);
  47 }
  48
  49 static uint32_t pci_vpb_config_readb (void *opaque, target_phys_addr_t addr)
  50 {
  51     uint32_t val;
  52     val = pci_data_read(opaque, vpb_pci_config_addr (addr), 1);
  53     return val;
  54 }
  55
  56 static uint32_t pci_vpb_config_readw (void *opaque, target_phys_addr_t addr)
  57 {
  58     uint32_t val;
  59     val = pci_data_read(opaque, vpb_pci_config_addr (addr), 2);
  60 #ifdef TARGET_WORDS_BIGENDIAN
  61     val = bswap16(val);
  62 #endif
  63     return val;
  64 }
  65
  66 static uint32_t pci_vpb_config_readl (void *opaque, target_phys_addr_t addr)
  67 {
  68     uint32_t val;
  69     val = pci_data_read(opaque, vpb_pci_config_addr (addr), 4);
  70 #ifdef TARGET_WORDS_BIGENDIAN
  71     val = bswap32(val);
  72 #endif
  73     return val;
  74 }
  75
  76 static CPUWriteMemoryFunc * const pci_vpb_config_write[] = {
  77     &pci_vpb_config_writeb,
  78     &pci_vpb_config_writew,
  79     &pci_vpb_config_writel,
  80 };
  81
  82 static CPUReadMemoryFunc * const pci_vpb_config_read[] = {
  83     &pci_vpb_config_readb,
  84     &pci_vpb_config_readw,
  85     &pci_vpb_config_readl,
  86 };
  87
  88 static int pci_vpb_map_irq(PCIDevice *d, int irq_num)
  89 {
  90     return irq_num;
  91 }
  92
  93 static void pci_vpb_set_irq(void *opaque, int irq_num, int level)
  94 {
  95     qemu_irq *pic = opaque;
  96
  97     qemu_set_irq(pic[irq_num], level);
  98 }
  99
 100 static void pci_vpb_map(SysBusDevice *dev, target_phys_addr_t base)
 101 {
 102     PCIVPBState *s = (PCIVPBState *)dev;
 103     /* Selfconfig area.  */
 104     cpu_register_physical_memory(base + 0x01000000, 0x1000000, s->mem_config);
 105     /* Normal config area.  */
 106     cpu_register_physical_memory(base + 0x02000000, 0x1000000, s->mem_config);
 107
 108     if (s->realview) {
 109         /* IO memory area.  */
 110         isa_mmio_init(base + 0x03000000, 0x00100000);
 111     }
 112 }
 113
 114 static int pci_vpb_init(SysBusDevice *dev)
 115 {
 116     PCIVPBState *s = FROM_SYSBUS(PCIVPBState, dev);
 117     PCIBus *bus;
 118     int i;
 119
 120     for (i = 0; i < 4; i++) {
 121         sysbus_init_irq(dev, &s->irq[i]);
 122     }
 123     bus = pci_register_bus(&dev->qdev, "pci",
 124                            pci_vpb_set_irq, pci_vpb_map_irq, s->irq,
 125                            11 << 3, 4);
 126
 127     /* ??? Register memory space.  */
 128
 129     s->mem_config = cpu_register_io_memory(pci_vpb_config_read,
 130                                            pci_vpb_config_write, bus);
 131     sysbus_init_mmio_cb(dev, 0x04000000, pci_vpb_map);
 132
 133     pci_create_simple(bus, -1, "versatile_pci_host");
 134     return 0;
 135 }
 136
 137 static int pci_realview_init(SysBusDevice *dev)
 138 {
 139     PCIVPBState *s = FROM_SYSBUS(PCIVPBState, dev);
 140     s->realview = 1;
 141     return pci_vpb_init(dev);
 142 }
 143
 144 static int versatile_pci_host_init(PCIDevice *d)
 145 {
 146     pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_XILINX);
 147     /* Both boards have the same device ID.  Oh well.  */
 148     pci_config_set_device_id(d->config, PCI_DEVICE_ID_XILINX_XC2VP30);
 149     d->config[0x04] = 0x00;
 150     d->config[0x05] = 0x00;
 151     d->config[0x06] = 0x20;
 152     d->config[0x07] = 0x02;
 153     d->config[0x08] = 0x00; // revision
 154     d->config[0x09] = 0x00; // programming i/f
 155     pci_config_set_class(d->config, PCI_CLASS_PROCESSOR_CO);
 156     d->config[0x0D] = 0x10; // latency_timer
 157     return 0;
 158 }
 159
 160 static PCIDeviceInfo versatile_pci_host_info = {
 161     .qdev.name = "versatile_pci_host",
 162     .qdev.size = sizeof(PCIDevice),
 163     .init      = versatile_pci_host_init,
 164 };
 165
 166 static void versatile_pci_register_devices(void)
 167 {
 168     sysbus_register_dev("versatile_pci", sizeof(PCIVPBState), pci_vpb_init);
 169     sysbus_register_dev("realview_pci", sizeof(PCIVPBState),
 170                         pci_realview_init);
 171     pci_qdev_register(&versatile_pci_host_info);
 172 }
 173
 174 device_init(versatile_pci_register_devices)