Please file new bugs on Launchpad: Invirt or XVM (if you're not sure which, just pick one)

Context Navigation

source: trunk/packages/xen-3.1/xen-3.1/tools/firmware/vgabios/vgabios.c @ 34

Last change on this file since 34 was 34, checked in by hartmans, 18 years ago
Add xen and xen-common
Property svn:mime-type set to `text/cpp`
File size: 75.6 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: