hw/arm/bcm2836: Only provide "enabled-cpus" property to multicore SoCs
[qemu.git] / hw / display / macfb.c
1 /*
2 * QEMU Motorola 680x0 Macintosh Video Card Emulation
3 * Copyright (c) 2012-2018 Laurent Vivier
4 *
5 * some parts from QEMU G364 framebuffer Emulator.
6 * Copyright (c) 2007-2011 Herve Poussineau
7 *
8 * This work is licensed under the terms of the GNU GPL, version 2 or later.
9 * See the COPYING file in the top-level directory.
10 *
11 */
12
13 #include "qemu/osdep.h"
14 #include "qemu/units.h"
15 #include "hw/sysbus.h"
16 #include "ui/console.h"
17 #include "ui/pixel_ops.h"
18 #include "hw/nubus/nubus.h"
19 #include "hw/display/macfb.h"
20 #include "qapi/error.h"
21 #include "hw/qdev-properties.h"
22 #include "migration/vmstate.h"
23
24 #define VIDEO_BASE 0x00001000
25 #define DAFB_BASE 0x00800000
26
27 #define MACFB_PAGE_SIZE 4096
28 #define MACFB_VRAM_SIZE (4 * MiB)
29
30 #define DAFB_RESET 0x200
31 #define DAFB_LUT 0x213
32
33
34 typedef void macfb_draw_line_func(MacfbState *s, uint8_t *d, uint32_t addr,
35 int width);
36
37 static inline uint8_t macfb_read_byte(MacfbState *s, uint32_t addr)
38 {
39 return s->vram[addr & s->vram_bit_mask];
40 }
41
42 /* 1-bit color */
43 static void macfb_draw_line1(MacfbState *s, uint8_t *d, uint32_t addr,
44 int width)
45 {
46 uint8_t r, g, b;
47 int x;
48
49 for (x = 0; x < width; x++) {
50 int bit = x & 7;
51 int idx = (macfb_read_byte(s, addr) >> (7 - bit)) & 1;
52 r = g = b = ((1 - idx) << 7);
53 addr += (bit == 7);
54
55 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
56 d += 4;
57 }
58 }
59
60 /* 2-bit color */
61 static void macfb_draw_line2(MacfbState *s, uint8_t *d, uint32_t addr,
62 int width)
63 {
64 uint8_t r, g, b;
65 int x;
66
67 for (x = 0; x < width; x++) {
68 int bit = (x & 3);
69 int idx = (macfb_read_byte(s, addr) >> ((3 - bit) << 1)) & 3;
70 r = s->color_palette[idx * 3];
71 g = s->color_palette[idx * 3 + 1];
72 b = s->color_palette[idx * 3 + 2];
73 addr += (bit == 3);
74
75 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
76 d += 4;
77 }
78 }
79
80 /* 4-bit color */
81 static void macfb_draw_line4(MacfbState *s, uint8_t *d, uint32_t addr,
82 int width)
83 {
84 uint8_t r, g, b;
85 int x;
86
87 for (x = 0; x < width; x++) {
88 int bit = x & 1;
89 int idx = (macfb_read_byte(s, addr) >> ((1 - bit) << 2)) & 15;
90 r = s->color_palette[idx * 3];
91 g = s->color_palette[idx * 3 + 1];
92 b = s->color_palette[idx * 3 + 2];
93 addr += (bit == 1);
94
95 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
96 d += 4;
97 }
98 }
99
100 /* 8-bit color */
101 static void macfb_draw_line8(MacfbState *s, uint8_t *d, uint32_t addr,
102 int width)
103 {
104 uint8_t r, g, b;
105 int x;
106
107 for (x = 0; x < width; x++) {
108 r = s->color_palette[macfb_read_byte(s, addr) * 3];
109 g = s->color_palette[macfb_read_byte(s, addr) * 3 + 1];
110 b = s->color_palette[macfb_read_byte(s, addr) * 3 + 2];
111 addr++;
112
113 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
114 d += 4;
115 }
116 }
117
118 /* 16-bit color */
119 static void macfb_draw_line16(MacfbState *s, uint8_t *d, uint32_t addr,
120 int width)
121 {
122 uint8_t r, g, b;
123 int x;
124
125 for (x = 0; x < width; x++) {
126 uint16_t pixel;
127 pixel = (macfb_read_byte(s, addr) << 8) | macfb_read_byte(s, addr + 1);
128 r = ((pixel >> 10) & 0x1f) << 3;
129 g = ((pixel >> 5) & 0x1f) << 3;
130 b = (pixel & 0x1f) << 3;
131 addr += 2;
132
133 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
134 d += 4;
135 }
136 }
137
138 /* 24-bit color */
139 static void macfb_draw_line24(MacfbState *s, uint8_t *d, uint32_t addr,
140 int width)
141 {
142 uint8_t r, g, b;
143 int x;
144
145 for (x = 0; x < width; x++) {
146 r = macfb_read_byte(s, addr);
147 g = macfb_read_byte(s, addr + 1);
148 b = macfb_read_byte(s, addr + 2);
149 addr += 3;
150
151 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
152 d += 4;
153 }
154 }
155
156
157 enum {
158 MACFB_DRAW_LINE1,
159 MACFB_DRAW_LINE2,
160 MACFB_DRAW_LINE4,
161 MACFB_DRAW_LINE8,
162 MACFB_DRAW_LINE16,
163 MACFB_DRAW_LINE24,
164 MACFB_DRAW_LINE_NB,
165 };
166
167 static macfb_draw_line_func * const
168 macfb_draw_line_table[MACFB_DRAW_LINE_NB] = {
169 macfb_draw_line1,
170 macfb_draw_line2,
171 macfb_draw_line4,
172 macfb_draw_line8,
173 macfb_draw_line16,
174 macfb_draw_line24,
175 };
176
177 static int macfb_check_dirty(MacfbState *s, DirtyBitmapSnapshot *snap,
178 ram_addr_t addr, int len)
179 {
180 return memory_region_snapshot_get_dirty(&s->mem_vram, snap, addr, len);
181 }
182
183 static void macfb_draw_graphic(MacfbState *s)
184 {
185 DisplaySurface *surface = qemu_console_surface(s->con);
186 DirtyBitmapSnapshot *snap = NULL;
187 ram_addr_t page;
188 uint32_t v = 0;
189 int y, ymin;
190 int macfb_stride = (s->depth * s->width + 7) / 8;
191 macfb_draw_line_func *macfb_draw_line;
192
193 switch (s->depth) {
194 case 1:
195 v = MACFB_DRAW_LINE1;
196 break;
197 case 2:
198 v = MACFB_DRAW_LINE2;
199 break;
200 case 4:
201 v = MACFB_DRAW_LINE4;
202 break;
203 case 8:
204 v = MACFB_DRAW_LINE8;
205 break;
206 case 16:
207 v = MACFB_DRAW_LINE16;
208 break;
209 case 24:
210 v = MACFB_DRAW_LINE24;
211 break;
212 }
213
214 macfb_draw_line = macfb_draw_line_table[v];
215 assert(macfb_draw_line != NULL);
216
217 snap = memory_region_snapshot_and_clear_dirty(&s->mem_vram, 0x0,
218 memory_region_size(&s->mem_vram),
219 DIRTY_MEMORY_VGA);
220
221 ymin = -1;
222 page = 0;
223 for (y = 0; y < s->height; y++, page += macfb_stride) {
224 if (macfb_check_dirty(s, snap, page, macfb_stride)) {
225 uint8_t *data_display;
226
227 data_display = surface_data(surface) + y * surface_stride(surface);
228 macfb_draw_line(s, data_display, page, s->width);
229
230 if (ymin < 0) {
231 ymin = y;
232 }
233 } else {
234 if (ymin >= 0) {
235 dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
236 ymin = -1;
237 }
238 }
239 }
240
241 if (ymin >= 0) {
242 dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
243 }
244
245 g_free(snap);
246 }
247
248 static void macfb_invalidate_display(void *opaque)
249 {
250 MacfbState *s = opaque;
251
252 memory_region_set_dirty(&s->mem_vram, 0, MACFB_VRAM_SIZE);
253 }
254
255 static void macfb_update_display(void *opaque)
256 {
257 MacfbState *s = opaque;
258 DisplaySurface *surface = qemu_console_surface(s->con);
259
260 qemu_flush_coalesced_mmio_buffer();
261
262 if (s->width == 0 || s->height == 0) {
263 return;
264 }
265
266 if (s->width != surface_width(surface) ||
267 s->height != surface_height(surface)) {
268 qemu_console_resize(s->con, s->width, s->height);
269 }
270
271 macfb_draw_graphic(s);
272 }
273
274 static void macfb_reset(MacfbState *s)
275 {
276 int i;
277
278 s->palette_current = 0;
279 for (i = 0; i < 256; i++) {
280 s->color_palette[i * 3] = 255 - i;
281 s->color_palette[i * 3 + 1] = 255 - i;
282 s->color_palette[i * 3 + 2] = 255 - i;
283 }
284 memset(s->vram, 0, MACFB_VRAM_SIZE);
285 macfb_invalidate_display(s);
286 }
287
288 static uint64_t macfb_ctrl_read(void *opaque,
289 hwaddr addr,
290 unsigned int size)
291 {
292 return 0;
293 }
294
295 static void macfb_ctrl_write(void *opaque,
296 hwaddr addr,
297 uint64_t val,
298 unsigned int size)
299 {
300 MacfbState *s = opaque;
301 switch (addr) {
302 case DAFB_RESET:
303 s->palette_current = 0;
304 break;
305 case DAFB_LUT:
306 s->color_palette[s->palette_current++] = val;
307 if (s->palette_current % 3) {
308 macfb_invalidate_display(s);
309 }
310 break;
311 }
312 }
313
314 static const MemoryRegionOps macfb_ctrl_ops = {
315 .read = macfb_ctrl_read,
316 .write = macfb_ctrl_write,
317 .endianness = DEVICE_BIG_ENDIAN,
318 .impl.min_access_size = 1,
319 .impl.max_access_size = 4,
320 };
321
322 static int macfb_post_load(void *opaque, int version_id)
323 {
324 macfb_invalidate_display(opaque);
325 return 0;
326 }
327
328 static const VMStateDescription vmstate_macfb = {
329 .name = "macfb",
330 .version_id = 1,
331 .minimum_version_id = 1,
332 .minimum_version_id_old = 1,
333 .post_load = macfb_post_load,
334 .fields = (VMStateField[]) {
335 VMSTATE_UINT8_ARRAY(color_palette, MacfbState, 256 * 3),
336 VMSTATE_UINT32(palette_current, MacfbState),
337 VMSTATE_END_OF_LIST()
338 }
339 };
340
341 static const GraphicHwOps macfb_ops = {
342 .invalidate = macfb_invalidate_display,
343 .gfx_update = macfb_update_display,
344 };
345
346 static void macfb_common_realize(DeviceState *dev, MacfbState *s, Error **errp)
347 {
348 DisplaySurface *surface;
349
350 if (s->depth != 1 && s->depth != 2 && s->depth != 4 && s->depth != 8 &&
351 s->depth != 16 && s->depth != 24) {
352 error_setg(errp, "unknown guest depth %d", s->depth);
353 return;
354 }
355
356 s->con = graphic_console_init(dev, 0, &macfb_ops, s);
357 surface = qemu_console_surface(s->con);
358
359 if (surface_bits_per_pixel(surface) != 32) {
360 error_setg(errp, "unknown host depth %d",
361 surface_bits_per_pixel(surface));
362 return;
363 }
364
365 memory_region_init_io(&s->mem_ctrl, OBJECT(dev), &macfb_ctrl_ops, s,
366 "macfb-ctrl", 0x1000);
367
368 memory_region_init_ram_nomigrate(&s->mem_vram, OBJECT(s), "macfb-vram",
369 MACFB_VRAM_SIZE, errp);
370 s->vram = memory_region_get_ram_ptr(&s->mem_vram);
371 s->vram_bit_mask = MACFB_VRAM_SIZE - 1;
372 vmstate_register_ram(&s->mem_vram, dev);
373 memory_region_set_coalescing(&s->mem_vram);
374 }
375
376 static void macfb_sysbus_realize(DeviceState *dev, Error **errp)
377 {
378 MacfbSysBusState *s = MACFB(dev);
379 MacfbState *ms = &s->macfb;
380
381 macfb_common_realize(dev, ms, errp);
382 sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_ctrl);
383 sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_vram);
384 }
385
386 const uint8_t macfb_rom[] = {
387 255, 0, 0, 0,
388 };
389
390 static void macfb_nubus_realize(DeviceState *dev, Error **errp)
391 {
392 NubusDevice *nd = NUBUS_DEVICE(dev);
393 MacfbNubusState *s = NUBUS_MACFB(dev);
394 MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
395 MacfbState *ms = &s->macfb;
396
397 ndc->parent_realize(dev, errp);
398
399 macfb_common_realize(dev, ms, errp);
400 memory_region_add_subregion(&nd->slot_mem, DAFB_BASE, &ms->mem_ctrl);
401 memory_region_add_subregion(&nd->slot_mem, VIDEO_BASE, &ms->mem_vram);
402
403 nubus_register_rom(nd, macfb_rom, sizeof(macfb_rom), 1, 9, 0xf);
404 }
405
406 static void macfb_sysbus_reset(DeviceState *d)
407 {
408 MacfbSysBusState *s = MACFB(d);
409 macfb_reset(&s->macfb);
410 }
411
412 static void macfb_nubus_reset(DeviceState *d)
413 {
414 MacfbNubusState *s = NUBUS_MACFB(d);
415 macfb_reset(&s->macfb);
416 }
417
418 static Property macfb_sysbus_properties[] = {
419 DEFINE_PROP_UINT32("width", MacfbSysBusState, macfb.width, 640),
420 DEFINE_PROP_UINT32("height", MacfbSysBusState, macfb.height, 480),
421 DEFINE_PROP_UINT8("depth", MacfbSysBusState, macfb.depth, 8),
422 DEFINE_PROP_END_OF_LIST(),
423 };
424
425 static Property macfb_nubus_properties[] = {
426 DEFINE_PROP_UINT32("width", MacfbNubusState, macfb.width, 640),
427 DEFINE_PROP_UINT32("height", MacfbNubusState, macfb.height, 480),
428 DEFINE_PROP_UINT8("depth", MacfbNubusState, macfb.depth, 8),
429 DEFINE_PROP_END_OF_LIST(),
430 };
431
432 static void macfb_sysbus_class_init(ObjectClass *klass, void *data)
433 {
434 DeviceClass *dc = DEVICE_CLASS(klass);
435
436 dc->realize = macfb_sysbus_realize;
437 dc->desc = "SysBus Macintosh framebuffer";
438 dc->reset = macfb_sysbus_reset;
439 dc->vmsd = &vmstate_macfb;
440 device_class_set_props(dc, macfb_sysbus_properties);
441 }
442
443 static void macfb_nubus_class_init(ObjectClass *klass, void *data)
444 {
445 DeviceClass *dc = DEVICE_CLASS(klass);
446 MacfbNubusDeviceClass *ndc = NUBUS_MACFB_CLASS(klass);
447
448 device_class_set_parent_realize(dc, macfb_nubus_realize,
449 &ndc->parent_realize);
450 dc->desc = "Nubus Macintosh framebuffer";
451 dc->reset = macfb_nubus_reset;
452 dc->vmsd = &vmstate_macfb;
453 device_class_set_props(dc, macfb_nubus_properties);
454 }
455
456 static TypeInfo macfb_sysbus_info = {
457 .name = TYPE_MACFB,
458 .parent = TYPE_SYS_BUS_DEVICE,
459 .instance_size = sizeof(MacfbSysBusState),
460 .class_init = macfb_sysbus_class_init,
461 };
462
463 static TypeInfo macfb_nubus_info = {
464 .name = TYPE_NUBUS_MACFB,
465 .parent = TYPE_NUBUS_DEVICE,
466 .instance_size = sizeof(MacfbNubusState),
467 .class_init = macfb_nubus_class_init,
468 .class_size = sizeof(MacfbNubusDeviceClass),
469 };
470
471 static void macfb_register_types(void)
472 {
473 type_register_static(&macfb_sysbus_info);
474 type_register_static(&macfb_nubus_info);
475 }
476
477 type_init(macfb_register_types)