hw/display/milkymist-vgafb.c

   1
   2 /*
   3  *  QEMU model of the Milkymist VGA framebuffer.
   4  *
   5  *  Copyright (c) 2010-2012 Michael Walle <michael@walle.cc>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  *
  21  * Specification available at:
  22  *   http://www.milkymist.org/socdoc/vgafb.pdf
  23  */
  24
  25 #include "hw/hw.h"
  26 #include "hw/sysbus.h"
  27 #include "trace.h"
  28 #include "ui/console.h"
  29 #include "framebuffer.h"
  30 #include "ui/pixel_ops.h"
  31 #include "qemu/error-report.h"
  32
  33 #define BITS 8
  34 #include "milkymist-vgafb_template.h"
  35 #define BITS 15
  36 #include "milkymist-vgafb_template.h"
  37 #define BITS 16
  38 #include "milkymist-vgafb_template.h"
  39 #define BITS 24
  40 #include "milkymist-vgafb_template.h"
  41 #define BITS 32
  42 #include "milkymist-vgafb_template.h"
  43
  44 enum {
  45     R_CTRL = 0,
  46     R_HRES,
  47     R_HSYNC_START,
  48     R_HSYNC_END,
  49     R_HSCAN,
  50     R_VRES,
  51     R_VSYNC_START,
  52     R_VSYNC_END,
  53     R_VSCAN,
  54     R_BASEADDRESS,
  55     R_BASEADDRESS_ACT,
  56     R_BURST_COUNT,
  57     R_DDC,
  58     R_SOURCE_CLOCK,
  59     R_MAX
  60 };
  61
  62 enum {
  63     CTRL_RESET = (1<<0),
  64 };
  65
  66 #define TYPE_MILKYMIST_VGAFB "milkymist-vgafb"
  67 #define MILKYMIST_VGAFB(obj) \
  68     OBJECT_CHECK(MilkymistVgafbState, (obj), TYPE_MILKYMIST_VGAFB)
  69
  70 struct MilkymistVgafbState {
  71     SysBusDevice parent_obj;
  72
  73     MemoryRegion regs_region;
  74     QemuConsole *con;
  75
  76     int invalidate;
  77     uint32_t fb_offset;
  78     uint32_t fb_mask;
  79
  80     uint32_t regs[R_MAX];
  81 };
  82 typedef struct MilkymistVgafbState MilkymistVgafbState;
  83
  84 static int vgafb_enabled(MilkymistVgafbState *s)
  85 {
  86     return !(s->regs[R_CTRL] & CTRL_RESET);
  87 }
  88
  89 static void vgafb_update_display(void *opaque)
  90 {
  91     MilkymistVgafbState *s = opaque;
  92     SysBusDevice *sbd;
  93     DisplaySurface *surface = qemu_console_surface(s->con);
  94     int first = 0;
  95     int last = 0;
  96     drawfn fn;
  97
  98     if (!vgafb_enabled(s)) {
  99         return;
 100     }
 101
 102     sbd = SYS_BUS_DEVICE(s);
 103     int dest_width = s->regs[R_HRES];
 104
 105     switch (surface_bits_per_pixel(surface)) {
 106     case 0:
 107         return;
 108     case 8:
 109         fn = draw_line_8;
 110         break;
 111     case 15:
 112         fn = draw_line_15;
 113         dest_width *= 2;
 114         break;
 115     case 16:
 116         fn = draw_line_16;
 117         dest_width *= 2;
 118         break;
 119     case 24:
 120         fn = draw_line_24;
 121         dest_width *= 3;
 122         break;
 123     case 32:
 124         fn = draw_line_32;
 125         dest_width *= 4;
 126         break;
 127     default:
 128         hw_error("milkymist_vgafb: bad color depth\n");
 129         break;
 130     }
 131
 132     framebuffer_update_display(surface, sysbus_address_space(sbd),
 133                                s->regs[R_BASEADDRESS] + s->fb_offset,
 134                                s->regs[R_HRES],
 135                                s->regs[R_VRES],
 136                                s->regs[R_HRES] * 2,
 137                                dest_width,
 138                                0,
 139                                s->invalidate,
 140                                fn,
 141                                NULL,
 142                                &first, &last);
 143
 144     if (first >= 0) {
 145         dpy_gfx_update(s->con, 0, first, s->regs[R_HRES], last - first + 1);
 146     }
 147     s->invalidate = 0;
 148 }
 149
 150 static void vgafb_invalidate_display(void *opaque)
 151 {
 152     MilkymistVgafbState *s = opaque;
 153     s->invalidate = 1;
 154 }
 155
 156 static void vgafb_resize(MilkymistVgafbState *s)
 157 {
 158     if (!vgafb_enabled(s)) {
 159         return;
 160     }
 161
 162     qemu_console_resize(s->con, s->regs[R_HRES], s->regs[R_VRES]);
 163     s->invalidate = 1;
 164 }
 165
 166 static uint64_t vgafb_read(void *opaque, hwaddr addr,
 167                            unsigned size)
 168 {
 169     MilkymistVgafbState *s = opaque;
 170     uint32_t r = 0;
 171
 172     addr >>= 2;
 173     switch (addr) {
 174     case R_CTRL:
 175     case R_HRES:
 176     case R_HSYNC_START:
 177     case R_HSYNC_END:
 178     case R_HSCAN:
 179     case R_VRES:
 180     case R_VSYNC_START:
 181     case R_VSYNC_END:
 182     case R_VSCAN:
 183     case R_BASEADDRESS:
 184     case R_BURST_COUNT:
 185     case R_DDC:
 186     case R_SOURCE_CLOCK:
 187         r = s->regs[addr];
 188     break;
 189     case R_BASEADDRESS_ACT:
 190         r = s->regs[R_BASEADDRESS];
 191     break;
 192
 193     default:
 194         error_report("milkymist_vgafb: read access to unknown register 0x"
 195                 TARGET_FMT_plx, addr << 2);
 196         break;
 197     }
 198
 199     trace_milkymist_vgafb_memory_read(addr << 2, r);
 200
 201     return r;
 202 }
 203
 204 static void vgafb_write(void *opaque, hwaddr addr, uint64_t value,
 205                         unsigned size)
 206 {
 207     MilkymistVgafbState *s = opaque;
 208
 209     trace_milkymist_vgafb_memory_write(addr, value);
 210
 211     addr >>= 2;
 212     switch (addr) {
 213     case R_CTRL:
 214         s->regs[addr] = value;
 215         vgafb_resize(s);
 216         break;
 217     case R_HSYNC_START:
 218     case R_HSYNC_END:
 219     case R_HSCAN:
 220     case R_VSYNC_START:
 221     case R_VSYNC_END:
 222     case R_VSCAN:
 223     case R_BURST_COUNT:
 224     case R_DDC:
 225     case R_SOURCE_CLOCK:
 226         s->regs[addr] = value;
 227         break;
 228     case R_BASEADDRESS:
 229         if (value & 0x1f) {
 230             error_report("milkymist_vgafb: framebuffer base address have to "
 231                      "be 32 byte aligned");
 232             break;
 233         }
 234         s->regs[addr] = value & s->fb_mask;
 235         s->invalidate = 1;
 236         break;
 237     case R_HRES:
 238     case R_VRES:
 239         s->regs[addr] = value;
 240         vgafb_resize(s);
 241         break;
 242     case R_BASEADDRESS_ACT:
 243         error_report("milkymist_vgafb: write to read-only register 0x"
 244                 TARGET_FMT_plx, addr << 2);
 245         break;
 246
 247     default:
 248         error_report("milkymist_vgafb: write access to unknown register 0x"
 249                 TARGET_FMT_plx, addr << 2);
 250         break;
 251     }
 252 }
 253
 254 static const MemoryRegionOps vgafb_mmio_ops = {
 255     .read = vgafb_read,
 256     .write = vgafb_write,
 257     .valid = {
 258         .min_access_size = 4,
 259         .max_access_size = 4,
 260     },
 261     .endianness = DEVICE_NATIVE_ENDIAN,
 262 };
 263
 264 static void milkymist_vgafb_reset(DeviceState *d)
 265 {
 266     MilkymistVgafbState *s = MILKYMIST_VGAFB(d);
 267     int i;
 268
 269     for (i = 0; i < R_MAX; i++) {
 270         s->regs[i] = 0;
 271     }
 272
 273     /* defaults */
 274     s->regs[R_CTRL] = CTRL_RESET;
 275     s->regs[R_HRES] = 640;
 276     s->regs[R_VRES] = 480;
 277     s->regs[R_BASEADDRESS] = 0;
 278 }
 279
 280 static const GraphicHwOps vgafb_ops = {
 281     .invalidate  = vgafb_invalidate_display,
 282     .gfx_update  = vgafb_update_display,
 283 };
 284
 285 static int milkymist_vgafb_init(SysBusDevice *dev)
 286 {
 287     MilkymistVgafbState *s = MILKYMIST_VGAFB(dev);
 288
 289     memory_region_init_io(&s->regs_region, OBJECT(s), &vgafb_mmio_ops, s,
 290             "milkymist-vgafb", R_MAX * 4);
 291     sysbus_init_mmio(dev, &s->regs_region);
 292
 293     s->con = graphic_console_init(DEVICE(dev), &vgafb_ops, s);
 294
 295     return 0;
 296 }
 297
 298 static int vgafb_post_load(void *opaque, int version_id)
 299 {
 300     vgafb_invalidate_display(opaque);
 301     return 0;
 302 }
 303
 304 static const VMStateDescription vmstate_milkymist_vgafb = {
 305     .name = "milkymist-vgafb",
 306     .version_id = 1,
 307     .minimum_version_id = 1,
 308     .minimum_version_id_old = 1,
 309     .post_load = vgafb_post_load,
 310     .fields      = (VMStateField[]) {
 311         VMSTATE_UINT32_ARRAY(regs, MilkymistVgafbState, R_MAX),
 312         VMSTATE_END_OF_LIST()
 313     }
 314 };
 315
 316 static Property milkymist_vgafb_properties[] = {
 317     DEFINE_PROP_UINT32("fb_offset", MilkymistVgafbState, fb_offset, 0x0),
 318     DEFINE_PROP_UINT32("fb_mask", MilkymistVgafbState, fb_mask, 0xffffffff),
 319     DEFINE_PROP_END_OF_LIST(),
 320 };
 321
 322 static void milkymist_vgafb_class_init(ObjectClass *klass, void *data)
 323 {
 324     DeviceClass *dc = DEVICE_CLASS(klass);
 325     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 326
 327     k->init = milkymist_vgafb_init;
 328     dc->reset = milkymist_vgafb_reset;
 329     dc->vmsd = &vmstate_milkymist_vgafb;
 330     dc->props = milkymist_vgafb_properties;
 331 }
 332
 333 static const TypeInfo milkymist_vgafb_info = {
 334     .name          = TYPE_MILKYMIST_VGAFB,
 335     .parent        = TYPE_SYS_BUS_DEVICE,
 336     .instance_size = sizeof(MilkymistVgafbState),
 337     .class_init    = milkymist_vgafb_class_init,
 338 };
 339
 340 static void milkymist_vgafb_register_types(void)
 341 {
 342     type_register_static(&milkymist_vgafb_info);
 343 }
 344
 345 type_init(milkymist_vgafb_register_types)