![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vgabios.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / vgasrc|
Return to vgabios.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / vgasrc |
1.1 root 1: // VGA bios implementation
2: //
3: // Copyright (C) 2009-2012 Kevin O'Connor <[email protected]>
4: // Copyright (C) 2001-2008 the LGPL VGABios developers Team
5: //
6: // This file may be distributed under the terms of the GNU LGPLv3 license.
7:
8: #include "bregs.h" // struct bregs
9: #include "biosvar.h" // GET_BDA
10: #include "util.h" // memset
11: #include "vgabios.h" // calc_page_size
12: #include "optionroms.h" // struct pci_data
13: #include "config.h" // CONFIG_*
14: #include "stdvga.h" // stdvga_set_cursor_shape
15: #include "clext.h" // clext_1012
16: #include "vgahw.h" // vgahw_set_mode
17: #include "vbe.h" // VBE_RETURN_STATUS_FAILED
18: #include "pci.h" // pci_config_readw
19: #include "pci_regs.h" // PCI_VENDOR_ID
20:
21: // Standard Video Save Pointer Table
22: struct VideoSavePointer_s {
23: struct segoff_s videoparam;
24: struct segoff_s paramdynamicsave;
25: struct segoff_s textcharset;
26: struct segoff_s graphcharset;
27: struct segoff_s secsavepointer;
28: u8 reserved[8];
29: } PACKED;
30:
31: static struct VideoSavePointer_s video_save_pointer_table VAR16;
32:
33: struct VideoParam_s video_param_table[29] VAR16;
34:
35:
36: /****************************************************************
37: * PCI Data
38: ****************************************************************/
39:
40: struct pci_data rom_pci_data VAR16VISIBLE = {
41: .signature = PCI_ROM_SIGNATURE,
42: .vendor = CONFIG_VGA_VID,
43: .device = CONFIG_VGA_DID,
44: .dlen = 0x18,
45: .class_hi = 0x300,
46: .irevision = 1,
47: .type = PCIROM_CODETYPE_X86,
48: .indicator = 0x80,
49: };
50:
51:
52: /****************************************************************
53: * Helper functions
54: ****************************************************************/
55:
56: // Return the bits per pixel in system memory for a given mode.
57: int
58: vga_bpp(struct vgamode_s *vmode_g)
59: {
60: switch (GET_GLOBAL(vmode_g->memmodel)) {
61: case MM_TEXT:
62: return 16;
63: case MM_PLANAR:
64: return 1;
65: }
66: u8 depth = GET_GLOBAL(vmode_g->depth);
67: if (depth > 8)
68: return ALIGN(depth, 8);
69: return depth;
70: }
71:
72: u16
73: calc_page_size(u8 memmodel, u16 width, u16 height)
74: {
75: switch (memmodel) {
76: case MM_TEXT:
77: return ALIGN(width * height * 2, 2*1024);
78: case MM_CGA:
79: return 16*1024;
80: default:
81: return ALIGN(width * height / 8, 8*1024);
82: }
83: }
84:
85: static void
86: set_cursor_shape(u8 start, u8 end)
87: {
88: start &= 0x3f;
89: end &= 0x1f;
90:
91: u16 curs = (start << 8) + end;
92: SET_BDA(cursor_type, curs);
93:
94: u8 modeset_ctl = GET_BDA(modeset_ctl);
95: u16 cheight = GET_BDA(char_height);
96: if ((modeset_ctl & 0x01) && (cheight > 8) && (end < 8) && (start < 0x20)) {
97: if (end != (start + 1))
98: start = ((start + 1) * cheight / 8) - 1;
99: else
100: start = ((end + 1) * cheight / 8) - 2;
101: end = ((end + 1) * cheight / 8) - 1;
102: }
103: stdvga_set_cursor_shape(start, end);
104: }
105:
106: static u16
107: get_cursor_shape(u8 page)
108: {
109: if (page > 7)
110: return 0;
111: // FIXME should handle VGA 14/16 lines
112: return GET_BDA(cursor_type);
113: }
114:
115: static void
116: set_cursor_pos(struct cursorpos cp)
117: {
118: u8 page = cp.page, x = cp.x, y = cp.y;
119:
120: // Should not happen...
121: if (page > 7)
122: return;
123:
124: // Bios cursor pos
125: SET_BDA(cursor_pos[page], (y << 8) | x);
126:
127: // Set the hardware cursor
128: u8 current = GET_BDA(video_page);
129: if (cp.page != current)
130: return;
131:
132: // Calculate the memory address
133: int address = (GET_BDA(video_pagesize) * page
134: + (x + y * GET_BDA(video_cols)) * 2);
135: stdvga_set_cursor_pos(address);
136: }
137:
138: static struct cursorpos
139: get_cursor_pos(u8 page)
140: {
141: if (page == 0xff)
142: // special case - use current page
143: page = GET_BDA(video_page);
144: if (page > 7) {
145: struct cursorpos cp = { 0, 0, 0xfe };
146: return cp;
147: }
148: // FIXME should handle VGA 14/16 lines
149: u16 xy = GET_BDA(cursor_pos[page]);
150: struct cursorpos cp = {xy, xy>>8, page};
151: return cp;
152: }
153:
154: static void
155: set_active_page(u8 page)
156: {
157: if (page > 7)
158: return;
159:
160: // Get the mode
161: struct vgamode_s *vmode_g = get_current_mode();
162: if (!vmode_g)
163: return;
164:
165: // Get cursor pos for the given page
166: struct cursorpos cp = get_cursor_pos(page);
167:
168: // Calculate memory address of start of page
169: int address = GET_BDA(video_pagesize) * page;
170: vgahw_set_displaystart(vmode_g, address);
171:
172: // And change the BIOS page
173: SET_BDA(video_pagestart, address);
174: SET_BDA(video_page, page);
175:
176: dprintf(1, "Set active page %02x address %04x\n", page, address);
177:
178: // Display the cursor, now the page is active
179: set_cursor_pos(cp);
180: }
181:
182: static void
183: set_scan_lines(u8 lines)
184: {
185: stdvga_set_scan_lines(lines);
186: if (lines == 8)
187: set_cursor_shape(0x06, 0x07);
188: else
189: set_cursor_shape(lines - 4, lines - 3);
190: SET_BDA(char_height, lines);
191: u16 vde = stdvga_get_vde();
192: u8 rows = vde / lines;
193: SET_BDA(video_rows, rows - 1);
194: u16 cols = GET_BDA(video_cols);
195: SET_BDA(video_pagesize, calc_page_size(MM_TEXT, cols, rows));
196: }
197:
198:
199: /****************************************************************
200: * Character writing
201: ****************************************************************/
202:
203: // Scroll the screen one line. This function is designed to be called
204: // tail-recursive to reduce stack usage.
205: static void noinline
206: scroll_one(u16 nbrows, u16 nbcols, u8 page)
207: {
208: struct cursorpos ul = {0, 0, page};
209: struct cursorpos lr = {nbcols-1, nbrows-1, page};
210: vgafb_scroll(1, -1, ul, lr);
211: }
212:
213: // Write a character to the screen at a given position. Implement
214: // special characters and scroll the screen if necessary.
215: static void
216: write_teletype(struct cursorpos *pcp, struct carattr ca)
217: {
218: struct cursorpos cp = *pcp;
219:
220: // Get the dimensions
221: u16 nbrows = GET_BDA(video_rows) + 1;
222: u16 nbcols = GET_BDA(video_cols);
223:
224: switch (ca.car) {
225: case 7:
226: //FIXME should beep
227: break;
228: case 8:
229: if (cp.x > 0)
230: cp.x--;
231: break;
232: case '\r':
233: cp.x = 0;
234: break;
235: case '\n':
236: cp.y++;
237: break;
238: case '\t':
239: ca.car = ' ';
240: do {
241: vgafb_write_char(cp, ca);
242: cp.x++;
243: } while (cp.x < nbcols && cp.x % 8);
244: break;
245: default:
246: vgafb_write_char(cp, ca);
247: cp.x++;
248: }
249:
250: // Do we need to wrap ?
251: if (cp.x == nbcols) {
252: cp.x = 0;
253: cp.y++;
254: }
255: // Do we need to scroll ?
256: if (cp.y < nbrows) {
257: *pcp = cp;
258: return;
259: }
260: // Scroll screen
261: cp.y--;
262: *pcp = cp;
263: scroll_one(nbrows, nbcols, cp.page);
264: }
265:
266:
267: /****************************************************************
268: * Save and restore bda state
269: ****************************************************************/
270:
271: void
272: save_bda_state(u16 seg, struct saveBDAstate *info)
273: {
274: SET_FARVAR(seg, info->video_mode, GET_BDA(vbe_mode));
275: SET_FARVAR(seg, info->video_cols, GET_BDA(video_cols));
276: SET_FARVAR(seg, info->video_pagesize, GET_BDA(video_pagesize));
277: SET_FARVAR(seg, info->crtc_address, GET_BDA(crtc_address));
278: SET_FARVAR(seg, info->video_rows, GET_BDA(video_rows));
279: SET_FARVAR(seg, info->char_height, GET_BDA(char_height));
280: SET_FARVAR(seg, info->video_ctl, GET_BDA(video_ctl));
281: SET_FARVAR(seg, info->video_switches, GET_BDA(video_switches));
282: SET_FARVAR(seg, info->modeset_ctl, GET_BDA(modeset_ctl));
283: SET_FARVAR(seg, info->cursor_type, GET_BDA(cursor_type));
284: int i;
285: for (i=0; i<8; i++)
286: SET_FARVAR(seg, info->cursor_pos[i], GET_BDA(cursor_pos[i]));
287: SET_FARVAR(seg, info->video_pagestart, GET_BDA(video_pagestart));
288: SET_FARVAR(seg, info->video_page, GET_BDA(video_page));
289: /* current font */
290: SET_FARVAR(seg, info->font0, GET_IVT(0x1f));
291: SET_FARVAR(seg, info->font1, GET_IVT(0x43));
292: }
293:
294: void
295: restore_bda_state(u16 seg, struct saveBDAstate *info)
296: {
297: u16 mode = GET_FARVAR(seg, info->video_mode);
298: SET_BDA(vbe_mode, mode);
299: if (mode < 0x100)
300: SET_BDA(video_mode, mode);
301: else
302: SET_BDA(video_mode, 0xff);
303: SET_BDA(video_cols, GET_FARVAR(seg, info->video_cols));
304: SET_BDA(video_pagesize, GET_FARVAR(seg, info->video_pagesize));
305: SET_BDA(crtc_address, GET_FARVAR(seg, info->crtc_address));
306: SET_BDA(video_rows, GET_FARVAR(seg, info->video_rows));
307: SET_BDA(char_height, GET_FARVAR(seg, info->char_height));
308: SET_BDA(video_ctl, GET_FARVAR(seg, info->video_ctl));
309: SET_BDA(video_switches, GET_FARVAR(seg, info->video_switches));
310: SET_BDA(modeset_ctl, GET_FARVAR(seg, info->modeset_ctl));
311: SET_BDA(cursor_type, GET_FARVAR(seg, info->cursor_type));
312: int i;
313: for (i = 0; i < 8; i++)
314: SET_BDA(cursor_pos[i], GET_FARVAR(seg, info->cursor_pos[i]));
315: SET_BDA(video_pagestart, GET_FARVAR(seg, info->video_pagestart));
316: SET_BDA(video_page, GET_FARVAR(seg, info->video_page));
317: /* current font */
318: SET_IVT(0x1f, GET_FARVAR(seg, info->font0));
319: SET_IVT(0x43, GET_FARVAR(seg, info->font1));
320: }
321:
322:
323: /****************************************************************
324: * Mode setting
325: ****************************************************************/
326:
327: struct vgamode_s *
328: get_current_mode(void)
329: {
330: return vgahw_find_mode(GET_BDA(vbe_mode) & ~MF_VBEFLAGS);
331: }
332:
333: // Setup BDA after a mode switch.
334: int
335: vga_set_mode(int mode, int flags)
336: {
337: dprintf(1, "set VGA mode %x\n", mode);
338: struct vgamode_s *vmode_g = vgahw_find_mode(mode);
339: if (!vmode_g)
340: return VBE_RETURN_STATUS_FAILED;
341:
342: int ret = vgahw_set_mode(vmode_g, flags);
343: if (ret)
344: return ret;
345:
346: // Set the BIOS mem
347: int width = GET_GLOBAL(vmode_g->width);
348: int height = GET_GLOBAL(vmode_g->height);
349: u8 memmodel = GET_GLOBAL(vmode_g->memmodel);
350: int cheight = GET_GLOBAL(vmode_g->cheight);
351: if (mode < 0x100)
352: SET_BDA(video_mode, mode);
353: else
354: SET_BDA(video_mode, 0xff);
355: SET_BDA(vbe_mode, mode | (flags & MF_VBEFLAGS));
356: if (memmodel == MM_TEXT) {
357: SET_BDA(video_cols, width);
358: SET_BDA(video_rows, height-1);
359: SET_BDA(cursor_type, 0x0607);
360: } else {
361: int cwidth = GET_GLOBAL(vmode_g->cwidth);
362: SET_BDA(video_cols, width / cwidth);
363: SET_BDA(video_rows, (height / cheight) - 1);
364: SET_BDA(cursor_type, 0x0000);
365: }
366: SET_BDA(video_pagesize, calc_page_size(memmodel, width, height));
367: SET_BDA(crtc_address, stdvga_get_crtc());
368: SET_BDA(char_height, cheight);
369: SET_BDA(video_ctl, 0x60 | (flags & MF_NOCLEARMEM ? 0x80 : 0x00));
370: SET_BDA(video_switches, 0xF9);
371: SET_BDA(modeset_ctl, GET_BDA(modeset_ctl) & 0x7f);
372: int i;
373: for (i=0; i<8; i++)
374: SET_BDA(cursor_pos[i], 0x0000);
375: SET_BDA(video_pagestart, 0x0000);
376: SET_BDA(video_page, 0x00);
377:
378: // FIXME We nearly have the good tables. to be reworked
379: SET_BDA(dcc_index, 0x08); // 8 is VGA should be ok for now
380: SET_BDA(video_savetable
381: , SEGOFF(get_global_seg(), (u32)&video_save_pointer_table));
382:
383: // FIXME
384: SET_BDA(video_msr, 0x00); // Unavailable on vanilla vga, but...
385: SET_BDA(video_pal, 0x00); // Unavailable on vanilla vga, but...
386:
387: // Set the ints 0x1F and 0x43
388: SET_IVT(0x1f, SEGOFF(get_global_seg(), (u32)&vgafont8[128 * 8]));
389:
390: switch (cheight) {
391: case 8:
392: SET_IVT(0x43, SEGOFF(get_global_seg(), (u32)vgafont8));
393: break;
394: case 14:
395: SET_IVT(0x43, SEGOFF(get_global_seg(), (u32)vgafont14));
396: break;
397: case 16:
398: SET_IVT(0x43, SEGOFF(get_global_seg(), (u32)vgafont16));
399: break;
400: }
401:
402: return 0;
403: }
404:
405:
406: /****************************************************************
407: * VGA int 10 handler
408: ****************************************************************/
409:
410: static void
411: handle_1000(struct bregs *regs)
412: {
413: int mode = regs->al & 0x7f;
414:
415: // Set regs->al
416: if (mode > 7)
417: regs->al = 0x20;
418: else if (mode == 6)
419: regs->al = 0x3f;
420: else
421: regs->al = 0x30;
422:
423: int flags = GET_BDA(modeset_ctl) & (MF_NOPALETTE|MF_GRAYSUM);
424: if (regs->al & 0x80)
425: flags |= MF_NOCLEARMEM;
426:
427: vga_set_mode(mode, flags);
428: }
429:
430: static void
431: handle_1001(struct bregs *regs)
432: {
433: set_cursor_shape(regs->ch, regs->cl);
434: }
435:
436: static void
437: handle_1002(struct bregs *regs)
438: {
439: struct cursorpos cp = {regs->dl, regs->dh, regs->bh};
440: set_cursor_pos(cp);
441: }
442:
443: static void
444: handle_1003(struct bregs *regs)
445: {
446: regs->cx = get_cursor_shape(regs->bh);
447: struct cursorpos cp = get_cursor_pos(regs->bh);
448: regs->dl = cp.x;
449: regs->dh = cp.y;
450: }
451:
452: // Read light pen pos (unimplemented)
453: static void
454: handle_1004(struct bregs *regs)
455: {
456: debug_stub(regs);
457: regs->ax = regs->bx = regs->cx = regs->dx = 0;
458: }
459:
460: static void
461: handle_1005(struct bregs *regs)
462: {
463: set_active_page(regs->al);
464: }
465:
466: static void
467: verify_scroll(struct bregs *regs, int dir)
468: {
469: u8 ulx = regs->cl, uly = regs->ch, lrx = regs->dl, lry = regs->dh;
470: u16 nbrows = GET_BDA(video_rows) + 1;
471: if (lry >= nbrows)
472: lry = nbrows - 1;
473: u16 nbcols = GET_BDA(video_cols);
474: if (lrx >= nbcols)
475: lrx = nbcols - 1;
476:
477: if (ulx > lrx || uly > lry)
478: return;
479:
480: int nblines = regs->al;
481: if (!nblines || nblines > lry - uly + 1)
482: nblines = lry - uly + 1;
483:
484: u8 page = GET_BDA(video_page);
485: struct cursorpos ul = {ulx, uly, page};
486: struct cursorpos lr = {lrx, lry, page};
487: vgafb_scroll(dir * nblines, regs->bh, ul, lr);
488: }
489:
490: static void
491: handle_1006(struct bregs *regs)
492: {
493: verify_scroll(regs, 1);
494: }
495:
496: static void
497: handle_1007(struct bregs *regs)
498: {
499: verify_scroll(regs, -1);
500: }
501:
502: static void
503: handle_1008(struct bregs *regs)
504: {
505: struct carattr ca = vgafb_read_char(get_cursor_pos(regs->bh));
506: regs->al = ca.car;
507: regs->ah = ca.attr;
508: }
509:
510: static void noinline
511: write_chars(u8 page, struct carattr ca, u16 count)
512: {
513: u16 nbcols = GET_BDA(video_cols);
514: struct cursorpos cp = get_cursor_pos(page);
515: while (count--) {
516: vgafb_write_char(cp, ca);
517: cp.x++;
518: if (cp.x >= nbcols) {
519: cp.x -= nbcols;
520: cp.y++;
521: }
522: }
523: }
524:
525: static void
526: handle_1009(struct bregs *regs)
527: {
528: struct carattr ca = {regs->al, regs->bl, 1};
529: write_chars(regs->bh, ca, regs->cx);
530: }
531:
532: static void
533: handle_100a(struct bregs *regs)
534: {
535: struct carattr ca = {regs->al, regs->bl, 0};
536: write_chars(regs->bh, ca, regs->cx);
537: }
538:
539:
540: static void
541: handle_100b00(struct bregs *regs)
542: {
543: stdvga_set_border_color(regs->bl);
544: }
545:
546: static void
547: handle_100b01(struct bregs *regs)
548: {
549: stdvga_set_palette(regs->bl);
550: }
551:
552: static void
553: handle_100bXX(struct bregs *regs)
554: {
555: debug_stub(regs);
556: }
557:
558: static void
559: handle_100b(struct bregs *regs)
560: {
561: switch (regs->bh) {
562: case 0x00: handle_100b00(regs); break;
563: case 0x01: handle_100b01(regs); break;
564: default: handle_100bXX(regs); break;
565: }
566: }
567:
568:
569: static void
570: handle_100c(struct bregs *regs)
571: {
572: // XXX - page (regs->bh) is unused
573: vgafb_write_pixel(regs->al, regs->cx, regs->dx);
574: }
575:
576: static void
577: handle_100d(struct bregs *regs)
578: {
579: // XXX - page (regs->bh) is unused
580: regs->al = vgafb_read_pixel(regs->cx, regs->dx);
581: }
582:
583: static void noinline
584: handle_100e(struct bregs *regs)
585: {
586: // Ralf Brown Interrupt list is WRONG on bh(page)
587: // We do output only on the current page !
588: struct carattr ca = {regs->al, regs->bl, 0};
589: struct cursorpos cp = get_cursor_pos(0xff);
590: write_teletype(&cp, ca);
591: set_cursor_pos(cp);
592: }
593:
594: static void
595: handle_100f(struct bregs *regs)
596: {
597: regs->bh = GET_BDA(video_page);
598: regs->al = GET_BDA(video_mode) | (GET_BDA(video_ctl) & 0x80);
599: regs->ah = GET_BDA(video_cols);
600: }
601:
602:
603: static void
604: handle_101000(struct bregs *regs)
605: {
606: if (regs->bl > 0x14)
607: return;
608: stdvga_attr_write(regs->bl, regs->bh);
609: }
610:
611: static void
612: handle_101001(struct bregs *regs)
613: {
614: stdvga_set_overscan_border_color(regs->bh);
615: }
616:
617: static void
618: handle_101002(struct bregs *regs)
619: {
620: stdvga_set_all_palette_reg(regs->es, (u8*)(regs->dx + 0));
621: }
622:
623: static void
624: handle_101003(struct bregs *regs)
625: {
626: stdvga_toggle_intensity(regs->bl);
627: }
628:
629: static void
630: handle_101007(struct bregs *regs)
631: {
632: if (regs->bl > 0x14)
633: return;
634: regs->bh = stdvga_attr_read(regs->bl);
635: }
636:
637: static void
638: handle_101008(struct bregs *regs)
639: {
640: regs->bh = stdvga_get_overscan_border_color();
641: }
642:
643: static void
644: handle_101009(struct bregs *regs)
645: {
646: stdvga_get_all_palette_reg(regs->es, (u8*)(regs->dx + 0));
647: }
648:
649: static void noinline
650: handle_101010(struct bregs *regs)
651: {
652: u8 rgb[3] = {regs->dh, regs->ch, regs->cl};
653: stdvga_dac_write(GET_SEG(SS), rgb, regs->bx, 1);
654: }
655:
656: static void
657: handle_101012(struct bregs *regs)
658: {
659: stdvga_dac_write(regs->es, (u8*)(regs->dx + 0), regs->bx, regs->cx);
660: }
661:
662: static void
663: handle_101013(struct bregs *regs)
664: {
665: stdvga_select_video_dac_color_page(regs->bl, regs->bh);
666: }
667:
668: static void noinline
669: handle_101015(struct bregs *regs)
670: {
671: u8 rgb[3];
672: stdvga_dac_read(GET_SEG(SS), rgb, regs->bx, 1);
673: regs->dh = rgb[0];
674: regs->ch = rgb[1];
675: regs->cl = rgb[2];
676: }
677:
678: static void
679: handle_101017(struct bregs *regs)
680: {
681: stdvga_dac_read(regs->es, (u8*)(regs->dx + 0), regs->bx, regs->cx);
682: }
683:
684: static void
685: handle_101018(struct bregs *regs)
686: {
687: stdvga_pelmask_write(regs->bl);
688: }
689:
690: static void
691: handle_101019(struct bregs *regs)
692: {
693: regs->bl = stdvga_pelmask_read();
694: }
695:
696: static void
697: handle_10101a(struct bregs *regs)
698: {
699: stdvga_read_video_dac_state(®s->bl, ®s->bh);
700: }
701:
702: static void
703: handle_10101b(struct bregs *regs)
704: {
705: stdvga_perform_gray_scale_summing(regs->bx, regs->cx);
706: }
707:
708: static void
709: handle_1010XX(struct bregs *regs)
710: {
711: debug_stub(regs);
712: }
713:
714: static void
715: handle_1010(struct bregs *regs)
716: {
717: switch (regs->al) {
718: case 0x00: handle_101000(regs); break;
719: case 0x01: handle_101001(regs); break;
720: case 0x02: handle_101002(regs); break;
721: case 0x03: handle_101003(regs); break;
722: case 0x07: handle_101007(regs); break;
723: case 0x08: handle_101008(regs); break;
724: case 0x09: handle_101009(regs); break;
725: case 0x10: handle_101010(regs); break;
726: case 0x12: handle_101012(regs); break;
727: case 0x13: handle_101013(regs); break;
728: case 0x15: handle_101015(regs); break;
729: case 0x17: handle_101017(regs); break;
730: case 0x18: handle_101018(regs); break;
731: case 0x19: handle_101019(regs); break;
732: case 0x1a: handle_10101a(regs); break;
733: case 0x1b: handle_10101b(regs); break;
734: default: handle_1010XX(regs); break;
735: }
736: }
737:
738:
739: static void
740: handle_101100(struct bregs *regs)
741: {
742: stdvga_load_font(regs->es, (void*)(regs->bp+0), regs->cx
743: , regs->dx, regs->bl, regs->bh);
744: }
745:
746: static void
747: handle_101101(struct bregs *regs)
748: {
749: stdvga_load_font(get_global_seg(), vgafont14, 0x100, 0, regs->bl, 14);
750: }
751:
752: static void
753: handle_101102(struct bregs *regs)
754: {
755: stdvga_load_font(get_global_seg(), vgafont8, 0x100, 0, regs->bl, 8);
756: }
757:
758: static void
759: handle_101103(struct bregs *regs)
760: {
761: stdvga_set_text_block_specifier(regs->bl);
762: }
763:
764: static void
765: handle_101104(struct bregs *regs)
766: {
767: stdvga_load_font(get_global_seg(), vgafont16, 0x100, 0, regs->bl, 16);
768: }
769:
770: static void
771: handle_101110(struct bregs *regs)
772: {
773: stdvga_load_font(regs->es, (void*)(regs->bp+0), regs->cx
774: , regs->dx, regs->bl, regs->bh);
775: set_scan_lines(regs->bh);
776: }
777:
778: static void
779: handle_101111(struct bregs *regs)
780: {
781: stdvga_load_font(get_global_seg(), vgafont14, 0x100, 0, regs->bl, 14);
782: set_scan_lines(14);
783: }
784:
785: static void
786: handle_101112(struct bregs *regs)
787: {
788: stdvga_load_font(get_global_seg(), vgafont8, 0x100, 0, regs->bl, 8);
789: set_scan_lines(8);
790: }
791:
792: static void
793: handle_101114(struct bregs *regs)
794: {
795: stdvga_load_font(get_global_seg(), vgafont16, 0x100, 0, regs->bl, 16);
796: set_scan_lines(16);
797: }
798:
799: static void
800: handle_101130(struct bregs *regs)
801: {
802: switch (regs->bh) {
803: case 0x00: {
804: struct segoff_s so = GET_IVT(0x1f);
805: regs->es = so.seg;
806: regs->bp = so.offset;
807: break;
808: }
809: case 0x01: {
810: struct segoff_s so = GET_IVT(0x43);
811: regs->es = so.seg;
812: regs->bp = so.offset;
813: break;
814: }
815: case 0x02:
816: regs->es = get_global_seg();
817: regs->bp = (u32)vgafont14;
818: break;
819: case 0x03:
820: regs->es = get_global_seg();
821: regs->bp = (u32)vgafont8;
822: break;
823: case 0x04:
824: regs->es = get_global_seg();
825: regs->bp = (u32)vgafont8 + 128 * 8;
826: break;
827: case 0x05:
828: regs->es = get_global_seg();
829: regs->bp = (u32)vgafont14alt;
830: break;
831: case 0x06:
832: regs->es = get_global_seg();
833: regs->bp = (u32)vgafont16;
834: break;
835: case 0x07:
836: regs->es = get_global_seg();
837: regs->bp = (u32)vgafont16alt;
838: break;
839: default:
840: dprintf(1, "Get font info BH(%02x) was discarded\n", regs->bh);
841: return;
842: }
843: // Set byte/char of on screen font
844: regs->cx = GET_BDA(char_height) & 0xff;
845:
846: // Set Highest char row
847: regs->dl = GET_BDA(video_rows);
848: }
849:
850: static void
851: handle_1011XX(struct bregs *regs)
852: {
853: debug_stub(regs);
854: }
855:
856: static void
857: handle_1011(struct bregs *regs)
858: {
859: switch (regs->al) {
860: case 0x00: handle_101100(regs); break;
861: case 0x01: handle_101101(regs); break;
862: case 0x02: handle_101102(regs); break;
863: case 0x03: handle_101103(regs); break;
864: case 0x04: handle_101104(regs); break;
865: case 0x10: handle_101110(regs); break;
866: case 0x11: handle_101111(regs); break;
867: case 0x12: handle_101112(regs); break;
868: case 0x14: handle_101114(regs); break;
869: case 0x30: handle_101130(regs); break;
870: default: handle_1011XX(regs); break;
871: }
872: }
873:
874:
875: static void
876: handle_101210(struct bregs *regs)
877: {
878: u16 crtc_addr = GET_BDA(crtc_address);
879: if (crtc_addr == VGAREG_MDA_CRTC_ADDRESS)
880: regs->bx = 0x0103;
881: else
882: regs->bx = 0x0003;
883: regs->cx = GET_BDA(video_switches) & 0x0f;
884: }
885:
886: static void
887: handle_101230(struct bregs *regs)
888: {
889: u8 mctl = GET_BDA(modeset_ctl);
890: u8 vswt = GET_BDA(video_switches);
891: switch (regs->al) {
892: case 0x00:
893: // 200 lines
894: mctl = (mctl & ~0x10) | 0x80;
895: vswt = (vswt & ~0x0f) | 0x08;
896: break;
897: case 0x01:
898: // 350 lines
899: mctl &= ~0x90;
900: vswt = (vswt & ~0x0f) | 0x09;
901: break;
902: case 0x02:
903: // 400 lines
904: mctl = (mctl & ~0x80) | 0x10;
905: vswt = (vswt & ~0x0f) | 0x09;
906: break;
907: default:
908: dprintf(1, "Select vert res (%02x) was discarded\n", regs->al);
909: break;
910: }
911: SET_BDA(modeset_ctl, mctl);
912: SET_BDA(video_switches, vswt);
913: regs->al = 0x12;
914: }
915:
916: static void
917: handle_101231(struct bregs *regs)
918: {
919: u8 v = (regs->al & 0x01) << 3;
920: u8 mctl = GET_BDA(video_ctl) & ~0x08;
921: SET_BDA(video_ctl, mctl | v);
922: regs->al = 0x12;
923: }
924:
925: static void
926: handle_101232(struct bregs *regs)
927: {
928: stdvga_enable_video_addressing(regs->al);
929: regs->al = 0x12;
930: }
931:
932: static void
933: handle_101233(struct bregs *regs)
934: {
935: u8 v = ((regs->al << 1) & 0x02) ^ 0x02;
936: u8 v2 = GET_BDA(modeset_ctl) & ~0x02;
937: SET_BDA(modeset_ctl, v | v2);
938: regs->al = 0x12;
939: }
940:
941: static void
942: handle_101234(struct bregs *regs)
943: {
944: u8 v = (regs->al & 0x01) ^ 0x01;
945: u8 v2 = GET_BDA(modeset_ctl) & ~0x01;
946: SET_BDA(modeset_ctl, v | v2);
947: regs->al = 0x12;
948: }
949:
950: static void
951: handle_101235(struct bregs *regs)
952: {
953: debug_stub(regs);
954: regs->al = 0x12;
955: }
956:
957: static void
958: handle_101236(struct bregs *regs)
959: {
960: debug_stub(regs);
961: regs->al = 0x12;
962: }
963:
964: static void
965: handle_1012XX(struct bregs *regs)
966: {
967: debug_stub(regs);
968: }
969:
970: static void
971: handle_1012(struct bregs *regs)
972: {
973: if (CONFIG_VGA_CIRRUS && regs->bl >= 0x80) {
974: clext_1012(regs);
975: return;
976: }
977:
978: switch (regs->bl) {
979: case 0x10: handle_101210(regs); break;
980: case 0x30: handle_101230(regs); break;
981: case 0x31: handle_101231(regs); break;
982: case 0x32: handle_101232(regs); break;
983: case 0x33: handle_101233(regs); break;
984: case 0x34: handle_101234(regs); break;
985: case 0x35: handle_101235(regs); break;
986: case 0x36: handle_101236(regs); break;
987: default: handle_1012XX(regs); break;
988: }
989: }
990:
991:
992: // Write string
993: static void noinline
994: handle_1013(struct bregs *regs)
995: {
996: struct cursorpos cp;
997: if (regs->dh == 0xff)
998: // if row=0xff special case : use current cursor position
999: cp = get_cursor_pos(regs->bh);
1000: else
1001: cp = (struct cursorpos) {regs->dl, regs->dh, regs->bh};
1002:
1003: u16 count = regs->cx;
1004: u8 *offset_far = (void*)(regs->bp + 0);
1005: u8 attr = regs->bl;
1006: while (count--) {
1007: u8 car = GET_FARVAR(regs->es, *offset_far);
1008: offset_far++;
1009: if (regs->al & 2) {
1010: attr = GET_FARVAR(regs->es, *offset_far);
1011: offset_far++;
1012: }
1013:
1014: struct carattr ca = {car, attr, 1};
1015: write_teletype(&cp, ca);
1016: }
1017:
1018: if (regs->al & 1)
1019: set_cursor_pos(cp);
1020: }
1021:
1022:
1023: static void
1024: handle_101a00(struct bregs *regs)
1025: {
1026: regs->bx = GET_BDA(dcc_index);
1027: regs->al = 0x1a;
1028: }
1029:
1030: static void
1031: handle_101a01(struct bregs *regs)
1032: {
1033: SET_BDA(dcc_index, regs->bl);
1034: dprintf(1, "Alternate Display code (%02x) was discarded\n", regs->bh);
1035: regs->al = 0x1a;
1036: }
1037:
1038: static void
1039: handle_101aXX(struct bregs *regs)
1040: {
1041: debug_stub(regs);
1042: }
1043:
1044: static void
1045: handle_101a(struct bregs *regs)
1046: {
1047: switch (regs->al) {
1048: case 0x00: handle_101a00(regs); break;
1049: case 0x01: handle_101a01(regs); break;
1050: default: handle_101aXX(regs); break;
1051: }
1052: }
1053:
1054:
1055: static u8 static_functionality[0x10] VAR16 = {
1056: /* 0 */ 0xff, // All modes supported #1
1057: /* 1 */ 0xe0, // All modes supported #2
1058: /* 2 */ 0x0f, // All modes supported #3
1059: /* 3 */ 0x00, 0x00, 0x00, 0x00, // reserved
1060: /* 7 */ 0x07, // 200, 350, 400 scan lines
1061: /* 8 */ 0x02, // mamimum number of visible charsets in text mode
1062: /* 9 */ 0x08, // total number of charset blocks in text mode
1063: /* a */ 0xe7, // Change to add new functions
1064: /* b */ 0x0c, // Change to add new functions
1065: /* c */ 0x00, // reserved
1066: /* d */ 0x00, // reserved
1067: /* e */ 0x00, // Change to add new functions
1068: /* f */ 0x00 // reserved
1069: };
1070:
1071: struct funcInfo {
1072: struct segoff_s static_functionality;
1073: u8 bda_0x49[30];
1074: u8 bda_0x84[3];
1075: u8 dcc_index;
1076: u8 dcc_alt;
1077: u16 colors;
1078: u8 pages;
1079: u8 scan_lines;
1080: u8 primary_char;
1081: u8 secondar_char;
1082: u8 misc;
1083: u8 non_vga_mode;
1084: u8 reserved_2f[2];
1085: u8 video_mem;
1086: u8 save_flags;
1087: u8 disp_info;
1088: u8 reserved_34[12];
1089: };
1090:
1091: static void
1092: handle_101b(struct bregs *regs)
1093: {
1094: u16 seg = regs->es;
1095: struct funcInfo *info = (void*)(regs->di+0);
1096: memset_far(seg, info, 0, sizeof(*info));
1097: // Address of static functionality table
1098: SET_FARVAR(seg, info->static_functionality
1099: , SEGOFF(get_global_seg(), (u32)static_functionality));
1100:
1101: // Hard coded copy from BIOS area. Should it be cleaner ?
1102: memcpy_far(seg, info->bda_0x49, SEG_BDA, (void*)0x49
1103: , sizeof(info->bda_0x49));
1104: memcpy_far(seg, info->bda_0x84, SEG_BDA, (void*)0x84
1105: , sizeof(info->bda_0x84));
1106:
1107: SET_FARVAR(seg, info->dcc_index, GET_BDA(dcc_index));
1108: SET_FARVAR(seg, info->colors, 16);
1109: SET_FARVAR(seg, info->pages, 8);
1110: SET_FARVAR(seg, info->scan_lines, 2);
1111: SET_FARVAR(seg, info->video_mem, 3);
1112: regs->al = 0x1B;
1113: }
1114:
1115:
1116: static void
1117: handle_101c(struct bregs *regs)
1118: {
1119: u16 seg = regs->es;
1120: void *data = (void*)(regs->bx+0);
1121: u16 states = regs->cx;
1122: if (states & ~0x07)
1123: goto fail;
1124: int ret;
1125: switch (regs->al) {
1126: case 0x00:
1127: ret = vgahw_size_state(states);
1128: if (ret < 0)
1129: goto fail;
1130: regs->bx = ret / 64;
1131: break;
1132: case 0x01:
1133: ret = vgahw_save_state(seg, data, states);
1134: if (ret)
1135: goto fail;
1136: break;
1137: case 0x02:
1138: ret = vgahw_restore_state(seg, data, states);
1139: if (ret)
1140: goto fail;
1141: break;
1142: default:
1143: goto fail;
1144: }
1145: regs->al = 0x1c;
1146: fail:
1147: return;
1148: }
1149:
1150: static void
1151: handle_10XX(struct bregs *regs)
1152: {
1153: debug_stub(regs);
1154: }
1155:
1156: // INT 10h Video Support Service Entry Point
1157: void VISIBLE16
1158: handle_10(struct bregs *regs)
1159: {
1160: debug_enter(regs, DEBUG_VGA_10);
1161: switch (regs->ah) {
1162: case 0x00: handle_1000(regs); break;
1163: case 0x01: handle_1001(regs); break;
1164: case 0x02: handle_1002(regs); break;
1165: case 0x03: handle_1003(regs); break;
1166: case 0x04: handle_1004(regs); break;
1167: case 0x05: handle_1005(regs); break;
1168: case 0x06: handle_1006(regs); break;
1169: case 0x07: handle_1007(regs); break;
1170: case 0x08: handle_1008(regs); break;
1171: case 0x09: handle_1009(regs); break;
1172: case 0x0a: handle_100a(regs); break;
1173: case 0x0b: handle_100b(regs); break;
1174: case 0x0c: handle_100c(regs); break;
1175: case 0x0d: handle_100d(regs); break;
1176: case 0x0e: handle_100e(regs); break;
1177: case 0x0f: handle_100f(regs); break;
1178: case 0x10: handle_1010(regs); break;
1179: case 0x11: handle_1011(regs); break;
1180: case 0x12: handle_1012(regs); break;
1181: case 0x13: handle_1013(regs); break;
1182: case 0x1a: handle_101a(regs); break;
1183: case 0x1b: handle_101b(regs); break;
1184: case 0x1c: handle_101c(regs); break;
1185: case 0x4f: handle_104f(regs); break;
1186: default: handle_10XX(regs); break;
1187: }
1188: }
1189:
1190:
1191: /****************************************************************
1192: * VGA post
1193: ****************************************************************/
1194:
1195: static void
1196: init_bios_area(void)
1197: {
1198: // init detected hardware BIOS Area
1199: // set 80x25 color (not clear from RBIL but usual)
1200: u16 eqf = GET_BDA(equipment_list_flags);
1201: SET_BDA(equipment_list_flags, (eqf & 0xffcf) | 0x20);
1202:
1203: // Just for the first int10 find its children
1204:
1205: // the default char height
1206: SET_BDA(char_height, 0x10);
1207:
1208: // Clear the screen
1209: SET_BDA(video_ctl, 0x60);
1210:
1211: // Set the basic screen we have
1212: SET_BDA(video_switches, 0xf9);
1213:
1214: // Set the basic modeset options
1215: SET_BDA(modeset_ctl, 0x51);
1216:
1217: // Set the default MSR
1218: SET_BDA(video_msr, 0x09);
1219: }
1220:
1221: int VgaBDF VAR16 = -1;
1222: int HaveRunInit VAR16;
1223:
1224: void VISIBLE16
1225: vga_post(struct bregs *regs)
1226: {
1227: debug_serial_setup();
1228: dprintf(1, "Start SeaVGABIOS (version %s)\n", VERSION);
1229: debug_enter(regs, DEBUG_VGA_POST);
1230:
1231: if (CONFIG_VGA_PCI && !GET_GLOBAL(HaveRunInit)) {
1232: u16 bdf = regs->ax;
1233: if ((pci_config_readw(bdf, PCI_VENDOR_ID)
1234: == GET_GLOBAL(rom_pci_data.vendor))
1235: && (pci_config_readw(bdf, PCI_DEVICE_ID)
1236: == GET_GLOBAL(rom_pci_data.device)))
1237: SET_VGA(VgaBDF, bdf);
1238: }
1239:
1240: int ret = vgahw_init();
1241: if (ret) {
1242: dprintf(1, "Failed to initialize VGA hardware. Exiting.\n");
1243: return;
1244: }
1245:
1246: if (GET_GLOBAL(HaveRunInit))
1247: return;
1248:
1249: init_bios_area();
1250:
1251: SET_VGA(video_save_pointer_table.videoparam
1252: , SEGOFF(get_global_seg(), (u32)video_param_table));
1253: stdvga_build_video_param();
1254:
1255: extern void entry_10(void);
1256: SET_IVT(0x10, SEGOFF(get_global_seg(), (u32)entry_10));
1257:
1258: SET_VGA(HaveRunInit, 1);
1259:
1260: // Fixup checksum
1261: extern u8 _rom_header_size, _rom_header_checksum;
1262: SET_VGA(_rom_header_checksum, 0);
1263: u8 sum = -checksum_far(get_global_seg(), 0,
1264: GET_GLOBAL(_rom_header_size) * 512);
1265: SET_VGA(_rom_header_checksum, sum);
1266: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.