xref: /openbmc/qemu/hw/display/vga-helpers.h (revision 4d6d8a05)
1 /*
2  * QEMU VGA Emulator templates
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 static inline void vga_draw_glyph_line(uint8_t *d, uint32_t font_data,
26                                        uint32_t xorcol, uint32_t bgcol)
27 {
28         ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
29         ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
30         ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
31         ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
32         ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
33         ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
34         ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
35         ((uint32_t *)d)[7] = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
36 }
37 
38 static void vga_draw_glyph8(uint8_t *d, int linesize,
39                             const uint8_t *font_ptr, int h,
40                             uint32_t fgcol, uint32_t bgcol)
41 {
42     uint32_t font_data, xorcol;
43 
44     xorcol = bgcol ^ fgcol;
45     do {
46         font_data = font_ptr[0];
47         vga_draw_glyph_line(d, font_data, xorcol, bgcol);
48         font_ptr += 4;
49         d += linesize;
50     } while (--h);
51 }
52 
53 static void vga_draw_glyph16(uint8_t *d, int linesize,
54                                           const uint8_t *font_ptr, int h,
55                                           uint32_t fgcol, uint32_t bgcol)
56 {
57     uint32_t font_data, xorcol;
58 
59     xorcol = bgcol ^ fgcol;
60     do {
61         font_data = font_ptr[0];
62         vga_draw_glyph_line(d, expand4to8[font_data >> 4],
63                             xorcol, bgcol);
64         vga_draw_glyph_line(d + 32, expand4to8[font_data & 0x0f],
65                             xorcol, bgcol);
66         font_ptr += 4;
67         d += linesize;
68     } while (--h);
69 }
70 
71 static void vga_draw_glyph9(uint8_t *d, int linesize,
72                             const uint8_t *font_ptr, int h,
73                             uint32_t fgcol, uint32_t bgcol, int dup9)
74 {
75     uint32_t font_data, xorcol, v;
76 
77     xorcol = bgcol ^ fgcol;
78     do {
79         font_data = font_ptr[0];
80         ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
81         ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
82         ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
83         ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
84         ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
85         ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
86         ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
87         v = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
88         ((uint32_t *)d)[7] = v;
89         if (dup9)
90             ((uint32_t *)d)[8] = v;
91         else
92             ((uint32_t *)d)[8] = bgcol;
93         font_ptr += 4;
94         d += linesize;
95     } while (--h);
96 }
97 
98 /*
99  * 4 color mode
100  */
101 static void *vga_draw_line2(VGACommonState *vga, uint8_t *d,
102                             uint32_t addr, int width, int hpel)
103 {
104     uint32_t plane_mask, *palette, data, v;
105     int x;
106 
107     palette = vga->last_palette;
108     plane_mask = mask16[vga->ar[VGA_ATC_PLANE_ENABLE] & 0xf];
109     hpel &= 7;
110     if (hpel) {
111         width += 8;
112         d = vga->panning_buf;
113     }
114     width >>= 3;
115     for(x = 0; x < width; x++) {
116         data = vga_read_dword_le(vga, addr & (VGA_VRAM_SIZE - 1));
117         data &= plane_mask;
118         v = expand2[GET_PLANE(data, 0)];
119         v |= expand2[GET_PLANE(data, 2)] << 2;
120         ((uint32_t *)d)[0] = palette[v >> 12];
121         ((uint32_t *)d)[1] = palette[(v >> 8) & 0xf];
122         ((uint32_t *)d)[2] = palette[(v >> 4) & 0xf];
123         ((uint32_t *)d)[3] = palette[(v >> 0) & 0xf];
124 
125         v = expand2[GET_PLANE(data, 1)];
126         v |= expand2[GET_PLANE(data, 3)] << 2;
127         ((uint32_t *)d)[4] = palette[v >> 12];
128         ((uint32_t *)d)[5] = palette[(v >> 8) & 0xf];
129         ((uint32_t *)d)[6] = palette[(v >> 4) & 0xf];
130         ((uint32_t *)d)[7] = palette[(v >> 0) & 0xf];
131         d += 32;
132         addr += 4;
133     }
134     return hpel ? vga->panning_buf + 4 * hpel : NULL;
135 }
136 
137 #define PUT_PIXEL2(d, n, v) \
138 ((uint32_t *)d)[2*(n)] = ((uint32_t *)d)[2*(n)+1] = (v)
139 
140 /*
141  * 4 color mode, dup2 horizontal
142  */
143 static void *vga_draw_line2d2(VGACommonState *vga, uint8_t *d,
144                               uint32_t addr, int width, int hpel)
145 {
146     uint32_t plane_mask, *palette, data, v;
147     int x;
148 
149     palette = vga->last_palette;
150     plane_mask = mask16[vga->ar[VGA_ATC_PLANE_ENABLE] & 0xf];
151     hpel &= 7;
152     if (hpel) {
153         width += 8;
154         d = vga->panning_buf;
155     }
156     width >>= 3;
157     for(x = 0; x < width; x++) {
158         data = vga_read_dword_le(vga, addr & (VGA_VRAM_SIZE - 1));
159         data &= plane_mask;
160         v = expand2[GET_PLANE(data, 0)];
161         v |= expand2[GET_PLANE(data, 2)] << 2;
162         PUT_PIXEL2(d, 0, palette[v >> 12]);
163         PUT_PIXEL2(d, 1, palette[(v >> 8) & 0xf]);
164         PUT_PIXEL2(d, 2, palette[(v >> 4) & 0xf]);
165         PUT_PIXEL2(d, 3, palette[(v >> 0) & 0xf]);
166 
167         v = expand2[GET_PLANE(data, 1)];
168         v |= expand2[GET_PLANE(data, 3)] << 2;
169         PUT_PIXEL2(d, 4, palette[v >> 12]);
170         PUT_PIXEL2(d, 5, palette[(v >> 8) & 0xf]);
171         PUT_PIXEL2(d, 6, palette[(v >> 4) & 0xf]);
172         PUT_PIXEL2(d, 7, palette[(v >> 0) & 0xf]);
173         d += 64;
174         addr += 4;
175     }
176     return hpel ? vga->panning_buf + 8 * hpel : NULL;
177 }
178 
179 /*
180  * 16 color mode
181  */
182 static void *vga_draw_line4(VGACommonState *vga, uint8_t *d,
183                             uint32_t addr, int width, int hpel)
184 {
185     uint32_t plane_mask, data, v, *palette;
186     int x;
187 
188     palette = vga->last_palette;
189     plane_mask = mask16[vga->ar[VGA_ATC_PLANE_ENABLE] & 0xf];
190     hpel &= 7;
191     if (hpel) {
192         width += 8;
193         d = vga->panning_buf;
194     }
195     width >>= 3;
196     for(x = 0; x < width; x++) {
197         data = vga_read_dword_le(vga, addr & (VGA_VRAM_SIZE - 1));
198         data &= plane_mask;
199         v = expand4[GET_PLANE(data, 0)];
200         v |= expand4[GET_PLANE(data, 1)] << 1;
201         v |= expand4[GET_PLANE(data, 2)] << 2;
202         v |= expand4[GET_PLANE(data, 3)] << 3;
203         ((uint32_t *)d)[0] = palette[v >> 28];
204         ((uint32_t *)d)[1] = palette[(v >> 24) & 0xf];
205         ((uint32_t *)d)[2] = palette[(v >> 20) & 0xf];
206         ((uint32_t *)d)[3] = palette[(v >> 16) & 0xf];
207         ((uint32_t *)d)[4] = palette[(v >> 12) & 0xf];
208         ((uint32_t *)d)[5] = palette[(v >> 8) & 0xf];
209         ((uint32_t *)d)[6] = palette[(v >> 4) & 0xf];
210         ((uint32_t *)d)[7] = palette[(v >> 0) & 0xf];
211         d += 32;
212         addr += 4;
213     }
214     return hpel ? vga->panning_buf + 4 * hpel : NULL;
215 }
216 
217 /*
218  * 16 color mode, dup2 horizontal
219  */
220 static void *vga_draw_line4d2(VGACommonState *vga, uint8_t *d,
221                               uint32_t addr, int width, int hpel)
222 {
223     uint32_t plane_mask, data, v, *palette;
224     int x;
225 
226     palette = vga->last_palette;
227     plane_mask = mask16[vga->ar[VGA_ATC_PLANE_ENABLE] & 0xf];
228     hpel &= 7;
229     if (hpel) {
230         width += 8;
231         d = vga->panning_buf;
232     }
233     width >>= 3;
234     for(x = 0; x < width; x++) {
235         data = vga_read_dword_le(vga, addr & (VGA_VRAM_SIZE - 1));
236         data &= plane_mask;
237         v = expand4[GET_PLANE(data, 0)];
238         v |= expand4[GET_PLANE(data, 1)] << 1;
239         v |= expand4[GET_PLANE(data, 2)] << 2;
240         v |= expand4[GET_PLANE(data, 3)] << 3;
241         PUT_PIXEL2(d, 0, palette[v >> 28]);
242         PUT_PIXEL2(d, 1, palette[(v >> 24) & 0xf]);
243         PUT_PIXEL2(d, 2, palette[(v >> 20) & 0xf]);
244         PUT_PIXEL2(d, 3, palette[(v >> 16) & 0xf]);
245         PUT_PIXEL2(d, 4, palette[(v >> 12) & 0xf]);
246         PUT_PIXEL2(d, 5, palette[(v >> 8) & 0xf]);
247         PUT_PIXEL2(d, 6, palette[(v >> 4) & 0xf]);
248         PUT_PIXEL2(d, 7, palette[(v >> 0) & 0xf]);
249         d += 64;
250         addr += 4;
251     }
252     return hpel ? vga->panning_buf + 8 * hpel : NULL;
253 }
254 
255 /*
256  * 256 color mode, double pixels
257  *
258  * XXX: add plane_mask support (never used in standard VGA modes)
259  */
260 static void *vga_draw_line8d2(VGACommonState *vga, uint8_t *d,
261                               uint32_t addr, int width, int hpel)
262 {
263     uint32_t *palette;
264     int x;
265 
266     palette = vga->last_palette;
267     hpel = (hpel >> 1) & 3;
268 
269     /* For 256 color modes, we can adjust the source address and write directly
270      * to the destination, even if horizontal pel panning is active.  However,
271      * the loop below assumes that the address does not wrap in the middle of a
272      * plane.  If that happens...
273      */
274     if (addr + (width >> 3) * 4 < VGA_VRAM_SIZE) {
275         addr += hpel * 4;
276         hpel = 0;
277     }
278 
279     /* ... use the panning buffer as in planar modes.  */
280     if (hpel) {
281         width += 8;
282         d = vga->panning_buf;
283     }
284     width >>= 3;
285     for(x = 0; x < width; x++) {
286         addr &= VGA_VRAM_SIZE - 1;
287         PUT_PIXEL2(d, 0, palette[vga_read_byte(vga, addr + 0)]);
288         PUT_PIXEL2(d, 1, palette[vga_read_byte(vga, addr + 1)]);
289         PUT_PIXEL2(d, 2, palette[vga_read_byte(vga, addr + 2)]);
290         PUT_PIXEL2(d, 3, palette[vga_read_byte(vga, addr + 3)]);
291         d += 32;
292         addr += 4;
293     }
294     return hpel ? vga->panning_buf + 8 * hpel : NULL;
295 }
296 
297 /*
298  * standard 256 color mode
299  *
300  * XXX: add plane_mask support (never used in standard VGA modes)
301  */
302 static void *vga_draw_line8(VGACommonState *vga, uint8_t *d,
303                             uint32_t addr, int width, int hpel)
304 {
305     uint32_t *palette;
306     int x;
307 
308     palette = vga->last_palette;
309     hpel = (hpel >> 1) & 3;
310     if (hpel) {
311         width += 8;
312         d = vga->panning_buf;
313     }
314     width >>= 3;
315     for(x = 0; x < width; x++) {
316         ((uint32_t *)d)[0] = palette[vga_read_byte(vga, addr + 0)];
317         ((uint32_t *)d)[1] = palette[vga_read_byte(vga, addr + 1)];
318         ((uint32_t *)d)[2] = palette[vga_read_byte(vga, addr + 2)];
319         ((uint32_t *)d)[3] = palette[vga_read_byte(vga, addr + 3)];
320         ((uint32_t *)d)[4] = palette[vga_read_byte(vga, addr + 4)];
321         ((uint32_t *)d)[5] = palette[vga_read_byte(vga, addr + 5)];
322         ((uint32_t *)d)[6] = palette[vga_read_byte(vga, addr + 6)];
323         ((uint32_t *)d)[7] = palette[vga_read_byte(vga, addr + 7)];
324         d += 32;
325         addr += 8;
326     }
327     return hpel ? vga->panning_buf + 4 * hpel : NULL;
328 }
329 
330 /*
331  * 15 bit color
332  */
333 static void *vga_draw_line15_le(VGACommonState *vga, uint8_t *d,
334                                 uint32_t addr, int width, int hpel)
335 {
336     int w;
337     uint32_t v, r, g, b;
338 
339     w = width;
340     do {
341         v = vga_read_word_le(vga, addr);
342         r = (v >> 7) & 0xf8;
343         g = (v >> 2) & 0xf8;
344         b = (v << 3) & 0xf8;
345         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
346         addr += 2;
347         d += 4;
348     } while (--w != 0);
349     return NULL;
350 }
351 
352 static void *vga_draw_line15_be(VGACommonState *vga, uint8_t *d,
353                                 uint32_t addr, int width, int hpel)
354 {
355     int w;
356     uint32_t v, r, g, b;
357 
358     w = width;
359     do {
360         v = vga_read_word_be(vga, addr);
361         r = (v >> 7) & 0xf8;
362         g = (v >> 2) & 0xf8;
363         b = (v << 3) & 0xf8;
364         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
365         addr += 2;
366         d += 4;
367     } while (--w != 0);
368     return NULL;
369 }
370 
371 /*
372  * 16 bit color
373  */
374 static void *vga_draw_line16_le(VGACommonState *vga, uint8_t *d,
375                                 uint32_t addr, int width, int hpel)
376 {
377     int w;
378     uint32_t v, r, g, b;
379 
380     w = width;
381     do {
382         v = vga_read_word_le(vga, addr);
383         r = (v >> 8) & 0xf8;
384         g = (v >> 3) & 0xfc;
385         b = (v << 3) & 0xf8;
386         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
387         addr += 2;
388         d += 4;
389     } while (--w != 0);
390     return NULL;
391 }
392 
393 static void *vga_draw_line16_be(VGACommonState *vga, uint8_t *d,
394                                 uint32_t addr, int width, int hpel)
395 {
396     int w;
397     uint32_t v, r, g, b;
398 
399     w = width;
400     do {
401         v = vga_read_word_be(vga, addr);
402         r = (v >> 8) & 0xf8;
403         g = (v >> 3) & 0xfc;
404         b = (v << 3) & 0xf8;
405         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
406         addr += 2;
407         d += 4;
408     } while (--w != 0);
409     return NULL;
410 }
411 
412 /*
413  * 24 bit color
414  */
415 static void *vga_draw_line24_le(VGACommonState *vga, uint8_t *d,
416                                 uint32_t addr, int width, int hpel)
417 {
418     int w;
419     uint32_t r, g, b;
420 
421     w = width;
422     do {
423         b = vga_read_byte(vga, addr + 0);
424         g = vga_read_byte(vga, addr + 1);
425         r = vga_read_byte(vga, addr + 2);
426         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
427         addr += 3;
428         d += 4;
429     } while (--w != 0);
430     return NULL;
431 }
432 
433 static void *vga_draw_line24_be(VGACommonState *vga, uint8_t *d,
434                                 uint32_t addr, int width, int hpel)
435 {
436     int w;
437     uint32_t r, g, b;
438 
439     w = width;
440     do {
441         r = vga_read_byte(vga, addr + 0);
442         g = vga_read_byte(vga, addr + 1);
443         b = vga_read_byte(vga, addr + 2);
444         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
445         addr += 3;
446         d += 4;
447     } while (--w != 0);
448     return NULL;
449 }
450 
451 /*
452  * 32 bit color
453  */
454 static void *vga_draw_line32_le(VGACommonState *vga, uint8_t *d,
455                                 uint32_t addr, int width, int hpel)
456 {
457     int w;
458     uint32_t r, g, b;
459 
460     w = width;
461     do {
462         b = vga_read_byte(vga, addr + 0);
463         g = vga_read_byte(vga, addr + 1);
464         r = vga_read_byte(vga, addr + 2);
465         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
466         addr += 4;
467         d += 4;
468     } while (--w != 0);
469     return NULL;
470 }
471 
472 static void *vga_draw_line32_be(VGACommonState *vga, uint8_t *d,
473                                 uint32_t addr, int width, int hpel)
474 {
475     int w;
476     uint32_t r, g, b;
477 
478     w = width;
479     do {
480         r = vga_read_byte(vga, addr + 1);
481         g = vga_read_byte(vga, addr + 2);
482         b = vga_read_byte(vga, addr + 3);
483         ((uint32_t *)d)[0] = rgb_to_pixel32(r, g, b);
484         addr += 4;
485         d += 4;
486     } while (--w != 0);
487     return NULL;
488 }
489