]>
Commit | Line | Data |
---|---|---|
4af39611 PB |
1 | /* |
2 | * Syborg Framebuffer | |
3 | * | |
4 | * Copyright (c) 2009 CodeSourcery | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
25 | #include "sysbus.h" | |
26 | #include "console.h" | |
27 | #include "syborg.h" | |
28 | #include "framebuffer.h" | |
29 | ||
30 | //#define DEBUG_SYBORG_FB | |
31 | ||
32 | #ifdef DEBUG_SYBORG_FB | |
33 | #define DPRINTF(fmt, ...) \ | |
34 | do { printf("syborg_fb: " fmt , ## __VA_ARGS__); } while (0) | |
35 | #define BADF(fmt, ...) \ | |
36 | do { fprintf(stderr, "syborg_fb: error: " fmt , ## __VA_ARGS__); \ | |
37 | exit(1);} while (0) | |
38 | #else | |
39 | #define DPRINTF(fmt, ...) do {} while(0) | |
40 | #define BADF(fmt, ...) \ | |
41 | do { fprintf(stderr, "syborg_fb: error: " fmt , ## __VA_ARGS__);} while (0) | |
42 | #endif | |
43 | ||
44 | enum { | |
45 | FB_ID = 0, | |
46 | FB_BASE = 1, | |
47 | FB_HEIGHT = 2, | |
48 | FB_WIDTH = 3, | |
49 | FB_ORIENTATION = 4, | |
50 | FB_BLANK = 5, | |
51 | FB_INT_MASK = 6, | |
52 | FB_INTERRUPT_CAUSE = 7, | |
53 | FB_BPP = 8, | |
54 | FB_COLOR_ORDER = 9, | |
55 | FB_BYTE_ORDER = 10, | |
56 | FB_PIXEL_ORDER = 11, | |
57 | FB_ROW_PITCH = 12, | |
58 | FB_ENABLED = 13, | |
59 | FB_PALETTE_START = 0x400 >> 2, | |
60 | FB_PALETTE_END = FB_PALETTE_START+256-1, | |
61 | }; | |
62 | ||
63 | #define FB_INT_VSYNC (1U << 0) | |
64 | #define FB_INT_BASE_UPDATE_DONE (1U << 1) | |
65 | ||
66 | typedef struct { | |
67 | SysBusDevice busdev; | |
0520a049 | 68 | MemoryRegion iomem; |
4af39611 PB |
69 | DisplayState *ds; |
70 | /*QEMUConsole *console;*/ | |
71 | uint32_t need_update : 1; | |
72 | uint32_t need_int : 1; | |
73 | uint32_t enabled : 1; | |
74 | uint32_t int_status; | |
75 | uint32_t int_enable; | |
76 | qemu_irq irq; | |
77 | ||
78 | uint32_t base; | |
79 | uint32_t pitch; | |
ee6847d1 GH |
80 | uint32_t rows; |
81 | uint32_t cols; | |
4af39611 PB |
82 | int blank; |
83 | int bpp; | |
84 | int rgb; /* 0 = BGR, 1 = RGB */ | |
85 | int endian; /* 0 = Little, 1 = Big */ | |
86 | uint32_t raw_palette[256]; | |
87 | uint32_t palette[256]; | |
88 | } SyborgFBState; | |
89 | ||
90 | enum { | |
91 | BPP_SRC_1, | |
92 | BPP_SRC_2, | |
93 | BPP_SRC_4, | |
94 | BPP_SRC_8, | |
95 | BPP_SRC_16, | |
96 | BPP_SRC_32, | |
97 | /* TODO: Implement these. */ | |
98 | BPP_SRC_15 = -1, | |
99 | BPP_SRC_24 = -2 | |
100 | }; | |
101 | ||
102 | #include "pixel_ops.h" | |
103 | ||
104 | #define BITS 8 | |
105 | #include "pl110_template.h" | |
106 | #define BITS 15 | |
107 | #include "pl110_template.h" | |
108 | #define BITS 16 | |
109 | #include "pl110_template.h" | |
110 | #define BITS 24 | |
111 | #include "pl110_template.h" | |
112 | #define BITS 32 | |
113 | #include "pl110_template.h" | |
114 | ||
115 | /* Update interrupts. */ | |
116 | static void syborg_fb_update(SyborgFBState *s) | |
117 | { | |
118 | if ((s->int_status & s->int_enable) != 0) { | |
119 | DPRINTF("Raise IRQ\n"); | |
120 | qemu_irq_raise(s->irq); | |
121 | } else { | |
122 | DPRINTF("Lower IRQ\n"); | |
123 | qemu_irq_lower(s->irq); | |
124 | } | |
125 | } | |
126 | ||
127 | static int syborg_fb_enabled(const SyborgFBState *s) | |
128 | { | |
129 | return s->enabled; | |
130 | } | |
131 | ||
132 | static void syborg_fb_update_palette(SyborgFBState *s) | |
133 | { | |
134 | int n, i; | |
135 | uint32_t raw; | |
136 | unsigned int r, g, b; | |
137 | ||
138 | switch (s->bpp) { | |
139 | case BPP_SRC_1: n = 2; break; | |
140 | case BPP_SRC_2: n = 4; break; | |
141 | case BPP_SRC_4: n = 16; break; | |
142 | case BPP_SRC_8: n = 256; break; | |
143 | default: return; | |
144 | } | |
145 | ||
146 | for (i = 0; i < n; i++) { | |
147 | raw = s->raw_palette[i]; | |
148 | r = (raw >> 16) & 0xff; | |
149 | g = (raw >> 8) & 0xff; | |
150 | b = raw & 0xff; | |
151 | switch (ds_get_bits_per_pixel(s->ds)) { | |
152 | case 8: | |
153 | s->palette[i] = rgb_to_pixel8(r, g, b); | |
154 | break; | |
155 | case 15: | |
156 | s->palette[i] = rgb_to_pixel15(r, g, b); | |
157 | break; | |
158 | case 16: | |
159 | s->palette[i] = rgb_to_pixel16(r, g, b); | |
160 | break; | |
161 | case 24: | |
162 | case 32: | |
163 | s->palette[i] = rgb_to_pixel32(r, g, b); | |
164 | break; | |
165 | default: | |
166 | abort(); | |
167 | } | |
168 | } | |
169 | ||
170 | } | |
171 | ||
172 | static void syborg_fb_update_display(void *opaque) | |
173 | { | |
174 | SyborgFBState *s = (SyborgFBState *)opaque; | |
175 | drawfn* fntable; | |
176 | drawfn fn; | |
177 | int dest_width; | |
178 | int src_width; | |
179 | int bpp_offset; | |
180 | int first; | |
181 | int last; | |
182 | ||
183 | if (!syborg_fb_enabled(s)) | |
184 | return; | |
185 | ||
186 | switch (ds_get_bits_per_pixel(s->ds)) { | |
187 | case 0: | |
188 | return; | |
189 | case 8: | |
190 | fntable = pl110_draw_fn_8; | |
191 | dest_width = 1; | |
192 | break; | |
193 | case 15: | |
194 | fntable = pl110_draw_fn_15; | |
195 | dest_width = 2; | |
196 | break; | |
197 | case 16: | |
198 | fntable = pl110_draw_fn_16; | |
199 | dest_width = 2; | |
200 | break; | |
201 | case 24: | |
202 | fntable = pl110_draw_fn_24; | |
203 | dest_width = 3; | |
204 | break; | |
205 | case 32: | |
206 | fntable = pl110_draw_fn_32; | |
207 | dest_width = 4; | |
208 | break; | |
209 | default: | |
210 | fprintf(stderr, "syborg_fb: Bad color depth\n"); | |
211 | exit(1); | |
212 | } | |
213 | ||
214 | if (s->need_int) { | |
215 | s->int_status |= FB_INT_BASE_UPDATE_DONE; | |
216 | syborg_fb_update(s); | |
217 | s->need_int = 0; | |
218 | } | |
219 | ||
220 | if (s->rgb) { | |
4fbf5556 | 221 | bpp_offset = 24; |
4af39611 PB |
222 | } else { |
223 | bpp_offset = 0; | |
224 | } | |
225 | if (s->endian) { | |
4fbf5556 PM |
226 | bpp_offset += 8; |
227 | } | |
228 | /* Our bpp constants mostly match the PL110/PL111 but | |
229 | * not for the 16 bit case | |
230 | */ | |
231 | switch (s->bpp) { | |
232 | case BPP_SRC_16: | |
4af39611 | 233 | bpp_offset += 6; |
4fbf5556 PM |
234 | break; |
235 | default: | |
236 | bpp_offset += s->bpp; | |
4af39611 | 237 | } |
4fbf5556 | 238 | fn = fntable[bpp_offset]; |
4af39611 PB |
239 | |
240 | if (s->pitch) { | |
241 | src_width = s->pitch; | |
242 | } else { | |
243 | src_width = s->cols; | |
244 | switch (s->bpp) { | |
245 | case BPP_SRC_1: | |
246 | src_width >>= 3; | |
247 | break; | |
248 | case BPP_SRC_2: | |
249 | src_width >>= 2; | |
250 | break; | |
251 | case BPP_SRC_4: | |
252 | src_width >>= 1; | |
253 | break; | |
254 | case BPP_SRC_8: | |
255 | break; | |
256 | case BPP_SRC_15: | |
257 | case BPP_SRC_16: | |
258 | src_width <<= 1; | |
259 | break; | |
260 | case BPP_SRC_24: | |
261 | src_width *= 3; | |
262 | break; | |
263 | case BPP_SRC_32: | |
264 | src_width <<= 2; | |
265 | break; | |
266 | } | |
267 | } | |
268 | dest_width *= s->cols; | |
269 | first = 0; | |
270 | /* TODO: Implement blanking. */ | |
271 | if (!s->blank) { | |
272 | if (s->need_update && s->bpp <= BPP_SRC_8) { | |
273 | syborg_fb_update_palette(s); | |
274 | } | |
275 | framebuffer_update_display(s->ds, | |
276 | s->base, s->cols, s->rows, | |
277 | src_width, dest_width, 0, | |
278 | s->need_update, | |
279 | fn, s->palette, | |
280 | &first, &last); | |
281 | if (first >= 0) { | |
282 | dpy_update(s->ds, 0, first, s->cols, last - first + 1); | |
283 | } | |
284 | ||
285 | s->int_status |= FB_INT_VSYNC; | |
286 | syborg_fb_update(s); | |
287 | } | |
288 | ||
289 | s->need_update = 0; | |
290 | } | |
291 | ||
292 | static void syborg_fb_invalidate_display(void * opaque) | |
293 | { | |
294 | SyborgFBState *s = (SyborgFBState *)opaque; | |
295 | s->need_update = 1; | |
296 | } | |
297 | ||
0520a049 BC |
298 | static uint64_t syborg_fb_read(void *opaque, target_phys_addr_t offset, |
299 | unsigned size) | |
4af39611 PB |
300 | { |
301 | SyborgFBState *s = opaque; | |
302 | ||
303 | DPRINTF("read reg %d\n", (int)offset); | |
304 | offset &= 0xfff; | |
305 | switch (offset >> 2) { | |
306 | case FB_ID: | |
307 | return SYBORG_ID_FRAMEBUFFER; | |
308 | ||
309 | case FB_BASE: | |
310 | return s->base; | |
311 | ||
312 | case FB_HEIGHT: | |
313 | return s->rows; | |
314 | ||
315 | case FB_WIDTH: | |
316 | return s->cols; | |
317 | ||
318 | case FB_ORIENTATION: | |
319 | return 0; | |
320 | ||
321 | case FB_BLANK: | |
322 | return s->blank; | |
323 | ||
324 | case FB_INT_MASK: | |
325 | return s->int_enable; | |
326 | ||
327 | case FB_INTERRUPT_CAUSE: | |
328 | return s->int_status; | |
329 | ||
330 | case FB_BPP: | |
331 | switch (s->bpp) { | |
332 | case BPP_SRC_1: return 1; | |
333 | case BPP_SRC_2: return 2; | |
334 | case BPP_SRC_4: return 4; | |
335 | case BPP_SRC_8: return 8; | |
336 | case BPP_SRC_15: return 15; | |
337 | case BPP_SRC_16: return 16; | |
338 | case BPP_SRC_24: return 24; | |
339 | case BPP_SRC_32: return 32; | |
340 | default: return 0; | |
341 | } | |
342 | ||
343 | case FB_COLOR_ORDER: | |
344 | return s->rgb; | |
345 | ||
346 | case FB_BYTE_ORDER: | |
347 | return s->endian; | |
348 | ||
349 | case FB_PIXEL_ORDER: | |
350 | return 0; | |
351 | ||
352 | case FB_ROW_PITCH: | |
353 | return s->pitch; | |
354 | ||
355 | case FB_ENABLED: | |
356 | return s->enabled; | |
357 | ||
358 | default: | |
359 | if ((offset >> 2) >= FB_PALETTE_START | |
360 | && (offset >> 2) <= FB_PALETTE_END) { | |
361 | return s->raw_palette[(offset >> 2) - FB_PALETTE_START]; | |
362 | } else { | |
363 | cpu_abort (cpu_single_env, "syborg_fb_read: Bad offset %x\n", | |
364 | (int)offset); | |
365 | } | |
366 | return 0; | |
367 | } | |
368 | } | |
369 | ||
c227f099 | 370 | static void syborg_fb_write(void *opaque, target_phys_addr_t offset, |
0520a049 | 371 | uint64_t val, unsigned size) |
4af39611 PB |
372 | { |
373 | SyborgFBState *s = opaque; | |
374 | ||
375 | DPRINTF("write reg %d = %d\n", (int)offset, val); | |
376 | s->need_update = 1; | |
377 | offset &= 0xfff; | |
378 | switch (offset >> 2) { | |
379 | case FB_BASE: | |
380 | s->base = val; | |
381 | s->need_int = 1; | |
382 | s->need_update = 1; | |
383 | syborg_fb_update(s); | |
384 | break; | |
385 | ||
386 | case FB_HEIGHT: | |
387 | s->rows = val; | |
388 | break; | |
389 | ||
390 | case FB_WIDTH: | |
391 | s->cols = val; | |
392 | break; | |
393 | ||
394 | case FB_ORIENTATION: | |
395 | /* TODO: Implement rotation. */ | |
396 | break; | |
397 | ||
398 | case FB_BLANK: | |
399 | s->blank = val & 1; | |
400 | break; | |
401 | ||
402 | case FB_INT_MASK: | |
403 | s->int_enable = val; | |
404 | syborg_fb_update(s); | |
405 | break; | |
406 | ||
407 | case FB_INTERRUPT_CAUSE: | |
408 | s->int_status &= ~val; | |
409 | syborg_fb_update(s); | |
410 | break; | |
411 | ||
412 | case FB_BPP: | |
413 | switch (val) { | |
414 | case 1: val = BPP_SRC_1; break; | |
415 | case 2: val = BPP_SRC_2; break; | |
416 | case 4: val = BPP_SRC_4; break; | |
417 | case 8: val = BPP_SRC_8; break; | |
418 | /* case 15: val = BPP_SRC_15; break; */ | |
419 | case 16: val = BPP_SRC_16; break; | |
420 | /* case 24: val = BPP_SRC_24; break; */ | |
421 | case 32: val = BPP_SRC_32; break; | |
422 | default: val = s->bpp; break; | |
423 | } | |
424 | s->bpp = val; | |
425 | break; | |
426 | ||
427 | case FB_COLOR_ORDER: | |
428 | s->rgb = (val != 0); | |
429 | break; | |
430 | ||
431 | case FB_BYTE_ORDER: | |
432 | s->endian = (val != 0); | |
433 | break; | |
434 | ||
435 | case FB_PIXEL_ORDER: | |
436 | /* TODO: Implement this. */ | |
437 | break; | |
438 | ||
439 | case FB_ROW_PITCH: | |
440 | s->pitch = val; | |
441 | break; | |
442 | ||
443 | case FB_ENABLED: | |
444 | s->enabled = val; | |
445 | break; | |
446 | ||
447 | default: | |
448 | if ((offset >> 2) >= FB_PALETTE_START | |
449 | && (offset >> 2) <= FB_PALETTE_END) { | |
450 | s->raw_palette[(offset >> 2) - FB_PALETTE_START] = val; | |
451 | } else { | |
452 | cpu_abort (cpu_single_env, "syborg_fb_write: Bad offset %x\n", | |
453 | (int)offset); | |
454 | } | |
455 | break; | |
456 | } | |
457 | } | |
458 | ||
0520a049 BC |
459 | static const MemoryRegionOps syborg_fb_ops = { |
460 | .read = syborg_fb_read, | |
461 | .write = syborg_fb_write, | |
462 | .endianness = DEVICE_NATIVE_ENDIAN, | |
4af39611 PB |
463 | }; |
464 | ||
465 | static void syborg_fb_save(QEMUFile *f, void *opaque) | |
466 | { | |
467 | SyborgFBState *s = opaque; | |
468 | int i; | |
469 | ||
470 | qemu_put_be32(f, s->need_int); | |
471 | qemu_put_be32(f, s->int_status); | |
472 | qemu_put_be32(f, s->int_enable); | |
473 | qemu_put_be32(f, s->enabled); | |
474 | qemu_put_be32(f, s->base); | |
475 | qemu_put_be32(f, s->pitch); | |
476 | qemu_put_be32(f, s->rows); | |
477 | qemu_put_be32(f, s->cols); | |
478 | qemu_put_be32(f, s->bpp); | |
479 | qemu_put_be32(f, s->rgb); | |
480 | for (i = 0; i < 256; i++) { | |
481 | qemu_put_be32(f, s->raw_palette[i]); | |
482 | } | |
483 | } | |
484 | ||
485 | static int syborg_fb_load(QEMUFile *f, void *opaque, int version_id) | |
486 | { | |
487 | SyborgFBState *s = opaque; | |
488 | int i; | |
489 | ||
490 | if (version_id != 1) | |
491 | return -EINVAL; | |
492 | ||
493 | s->need_int = qemu_get_be32(f); | |
494 | s->int_status = qemu_get_be32(f); | |
495 | s->int_enable = qemu_get_be32(f); | |
496 | s->enabled = qemu_get_be32(f); | |
497 | s->base = qemu_get_be32(f); | |
498 | s->pitch = qemu_get_be32(f); | |
499 | s->rows = qemu_get_be32(f); | |
500 | s->cols = qemu_get_be32(f); | |
501 | s->bpp = qemu_get_be32(f); | |
502 | s->rgb = qemu_get_be32(f); | |
503 | for (i = 0; i < 256; i++) { | |
504 | s->raw_palette[i] = qemu_get_be32(f); | |
505 | } | |
506 | s->need_update = 1; | |
507 | ||
508 | return 0; | |
509 | } | |
510 | ||
81a322d4 | 511 | static int syborg_fb_init(SysBusDevice *dev) |
4af39611 PB |
512 | { |
513 | SyborgFBState *s = FROM_SYSBUS(SyborgFBState, dev); | |
4af39611 PB |
514 | |
515 | sysbus_init_irq(dev, &s->irq); | |
0520a049 BC |
516 | memory_region_init_io(&s->iomem, &syborg_fb_ops, s, |
517 | "framebuffer", 0x1000); | |
750ecd44 | 518 | sysbus_init_mmio(dev, &s->iomem); |
4af39611 | 519 | |
4af39611 PB |
520 | s->ds = graphic_console_init(syborg_fb_update_display, |
521 | syborg_fb_invalidate_display, | |
522 | NULL, NULL, s); | |
523 | ||
ee6847d1 GH |
524 | if (s->cols != 0 && s->rows != 0) { |
525 | qemu_console_resize(s->ds, s->cols, s->rows); | |
4af39611 PB |
526 | } |
527 | ||
ee6847d1 GH |
528 | if (!s->cols) |
529 | s->cols = ds_get_width(s->ds); | |
530 | if (!s->rows) | |
531 | s->rows = ds_get_height(s->ds); | |
4af39611 | 532 | |
0be71e32 | 533 | register_savevm(&dev->qdev, "syborg_framebuffer", -1, 1, |
4af39611 | 534 | syborg_fb_save, syborg_fb_load, s); |
81a322d4 | 535 | return 0; |
4af39611 PB |
536 | } |
537 | ||
ee6847d1 GH |
538 | static SysBusDeviceInfo syborg_fb_info = { |
539 | .init = syborg_fb_init, | |
540 | .qdev.name = "syborg,framebuffer", | |
541 | .qdev.size = sizeof(SyborgFBState), | |
542 | .qdev.props = (Property[]) { | |
c230c4e3 GH |
543 | DEFINE_PROP_UINT32("width", SyborgFBState, cols, 0), |
544 | DEFINE_PROP_UINT32("height", SyborgFBState, rows, 0), | |
545 | DEFINE_PROP_END_OF_LIST(), | |
ee6847d1 GH |
546 | } |
547 | }; | |
548 | ||
4af39611 PB |
549 | static void syborg_fb_register_devices(void) |
550 | { | |
ee6847d1 | 551 | sysbus_register_withprop(&syborg_fb_info); |
4af39611 PB |
552 | } |
553 | ||
554 | device_init(syborg_fb_register_devices) |