![[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 / vgabios|
Return to vgabios.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / vgabios |
1.1 root 1: // ============================================================================================
2: /*
3: * vgabios.c
4: */
5: // ============================================================================================
6: //
7: // Copyright (C) 2001-2008 the LGPL VGABios developers Team
8: //
9: // This library is free software; you can redistribute it and/or
10: // modify it under the terms of the GNU Lesser General Public
11: // License as published by the Free Software Foundation; either
12: // version 2 of the License, or (at your option) any later version.
13: //
14: // This library is distributed in the hope that it will be useful,
15: // but WITHOUT ANY WARRANTY; without even the implied warranty of
16: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17: // Lesser General Public License for more details.
18: //
19: // You should have received a copy of the GNU Lesser General Public
20: // License along with this library; if not, write to the Free Software
21: // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22: //
23: // ============================================================================================
24: //
25: // This VGA Bios is specific to the plex86/bochs Emulated VGA card.
26: // You can NOT drive any physical vga card with it.
27: //
28: // ============================================================================================
29: //
30: // This file contains code ripped from :
31: // - rombios.c of plex86
32: //
33: // This VGA Bios contains fonts from :
34: // - fntcol16.zip (c) by Joseph Gil avalable at :
35: // ftp://ftp.simtel.net/pub/simtelnet/msdos/screen/fntcol16.zip
36: // These fonts are public domain
37: //
38: // This VGA Bios is based on information taken from :
39: // - Kevin Lawton's vga card emulation for bochs/plex86
40: // - Ralf Brown's interrupts list available at http://www.cs.cmu.edu/afs/cs/user/ralf/pub/WWW/files.html
41: // - Finn Thogersons' VGADOC4b available at http://home.worldonline.dk/~finth/
42: // - Michael Abrash's Graphics Programming Black Book
43: // - Francois Gervais' book "programmation des cartes graphiques cga-ega-vga" edited by sybex
44: // - DOSEMU 1.0.1 source code for several tables values and formulas
45: //
46: // Thanks for patches, comments and ideas to :
47: // - [email protected]
48: //
49: // ============================================================================================
50:
51: #include "vgabios.h"
52:
53: #ifdef VBE
54: #include "vbe.h"
55: #endif
56:
57: #define USE_BX_INFO
58:
59: /* Declares */
60: static Bit8u read_byte();
61: static Bit16u read_word();
62: static void write_byte();
63: static void write_word();
64: static Bit8u inb();
65: static Bit16u inw();
66: static void outb();
67: static void outw();
68:
69: static Bit16u get_SS();
70:
71: // Output
72: static void printf();
73: static void unimplemented();
74: static void unknown();
75:
76: static Bit8u find_vga_entry();
77:
78: static void memsetb();
79: static void memsetw();
80: static void memcpyb();
81: static void memcpyw();
82:
83: static void biosfn_set_video_mode();
84: static void biosfn_set_cursor_shape();
85: static void biosfn_set_cursor_pos();
86: static void biosfn_get_cursor_pos();
87: static void biosfn_set_active_page();
88: static void biosfn_scroll();
89: static void biosfn_read_char_attr();
90: static void biosfn_write_char_attr();
91: static void biosfn_write_char_only();
92: static void biosfn_write_pixel();
93: static void biosfn_read_pixel();
94: static void biosfn_write_teletype();
95: static void biosfn_perform_gray_scale_summing();
96: static void biosfn_load_text_user_pat();
97: static void biosfn_load_text_8_14_pat();
98: static void biosfn_load_text_8_8_pat();
99: static void biosfn_load_text_8_16_pat();
100: static void biosfn_load_gfx_8_8_chars();
101: static void biosfn_load_gfx_user_chars();
102: static void biosfn_load_gfx_8_14_chars();
103: static void biosfn_load_gfx_8_8_dd_chars();
104: static void biosfn_load_gfx_8_16_chars();
105: static void biosfn_get_font_info();
106: static void biosfn_alternate_prtsc();
107: static void biosfn_switch_video_interface();
108: static void biosfn_enable_video_refresh_control();
109: static void biosfn_write_string();
110: static void biosfn_read_state_info();
111: static void biosfn_read_video_state_size();
112: static Bit16u biosfn_save_video_state();
113: static Bit16u biosfn_restore_video_state();
114: extern Bit8u video_save_pointer_table[];
115:
116: // This is for compiling with gcc2 and gcc3
117: #define ASM_START #asm
118: #define ASM_END #endasm
119:
120: ASM_START
121:
122: MACRO SET_INT_VECTOR
123: push ds
124: xor ax, ax
125: mov ds, ax
126: mov ax, ?3
127: mov ?1*4, ax
128: mov ax, ?2
129: mov ?1*4+2, ax
130: pop ds
131: MEND
132:
133: ASM_END
134:
135: ASM_START
136: .text
137: .rom
138: .org 0
139:
140: use16 386
141:
142: vgabios_start:
143: .byte 0x55, 0xaa /* BIOS signature, required for BIOS extensions */
144:
145: .byte 0x40 /* BIOS extension length in units of 512 bytes */
146:
147:
148: vgabios_entry_point:
149:
150: jmp vgabios_init_func
151:
152: #ifdef PCIBIOS
153: .org 0x18
154: .word vgabios_pci_data
155: #endif
156:
157: // Info from Bart Oldeman
158: .org 0x1e
159: .ascii "IBM"
160: .byte 0x00
161:
162: vgabios_name:
163: .ascii "Plex86/Bochs VGABios"
164: #ifdef PCIBIOS
165: .ascii " (PCI)"
166: #endif
167: .ascii " "
168: .byte 0x00
169:
170: vgabios_version:
171: #ifndef VGABIOS_VERS
172: .ascii "current-cvs"
173: #else
174: .ascii VGABIOS_VERS
175: #endif
176: .ascii " "
177:
178: vgabios_date:
179: .ascii VGABIOS_DATE
180: .byte 0x0a,0x0d
181: .byte 0x00
182:
183: vgabios_copyright:
184: .ascii "(C) 2008 the LGPL VGABios developers Team"
185: .byte 0x0a,0x0d
186: .byte 0x00
187:
188: vgabios_license:
189: .ascii "This VGA/VBE Bios is released under the GNU LGPL"
190: .byte 0x0a,0x0d
191: .byte 0x0a,0x0d
192: .byte 0x00
193:
194: vgabios_website:
195: .ascii "Please visit :"
196: .byte 0x0a,0x0d
197: ;;.ascii " . http://www.plex86.org"
198: ;;.byte 0x0a,0x0d
199: .ascii " . http://bochs.sourceforge.net"
200: .byte 0x0a,0x0d
201: .ascii " . http://www.nongnu.org/vgabios"
202: .byte 0x0a,0x0d
203: .byte 0x0a,0x0d
204: .byte 0x00
205:
206: #ifdef PCIBIOS
207: vgabios_pci_data:
208: .ascii "PCIR"
209: #ifdef CIRRUS
210: .word 0x1013
211: .word 0x00b8 // CLGD5446
212: #else
213: #error "Unknown PCI vendor and device id"
214: #endif
215: .word 0 // reserved
216: .word 0x18 // dlen
217: .byte 0 // revision
218: .byte 0x0 // class,hi: vga display
219: .word 0x300 // class,lo: vga display
220: .word 0x40 // bios size
221: .word 1 // revision
222: .byte 0 // intel x86 data
223: .byte 0x80 // last image
224: .word 0 // reserved
225: #endif
226:
227:
228: ;; ============================================================================================
229: ;;
230: ;; Init Entry point
231: ;;
232: ;; ============================================================================================
233: vgabios_init_func:
234:
235: ;; init vga card
236: call init_vga_card
237:
238: ;; init basic bios vars
239: call init_bios_area
240:
241: #ifdef VBE
242: ;; init vbe functions
243: call vbe_init
244: #endif
245:
246: ;; set int10 vect
247: SET_INT_VECTOR(0x10, #0xC000, #vgabios_int10_handler)
248:
249: #ifdef CIRRUS
250: call cirrus_init
251: #endif
252:
253: ;; display splash screen
254: call _display_splash_screen
255:
256: ;; init video mode and clear the screen
257: mov ax,#0x0003
258: int #0x10
259:
260: ;; show info
261: call _display_info
262:
263: #ifdef VBE
264: ;; show vbe info
265: call vbe_display_info
266: #endif
267:
268: #ifdef CIRRUS
269: ;; show cirrus info
270: call cirrus_display_info
271: #endif
272:
273: retf
274: ASM_END
275:
276: /*
277: * int10 handled here
278: */
279: ASM_START
280: vgabios_int10_handler:
281: pushf
282: #ifdef DEBUG
283: push es
284: push ds
285: pusha
286: mov bx, #0xc000
287: mov ds, bx
288: call _int10_debugmsg
289: popa
290: pop ds
291: pop es
292: #endif
293: cmp ah, #0x0f
294: jne int10_test_1A
295: call biosfn_get_video_mode
296: jmp int10_end
297: int10_test_1A:
298: cmp ah, #0x1a
299: jne int10_test_0B
300: call biosfn_group_1A
301: jmp int10_end
302: int10_test_0B:
303: cmp ah, #0x0b
304: jne int10_test_1103
305: call biosfn_group_0B
306: jmp int10_end
307: int10_test_1103:
308: cmp ax, #0x1103
309: jne int10_test_12
310: call biosfn_set_text_block_specifier
311: jmp int10_end
312: int10_test_12:
313: cmp ah, #0x12
314: jne int10_test_101B
315: cmp bl, #0x10
316: jne int10_test_BL30
317: call biosfn_get_ega_info
318: jmp int10_end
319: int10_test_BL30:
320: cmp bl, #0x30
321: jne int10_test_BL31
322: call biosfn_select_vert_res
323: jmp int10_end
324: int10_test_BL31:
325: cmp bl, #0x31
326: jne int10_test_BL32
327: call biosfn_enable_default_palette_loading
328: jmp int10_end
329: int10_test_BL32:
330: cmp bl, #0x32
331: jne int10_test_BL33
332: call biosfn_enable_video_addressing
333: jmp int10_end
334: int10_test_BL33:
335: cmp bl, #0x33
336: jne int10_test_BL34
337: call biosfn_enable_grayscale_summing
338: jmp int10_end
339: int10_test_BL34:
340: cmp bl, #0x34
341: jne int10_normal
342: call biosfn_enable_cursor_emulation
343: jmp int10_end
344: int10_test_101B:
345: cmp ax, #0x101b
346: je int10_normal
347: cmp ah, #0x10
348: #ifndef VBE
349: jne int10_normal
350: #else
351: jne int10_test_4F
352: #endif
353: call biosfn_group_10
354: jmp int10_end
355: #ifdef VBE
356: int10_test_4F:
357: cmp ah, #0x4f
358: jne int10_normal
359: cmp al, #0x03
360: jne int10_test_vbe_05
361: call vbe_biosfn_return_current_mode
362: jmp int10_end
363: int10_test_vbe_05:
364: cmp al, #0x05
365: jne int10_test_vbe_06
366: call vbe_biosfn_display_window_control
367: jmp int10_end
368: int10_test_vbe_06:
369: cmp al, #0x06
370: jne int10_test_vbe_07
371: call vbe_biosfn_set_get_logical_scan_line_length
372: jmp int10_end
373: int10_test_vbe_07:
374: cmp al, #0x07
375: jne int10_test_vbe_08
376: call vbe_biosfn_set_get_display_start
377: jmp int10_end
378: int10_test_vbe_08:
379: cmp al, #0x08
380: jne int10_test_vbe_0A
381: call vbe_biosfn_set_get_dac_palette_format
382: jmp int10_end
383: int10_test_vbe_0A:
384: cmp al, #0x0A
385: jne int10_normal
386: call vbe_biosfn_return_protected_mode_interface
387: jmp int10_end
388: #endif
389:
390: int10_normal:
391: push es
392: push ds
393: pusha
394:
395: ;; We have to set ds to access the right data segment
396: mov bx, #0xc000
397: mov ds, bx
398: call _int10_func
399:
400: popa
401: pop ds
402: pop es
403: int10_end:
404: popf
405: iret
406: ASM_END
407:
408: #include "vgatables.h"
409: #include "vgafonts.h"
410:
411: /*
412: * Boot time harware inits
413: */
414: ASM_START
415: init_vga_card:
416: ;; switch to color mode and enable CPU access 480 lines
417: mov dx, #0x3C2
418: mov al, #0xC3
419: outb dx,al
420:
421: ;; more than 64k 3C4/04
422: mov dx, #0x3C4
423: mov al, #0x04
424: outb dx,al
425: mov dx, #0x3C5
426: mov al, #0x02
427: outb dx,al
428:
429: #if defined(USE_BX_INFO) || defined(DEBUG)
430: mov bx, #msg_vga_init
431: push bx
432: call _printf
433: #endif
434: inc sp
435: inc sp
436: ret
437:
438: #if defined(USE_BX_INFO) || defined(DEBUG)
439: msg_vga_init:
440: .ascii "VGABios $Id$"
441: .byte 0x0d,0x0a,0x00
442: #endif
443: ASM_END
444:
445: // --------------------------------------------------------------------------------------------
446: /*
447: * Boot time bios area inits
448: */
449: ASM_START
450: init_bios_area:
451: push ds
452: mov ax, # BIOSMEM_SEG
453: mov ds, ax
454:
455: ;; init detected hardware BIOS Area
456: mov bx, # BIOSMEM_INITIAL_MODE
457: mov ax, [bx]
458: and ax, #0xffcf
459: ;; set 80x25 color (not clear from RBIL but usual)
460: or ax, #0x0020
461: mov [bx], ax
462:
463: ;; Just for the first int10 find its children
464:
465: ;; the default char height
466: mov bx, # BIOSMEM_CHAR_HEIGHT
467: mov al, #0x10
468: mov [bx], al
469:
470: ;; Clear the screen
471: mov bx, # BIOSMEM_VIDEO_CTL
472: mov al, #0x60
473: mov [bx], al
474:
475: ;; Set the basic screen we have
476: mov bx, # BIOSMEM_SWITCHES
477: mov al, #0xf9
478: mov [bx], al
479:
480: ;; Set the basic modeset options
481: mov bx, # BIOSMEM_MODESET_CTL
482: mov al, #0x51
483: mov [bx], al
484:
485: ;; Set the default MSR
486: mov bx, # BIOSMEM_CURRENT_MSR
487: mov al, #0x09
488: mov [bx], al
489:
490: pop ds
491: ret
492:
493: _video_save_pointer_table:
494: .word _video_param_table
495: .word 0xc000
496:
497: .word 0 /* XXX: fill it */
498: .word 0
499:
500: .word 0 /* XXX: fill it */
501: .word 0
502:
503: .word 0 /* XXX: fill it */
504: .word 0
505:
506: .word 0 /* XXX: fill it */
507: .word 0
508:
509: .word 0 /* XXX: fill it */
510: .word 0
511:
512: .word 0 /* XXX: fill it */
513: .word 0
514:
515: ASM_END
516:
517: // --------------------------------------------------------------------------------------------
518: /*
519: * Boot time Splash screen
520: */
521: static void display_splash_screen()
522: {
523: }
524:
525: // --------------------------------------------------------------------------------------------
526: /*
527: * Tell who we are
528: */
529:
530: static void display_info()
531: {
532: ASM_START
533: mov ax,#0xc000
534: mov ds,ax
535: mov si,#vgabios_name
536: call _display_string
537: mov si,#vgabios_version
538: call _display_string
539:
540: ;;mov si,#vgabios_copyright
541: ;;call _display_string
542: ;;mov si,#crlf
543: ;;call _display_string
544:
545: mov si,#vgabios_license
546: call _display_string
547: mov si,#vgabios_website
548: call _display_string
549: ASM_END
550: }
551:
552: static void display_string()
553: {
554: // Get length of string
555: ASM_START
556: mov ax,ds
557: mov es,ax
558: mov di,si
559: xor cx,cx
560: not cx
561: xor al,al
562: cld
563: repne
564: scasb
565: not cx
566: dec cx
567: push cx
568:
569: mov ax,#0x0300
570: mov bx,#0x0000
571: int #0x10
572:
573: pop cx
574: mov ax,#0x1301
575: mov bx,#0x000b
576: mov bp,si
577: int #0x10
578: ASM_END
579: }
580:
581: // --------------------------------------------------------------------------------------------
582: #ifdef DEBUG
583: static void int10_debugmsg(DI, SI, BP, SP, BX, DX, CX, AX, DS, ES, FLAGS)
584: Bit16u DI, SI, BP, SP, BX, DX, CX, AX, ES, DS, FLAGS;
585: {
586: // 0E is write char...
587: if(GET_AH()!=0x0E)
588: printf("vgabios call ah%02x al%02x bx%04x cx%04x dx%04x\n",GET_AH(),GET_AL(),BX,CX,DX);
589: }
590: #endif
591:
592: // --------------------------------------------------------------------------------------------
593: /*
594: * int10 main dispatcher
595: */
596: static void int10_func(DI, SI, BP, SP, BX, DX, CX, AX, DS, ES, FLAGS)
597: Bit16u DI, SI, BP, SP, BX, DX, CX, AX, ES, DS, FLAGS;
598: {
599:
600: // BIOS functions
601: switch(GET_AH())
602: {
603: case 0x00:
604: biosfn_set_video_mode(GET_AL());
605: switch(GET_AL()&0x7F)
606: {case 6:
607: SET_AL(0x3F);
608: break;
609: case 0:
610: case 1:
611: case 2:
612: case 3:
613: case 4:
614: case 5:
615: case 7:
616: SET_AL(0x30);
617: break;
618: default:
619: SET_AL(0x20);
620: }
621: break;
622: case 0x01:
623: biosfn_set_cursor_shape(GET_CH(),GET_CL());
624: break;
625: case 0x02:
626: biosfn_set_cursor_pos(GET_BH(),DX);
627: break;
628: case 0x03:
629: biosfn_get_cursor_pos(GET_BH(),&CX,&DX);
630: break;
631: case 0x04:
632: // Read light pen pos (unimplemented)
633: #ifdef DEBUG
634: unimplemented();
635: #endif
636: AX=0x00;
637: BX=0x00;
638: CX=0x00;
639: DX=0x00;
640: break;
641: case 0x05:
642: biosfn_set_active_page(GET_AL());
643: break;
644: case 0x06:
645: biosfn_scroll(GET_AL(),GET_BH(),GET_CH(),GET_CL(),GET_DH(),GET_DL(),0xFF,SCROLL_UP);
646: break;
647: case 0x07:
648: biosfn_scroll(GET_AL(),GET_BH(),GET_CH(),GET_CL(),GET_DH(),GET_DL(),0xFF,SCROLL_DOWN);
649: break;
650: case 0x08:
651: biosfn_read_char_attr(GET_BH(),&AX);
652: break;
653: case 0x09:
654: biosfn_write_char_attr(GET_AL(),GET_BH(),GET_BL(),CX);
655: break;
656: case 0x0A:
657: biosfn_write_char_only(GET_AL(),GET_BH(),GET_BL(),CX);
658: break;
659: case 0x0C:
660: biosfn_write_pixel(GET_BH(),GET_AL(),CX,DX);
661: break;
662: case 0x0D:
663: biosfn_read_pixel(GET_BH(),CX,DX,&AX);
664: break;
665: case 0x0E:
666: // Ralf Brown Interrupt list is WRONG on bh(page)
667: // We do output only on the current page !
668: biosfn_write_teletype(GET_AL(),0xff,GET_BL(),NO_ATTR);
669: break;
670: case 0x10:
671: // All other functions of group AH=0x10 rewritten in assembler
672: biosfn_perform_gray_scale_summing(BX,CX);
673: break;
674: case 0x11:
675: switch(GET_AL())
676: {
677: case 0x00:
678: case 0x10:
679: biosfn_load_text_user_pat(GET_AL(),ES,BP,CX,DX,GET_BL(),GET_BH());
680: break;
681: case 0x01:
682: case 0x11:
683: biosfn_load_text_8_14_pat(GET_AL(),GET_BL());
684: break;
685: case 0x02:
686: case 0x12:
687: biosfn_load_text_8_8_pat(GET_AL(),GET_BL());
688: break;
689: case 0x04:
690: case 0x14:
691: biosfn_load_text_8_16_pat(GET_AL(),GET_BL());
692: break;
693: case 0x20:
694: biosfn_load_gfx_8_8_chars(ES,BP);
695: break;
696: case 0x21:
697: biosfn_load_gfx_user_chars(ES,BP,CX,GET_BL(),GET_DL());
698: break;
699: case 0x22:
700: biosfn_load_gfx_8_14_chars(GET_BL());
701: break;
702: case 0x23:
703: biosfn_load_gfx_8_8_dd_chars(GET_BL());
704: break;
705: case 0x24:
706: biosfn_load_gfx_8_16_chars(GET_BL());
707: break;
708: case 0x30:
709: biosfn_get_font_info(GET_BH(),&ES,&BP,&CX,&DX);
710: break;
711: #ifdef DEBUG
712: default:
713: unknown();
714: #endif
715: }
716:
717: break;
718: case 0x12:
719: switch(GET_BL())
720: {
721: case 0x20:
722: biosfn_alternate_prtsc();
723: break;
724: case 0x35:
725: biosfn_switch_video_interface(GET_AL(),ES,DX);
726: SET_AL(0x12);
727: break;
728: case 0x36:
729: biosfn_enable_video_refresh_control(GET_AL());
730: SET_AL(0x12);
731: break;
732: #ifdef DEBUG
733: default:
734: unknown();
735: #endif
736: }
737: break;
738: case 0x13:
739: biosfn_write_string(GET_AL(),GET_BH(),GET_BL(),CX,GET_DH(),GET_DL(),ES,BP);
740: break;
741: case 0x1B:
742: biosfn_read_state_info(BX,ES,DI);
743: SET_AL(0x1B);
744: break;
745: case 0x1C:
746: switch(GET_AL())
747: {
748: case 0x00:
749: biosfn_read_video_state_size(CX,&BX);
750: break;
751: case 0x01:
752: biosfn_save_video_state(CX,ES,BX);
753: break;
754: case 0x02:
755: biosfn_restore_video_state(CX,ES,BX);
756: break;
757: #ifdef DEBUG
758: default:
759: unknown();
760: #endif
761: }
762: SET_AL(0x1C);
763: break;
764:
765: #ifdef VBE
766: case 0x4f:
767: if (vbe_has_vbe_display()) {
768: switch(GET_AL())
769: {
770: case 0x00:
771: vbe_biosfn_return_controller_information(&AX,ES,DI);
772: break;
773: case 0x01:
774: vbe_biosfn_return_mode_information(&AX,CX,ES,DI);
775: break;
776: case 0x02:
777: vbe_biosfn_set_mode(&AX,BX,ES,DI);
778: break;
779: case 0x04:
780: vbe_biosfn_save_restore_state(&AX, CX, DX, ES, &BX);
781: break;
782: case 0x09:
783: //FIXME
784: #ifdef DEBUG
785: unimplemented();
786: #endif
787: // function failed
788: AX=0x100;
789: break;
790: case 0x0A:
791: //FIXME
792: #ifdef DEBUG
793: unimplemented();
794: #endif
795: // function failed
796: AX=0x100;
797: break;
798: default:
799: #ifdef DEBUG
800: unknown();
801: #endif
802: // function failed
803: AX=0x100;
804: }
805: }
806: else {
807: // No VBE display
808: AX=0x0100;
809: }
810: break;
811: #endif
812:
813: #ifdef DEBUG
814: default:
815: unknown();
816: #endif
817: }
818: }
819:
820: // ============================================================================================
821: //
822: // BIOS functions
823: //
824: // ============================================================================================
825:
826: static void biosfn_set_video_mode(mode) Bit8u mode;
827: {// mode: Bit 7 is 1 if no clear screen
828:
829: // Should we clear the screen ?
830: Bit8u noclearmem=mode&0x80;
831: Bit8u line,mmask,*palette,vpti;
832: Bit16u i,twidth,theightm1,cheight;
833: Bit8u modeset_ctl,video_ctl,vga_switches;
834: Bit16u crtc_addr;
835:
836: #ifdef VBE
837: if (vbe_has_vbe_display()) {
838: dispi_set_enable(VBE_DISPI_DISABLED);
839: }
840: #endif // def VBE
841:
842: // The real mode
843: mode=mode&0x7f;
844:
845: // find the entry in the video modes
846: line=find_vga_entry(mode);
847:
848: #ifdef DEBUG
849: printf("mode search %02x found line %02x\n",mode,line);
850: #endif
851:
852: if(line==0xFF)
853: return;
854:
855: vpti=line_to_vpti[line];
856: twidth=video_param_table[vpti].twidth;
857: theightm1=video_param_table[vpti].theightm1;
858: cheight=video_param_table[vpti].cheight;
859:
860: // Read the bios vga control
861: video_ctl=read_byte(BIOSMEM_SEG,BIOSMEM_VIDEO_CTL);
862:
863: // Read the bios vga switches
864: vga_switches=read_byte(BIOSMEM_SEG,BIOSMEM_SWITCHES);
865:
866: // Read the bios mode set control
867: modeset_ctl=read_byte(BIOSMEM_SEG,BIOSMEM_MODESET_CTL);
868:
869: // Then we know the number of lines
870: // FIXME
871:
872: // if palette loading (bit 3 of modeset ctl = 0)
873: if((modeset_ctl&0x08)==0)
874: {// Set the PEL mask
875: outb(VGAREG_PEL_MASK,vga_modes[line].pelmask);
876:
877: // Set the whole dac always, from 0
878: outb(VGAREG_DAC_WRITE_ADDRESS,0x00);
879:
880: // From which palette
881: switch(vga_modes[line].dacmodel)
882: {case 0:
883: palette=&palette0;
884: break;
885: case 1:
886: palette=&palette1;
887: break;
888: case 2:
889: palette=&palette2;
890: break;
891: case 3:
892: palette=&palette3;
893: break;
894: }
895: // Always 256*3 values
896: for(i=0;i<0x0100;i++)
897: {if(i<=dac_regs[vga_modes[line].dacmodel])
898: {outb(VGAREG_DAC_DATA,palette[(i*3)+0]);
899: outb(VGAREG_DAC_DATA,palette[(i*3)+1]);
900: outb(VGAREG_DAC_DATA,palette[(i*3)+2]);
901: }
902: else
903: {outb(VGAREG_DAC_DATA,0);
904: outb(VGAREG_DAC_DATA,0);
905: outb(VGAREG_DAC_DATA,0);
906: }
907: }
908: if((modeset_ctl&0x02)==0x02)
909: {
910: biosfn_perform_gray_scale_summing(0x00, 0x100);
911: }
912: }
913:
914: // Reset Attribute Ctl flip-flop
915: inb(VGAREG_ACTL_RESET);
916:
917: // Set Attribute Ctl
918: for(i=0;i<=0x13;i++)
919: {outb(VGAREG_ACTL_ADDRESS,i);
920: outb(VGAREG_ACTL_WRITE_DATA,video_param_table[vpti].actl_regs[i]);
921: }
922: outb(VGAREG_ACTL_ADDRESS,0x14);
923: outb(VGAREG_ACTL_WRITE_DATA,0x00);
924:
925: // Set Sequencer Ctl
926: outb(VGAREG_SEQU_ADDRESS,0);
927: outb(VGAREG_SEQU_DATA,0x03);
928: for(i=1;i<=4;i++)
929: {outb(VGAREG_SEQU_ADDRESS,i);
930: outb(VGAREG_SEQU_DATA,video_param_table[vpti].sequ_regs[i - 1]);
931: }
932:
933: // Set Grafx Ctl
934: for(i=0;i<=8;i++)
935: {outb(VGAREG_GRDC_ADDRESS,i);
936: outb(VGAREG_GRDC_DATA,video_param_table[vpti].grdc_regs[i]);
937: }
938:
939: // Set CRTC address VGA or MDA
940: crtc_addr=vga_modes[line].memmodel==MTEXT?VGAREG_MDA_CRTC_ADDRESS:VGAREG_VGA_CRTC_ADDRESS;
941:
942: // Disable CRTC write protection
943: outw(crtc_addr,0x0011);
944: // Set CRTC regs
945: for(i=0;i<=0x18;i++)
946: {outb(crtc_addr,i);
947: outb(crtc_addr+1,video_param_table[vpti].crtc_regs[i]);
948: }
949:
950: // Set the misc register
951: outb(VGAREG_WRITE_MISC_OUTPUT,video_param_table[vpti].miscreg);
952:
953: // Enable video
954: outb(VGAREG_ACTL_ADDRESS,0x20);
955: inb(VGAREG_ACTL_RESET);
956:
957: if(noclearmem==0x00)
958: {
959: if(vga_modes[line].class==TEXT)
960: {
961: memsetw(vga_modes[line].sstart,0,0x0720,0x4000); // 32k
962: }
963: else
964: {
965: if(mode<0x0d)
966: {
967: memsetw(vga_modes[line].sstart,0,0x0000,0x4000); // 32k
968: }
969: else
970: {
971: outb( VGAREG_SEQU_ADDRESS, 0x02 );
972: mmask = inb( VGAREG_SEQU_DATA );
973: outb( VGAREG_SEQU_DATA, 0x0f ); // all planes
974: memsetw(vga_modes[line].sstart,0,0x0000,0x8000); // 64k
975: outb( VGAREG_SEQU_DATA, mmask );
976: }
977: }
978: }
979:
980: // Set the BIOS mem
981: write_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE,mode);
982: write_word(BIOSMEM_SEG,BIOSMEM_NB_COLS,twidth);
983: write_word(BIOSMEM_SEG,BIOSMEM_PAGE_SIZE,*(Bit16u *)&video_param_table[vpti].slength_l);
984: write_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS,crtc_addr);
985: write_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS,theightm1);
986: write_word(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT,cheight);
987: write_byte(BIOSMEM_SEG,BIOSMEM_VIDEO_CTL,(0x60|noclearmem));
988: write_byte(BIOSMEM_SEG,BIOSMEM_SWITCHES,0xF9);
989: write_byte(BIOSMEM_SEG,BIOSMEM_MODESET_CTL,read_byte(BIOSMEM_SEG,BIOSMEM_MODESET_CTL)&0x7f);
990:
991: // FIXME We nearly have the good tables. to be reworked
992: write_byte(BIOSMEM_SEG,BIOSMEM_DCC_INDEX,0x08); // 8 is VGA should be ok for now
993: write_word(BIOSMEM_SEG,BIOSMEM_VS_POINTER, video_save_pointer_table);
994: write_word(BIOSMEM_SEG,BIOSMEM_VS_POINTER+2, 0xc000);
995:
996: // FIXME
997: write_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MSR,0x00); // Unavailable on vanilla vga, but...
998: write_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAL,0x00); // Unavailable on vanilla vga, but...
999:
1000: // Set cursor shape
1001: if(vga_modes[line].class==TEXT)
1002: {
1003: biosfn_set_cursor_shape(0x06,0x07);
1004: }
1005:
1006: // Set cursor pos for page 0..7
1007: for(i=0;i<8;i++)
1008: biosfn_set_cursor_pos(i,0x0000);
1009:
1010: // Set active page 0
1011: biosfn_set_active_page(0x00);
1012:
1013: // Write the fonts in memory
1014: if(vga_modes[line].class==TEXT)
1015: {
1016: ASM_START
1017: ;; copy and activate 8x16 font
1018: mov ax, #0x1104
1019: mov bl, #0x00
1020: int #0x10
1021: mov ax, #0x1103
1022: mov bl, #0x00
1023: int #0x10
1024: ASM_END
1025: }
1026:
1027: // Set the ints 0x1F and 0x43
1028: ASM_START
1029: SET_INT_VECTOR(0x1f, #0xC000, #_vgafont8+128*8)
1030: ASM_END
1031:
1032: switch(cheight)
1033: {case 8:
1034: ASM_START
1035: SET_INT_VECTOR(0x43, #0xC000, #_vgafont8)
1036: ASM_END
1037: break;
1038: case 14:
1039: ASM_START
1040: SET_INT_VECTOR(0x43, #0xC000, #_vgafont14)
1041: ASM_END
1042: break;
1043: case 16:
1044: ASM_START
1045: SET_INT_VECTOR(0x43, #0xC000, #_vgafont16)
1046: ASM_END
1047: break;
1048: }
1049: }
1050:
1051: // --------------------------------------------------------------------------------------------
1052: static void biosfn_set_cursor_shape (CH,CL)
1053: Bit8u CH;Bit8u CL;
1054: {Bit16u cheight,curs,crtc_addr;
1055: Bit8u modeset_ctl;
1056:
1057: CH&=0x3f;
1058: CL&=0x1f;
1059:
1060: curs=(CH<<8)+CL;
1061: write_word(BIOSMEM_SEG,BIOSMEM_CURSOR_TYPE,curs);
1062:
1063: modeset_ctl=read_byte(BIOSMEM_SEG,BIOSMEM_MODESET_CTL);
1064: cheight = read_word(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT);
1065: if((modeset_ctl&0x01) && (cheight>8) && (CL<8) && (CH<0x20))
1066: {
1067: if(CL!=(CH+1))
1068: {
1069: CH = ((CH+1) * cheight / 8) -1;
1070: }
1071: else
1072: {
1073: CH = ((CL+1) * cheight / 8) - 2;
1074: }
1075: CL = ((CL+1) * cheight / 8) - 1;
1076: }
1077:
1078: // CTRC regs 0x0a and 0x0b
1079: crtc_addr=read_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
1080: outb(crtc_addr,0x0a);
1081: outb(crtc_addr+1,CH);
1082: outb(crtc_addr,0x0b);
1083: outb(crtc_addr+1,CL);
1084: }
1085:
1086: // --------------------------------------------------------------------------------------------
1087: static void biosfn_set_cursor_pos (page, cursor)
1088: Bit8u page;Bit16u cursor;
1089: {
1090: Bit8u xcurs,ycurs,current;
1091: Bit16u nbcols,nbrows,address,crtc_addr;
1092:
1093: // Should not happen...
1094: if(page>7)return;
1095:
1096: // Bios cursor pos
1097: write_word(BIOSMEM_SEG, BIOSMEM_CURSOR_POS+2*page, cursor);
1098:
1099: // Set the hardware cursor
1100: current=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE);
1101: if(page==current)
1102: {
1103: // Get the dimensions
1104: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1105: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1106:
1107: xcurs=cursor&0x00ff;ycurs=(cursor&0xff00)>>8;
1108:
1109: // Calculate the address knowing nbcols nbrows and page num
1110: address=SCREEN_IO_START(nbcols,nbrows,page)+xcurs+ycurs*nbcols;
1111:
1112: // CRTC regs 0x0e and 0x0f
1113: crtc_addr=read_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
1114: outb(crtc_addr,0x0e);
1115: outb(crtc_addr+1,(address&0xff00)>>8);
1116: outb(crtc_addr,0x0f);
1117: outb(crtc_addr+1,address&0x00ff);
1118: }
1119: }
1120:
1121: // --------------------------------------------------------------------------------------------
1122: static void biosfn_get_cursor_pos (page,shape, pos)
1123: Bit8u page;Bit16u *shape;Bit16u *pos;
1124: {
1125: Bit16u ss=get_SS();
1126:
1127: // Default
1128: write_word(ss, shape, 0);
1129: write_word(ss, pos, 0);
1130:
1131: if(page>7)return;
1132: // FIXME should handle VGA 14/16 lines
1133: write_word(ss,shape,read_word(BIOSMEM_SEG,BIOSMEM_CURSOR_TYPE));
1134: write_word(ss,pos,read_word(BIOSMEM_SEG,BIOSMEM_CURSOR_POS+page*2));
1135: }
1136:
1137: // --------------------------------------------------------------------------------------------
1138: static void biosfn_set_active_page (page)
1139: Bit8u page;
1140: {
1141: Bit16u cursor,dummy,crtc_addr;
1142: Bit16u nbcols,nbrows,address;
1143: Bit8u mode,line;
1144:
1145: if(page>7)return;
1146:
1147: // Get the mode
1148: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1149: line=find_vga_entry(mode);
1150: if(line==0xFF)return;
1151:
1152: // Get pos curs pos for the right page
1153: biosfn_get_cursor_pos(page,&dummy,&cursor);
1154:
1155: if(vga_modes[line].class==TEXT)
1156: {
1157: // Get the dimensions
1158: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1159: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1160:
1161: // Calculate the address knowing nbcols nbrows and page num
1162: address=SCREEN_MEM_START(nbcols,nbrows,page);
1163: write_word(BIOSMEM_SEG,BIOSMEM_CURRENT_START,address);
1164:
1165: // Start address
1166: address=SCREEN_IO_START(nbcols,nbrows,page);
1167: }
1168: else
1169: {
1170: address = page * (*(Bit16u *)&video_param_table[line_to_vpti[line]].slength_l);
1171: }
1172:
1173: // CRTC regs 0x0c and 0x0d
1174: crtc_addr=read_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
1175: outb(crtc_addr,0x0c);
1176: outb(crtc_addr+1,(address&0xff00)>>8);
1177: outb(crtc_addr,0x0d);
1178: outb(crtc_addr+1,address&0x00ff);
1179:
1180: // And change the BIOS page
1181: write_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE,page);
1182:
1183: #ifdef DEBUG
1184: printf("Set active page %02x address %04x\n",page,address);
1185: #endif
1186:
1187: // Display the cursor, now the page is active
1188: biosfn_set_cursor_pos(page,cursor);
1189: }
1190:
1191: // --------------------------------------------------------------------------------------------
1192: static void vgamem_copy_pl4(xstart,ysrc,ydest,cols,nbcols,cheight)
1193: Bit8u xstart;Bit8u ysrc;Bit8u ydest;Bit8u cols;Bit8u nbcols;Bit8u cheight;
1194: {
1195: Bit16u src,dest;
1196: Bit8u i;
1197:
1198: src=ysrc*cheight*nbcols+xstart;
1199: dest=ydest*cheight*nbcols+xstart;
1200: outw(VGAREG_GRDC_ADDRESS, 0x0105);
1201: for(i=0;i<cheight;i++)
1202: {
1203: memcpyb(0xa000,dest+i*nbcols,0xa000,src+i*nbcols,cols);
1204: }
1205: outw(VGAREG_GRDC_ADDRESS, 0x0005);
1206: }
1207:
1208: // --------------------------------------------------------------------------------------------
1209: static void vgamem_fill_pl4(xstart,ystart,cols,nbcols,cheight,attr)
1210: Bit8u xstart;Bit8u ystart;Bit8u cols;Bit8u nbcols;Bit8u cheight;Bit8u attr;
1211: {
1212: Bit16u dest;
1213: Bit8u i;
1214:
1215: dest=ystart*cheight*nbcols+xstart;
1216: outw(VGAREG_GRDC_ADDRESS, 0x0205);
1217: for(i=0;i<cheight;i++)
1218: {
1219: memsetb(0xa000,dest+i*nbcols,attr,cols);
1220: }
1221: outw(VGAREG_GRDC_ADDRESS, 0x0005);
1222: }
1223:
1224: // --------------------------------------------------------------------------------------------
1225: static void vgamem_copy_cga(xstart,ysrc,ydest,cols,nbcols,cheight)
1226: Bit8u xstart;Bit8u ysrc;Bit8u ydest;Bit8u cols;Bit8u nbcols;Bit8u cheight;
1227: {
1228: Bit16u src,dest;
1229: Bit8u i;
1230:
1231: src=((ysrc*cheight*nbcols)>>1)+xstart;
1232: dest=((ydest*cheight*nbcols)>>1)+xstart;
1233: for(i=0;i<cheight;i++)
1234: {
1235: if (i & 1)
1236: memcpyb(0xb800,0x2000+dest+(i>>1)*nbcols,0xb800,0x2000+src+(i>>1)*nbcols,cols);
1237: else
1238: memcpyb(0xb800,dest+(i>>1)*nbcols,0xb800,src+(i>>1)*nbcols,cols);
1239: }
1240: }
1241:
1242: // --------------------------------------------------------------------------------------------
1243: static void vgamem_fill_cga(xstart,ystart,cols,nbcols,cheight,attr)
1244: Bit8u xstart;Bit8u ystart;Bit8u cols;Bit8u nbcols;Bit8u cheight;Bit8u attr;
1245: {
1246: Bit16u dest;
1247: Bit8u i;
1248:
1249: dest=((ystart*cheight*nbcols)>>1)+xstart;
1250: for(i=0;i<cheight;i++)
1251: {
1252: if (i & 1)
1253: memsetb(0xb800,0x2000+dest+(i>>1)*nbcols,attr,cols);
1254: else
1255: memsetb(0xb800,dest+(i>>1)*nbcols,attr,cols);
1256: }
1257: }
1258:
1259: // --------------------------------------------------------------------------------------------
1260: static void biosfn_scroll (nblines,attr,rul,cul,rlr,clr,page,dir)
1261: Bit8u nblines;Bit8u attr;Bit8u rul;Bit8u cul;Bit8u rlr;Bit8u clr;Bit8u page;Bit8u dir;
1262: {
1263: // page == 0xFF if current
1264:
1265: Bit8u mode,line,cheight,bpp,cols;
1266: Bit16u nbcols,nbrows,i;
1267: Bit16u address;
1268:
1269: if(rul>rlr)return;
1270: if(cul>clr)return;
1271:
1272: // Get the mode
1273: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1274: line=find_vga_entry(mode);
1275: if(line==0xFF)return;
1276:
1277: // Get the dimensions
1278: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1279: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1280:
1281: // Get the current page
1282: if(page==0xFF)
1283: page=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE);
1284:
1285: if(rlr>=nbrows)rlr=nbrows-1;
1286: if(clr>=nbcols)clr=nbcols-1;
1287: if(nblines>nbrows)nblines=0;
1288: cols=clr-cul+1;
1289:
1290: if(vga_modes[line].class==TEXT)
1291: {
1292: // Compute the address
1293: address=SCREEN_MEM_START(nbcols,nbrows,page);
1294: #ifdef DEBUG
1295: printf("Scroll, address %04x (%04x %04x %02x)\n",address,nbrows,nbcols,page);
1296: #endif
1297:
1298: if(nblines==0&&rul==0&&cul==0&&rlr==nbrows-1&&clr==nbcols-1)
1299: {
1300: memsetw(vga_modes[line].sstart,address,(Bit16u)attr*0x100+' ',nbrows*nbcols);
1301: }
1302: else
1303: {// if Scroll up
1304: if(dir==SCROLL_UP)
1305: {for(i=rul;i<=rlr;i++)
1306: {
1307: if((i+nblines>rlr)||(nblines==0))
1308: memsetw(vga_modes[line].sstart,address+(i*nbcols+cul)*2,(Bit16u)attr*0x100+' ',cols);
1309: else
1310: memcpyw(vga_modes[line].sstart,address+(i*nbcols+cul)*2,vga_modes[line].sstart,((i+nblines)*nbcols+cul)*2,cols);
1311: }
1312: }
1313: else
1314: {for(i=rlr;i>=rul;i--)
1315: {
1316: if((i<rul+nblines)||(nblines==0))
1317: memsetw(vga_modes[line].sstart,address+(i*nbcols+cul)*2,(Bit16u)attr*0x100+' ',cols);
1318: else
1319: memcpyw(vga_modes[line].sstart,address+(i*nbcols+cul)*2,vga_modes[line].sstart,((i-nblines)*nbcols+cul)*2,cols);
1320: if (i>rlr) break;
1321: }
1322: }
1323: }
1324: }
1325: else
1326: {
1327: // FIXME gfx mode not complete
1328: cheight=video_param_table[line_to_vpti[line]].cheight;
1329: switch(vga_modes[line].memmodel)
1330: {
1331: case PLANAR4:
1332: case PLANAR1:
1333: if(nblines==0&&rul==0&&cul==0&&rlr==nbrows-1&&clr==nbcols-1)
1334: {
1335: outw(VGAREG_GRDC_ADDRESS, 0x0205);
1336: memsetb(vga_modes[line].sstart,0,attr,nbrows*nbcols*cheight);
1337: outw(VGAREG_GRDC_ADDRESS, 0x0005);
1338: }
1339: else
1340: {// if Scroll up
1341: if(dir==SCROLL_UP)
1342: {for(i=rul;i<=rlr;i++)
1343: {
1344: if((i+nblines>rlr)||(nblines==0))
1345: vgamem_fill_pl4(cul,i,cols,nbcols,cheight,attr);
1346: else
1347: vgamem_copy_pl4(cul,i+nblines,i,cols,nbcols,cheight);
1348: }
1349: }
1350: else
1351: {for(i=rlr;i>=rul;i--)
1352: {
1353: if((i<rul+nblines)||(nblines==0))
1354: vgamem_fill_pl4(cul,i,cols,nbcols,cheight,attr);
1355: else
1356: vgamem_copy_pl4(cul,i,i-nblines,cols,nbcols,cheight);
1357: if (i>rlr) break;
1358: }
1359: }
1360: }
1361: break;
1362: case CGA:
1363: bpp=vga_modes[line].pixbits;
1364: if(nblines==0&&rul==0&&cul==0&&rlr==nbrows-1&&clr==nbcols-1)
1365: {
1366: memsetb(vga_modes[line].sstart,0,attr,nbrows*nbcols*cheight*bpp);
1367: }
1368: else
1369: {
1370: if(bpp==2)
1371: {
1372: cul<<=1;
1373: cols<<=1;
1374: nbcols<<=1;
1375: }
1376: // if Scroll up
1377: if(dir==SCROLL_UP)
1378: {for(i=rul;i<=rlr;i++)
1379: {
1380: if((i+nblines>rlr)||(nblines==0))
1381: vgamem_fill_cga(cul,i,cols,nbcols,cheight,attr);
1382: else
1383: vgamem_copy_cga(cul,i+nblines,i,cols,nbcols,cheight);
1384: }
1385: }
1386: else
1387: {for(i=rlr;i>=rul;i--)
1388: {
1389: if((i<rul+nblines)||(nblines==0))
1390: vgamem_fill_cga(cul,i,cols,nbcols,cheight,attr);
1391: else
1392: vgamem_copy_cga(cul,i,i-nblines,cols,nbcols,cheight);
1393: if (i>rlr) break;
1394: }
1395: }
1396: }
1397: break;
1398: #ifdef DEBUG
1399: default:
1400: printf("Scroll in graphics mode ");
1401: unimplemented();
1402: #endif
1403: }
1404: }
1405: }
1406:
1407: // --------------------------------------------------------------------------------------------
1408: static void biosfn_read_char_attr (page,car)
1409: Bit8u page;Bit16u *car;
1410: {Bit16u ss=get_SS();
1411: Bit8u xcurs,ycurs,mode,line;
1412: Bit16u nbcols,nbrows,address;
1413: Bit16u cursor,dummy;
1414:
1415: // Get the mode
1416: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1417: line=find_vga_entry(mode);
1418: if(line==0xFF)return;
1419:
1420: // Get the cursor pos for the page
1421: biosfn_get_cursor_pos(page,&dummy,&cursor);
1422: xcurs=cursor&0x00ff;ycurs=(cursor&0xff00)>>8;
1423:
1424: // Get the dimensions
1425: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1426: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1427:
1428: if(vga_modes[line].class==TEXT)
1429: {
1430: // Compute the address
1431: address=SCREEN_MEM_START(nbcols,nbrows,page)+(xcurs+ycurs*nbcols)*2;
1432:
1433: write_word(ss,car,read_word(vga_modes[line].sstart,address));
1434: }
1435: else
1436: {
1437: // FIXME gfx mode
1438: #ifdef DEBUG
1439: unimplemented();
1440: #endif
1441: }
1442: }
1443:
1444: // --------------------------------------------------------------------------------------------
1445: static void write_gfx_char_pl4(car,attr,xcurs,ycurs,nbcols,cheight)
1446: Bit8u car;Bit8u attr;Bit8u xcurs;Bit8u ycurs;Bit8u nbcols;Bit8u cheight;
1447: {
1448: Bit8u i,j,mask;
1449: Bit8u *fdata;
1450: Bit16u addr,dest,src;
1451:
1452: switch(cheight)
1453: {case 14:
1454: fdata = &vgafont14;
1455: break;
1456: case 16:
1457: fdata = &vgafont16;
1458: break;
1459: default:
1460: fdata = &vgafont8;
1461: }
1462: addr=xcurs+ycurs*cheight*nbcols;
1463: src = car * cheight;
1464: outw(VGAREG_SEQU_ADDRESS, 0x0f02);
1465: outw(VGAREG_GRDC_ADDRESS, 0x0205);
1466: if(attr&0x80)
1467: {
1468: outw(VGAREG_GRDC_ADDRESS, 0x1803);
1469: }
1470: else
1471: {
1472: outw(VGAREG_GRDC_ADDRESS, 0x0003);
1473: }
1474: for(i=0;i<cheight;i++)
1475: {
1476: dest=addr+i*nbcols;
1477: for(j=0;j<8;j++)
1478: {
1479: mask=0x80>>j;
1480: outw(VGAREG_GRDC_ADDRESS, (mask << 8) | 0x08);
1481: read_byte(0xa000,dest);
1482: if(fdata[src+i]&mask)
1483: {
1484: write_byte(0xa000,dest,attr&0x0f);
1485: }
1486: else
1487: {
1488: write_byte(0xa000,dest,0x00);
1489: }
1490: }
1491: }
1492: ASM_START
1493: mov dx, # VGAREG_GRDC_ADDRESS
1494: mov ax, #0xff08
1495: out dx, ax
1496: mov ax, #0x0005
1497: out dx, ax
1498: mov ax, #0x0003
1499: out dx, ax
1500: ASM_END
1501: }
1502:
1503: // --------------------------------------------------------------------------------------------
1504: static void write_gfx_char_cga(car,attr,xcurs,ycurs,nbcols,bpp)
1505: Bit8u car;Bit8u attr;Bit8u xcurs;Bit8u ycurs;Bit8u nbcols;Bit8u bpp;
1506: {
1507: Bit8u i,j,mask,data;
1508: Bit8u *fdata;
1509: Bit16u addr,dest,src;
1510:
1511: fdata = &vgafont8;
1512: addr=(xcurs*bpp)+ycurs*320;
1513: src = car * 8;
1514: for(i=0;i<8;i++)
1515: {
1516: dest=addr+(i>>1)*80;
1517: if (i & 1) dest += 0x2000;
1518: mask = 0x80;
1519: if (bpp == 1)
1520: {
1521: if (attr & 0x80)
1522: {
1523: data = read_byte(0xb800,dest);
1524: }
1525: else
1526: {
1527: data = 0x00;
1528: }
1529: for(j=0;j<8;j++)
1530: {
1531: if (fdata[src+i] & mask)
1532: {
1533: if (attr & 0x80)
1534: {
1535: data ^= (attr & 0x01) << (7-j);
1536: }
1537: else
1538: {
1539: data |= (attr & 0x01) << (7-j);
1540: }
1541: }
1542: mask >>= 1;
1543: }
1544: write_byte(0xb800,dest,data);
1545: }
1546: else
1547: {
1548: while (mask > 0)
1549: {
1550: if (attr & 0x80)
1551: {
1552: data = read_byte(0xb800,dest);
1553: }
1554: else
1555: {
1556: data = 0x00;
1557: }
1558: for(j=0;j<4;j++)
1559: {
1560: if (fdata[src+i] & mask)
1561: {
1562: if (attr & 0x80)
1563: {
1564: data ^= (attr & 0x03) << ((3-j)*2);
1565: }
1566: else
1567: {
1568: data |= (attr & 0x03) << ((3-j)*2);
1569: }
1570: }
1571: mask >>= 1;
1572: }
1573: write_byte(0xb800,dest,data);
1574: dest += 1;
1575: }
1576: }
1577: }
1578: }
1579:
1580: // --------------------------------------------------------------------------------------------
1581: static void write_gfx_char_lin(car,attr,xcurs,ycurs,nbcols)
1582: Bit8u car;Bit8u attr;Bit8u xcurs;Bit8u ycurs;Bit8u nbcols;
1583: {
1584: Bit8u i,j,mask,data;
1585: Bit8u *fdata;
1586: Bit16u addr,dest,src;
1587:
1588: fdata = &vgafont8;
1589: addr=xcurs*8+ycurs*nbcols*64;
1590: src = car * 8;
1591: for(i=0;i<8;i++)
1592: {
1593: dest=addr+i*nbcols*8;
1594: mask = 0x80;
1595: for(j=0;j<8;j++)
1596: {
1597: data = 0x00;
1598: if (fdata[src+i] & mask)
1599: {
1600: data = attr;
1601: }
1602: write_byte(0xa000,dest+j,data);
1603: mask >>= 1;
1604: }
1605: }
1606: }
1607:
1608: // --------------------------------------------------------------------------------------------
1609: static void biosfn_write_char_attr (car,page,attr,count)
1610: Bit8u car;Bit8u page;Bit8u attr;Bit16u count;
1611: {
1612: Bit8u cheight,xcurs,ycurs,mode,line,bpp;
1613: Bit16u nbcols,nbrows,address;
1614: Bit16u cursor,dummy;
1615:
1616: // Get the mode
1617: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1618: line=find_vga_entry(mode);
1619: if(line==0xFF)return;
1620:
1621: // Get the cursor pos for the page
1622: biosfn_get_cursor_pos(page,&dummy,&cursor);
1623: xcurs=cursor&0x00ff;ycurs=(cursor&0xff00)>>8;
1624:
1625: // Get the dimensions
1626: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1627: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1628:
1629: if(vga_modes[line].class==TEXT)
1630: {
1631: // Compute the address
1632: address=SCREEN_MEM_START(nbcols,nbrows,page)+(xcurs+ycurs*nbcols)*2;
1633:
1634: dummy=((Bit16u)attr<<8)+car;
1635: memsetw(vga_modes[line].sstart,address,dummy,count);
1636: }
1637: else
1638: {
1639: // FIXME gfx mode not complete
1640: cheight=video_param_table[line_to_vpti[line]].cheight;
1641: bpp=vga_modes[line].pixbits;
1642: while((count-->0) && (xcurs<nbcols))
1643: {
1644: switch(vga_modes[line].memmodel)
1645: {
1646: case PLANAR4:
1647: case PLANAR1:
1648: write_gfx_char_pl4(car,attr,xcurs,ycurs,nbcols,cheight);
1649: break;
1650: case CGA:
1651: write_gfx_char_cga(car,attr,xcurs,ycurs,nbcols,bpp);
1652: break;
1653: case LINEAR8:
1654: write_gfx_char_lin(car,attr,xcurs,ycurs,nbcols);
1655: break;
1656: #ifdef DEBUG
1657: default:
1658: unimplemented();
1659: #endif
1660: }
1661: xcurs++;
1662: }
1663: }
1664: }
1665:
1666: // --------------------------------------------------------------------------------------------
1667: static void biosfn_write_char_only (car,page,attr,count)
1668: Bit8u car;Bit8u page;Bit8u attr;Bit16u count;
1669: {
1670: Bit8u cheight,xcurs,ycurs,mode,line,bpp;
1671: Bit16u nbcols,nbrows,address;
1672: Bit16u cursor,dummy;
1673:
1674: // Get the mode
1675: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1676: line=find_vga_entry(mode);
1677: if(line==0xFF)return;
1678:
1679: // Get the cursor pos for the page
1680: biosfn_get_cursor_pos(page,&dummy,&cursor);
1681: xcurs=cursor&0x00ff;ycurs=(cursor&0xff00)>>8;
1682:
1683: // Get the dimensions
1684: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1685: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1686:
1687: if(vga_modes[line].class==TEXT)
1688: {
1689: // Compute the address
1690: address=SCREEN_MEM_START(nbcols,nbrows,page)+(xcurs+ycurs*nbcols)*2;
1691:
1692: while(count-->0)
1693: {write_byte(vga_modes[line].sstart,address,car);
1694: address+=2;
1695: }
1696: }
1697: else
1698: {
1699: // FIXME gfx mode not complete
1700: cheight=video_param_table[line_to_vpti[line]].cheight;
1701: bpp=vga_modes[line].pixbits;
1702: while((count-->0) && (xcurs<nbcols))
1703: {
1704: switch(vga_modes[line].memmodel)
1705: {
1706: case PLANAR4:
1707: case PLANAR1:
1708: write_gfx_char_pl4(car,attr,xcurs,ycurs,nbcols,cheight);
1709: break;
1710: case CGA:
1711: write_gfx_char_cga(car,attr,xcurs,ycurs,nbcols,bpp);
1712: break;
1713: case LINEAR8:
1714: write_gfx_char_lin(car,attr,xcurs,ycurs,nbcols);
1715: break;
1716: #ifdef DEBUG
1717: default:
1718: unimplemented();
1719: #endif
1720: }
1721: xcurs++;
1722: }
1723: }
1724: }
1725:
1726: // --------------------------------------------------------------------------------------------
1727: ASM_START
1728: biosfn_group_0B:
1729: cmp bh, #0x00
1730: je biosfn_set_border_color
1731: cmp bh, #0x01
1732: je biosfn_set_palette
1733: #ifdef DEBUG
1734: call _unknown
1735: #endif
1736: ret
1737: biosfn_set_border_color:
1738: push ax
1739: push bx
1740: push cx
1741: push dx
1742: mov dx, # VGAREG_ACTL_RESET
1743: in al, dx
1744: mov dx, # VGAREG_ACTL_ADDRESS
1745: mov al, #0x00
1746: out dx, al
1747: mov al, bl
1748: and al, #0x0f
1749: test al, #0x08
1750: jz set_low_border
1751: add al, #0x08
1752: set_low_border:
1753: out dx, al
1754: mov cl, #0x01
1755: and bl, #0x10
1756: set_intensity_loop:
1757: mov dx, # VGAREG_ACTL_ADDRESS
1758: mov al, cl
1759: out dx, al
1760: mov dx, # VGAREG_ACTL_READ_DATA
1761: in al, dx
1762: and al, #0xef
1763: or al, bl
1764: mov dx, # VGAREG_ACTL_ADDRESS
1765: out dx, al
1766: inc cl
1767: cmp cl, #0x04
1768: jne set_intensity_loop
1769: mov al, #0x20
1770: out dx, al
1771: pop dx
1772: pop cx
1773: pop bx
1774: pop ax
1775: ret
1776: biosfn_set_palette:
1777: push ax
1778: push bx
1779: push cx
1780: push dx
1781: mov dx, # VGAREG_ACTL_RESET
1782: in al, dx
1783: mov cl, #0x01
1784: and bl, #0x01
1785: set_cga_palette_loop:
1786: mov dx, # VGAREG_ACTL_ADDRESS
1787: mov al, cl
1788: out dx, al
1789: mov dx, # VGAREG_ACTL_READ_DATA
1790: in al, dx
1791: and al, #0xfe
1792: or al, bl
1793: mov dx, # VGAREG_ACTL_ADDRESS
1794: out dx, al
1795: inc cl
1796: cmp cl, #0x04
1797: jne set_cga_palette_loop
1798: mov al, #0x20
1799: out dx, al
1800: pop dx
1801: pop cx
1802: pop bx
1803: pop ax
1804: ret
1805: ASM_END
1806:
1807: // --------------------------------------------------------------------------------------------
1808: static void biosfn_write_pixel (BH,AL,CX,DX) Bit8u BH;Bit8u AL;Bit16u CX;Bit16u DX;
1809: {
1810: Bit8u mode,line,mask,attr,data;
1811: Bit16u addr;
1812:
1813: // Get the mode
1814: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1815: line=find_vga_entry(mode);
1816: if(line==0xFF)return;
1817: if(vga_modes[line].class==TEXT)return;
1818:
1819: switch(vga_modes[line].memmodel)
1820: {
1821: case PLANAR4:
1822: case PLANAR1:
1823: addr = CX/8+DX*read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1824: mask = 0x80 >> (CX & 0x07);
1825: outw(VGAREG_GRDC_ADDRESS, (mask << 8) | 0x08);
1826: outw(VGAREG_GRDC_ADDRESS, 0x0205);
1827: data = read_byte(0xa000,addr);
1828: if (AL & 0x80)
1829: {
1830: outw(VGAREG_GRDC_ADDRESS, 0x1803);
1831: }
1832: write_byte(0xa000,addr,AL);
1833: ASM_START
1834: mov dx, # VGAREG_GRDC_ADDRESS
1835: mov ax, #0xff08
1836: out dx, ax
1837: mov ax, #0x0005
1838: out dx, ax
1839: mov ax, #0x0003
1840: out dx, ax
1841: ASM_END
1842: break;
1843: case CGA:
1844: if(vga_modes[line].pixbits==2)
1845: {
1846: addr=(CX>>2)+(DX>>1)*80;
1847: }
1848: else
1849: {
1850: addr=(CX>>3)+(DX>>1)*80;
1851: }
1852: if (DX & 1) addr += 0x2000;
1853: data = read_byte(0xb800,addr);
1854: if(vga_modes[line].pixbits==2)
1855: {
1856: attr = (AL & 0x03) << ((3 - (CX & 0x03)) * 2);
1857: mask = 0x03 << ((3 - (CX & 0x03)) * 2);
1858: }
1859: else
1860: {
1861: attr = (AL & 0x01) << (7 - (CX & 0x07));
1862: mask = 0x01 << (7 - (CX & 0x07));
1863: }
1864: if (AL & 0x80)
1865: {
1866: data ^= attr;
1867: }
1868: else
1869: {
1870: data &= ~mask;
1871: data |= attr;
1872: }
1873: write_byte(0xb800,addr,data);
1874: break;
1875: case LINEAR8:
1876: addr=CX+DX*(read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS)*8);
1877: write_byte(0xa000,addr,AL);
1878: break;
1879: #ifdef DEBUG
1880: default:
1881: unimplemented();
1882: #endif
1883: }
1884: }
1885:
1886: // --------------------------------------------------------------------------------------------
1887: static void biosfn_read_pixel (BH,CX,DX,AX) Bit8u BH;Bit16u CX;Bit16u DX;Bit16u *AX;
1888: {
1889: Bit8u mode,line,mask,attr,data,i;
1890: Bit16u addr;
1891: Bit16u ss=get_SS();
1892:
1893: // Get the mode
1894: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1895: line=find_vga_entry(mode);
1896: if(line==0xFF)return;
1897: if(vga_modes[line].class==TEXT)return;
1898:
1899: switch(vga_modes[line].memmodel)
1900: {
1901: case PLANAR4:
1902: case PLANAR1:
1903: addr = CX/8+DX*read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1904: mask = 0x80 >> (CX & 0x07);
1905: attr = 0x00;
1906: for(i=0;i<4;i++)
1907: {
1908: outw(VGAREG_GRDC_ADDRESS, (i << 8) | 0x04);
1909: data = read_byte(0xa000,addr) & mask;
1910: if (data > 0) attr |= (0x01 << i);
1911: }
1912: break;
1913: case CGA:
1914: addr=(CX>>2)+(DX>>1)*80;
1915: if (DX & 1) addr += 0x2000;
1916: data = read_byte(0xb800,addr);
1917: if(vga_modes[line].pixbits==2)
1918: {
1919: attr = (data >> ((3 - (CX & 0x03)) * 2)) & 0x03;
1920: }
1921: else
1922: {
1923: attr = (data >> (7 - (CX & 0x07))) & 0x01;
1924: }
1925: break;
1926: case LINEAR8:
1927: addr=CX+DX*(read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS)*8);
1928: attr=read_byte(0xa000,addr);
1929: break;
1930: default:
1931: #ifdef DEBUG
1932: unimplemented();
1933: #endif
1934: attr = 0;
1935: }
1936: write_word(ss,AX,(read_word(ss,AX) & 0xff00) | attr);
1937: }
1938:
1939: // --------------------------------------------------------------------------------------------
1940: static void biosfn_write_teletype (car, page, attr, flag)
1941: Bit8u car;Bit8u page;Bit8u attr;Bit8u flag;
1942: {// flag = WITH_ATTR / NO_ATTR
1943:
1944: Bit8u cheight,xcurs,ycurs,mode,line,bpp;
1945: Bit16u nbcols,nbrows,address;
1946: Bit16u cursor,dummy;
1947:
1948: // special case if page is 0xff, use current page
1949: if(page==0xff)
1950: page=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE);
1951:
1952: // Get the mode
1953: mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
1954: line=find_vga_entry(mode);
1955: if(line==0xFF)return;
1956:
1957: // Get the cursor pos for the page
1958: biosfn_get_cursor_pos(page,&dummy,&cursor);
1959: xcurs=cursor&0x00ff;ycurs=(cursor&0xff00)>>8;
1960:
1961: // Get the dimensions
1962: nbrows=read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)+1;
1963: nbcols=read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
1964:
1965: switch(car)
1966: {
1967: case 7:
1968: //FIXME should beep
1969: break;
1970:
1971: case 8:
1972: if(xcurs>0)xcurs--;
1973: break;
1974:
1975: case '\r':
1976: xcurs=0;
1977: break;
1978:
1979: case '\n':
1980: ycurs++;
1981: break;
1982:
1983: case '\t':
1984: do
1985: {
1986: biosfn_write_teletype(' ',page,attr,flag);
1987: biosfn_get_cursor_pos(page,&dummy,&cursor);
1988: xcurs=cursor&0x00ff;ycurs=(cursor&0xff00)>>8;
1989: }while(xcurs%8==0);
1990: break;
1991:
1992: default:
1993:
1994: if(vga_modes[line].class==TEXT)
1995: {
1996: // Compute the address
1997: address=SCREEN_MEM_START(nbcols,nbrows,page)+(xcurs+ycurs*nbcols)*2;
1998:
1999: // Write the char
2000: write_byte(vga_modes[line].sstart,address,car);
2001:
2002: if(flag==WITH_ATTR)
2003: write_byte(vga_modes[line].sstart,address+1,attr);
2004: }
2005: else
2006: {
2007: // FIXME gfx mode not complete
2008: cheight=video_param_table[line_to_vpti[line]].cheight;
2009: bpp=vga_modes[line].pixbits;
2010: switch(vga_modes[line].memmodel)
2011: {
2012: case PLANAR4:
2013: case PLANAR1:
2014: write_gfx_char_pl4(car,attr,xcurs,ycurs,nbcols,cheight);
2015: break;
2016: case CGA:
2017: write_gfx_char_cga(car,attr,xcurs,ycurs,nbcols,bpp);
2018: break;
2019: case LINEAR8:
2020: write_gfx_char_lin(car,attr,xcurs,ycurs,nbcols);
2021: break;
2022: #ifdef DEBUG
2023: default:
2024: unimplemented();
2025: #endif
2026: }
2027: }
2028: xcurs++;
2029: }
2030:
2031: // Do we need to wrap ?
2032: if(xcurs==nbcols)
2033: {xcurs=0;
2034: ycurs++;
2035: }
2036:
2037: // Do we need to scroll ?
2038: if(ycurs==nbrows)
2039: {
2040: if(vga_modes[line].class==TEXT)
2041: {
2042: biosfn_scroll(0x01,0x07,0,0,nbrows-1,nbcols-1,page,SCROLL_UP);
2043: }
2044: else
2045: {
2046: biosfn_scroll(0x01,0x00,0,0,nbrows-1,nbcols-1,page,SCROLL_UP);
2047: }
2048: ycurs-=1;
2049: }
2050:
2051: // Set the cursor for the page
2052: cursor=ycurs; cursor<<=8; cursor+=xcurs;
2053: biosfn_set_cursor_pos(page,cursor);
2054: }
2055:
2056: // --------------------------------------------------------------------------------------------
2057: ASM_START
2058: biosfn_get_video_mode:
2059: push ds
2060: mov ax, # BIOSMEM_SEG
2061: mov ds, ax
2062: push bx
2063: mov bx, # BIOSMEM_CURRENT_PAGE
2064: mov al, [bx]
2065: pop bx
2066: mov bh, al
2067: push bx
2068: mov bx, # BIOSMEM_VIDEO_CTL
2069: mov ah, [bx]
2070: and ah, #0x80
2071: mov bx, # BIOSMEM_CURRENT_MODE
2072: mov al, [bx]
2073: or al, ah
2074: mov bx, # BIOSMEM_NB_COLS
2075: mov ah, [bx]
2076: pop bx
2077: pop ds
2078: ret
2079: ASM_END
2080:
2081: // --------------------------------------------------------------------------------------------
2082: ASM_START
2083: biosfn_group_10:
2084: cmp al, #0x00
2085: jne int10_test_1001
2086: jmp biosfn_set_single_palette_reg
2087: int10_test_1001:
2088: cmp al, #0x01
2089: jne int10_test_1002
2090: jmp biosfn_set_overscan_border_color
2091: int10_test_1002:
2092: cmp al, #0x02
2093: jne int10_test_1003
2094: jmp biosfn_set_all_palette_reg
2095: int10_test_1003:
2096: cmp al, #0x03
2097: jne int10_test_1007
2098: jmp biosfn_toggle_intensity
2099: int10_test_1007:
2100: cmp al, #0x07
2101: jne int10_test_1008
2102: jmp biosfn_get_single_palette_reg
2103: int10_test_1008:
2104: cmp al, #0x08
2105: jne int10_test_1009
2106: jmp biosfn_read_overscan_border_color
2107: int10_test_1009:
2108: cmp al, #0x09
2109: jne int10_test_1010
2110: jmp biosfn_get_all_palette_reg
2111: int10_test_1010:
2112: cmp al, #0x10
2113: jne int10_test_1012
2114: jmp biosfn_set_single_dac_reg
2115: int10_test_1012:
2116: cmp al, #0x12
2117: jne int10_test_1013
2118: jmp biosfn_set_all_dac_reg
2119: int10_test_1013:
2120: cmp al, #0x13
2121: jne int10_test_1015
2122: jmp biosfn_select_video_dac_color_page
2123: int10_test_1015:
2124: cmp al, #0x15
2125: jne int10_test_1017
2126: jmp biosfn_read_single_dac_reg
2127: int10_test_1017:
2128: cmp al, #0x17
2129: jne int10_test_1018
2130: jmp biosfn_read_all_dac_reg
2131: int10_test_1018:
2132: cmp al, #0x18
2133: jne int10_test_1019
2134: jmp biosfn_set_pel_mask
2135: int10_test_1019:
2136: cmp al, #0x19
2137: jne int10_test_101A
2138: jmp biosfn_read_pel_mask
2139: int10_test_101A:
2140: cmp al, #0x1a
2141: jne int10_group_10_unknown
2142: jmp biosfn_read_video_dac_state
2143: int10_group_10_unknown:
2144: #ifdef DEBUG
2145: call _unknown
2146: #endif
2147: ret
2148:
2149: biosfn_set_single_palette_reg:
2150: cmp bl, #0x14
2151: ja no_actl_reg1
2152: push ax
2153: push dx
2154: mov dx, # VGAREG_ACTL_RESET
2155: in al, dx
2156: mov dx, # VGAREG_ACTL_ADDRESS
2157: mov al, bl
2158: out dx, al
2159: mov al, bh
2160: out dx, al
2161: mov al, #0x20
2162: out dx, al
2163: pop dx
2164: pop ax
2165: no_actl_reg1:
2166: ret
2167: ASM_END
2168:
2169: // --------------------------------------------------------------------------------------------
2170: ASM_START
2171: biosfn_set_overscan_border_color:
2172: push bx
2173: mov bl, #0x11
2174: call biosfn_set_single_palette_reg
2175: pop bx
2176: ret
2177: ASM_END
2178:
2179: // --------------------------------------------------------------------------------------------
2180: ASM_START
2181: biosfn_set_all_palette_reg:
2182: push ax
2183: push bx
2184: push cx
2185: push dx
2186: mov bx, dx
2187: mov dx, # VGAREG_ACTL_RESET
2188: in al, dx
2189: mov cl, #0x00
2190: mov dx, # VGAREG_ACTL_ADDRESS
2191: set_palette_loop:
2192: mov al, cl
2193: out dx, al
2194: seg es
2195: mov al, [bx]
2196: out dx, al
2197: inc bx
2198: inc cl
2199: cmp cl, #0x10
2200: jne set_palette_loop
2201: mov al, #0x11
2202: out dx, al
2203: seg es
2204: mov al, [bx]
2205: out dx, al
2206: mov al, #0x20
2207: out dx, al
2208: pop dx
2209: pop cx
2210: pop bx
2211: pop ax
2212: ret
2213: ASM_END
2214:
2215: // --------------------------------------------------------------------------------------------
2216: ASM_START
2217: biosfn_toggle_intensity:
2218: push ax
2219: push bx
2220: push dx
2221: mov dx, # VGAREG_ACTL_RESET
2222: in al, dx
2223: mov dx, # VGAREG_ACTL_ADDRESS
2224: mov al, #0x10
2225: out dx, al
2226: mov dx, # VGAREG_ACTL_READ_DATA
2227: in al, dx
2228: and al, #0xf7
2229: and bl, #0x01
2230: shl bl, 3
2231: or al, bl
2232: mov dx, # VGAREG_ACTL_ADDRESS
2233: out dx, al
2234: mov al, #0x20
2235: out dx, al
2236: pop dx
2237: pop bx
2238: pop ax
2239: ret
2240: ASM_END
2241:
2242: // --------------------------------------------------------------------------------------------
2243: ASM_START
2244: biosfn_get_single_palette_reg:
2245: cmp bl, #0x14
2246: ja no_actl_reg2
2247: push ax
2248: push dx
2249: mov dx, # VGAREG_ACTL_RESET
2250: in al, dx
2251: mov dx, # VGAREG_ACTL_ADDRESS
2252: mov al, bl
2253: out dx, al
2254: mov dx, # VGAREG_ACTL_READ_DATA
2255: in al, dx
2256: mov bh, al
2257: mov dx, # VGAREG_ACTL_RESET
2258: in al, dx
2259: mov dx, # VGAREG_ACTL_ADDRESS
2260: mov al, #0x20
2261: out dx, al
2262: pop dx
2263: pop ax
2264: no_actl_reg2:
2265: ret
2266: ASM_END
2267:
2268: // --------------------------------------------------------------------------------------------
2269: ASM_START
2270: biosfn_read_overscan_border_color:
2271: push ax
2272: push bx
2273: mov bl, #0x11
2274: call biosfn_get_single_palette_reg
2275: mov al, bh
2276: pop bx
2277: mov bh, al
2278: pop ax
2279: ret
2280: ASM_END
2281:
2282: // --------------------------------------------------------------------------------------------
2283: ASM_START
2284: biosfn_get_all_palette_reg:
2285: push ax
2286: push bx
2287: push cx
2288: push dx
2289: mov bx, dx
2290: mov cl, #0x00
2291: get_palette_loop:
2292: mov dx, # VGAREG_ACTL_RESET
2293: in al, dx
2294: mov dx, # VGAREG_ACTL_ADDRESS
2295: mov al, cl
2296: out dx, al
2297: mov dx, # VGAREG_ACTL_READ_DATA
2298: in al, dx
2299: seg es
2300: mov [bx], al
2301: inc bx
2302: inc cl
2303: cmp cl, #0x10
2304: jne get_palette_loop
2305: mov dx, # VGAREG_ACTL_RESET
2306: in al, dx
2307: mov dx, # VGAREG_ACTL_ADDRESS
2308: mov al, #0x11
2309: out dx, al
2310: mov dx, # VGAREG_ACTL_READ_DATA
2311: in al, dx
2312: seg es
2313: mov [bx], al
2314: mov dx, # VGAREG_ACTL_RESET
2315: in al, dx
2316: mov dx, # VGAREG_ACTL_ADDRESS
2317: mov al, #0x20
2318: out dx, al
2319: pop dx
2320: pop cx
2321: pop bx
2322: pop ax
2323: ret
2324: ASM_END
2325:
2326: // --------------------------------------------------------------------------------------------
2327: ASM_START
2328: biosfn_set_single_dac_reg:
2329: push ax
2330: push dx
2331: mov dx, # VGAREG_DAC_WRITE_ADDRESS
2332: mov al, bl
2333: out dx, al
2334: mov dx, # VGAREG_DAC_DATA
2335: pop ax
2336: push ax
2337: mov al, ah
2338: out dx, al
2339: mov al, ch
2340: out dx, al
2341: mov al, cl
2342: out dx, al
2343: pop dx
2344: pop ax
2345: ret
2346: ASM_END
2347:
2348: // --------------------------------------------------------------------------------------------
2349: ASM_START
2350: biosfn_set_all_dac_reg:
2351: push ax
2352: push bx
2353: push cx
2354: push dx
2355: mov dx, # VGAREG_DAC_WRITE_ADDRESS
2356: mov al, bl
2357: out dx, al
2358: pop dx
2359: push dx
2360: mov bx, dx
2361: mov dx, # VGAREG_DAC_DATA
2362: set_dac_loop:
2363: seg es
2364: mov al, [bx]
2365: out dx, al
2366: inc bx
2367: seg es
2368: mov al, [bx]
2369: out dx, al
2370: inc bx
2371: seg es
2372: mov al, [bx]
2373: out dx, al
2374: inc bx
2375: dec cx
2376: jnz set_dac_loop
2377: pop dx
2378: pop cx
2379: pop bx
2380: pop ax
2381: ret
2382: ASM_END
2383:
2384: // --------------------------------------------------------------------------------------------
2385: ASM_START
2386: biosfn_select_video_dac_color_page:
2387: push ax
2388: push bx
2389: push dx
2390: mov dx, # VGAREG_ACTL_RESET
2391: in al, dx
2392: mov dx, # VGAREG_ACTL_ADDRESS
2393: mov al, #0x10
2394: out dx, al
2395: mov dx, # VGAREG_ACTL_READ_DATA
2396: in al, dx
2397: and bl, #0x01
2398: jnz set_dac_page
2399: and al, #0x7f
2400: shl bh, 7
2401: or al, bh
2402: mov dx, # VGAREG_ACTL_ADDRESS
2403: out dx, al
2404: jmp set_actl_normal
2405: set_dac_page:
2406: push ax
2407: mov dx, # VGAREG_ACTL_RESET
2408: in al, dx
2409: mov dx, # VGAREG_ACTL_ADDRESS
2410: mov al, #0x14
2411: out dx, al
2412: pop ax
2413: and al, #0x80
2414: jnz set_dac_16_page
2415: shl bh, 2
2416: set_dac_16_page:
2417: and bh, #0x0f
2418: mov al, bh
2419: out dx, al
2420: set_actl_normal:
2421: mov al, #0x20
2422: out dx, al
2423: pop dx
2424: pop bx
2425: pop ax
2426: ret
2427: ASM_END
2428:
2429: // --------------------------------------------------------------------------------------------
2430: ASM_START
2431: biosfn_read_single_dac_reg:
2432: push ax
2433: push dx
2434: mov dx, # VGAREG_DAC_READ_ADDRESS
2435: mov al, bl
2436: out dx, al
2437: pop ax
2438: mov ah, al
2439: mov dx, # VGAREG_DAC_DATA
2440: in al, dx
2441: xchg al, ah
2442: push ax
2443: in al, dx
2444: mov ch, al
2445: in al, dx
2446: mov cl, al
2447: pop dx
2448: pop ax
2449: ret
2450: ASM_END
2451:
2452: // --------------------------------------------------------------------------------------------
2453: ASM_START
2454: biosfn_read_all_dac_reg:
2455: push ax
2456: push bx
2457: push cx
2458: push dx
2459: mov dx, # VGAREG_DAC_READ_ADDRESS
2460: mov al, bl
2461: out dx, al
2462: pop dx
2463: push dx
2464: mov bx, dx
2465: mov dx, # VGAREG_DAC_DATA
2466: read_dac_loop:
2467: in al, dx
2468: seg es
2469: mov [bx], al
2470: inc bx
2471: in al, dx
2472: seg es
2473: mov [bx], al
2474: inc bx
2475: in al, dx
2476: seg es
2477: mov [bx], al
2478: inc bx
2479: dec cx
2480: jnz read_dac_loop
2481: pop dx
2482: pop cx
2483: pop bx
2484: pop ax
2485: ret
2486: ASM_END
2487:
2488: // --------------------------------------------------------------------------------------------
2489: ASM_START
2490: biosfn_set_pel_mask:
2491: push ax
2492: push dx
2493: mov dx, # VGAREG_PEL_MASK
2494: mov al, bl
2495: out dx, al
2496: pop dx
2497: pop ax
2498: ret
2499: ASM_END
2500:
2501: // --------------------------------------------------------------------------------------------
2502: ASM_START
2503: biosfn_read_pel_mask:
2504: push ax
2505: push dx
2506: mov dx, # VGAREG_PEL_MASK
2507: in al, dx
2508: mov bl, al
2509: pop dx
2510: pop ax
2511: ret
2512: ASM_END
2513:
2514: // --------------------------------------------------------------------------------------------
2515: ASM_START
2516: biosfn_read_video_dac_state:
2517: push ax
2518: push dx
2519: mov dx, # VGAREG_ACTL_RESET
2520: in al, dx
2521: mov dx, # VGAREG_ACTL_ADDRESS
2522: mov al, #0x10
2523: out dx, al
2524: mov dx, # VGAREG_ACTL_READ_DATA
2525: in al, dx
2526: mov bl, al
2527: shr bl, 7
2528: mov dx, # VGAREG_ACTL_RESET
2529: in al, dx
2530: mov dx, # VGAREG_ACTL_ADDRESS
2531: mov al, #0x14
2532: out dx, al
2533: mov dx, # VGAREG_ACTL_READ_DATA
2534: in al, dx
2535: mov bh, al
2536: and bh, #0x0f
2537: test bl, #0x01
2538: jnz get_dac_16_page
2539: shr bh, 2
2540: get_dac_16_page:
2541: mov dx, # VGAREG_ACTL_RESET
2542: in al, dx
2543: mov dx, # VGAREG_ACTL_ADDRESS
2544: mov al, #0x20
2545: out dx, al
2546: pop dx
2547: pop ax
2548: ret
2549: ASM_END
2550:
2551: // --------------------------------------------------------------------------------------------
2552: static void biosfn_perform_gray_scale_summing (start,count)
2553: Bit16u start;Bit16u count;
2554: {Bit8u r,g,b;
2555: Bit16u i;
2556: Bit16u index;
2557:
2558: inb(VGAREG_ACTL_RESET);
2559: outb(VGAREG_ACTL_ADDRESS,0x00);
2560:
2561: for( index = 0; index < count; index++ )
2562: {
2563: // set read address and switch to read mode
2564: outb(VGAREG_DAC_READ_ADDRESS,start);
2565: // get 6-bit wide RGB data values
2566: r=inb( VGAREG_DAC_DATA );
2567: g=inb( VGAREG_DAC_DATA );
2568: b=inb( VGAREG_DAC_DATA );
2569:
2570: // intensity = ( 0.3 * Red ) + ( 0.59 * Green ) + ( 0.11 * Blue )
2571: i = ( ( 77*r + 151*g + 28*b ) + 0x80 ) >> 8;
2572:
2573: if(i>0x3f)i=0x3f;
2574:
2575: // set write address and switch to write mode
2576: outb(VGAREG_DAC_WRITE_ADDRESS,start);
2577: // write new intensity value
2578: outb( VGAREG_DAC_DATA, i&0xff );
2579: outb( VGAREG_DAC_DATA, i&0xff );
2580: outb( VGAREG_DAC_DATA, i&0xff );
2581: start++;
2582: }
2583: inb(VGAREG_ACTL_RESET);
2584: outb(VGAREG_ACTL_ADDRESS,0x20);
2585: }
2586:
2587: // --------------------------------------------------------------------------------------------
2588: static void get_font_access()
2589: {
2590: ASM_START
2591: mov dx, # VGAREG_SEQU_ADDRESS
2592: mov ax, #0x0100
2593: out dx, ax
2594: mov ax, #0x0402
2595: out dx, ax
2596: mov ax, #0x0704
2597: out dx, ax
2598: mov ax, #0x0300
2599: out dx, ax
2600: mov dx, # VGAREG_GRDC_ADDRESS
2601: mov ax, #0x0204
2602: out dx, ax
2603: mov ax, #0x0005
2604: out dx, ax
2605: mov ax, #0x0406
2606: out dx, ax
2607: ASM_END
2608: }
2609:
2610: static void release_font_access()
2611: {
2612: ASM_START
2613: mov dx, # VGAREG_SEQU_ADDRESS
2614: mov ax, #0x0100
2615: out dx, ax
2616: mov ax, #0x0302
2617: out dx, ax
2618: mov ax, #0x0304
2619: out dx, ax
2620: mov ax, #0x0300
2621: out dx, ax
2622: mov dx, # VGAREG_READ_MISC_OUTPUT
2623: in al, dx
2624: and al, #0x01
2625: shl al, 2
2626: or al, #0x0a
2627: mov ah, al
2628: mov al, #0x06
2629: mov dx, # VGAREG_GRDC_ADDRESS
2630: out dx, ax
2631: mov ax, #0x0004
2632: out dx, ax
2633: mov ax, #0x1005
2634: out dx, ax
2635: ASM_END
2636: }
2637:
2638: ASM_START
2639: idiv_u:
2640: xor dx,dx
2641: div bx
2642: ret
2643: ASM_END
2644:
2645: static void set_scan_lines(lines) Bit8u lines;
2646: {
2647: Bit16u crtc_addr,cols,page,vde;
2648: Bit8u crtc_r9,ovl,rows;
2649:
2650: crtc_addr = read_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS);
2651: outb(crtc_addr, 0x09);
2652: crtc_r9 = inb(crtc_addr+1);
2653: crtc_r9 = (crtc_r9 & 0xe0) | (lines - 1);
2654: outb(crtc_addr+1, crtc_r9);
2655: if(lines==8)
2656: {
2657: biosfn_set_cursor_shape(0x06,0x07);
2658: }
2659: else
2660: {
2661: biosfn_set_cursor_shape(lines-4,lines-3);
2662: }
2663: write_word(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT, lines);
2664: outb(crtc_addr, 0x12);
2665: vde = inb(crtc_addr+1);
2666: outb(crtc_addr, 0x07);
2667: ovl = inb(crtc_addr+1);
2668: vde += (((ovl & 0x02) << 7) + ((ovl & 0x40) << 3) + 1);
2669: rows = vde / lines;
2670: write_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS, rows-1);
2671: cols = read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS);
2672: write_word(BIOSMEM_SEG,BIOSMEM_PAGE_SIZE, rows * cols * 2);
2673: }
2674:
2675: static void biosfn_load_text_user_pat (AL,ES,BP,CX,DX,BL,BH) Bit8u AL;Bit16u ES;Bit16u BP;Bit16u CX;Bit16u DX;Bit8u BL;Bit8u BH;
2676: {
2677: Bit16u blockaddr,dest,i,src;
2678:
2679: get_font_access();
2680: blockaddr = ((BL & 0x03) << 14) + ((BL & 0x04) << 11);
2681: for(i=0;i<CX;i++)
2682: {
2683: src = BP + i * BH;
2684: dest = blockaddr + (DX + i) * 32;
2685: memcpyb(0xA000, dest, ES, src, BH);
2686: }
2687: release_font_access();
2688: if(AL>=0x10)
2689: {
2690: set_scan_lines(BH);
2691: }
2692: }
2693:
2694: static void biosfn_load_text_8_14_pat (AL,BL) Bit8u AL;Bit8u BL;
2695: {
2696: Bit16u blockaddr,dest,i,src;
2697:
2698: get_font_access();
2699: blockaddr = ((BL & 0x03) << 14) + ((BL & 0x04) << 11);
2700: for(i=0;i<0x100;i++)
2701: {
2702: src = i * 14;
2703: dest = blockaddr + i * 32;
2704: memcpyb(0xA000, dest, 0xC000, vgafont14+src, 14);
2705: }
2706: release_font_access();
2707: if(AL>=0x10)
2708: {
2709: set_scan_lines(14);
2710: }
2711: }
2712:
2713: static void biosfn_load_text_8_8_pat (AL,BL) Bit8u AL;Bit8u BL;
2714: {
2715: Bit16u blockaddr,dest,i,src;
2716:
2717: get_font_access();
2718: blockaddr = ((BL & 0x03) << 14) + ((BL & 0x04) << 11);
2719: for(i=0;i<0x100;i++)
2720: {
2721: src = i * 8;
2722: dest = blockaddr + i * 32;
2723: memcpyb(0xA000, dest, 0xC000, vgafont8+src, 8);
2724: }
2725: release_font_access();
2726: if(AL>=0x10)
2727: {
2728: set_scan_lines(8);
2729: }
2730: }
2731:
2732: // --------------------------------------------------------------------------------------------
2733: ASM_START
2734: biosfn_set_text_block_specifier:
2735: push ax
2736: push dx
2737: mov dx, # VGAREG_SEQU_ADDRESS
2738: mov ah, bl
2739: mov al, #0x03
2740: out dx, ax
2741: pop dx
2742: pop ax
2743: ret
2744: ASM_END
2745:
2746: // --------------------------------------------------------------------------------------------
2747: static void biosfn_load_text_8_16_pat (AL,BL) Bit8u AL;Bit8u BL;
2748: {
2749: Bit16u blockaddr,dest,i,src;
2750:
2751: get_font_access();
2752: blockaddr = ((BL & 0x03) << 14) + ((BL & 0x04) << 11);
2753: for(i=0;i<0x100;i++)
2754: {
2755: src = i * 16;
2756: dest = blockaddr + i * 32;
2757: memcpyb(0xA000, dest, 0xC000, vgafont16+src, 16);
2758: }
2759: release_font_access();
2760: if(AL>=0x10)
2761: {
2762: set_scan_lines(16);
2763: }
2764: }
2765:
2766: static void biosfn_load_gfx_8_8_chars (ES,BP) Bit16u ES;Bit16u BP;
2767: {
2768: #ifdef DEBUG
2769: unimplemented();
2770: #endif
2771: }
2772: static void biosfn_load_gfx_user_chars (ES,BP,CX,BL,DL) Bit16u ES;Bit16u BP;Bit16u CX;Bit8u BL;Bit8u DL;
2773: {
2774: #ifdef DEBUG
2775: unimplemented();
2776: #endif
2777: }
2778: static void biosfn_load_gfx_8_14_chars (BL) Bit8u BL;
2779: {
2780: #ifdef DEBUG
2781: unimplemented();
2782: #endif
2783: }
2784: static void biosfn_load_gfx_8_8_dd_chars (BL) Bit8u BL;
2785: {
2786: #ifdef DEBUG
2787: unimplemented();
2788: #endif
2789: }
2790: static void biosfn_load_gfx_8_16_chars (BL) Bit8u BL;
2791: {
2792: #ifdef DEBUG
2793: unimplemented();
2794: #endif
2795: }
2796: // --------------------------------------------------------------------------------------------
2797: static void biosfn_get_font_info (BH,ES,BP,CX,DX)
2798: Bit8u BH;Bit16u *ES;Bit16u *BP;Bit16u *CX;Bit16u *DX;
2799: {Bit16u ss=get_SS();
2800:
2801: switch(BH)
2802: {case 0x00:
2803: write_word(ss,ES,read_word(0x00,0x1f*4));
2804: write_word(ss,BP,read_word(0x00,(0x1f*4)+2));
2805: break;
2806: case 0x01:
2807: write_word(ss,ES,read_word(0x00,0x43*4));
2808: write_word(ss,BP,read_word(0x00,(0x43*4)+2));
2809: break;
2810: case 0x02:
2811: write_word(ss,ES,0xC000);
2812: write_word(ss,BP,vgafont14);
2813: break;
2814: case 0x03:
2815: write_word(ss,ES,0xC000);
2816: write_word(ss,BP,vgafont8);
2817: break;
2818: case 0x04:
2819: write_word(ss,ES,0xC000);
2820: write_word(ss,BP,vgafont8+128*8);
2821: break;
2822: case 0x05:
2823: write_word(ss,ES,0xC000);
2824: write_word(ss,BP,vgafont14alt);
2825: break;
2826: case 0x06:
2827: write_word(ss,ES,0xC000);
2828: write_word(ss,BP,vgafont16);
2829: break;
2830: case 0x07:
2831: write_word(ss,ES,0xC000);
2832: write_word(ss,BP,vgafont16alt);
2833: break;
2834: default:
2835: #ifdef DEBUG
2836: printf("Get font info BH(%02x) was discarded\n",BH);
2837: #endif
2838: return;
2839: }
2840: // Set byte/char of on screen font
2841: write_word(ss,CX,(Bit16u)read_byte(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT));
2842:
2843: // Set Highest char row
2844: write_word(ss,DX,(Bit16u)read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS));
2845: }
2846:
2847: // --------------------------------------------------------------------------------------------
2848: ASM_START
2849: biosfn_get_ega_info:
2850: push ds
2851: push ax
2852: mov ax, # BIOSMEM_SEG
2853: mov ds, ax
2854: xor ch, ch
2855: mov bx, # BIOSMEM_SWITCHES
2856: mov cl, [bx]
2857: and cl, #0x0f
2858: mov bx, # BIOSMEM_CRTC_ADDRESS
2859: mov ax, [bx]
2860: mov bx, #0x0003
2861: cmp ax, # VGAREG_MDA_CRTC_ADDRESS
2862: jne mode_ega_color
2863: mov bh, #0x01
2864: mode_ega_color:
2865: pop ax
2866: pop ds
2867: ret
2868: ASM_END
2869:
2870: // --------------------------------------------------------------------------------------------
2871: static void biosfn_alternate_prtsc()
2872: {
2873: #ifdef DEBUG
2874: unimplemented();
2875: #endif
2876: }
2877:
2878: // --------------------------------------------------------------------------------------------
2879: ASM_START
2880: biosfn_select_vert_res:
2881:
2882: ; res : 00 200 lines, 01 350 lines, 02 400 lines
2883:
2884: push ds
2885: push bx
2886: push dx
2887: mov dl, al
2888: mov ax, # BIOSMEM_SEG
2889: mov ds, ax
2890: mov bx, # BIOSMEM_MODESET_CTL
2891: mov al, [bx]
2892: mov bx, # BIOSMEM_SWITCHES
2893: mov ah, [bx]
2894: cmp dl, #0x01
2895: je vert_res_350
2896: jb vert_res_200
2897: cmp dl, #0x02
2898: je vert_res_400
2899: #ifdef DEBUG
2900: mov al, dl
2901: xor ah, ah
2902: push ax
2903: mov bx, #msg_vert_res
2904: push bx
2905: call _printf
2906: add sp, #4
2907: #endif
2908: jmp set_retcode
2909: vert_res_400:
2910:
2911: ; reset modeset ctl bit 7 and set bit 4
2912: ; set switches bit 3-0 to 0x09
2913:
2914: and al, #0x7f
2915: or al, #0x10
2916: and ah, #0xf0
2917: or ah, #0x09
2918: jnz set_vert_res
2919: vert_res_350:
2920:
2921: ; reset modeset ctl bit 7 and bit 4
2922: ; set switches bit 3-0 to 0x09
2923:
2924: and al, #0x6f
2925: and ah, #0xf0
2926: or ah, #0x09
2927: jnz set_vert_res
2928: vert_res_200:
2929:
2930: ; set modeset ctl bit 7 and reset bit 4
2931: ; set switches bit 3-0 to 0x08
2932:
2933: and al, #0xef
2934: or al, #0x80
2935: and ah, #0xf0
2936: or ah, #0x08
2937: set_vert_res:
2938: mov bx, # BIOSMEM_MODESET_CTL
2939: mov [bx], al
2940: mov bx, # BIOSMEM_SWITCHES
2941: mov [bx], ah
2942: set_retcode:
2943: mov ax, #0x1212
2944: pop dx
2945: pop bx
2946: pop ds
2947: ret
2948:
2949: #ifdef DEBUG
2950: msg_vert_res:
2951: .ascii "Select vert res (%02x) was discarded"
2952: .byte 0x0d,0x0a,0x00
2953: #endif
2954:
2955:
2956: biosfn_enable_default_palette_loading:
2957: push ds
2958: push bx
2959: push dx
2960: mov dl, al
2961: and dl, #0x01
2962: shl dl, 3
2963: mov ax, # BIOSMEM_SEG
2964: mov ds, ax
2965: mov bx, # BIOSMEM_MODESET_CTL
2966: mov al, [bx]
2967: and al, #0xf7
2968: or al, dl
2969: mov [bx], al
2970: mov ax, #0x1212
2971: pop dx
2972: pop bx
2973: pop ds
2974: ret
2975:
2976:
2977: biosfn_enable_video_addressing:
2978: push bx
2979: push dx
2980: mov bl, al
2981: and bl, #0x01
2982: xor bl, #0x01
2983: shl bl, 1
2984: mov dx, # VGAREG_READ_MISC_OUTPUT
2985: in al, dx
2986: and al, #0xfd
2987: or al, bl
2988: mov dx, # VGAREG_WRITE_MISC_OUTPUT
2989: out dx, al
2990: mov ax, #0x1212
2991: pop dx
2992: pop bx
2993: ret
2994:
2995:
2996: biosfn_enable_grayscale_summing:
2997: push ds
2998: push bx
2999: push dx
3000: mov dl, al
3001: and dl, #0x01
3002: xor dl, #0x01
3003: shl dl, 1
3004: mov ax, # BIOSMEM_SEG
3005: mov ds, ax
3006: mov bx, # BIOSMEM_MODESET_CTL
3007: mov al, [bx]
3008: and al, #0xfd
3009: or al, dl
3010: mov [bx], al
3011: mov ax, #0x1212
3012: pop dx
3013: pop bx
3014: pop ds
3015: ret
3016:
3017:
3018: biosfn_enable_cursor_emulation:
3019: push ds
3020: push bx
3021: push dx
3022: mov dl, al
3023: and dl, #0x01
3024: xor dl, #0x01
3025: mov ax, # BIOSMEM_SEG
3026: mov ds, ax
3027: mov bx, # BIOSMEM_MODESET_CTL
3028: mov al, [bx]
3029: and al, #0xfe
3030: or al, dl
3031: mov [bx], al
3032: mov ax, #0x1212
3033: pop dx
3034: pop bx
3035: pop ds
3036: ret
3037: ASM_END
3038:
3039: // --------------------------------------------------------------------------------------------
3040: static void biosfn_switch_video_interface (AL,ES,DX) Bit8u AL;Bit16u ES;Bit16u DX;
3041: {
3042: #ifdef DEBUG
3043: unimplemented();
3044: #endif
3045: }
3046: static void biosfn_enable_video_refresh_control (AL) Bit8u AL;
3047: {
3048: #ifdef DEBUG
3049: unimplemented();
3050: #endif
3051: }
3052:
3053: // --------------------------------------------------------------------------------------------
3054: static void biosfn_write_string (flag,page,attr,count,row,col,seg,offset)
3055: Bit8u flag;Bit8u page;Bit8u attr;Bit16u count;Bit8u row;Bit8u col;Bit16u seg;Bit16u offset;
3056: {
3057: Bit16u newcurs,oldcurs,dummy;
3058: Bit8u car,carattr;
3059:
3060: // Read curs info for the page
3061: biosfn_get_cursor_pos(page,&dummy,&oldcurs);
3062:
3063: // if row=0xff special case : use current cursor position
3064: if(row==0xff)
3065: {col=oldcurs&0x00ff;
3066: row=(oldcurs&0xff00)>>8;
3067: }
3068:
3069: newcurs=row; newcurs<<=8; newcurs+=col;
3070: biosfn_set_cursor_pos(page,newcurs);
3071:
3072: while(count--!=0)
3073: {
3074: car=read_byte(seg,offset++);
3075: if((flag&0x02)!=0)
3076: attr=read_byte(seg,offset++);
3077:
3078: biosfn_write_teletype(car,page,attr,WITH_ATTR);
3079: }
3080:
3081: // Set back curs pos
3082: if((flag&0x01)==0)
3083: biosfn_set_cursor_pos(page,oldcurs);
3084: }
3085:
3086: // --------------------------------------------------------------------------------------------
3087: ASM_START
3088: biosfn_group_1A:
3089: cmp al, #0x00
3090: je biosfn_read_display_code
3091: cmp al, #0x01
3092: je biosfn_set_display_code
3093: #ifdef DEBUG
3094: call _unknown
3095: #endif
3096: ret
3097: biosfn_read_display_code:
3098: push ds
3099: push ax
3100: mov ax, # BIOSMEM_SEG
3101: mov ds, ax
3102: mov bx, # BIOSMEM_DCC_INDEX
3103: mov al, [bx]
3104: mov bl, al
3105: xor bh, bh
3106: pop ax
3107: mov al, ah
3108: pop ds
3109: ret
3110: biosfn_set_display_code:
3111: push ds
3112: push ax
3113: push bx
3114: mov ax, # BIOSMEM_SEG
3115: mov ds, ax
3116: mov ax, bx
3117: mov bx, # BIOSMEM_DCC_INDEX
3118: mov [bx], al
3119: #ifdef DEBUG
3120: mov al, ah
3121: xor ah, ah
3122: push ax
3123: mov bx, #msg_alt_dcc
3124: push bx
3125: call _printf
3126: add sp, #4
3127: #endif
3128: pop bx
3129: pop ax
3130: mov al, ah
3131: pop ds
3132: ret
3133:
3134: #ifdef DEBUG
3135: msg_alt_dcc:
3136: .ascii "Alternate Display code (%02x) was discarded"
3137: .byte 0x0d,0x0a,0x00
3138: #endif
3139: ASM_END
3140:
3141: // --------------------------------------------------------------------------------------------
3142: static void biosfn_read_state_info (BX,ES,DI)
3143: Bit16u BX;Bit16u ES;Bit16u DI;
3144: {
3145: // Address of static functionality table
3146: write_word(ES,DI+0x00,&static_functionality);
3147: write_word(ES,DI+0x02,0xC000);
3148:
3149: // Hard coded copy from BIOS area. Should it be cleaner ?
3150: memcpyb(ES,DI+0x04,BIOSMEM_SEG,0x49,30);
3151: memcpyb(ES,DI+0x22,BIOSMEM_SEG,0x84,3);
3152:
3153: write_byte(ES,DI+0x25,read_byte(BIOSMEM_SEG,BIOSMEM_DCC_INDEX));
3154: write_byte(ES,DI+0x26,0);
3155: write_byte(ES,DI+0x27,16);
3156: write_byte(ES,DI+0x28,0);
3157: write_byte(ES,DI+0x29,8);
3158: write_byte(ES,DI+0x2a,2);
3159: write_byte(ES,DI+0x2b,0);
3160: write_byte(ES,DI+0x2c,0);
3161: write_byte(ES,DI+0x31,3);
3162: write_byte(ES,DI+0x32,0);
3163:
3164: memsetb(ES,DI+0x33,0,13);
3165: }
3166:
3167: // --------------------------------------------------------------------------------------------
3168: // --------------------------------------------------------------------------------------------
3169: static Bit16u biosfn_read_video_state_size2 (CX)
3170: Bit16u CX;
3171: {
3172: Bit16u size;
3173: size = 0;
3174: if (CX & 1) {
3175: size += 0x46;
3176: }
3177: if (CX & 2) {
3178: size += (5 + 8 + 5) * 2 + 6;
3179: }
3180: if (CX & 4) {
3181: size += 3 + 256 * 3 + 1;
3182: }
3183: return size;
3184: }
3185:
3186: static void biosfn_read_video_state_size (CX, BX)
3187: Bit16u CX; Bit16u *BX;
3188: {
3189: Bit16u ss=get_SS();
3190: write_word(ss, BX, biosfn_read_video_state_size2(CX));
3191: }
3192:
3193: static Bit16u biosfn_save_video_state (CX,ES,BX)
3194: Bit16u CX;Bit16u ES;Bit16u BX;
3195: {
3196: Bit16u i, v, crtc_addr, ar_index;
3197:
3198: crtc_addr = read_word(BIOSMEM_SEG, BIOSMEM_CRTC_ADDRESS);
3199: if (CX & 1) {
3200: write_byte(ES, BX, inb(VGAREG_SEQU_ADDRESS)); BX++;
3201: write_byte(ES, BX, inb(crtc_addr)); BX++;
3202: write_byte(ES, BX, inb(VGAREG_GRDC_ADDRESS)); BX++;
3203: inb(VGAREG_ACTL_RESET);
3204: ar_index = inb(VGAREG_ACTL_ADDRESS);
3205: write_byte(ES, BX, ar_index); BX++;
3206: write_byte(ES, BX, inb(VGAREG_READ_FEATURE_CTL)); BX++;
3207:
3208: for(i=1;i<=4;i++){
3209: outb(VGAREG_SEQU_ADDRESS, i);
3210: write_byte(ES, BX, inb(VGAREG_SEQU_DATA)); BX++;
3211: }
3212: outb(VGAREG_SEQU_ADDRESS, 0);
3213: write_byte(ES, BX, inb(VGAREG_SEQU_DATA)); BX++;
3214:
3215: for(i=0;i<=0x18;i++) {
3216: outb(crtc_addr,i);
3217: write_byte(ES, BX, inb(crtc_addr+1)); BX++;
3218: }
3219:
3220: for(i=0;i<=0x13;i++) {
3221: inb(VGAREG_ACTL_RESET);
3222: outb(VGAREG_ACTL_ADDRESS, i | (ar_index & 0x20));
3223: write_byte(ES, BX, inb(VGAREG_ACTL_READ_DATA)); BX++;
3224: }
3225: inb(VGAREG_ACTL_RESET);
3226:
3227: for(i=0;i<=8;i++) {
3228: outb(VGAREG_GRDC_ADDRESS,i);
3229: write_byte(ES, BX, inb(VGAREG_GRDC_DATA)); BX++;
3230: }
3231:
3232: write_word(ES, BX, crtc_addr); BX+= 2;
3233:
3234: /* XXX: read plane latches */
3235: write_byte(ES, BX, 0); BX++;
3236: write_byte(ES, BX, 0); BX++;
3237: write_byte(ES, BX, 0); BX++;
3238: write_byte(ES, BX, 0); BX++;
3239: }
3240: if (CX & 2) {
3241: write_byte(ES, BX, read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE)); BX++;
3242: write_word(ES, BX, read_word(BIOSMEM_SEG,BIOSMEM_NB_COLS)); BX += 2;
3243: write_word(ES, BX, read_word(BIOSMEM_SEG,BIOSMEM_PAGE_SIZE)); BX += 2;
3244: write_word(ES, BX, read_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS)); BX += 2;
3245: write_byte(ES, BX, read_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS)); BX++;
3246: write_word(ES, BX, read_word(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT)); BX += 2;
3247: write_byte(ES, BX, read_byte(BIOSMEM_SEG,BIOSMEM_VIDEO_CTL)); BX++;
3248: write_byte(ES, BX, read_byte(BIOSMEM_SEG,BIOSMEM_SWITCHES)); BX++;
3249: write_byte(ES, BX, read_byte(BIOSMEM_SEG,BIOSMEM_MODESET_CTL)); BX++;
3250: write_word(ES, BX, read_word(BIOSMEM_SEG,BIOSMEM_CURSOR_TYPE)); BX += 2;
3251: for(i=0;i<8;i++) {
3252: write_word(ES, BX, read_word(BIOSMEM_SEG, BIOSMEM_CURSOR_POS+2*i));
3253: BX += 2;
3254: }
3255: write_word(ES, BX, read_word(BIOSMEM_SEG,BIOSMEM_CURRENT_START)); BX += 2;
3256: write_byte(ES, BX, read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE)); BX++;
3257: /* current font */
3258: write_word(ES, BX, read_word(0, 0x1f * 4)); BX += 2;
3259: write_word(ES, BX, read_word(0, 0x1f * 4 + 2)); BX += 2;
3260: write_word(ES, BX, read_word(0, 0x43 * 4)); BX += 2;
3261: write_word(ES, BX, read_word(0, 0x43 * 4 + 2)); BX += 2;
3262: }
3263: if (CX & 4) {
3264: /* XXX: check this */
3265: write_byte(ES, BX, inb(VGAREG_DAC_STATE)); BX++; /* read/write mode dac */
3266: write_byte(ES, BX, inb(VGAREG_DAC_WRITE_ADDRESS)); BX++; /* pix address */
3267: write_byte(ES, BX, inb(VGAREG_PEL_MASK)); BX++;
3268: // Set the whole dac always, from 0
3269: outb(VGAREG_DAC_WRITE_ADDRESS,0x00);
3270: for(i=0;i<256*3;i++) {
3271: write_byte(ES, BX, inb(VGAREG_DAC_DATA)); BX++;
3272: }
3273: write_byte(ES, BX, 0); BX++; /* color select register */
3274: }
3275: return BX;
3276: }
3277:
3278: static Bit16u biosfn_restore_video_state (CX,ES,BX)
3279: Bit16u CX;Bit16u ES;Bit16u BX;
3280: {
3281: Bit16u i, crtc_addr, v, addr1, ar_index;
3282:
3283: if (CX & 1) {
3284: // Reset Attribute Ctl flip-flop
3285: inb(VGAREG_ACTL_RESET);
3286:
3287: crtc_addr = read_word(ES, BX + 0x40);
3288: addr1 = BX;
3289: BX += 5;
3290:
3291: for(i=1;i<=4;i++){
3292: outb(VGAREG_SEQU_ADDRESS, i);
3293: outb(VGAREG_SEQU_DATA, read_byte(ES, BX)); BX++;
3294: }
3295: outb(VGAREG_SEQU_ADDRESS, 0);
3296: outb(VGAREG_SEQU_DATA, read_byte(ES, BX)); BX++;
3297:
3298: // Disable CRTC write protection
3299: outw(crtc_addr,0x0011);
3300: // Set CRTC regs
3301: for(i=0;i<=0x18;i++) {
3302: if (i != 0x11) {
3303: outb(crtc_addr,i);
3304: outb(crtc_addr+1, read_byte(ES, BX));
3305: }
3306: BX++;
3307: }
3308: // select crtc base address
3309: v = inb(VGAREG_READ_MISC_OUTPUT) & ~0x01;
3310: if (crtc_addr = 0x3d4)
3311: v |= 0x01;
3312: outb(VGAREG_WRITE_MISC_OUTPUT, v);
3313:
3314: // enable write protection if needed
3315: outb(crtc_addr, 0x11);
3316: outb(crtc_addr+1, read_byte(ES, BX - 0x18 + 0x11));
3317:
3318: // Set Attribute Ctl
3319: ar_index = read_byte(ES, addr1 + 0x03);
3320: inb(VGAREG_ACTL_RESET);
3321: for(i=0;i<=0x13;i++) {
3322: outb(VGAREG_ACTL_ADDRESS, i | (ar_index & 0x20));
3323: outb(VGAREG_ACTL_WRITE_DATA, read_byte(ES, BX)); BX++;
3324: }
3325: outb(VGAREG_ACTL_ADDRESS, ar_index);
3326: inb(VGAREG_ACTL_RESET);
3327:
3328: for(i=0;i<=8;i++) {
3329: outb(VGAREG_GRDC_ADDRESS,i);
3330: outb(VGAREG_GRDC_DATA, read_byte(ES, BX)); BX++;
3331: }
3332: BX += 2; /* crtc_addr */
3333: BX += 4; /* plane latches */
3334:
3335: outb(VGAREG_SEQU_ADDRESS, read_byte(ES, addr1)); addr1++;
3336: outb(crtc_addr, read_byte(ES, addr1)); addr1++;
3337: outb(VGAREG_GRDC_ADDRESS, read_byte(ES, addr1)); addr1++;
3338: addr1++;
3339: outb(crtc_addr - 0x4 + 0xa, read_byte(ES, addr1)); addr1++;
3340: }
3341: if (CX & 2) {
3342: write_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE, read_byte(ES, BX)); BX++;
3343: write_word(BIOSMEM_SEG,BIOSMEM_NB_COLS, read_word(ES, BX)); BX += 2;
3344: write_word(BIOSMEM_SEG,BIOSMEM_PAGE_SIZE, read_word(ES, BX)); BX += 2;
3345: write_word(BIOSMEM_SEG,BIOSMEM_CRTC_ADDRESS, read_word(ES, BX)); BX += 2;
3346: write_byte(BIOSMEM_SEG,BIOSMEM_NB_ROWS, read_byte(ES, BX)); BX++;
3347: write_word(BIOSMEM_SEG,BIOSMEM_CHAR_HEIGHT, read_word(ES, BX)); BX += 2;
3348: write_byte(BIOSMEM_SEG,BIOSMEM_VIDEO_CTL, read_byte(ES, BX)); BX++;
3349: write_byte(BIOSMEM_SEG,BIOSMEM_SWITCHES, read_byte(ES, BX)); BX++;
3350: write_byte(BIOSMEM_SEG,BIOSMEM_MODESET_CTL, read_byte(ES, BX)); BX++;
3351: write_word(BIOSMEM_SEG,BIOSMEM_CURSOR_TYPE, read_word(ES, BX)); BX += 2;
3352: for(i=0;i<8;i++) {
3353: write_word(BIOSMEM_SEG, BIOSMEM_CURSOR_POS+2*i, read_word(ES, BX));
3354: BX += 2;
3355: }
3356: write_word(BIOSMEM_SEG,BIOSMEM_CURRENT_START, read_word(ES, BX)); BX += 2;
3357: write_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_PAGE, read_byte(ES, BX)); BX++;
3358: /* current font */
3359: write_word(0, 0x1f * 4, read_word(ES, BX)); BX += 2;
3360: write_word(0, 0x1f * 4 + 2, read_word(ES, BX)); BX += 2;
3361: write_word(0, 0x43 * 4, read_word(ES, BX)); BX += 2;
3362: write_word(0, 0x43 * 4 + 2, read_word(ES, BX)); BX += 2;
3363: }
3364: if (CX & 4) {
3365: BX++;
3366: v = read_byte(ES, BX); BX++;
3367: outb(VGAREG_PEL_MASK, read_byte(ES, BX)); BX++;
3368: // Set the whole dac always, from 0
3369: outb(VGAREG_DAC_WRITE_ADDRESS,0x00);
3370: for(i=0;i<256*3;i++) {
3371: outb(VGAREG_DAC_DATA, read_byte(ES, BX)); BX++;
3372: }
3373: BX++;
3374: outb(VGAREG_DAC_WRITE_ADDRESS, v);
3375: }
3376: return BX;
3377: }
3378:
3379: // ============================================================================================
3380: //
3381: // Video Utils
3382: //
3383: // ============================================================================================
3384:
3385: // --------------------------------------------------------------------------------------------
3386: static Bit8u find_vga_entry(mode)
3387: Bit8u mode;
3388: {
3389: Bit8u i,line=0xFF;
3390: for(i=0;i<=MODE_MAX;i++)
3391: if(vga_modes[i].svgamode==mode)
3392: {line=i;
3393: break;
3394: }
3395: return line;
3396: }
3397:
3398: /* =========================================================== */
3399: /*
3400: * Misc Utils
3401: */
3402: /* =========================================================== */
3403:
3404: // --------------------------------------------------------------------------------------------
3405: static void memsetb(seg,offset,value,count)
3406: Bit16u seg;
3407: Bit16u offset;
3408: Bit16u value;
3409: Bit16u count;
3410: {
3411: ASM_START
3412: push bp
3413: mov bp, sp
3414:
3415: push ax
3416: push cx
3417: push es
3418: push di
3419:
3420: mov cx, 10[bp] ; count
3421: cmp cx, #0x00
3422: je memsetb_end
3423: mov ax, 4[bp] ; segment
3424: mov es, ax
3425: mov ax, 6[bp] ; offset
3426: mov di, ax
3427: mov al, 8[bp] ; value
3428: cld
3429: rep
3430: stosb
3431:
3432: memsetb_end:
3433: pop di
3434: pop es
3435: pop cx
3436: pop ax
3437:
3438: pop bp
3439: ASM_END
3440: }
3441:
3442: // --------------------------------------------------------------------------------------------
3443: static void memsetw(seg,offset,value,count)
3444: Bit16u seg;
3445: Bit16u offset;
3446: Bit16u value;
3447: Bit16u count;
3448: {
3449: ASM_START
3450: push bp
3451: mov bp, sp
3452:
3453: push ax
3454: push cx
3455: push es
3456: push di
3457:
3458: mov cx, 10[bp] ; count
3459: cmp cx, #0x00
3460: je memsetw_end
3461: mov ax, 4[bp] ; segment
3462: mov es, ax
3463: mov ax, 6[bp] ; offset
3464: mov di, ax
3465: mov ax, 8[bp] ; value
3466: cld
3467: rep
3468: stosw
3469:
3470: memsetw_end:
3471: pop di
3472: pop es
3473: pop cx
3474: pop ax
3475:
3476: pop bp
3477: ASM_END
3478: }
3479:
3480: // --------------------------------------------------------------------------------------------
3481: static void memcpyb(dseg,doffset,sseg,soffset,count)
3482: Bit16u dseg;
3483: Bit16u doffset;
3484: Bit16u sseg;
3485: Bit16u soffset;
3486: Bit16u count;
3487: {
3488: ASM_START
3489: push bp
3490: mov bp, sp
3491:
3492: push ax
3493: push cx
3494: push es
3495: push di
3496: push ds
3497: push si
3498:
3499: mov cx, 12[bp] ; count
3500: cmp cx, #0x0000
3501: je memcpyb_end
3502: mov ax, 4[bp] ; dsegment
3503: mov es, ax
3504: mov ax, 6[bp] ; doffset
3505: mov di, ax
3506: mov ax, 8[bp] ; ssegment
3507: mov ds, ax
3508: mov ax, 10[bp] ; soffset
3509: mov si, ax
3510: cld
3511: rep
3512: movsb
3513:
3514: memcpyb_end:
3515: pop si
3516: pop ds
3517: pop di
3518: pop es
3519: pop cx
3520: pop ax
3521:
3522: pop bp
3523: ASM_END
3524: }
3525:
3526: // --------------------------------------------------------------------------------------------
3527: static void memcpyw(dseg,doffset,sseg,soffset,count)
3528: Bit16u dseg;
3529: Bit16u doffset;
3530: Bit16u sseg;
3531: Bit16u soffset;
3532: Bit16u count;
3533: {
3534: ASM_START
3535: push bp
3536: mov bp, sp
3537:
3538: push ax
3539: push cx
3540: push es
3541: push di
3542: push ds
3543: push si
3544:
3545: mov cx, 12[bp] ; count
3546: cmp cx, #0x0000
3547: je memcpyw_end
3548: mov ax, 4[bp] ; dsegment
3549: mov es, ax
3550: mov ax, 6[bp] ; doffset
3551: mov di, ax
3552: mov ax, 8[bp] ; ssegment
3553: mov ds, ax
3554: mov ax, 10[bp] ; soffset
3555: mov si, ax
3556: cld
3557: rep
3558: movsw
3559:
3560: memcpyw_end:
3561: pop si
3562: pop ds
3563: pop di
3564: pop es
3565: pop cx
3566: pop ax
3567:
3568: pop bp
3569: ASM_END
3570: }
3571:
3572: /* =========================================================== */
3573: /*
3574: * These functions where ripped from Kevin's rombios.c
3575: */
3576: /* =========================================================== */
3577:
3578: // --------------------------------------------------------------------------------------------
3579: static Bit8u
3580: read_byte(seg, offset)
3581: Bit16u seg;
3582: Bit16u offset;
3583: {
3584: ASM_START
3585: push bp
3586: mov bp, sp
3587:
3588: push bx
3589: push ds
3590: mov ax, 4[bp] ; segment
3591: mov ds, ax
3592: mov bx, 6[bp] ; offset
3593: mov al, [bx]
3594: ;; al = return value (byte)
3595: pop ds
3596: pop bx
3597:
3598: pop bp
3599: ASM_END
3600: }
3601:
3602: // --------------------------------------------------------------------------------------------
3603: static Bit16u
3604: read_word(seg, offset)
3605: Bit16u seg;
3606: Bit16u offset;
3607: {
3608: ASM_START
3609: push bp
3610: mov bp, sp
3611:
3612: push bx
3613: push ds
3614: mov ax, 4[bp] ; segment
3615: mov ds, ax
3616: mov bx, 6[bp] ; offset
3617: mov ax, [bx]
3618: ;; ax = return value (word)
3619: pop ds
3620: pop bx
3621:
3622: pop bp
3623: ASM_END
3624: }
3625:
3626: // --------------------------------------------------------------------------------------------
3627: static void
3628: write_byte(seg, offset, data)
3629: Bit16u seg;
3630: Bit16u offset;
3631: Bit8u data;
3632: {
3633: ASM_START
3634: push bp
3635: mov bp, sp
3636:
3637: push ax
3638: push bx
3639: push ds
3640: mov ax, 4[bp] ; segment
3641: mov ds, ax
3642: mov bx, 6[bp] ; offset
3643: mov al, 8[bp] ; data byte
3644: mov [bx], al ; write data byte
3645: pop ds
3646: pop bx
3647: pop ax
3648:
3649: pop bp
3650: ASM_END
3651: }
3652:
3653: // --------------------------------------------------------------------------------------------
3654: static void
3655: write_word(seg, offset, data)
3656: Bit16u seg;
3657: Bit16u offset;
3658: Bit16u data;
3659: {
3660: ASM_START
3661: push bp
3662: mov bp, sp
3663:
3664: push ax
3665: push bx
3666: push ds
3667: mov ax, 4[bp] ; segment
3668: mov ds, ax
3669: mov bx, 6[bp] ; offset
3670: mov ax, 8[bp] ; data word
3671: mov [bx], ax ; write data word
3672: pop ds
3673: pop bx
3674: pop ax
3675:
3676: pop bp
3677: ASM_END
3678: }
3679:
3680: // --------------------------------------------------------------------------------------------
3681: Bit8u
3682: inb(port)
3683: Bit16u port;
3684: {
3685: ASM_START
3686: push bp
3687: mov bp, sp
3688:
3689: push dx
3690: mov dx, 4[bp]
3691: in al, dx
3692: pop dx
3693:
3694: pop bp
3695: ASM_END
3696: }
3697:
3698: Bit16u
3699: inw(port)
3700: Bit16u port;
3701: {
3702: ASM_START
3703: push bp
3704: mov bp, sp
3705:
3706: push dx
3707: mov dx, 4[bp]
3708: in ax, dx
3709: pop dx
3710:
3711: pop bp
3712: ASM_END
3713: }
3714:
3715: // --------------------------------------------------------------------------------------------
3716: void
3717: outb(port, val)
3718: Bit16u port;
3719: Bit8u val;
3720: {
3721: ASM_START
3722: push bp
3723: mov bp, sp
3724:
3725: push ax
3726: push dx
3727: mov dx, 4[bp]
3728: mov al, 6[bp]
3729: out dx, al
3730: pop dx
3731: pop ax
3732:
3733: pop bp
3734: ASM_END
3735: }
3736:
3737: // --------------------------------------------------------------------------------------------
3738: void
3739: outw(port, val)
3740: Bit16u port;
3741: Bit16u val;
3742: {
3743: ASM_START
3744: push bp
3745: mov bp, sp
3746:
3747: push ax
3748: push dx
3749: mov dx, 4[bp]
3750: mov ax, 6[bp]
3751: out dx, ax
3752: pop dx
3753: pop ax
3754:
3755: pop bp
3756: ASM_END
3757: }
3758:
3759: Bit16u get_SS()
3760: {
3761: ASM_START
3762: mov ax, ss
3763: ASM_END
3764: }
3765:
3766: #ifdef DEBUG
3767: void unimplemented()
3768: {
3769: printf("--> Unimplemented\n");
3770: }
3771:
3772: void unknown()
3773: {
3774: printf("--> Unknown int10\n");
3775: }
3776: #endif
3777:
3778: // --------------------------------------------------------------------------------------------
3779: #if defined(USE_BX_INFO) || defined(DEBUG) || defined(CIRRUS_DEBUG)
3780: void printf(s)
3781: Bit8u *s;
3782: {
3783: Bit8u c, format_char;
3784: Boolean in_format;
3785: unsigned format_width, i;
3786: Bit16u *arg_ptr;
3787: Bit16u arg_seg, arg, digit, nibble, shift_count;
3788:
3789: arg_ptr = &s;
3790: arg_seg = get_SS();
3791:
3792: in_format = 0;
3793: format_width = 0;
3794:
3795: while (c = read_byte(0xc000, s)) {
3796: if ( c == '%' ) {
3797: in_format = 1;
3798: format_width = 0;
3799: }
3800: else if (in_format) {
3801: if ( (c>='0') && (c<='9') ) {
3802: format_width = (format_width * 10) + (c - '0');
3803: }
3804: else if (c == 'x') {
3805: arg_ptr++; // increment to next arg
3806: arg = read_word(arg_seg, arg_ptr);
3807: if (format_width == 0)
3808: format_width = 4;
3809: i = 0;
3810: digit = format_width - 1;
3811: for (i=0; i<format_width; i++) {
3812: nibble = (arg >> (4 * digit)) & 0x000f;
3813: if (nibble <= 9)
3814: outb(0x0500, nibble + '0');
3815: else
3816: outb(0x0500, (nibble - 10) + 'A');
3817: digit--;
3818: }
3819: in_format = 0;
3820: }
3821: //else if (c == 'd') {
3822: // in_format = 0;
3823: // }
3824: }
3825: else {
3826: outb(0x0500, c);
3827: }
3828: s ++;
3829: }
3830: }
3831: #endif
3832:
3833: #ifdef VBE
3834: #include "vbe.c"
3835: #endif
3836:
3837: #ifdef CIRRUS
3838: #include "clext.c"
3839: #endif
3840:
3841: // --------------------------------------------------------------------------------------------
3842:
3843: ASM_START
3844: ;; DATA_SEG_DEFS_HERE
3845: ASM_END
3846:
3847: ASM_START
3848: .ascii "vgabios ends here"
3849: .byte 0x00
3850: vgabios_end:
3851: .byte 0xCB
3852: ;; BLOCK_STRINGS_BEGIN
3853: ASM_END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.