hw/lm32/milkymist-hw.h

   1 #ifndef QEMU_HW_MILKYMIST_H
   2 #define QEMU_HW_MILKYMIST_H
   3
   4 #include "hw/qdev.h"
   5 #include "net/net.h"
   6
   7 static inline DeviceState *milkymist_uart_create(hwaddr base,
   8         qemu_irq irq)
   9 {
  10     DeviceState *dev;
  11
  12     dev = qdev_create(NULL, "milkymist-uart");
  13     qdev_init_nofail(dev);
  14     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
  15     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq);
  16
  17     return dev;
  18 }
  19
  20 static inline DeviceState *milkymist_hpdmc_create(hwaddr base)
  21 {
  22     DeviceState *dev;
  23
  24     dev = qdev_create(NULL, "milkymist-hpdmc");
  25     qdev_init_nofail(dev);
  26     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
  27
  28     return dev;
  29 }
  30
  31 static inline DeviceState *milkymist_memcard_create(hwaddr base)
  32 {
  33     DeviceState *dev;
  34
  35     dev = qdev_create(NULL, "milkymist-memcard");
  36     qdev_init_nofail(dev);
  37     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
  38
  39     return dev;
  40 }
  41
  42 static inline DeviceState *milkymist_vgafb_create(hwaddr base,
  43         uint32_t fb_offset, uint32_t fb_mask)
  44 {
  45     DeviceState *dev;
  46
  47     dev = qdev_create(NULL, "milkymist-vgafb");
  48     qdev_prop_set_uint32(dev, "fb_offset", fb_offset);
  49     qdev_prop_set_uint32(dev, "fb_mask", fb_mask);
  50     qdev_init_nofail(dev);
  51     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
  52
  53     return dev;
  54 }
  55
  56 static inline DeviceState *milkymist_sysctl_create(hwaddr base,
  57         qemu_irq gpio_irq, qemu_irq timer0_irq, qemu_irq timer1_irq,
  58         uint32_t freq_hz, uint32_t system_id, uint32_t capabilities,
  59         uint32_t gpio_strappings)
  60 {
  61     DeviceState *dev;
  62
  63     dev = qdev_create(NULL, "milkymist-sysctl");
  64     qdev_prop_set_uint32(dev, "frequency", freq_hz);
  65     qdev_prop_set_uint32(dev, "systemid", system_id);
  66     qdev_prop_set_uint32(dev, "capabilities", capabilities);
  67     qdev_prop_set_uint32(dev, "gpio_strappings", gpio_strappings);
  68     qdev_init_nofail(dev);
  69     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
  70     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, gpio_irq);
  71     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 1, timer0_irq);
  72     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 2, timer1_irq);
  73
  74     return dev;
  75 }
  76
  77 static inline DeviceState *milkymist_pfpu_create(hwaddr base,
  78         qemu_irq irq)
  79 {
  80     DeviceState *dev;
  81
  82     dev = qdev_create(NULL, "milkymist-pfpu");
  83     qdev_init_nofail(dev);
  84     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
  85     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq);
  86     return dev;
  87 }
  88
  89 #ifdef CONFIG_OPENGL
  90 #include <X11/Xlib.h>
  91 #include <GL/glx.h>
  92 static const int glx_fbconfig_attr[] = {
  93     GLX_GREEN_SIZE, 5,
  94     GLX_GREEN_SIZE, 6,
  95     GLX_BLUE_SIZE, 5,
  96     None
  97 };
  98 #endif
  99
 100 static inline DeviceState *milkymist_tmu2_create(hwaddr base,
 101         qemu_irq irq)
 102 {
 103 #ifdef CONFIG_OPENGL
 104     DeviceState *dev;
 105     Display *d;
 106     GLXFBConfig *configs;
 107     int nelements;
 108     int ver_major, ver_minor;
 109
 110     if (display_type == DT_NOGRAPHIC) {
 111         return NULL;
 112     }
 113
 114     /* check that GLX will work */
 115     d = XOpenDisplay(NULL);
 116     if (d == NULL) {
 117         return NULL;
 118     }
 119
 120     if (!glXQueryVersion(d, &ver_major, &ver_minor)) {
 121         /* Yeah, sometimes getting the GLX version can fail.
 122          * Isn't X beautiful? */
 123         XCloseDisplay(d);
 124         return NULL;
 125     }
 126
 127     if ((ver_major < 1) || ((ver_major == 1) && (ver_minor < 3))) {
 128         printf("Your GLX version is %d.%d,"
 129           "but TMU emulation needs at least 1.3. TMU disabled.\n",
 130           ver_major, ver_minor);
 131         XCloseDisplay(d);
 132         return NULL;
 133     }
 134
 135     configs = glXChooseFBConfig(d, 0, glx_fbconfig_attr, &nelements);
 136     if (configs == NULL) {
 137         XCloseDisplay(d);
 138         return NULL;
 139     }
 140
 141     XFree(configs);
 142     XCloseDisplay(d);
 143
 144     dev = qdev_create(NULL, "milkymist-tmu2");
 145     qdev_init_nofail(dev);
 146     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
 147     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq);
 148
 149     return dev;
 150 #else
 151     return NULL;
 152 #endif
 153 }
 154
 155 static inline DeviceState *milkymist_ac97_create(hwaddr base,
 156         qemu_irq crrequest_irq, qemu_irq crreply_irq, qemu_irq dmar_irq,
 157         qemu_irq dmaw_irq)
 158 {
 159     DeviceState *dev;
 160
 161     dev = qdev_create(NULL, "milkymist-ac97");
 162     qdev_init_nofail(dev);
 163     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
 164     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, crrequest_irq);
 165     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 1, crreply_irq);
 166     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 2, dmar_irq);
 167     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 3, dmaw_irq);
 168
 169     return dev;
 170 }
 171
 172 static inline DeviceState *milkymist_minimac2_create(hwaddr base,
 173         hwaddr buffers_base, qemu_irq rx_irq, qemu_irq tx_irq)
 174 {
 175     DeviceState *dev;
 176
 177     qemu_check_nic_model(&nd_table[0], "minimac2");
 178     dev = qdev_create(NULL, "milkymist-minimac2");
 179     qdev_set_nic_properties(dev, &nd_table[0]);
 180     qdev_init_nofail(dev);
 181     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
 182     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 1, buffers_base);
 183     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, rx_irq);
 184     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 1, tx_irq);
 185
 186     return dev;
 187 }
 188
 189 static inline DeviceState *milkymist_softusb_create(hwaddr base,
 190         qemu_irq irq, uint32_t pmem_base, uint32_t pmem_size,
 191         uint32_t dmem_base, uint32_t dmem_size)
 192 {
 193     DeviceState *dev;
 194
 195     dev = qdev_create(NULL, "milkymist-softusb");
 196     qdev_prop_set_uint32(dev, "pmem_size", pmem_size);
 197     qdev_prop_set_uint32(dev, "dmem_size", dmem_size);
 198     qdev_init_nofail(dev);
 199     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
 200     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 1, pmem_base);
 201     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 2, dmem_base);
 202     sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq);
 203
 204     return dev;
 205 }
 206
 207 #endif /* QEMU_HW_MILKYMIST_H */