?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'qemu-macppc-20230206' of https://github.com/mcayland/qemu into staging
[qemu/rayw.git] / hw / display / vga.c
blob7a5fdff649f482a355ae2a7c7aa6167b7ff2b6f1
1 /*
2 * QEMU VGA Emulator.
3 *
4 * Copyright (c) 2003 Fabrice Bellard
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 "qemu/osdep.h"
26 #include "qemu/units.h"
27 #include "sysemu/reset.h"
28 #include "qapi/error.h"
29 #include "hw/display/vga.h"
30 #include "hw/pci/pci.h"
31 #include "vga_int.h"
32 #include "vga_regs.h"
33 #include "ui/pixel_ops.h"
34 #include "ui/console.h"
35 #include "qemu/timer.h"
36 #include "hw/xen/xen.h"
37 #include "migration/vmstate.h"
38 #include "trace.h"
39
40 //#define DEBUG_VGA_MEM
41 //#define DEBUG_VGA_REG
42
43 bool have_vga = true;
44
45 /* 16 state changes per vertical frame @60 Hz */
46 #define VGA_TEXT_CURSOR_PERIOD_MS (1000 * 2 * 16 / 60)
47
48 /*
49 * Video Graphics Array (VGA)
50 *
51 * Chipset docs for original IBM VGA:
52 * http://www.mcamafia.de/pdf/ibm_vgaxga_trm2.pdf
53 *
54 * FreeVGA site:
55 * http://www.osdever.net/FreeVGA/home.htm
56 *
57 * Standard VGA features and Bochs VBE extensions are implemented.
58 */
59
60 /* force some bits to zero */
61 const uint8_t sr_mask[8] = {
62 0x03,
63 0x3d,
64 0x0f,
65 0x3f,
66 0x0e,
67 0x00,
68 0x00,
69 0xff,
70 };
71
72 const uint8_t gr_mask[16] = {
73 0x0f, /* 0x00 */
74 0x0f, /* 0x01 */
75 0x0f, /* 0x02 */
76 0x1f, /* 0x03 */
77 0x03, /* 0x04 */
78 0x7b, /* 0x05 */
79 0x0f, /* 0x06 */
80 0x0f, /* 0x07 */
81 0xff, /* 0x08 */
82 0x00, /* 0x09 */
83 0x00, /* 0x0a */
84 0x00, /* 0x0b */
85 0x00, /* 0x0c */
86 0x00, /* 0x0d */
87 0x00, /* 0x0e */
88 0x00, /* 0x0f */
89 };
90
91 #define cbswap_32(__x) \
92 ((uint32_t)( \
93 (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
94 (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) << 8) | \
95 (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >> 8) | \
96 (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) ))
97
98 #if HOST_BIG_ENDIAN
99 #define PAT(x) cbswap_32(x)
100 #else
101 #define PAT(x) (x)
102 #endif
103
104 #if HOST_BIG_ENDIAN
105 #define BIG 1
106 #else
107 #define BIG 0
108 #endif
109
110 #if HOST_BIG_ENDIAN
111 #define GET_PLANE(data, p) (((data) >> (24 - (p) * 8)) & 0xff)
112 #else
113 #define GET_PLANE(data, p) (((data) >> ((p) * 8)) & 0xff)
114 #endif
115
116 static const uint32_t mask16[16] = {
117 PAT(0x00000000),
118 PAT(0x000000ff),
119 PAT(0x0000ff00),
120 PAT(0x0000ffff),
121 PAT(0x00ff0000),
122 PAT(0x00ff00ff),
123 PAT(0x00ffff00),
124 PAT(0x00ffffff),
125 PAT(0xff000000),
126 PAT(0xff0000ff),
127 PAT(0xff00ff00),
128 PAT(0xff00ffff),
129 PAT(0xffff0000),
130 PAT(0xffff00ff),
131 PAT(0xffffff00),
132 PAT(0xffffffff),
133 };
134
135 #undef PAT
136
137 #if HOST_BIG_ENDIAN
138 #define PAT(x) (x)
139 #else
140 #define PAT(x) cbswap_32(x)
141 #endif
142
143 static uint32_t expand4[256];
144 static uint16_t expand2[256];
145 static uint8_t expand4to8[16];
146
147 static void vbe_update_vgaregs(VGACommonState *s);
148
149 static inline bool vbe_enabled(VGACommonState *s)
150 {
151 return s->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED;
152 }
153
154 static inline uint8_t sr(VGACommonState *s, int idx)
155 {
156 return vbe_enabled(s) ? s->sr_vbe[idx] : s->sr[idx];
157 }
158
159 static void vga_update_memory_access(VGACommonState *s)
160 {
161 hwaddr base, offset, size;
162
163 if (s->legacy_address_space == NULL) {
164 return;
165 }
166
167 if (s->has_chain4_alias) {
168 memory_region_del_subregion(s->legacy_address_space, &s->chain4_alias);
169 object_unparent(OBJECT(&s->chain4_alias));
170 s->has_chain4_alias = false;
171 s->plane_updated = 0xf;
172 }
173 if ((sr(s, VGA_SEQ_PLANE_WRITE) & VGA_SR02_ALL_PLANES) ==
174 VGA_SR02_ALL_PLANES && sr(s, VGA_SEQ_MEMORY_MODE) & VGA_SR04_CHN_4M) {
175 offset = 0;
176 switch ((s->gr[VGA_GFX_MISC] >> 2) & 3) {
177 case 0:
178 base = 0xa0000;
179 size = 0x20000;
180 break;
181 case 1:
182 base = 0xa0000;
183 size = 0x10000;
184 offset = s->bank_offset;
185 break;
186 case 2:
187 base = 0xb0000;
188 size = 0x8000;
189 break;
190 case 3:
191 default:
192 base = 0xb8000;
193 size = 0x8000;
194 break;
195 }
196 assert(offset + size <= s->vram_size);
197 memory_region_init_alias(&s->chain4_alias, memory_region_owner(&s->vram),
198 "vga.chain4", &s->vram, offset, size);
199 memory_region_add_subregion_overlap(s->legacy_address_space, base,
200 &s->chain4_alias, 2);
201 s->has_chain4_alias = true;
202 }
203 }
204
205 static void vga_dumb_update_retrace_info(VGACommonState *s)
206 {
207 (void) s;
208 }
209
210 static void vga_precise_update_retrace_info(VGACommonState *s)
211 {
212 int htotal_chars;
213 int hretr_start_char;
214 int hretr_skew_chars;
215 int hretr_end_char;
216
217 int vtotal_lines;
218 int vretr_start_line;
219 int vretr_end_line;
220
221 int dots;
222 #if 0
223 int div2, sldiv2;
224 #endif
225 int clocking_mode;
226 int clock_sel;
227 const int clk_hz[] = {25175000, 28322000, 25175000, 25175000};
228 int64_t chars_per_sec;
229 struct vga_precise_retrace *r = &s->retrace_info.precise;
230
231 htotal_chars = s->cr[VGA_CRTC_H_TOTAL] + 5;
232 hretr_start_char = s->cr[VGA_CRTC_H_SYNC_START];
233 hretr_skew_chars = (s->cr[VGA_CRTC_H_SYNC_END] >> 5) & 3;
234 hretr_end_char = s->cr[VGA_CRTC_H_SYNC_END] & 0x1f;
235
236 vtotal_lines = (s->cr[VGA_CRTC_V_TOTAL] |
237 (((s->cr[VGA_CRTC_OVERFLOW] & 1) |
238 ((s->cr[VGA_CRTC_OVERFLOW] >> 4) & 2)) << 8)) + 2;
239 vretr_start_line = s->cr[VGA_CRTC_V_SYNC_START] |
240 ((((s->cr[VGA_CRTC_OVERFLOW] >> 2) & 1) |
241 ((s->cr[VGA_CRTC_OVERFLOW] >> 6) & 2)) << 8);
242 vretr_end_line = s->cr[VGA_CRTC_V_SYNC_END] & 0xf;
243
244 clocking_mode = (sr(s, VGA_SEQ_CLOCK_MODE) >> 3) & 1;
245 clock_sel = (s->msr >> 2) & 3;
246 dots = (s->msr & 1) ? 8 : 9;
247
248 chars_per_sec = clk_hz[clock_sel] / dots;
249
250 htotal_chars <<= clocking_mode;
251
252 r->total_chars = vtotal_lines * htotal_chars;
253 if (r->freq) {
254 r->ticks_per_char = NANOSECONDS_PER_SECOND / (r->total_chars * r->freq);
255 } else {
256 r->ticks_per_char = NANOSECONDS_PER_SECOND / chars_per_sec;
257 }
258
259 r->vstart = vretr_start_line;
260 r->vend = r->vstart + vretr_end_line + 1;
261
262 r->hstart = hretr_start_char + hretr_skew_chars;
263 r->hend = r->hstart + hretr_end_char + 1;
264 r->htotal = htotal_chars;
265
266 #if 0
267 div2 = (s->cr[VGA_CRTC_MODE] >> 2) & 1;
268 sldiv2 = (s->cr[VGA_CRTC_MODE] >> 3) & 1;
269 printf (
270 "hz=%f\n"
271 "htotal = %d\n"
272 "hretr_start = %d\n"
273 "hretr_skew = %d\n"
274 "hretr_end = %d\n"
275 "vtotal = %d\n"
276 "vretr_start = %d\n"
277 "vretr_end = %d\n"
278 "div2 = %d sldiv2 = %d\n"
279 "clocking_mode = %d\n"
280 "clock_sel = %d %d\n"
281 "dots = %d\n"
282 "ticks/char = %" PRId64 "\n"
283 "\n",
284 (double) NANOSECONDS_PER_SECOND / (r->ticks_per_char * r->total_chars),
285 htotal_chars,
286 hretr_start_char,
287 hretr_skew_chars,
288 hretr_end_char,
289 vtotal_lines,
290 vretr_start_line,
291 vretr_end_line,
292 div2, sldiv2,
293 clocking_mode,
294 clock_sel,
295 clk_hz[clock_sel],
296 dots,
297 r->ticks_per_char
298 );
299 #endif
300 }
301
302 static uint8_t vga_precise_retrace(VGACommonState *s)
303 {
304 struct vga_precise_retrace *r = &s->retrace_info.precise;
305 uint8_t val = s->st01 & ~(ST01_V_RETRACE | ST01_DISP_ENABLE);
306
307 if (r->total_chars) {
308 int cur_line, cur_line_char, cur_char;
309 int64_t cur_tick;
310
311 cur_tick = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
312
313 cur_char = (cur_tick / r->ticks_per_char) % r->total_chars;
314 cur_line = cur_char / r->htotal;
315
316 if (cur_line >= r->vstart && cur_line <= r->vend) {
317 val |= ST01_V_RETRACE | ST01_DISP_ENABLE;
318 } else {
319 cur_line_char = cur_char % r->htotal;
320 if (cur_line_char >= r->hstart && cur_line_char <= r->hend) {
321 val |= ST01_DISP_ENABLE;
322 }
323 }
324
325 return val;
326 } else {
327 return s->st01 ^ (ST01_V_RETRACE | ST01_DISP_ENABLE);
328 }
329 }
330
331 static uint8_t vga_dumb_retrace(VGACommonState *s)
332 {
333 return s->st01 ^ (ST01_V_RETRACE | ST01_DISP_ENABLE);
334 }
335
336 int vga_ioport_invalid(VGACommonState *s, uint32_t addr)
337 {
338 if (s->msr & VGA_MIS_COLOR) {
339 /* Color */
340 return (addr >= 0x3b0 && addr <= 0x3bf);
341 } else {
342 /* Monochrome */
343 return (addr >= 0x3d0 && addr <= 0x3df);
344 }
345 }
346
347 uint32_t vga_ioport_read(void *opaque, uint32_t addr)
348 {
349 VGACommonState *s = opaque;
350 int val, index;
351
352 if (vga_ioport_invalid(s, addr)) {
353 val = 0xff;
354 } else {
355 switch(addr) {
356 case VGA_ATT_W:
357 if (s->ar_flip_flop == 0) {
358 val = s->ar_index;
359 } else {
360 val = 0;
361 }
362 break;
363 case VGA_ATT_R:
364 index = s->ar_index & 0x1f;
365 if (index < VGA_ATT_C) {
366 val = s->ar[index];
367 } else {
368 val = 0;
369 }
370 break;
371 case VGA_MIS_W:
372 val = s->st00;
373 break;
374 case VGA_SEQ_I:
375 val = s->sr_index;
376 break;
377 case VGA_SEQ_D:
378 val = s->sr[s->sr_index];
379 #ifdef DEBUG_VGA_REG
380 printf("vga: read SR%x = 0x%02x\n", s->sr_index, val);
381 #endif
382 break;
383 case VGA_PEL_IR:
384 val = s->dac_state;
385 break;
386 case VGA_PEL_IW:
387 val = s->dac_write_index;
388 break;
389 case VGA_PEL_D:
390 val = s->palette[s->dac_read_index * 3 + s->dac_sub_index];
391 if (++s->dac_sub_index == 3) {
392 s->dac_sub_index = 0;
393 s->dac_read_index++;
394 }
395 break;
396 case VGA_FTC_R:
397 val = s->fcr;
398 break;
399 case VGA_MIS_R:
400 val = s->msr;
401 break;
402 case VGA_GFX_I:
403 val = s->gr_index;
404 break;
405 case VGA_GFX_D:
406 val = s->gr[s->gr_index];
407 #ifdef DEBUG_VGA_REG
408 printf("vga: read GR%x = 0x%02x\n", s->gr_index, val);
409 #endif
410 break;
411 case VGA_CRT_IM:
412 case VGA_CRT_IC:
413 val = s->cr_index;
414 break;
415 case VGA_CRT_DM:
416 case VGA_CRT_DC:
417 val = s->cr[s->cr_index];
418 #ifdef DEBUG_VGA_REG
419 printf("vga: read CR%x = 0x%02x\n", s->cr_index, val);
420 #endif
421 break;
422 case VGA_IS1_RM:
423 case VGA_IS1_RC:
424 /* just toggle to fool polling */
425 val = s->st01 = s->retrace(s);
426 s->ar_flip_flop = 0;
427 break;
428 default:
429 val = 0x00;
430 break;
431 }
432 }
433 trace_vga_std_read_io(addr, val);
434 return val;
435 }
436
437 void vga_ioport_write(void *opaque, uint32_t addr, uint32_t val)
438 {
439 VGACommonState *s = opaque;
440 int index;
441
442 /* check port range access depending on color/monochrome mode */
443 if (vga_ioport_invalid(s, addr)) {
444 return;
445 }
446 trace_vga_std_write_io(addr, val);
447
448 switch(addr) {
449 case VGA_ATT_W:
450 if (s->ar_flip_flop == 0) {
451 val &= 0x3f;
452 s->ar_index = val;
453 } else {
454 index = s->ar_index & 0x1f;
455 switch(index) {
456 case VGA_ATC_PALETTE0 ... VGA_ATC_PALETTEF:
457 s->ar[index] = val & 0x3f;
458 break;
459 case VGA_ATC_MODE:
460 s->ar[index] = val & ~0x10;
461 break;
462 case VGA_ATC_OVERSCAN:
463 s->ar[index] = val;
464 break;
465 case VGA_ATC_PLANE_ENABLE:
466 s->ar[index] = val & ~0xc0;
467 break;
468 case VGA_ATC_PEL:
469 s->ar[index] = val & ~0xf0;
470 break;
471 case VGA_ATC_COLOR_PAGE:
472 s->ar[index] = val & ~0xf0;
473 break;
474 default:
475 break;
476 }
477 }
478 s->ar_flip_flop ^= 1;
479 break;
480 case VGA_MIS_W:
481 s->msr = val & ~0x10;
482 s->update_retrace_info(s);
483 break;
484 case VGA_SEQ_I:
485 s->sr_index = val & 7;
486 break;
487 case VGA_SEQ_D:
488 #ifdef DEBUG_VGA_REG
489 printf("vga: write SR%x = 0x%02x\n", s->sr_index, val);
490 #endif
491 s->sr[s->sr_index] = val & sr_mask[s->sr_index];
492 if (s->sr_index == VGA_SEQ_CLOCK_MODE) {
493 s->update_retrace_info(s);
494 }
495 vga_update_memory_access(s);
496 break;
497 case VGA_PEL_IR:
498 s->dac_read_index = val;
499 s->dac_sub_index = 0;
500 s->dac_state = 3;
501 break;
502 case VGA_PEL_IW:
503 s->dac_write_index = val;
504 s->dac_sub_index = 0;
505 s->dac_state = 0;
506 break;
507 case VGA_PEL_D:
508 s->dac_cache[s->dac_sub_index] = val;
509 if (++s->dac_sub_index == 3) {
510 memcpy(&s->palette[s->dac_write_index * 3], s->dac_cache, 3);
511 s->dac_sub_index = 0;
512 s->dac_write_index++;
513 }
514 break;
515 case VGA_GFX_I:
516 s->gr_index = val & 0x0f;
517 break;
518 case VGA_GFX_D:
519 #ifdef DEBUG_VGA_REG
520 printf("vga: write GR%x = 0x%02x\n", s->gr_index, val);
521 #endif
522 s->gr[s->gr_index] = val & gr_mask[s->gr_index];
523 vbe_update_vgaregs(s);
524 vga_update_memory_access(s);
525 break;
526 case VGA_CRT_IM:
527 case VGA_CRT_IC:
528 s->cr_index = val;
529 break;
530 case VGA_CRT_DM:
531 case VGA_CRT_DC:
532 #ifdef DEBUG_VGA_REG
533 printf("vga: write CR%x = 0x%02x\n", s->cr_index, val);
534 #endif
535 /* handle CR0-7 protection */
536 if ((s->cr[VGA_CRTC_V_SYNC_END] & VGA_CR11_LOCK_CR0_CR7) &&
537 s->cr_index <= VGA_CRTC_OVERFLOW) {
538 /* can always write bit 4 of CR7 */
539 if (s->cr_index == VGA_CRTC_OVERFLOW) {
540 s->cr[VGA_CRTC_OVERFLOW] = (s->cr[VGA_CRTC_OVERFLOW] & ~0x10) |
541 (val & 0x10);
542 vbe_update_vgaregs(s);
543 }
544 return;
545 }
546 s->cr[s->cr_index] = val;
547 vbe_update_vgaregs(s);
548
549 switch(s->cr_index) {
550 case VGA_CRTC_H_TOTAL:
551 case VGA_CRTC_H_SYNC_START:
552 case VGA_CRTC_H_SYNC_END:
553 case VGA_CRTC_V_TOTAL:
554 case VGA_CRTC_OVERFLOW:
555 case VGA_CRTC_V_SYNC_END:
556 case VGA_CRTC_MODE:
557 s->update_retrace_info(s);
558 break;
559 }
560 break;
561 case VGA_IS1_RM:
562 case VGA_IS1_RC:
563 s->fcr = val & 0x10;
564 break;
565 }
566 }
567
568 /*
569 * Sanity check vbe register writes.
570 *
571 * As we don't have a way to signal errors to the guest in the bochs
572 * dispi interface we'll go adjust the registers to the closest valid
573 * value.
574 */
575 static void vbe_fixup_regs(VGACommonState *s)
576 {
577 uint16_t *r = s->vbe_regs;
578 uint32_t bits, linelength, maxy, offset;
579
580 if (!vbe_enabled(s)) {
581 /* vbe is turned off -- nothing to do */
582 return;
583 }
584
585 /* check depth */
586 switch (r[VBE_DISPI_INDEX_BPP]) {
587 case 4:
588 case 8:
589 case 16:
590 case 24:
591 case 32:
592 bits = r[VBE_DISPI_INDEX_BPP];
593 break;
594 case 15:
595 bits = 16;
596 break;
597 default:
598 bits = r[VBE_DISPI_INDEX_BPP] = 8;
599 break;
600 }
601
602 /* check width */
603 r[VBE_DISPI_INDEX_XRES] &= ~7u;
604 if (r[VBE_DISPI_INDEX_XRES] == 0) {
605 r[VBE_DISPI_INDEX_XRES] = 8;
606 }
607 if (r[VBE_DISPI_INDEX_XRES] > VBE_DISPI_MAX_XRES) {
608 r[VBE_DISPI_INDEX_XRES] = VBE_DISPI_MAX_XRES;
609 }
610 r[VBE_DISPI_INDEX_VIRT_WIDTH] &= ~7u;
611 if (r[VBE_DISPI_INDEX_VIRT_WIDTH] > VBE_DISPI_MAX_XRES) {
612 r[VBE_DISPI_INDEX_VIRT_WIDTH] = VBE_DISPI_MAX_XRES;
613 }
614 if (r[VBE_DISPI_INDEX_VIRT_WIDTH] < r[VBE_DISPI_INDEX_XRES]) {
615 r[VBE_DISPI_INDEX_VIRT_WIDTH] = r[VBE_DISPI_INDEX_XRES];
616 }
617
618 /* check height */
619 linelength = r[VBE_DISPI_INDEX_VIRT_WIDTH] * bits / 8;
620 maxy = s->vbe_size / linelength;
621 if (r[VBE_DISPI_INDEX_YRES] == 0) {
622 r[VBE_DISPI_INDEX_YRES] = 1;
623 }
624 if (r[VBE_DISPI_INDEX_YRES] > VBE_DISPI_MAX_YRES) {
625 r[VBE_DISPI_INDEX_YRES] = VBE_DISPI_MAX_YRES;
626 }
627 if (r[VBE_DISPI_INDEX_YRES] > maxy) {
628 r[VBE_DISPI_INDEX_YRES] = maxy;
629 }
630
631 /* check offset */
632 if (r[VBE_DISPI_INDEX_X_OFFSET] > VBE_DISPI_MAX_XRES) {
633 r[VBE_DISPI_INDEX_X_OFFSET] = VBE_DISPI_MAX_XRES;
634 }
635 if (r[VBE_DISPI_INDEX_Y_OFFSET] > VBE_DISPI_MAX_YRES) {
636 r[VBE_DISPI_INDEX_Y_OFFSET] = VBE_DISPI_MAX_YRES;
637 }
638 offset = r[VBE_DISPI_INDEX_X_OFFSET] * bits / 8;
639 offset += r[VBE_DISPI_INDEX_Y_OFFSET] * linelength;
640 if (offset + r[VBE_DISPI_INDEX_YRES] * linelength > s->vbe_size) {
641 r[VBE_DISPI_INDEX_Y_OFFSET] = 0;
642 offset = r[VBE_DISPI_INDEX_X_OFFSET] * bits / 8;
643 if (offset + r[VBE_DISPI_INDEX_YRES] * linelength > s->vbe_size) {
644 r[VBE_DISPI_INDEX_X_OFFSET] = 0;
645 offset = 0;
646 }
647 }
648
649 /* update vga state */
650 r[VBE_DISPI_INDEX_VIRT_HEIGHT] = maxy;
651 s->vbe_line_offset = linelength;
652 s->vbe_start_addr = offset / 4;
653 }
654
655 /* we initialize the VGA graphic mode */
656 static void vbe_update_vgaregs(VGACommonState *s)
657 {
658 int h, shift_control;
659
660 if (!vbe_enabled(s)) {
661 /* vbe is turned off -- nothing to do */
662 return;
663 }
664
665 /* graphic mode + memory map 1 */
666 s->gr[VGA_GFX_MISC] = (s->gr[VGA_GFX_MISC] & ~0x0c) | 0x04 |
667 VGA_GR06_GRAPHICS_MODE;
668 s->cr[VGA_CRTC_MODE] |= 3; /* no CGA modes */
669 s->cr[VGA_CRTC_OFFSET] = s->vbe_line_offset >> 3;
670 /* width */
671 s->cr[VGA_CRTC_H_DISP] =
672 (s->vbe_regs[VBE_DISPI_INDEX_XRES] >> 3) - 1;
673 /* height (only meaningful if < 1024) */
674 h = s->vbe_regs[VBE_DISPI_INDEX_YRES] - 1;
675 s->cr[VGA_CRTC_V_DISP_END] = h;
676 s->cr[VGA_CRTC_OVERFLOW] = (s->cr[VGA_CRTC_OVERFLOW] & ~0x42) |
677 ((h >> 7) & 0x02) | ((h >> 3) & 0x40);
678 /* line compare to 1023 */
679 s->cr[VGA_CRTC_LINE_COMPARE] = 0xff;
680 s->cr[VGA_CRTC_OVERFLOW] |= 0x10;
681 s->cr[VGA_CRTC_MAX_SCAN] |= 0x40;
682
683 if (s->vbe_regs[VBE_DISPI_INDEX_BPP] == 4) {
684 shift_control = 0;
685 s->sr_vbe[VGA_SEQ_CLOCK_MODE] &= ~8; /* no double line */
686 } else {
687 shift_control = 2;
688 /* set chain 4 mode */
689 s->sr_vbe[VGA_SEQ_MEMORY_MODE] |= VGA_SR04_CHN_4M;
690 /* activate all planes */
691 s->sr_vbe[VGA_SEQ_PLANE_WRITE] |= VGA_SR02_ALL_PLANES;
692 }
693 s->gr[VGA_GFX_MODE] = (s->gr[VGA_GFX_MODE] & ~0x60) |
694 (shift_control << 5);
695 s->cr[VGA_CRTC_MAX_SCAN] &= ~0x9f; /* no double scan */
696 }
697
698 static uint32_t vbe_ioport_read_index(void *opaque, uint32_t addr)
699 {
700 VGACommonState *s = opaque;
701 return s->vbe_index;
702 }
703
704 uint32_t vbe_ioport_read_data(void *opaque, uint32_t addr)
705 {
706 VGACommonState *s = opaque;
707 uint32_t val;
708
709 if (s->vbe_index < VBE_DISPI_INDEX_NB) {
710 if (s->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_GETCAPS) {
711 switch(s->vbe_index) {
712 /* XXX: do not hardcode ? */
713 case VBE_DISPI_INDEX_XRES:
714 val = VBE_DISPI_MAX_XRES;
715 break;
716 case VBE_DISPI_INDEX_YRES:
717 val = VBE_DISPI_MAX_YRES;
718 break;
719 case VBE_DISPI_INDEX_BPP:
720 val = VBE_DISPI_MAX_BPP;
721 break;
722 default:
723 val = s->vbe_regs[s->vbe_index];
724 break;
725 }
726 } else {
727 val = s->vbe_regs[s->vbe_index];
728 }
729 } else if (s->vbe_index == VBE_DISPI_INDEX_VIDEO_MEMORY_64K) {
730 val = s->vbe_size / (64 * KiB);
731 } else {
732 val = 0;
733 }
734 trace_vga_vbe_read(s->vbe_index, val);
735 return val;
736 }
737
738 void vbe_ioport_write_index(void *opaque, uint32_t addr, uint32_t val)
739 {
740 VGACommonState *s = opaque;
741 s->vbe_index = val;
742 }
743
744 void vbe_ioport_write_data(void *opaque, uint32_t addr, uint32_t val)
745 {
746 VGACommonState *s = opaque;
747
748 if (s->vbe_index <= VBE_DISPI_INDEX_NB) {
749 trace_vga_vbe_write(s->vbe_index, val);
750 switch(s->vbe_index) {
751 case VBE_DISPI_INDEX_ID:
752 if (val == VBE_DISPI_ID0 ||
753 val == VBE_DISPI_ID1 ||
754 val == VBE_DISPI_ID2 ||
755 val == VBE_DISPI_ID3 ||
756 val == VBE_DISPI_ID4 ||
757 val == VBE_DISPI_ID5) {
758 s->vbe_regs[s->vbe_index] = val;
759 }
760 break;
761 case VBE_DISPI_INDEX_XRES:
762 case VBE_DISPI_INDEX_YRES:
763 case VBE_DISPI_INDEX_BPP:
764 case VBE_DISPI_INDEX_VIRT_WIDTH:
765 case VBE_DISPI_INDEX_X_OFFSET:
766 case VBE_DISPI_INDEX_Y_OFFSET:
767 s->vbe_regs[s->vbe_index] = val;
768 vbe_fixup_regs(s);
769 vbe_update_vgaregs(s);
770 break;
771 case VBE_DISPI_INDEX_BANK:
772 val &= s->vbe_bank_mask;
773 s->vbe_regs[s->vbe_index] = val;
774 s->bank_offset = (val << 16);
775 vga_update_memory_access(s);
776 break;
777 case VBE_DISPI_INDEX_ENABLE:
778 if ((val & VBE_DISPI_ENABLED) &&
779 !(s->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED)) {
780
781 s->vbe_regs[VBE_DISPI_INDEX_VIRT_WIDTH] = 0;
782 s->vbe_regs[VBE_DISPI_INDEX_X_OFFSET] = 0;
783 s->vbe_regs[VBE_DISPI_INDEX_Y_OFFSET] = 0;
784 s->vbe_regs[VBE_DISPI_INDEX_ENABLE] |= VBE_DISPI_ENABLED;
785 vbe_fixup_regs(s);
786 vbe_update_vgaregs(s);
787
788 /* clear the screen */
789 if (!(val & VBE_DISPI_NOCLEARMEM)) {
790 memset(s->vram_ptr, 0,
791 s->vbe_regs[VBE_DISPI_INDEX_YRES] * s->vbe_line_offset);
792 }
793 } else {
794 s->bank_offset = 0;
795 }
796 s->dac_8bit = (val & VBE_DISPI_8BIT_DAC) > 0;
797 s->vbe_regs[s->vbe_index] = val;
798 vga_update_memory_access(s);
799 break;
800 default:
801 break;
802 }
803 }
804 }
805
806 /* called for accesses between 0xa0000 and 0xc0000 */
807 uint32_t vga_mem_readb(VGACommonState *s, hwaddr addr)
808 {
809 int memory_map_mode, plane;
810 uint32_t ret;
811
812 /* convert to VGA memory offset */
813 memory_map_mode = (s->gr[VGA_GFX_MISC] >> 2) & 3;
814 addr &= 0x1ffff;
815 switch(memory_map_mode) {
816 case 0:
817 break;
818 case 1:
819 if (addr >= 0x10000)
820 return 0xff;
821 addr += s->bank_offset;
822 break;
823 case 2:
824 addr -= 0x10000;
825 if (addr >= 0x8000)
826 return 0xff;
827 break;
828 default:
829 case 3:
830 addr -= 0x18000;
831 if (addr >= 0x8000)
832 return 0xff;
833 break;
834 }
835
836 if (sr(s, VGA_SEQ_MEMORY_MODE) & VGA_SR04_CHN_4M) {
837 /* chain 4 mode : simplest access */
838 assert(addr < s->vram_size);
839 ret = s->vram_ptr[addr];
840 } else if (s->gr[VGA_GFX_MODE] & 0x10) {
841 /* odd/even mode (aka text mode mapping) */
842 plane = (s->gr[VGA_GFX_PLANE_READ] & 2) | (addr & 1);
843 addr = ((addr & ~1) << 1) | plane;
844 if (addr >= s->vram_size) {
845 return 0xff;
846 }
847 ret = s->vram_ptr[addr];
848 } else {
849 /* standard VGA latched access */
850 if (addr * sizeof(uint32_t) >= s->vram_size) {
851 return 0xff;
852 }
853 s->latch = ((uint32_t *)s->vram_ptr)[addr];
854
855 if (!(s->gr[VGA_GFX_MODE] & 0x08)) {
856 /* read mode 0 */
857 plane = s->gr[VGA_GFX_PLANE_READ];
858 ret = GET_PLANE(s->latch, plane);
859 } else {
860 /* read mode 1 */
861 ret = (s->latch ^ mask16[s->gr[VGA_GFX_COMPARE_VALUE]]) &
862 mask16[s->gr[VGA_GFX_COMPARE_MASK]];
863 ret |= ret >> 16;
864 ret |= ret >> 8;
865 ret = (~ret) & 0xff;
866 }
867 }
868 return ret;
869 }
870
871 /* called for accesses between 0xa0000 and 0xc0000 */
872 void vga_mem_writeb(VGACommonState *s, hwaddr addr, uint32_t val)
873 {
874 int memory_map_mode, plane, write_mode, b, func_select, mask;
875 uint32_t write_mask, bit_mask, set_mask;
876
877 #ifdef DEBUG_VGA_MEM
878 printf("vga: [0x" HWADDR_FMT_plx "] = 0x%02x\n", addr, val);
879 #endif
880 /* convert to VGA memory offset */
881 memory_map_mode = (s->gr[VGA_GFX_MISC] >> 2) & 3;
882 addr &= 0x1ffff;
883 switch(memory_map_mode) {
884 case 0:
885 break;
886 case 1:
887 if (addr >= 0x10000)
888 return;
889 addr += s->bank_offset;
890 break;
891 case 2:
892 addr -= 0x10000;
893 if (addr >= 0x8000)
894 return;
895 break;
896 default:
897 case 3:
898 addr -= 0x18000;
899 if (addr >= 0x8000)
900 return;
901 break;
902 }
903
904 if (sr(s, VGA_SEQ_MEMORY_MODE) & VGA_SR04_CHN_4M) {
905 /* chain 4 mode : simplest access */
906 plane = addr & 3;
907 mask = (1 << plane);
908 if (sr(s, VGA_SEQ_PLANE_WRITE) & mask) {
909 assert(addr < s->vram_size);
910 s->vram_ptr[addr] = val;
911 #ifdef DEBUG_VGA_MEM
912 printf("vga: chain4: [0x" HWADDR_FMT_plx "]\n", addr);
913 #endif
914 s->plane_updated |= mask; /* only used to detect font change */
915 memory_region_set_dirty(&s->vram, addr, 1);
916 }
917 } else if (s->gr[VGA_GFX_MODE] & 0x10) {
918 /* odd/even mode (aka text mode mapping) */
919 plane = (s->gr[VGA_GFX_PLANE_READ] & 2) | (addr & 1);
920 mask = (1 << plane);
921 if (sr(s, VGA_SEQ_PLANE_WRITE) & mask) {
922 addr = ((addr & ~1) << 1) | plane;
923 if (addr >= s->vram_size) {
924 return;
925 }
926 s->vram_ptr[addr] = val;
927 #ifdef DEBUG_VGA_MEM
928 printf("vga: odd/even: [0x" HWADDR_FMT_plx "]\n", addr);
929 #endif
930 s->plane_updated |= mask; /* only used to detect font change */
931 memory_region_set_dirty(&s->vram, addr, 1);
932 }
933 } else {
934 /* standard VGA latched access */
935 write_mode = s->gr[VGA_GFX_MODE] & 3;
936 switch(write_mode) {
937 default:
938 case 0:
939 /* rotate */
940 b = s->gr[VGA_GFX_DATA_ROTATE] & 7;
941 val = ((val >> b) | (val << (8 - b))) & 0xff;
942 val |= val << 8;
943 val |= val << 16;
944
945 /* apply set/reset mask */
946 set_mask = mask16[s->gr[VGA_GFX_SR_ENABLE]];
947 val = (val & ~set_mask) |
948 (mask16[s->gr[VGA_GFX_SR_VALUE]] & set_mask);
949 bit_mask = s->gr[VGA_GFX_BIT_MASK];
950 break;
951 case 1:
952 val = s->latch;
953 goto do_write;
954 case 2:
955 val = mask16[val & 0x0f];
956 bit_mask = s->gr[VGA_GFX_BIT_MASK];
957 break;
958 case 3:
959 /* rotate */
960 b = s->gr[VGA_GFX_DATA_ROTATE] & 7;
961 val = (val >> b) | (val << (8 - b));
962
963 bit_mask = s->gr[VGA_GFX_BIT_MASK] & val;
964 val = mask16[s->gr[VGA_GFX_SR_VALUE]];
965 break;
966 }
967
968 /* apply logical operation */
969 func_select = s->gr[VGA_GFX_DATA_ROTATE] >> 3;
970 switch(func_select) {
971 case 0:
972 default:
973 /* nothing to do */
974 break;
975 case 1:
976 /* and */
977 val &= s->latch;
978 break;
979 case 2:
980 /* or */
981 val |= s->latch;
982 break;
983 case 3:
984 /* xor */
985 val ^= s->latch;
986 break;
987 }
988
989 /* apply bit mask */
990 bit_mask |= bit_mask << 8;
991 bit_mask |= bit_mask << 16;
992 val = (val & bit_mask) | (s->latch & ~bit_mask);
993
994 do_write:
995 /* mask data according to sr[2] */
996 mask = sr(s, VGA_SEQ_PLANE_WRITE);
997 s->plane_updated |= mask; /* only used to detect font change */
998 write_mask = mask16[mask];
999 if (addr * sizeof(uint32_t) >= s->vram_size) {
1000 return;
1001 }
1002 ((uint32_t *)s->vram_ptr)[addr] =
1003 (((uint32_t *)s->vram_ptr)[addr] & ~write_mask) |
1004 (val & write_mask);
1005 #ifdef DEBUG_VGA_MEM
1006 printf("vga: latch: [0x" HWADDR_FMT_plx "] mask=0x%08x val=0x%08x\n",
1007 addr * 4, write_mask, val);
1008 #endif
1009 memory_region_set_dirty(&s->vram, addr << 2, sizeof(uint32_t));
1010 }
1011 }
1012
1013 typedef void vga_draw_line_func(VGACommonState *s1, uint8_t *d,
1014 uint32_t srcaddr, int width);
1015
1016 #include "vga-access.h"
1017 #include "vga-helpers.h"
1018
1019 /* return true if the palette was modified */
1020 static int update_palette16(VGACommonState *s)
1021 {
1022 int full_update, i;
1023 uint32_t v, col, *palette;
1024
1025 full_update = 0;
1026 palette = s->last_palette;
1027 for(i = 0; i < 16; i++) {
1028 v = s->ar[i];
1029 if (s->ar[VGA_ATC_MODE] & 0x80) {
1030 v = ((s->ar[VGA_ATC_COLOR_PAGE] & 0xf) << 4) | (v & 0xf);
1031 } else {
1032 v = ((s->ar[VGA_ATC_COLOR_PAGE] & 0xc) << 4) | (v & 0x3f);
1033 }
1034 v = v * 3;
1035 col = rgb_to_pixel32(c6_to_8(s->palette[v]),
1036 c6_to_8(s->palette[v + 1]),
1037 c6_to_8(s->palette[v + 2]));
1038 if (col != palette[i]) {
1039 full_update = 1;
1040 palette[i] = col;
1041 }
1042 }
1043 return full_update;
1044 }
1045
1046 /* return true if the palette was modified */
1047 static int update_palette256(VGACommonState *s)
1048 {
1049 int full_update, i;
1050 uint32_t v, col, *palette;
1051
1052 full_update = 0;
1053 palette = s->last_palette;
1054 v = 0;
1055 for(i = 0; i < 256; i++) {
1056 if (s->dac_8bit) {
1057 col = rgb_to_pixel32(s->palette[v],
1058 s->palette[v + 1],
1059 s->palette[v + 2]);
1060 } else {
1061 col = rgb_to_pixel32(c6_to_8(s->palette[v]),
1062 c6_to_8(s->palette[v + 1]),
1063 c6_to_8(s->palette[v + 2]));
1064 }
1065 if (col != palette[i]) {
1066 full_update = 1;
1067 palette[i] = col;
1068 }
1069 v += 3;
1070 }
1071 return full_update;
1072 }
1073
1074 static void vga_get_offsets(VGACommonState *s,
1075 uint32_t *pline_offset,
1076 uint32_t *pstart_addr,
1077 uint32_t *pline_compare)
1078 {
1079 uint32_t start_addr, line_offset, line_compare;
1080
1081 if (vbe_enabled(s)) {
1082 line_offset = s->vbe_line_offset;
1083 start_addr = s->vbe_start_addr;
1084 line_compare = 65535;
1085 } else {
1086 /* compute line_offset in bytes */
1087 line_offset = s->cr[VGA_CRTC_OFFSET];
1088 line_offset <<= 3;
1089
1090 /* starting address */
1091 start_addr = s->cr[VGA_CRTC_START_LO] |
1092 (s->cr[VGA_CRTC_START_HI] << 8);
1093
1094 /* line compare */
1095 line_compare = s->cr[VGA_CRTC_LINE_COMPARE] |
1096 ((s->cr[VGA_CRTC_OVERFLOW] & 0x10) << 4) |
1097 ((s->cr[VGA_CRTC_MAX_SCAN] & 0x40) << 3);
1098 }
1099 *pline_offset = line_offset;
1100 *pstart_addr = start_addr;
1101 *pline_compare = line_compare;
1102 }
1103
1104 /* update start_addr and line_offset. Return TRUE if modified */
1105 static int update_basic_params(VGACommonState *s)
1106 {
1107 int full_update;
1108 uint32_t start_addr, line_offset, line_compare;
1109
1110 full_update = 0;
1111
1112 s->get_offsets(s, &line_offset, &start_addr, &line_compare);
1113
1114 if (line_offset != s->line_offset ||
1115 start_addr != s->start_addr ||
1116 line_compare != s->line_compare) {
1117 s->line_offset = line_offset;
1118 s->start_addr = start_addr;
1119 s->line_compare = line_compare;
1120 full_update = 1;
1121 }
1122 return full_update;
1123 }
1124
1125
1126 static const uint8_t cursor_glyph[32 * 4] = {
1127 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1128 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1129 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1130 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1131 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1132 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1133 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1134 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1135 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1136 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1137 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1138 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1139 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1140 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1141 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1142 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1143 };
1144
1145 static void vga_get_text_resolution(VGACommonState *s, int *pwidth, int *pheight,
1146 int *pcwidth, int *pcheight)
1147 {
1148 int width, cwidth, height, cheight;
1149
1150 /* total width & height */
1151 cheight = (s->cr[VGA_CRTC_MAX_SCAN] & 0x1f) + 1;
1152 cwidth = 8;
1153 if (!(sr(s, VGA_SEQ_CLOCK_MODE) & VGA_SR01_CHAR_CLK_8DOTS)) {
1154 cwidth = 9;
1155 }
1156 if (sr(s, VGA_SEQ_CLOCK_MODE) & 0x08) {
1157 cwidth = 16; /* NOTE: no 18 pixel wide */
1158 }
1159 width = (s->cr[VGA_CRTC_H_DISP] + 1);
1160 if (s->cr[VGA_CRTC_V_TOTAL] == 100) {
1161 /* ugly hack for CGA 160x100x16 - explain me the logic */
1162 height = 100;
1163 } else {
1164 height = s->cr[VGA_CRTC_V_DISP_END] |
1165 ((s->cr[VGA_CRTC_OVERFLOW] & 0x02) << 7) |
1166 ((s->cr[VGA_CRTC_OVERFLOW] & 0x40) << 3);
1167 height = (height + 1) / cheight;
1168 }
1169
1170 *pwidth = width;
1171 *pheight = height;
1172 *pcwidth = cwidth;
1173 *pcheight = cheight;
1174 }
1175
1176 /*
1177 * Text mode update
1178 * Missing:
1179 * - double scan
1180 * - double width
1181 * - underline
1182 * - flashing
1183 */
1184 static void vga_draw_text(VGACommonState *s, int full_update)
1185 {
1186 DisplaySurface *surface = qemu_console_surface(s->con);
1187 int cx, cy, cheight, cw, ch, cattr, height, width, ch_attr;
1188 int cx_min, cx_max, linesize, x_incr, line, line1;
1189 uint32_t offset, fgcol, bgcol, v, cursor_offset;
1190 uint8_t *d1, *d, *src, *dest, *cursor_ptr;
1191 const uint8_t *font_ptr, *font_base[2];
1192 int dup9, line_offset;
1193 uint32_t *palette;
1194 uint32_t *ch_attr_ptr;
1195 int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);
1196
1197 /* compute font data address (in plane 2) */
1198 v = sr(s, VGA_SEQ_CHARACTER_MAP);
1199 offset = (((v >> 4) & 1) | ((v << 1) & 6)) * 8192 * 4 + 2;
1200 if (offset != s->font_offsets[0]) {
1201 s->font_offsets[0] = offset;
1202 full_update = 1;
1203 }
1204 font_base[0] = s->vram_ptr + offset;
1205
1206 offset = (((v >> 5) & 1) | ((v >> 1) & 6)) * 8192 * 4 + 2;
1207 font_base[1] = s->vram_ptr + offset;
1208 if (offset != s->font_offsets[1]) {
1209 s->font_offsets[1] = offset;
1210 full_update = 1;
1211 }
1212 if (s->plane_updated & (1 << 2) || s->has_chain4_alias) {
1213 /* if the plane 2 was modified since the last display, it
1214 indicates the font may have been modified */
1215 s->plane_updated = 0;
1216 full_update = 1;
1217 }
1218 full_update |= update_basic_params(s);
1219
1220 line_offset = s->line_offset;
1221
1222 vga_get_text_resolution(s, &width, &height, &cw, &cheight);
1223 if ((height * width) <= 1) {
1224 /* better than nothing: exit if transient size is too small */
1225 return;
1226 }
1227 if ((height * width) > CH_ATTR_SIZE) {
1228 /* better than nothing: exit if transient size is too big */
1229 return;
1230 }
1231
1232 if (width != s->last_width || height != s->last_height ||
1233 cw != s->last_cw || cheight != s->last_ch || s->last_depth) {
1234 s->last_scr_width = width * cw;
1235 s->last_scr_height = height * cheight;
1236 qemu_console_resize(s->con, s->last_scr_width, s->last_scr_height);
1237 surface = qemu_console_surface(s->con);
1238 dpy_text_resize(s->con, width, height);
1239 s->last_depth = 0;
1240 s->last_width = width;
1241 s->last_height = height;
1242 s->last_ch = cheight;
1243 s->last_cw = cw;
1244 full_update = 1;
1245 }
1246 full_update |= update_palette16(s);
1247 palette = s->last_palette;
1248 x_incr = cw * surface_bytes_per_pixel(surface);
1249
1250 if (full_update) {
1251 s->full_update_text = 1;
1252 }
1253 if (s->full_update_gfx) {
1254 s->full_update_gfx = 0;
1255 full_update |= 1;
1256 }
1257
1258 cursor_offset = ((s->cr[VGA_CRTC_CURSOR_HI] << 8) |
1259 s->cr[VGA_CRTC_CURSOR_LO]) - s->start_addr;
1260 if (cursor_offset != s->cursor_offset ||
1261 s->cr[VGA_CRTC_CURSOR_START] != s->cursor_start ||
1262 s->cr[VGA_CRTC_CURSOR_END] != s->cursor_end) {
1263 /* if the cursor position changed, we update the old and new
1264 chars */
1265 if (s->cursor_offset < CH_ATTR_SIZE)
1266 s->last_ch_attr[s->cursor_offset] = -1;
1267 if (cursor_offset < CH_ATTR_SIZE)
1268 s->last_ch_attr[cursor_offset] = -1;
1269 s->cursor_offset = cursor_offset;
1270 s->cursor_start = s->cr[VGA_CRTC_CURSOR_START];
1271 s->cursor_end = s->cr[VGA_CRTC_CURSOR_END];
1272 }
1273 cursor_ptr = s->vram_ptr + (s->start_addr + cursor_offset) * 4;
1274 if (now >= s->cursor_blink_time) {
1275 s->cursor_blink_time = now + VGA_TEXT_CURSOR_PERIOD_MS / 2;
1276 s->cursor_visible_phase = !s->cursor_visible_phase;
1277 }
1278
1279 dest = surface_data(surface);
1280 linesize = surface_stride(surface);
1281 ch_attr_ptr = s->last_ch_attr;
1282 line = 0;
1283 offset = s->start_addr * 4;
1284 for(cy = 0; cy < height; cy++) {
1285 d1 = dest;
1286 src = s->vram_ptr + offset;
1287 cx_min = width;
1288 cx_max = -1;
1289 for(cx = 0; cx < width; cx++) {
1290 if (src + sizeof(uint16_t) > s->vram_ptr + s->vram_size) {
1291 break;
1292 }
1293 ch_attr = *(uint16_t *)src;
1294 if (full_update || ch_attr != *ch_attr_ptr || src == cursor_ptr) {
1295 if (cx < cx_min)
1296 cx_min = cx;
1297 if (cx > cx_max)
1298 cx_max = cx;
1299 *ch_attr_ptr = ch_attr;
1300 #if HOST_BIG_ENDIAN
1301 ch = ch_attr >> 8;
1302 cattr = ch_attr & 0xff;
1303 #else
1304 ch = ch_attr & 0xff;
1305 cattr = ch_attr >> 8;
1306 #endif
1307 font_ptr = font_base[(cattr >> 3) & 1];
1308 font_ptr += 32 * 4 * ch;
1309 bgcol = palette[cattr >> 4];
1310 fgcol = palette[cattr & 0x0f];
1311 if (cw == 16) {
1312 vga_draw_glyph16(d1, linesize,
1313 font_ptr, cheight, fgcol, bgcol);
1314 } else if (cw != 9) {
1315 vga_draw_glyph8(d1, linesize,
1316 font_ptr, cheight, fgcol, bgcol);
1317 } else {
1318 dup9 = 0;
1319 if (ch >= 0xb0 && ch <= 0xdf &&
1320 (s->ar[VGA_ATC_MODE] & 0x04)) {
1321 dup9 = 1;
1322 }
1323 vga_draw_glyph9(d1, linesize,
1324 font_ptr, cheight, fgcol, bgcol, dup9);
1325 }
1326 if (src == cursor_ptr &&
1327 !(s->cr[VGA_CRTC_CURSOR_START] & 0x20) &&
1328 s->cursor_visible_phase) {
1329 int line_start, line_last, h;
1330 /* draw the cursor */
1331 line_start = s->cr[VGA_CRTC_CURSOR_START] & 0x1f;
1332 line_last = s->cr[VGA_CRTC_CURSOR_END] & 0x1f;
1333 /* XXX: check that */
1334 if (line_last > cheight - 1)
1335 line_last = cheight - 1;
1336 if (line_last >= line_start && line_start < cheight) {
1337 h = line_last - line_start + 1;
1338 d = d1 + linesize * line_start;
1339 if (cw == 16) {
1340 vga_draw_glyph16(d, linesize,
1341 cursor_glyph, h, fgcol, bgcol);
1342 } else if (cw != 9) {
1343 vga_draw_glyph8(d, linesize,
1344 cursor_glyph, h, fgcol, bgcol);
1345 } else {
1346 vga_draw_glyph9(d, linesize,
1347 cursor_glyph, h, fgcol, bgcol, 1);
1348 }
1349 }
1350 }
1351 }
1352 d1 += x_incr;
1353 src += 4;
1354 ch_attr_ptr++;
1355 }
1356 if (cx_max != -1) {
1357 dpy_gfx_update(s->con, cx_min * cw, cy * cheight,
1358 (cx_max - cx_min + 1) * cw, cheight);
1359 }
1360 dest += linesize * cheight;
1361 line1 = line + cheight;
1362 offset += line_offset;
1363 if (line < s->line_compare && line1 >= s->line_compare) {
1364 offset = 0;
1365 }
1366 line = line1;
1367 }
1368 }
1369
1370 enum {
1371 VGA_DRAW_LINE2,
1372 VGA_DRAW_LINE2D2,
1373 VGA_DRAW_LINE4,
1374 VGA_DRAW_LINE4D2,
1375 VGA_DRAW_LINE8D2,
1376 VGA_DRAW_LINE8,
1377 VGA_DRAW_LINE15_LE,
1378 VGA_DRAW_LINE16_LE,
1379 VGA_DRAW_LINE24_LE,
1380 VGA_DRAW_LINE32_LE,
1381 VGA_DRAW_LINE15_BE,
1382 VGA_DRAW_LINE16_BE,
1383 VGA_DRAW_LINE24_BE,
1384 VGA_DRAW_LINE32_BE,
1385 VGA_DRAW_LINE_NB,
1386 };
1387
1388 static vga_draw_line_func * const vga_draw_line_table[VGA_DRAW_LINE_NB] = {
1389 vga_draw_line2,
1390 vga_draw_line2d2,
1391 vga_draw_line4,
1392 vga_draw_line4d2,
1393 vga_draw_line8d2,
1394 vga_draw_line8,
1395 vga_draw_line15_le,
1396 vga_draw_line16_le,
1397 vga_draw_line24_le,
1398 vga_draw_line32_le,
1399 vga_draw_line15_be,
1400 vga_draw_line16_be,
1401 vga_draw_line24_be,
1402 vga_draw_line32_be,
1403 };
1404
1405 static int vga_get_bpp(VGACommonState *s)
1406 {
1407 int ret;
1408
1409 if (vbe_enabled(s)) {
1410 ret = s->vbe_regs[VBE_DISPI_INDEX_BPP];
1411 } else {
1412 ret = 0;
1413 }
1414 return ret;
1415 }
1416
1417 static void vga_get_resolution(VGACommonState *s, int *pwidth, int *pheight)
1418 {
1419 int width, height;
1420
1421 if (vbe_enabled(s)) {
1422 width = s->vbe_regs[VBE_DISPI_INDEX_XRES];
1423 height = s->vbe_regs[VBE_DISPI_INDEX_YRES];
1424 } else {
1425 width = (s->cr[VGA_CRTC_H_DISP] + 1) * 8;
1426 height = s->cr[VGA_CRTC_V_DISP_END] |
1427 ((s->cr[VGA_CRTC_OVERFLOW] & 0x02) << 7) |
1428 ((s->cr[VGA_CRTC_OVERFLOW] & 0x40) << 3);
1429 height = (height + 1);
1430 }
1431 *pwidth = width;
1432 *pheight = height;
1433 }
1434
1435 void vga_invalidate_scanlines(VGACommonState *s, int y1, int y2)
1436 {
1437 int y;
1438 if (y1 >= VGA_MAX_HEIGHT)
1439 return;
1440 if (y2 >= VGA_MAX_HEIGHT)
1441 y2 = VGA_MAX_HEIGHT;
1442 for(y = y1; y < y2; y++) {
1443 s->invalidated_y_table[y >> 5] |= 1 << (y & 0x1f);
1444 }
1445 }
1446
1447 static bool vga_scanline_invalidated(VGACommonState *s, int y)
1448 {
1449 if (y >= VGA_MAX_HEIGHT) {
1450 return false;
1451 }
1452 return s->invalidated_y_table[y >> 5] & (1 << (y & 0x1f));
1453 }
1454
1455 void vga_dirty_log_start(VGACommonState *s)
1456 {
1457 memory_region_set_log(&s->vram, true, DIRTY_MEMORY_VGA);
1458 }
1459
1460 void vga_dirty_log_stop(VGACommonState *s)
1461 {
1462 memory_region_set_log(&s->vram, false, DIRTY_MEMORY_VGA);
1463 }
1464
1465 /*
1466 * graphic modes
1467 */
1468 static void vga_draw_graphic(VGACommonState *s, int full_update)
1469 {
1470 DisplaySurface *surface = qemu_console_surface(s->con);
1471 int y1, y, update, linesize, y_start, double_scan, mask, depth;
1472 int width, height, shift_control, bwidth, bits;
1473 ram_addr_t page0, page1, region_start, region_end;
1474 DirtyBitmapSnapshot *snap = NULL;
1475 int disp_width, multi_scan, multi_run;
1476 uint8_t *d;
1477 uint32_t v, addr1, addr;
1478 vga_draw_line_func *vga_draw_line = NULL;
1479 bool share_surface, force_shadow = false;
1480 pixman_format_code_t format;
1481 #if HOST_BIG_ENDIAN
1482 bool byteswap = !s->big_endian_fb;
1483 #else
1484 bool byteswap = s->big_endian_fb;
1485 #endif
1486
1487 full_update |= update_basic_params(s);
1488
1489 s->get_resolution(s, &width, &height);
1490 disp_width = width;
1491 depth = s->get_bpp(s);
1492
1493 region_start = (s->start_addr * 4);
1494 region_end = region_start + (ram_addr_t)s->line_offset * height;
1495 region_end += width * depth / 8; /* scanline length */
1496 region_end -= s->line_offset;
1497 if (region_end > s->vbe_size || depth == 0 || depth == 15) {
1498 /*
1499 * We land here on:
1500 * - wraps around (can happen with cirrus vbe modes)
1501 * - depth == 0 (256 color palette video mode)
1502 * - depth == 15
1503 *
1504 * Take the safe and slow route:
1505 * - create a dirty bitmap snapshot for all vga memory.
1506 * - force shadowing (so all vga memory access goes
1507 * through vga_read_*() helpers).
1508 *
1509 * Given this affects only vga features which are pretty much
1510 * unused by modern guests there should be no performance
1511 * impact.
1512 */
1513 region_start = 0;
1514 region_end = s->vbe_size;
1515 force_shadow = true;
1516 }
1517
1518 /* bits 5-6: 0 = 16-color mode, 1 = 4-color mode, 2 = 256-color mode. */
1519 shift_control = (s->gr[VGA_GFX_MODE] >> 5) & 3;
1520 double_scan = (s->cr[VGA_CRTC_MAX_SCAN] >> 7);
1521 if (s->cr[VGA_CRTC_MODE] & 1) {
1522 multi_scan = (((s->cr[VGA_CRTC_MAX_SCAN] & 0x1f) + 1) << double_scan)
1523 - 1;
1524 } else {
1525 /* in CGA modes, multi_scan is ignored */
1526 /* XXX: is it correct ? */
1527 multi_scan = double_scan;
1528 }
1529 multi_run = multi_scan;
1530 if (shift_control != s->shift_control ||
1531 double_scan != s->double_scan) {
1532 full_update = 1;
1533 s->shift_control = shift_control;
1534 s->double_scan = double_scan;
1535 }
1536
1537 if (shift_control == 0) {
1538 if (sr(s, VGA_SEQ_CLOCK_MODE) & 8) {
1539 disp_width <<= 1;
1540 }
1541 } else if (shift_control == 1) {
1542 if (sr(s, VGA_SEQ_CLOCK_MODE) & 8) {
1543 disp_width <<= 1;
1544 }
1545 }
1546
1547 /*
1548 * Check whether we can share the surface with the backend
1549 * or whether we need a shadow surface. We share native
1550 * endian surfaces for 15bpp and above and byteswapped
1551 * surfaces for 24bpp and above.
1552 */
1553 format = qemu_default_pixman_format(depth, !byteswap);
1554 if (format) {
1555 share_surface = dpy_gfx_check_format(s->con, format)
1556 && !s->force_shadow && !force_shadow;
1557 } else {
1558 share_surface = false;
1559 }
1560
1561 if (s->line_offset != s->last_line_offset ||
1562 disp_width != s->last_width ||
1563 height != s->last_height ||
1564 s->last_depth != depth ||
1565 s->last_byteswap != byteswap ||
1566 share_surface != is_buffer_shared(surface)) {
1567 /* display parameters changed -> need new display surface */
1568 s->last_scr_width = disp_width;
1569 s->last_scr_height = height;
1570 s->last_width = disp_width;
1571 s->last_height = height;
1572 s->last_line_offset = s->line_offset;
1573 s->last_depth = depth;
1574 s->last_byteswap = byteswap;
1575 full_update = 1;
1576 }
1577 if (surface_data(surface) != s->vram_ptr + (s->start_addr * 4)
1578 && is_buffer_shared(surface)) {
1579 /* base address changed (page flip) -> shared display surfaces
1580 * must be updated with the new base address */
1581 full_update = 1;
1582 }
1583
1584 if (full_update) {
1585 if (share_surface) {
1586 surface = qemu_create_displaysurface_from(disp_width,
1587 height, format, s->line_offset,
1588 s->vram_ptr + (s->start_addr * 4));
1589 dpy_gfx_replace_surface(s->con, surface);
1590 } else {
1591 qemu_console_resize(s->con, disp_width, height);
1592 surface = qemu_console_surface(s->con);
1593 }
1594 }
1595
1596 if (shift_control == 0) {
1597 full_update |= update_palette16(s);
1598 if (sr(s, VGA_SEQ_CLOCK_MODE) & 8) {
1599 v = VGA_DRAW_LINE4D2;
1600 } else {
1601 v = VGA_DRAW_LINE4;
1602 }
1603 bits = 4;
1604 } else if (shift_control == 1) {
1605 full_update |= update_palette16(s);
1606 if (sr(s, VGA_SEQ_CLOCK_MODE) & 8) {
1607 v = VGA_DRAW_LINE2D2;
1608 } else {
1609 v = VGA_DRAW_LINE2;
1610 }
1611 bits = 4;
1612 } else {
1613 switch(s->get_bpp(s)) {
1614 default:
1615 case 0:
1616 full_update |= update_palette256(s);
1617 v = VGA_DRAW_LINE8D2;
1618 bits = 4;
1619 break;
1620 case 8:
1621 full_update |= update_palette256(s);
1622 v = VGA_DRAW_LINE8;
1623 bits = 8;
1624 break;
1625 case 15:
1626 v = s->big_endian_fb ? VGA_DRAW_LINE15_BE : VGA_DRAW_LINE15_LE;
1627 bits = 16;
1628 break;
1629 case 16:
1630 v = s->big_endian_fb ? VGA_DRAW_LINE16_BE : VGA_DRAW_LINE16_LE;
1631 bits = 16;
1632 break;
1633 case 24:
1634 v = s->big_endian_fb ? VGA_DRAW_LINE24_BE : VGA_DRAW_LINE24_LE;
1635 bits = 24;
1636 break;
1637 case 32:
1638 v = s->big_endian_fb ? VGA_DRAW_LINE32_BE : VGA_DRAW_LINE32_LE;
1639 bits = 32;
1640 break;
1641 }
1642 }
1643 vga_draw_line = vga_draw_line_table[v];
1644
1645 if (!is_buffer_shared(surface) && s->cursor_invalidate) {
1646 s->cursor_invalidate(s);
1647 }
1648
1649 #if 0
1650 printf("w=%d h=%d v=%d line_offset=%d cr[0x09]=0x%02x cr[0x17]=0x%02x linecmp=%d sr[0x01]=0x%02x\n",
1651 width, height, v, line_offset, s->cr[9], s->cr[VGA_CRTC_MODE],
1652 s->line_compare, sr(s, VGA_SEQ_CLOCK_MODE));
1653 #endif
1654 addr1 = (s->start_addr * 4);
1655 bwidth = DIV_ROUND_UP(width * bits, 8);
1656 y_start = -1;
1657 d = surface_data(surface);
1658 linesize = surface_stride(surface);
1659 y1 = 0;
1660
1661 if (!full_update) {
1662 if (s->line_compare < height) {
1663 /* split screen mode */
1664 region_start = 0;
1665 }
1666 snap = memory_region_snapshot_and_clear_dirty(&s->vram, region_start,
1667 region_end - region_start,
1668 DIRTY_MEMORY_VGA);
1669 }
1670
1671 for(y = 0; y < height; y++) {
1672 addr = addr1;
1673 if (!(s->cr[VGA_CRTC_MODE] & 1)) {
1674 int shift;
1675 /* CGA compatibility handling */
1676 shift = 14 + ((s->cr[VGA_CRTC_MODE] >> 6) & 1);
1677 addr = (addr & ~(1 << shift)) | ((y1 & 1) << shift);
1678 }
1679 if (!(s->cr[VGA_CRTC_MODE] & 2)) {
1680 addr = (addr & ~0x8000) | ((y1 & 2) << 14);
1681 }
1682 page0 = addr & s->vbe_size_mask;
1683 page1 = (addr + bwidth - 1) & s->vbe_size_mask;
1684 if (full_update) {
1685 update = 1;
1686 } else if (page1 < page0) {
1687 /* scanline wraps from end of video memory to the start */
1688 assert(force_shadow);
1689 update = memory_region_snapshot_get_dirty(&s->vram, snap,
1690 page0, s->vbe_size - page0);
1691 update |= memory_region_snapshot_get_dirty(&s->vram, snap,
1692 0, page1);
1693 } else {
1694 update = memory_region_snapshot_get_dirty(&s->vram, snap,
1695 page0, page1 - page0);
1696 }
1697 /* explicit invalidation for the hardware cursor (cirrus only) */
1698 update |= vga_scanline_invalidated(s, y);
1699 if (update) {
1700 if (y_start < 0)
1701 y_start = y;
1702 if (!(is_buffer_shared(surface))) {
1703 vga_draw_line(s, d, addr, width);
1704 if (s->cursor_draw_line)
1705 s->cursor_draw_line(s, d, y);
1706 }
1707 } else {
1708 if (y_start >= 0) {
1709 /* flush to display */
1710 dpy_gfx_update(s->con, 0, y_start,
1711 disp_width, y - y_start);
1712 y_start = -1;
1713 }
1714 }
1715 if (!multi_run) {
1716 mask = (s->cr[VGA_CRTC_MODE] & 3) ^ 3;
1717 if ((y1 & mask) == mask)
1718 addr1 += s->line_offset;
1719 y1++;
1720 multi_run = multi_scan;
1721 } else {
1722 multi_run--;
1723 }
1724 /* line compare acts on the displayed lines */
1725 if (y == s->line_compare)
1726 addr1 = 0;
1727 d += linesize;
1728 }
1729 if (y_start >= 0) {
1730 /* flush to display */
1731 dpy_gfx_update(s->con, 0, y_start,
1732 disp_width, y - y_start);
1733 }
1734 g_free(snap);
1735 memset(s->invalidated_y_table, 0, sizeof(s->invalidated_y_table));
1736 }
1737
1738 static void vga_draw_blank(VGACommonState *s, int full_update)
1739 {
1740 DisplaySurface *surface = qemu_console_surface(s->con);
1741 int i, w;
1742 uint8_t *d;
1743
1744 if (!full_update)
1745 return;
1746 if (s->last_scr_width <= 0 || s->last_scr_height <= 0)
1747 return;
1748
1749 w = s->last_scr_width * surface_bytes_per_pixel(surface);
1750 d = surface_data(surface);
1751 for(i = 0; i < s->last_scr_height; i++) {
1752 memset(d, 0, w);
1753 d += surface_stride(surface);
1754 }
1755 dpy_gfx_update_full(s->con);
1756 }
1757
1758 #define GMODE_TEXT 0
1759 #define GMODE_GRAPH 1
1760 #define GMODE_BLANK 2
1761
1762 static void vga_update_display(void *opaque)
1763 {
1764 VGACommonState *s = opaque;
1765 DisplaySurface *surface = qemu_console_surface(s->con);
1766 int full_update, graphic_mode;
1767
1768 qemu_flush_coalesced_mmio_buffer();
1769
1770 if (surface_bits_per_pixel(surface) == 0) {
1771 /* nothing to do */
1772 } else {
1773 full_update = 0;
1774 if (!(s->ar_index & 0x20)) {
1775 graphic_mode = GMODE_BLANK;
1776 } else {
1777 graphic_mode = s->gr[VGA_GFX_MISC] & VGA_GR06_GRAPHICS_MODE;
1778 }
1779 if (graphic_mode != s->graphic_mode) {
1780 s->graphic_mode = graphic_mode;
1781 s->cursor_blink_time = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);
1782 full_update = 1;
1783 }
1784 switch(graphic_mode) {
1785 case GMODE_TEXT:
1786 vga_draw_text(s, full_update);
1787 break;
1788 case GMODE_GRAPH:
1789 vga_draw_graphic(s, full_update);
1790 break;
1791 case GMODE_BLANK:
1792 default:
1793 vga_draw_blank(s, full_update);
1794 break;
1795 }
1796 }
1797 }
1798
1799 /* force a full display refresh */
1800 static void vga_invalidate_display(void *opaque)
1801 {
1802 VGACommonState *s = opaque;
1803
1804 s->last_width = -1;
1805 s->last_height = -1;
1806 }
1807
1808 void vga_common_reset(VGACommonState *s)
1809 {
1810 s->sr_index = 0;
1811 memset(s->sr, '\0', sizeof(s->sr));
1812 memset(s->sr_vbe, '\0', sizeof(s->sr_vbe));
1813 s->gr_index = 0;
1814 memset(s->gr, '\0', sizeof(s->gr));
1815 s->ar_index = 0;
1816 memset(s->ar, '\0', sizeof(s->ar));
1817 s->ar_flip_flop = 0;
1818 s->cr_index = 0;
1819 memset(s->cr, '\0', sizeof(s->cr));
1820 s->msr = 0;
1821 s->fcr = 0;
1822 s->st00 = 0;
1823 s->st01 = 0;
1824 s->dac_state = 0;
1825 s->dac_sub_index = 0;
1826 s->dac_read_index = 0;
1827 s->dac_write_index = 0;
1828 memset(s->dac_cache, '\0', sizeof(s->dac_cache));
1829 s->dac_8bit = 0;
1830 memset(s->palette, '\0', sizeof(s->palette));
1831 s->bank_offset = 0;
1832 s->vbe_index = 0;
1833 memset(s->vbe_regs, '\0', sizeof(s->vbe_regs));
1834 s->vbe_regs[VBE_DISPI_INDEX_ID] = VBE_DISPI_ID5;
1835 s->vbe_start_addr = 0;
1836 s->vbe_line_offset = 0;
1837 s->vbe_bank_mask = (s->vram_size >> 16) - 1;
1838 memset(s->font_offsets, '\0', sizeof(s->font_offsets));
1839 s->graphic_mode = -1; /* force full update */
1840 s->shift_control = 0;
1841 s->double_scan = 0;
1842 s->line_offset = 0;
1843 s->line_compare = 0;
1844 s->start_addr = 0;
1845 s->plane_updated = 0;
1846 s->last_cw = 0;
1847 s->last_ch = 0;
1848 s->last_width = 0;
1849 s->last_height = 0;
1850 s->last_scr_width = 0;
1851 s->last_scr_height = 0;
1852 s->cursor_start = 0;
1853 s->cursor_end = 0;
1854 s->cursor_offset = 0;
1855 s->big_endian_fb = s->default_endian_fb;
1856 memset(s->invalidated_y_table, '\0', sizeof(s->invalidated_y_table));
1857 memset(s->last_palette, '\0', sizeof(s->last_palette));
1858 memset(s->last_ch_attr, '\0', sizeof(s->last_ch_attr));
1859 switch (vga_retrace_method) {
1860 case VGA_RETRACE_DUMB:
1861 break;
1862 case VGA_RETRACE_PRECISE:
1863 memset(&s->retrace_info, 0, sizeof (s->retrace_info));
1864 break;
1865 }
1866 vga_update_memory_access(s);
1867 }
1868
1869 static void vga_reset(void *opaque)
1870 {
1871 VGACommonState *s = opaque;
1872 vga_common_reset(s);
1873 }
1874
1875 #define TEXTMODE_X(x) ((x) % width)
1876 #define TEXTMODE_Y(x) ((x) / width)
1877 #define VMEM2CHTYPE(v) ((v & 0xff0007ff) | \
1878 ((v & 0x00000800) << 10) | ((v & 0x00007000) >> 1))
1879 /* relay text rendering to the display driver
1880 * instead of doing a full vga_update_display() */
1881 static void vga_update_text(void *opaque, console_ch_t *chardata)
1882 {
1883 VGACommonState *s = opaque;
1884 int graphic_mode, i, cursor_offset, cursor_visible;
1885 int cw, cheight, width, height, size, c_min, c_max;
1886 uint32_t *src;
1887 console_ch_t *dst, val;
1888 char msg_buffer[80];
1889 int full_update = 0;
1890
1891 qemu_flush_coalesced_mmio_buffer();
1892
1893 if (!(s->ar_index & 0x20)) {
1894 graphic_mode = GMODE_BLANK;
1895 } else {
1896 graphic_mode = s->gr[VGA_GFX_MISC] & VGA_GR06_GRAPHICS_MODE;
1897 }
1898 if (graphic_mode != s->graphic_mode) {
1899 s->graphic_mode = graphic_mode;
1900 full_update = 1;
1901 }
1902 if (s->last_width == -1) {
1903 s->last_width = 0;
1904 full_update = 1;
1905 }
1906
1907 switch (graphic_mode) {
1908 case GMODE_TEXT:
1909 /* TODO: update palette */
1910 full_update |= update_basic_params(s);
1911
1912 /* total width & height */
1913 cheight = (s->cr[VGA_CRTC_MAX_SCAN] & 0x1f) + 1;
1914 cw = 8;
1915 if (!(sr(s, VGA_SEQ_CLOCK_MODE) & VGA_SR01_CHAR_CLK_8DOTS)) {
1916 cw = 9;
1917 }
1918 if (sr(s, VGA_SEQ_CLOCK_MODE) & 0x08) {
1919 cw = 16; /* NOTE: no 18 pixel wide */
1920 }
1921 width = (s->cr[VGA_CRTC_H_DISP] + 1);
1922 if (s->cr[VGA_CRTC_V_TOTAL] == 100) {
1923 /* ugly hack for CGA 160x100x16 - explain me the logic */
1924 height = 100;
1925 } else {
1926 height = s->cr[VGA_CRTC_V_DISP_END] |
1927 ((s->cr[VGA_CRTC_OVERFLOW] & 0x02) << 7) |
1928 ((s->cr[VGA_CRTC_OVERFLOW] & 0x40) << 3);
1929 height = (height + 1) / cheight;
1930 }
1931
1932 size = (height * width);
1933 if (size > CH_ATTR_SIZE) {
1934 if (!full_update)
1935 return;
1936
1937 snprintf(msg_buffer, sizeof(msg_buffer), "%i x %i Text mode",
1938 width, height);
1939 break;
1940 }
1941
1942 if (width != s->last_width || height != s->last_height ||
1943 cw != s->last_cw || cheight != s->last_ch) {
1944 s->last_scr_width = width * cw;
1945 s->last_scr_height = height * cheight;
1946 qemu_console_resize(s->con, s->last_scr_width, s->last_scr_height);
1947 dpy_text_resize(s->con, width, height);
1948 s->last_depth = 0;
1949 s->last_width = width;
1950 s->last_height = height;
1951 s->last_ch = cheight;
1952 s->last_cw = cw;
1953 full_update = 1;
1954 }
1955
1956 if (full_update) {
1957 s->full_update_gfx = 1;
1958 }
1959 if (s->full_update_text) {
1960 s->full_update_text = 0;
1961 full_update |= 1;
1962 }
1963
1964 /* Update "hardware" cursor */
1965 cursor_offset = ((s->cr[VGA_CRTC_CURSOR_HI] << 8) |
1966 s->cr[VGA_CRTC_CURSOR_LO]) - s->start_addr;
1967 if (cursor_offset != s->cursor_offset ||
1968 s->cr[VGA_CRTC_CURSOR_START] != s->cursor_start ||
1969 s->cr[VGA_CRTC_CURSOR_END] != s->cursor_end || full_update) {
1970 cursor_visible = !(s->cr[VGA_CRTC_CURSOR_START] & 0x20);
1971 if (cursor_visible && cursor_offset < size && cursor_offset >= 0)
1972 dpy_text_cursor(s->con,
1973 TEXTMODE_X(cursor_offset),
1974 TEXTMODE_Y(cursor_offset));
1975 else
1976 dpy_text_cursor(s->con, -1, -1);
1977 s->cursor_offset = cursor_offset;
1978 s->cursor_start = s->cr[VGA_CRTC_CURSOR_START];
1979 s->cursor_end = s->cr[VGA_CRTC_CURSOR_END];
1980 }
1981
1982 src = (uint32_t *) s->vram_ptr + s->start_addr;
1983 dst = chardata;
1984
1985 if (full_update) {
1986 for (i = 0; i < size; src ++, dst ++, i ++)
1987 console_write_ch(dst, VMEM2CHTYPE(le32_to_cpu(*src)));
1988
1989 dpy_text_update(s->con, 0, 0, width, height);
1990 } else {
1991 c_max = 0;
1992
1993 for (i = 0; i < size; src ++, dst ++, i ++) {
1994 console_write_ch(&val, VMEM2CHTYPE(le32_to_cpu(*src)));
1995 if (*dst != val) {
1996 *dst = val;
1997 c_max = i;
1998 break;
1999 }
2000 }
2001 c_min = i;
2002 for (; i < size; src ++, dst ++, i ++) {
2003 console_write_ch(&val, VMEM2CHTYPE(le32_to_cpu(*src)));
2004 if (*dst != val) {
2005 *dst = val;
2006 c_max = i;
2007 }
2008 }
2009
2010 if (c_min <= c_max) {
2011 i = TEXTMODE_Y(c_min);
2012 dpy_text_update(s->con, 0, i, width, TEXTMODE_Y(c_max) - i + 1);
2013 }
2014 }
2015
2016 return;
2017 case GMODE_GRAPH:
2018 if (!full_update)
2019 return;
2020
2021 s->get_resolution(s, &width, &height);
2022 snprintf(msg_buffer, sizeof(msg_buffer), "%i x %i Graphic mode",
2023 width, height);
2024 break;
2025 case GMODE_BLANK:
2026 default:
2027 if (!full_update)
2028 return;
2029
2030 snprintf(msg_buffer, sizeof(msg_buffer), "VGA Blank mode");
2031 break;
2032 }
2033
2034 /* Display a message */
2035 s->last_width = 60;
2036 s->last_height = height = 3;
2037 dpy_text_cursor(s->con, -1, -1);
2038 dpy_text_resize(s->con, s->last_width, height);
2039
2040 for (dst = chardata, i = 0; i < s->last_width * height; i ++)
2041 console_write_ch(dst ++, ' ');
2042
2043 size = strlen(msg_buffer);
2044 width = (s->last_width - size) / 2;
2045 dst = chardata + s->last_width + width;
2046 for (i = 0; i < size; i ++)
2047 console_write_ch(dst ++, ATTR2CHTYPE(msg_buffer[i], QEMU_COLOR_BLUE,
2048 QEMU_COLOR_BLACK, 1));
2049
2050 dpy_text_update(s->con, 0, 0, s->last_width, height);
2051 }
2052
2053 static uint64_t vga_mem_read(void *opaque, hwaddr addr,
2054 unsigned size)
2055 {
2056 VGACommonState *s = opaque;
2057
2058 return vga_mem_readb(s, addr);
2059 }
2060
2061 static void vga_mem_write(void *opaque, hwaddr addr,
2062 uint64_t data, unsigned size)
2063 {
2064 VGACommonState *s = opaque;
2065
2066 vga_mem_writeb(s, addr, data);
2067 }
2068
2069 const MemoryRegionOps vga_mem_ops = {
2070 .read = vga_mem_read,
2071 .write = vga_mem_write,
2072 .endianness = DEVICE_LITTLE_ENDIAN,
2073 .impl = {
2074 .min_access_size = 1,
2075 .max_access_size = 1,
2076 },
2077 };
2078
2079 static int vga_common_post_load(void *opaque, int version_id)
2080 {
2081 VGACommonState *s = opaque;
2082
2083 /* force refresh */
2084 s->graphic_mode = -1;
2085 vbe_update_vgaregs(s);
2086 vga_update_memory_access(s);
2087 return 0;
2088 }
2089
2090 static bool vga_endian_state_needed(void *opaque)
2091 {
2092 VGACommonState *s = opaque;
2093
2094 /*
2095 * Only send the endian state if it's different from the
2096 * default one, thus ensuring backward compatibility for
2097 * migration of the common case
2098 */
2099 return s->default_endian_fb != s->big_endian_fb;
2100 }
2101
2102 static const VMStateDescription vmstate_vga_endian = {
2103 .name = "vga.endian",
2104 .version_id = 1,
2105 .minimum_version_id = 1,
2106 .needed = vga_endian_state_needed,
2107 .fields = (VMStateField[]) {
2108 VMSTATE_BOOL(big_endian_fb, VGACommonState),
2109 VMSTATE_END_OF_LIST()
2110 }
2111 };
2112
2113 const VMStateDescription vmstate_vga_common = {
2114 .name = "vga",
2115 .version_id = 2,
2116 .minimum_version_id = 2,
2117 .post_load = vga_common_post_load,
2118 .fields = (VMStateField[]) {
2119 VMSTATE_UINT32(latch, VGACommonState),
2120 VMSTATE_UINT8(sr_index, VGACommonState),
2121 VMSTATE_PARTIAL_BUFFER(sr, VGACommonState, 8),
2122 VMSTATE_UINT8(gr_index, VGACommonState),
2123 VMSTATE_PARTIAL_BUFFER(gr, VGACommonState, 16),
2124 VMSTATE_UINT8(ar_index, VGACommonState),
2125 VMSTATE_BUFFER(ar, VGACommonState),
2126 VMSTATE_INT32(ar_flip_flop, VGACommonState),
2127 VMSTATE_UINT8(cr_index, VGACommonState),
2128 VMSTATE_BUFFER(cr, VGACommonState),
2129 VMSTATE_UINT8(msr, VGACommonState),
2130 VMSTATE_UINT8(fcr, VGACommonState),
2131 VMSTATE_UINT8(st00, VGACommonState),
2132 VMSTATE_UINT8(st01, VGACommonState),
2133
2134 VMSTATE_UINT8(dac_state, VGACommonState),
2135 VMSTATE_UINT8(dac_sub_index, VGACommonState),
2136 VMSTATE_UINT8(dac_read_index, VGACommonState),
2137 VMSTATE_UINT8(dac_write_index, VGACommonState),
2138 VMSTATE_BUFFER(dac_cache, VGACommonState),
2139 VMSTATE_BUFFER(palette, VGACommonState),
2140
2141 VMSTATE_INT32(bank_offset, VGACommonState),
2142 VMSTATE_UINT8_EQUAL(is_vbe_vmstate, VGACommonState, NULL),
2143 VMSTATE_UINT16(vbe_index, VGACommonState),
2144 VMSTATE_UINT16_ARRAY(vbe_regs, VGACommonState, VBE_DISPI_INDEX_NB),
2145 VMSTATE_UINT32(vbe_start_addr, VGACommonState),
2146 VMSTATE_UINT32(vbe_line_offset, VGACommonState),
2147 VMSTATE_UINT32(vbe_bank_mask, VGACommonState),
2148 VMSTATE_END_OF_LIST()
2149 },
2150 .subsections = (const VMStateDescription*[]) {
2151 &vmstate_vga_endian,
2152 NULL
2153 }
2154 };
2155
2156 static const GraphicHwOps vga_ops = {
2157 .invalidate = vga_invalidate_display,
2158 .gfx_update = vga_update_display,
2159 .text_update = vga_update_text,
2160 };
2161
2162 static inline uint32_t uint_clamp(uint32_t val, uint32_t vmin, uint32_t vmax)
2163 {
2164 if (val < vmin) {
2165 return vmin;
2166 }
2167 if (val > vmax) {
2168 return vmax;
2169 }
2170 return val;
2171 }
2172
2173 bool vga_common_init(VGACommonState *s, Object *obj, Error **errp)
2174 {
2175 int i, j, v, b;
2176 Error *local_err = NULL;
2177
2178 for(i = 0;i < 256; i++) {
2179 v = 0;
2180 for(j = 0; j < 8; j++) {
2181 v |= ((i >> j) & 1) << (j * 4);
2182 }
2183 expand4[i] = v;
2184
2185 v = 0;
2186 for(j = 0; j < 4; j++) {
2187 v |= ((i >> (2 * j)) & 3) << (j * 4);
2188 }
2189 expand2[i] = v;
2190 }
2191 for(i = 0; i < 16; i++) {
2192 v = 0;
2193 for(j = 0; j < 4; j++) {
2194 b = ((i >> j) & 1);
2195 v |= b << (2 * j);
2196 v |= b << (2 * j + 1);
2197 }
2198 expand4to8[i] = v;
2199 }
2200
2201 s->vram_size_mb = uint_clamp(s->vram_size_mb, 1, 512);
2202 s->vram_size_mb = pow2ceil(s->vram_size_mb);
2203 s->vram_size = s->vram_size_mb * MiB;
2204
2205 if (!s->vbe_size) {
2206 s->vbe_size = s->vram_size;
2207 }
2208 s->vbe_size_mask = s->vbe_size - 1;
2209
2210 s->is_vbe_vmstate = 1;
2211
2212 if (s->global_vmstate && qemu_ram_block_by_name("vga.vram")) {
2213 error_setg(errp, "Only one global VGA device can be used at a time");
2214 return false;
2215 }
2216
2217 memory_region_init_ram_nomigrate(&s->vram, obj, "vga.vram", s->vram_size,
2218 &local_err);
2219 if (local_err) {
2220 error_propagate(errp, local_err);
2221 return false;
2222 }
2223 vmstate_register_ram(&s->vram, s->global_vmstate ? NULL : DEVICE(obj));
2224 xen_register_framebuffer(&s->vram);
2225 s->vram_ptr = memory_region_get_ram_ptr(&s->vram);
2226 s->get_bpp = vga_get_bpp;
2227 s->get_offsets = vga_get_offsets;
2228 s->get_resolution = vga_get_resolution;
2229 s->hw_ops = &vga_ops;
2230 switch (vga_retrace_method) {
2231 case VGA_RETRACE_DUMB:
2232 s->retrace = vga_dumb_retrace;
2233 s->update_retrace_info = vga_dumb_update_retrace_info;
2234 break;
2235
2236 case VGA_RETRACE_PRECISE:
2237 s->retrace = vga_precise_retrace;
2238 s->update_retrace_info = vga_precise_update_retrace_info;
2239 break;
2240 }
2241
2242 /*
2243 * Set default fb endian based on target, could probably be turned
2244 * into a device attribute set by the machine/platform to remove
2245 * all target endian dependencies from this file.
2246 */
2247 #if TARGET_BIG_ENDIAN
2248 s->default_endian_fb = true;
2249 #else
2250 s->default_endian_fb = false;
2251 #endif
2252 vga_dirty_log_start(s);
2253
2254 return true;
2255 }
2256
2257 static const MemoryRegionPortio vga_portio_list[] = {
2258 { 0x04, 2, 1, .read = vga_ioport_read, .write = vga_ioport_write }, /* 3b4 */
2259 { 0x0a, 1, 1, .read = vga_ioport_read, .write = vga_ioport_write }, /* 3ba */
2260 { 0x10, 16, 1, .read = vga_ioport_read, .write = vga_ioport_write }, /* 3c0 */
2261 { 0x24, 2, 1, .read = vga_ioport_read, .write = vga_ioport_write }, /* 3d4 */
2262 { 0x2a, 1, 1, .read = vga_ioport_read, .write = vga_ioport_write }, /* 3da */
2263 PORTIO_END_OF_LIST(),
2264 };
2265
2266 static const MemoryRegionPortio vbe_portio_list[] = {
2267 { 0, 1, 2, .read = vbe_ioport_read_index, .write = vbe_ioport_write_index },
2268 # ifdef TARGET_I386
2269 { 1, 1, 2, .read = vbe_ioport_read_data, .write = vbe_ioport_write_data },
2270 # endif
2271 { 2, 1, 2, .read = vbe_ioport_read_data, .write = vbe_ioport_write_data },
2272 PORTIO_END_OF_LIST(),
2273 };
2274
2275 /* Used by both ISA and PCI */
2276 MemoryRegion *vga_init_io(VGACommonState *s, Object *obj,
2277 const MemoryRegionPortio **vga_ports,
2278 const MemoryRegionPortio **vbe_ports)
2279 {
2280 MemoryRegion *vga_mem;
2281
2282 *vga_ports = vga_portio_list;
2283 *vbe_ports = vbe_portio_list;
2284
2285 vga_mem = g_malloc(sizeof(*vga_mem));
2286 memory_region_init_io(vga_mem, obj, &vga_mem_ops, s,
2287 "vga-lowmem", 0x20000);
2288 memory_region_set_flush_coalesced(vga_mem);
2289
2290 return vga_mem;
2291 }
2292
2293 void vga_init(VGACommonState *s, Object *obj, MemoryRegion *address_space,
2294 MemoryRegion *address_space_io, bool init_vga_ports)
2295 {
2296 MemoryRegion *vga_io_memory;
2297 const MemoryRegionPortio *vga_ports, *vbe_ports;
2298
2299 qemu_register_reset(vga_reset, s);
2300
2301 s->bank_offset = 0;
2302
2303 s->legacy_address_space = address_space;
2304
2305 vga_io_memory = vga_init_io(s, obj, &vga_ports, &vbe_ports);
2306 memory_region_add_subregion_overlap(address_space,
2307 0x000a0000,
2308 vga_io_memory,
2309 1);
2310 memory_region_set_coalescing(vga_io_memory);
2311 if (init_vga_ports) {
2312 portio_list_init(&s->vga_port_list, obj, vga_ports, s, "vga");
2313 portio_list_set_flush_coalesced(&s->vga_port_list);
2314 portio_list_add(&s->vga_port_list, address_space_io, 0x3b0);
2315 }
2316 if (vbe_ports) {
2317 portio_list_init(&s->vbe_port_list, obj, vbe_ports, s, "vbe");
2318 portio_list_add(&s->vbe_port_list, address_space_io, 0x1ce);
2319 }
2320 }
Ray Wang's QEMU Repository