1 // Code for manipulating VGA framebuffers.
3 // Copyright (C) 2009-2014 Kevin O'Connor <kevin@koconnor.net>
4 // Copyright (C) 2001-2008 the LGPL VGABios developers Team
6 // This file may be distributed under the terms of the GNU LGPLv3 license.
8 #include "biosvar.h" // GET_BDA
9 #include "byteorder.h" // cpu_to_be16
10 #include "output.h" // dprintf
11 #include "stdvga.h" // stdvga_planar4_plane
12 #include "string.h" // memset_far
13 #include "vgabios.h" // vgafb_scroll
14 #include "vgahw.h" // vgahw_get_linelength
17 memmove_stride(u16 seg, void *dst, void *src, int copylen, int stride, int lines)
20 dst += stride * (lines - 1);
21 src += stride * (lines - 1);
24 for (; lines; lines--, dst+=stride, src+=stride)
25 memcpy_far(seg, dst, seg, src, copylen);
29 memset_stride(u16 seg, void *dst, u8 val, int setlen, int stride, int lines)
31 for (; lines; lines--, dst+=stride)
32 memset_far(seg, dst, val, setlen);
36 memset16_stride(u16 seg, void *dst, u16 val, int setlen, int stride, int lines)
38 for (; lines; lines--, dst+=stride)
39 memset16_far(seg, dst, val, setlen);
43 /****************************************************************
44 * Basic stdvga graphic manipulation
45 ****************************************************************/
48 gfx_planar(struct gfx_op *op)
50 if (!CONFIG_VGA_STDVGA_PORTS)
52 void *dest_far = (void*)(op->y * op->linelength + op->x / 8);
57 memset(op->pixels, 0, sizeof(op->pixels));
58 for (plane = 0; plane < 4; plane++) {
59 stdvga_planar4_plane(plane);
60 u8 data = GET_FARVAR(SEG_GRAPH, *(u8*)dest_far);
62 for (pixel=0; pixel<8; pixel++)
63 op->pixels[pixel] |= ((data>>(7-pixel)) & 1) << plane;
67 for (plane = 0; plane<4; plane++) {
68 stdvga_planar4_plane(plane);
71 for (pixel=0; pixel<8; pixel++)
72 data |= ((op->pixels[pixel]>>plane) & 1) << (7-pixel);
73 SET_FARVAR(SEG_GRAPH, *(u8*)dest_far, data);
77 for (plane = 0; plane < 4; plane++) {
78 stdvga_planar4_plane(plane);
79 u8 data = (op->pixels[0] & (1<<plane)) ? 0xff : 0x00;
80 memset_stride(SEG_GRAPH, dest_far, data
81 , op->xlen / 8, op->linelength, op->ylen);
85 void *src_far = (void*)(op->srcy * op->linelength + op->x / 8);
86 for (plane = 0; plane < 4; plane++) {
87 stdvga_planar4_plane(plane);
88 memmove_stride(SEG_GRAPH, dest_far, src_far
89 , op->xlen / 8, op->linelength, op->ylen);
93 stdvga_planar4_plane(-1);
97 gfx_cga(struct gfx_op *op)
99 int bpp = GET_GLOBAL(op->vmode_g->depth);
100 void *dest_far = (void*)(op->y / 2 * op->linelength + op->x / 8 * bpp);
107 u8 data = GET_FARVAR(SEG_CTEXT, *(u8*)dest_far);
109 for (pixel=0; pixel<8; pixel++)
110 op->pixels[pixel] = (data >> (7-pixel)) & 1;
112 u16 data = GET_FARVAR(SEG_CTEXT, *(u16*)dest_far);
113 data = be16_to_cpu(data);
115 for (pixel=0; pixel<8; pixel++)
116 op->pixels[pixel] = (data >> ((7-pixel)*2)) & 3;
125 for (pixel=0; pixel<8; pixel++)
126 data |= (op->pixels[pixel] & 1) << (7-pixel);
127 SET_FARVAR(SEG_CTEXT, *(u8*)dest_far, data);
131 for (pixel=0; pixel<8; pixel++)
132 data |= (op->pixels[pixel] & 3) << ((7-pixel) * 2);
133 data = cpu_to_be16(data);
134 SET_FARVAR(SEG_CTEXT, *(u16*)dest_far, data);
138 u8 data = op->pixels[0];
140 data = (data&1) | ((data&1)<<1);
142 data |= (data<<2) | (data<<4) | (data<<6);
143 memset_stride(SEG_CTEXT, dest_far, data
144 , op->xlen / 8 * bpp, op->linelength, op->ylen / 2);
145 memset_stride(SEG_CTEXT, dest_far + 0x2000, data
146 , op->xlen / 8 * bpp, op->linelength, op->ylen / 2);
149 void *src_far = (void*)(op->srcy / 2 * op->linelength + op->x / 8 * bpp);
150 memmove_stride(SEG_CTEXT, dest_far, src_far
151 , op->xlen / 8 * bpp, op->linelength, op->ylen / 2);
152 memmove_stride(SEG_CTEXT, dest_far + 0x2000, src_far + 0x2000
153 , op->xlen / 8 * bpp, op->linelength, op->ylen / 2);
159 gfx_packed(struct gfx_op *op)
161 void *dest_far = (void*)(op->y * op->linelength + op->x);
165 memcpy_far(GET_SEG(SS), op->pixels, SEG_GRAPH, dest_far, 8);
168 memcpy_far(SEG_GRAPH, dest_far, GET_SEG(SS), op->pixels, 8);
171 memset_stride(SEG_GRAPH, dest_far, op->pixels[0]
172 , op->xlen, op->linelength, op->ylen);
175 void *src_far = (void*)(op->srcy * op->linelength + op->x);
176 memmove_stride(SEG_GRAPH, dest_far, src_far
177 , op->xlen, op->linelength, op->ylen);
183 /****************************************************************
184 * Direct framebuffers in high mem
185 ****************************************************************/
187 // Use int 1587 call to copy memory to/from the framebuffer.
189 memcpy_high(void *dest, void *src, u32 len)
192 gdt[2] = GDT_DATA | GDT_LIMIT(0xfffff) | GDT_BASE((u32)src);
193 gdt[3] = GDT_DATA | GDT_LIMIT(0xfffff) | GDT_BASE((u32)dest);
195 // Call int 1587 to copy data.
200 SET_SEG(ES, GET_SEG(SS));
208 : "=r" (flags), "+a" (eax), "+S" (si), "+c" (len)
213 memmove_stride_high(void *dst, void *src, int copylen, int stride, int lines)
216 dst += stride * (lines - 1);
217 src += stride * (lines - 1);
220 for (; lines; lines--, dst+=stride, src+=stride)
221 memcpy_high(dst, src, copylen);
224 // Map a CGA color to a "direct" mode rgb value.
226 get_color(int depth, u8 attr)
228 int rbits, gbits, bbits;
230 case 15: rbits=5; gbits=5; bbits=5; break;
231 case 16: rbits=5; gbits=6; bbits=5; break;
233 case 24: rbits=8; gbits=8; bbits=8; break;
235 int h = (attr&8) ? 1 : 0;
236 int r = (attr&4) ? 2 : 0, g = (attr&2) ? 2 : 0, b = (attr&1) ? 2 : 0;
237 if ((attr & 0xf) == 6)
239 int rv = DIV_ROUND_CLOSEST(((1<<rbits) - 1) * (r + h), 3);
240 int gv = DIV_ROUND_CLOSEST(((1<<gbits) - 1) * (g + h), 3);
241 int bv = DIV_ROUND_CLOSEST(((1<<bbits) - 1) * (b + h), 3);
242 return (rv << (gbits+bbits)) + (gv << bbits) + bv;
245 // Find the closest attribute for a given framebuffer color
247 reverse_color(int depth, u32 color)
249 int rbits, gbits, bbits;
251 case 15: rbits=5; gbits=5; bbits=5; break;
252 case 16: rbits=5; gbits=6; bbits=5; break;
254 case 24: rbits=8; gbits=8; bbits=8; break;
256 int rv = (color >> (gbits+bbits)) & ((1<<rbits)-1);
257 int gv = (color >> bbits) & ((1<<gbits)-1);
258 int bv = color & ((1<<bbits)-1);
259 int r = DIV_ROUND_CLOSEST(rv * 3, (1<<rbits) - 1);
260 int g = DIV_ROUND_CLOSEST(gv * 3, (1<<gbits) - 1);
261 int b = DIV_ROUND_CLOSEST(bv * 3, (1<<bbits) - 1);
262 int h = r && g && b && (r != 2 || g != 2 || b != 2);
263 return (h ? 8 : 0) | ((r-h) ? 4 : 0) | ((g-h) ? 2 : 0) | ((b-h) ? 1 : 0);
267 gfx_direct(struct gfx_op *op)
269 void *fb = (void*)GET_GLOBAL(VBE_framebuffer);
272 int depth = GET_GLOBAL(op->vmode_g->depth);
273 int bypp = DIV_ROUND_UP(depth, 8);
274 void *dest_far = (fb + op->displaystart + op->y * op->linelength
281 memcpy_high(MAKE_FLATPTR(GET_SEG(SS), data), dest_far, bypp * 8);
283 op->pixels[i] = reverse_color(depth, *(u32*)&data[i*bypp]);
287 *(u32*)&data[i*bypp] = get_color(depth, op->pixels[i]);
288 memcpy_high(dest_far, MAKE_FLATPTR(GET_SEG(SS), data), bypp * 8);
291 u32 color = get_color(depth, op->pixels[0]);
293 *(u32*)&data[i*bypp] = color;
294 memcpy_high(dest_far, MAKE_FLATPTR(GET_SEG(SS), data), bypp * 8);
295 memcpy_high(dest_far + bypp * 8, dest_far, op->xlen * bypp - bypp * 8);
296 for (i=1; i < op->ylen; i++)
297 memcpy_high(dest_far + op->linelength * i
298 , dest_far, op->xlen * bypp);
301 void *src_far = (fb + op->displaystart + op->srcy * op->linelength
303 memmove_stride_high(dest_far, src_far
304 , op->xlen * bypp, op->linelength, op->ylen);
310 /****************************************************************
312 ****************************************************************/
314 // Prepare a struct gfx_op for use.
316 init_gfx_op(struct gfx_op *op, struct vgamode_s *vmode_g)
318 memset(op, 0, sizeof(*op));
319 op->vmode_g = vmode_g;
320 op->linelength = vgahw_get_linelength(vmode_g);
321 op->displaystart = vgahw_get_displaystart(vmode_g);
324 // Issue a graphics operation.
326 handle_gfx_op(struct gfx_op *op)
328 switch (GET_GLOBAL(op->vmode_g->memmodel)) {
346 // Move characters when in graphics mode.
348 gfx_move_chars(struct vgamode_s *vmode_g, struct cursorpos dest
349 , struct cursorpos src, struct cursorpos movesize)
352 init_gfx_op(&op, vmode_g);
354 op.xlen = movesize.x * 8;
355 int cheight = GET_BDA(char_height);
356 op.y = dest.y * cheight;
357 op.ylen = movesize.y * cheight;
358 op.srcy = src.y * cheight;
363 // Clear area of screen in graphics mode.
365 gfx_clear_chars(struct vgamode_s *vmode_g, struct cursorpos dest
366 , struct carattr ca, struct cursorpos clearsize)
369 init_gfx_op(&op, vmode_g);
371 op.xlen = clearsize.x * 8;
372 int cheight = GET_BDA(char_height);
373 op.y = dest.y * cheight;
374 op.ylen = clearsize.y * cheight;
375 op.pixels[0] = ca.attr;
376 if (vga_emulate_text())
377 op.pixels[0] = ca.attr >> 4;
382 // Return the font for a given character
386 int char_height = GET_BDA(char_height);
387 struct segoff_s font;
388 if (char_height == 8 && c >= 128) {
389 font = GET_IVT(0x1f);
392 font = GET_IVT(0x43);
394 font.offset += c * char_height;
398 // Write a character to the screen in graphics mode.
400 gfx_write_char(struct vgamode_s *vmode_g
401 , struct cursorpos cp, struct carattr ca)
403 if (cp.x >= GET_BDA(video_cols))
406 struct segoff_s font = get_font_data(ca.car);
408 init_gfx_op(&op, vmode_g);
410 int cheight = GET_BDA(char_height);
411 op.y = cp.y * cheight;
412 u8 fgattr = ca.attr, bgattr = 0x00;
414 if (vga_emulate_text()) {
416 bgattr = fgattr >> 4;
417 fgattr = fgattr & 0x0f;
419 // Read bottom right pixel of the cell to guess bg color
424 bgattr = op.pixels[7];
425 fgattr = bgattr ^ 0x7;
427 } else if (fgattr & 0x80 && GET_GLOBAL(vmode_g->depth) < 8) {
432 for (i = 0; i < cheight; i++, op.y++) {
433 u8 fontline = GET_FARVAR(font.seg, *(u8*)(font.offset+i));
438 for (j = 0; j < 8; j++)
439 op.pixels[j] ^= (fontline & (0x80>>j)) ? fgattr : 0x00;
442 for (j = 0; j < 8; j++)
443 op.pixels[j] = (fontline & (0x80>>j)) ? fgattr : bgattr;
450 // Read a character from the screen in graphics mode.
451 static struct carattr
452 gfx_read_char(struct vgamode_s *vmode_g, struct cursorpos cp)
455 int cheight = GET_BDA(char_height);
456 if (cp.x >= GET_BDA(video_cols) || cheight > ARRAY_SIZE(lines))
459 // Read cell from screen
461 init_gfx_op(&op, vmode_g);
464 op.y = cp.y * cheight;
466 u8 fgattr = 0x00, bgattr = 0x00;
467 if (vga_emulate_text()) {
468 // Read bottom right pixel of the cell to guess bg color
472 bgattr = op.pixels[7];
473 fgattr = bgattr ^ 0x7;
474 // Report space character for blank cells (skip null character check)
478 for (i=0; i<cheight; i++, op.y++) {
482 if (op.pixels[j] != bgattr) {
484 fgattr = op.pixels[j];
490 for (; car<256; car++) {
491 struct segoff_s font = get_font_data(car);
492 if (memcmp_far(GET_SEG(SS), lines
493 , font.seg, (void*)(font.offset+0), cheight) == 0)
494 return (struct carattr){car, fgattr | (bgattr << 4), 0};
497 return (struct carattr){0, 0, 0};
500 // Draw/undraw a cursor on the framebuffer by xor'ing the cursor cell
502 gfx_set_swcursor(struct vgamode_s *vmode_g, int enable, struct cursorpos cp)
504 u16 cursor_type = get_cursor_shape();
505 u8 start = cursor_type >> 8, end = cursor_type & 0xff;
507 init_gfx_op(&op, vmode_g);
509 int cheight = GET_BDA(char_height);
510 op.y = cp.y * cheight + start;
513 for (i = start; i < cheight && i <= end; i++, op.y++) {
517 for (j = 0; j < 8; j++)
518 op.pixels[j] ^= 0x07;
524 // Set the pixel at the given position.
526 vgafb_write_pixel(u8 color, u16 x, u16 y)
528 struct vgamode_s *vmode_g = get_current_mode();
531 vgafb_set_swcursor(0);
534 init_gfx_op(&op, vmode_g);
535 op.x = ALIGN_DOWN(x, 8);
540 int usexor = color & 0x80 && GET_GLOBAL(vmode_g->depth) < 8;
542 op.pixels[x & 0x07] ^= color & 0x7f;
544 op.pixels[x & 0x07] = color;
549 // Return the pixel at the given position.
551 vgafb_read_pixel(u16 x, u16 y)
553 struct vgamode_s *vmode_g = get_current_mode();
556 vgafb_set_swcursor(0);
559 init_gfx_op(&op, vmode_g);
560 op.x = ALIGN_DOWN(x, 8);
565 return op.pixels[x & 0x07];
569 /****************************************************************
571 ****************************************************************/
573 // Return the fb offset for the given character address when in text mode.
575 text_address(struct cursorpos cp)
577 int stride = GET_BDA(video_cols) * 2;
578 u32 pageoffset = GET_BDA(video_pagesize) * cp.page;
579 return (void*)pageoffset + cp.y * stride + cp.x * 2;
582 // Move characters on screen.
584 vgafb_move_chars(struct cursorpos dest
585 , struct cursorpos src, struct cursorpos movesize)
587 struct vgamode_s *vmode_g = get_current_mode();
590 vgafb_set_swcursor(0);
592 if (GET_GLOBAL(vmode_g->memmodel) != MM_TEXT) {
593 gfx_move_chars(vmode_g, dest, src, movesize);
597 int stride = GET_BDA(video_cols) * 2;
598 memmove_stride(GET_GLOBAL(vmode_g->sstart)
599 , text_address(dest), text_address(src)
600 , movesize.x * 2, stride, movesize.y);
603 // Clear area of screen.
605 vgafb_clear_chars(struct cursorpos dest
606 , struct carattr ca, struct cursorpos clearsize)
608 struct vgamode_s *vmode_g = get_current_mode();
611 vgafb_set_swcursor(0);
613 if (GET_GLOBAL(vmode_g->memmodel) != MM_TEXT) {
614 gfx_clear_chars(vmode_g, dest, ca, clearsize);
618 int stride = GET_BDA(video_cols) * 2;
619 u16 attr = ((ca.use_attr ? ca.attr : 0x07) << 8) | ca.car;
620 memset16_stride(GET_GLOBAL(vmode_g->sstart), text_address(dest), attr
621 , clearsize.x * 2, stride, clearsize.y);
624 // Write a character to the screen.
626 vgafb_write_char(struct cursorpos cp, struct carattr ca)
628 struct vgamode_s *vmode_g = get_current_mode();
631 vgafb_set_swcursor(0);
633 if (GET_GLOBAL(vmode_g->memmodel) != MM_TEXT) {
634 gfx_write_char(vmode_g, cp, ca);
638 void *dest_far = text_address(cp);
640 u16 dummy = (ca.attr << 8) | ca.car;
641 SET_FARVAR(GET_GLOBAL(vmode_g->sstart), *(u16*)dest_far, dummy);
643 SET_FARVAR(GET_GLOBAL(vmode_g->sstart), *(u8*)dest_far, ca.car);
647 // Return the character at the given position on the screen.
649 vgafb_read_char(struct cursorpos cp)
651 struct vgamode_s *vmode_g = get_current_mode();
653 return (struct carattr){0, 0, 0};
654 vgafb_set_swcursor(0);
656 if (GET_GLOBAL(vmode_g->memmodel) != MM_TEXT)
657 return gfx_read_char(vmode_g, cp);
659 u16 *dest_far = text_address(cp);
660 u16 v = GET_FARVAR(GET_GLOBAL(vmode_g->sstart), *dest_far);
661 return (struct carattr){v, v>>8, 0};
664 // Draw/undraw a cursor on the screen
666 vgafb_set_swcursor(int enable)
668 if (!vga_emulate_text())
670 u8 flags = GET_BDA_EXT(flags);
671 if (!!(flags & BF_SWCURSOR) == enable)
672 // Already in requested mode.
674 struct vgamode_s *vmode_g = get_current_mode();
677 struct cursorpos cp = get_cursor_pos(0xff);
678 if (cp.x >= GET_BDA(video_cols) || cp.y > GET_BDA(video_rows)
679 || GET_BDA(cursor_type) >= 0x2000)
680 // Cursor not visible
683 SET_BDA_EXT(flags, (flags & ~BF_SWCURSOR) | (enable ? BF_SWCURSOR : 0));
685 if (GET_GLOBAL(vmode_g->memmodel) != MM_TEXT) {
686 gfx_set_swcursor(vmode_g, enable, cp);
690 // In text mode, swap foreground and background attributes for cursor
691 void *dest_far = text_address(cp) + 1;
692 u8 attr = GET_FARVAR(GET_GLOBAL(vmode_g->sstart), *(u8*)dest_far);
693 attr = (attr >> 4) | (attr << 4);
694 SET_FARVAR(GET_GLOBAL(vmode_g->sstart), *(u8*)dest_far, attr);