?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- added DPMS support to cirrus vgabios (patch from Gleb Natapov)
[vgabios.git] / vbe.c
blob6173ca0338125d8aca228e071a402121abf7621f
1 // ============================================================================================
2 //
3 // Copyright (C) 2002 Jeroen Janssen
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 //
19 // ============================================================================================
20 //
21 // This VBE is part of the VGA Bios specific to the plex86/bochs Emulated VGA card.
22 // You can NOT drive any physical vga card with it.
23 //
24 // ============================================================================================
25 //
26 // This VBE Bios is based on information taken from :
27 // - VESA BIOS EXTENSION (VBE) Core Functions Standard Version 3.0 located at www.vesa.org
28 //
29 // ============================================================================================
30
31
32 // defines available
33
34 // disable VESA/VBE2 check in vbe info
35 //#define VBE2_NO_VESA_CHECK
36
37
38 #include "vbe.h"
39 #include "vbetables.h"
40
41 #define VBE_TOTAL_VIDEO_MEMORY_DIV_64K (VBE_DISPI_TOTAL_VIDEO_MEMORY_MB*1024/64)
42
43 // The current OEM Software Revision of this VBE Bios
44 #define VBE_OEM_SOFTWARE_REV 0x0002;
45
46 extern char vbebios_copyright;
47 extern char vbebios_vendor_name;
48 extern char vbebios_product_name;
49 extern char vbebios_product_revision;
50
51 ASM_START
52 // FIXME: 'merge' these (c) etc strings with the vgabios.c strings?
53 _vbebios_copyright:
54 .ascii "Bochs/Plex86 VBE(C) 2003 http://savannah.nongnu.org/projects/vgabios/"
55 .byte 0x00
56
57 _vbebios_vendor_name:
58 .ascii "Bochs/Plex86 Developers"
59 .byte 0x00
60
61 _vbebios_product_name:
62 .ascii "Bochs/Plex86 VBE Adapter"
63 .byte 0x00
64
65 _vbebios_product_revision:
66 .ascii "$Id$"
67 .byte 0x00
68
69 _vbebios_info_string:
70 .ascii "Bochs VBE Display Adapter enabled"
71 .byte 0x0a,0x0d
72 .byte 0x0a,0x0d
73 .byte 0x00
74
75 _no_vbebios_info_string:
76 .ascii "NO Bochs VBE Support available!"
77 .byte 0x0a,0x0d
78 .byte 0x0a,0x0d
79 .byte 0x00
80
81 #if defined(USE_BX_INFO) || defined(DEBUG)
82 msg_vbe_init:
83 .ascii "VBE Bios $Id$"
84 .byte 0x0a,0x0d, 0x00
85 #endif
86
87 .align 2
88 vesa_pm_start:
89 dw vesa_pm_set_window - vesa_pm_start
90 dw vesa_pm_set_display_start - vesa_pm_start
91 dw vesa_pm_unimplemented - vesa_pm_start
92 dw vesa_pm_io_ports_table - vesa_pm_start
93 vesa_pm_io_ports_table:
94 dw VBE_DISPI_IOPORT_INDEX
95 dw VBE_DISPI_IOPORT_INDEX + 1
96 dw VBE_DISPI_IOPORT_DATA
97 dw VBE_DISPI_IOPORT_DATA + 1
98 dw 0xffff
99 dw 0xffff
100
101 USE32
102 vesa_pm_set_window:
103 cmp bx, #0x00
104 je vesa_pm_set_display_window1
105 mov ax, #0x0100
106 ret
107 vesa_pm_set_display_window1:
108 mov ax, dx
109 push dx
110 push ax
111 mov dx, # VBE_DISPI_IOPORT_INDEX
112 mov ax, # VBE_DISPI_INDEX_BANK
113 out dx, ax
114 pop ax
115 mov dx, # VBE_DISPI_IOPORT_DATA
116 out dx, ax
117 in ax, dx
118 pop dx
119 cmp dx, ax
120 jne illegal_window
121 mov ax, #0x004f
122 ret
123 illegal_window:
124 mov ax, #0x014f
125 ret
126
127 vesa_pm_set_display_start:
128 cmp bl, #0x80
129 je vesa_pm_set_display_start1
130 cmp bl, #0x00
131 je vesa_pm_set_display_start1
132 mov ax, #0x0100
133 ret
134 vesa_pm_set_display_start1:
135 ; convert offset to (X, Y) coordinate
136 ; (would be simpler to change Bochs VBE API...)
137 push eax
138 push ecx
139 push edx
140 push esi
141 push edi
142 shl edx, #16
143 and ecx, #0xffff
144 or ecx, edx
145 shl ecx, #2
146 mov eax, ecx
147
148 push eax
149 mov dx, # VBE_DISPI_IOPORT_INDEX
150 mov ax, # VBE_DISPI_INDEX_VIRT_WIDTH
151 out dx, ax
152 mov dx, # VBE_DISPI_IOPORT_DATA
153 in ax, dx
154 movzx ecx, ax
155
156 mov dx, # VBE_DISPI_IOPORT_INDEX
157 mov ax, # VBE_DISPI_INDEX_BPP
158 out dx, ax
159 mov dx, # VBE_DISPI_IOPORT_DATA
160 in ax, dx
161 movzx esi, ax
162 pop eax
163
164 cmp esi, #4
165 jz bpp4_mode
166 add esi, #7
167 shr esi, #3
168 imul ecx, esi
169 xor edx, edx
170 div ecx
171 mov edi, eax
172 mov eax, edx
173 xor edx, edx
174 div esi
175 jmp set_xy_regs
176
177 bpp4_mode:
178 shr ecx, #1
179 xor edx, edx
180 div ecx
181 mov edi, eax
182 mov eax, edx
183 shl eax, #1
184
185 set_xy_regs:
186 push dx
187 push ax
188 mov dx, # VBE_DISPI_IOPORT_INDEX
189 mov ax, # VBE_DISPI_INDEX_X_OFFSET
190 out dx, ax
191 pop ax
192 mov dx, # VBE_DISPI_IOPORT_DATA
193 out dx, ax
194 pop dx
195
196 mov ax, di
197 push dx
198 push ax
199 mov dx, # VBE_DISPI_IOPORT_INDEX
200 mov ax, # VBE_DISPI_INDEX_Y_OFFSET
201 out dx, ax
202 pop ax
203 mov dx, # VBE_DISPI_IOPORT_DATA
204 out dx, ax
205 pop dx
206
207 pop edi
208 pop esi
209 pop edx
210 pop ecx
211 pop eax
212 mov ax, #0x004f
213 ret
214
215 vesa_pm_unimplemented:
216 mov ax, #0x014f
217 ret
218 USE16
219 vesa_pm_end:
220
221 ; DISPI ioport functions
222
223 dispi_get_id:
224 push dx
225 mov dx, # VBE_DISPI_IOPORT_INDEX
226 mov ax, # VBE_DISPI_INDEX_ID
227 out dx, ax
228 mov dx, # VBE_DISPI_IOPORT_DATA
229 in ax, dx
230 pop dx
231 ret
232
233 dispi_set_id:
234 push dx
235 push ax
236 mov dx, # VBE_DISPI_IOPORT_INDEX
237 mov ax, # VBE_DISPI_INDEX_ID
238 out dx, ax
239 pop ax
240 mov dx, # VBE_DISPI_IOPORT_DATA
241 out dx, ax
242 pop dx
243 ret
244 ASM_END
245
246 static void dispi_set_xres(xres)
247 Bit16u xres;
248 {
249 ASM_START
250 push bp
251 mov bp, sp
252 push ax
253 push dx
254
255 mov dx, # VBE_DISPI_IOPORT_INDEX
256 mov ax, # VBE_DISPI_INDEX_XRES
257 out dx, ax
258 mov dx, # VBE_DISPI_IOPORT_DATA
259 mov ax, 4[bp] ; xres
260 out dx, ax
261
262 pop dx
263 pop ax
264 pop bp
265 ASM_END
266 }
267
268 static void dispi_set_yres(yres)
269 Bit16u yres;
270 {
271 outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_YRES);
272 outw(VBE_DISPI_IOPORT_DATA,yres);
273 }
274
275 static void dispi_set_bpp(bpp)
276 Bit16u bpp;
277 {
278 outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_BPP);
279 outw(VBE_DISPI_IOPORT_DATA,bpp);
280 }
281
282 ASM_START
283 ; AL = bits per pixel / AH = bytes per pixel
284 dispi_get_bpp:
285 push dx
286 mov dx, # VBE_DISPI_IOPORT_INDEX
287 mov ax, # VBE_DISPI_INDEX_BPP
288 out dx, ax
289 mov dx, # VBE_DISPI_IOPORT_DATA
290 in ax, dx
291 mov ah, al
292 shr ah, 3
293 test al, #0x07
294 jz get_bpp_noinc
295 inc ah
296 get_bpp_noinc:
297 pop dx
298 ret
299
300 ; get display capabilities
301
302 _dispi_get_max_xres:
303 push dx
304 push bx
305 call dispi_get_enable
306 mov bx, ax
307 or ax, # VBE_DISPI_GETCAPS
308 call _dispi_set_enable
309 mov dx, # VBE_DISPI_IOPORT_INDEX
310 mov ax, # VBE_DISPI_INDEX_XRES
311 out dx, ax
312 mov dx, # VBE_DISPI_IOPORT_DATA
313 in ax, dx
314 push ax
315 mov ax, bx
316 call _dispi_set_enable
317 pop ax
318 pop bx
319 pop dx
320 ret
321
322 _dispi_get_max_bpp:
323 push dx
324 push bx
325 call dispi_get_enable
326 mov bx, ax
327 or ax, # VBE_DISPI_GETCAPS
328 call _dispi_set_enable
329 mov dx, # VBE_DISPI_IOPORT_INDEX
330 mov ax, # VBE_DISPI_INDEX_BPP
331 out dx, ax
332 mov dx, # VBE_DISPI_IOPORT_DATA
333 in ax, dx
334 push ax
335 mov ax, bx
336 call _dispi_set_enable
337 pop ax
338 pop bx
339 pop dx
340 ret
341
342 _dispi_set_enable:
343 push dx
344 push ax
345 mov dx, # VBE_DISPI_IOPORT_INDEX
346 mov ax, # VBE_DISPI_INDEX_ENABLE
347 out dx, ax
348 pop ax
349 mov dx, # VBE_DISPI_IOPORT_DATA
350 out dx, ax
351 pop dx
352 ret
353
354 dispi_get_enable:
355 push dx
356 mov dx, # VBE_DISPI_IOPORT_INDEX
357 mov ax, # VBE_DISPI_INDEX_ENABLE
358 out dx, ax
359 mov dx, # VBE_DISPI_IOPORT_DATA
360 in ax, dx
361 pop dx
362 ret
363
364 _dispi_set_bank:
365 push dx
366 push ax
367 mov dx, # VBE_DISPI_IOPORT_INDEX
368 mov ax, # VBE_DISPI_INDEX_BANK
369 out dx, ax
370 pop ax
371 mov dx, # VBE_DISPI_IOPORT_DATA
372 out dx, ax
373 pop dx
374 ret
375
376 dispi_get_bank:
377 push dx
378 mov dx, # VBE_DISPI_IOPORT_INDEX
379 mov ax, # VBE_DISPI_INDEX_BANK
380 out dx, ax
381 mov dx, # VBE_DISPI_IOPORT_DATA
382 in ax, dx
383 pop dx
384 ret
385 ASM_END
386
387 static void dispi_set_bank_farcall()
388 {
389 ASM_START
390 cmp bx,#0x0100
391 je dispi_set_bank_farcall_get
392 or bx,bx
393 jnz dispi_set_bank_farcall_error
394 mov ax,dx
395 push dx
396 push ax
397 mov ax,# VBE_DISPI_INDEX_BANK
398 mov dx,# VBE_DISPI_IOPORT_INDEX
399 out dx,ax
400 pop ax
401 mov dx,# VBE_DISPI_IOPORT_DATA
402 out dx,ax
403 in ax,dx
404 pop dx
405 cmp dx,ax
406 jne dispi_set_bank_farcall_error
407 mov ax, #0x004f
408 retf
409 dispi_set_bank_farcall_get:
410 mov ax,# VBE_DISPI_INDEX_BANK
411 mov dx,# VBE_DISPI_IOPORT_INDEX
412 out dx,ax
413 mov dx,# VBE_DISPI_IOPORT_DATA
414 in ax,dx
415 mov dx,ax
416 retf
417 dispi_set_bank_farcall_error:
418 mov ax,#0x014F
419 retf
420 ASM_END
421 }
422
423 ASM_START
424 dispi_set_x_offset:
425 push dx
426 push ax
427 mov dx, # VBE_DISPI_IOPORT_INDEX
428 mov ax, # VBE_DISPI_INDEX_X_OFFSET
429 out dx, ax
430 pop ax
431 mov dx, # VBE_DISPI_IOPORT_DATA
432 out dx, ax
433 pop dx
434 ret
435
436 dispi_get_x_offset:
437 push dx
438 mov dx, # VBE_DISPI_IOPORT_INDEX
439 mov ax, # VBE_DISPI_INDEX_X_OFFSET
440 out dx, ax
441 mov dx, # VBE_DISPI_IOPORT_DATA
442 in ax, dx
443 pop dx
444 ret
445
446 dispi_set_y_offset:
447 push dx
448 push ax
449 mov dx, # VBE_DISPI_IOPORT_INDEX
450 mov ax, # VBE_DISPI_INDEX_Y_OFFSET
451 out dx, ax
452 pop ax
453 mov dx, # VBE_DISPI_IOPORT_DATA
454 out dx, ax
455 pop dx
456 ret
457
458 dispi_get_y_offset:
459 push dx
460 mov dx, # VBE_DISPI_IOPORT_INDEX
461 mov ax, # VBE_DISPI_INDEX_Y_OFFSET
462 out dx, ax
463 mov dx, # VBE_DISPI_IOPORT_DATA
464 in ax, dx
465 pop dx
466 ret
467
468 vga_set_virt_width:
469 push ax
470 push bx
471 push dx
472 mov bx, ax
473 call dispi_get_bpp
474 cmp al, #0x04
475 ja set_width_svga
476 shr bx, #1
477 set_width_svga:
478 shr bx, #3
479 mov dx, # VGAREG_VGA_CRTC_ADDRESS
480 mov ah, bl
481 mov al, #0x13
482 out dx, ax
483 pop dx
484 pop bx
485 pop ax
486 ret
487
488 dispi_set_virt_width:
489 call vga_set_virt_width
490 push dx
491 push ax
492 mov dx, # VBE_DISPI_IOPORT_INDEX
493 mov ax, # VBE_DISPI_INDEX_VIRT_WIDTH
494 out dx, ax
495 pop ax
496 mov dx, # VBE_DISPI_IOPORT_DATA
497 out dx, ax
498 pop dx
499 ret
500
501 dispi_get_virt_width:
502 push dx
503 mov dx, # VBE_DISPI_IOPORT_INDEX
504 mov ax, # VBE_DISPI_INDEX_VIRT_WIDTH
505 out dx, ax
506 mov dx, # VBE_DISPI_IOPORT_DATA
507 in ax, dx
508 pop dx
509 ret
510
511 dispi_get_virt_height:
512 push dx
513 mov dx, # VBE_DISPI_IOPORT_INDEX
514 mov ax, # VBE_DISPI_INDEX_VIRT_HEIGHT
515 out dx, ax
516 mov dx, # VBE_DISPI_IOPORT_DATA
517 in ax, dx
518 pop dx
519 ret
520
521 _vga_compat_setup:
522 push ax
523 push dx
524
525 ; set CRT X resolution
526 mov dx, # VBE_DISPI_IOPORT_INDEX
527 mov ax, # VBE_DISPI_INDEX_XRES
528 out dx, ax
529 mov dx, # VBE_DISPI_IOPORT_DATA
530 in ax, dx
531 push ax
532 mov dx, # VGAREG_VGA_CRTC_ADDRESS
533 mov ax, #0x0011
534 out dx, ax
535 pop ax
536 push ax
537 shr ax, #3
538 dec ax
539 mov ah, al
540 mov al, #0x01
541 out dx, ax
542 pop ax
543 call vga_set_virt_width
544
545 ; set CRT Y resolution
546 mov dx, # VBE_DISPI_IOPORT_INDEX
547 mov ax, # VBE_DISPI_INDEX_YRES
548 out dx, ax
549 mov dx, # VBE_DISPI_IOPORT_DATA
550 in ax, dx
551 dec ax
552 push ax
553 mov dx, # VGAREG_VGA_CRTC_ADDRESS
554 mov ah, al
555 mov al, #0x12
556 out dx, ax
557 pop ax
558 mov al, #0x07
559 out dx, al
560 inc dx
561 in al, dx
562 and al, #0xbd
563 test ah, #0x01
564 jz bit8_clear
565 or al, #0x02
566 bit8_clear:
567 test ah, #0x02
568 jz bit9_clear
569 or al, #0x40
570 bit9_clear:
571 out dx, al
572
573 ; other settings
574 mov dx, # VGAREG_VGA_CRTC_ADDRESS
575 mov ax, #0x0009
576 out dx, ax
577 mov al, #0x17
578 out dx, al
579 mov dx, # VGAREG_VGA_CRTC_DATA
580 in al, dx
581 or al, #0x03
582 out dx, al
583 mov dx, # VGAREG_ACTL_RESET
584 in al, dx
585 mov dx, # VGAREG_ACTL_ADDRESS
586 mov al, #0x10
587 out dx, al
588 mov dx, # VGAREG_ACTL_READ_DATA
589 in al, dx
590 or al, #0x01
591 mov dx, # VGAREG_ACTL_ADDRESS
592 out dx, al
593 mov al, #0x20
594 out dx, al
595 mov dx, # VGAREG_GRDC_ADDRESS
596 mov ax, #0x0506
597 out dx, ax
598 mov dx, # VGAREG_SEQU_ADDRESS
599 mov ax, #0x0f02
600 out dx, ax
601
602 ; settings for >= 8bpp
603 mov dx, # VBE_DISPI_IOPORT_INDEX
604 mov ax, # VBE_DISPI_INDEX_BPP
605 out dx, ax
606 mov dx, # VBE_DISPI_IOPORT_DATA
607 in ax, dx
608 cmp al, #0x08
609 jb vga_compat_end
610 mov dx, # VGAREG_VGA_CRTC_ADDRESS
611 mov al, #0x14
612 out dx, al
613 mov dx, # VGAREG_VGA_CRTC_DATA
614 in al, dx
615 or al, #0x40
616 out dx, al
617 mov dx, # VGAREG_ACTL_RESET
618 in al, dx
619 mov dx, # VGAREG_ACTL_ADDRESS
620 mov al, #0x10
621 out dx, al
622 mov dx, # VGAREG_ACTL_READ_DATA
623 in al, dx
624 or al, #0x40
625 mov dx, # VGAREG_ACTL_ADDRESS
626 out dx, al
627 mov al, #0x20
628 out dx, al
629 mov dx, # VGAREG_SEQU_ADDRESS
630 mov al, #0x04
631 out dx, al
632 mov dx, # VGAREG_SEQU_DATA
633 in al, dx
634 or al, #0x08
635 out dx, al
636 mov dx, # VGAREG_GRDC_ADDRESS
637 mov al, #0x05
638 out dx, al
639 mov dx, # VGAREG_GRDC_DATA
640 in al, dx
641 and al, #0x9f
642 or al, #0x40
643 out dx, al
644
645 vga_compat_end:
646 pop dx
647 pop ax
648 ASM_END
649
650
651 // ModeInfo helper function
652 static ModeInfoListItem* mode_info_find_mode(mode, using_lfb)
653 Bit16u mode; Boolean using_lfb;
654 {
655 ModeInfoListItem *cur_info=&mode_info_list;
656
657 while (cur_info->mode != VBE_VESA_MODE_END_OF_LIST)
658 {
659 if (cur_info->mode == mode)
660 {
661 if (!using_lfb)
662 {
663 return cur_info;
664 }
665 else if (cur_info->info.ModeAttributes & VBE_MODE_ATTRIBUTE_LINEAR_FRAME_BUFFER_MODE)
666 {
667 return cur_info;
668 }
669 else
670 {
671 cur_info++;
672 }
673 }
674 else
675 {
676 cur_info++;
677 }
678 }
679
680 return 0;
681 }
682
683 ASM_START
684
685 ; Has VBE display - Returns true if VBE display detected
686
687 _vbe_has_vbe_display:
688 push ds
689 push bx
690 mov ax, # BIOSMEM_SEG
691 mov ds, ax
692 mov bx, # BIOSMEM_VBE_FLAG
693 mov al, [bx]
694 and al, #0x01
695 xor ah, ah
696 pop bx
697 pop ds
698 ret
699
700 ; VBE Init - Initialise the Vesa Bios Extension Code
701 ; This function does a sanity check on the host side display code interface.
702
703 vbe_init:
704 mov ax, # VBE_DISPI_ID0
705 call dispi_set_id
706 call dispi_get_id
707 cmp ax, # VBE_DISPI_ID0
708 jne no_vbe_interface
709 push ds
710 push bx
711 mov ax, # BIOSMEM_SEG
712 mov ds, ax
713 mov bx, # BIOSMEM_VBE_FLAG
714 mov al, #0x01
715 mov [bx], al
716 pop bx
717 pop ds
718 mov ax, # VBE_DISPI_ID4
719 call dispi_set_id
720 no_vbe_interface:
721 #if defined(USE_BX_INFO) || defined(DEBUG)
722 mov bx, #msg_vbe_init
723 push bx
724 call _printf
725 inc sp
726 inc sp
727 #endif
728 ret
729
730 ; VBE Display Info - Display information on screen about the VBE
731
732 vbe_display_info:
733 call _vbe_has_vbe_display
734 test ax, ax
735 jz no_vbe_flag
736 mov ax, #0xc000
737 mov ds, ax
738 mov si, #_vbebios_info_string
739 jmp _display_string
740 no_vbe_flag:
741 mov ax, #0xc000
742 mov ds, ax
743 mov si, #_no_vbebios_info_string
744 jmp _display_string
745 ASM_END
746
747 /** Function 00h - Return VBE Controller Information
748 *
749 * Input:
750 * AX = 4F00h
751 * ES:DI = Pointer to buffer in which to place VbeInfoBlock structure
752 * (VbeSignature should be VBE2 when VBE 2.0 information is desired and
753 * the info block is 512 bytes in size)
754 * Output:
755 * AX = VBE Return Status
756 *
757 */
758 void vbe_biosfn_return_controller_information(AX, ES, DI)
759 Bit16u *AX;Bit16u ES;Bit16u DI;
760 {
761 Bit16u ss=get_SS();
762 VbeInfoBlock vbe_info_block;
763 Bit16u status;
764 Bit16u result;
765 Bit16u vbe2_info;
766 Bit16u cur_mode=0;
767 Bit16u cur_ptr=34;
768 ModeInfoListItem *cur_info=&mode_info_list;
769
770 status = read_word(ss, AX);
771
772 #ifdef DEBUG
773 printf("VBE vbe_biosfn_return_vbe_info ES%x DI%x AX%x\n",ES,DI,status);
774 #endif
775
776 vbe2_info = 0;
777 #ifdef VBE2_NO_VESA_CHECK
778 #else
779 // get vbe_info_block into local variable
780 memcpyb(ss, &vbe_info_block, ES, DI, sizeof(vbe_info_block));
781
782 // check for VBE2 signature
783 if (((vbe_info_block.VbeSignature[0] == 'V') &&
784 (vbe_info_block.VbeSignature[1] == 'B') &&
785 (vbe_info_block.VbeSignature[2] == 'E') &&
786 (vbe_info_block.VbeSignature[3] == '2')) ||
787
788 ((vbe_info_block.VbeSignature[0] == 'V') &&
789 (vbe_info_block.VbeSignature[1] == 'E') &&
790 (vbe_info_block.VbeSignature[2] == 'S') &&
791 (vbe_info_block.VbeSignature[3] == 'A')) )
792 {
793 vbe2_info = 1;
794 #ifdef DEBUG
795 printf("VBE correct VESA/VBE2 signature found\n");
796 #endif
797 }
798 #endif
799
800 // VBE Signature
801 vbe_info_block.VbeSignature[0] = 'V';
802 vbe_info_block.VbeSignature[1] = 'E';
803 vbe_info_block.VbeSignature[2] = 'S';
804 vbe_info_block.VbeSignature[3] = 'A';
805
806 // VBE Version supported
807 vbe_info_block.VbeVersion = 0x0200;
808
809 // OEM String
810 vbe_info_block.OemStringPtr_Seg = 0xc000;
811 vbe_info_block.OemStringPtr_Off = &vbebios_copyright;
812
813 // Capabilities
814 vbe_info_block.Capabilities[0] = VBE_CAPABILITY_8BIT_DAC;
815 vbe_info_block.Capabilities[1] = 0;
816 vbe_info_block.Capabilities[2] = 0;
817 vbe_info_block.Capabilities[3] = 0;
818
819 // VBE Video Mode Pointer (dynamicly generated from the mode_info_list)
820 vbe_info_block.VideoModePtr_Seg= ES ;
821 vbe_info_block.VideoModePtr_Off= DI + 34;
822
823 // VBE Total Memory (in 64b blocks)
824 vbe_info_block.TotalMemory = VBE_TOTAL_VIDEO_MEMORY_DIV_64K;
825
826 if (vbe2_info)
827 {
828 // OEM Stuff
829 vbe_info_block.OemSoftwareRev = VBE_OEM_SOFTWARE_REV;
830 vbe_info_block.OemVendorNamePtr_Seg = 0xc000;
831 vbe_info_block.OemVendorNamePtr_Off = &vbebios_vendor_name;
832 vbe_info_block.OemProductNamePtr_Seg = 0xc000;
833 vbe_info_block.OemProductNamePtr_Off = &vbebios_product_name;
834 vbe_info_block.OemProductRevPtr_Seg = 0xc000;
835 vbe_info_block.OemProductRevPtr_Off = &vbebios_product_revision;
836
837 // copy updates in vbe_info_block back
838 memcpyb(ES, DI, ss, &vbe_info_block, sizeof(vbe_info_block));
839 }
840 else
841 {
842 // copy updates in vbe_info_block back (VBE 1.x compatibility)
843 memcpyb(ES, DI, ss, &vbe_info_block, 256);
844 }
845
846 do
847 {
848 if ((cur_info->info.XResolution <= dispi_get_max_xres()) &&
849 (cur_info->info.BitsPerPixel <= dispi_get_max_bpp())) {
850 #ifdef DEBUG
851 printf("VBE found mode %x => %x\n", cur_info->mode,cur_mode);
852 #endif
853 write_word(ES, DI + cur_ptr, cur_info->mode);
854 cur_mode++;
855 cur_ptr+=2;
856 } else {
857 #ifdef DEBUG
858 printf("VBE mode %x (xres=%x / bpp=%02x) not supported by display\n", cur_info->mode,cur_info->info.XResolution,cur_info->info.BitsPerPixel);
859 #endif
860 }
861 cur_info++;
862 } while (cur_info->mode != VBE_VESA_MODE_END_OF_LIST);
863
864 // Add vesa mode list terminator
865 write_word(ES, DI + cur_ptr, cur_info->mode);
866
867 result = 0x4f;
868
869 write_word(ss, AX, result);
870 }
871
872
873 /** Function 01h - Return VBE Mode Information
874 *
875 * Input:
876 * AX = 4F01h
877 * CX = Mode Number
878 * ES:DI = Pointer to buffer in which to place ModeInfoBlock structure
879 * Output:
880 * AX = VBE Return Status
881 *
882 */
883 void vbe_biosfn_return_mode_information(AX, CX, ES, DI)
884 Bit16u *AX;Bit16u CX; Bit16u ES;Bit16u DI;
885 {
886 Bit16u result=0x0100;
887 Bit16u ss=get_SS();
888 ModeInfoBlock info;
889 ModeInfoListItem *cur_info;
890 Boolean using_lfb;
891
892 #ifdef DEBUG
893 printf("VBE vbe_biosfn_return_mode_information ES%x DI%x CX%x\n",ES,DI,CX);
894 #endif
895
896 using_lfb=((CX & VBE_MODE_LINEAR_FRAME_BUFFER) == VBE_MODE_LINEAR_FRAME_BUFFER);
897
898 CX = (CX & 0x1ff);
899
900 cur_info = mode_info_find_mode(CX, using_lfb, &cur_info);
901
902 if (cur_info != 0)
903 {
904 #ifdef DEBUG
905 printf("VBE found mode %x\n",CX);
906 #endif
907 memsetb(ss, &info, 0, sizeof(ModeInfoBlock));
908 memcpyb(ss, &info, 0xc000, &(cur_info->info), sizeof(ModeInfoBlockCompact));
909 if (using_lfb) {
910 info.NumberOfBanks = 1;
911 }
912 if (info.WinAAttributes & VBE_WINDOW_ATTRIBUTE_RELOCATABLE) {
913 info.WinFuncPtr = 0xC0000000UL;
914 *(Bit16u *)&(info.WinFuncPtr) = (Bit16u)(dispi_set_bank_farcall);
915 }
916
917 result = 0x4f;
918 }
919 else
920 {
921 #ifdef DEBUG
922 printf("VBE *NOT* found mode %x\n",CX);
923 #endif
924 result = 0x100;
925 }
926
927 if (result == 0x4f)
928 {
929 // copy updates in mode_info_block back
930 memcpyb(ES, DI, ss, &info, sizeof(info));
931 }
932
933 write_word(ss, AX, result);
934 }
935
936 /** Function 02h - Set VBE Mode
937 *
938 * Input:
939 * AX = 4F02h
940 * BX = Desired Mode to set
941 * ES:DI = Pointer to CRTCInfoBlock structure
942 * Output:
943 * AX = VBE Return Status
944 *
945 */
946 void vbe_biosfn_set_mode(AX, BX, ES, DI)
947 Bit16u *AX;Bit16u BX; Bit16u ES;Bit16u DI;
948 {
949 Bit16u ss = get_SS();
950 Bit16u result;
951 ModeInfoListItem *cur_info;
952 Boolean using_lfb;
953 Bit8u no_clear;
954 Bit8u lfb_flag;
955
956 using_lfb=((BX & VBE_MODE_LINEAR_FRAME_BUFFER) == VBE_MODE_LINEAR_FRAME_BUFFER);
957 lfb_flag=using_lfb?VBE_DISPI_LFB_ENABLED:0;
958 no_clear=((BX & VBE_MODE_PRESERVE_DISPLAY_MEMORY) == VBE_MODE_PRESERVE_DISPLAY_MEMORY)?VBE_DISPI_NOCLEARMEM:0;
959
960 BX = (BX & 0x1ff);
961
962 //result=read_word(ss,AX);
963
964 // check for non vesa mode
965 if (BX<VBE_MODE_VESA_DEFINED)
966 {
967 Bit8u mode;
968
969 dispi_set_enable(VBE_DISPI_DISABLED);
970 // call the vgabios in order to set the video mode
971 // this allows for going back to textmode with a VBE call (some applications expect that to work)
972
973 mode=(BX & 0xff);
974 biosfn_set_video_mode(mode);
975 result = 0x4f;
976 }
977
978 cur_info = mode_info_find_mode(BX, using_lfb, &cur_info);
979
980 if (cur_info != 0)
981 {
982 #ifdef DEBUG
983 printf("VBE found mode %x, setting:\n", BX);
984 printf("\txres%x yres%x bpp%x\n",
985 cur_info->info.XResolution,
986 cur_info->info.YResolution,
987 cur_info->info.BitsPerPixel);
988 #endif
989
990 // first disable current mode (when switching between vesa modi)
991 dispi_set_enable(VBE_DISPI_DISABLED);
992
993 if (cur_info->info.BitsPerPixel == 4)
994 {
995 biosfn_set_video_mode(0x6a);
996 }
997
998 dispi_set_bpp(cur_info->info.BitsPerPixel);
999 dispi_set_xres(cur_info->info.XResolution);
1000 dispi_set_yres(cur_info->info.YResolution);
1001 dispi_set_bank(0);
1002 dispi_set_enable(VBE_DISPI_ENABLED | no_clear | lfb_flag);
1003 vga_compat_setup();
1004
1005 write_word(BIOSMEM_SEG,BIOSMEM_VBE_MODE,BX);
1006 write_byte(BIOSMEM_SEG,BIOSMEM_VIDEO_CTL,(0x60 | no_clear));
1007
1008 result = 0x4f;
1009 }
1010 else
1011 {
1012 #ifdef DEBUG
1013 printf("VBE *NOT* found mode %x\n" , BX);
1014 #endif
1015 result = 0x100;
1016
1017 // FIXME: redirect non VBE modi to normal VGA bios operation
1018 // (switch back to VGA mode
1019 if (BX == 3)
1020 result = 0x4f;
1021 }
1022
1023 write_word(ss, AX, result);
1024 }
1025
1026 /** Function 03h - Return Current VBE Mode
1027 *
1028 * Input:
1029 * AX = 4F03h
1030 * Output:
1031 * AX = VBE Return Status
1032 * BX = Current VBE Mode
1033 *
1034 */
1035 ASM_START
1036 vbe_biosfn_return_current_mode:
1037 push ds
1038 mov ax, # BIOSMEM_SEG
1039 mov ds, ax
1040 call dispi_get_enable
1041 and ax, # VBE_DISPI_ENABLED
1042 jz no_vbe_mode
1043 mov bx, # BIOSMEM_VBE_MODE
1044 mov ax, [bx]
1045 mov bx, ax
1046 jnz vbe_03_ok
1047 no_vbe_mode:
1048 mov bx, # BIOSMEM_CURRENT_MODE
1049 mov al, [bx]
1050 mov bl, al
1051 xor bh, bh
1052 vbe_03_ok:
1053 mov ax, #0x004f
1054 pop ds
1055 ret
1056 ASM_END
1057
1058
1059 Bit16u vbe_biosfn_read_video_state_size()
1060 {
1061 return 9 * 2;
1062 }
1063
1064 void vbe_biosfn_save_video_state(ES, BX)
1065 Bit16u ES; Bit16u BX;
1066 {
1067 Bit16u enable, i;
1068
1069 outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE);
1070 enable = inw(VBE_DISPI_IOPORT_DATA);
1071 write_word(ES, BX, enable);
1072 BX += 2;
1073 if (!(enable & VBE_DISPI_ENABLED))
1074 return;
1075 for(i = VBE_DISPI_INDEX_XRES; i <= VBE_DISPI_INDEX_Y_OFFSET; i++) {
1076 if (i != VBE_DISPI_INDEX_ENABLE) {
1077 outw(VBE_DISPI_IOPORT_INDEX, i);
1078 write_word(ES, BX, inw(VBE_DISPI_IOPORT_DATA));
1079 BX += 2;
1080 }
1081 }
1082 }
1083
1084
1085 void vbe_biosfn_restore_video_state(ES, BX)
1086 Bit16u ES; Bit16u BX;
1087 {
1088 Bit16u enable, i;
1089
1090 enable = read_word(ES, BX);
1091 BX += 2;
1092
1093 if (!(enable & VBE_DISPI_ENABLED)) {
1094 outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE);
1095 outw(VBE_DISPI_IOPORT_DATA, enable);
1096 } else {
1097 outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_XRES);
1098 outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX));
1099 BX += 2;
1100 outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_YRES);
1101 outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX));
1102 BX += 2;
1103 outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_BPP);
1104 outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX));
1105 BX += 2;
1106 outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE);
1107 outw(VBE_DISPI_IOPORT_DATA, enable);
1108
1109 for(i = VBE_DISPI_INDEX_BANK; i <= VBE_DISPI_INDEX_Y_OFFSET; i++) {
1110 outw(VBE_DISPI_IOPORT_INDEX, i);
1111 outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX));
1112 BX += 2;
1113 }
1114 }
1115 }
1116
1117 /** Function 04h - Save/Restore State
1118 *
1119 * Input:
1120 * AX = 4F04h
1121 * DL = 00h Return Save/Restore State buffer size
1122 * 01h Save State
1123 * 02h Restore State
1124 * CX = Requested states
1125 * ES:BX = Pointer to buffer (if DL <> 00h)
1126 * Output:
1127 * AX = VBE Return Status
1128 * BX = Number of 64-byte blocks to hold the state buffer (if DL=00h)
1129 *
1130 */
1131 void vbe_biosfn_save_restore_state(AX, CX, DX, ES, BX)
1132 Bit16u *AX; Bit16u CX; Bit16u DX; Bit16u ES; Bit16u *BX;
1133 {
1134 Bit16u ss=get_SS();
1135 Bit16u result, val;
1136
1137 result = 0x4f;
1138 switch(GET_DL()) {
1139 case 0x00:
1140 val = biosfn_read_video_state_size2(CX);
1141 #ifdef DEBUG
1142 printf("VGA state size=%x\n", val);
1143 #endif
1144 if (CX & 8)
1145 val += vbe_biosfn_read_video_state_size();
1146 write_word(ss, BX, val);
1147 break;
1148 case 0x01:
1149 val = read_word(ss, BX);
1150 val = biosfn_save_video_state(CX, ES, val);
1151 #ifdef DEBUG
1152 printf("VGA save_state offset=%x\n", val);
1153 #endif
1154 if (CX & 8)
1155 vbe_biosfn_save_video_state(ES, val);
1156 break;
1157 case 0x02:
1158 val = read_word(ss, BX);
1159 val = biosfn_restore_video_state(CX, ES, val);
1160 #ifdef DEBUG
1161 printf("VGA restore_state offset=%x\n", val);
1162 #endif
1163 if (CX & 8)
1164 vbe_biosfn_restore_video_state(ES, val);
1165 break;
1166 default:
1167 // function failed
1168 result = 0x100;
1169 break;
1170 }
1171 write_word(ss, AX, result);
1172 }
1173
1174 /** Function 05h - Display Window Control
1175 *
1176 * Input:
1177 * AX = 4F05h
1178 * (16-bit) BH = 00h Set memory window
1179 * = 01h Get memory window
1180 * BL = Window number
1181 * = 00h Window A
1182 * = 01h Window B
1183 * DX = Window number in video memory in window
1184 * granularity units (Set Memory Window only)
1185 * Note:
1186 * If this function is called while in a linear frame buffer mode,
1187 * this function must fail with completion code AH=03h
1188 *
1189 * Output:
1190 * AX = VBE Return Status
1191 * DX = Window number in window granularity units
1192 * (Get Memory Window only)
1193 */
1194 ASM_START
1195 vbe_biosfn_display_window_control:
1196 cmp bl, #0x00
1197 jne vbe_05_failed
1198 cmp bh, #0x01
1199 je get_display_window
1200 jb set_display_window
1201 mov ax, #0x0100
1202 ret
1203 set_display_window:
1204 mov ax, dx
1205 call _dispi_set_bank
1206 call dispi_get_bank
1207 cmp ax, dx
1208 jne vbe_05_failed
1209 mov ax, #0x004f
1210 ret
1211 get_display_window:
1212 call dispi_get_bank
1213 mov dx, ax
1214 mov ax, #0x004f
1215 ret
1216 vbe_05_failed:
1217 mov ax, #0x014f
1218 ret
1219 ASM_END
1220
1221
1222 /** Function 06h - Set/Get Logical Scan Line Length
1223 *
1224 * Input:
1225 * AX = 4F06h
1226 * BL = 00h Set Scan Line Length in Pixels
1227 * = 01h Get Scan Line Length
1228 * = 02h Set Scan Line Length in Bytes
1229 * = 03h Get Maximum Scan Line Length
1230 * CX = If BL=00h Desired Width in Pixels
1231 * If BL=02h Desired Width in Bytes
1232 * (Ignored for Get Functions)
1233 *
1234 * Output:
1235 * AX = VBE Return Status
1236 * BX = Bytes Per Scan Line
1237 * CX = Actual Pixels Per Scan Line
1238 * (truncated to nearest complete pixel)
1239 * DX = Maximum Number of Scan Lines
1240 */
1241 ASM_START
1242 vbe_biosfn_set_get_logical_scan_line_length:
1243 mov ax, cx
1244 cmp bl, #0x01
1245 je get_logical_scan_line_length
1246 cmp bl, #0x02
1247 je set_logical_scan_line_bytes
1248 jb set_logical_scan_line_pixels
1249 mov ax, #0x0100
1250 ret
1251 set_logical_scan_line_bytes:
1252 push ax
1253 call dispi_get_bpp
1254 xor bh, bh
1255 mov bl, ah
1256 or bl, bl
1257 jnz no_4bpp_1
1258 shl ax, #3
1259 mov bl, #1
1260 no_4bpp_1:
1261 xor dx, dx
1262 pop ax
1263 div bx
1264 set_logical_scan_line_pixels:
1265 call dispi_set_virt_width
1266 get_logical_scan_line_length:
1267 call dispi_get_bpp
1268 xor bh, bh
1269 mov bl, ah
1270 call dispi_get_virt_width
1271 mov cx, ax
1272 or bl, bl
1273 jnz no_4bpp_2
1274 shr ax, #3
1275 mov bl, #1
1276 no_4bpp_2:
1277 mul bx
1278 mov bx, ax
1279 call dispi_get_virt_height
1280 mov dx, ax
1281 mov ax, #0x004f
1282 ret
1283 ASM_END
1284
1285
1286 /** Function 07h - Set/Get Display Start
1287 *
1288 * Input(16-bit):
1289 * AX = 4F07h
1290 * BH = 00h Reserved and must be 00h
1291 * BL = 00h Set Display Start
1292 * = 01h Get Display Start
1293 * = 02h Schedule Display Start (Alternate)
1294 * = 03h Schedule Stereoscopic Display Start
1295 * = 04h Get Scheduled Display Start Status
1296 * = 05h Enable Stereoscopic Mode
1297 * = 06h Disable Stereoscopic Mode
1298 * = 80h Set Display Start during Vertical Retrace
1299 * = 82h Set Display Start during Vertical Retrace (Alternate)
1300 * = 83h Set Stereoscopic Display Start during Vertical Retrace
1301 * ECX = If BL=02h/82h Display Start Address in bytes
1302 * If BL=03h/83h Left Image Start Address in bytes
1303 * EDX = If BL=03h/83h Right Image Start Address in bytes
1304 * CX = If BL=00h/80h First Displayed Pixel In Scan Line
1305 * DX = If BL=00h/80h First Displayed Scan Line
1306 *
1307 * Output:
1308 * AX = VBE Return Status
1309 * BH = If BL=01h Reserved and will be 0
1310 * CX = If BL=01h First Displayed Pixel In Scan Line
1311 * If BL=04h 0 if flip has not occurred, not 0 if it has
1312 * DX = If BL=01h First Displayed Scan Line
1313 *
1314 * Input(32-bit):
1315 * BH = 00h Reserved and must be 00h
1316 * BL = 00h Set Display Start
1317 * = 80h Set Display Start during Vertical Retrace
1318 * CX = Bits 0-15 of display start address
1319 * DX = Bits 16-31 of display start address
1320 * ES = Selector for memory mapped registers
1321 */
1322 ASM_START
1323 vbe_biosfn_set_get_display_start:
1324 cmp bl, #0x80
1325 je set_display_start
1326 cmp bl, #0x01
1327 je get_display_start
1328 jb set_display_start
1329 mov ax, #0x0100
1330 ret
1331 set_display_start:
1332 mov ax, cx
1333 call dispi_set_x_offset
1334 mov ax, dx
1335 call dispi_set_y_offset
1336 mov ax, #0x004f
1337 ret
1338 get_display_start:
1339 call dispi_get_x_offset
1340 mov cx, ax
1341 call dispi_get_y_offset
1342 mov dx, ax
1343 xor bh, bh
1344 mov ax, #0x004f
1345 ret
1346 ASM_END
1347
1348
1349 /** Function 08h - Set/Get Dac Palette Format
1350 *
1351 * Input:
1352 * AX = 4F08h
1353 * BL = 00h set DAC palette width
1354 * = 01h get DAC palette width
1355 * BH = If BL=00h: desired number of bits per primary color
1356 * Output:
1357 * AX = VBE Return Status
1358 * BH = current number of bits per primary color (06h = standard VGA)
1359 */
1360 ASM_START
1361 vbe_biosfn_set_get_dac_palette_format:
1362 cmp bl, #0x01
1363 je get_dac_palette_format
1364 jb set_dac_palette_format
1365 mov ax, #0x0100
1366 ret
1367 set_dac_palette_format:
1368 call dispi_get_enable
1369 cmp bh, #0x06
1370 je set_normal_dac
1371 cmp bh, #0x08
1372 jne vbe_08_unsupported
1373 or ax, # VBE_DISPI_8BIT_DAC
1374 jnz set_dac_mode
1375 set_normal_dac:
1376 and ax, #~ VBE_DISPI_8BIT_DAC
1377 set_dac_mode:
1378 call _dispi_set_enable
1379 get_dac_palette_format:
1380 mov bh, #0x06
1381 call dispi_get_enable
1382 and ax, # VBE_DISPI_8BIT_DAC
1383 jz vbe_08_ok
1384 mov bh, #0x08
1385 vbe_08_ok:
1386 mov ax, #0x004f
1387 ret
1388 vbe_08_unsupported:
1389 mov ax, #0x014f
1390 ret
1391 ASM_END
1392
1393
1394 /** Function 09h - Set/Get Palette Data
1395 *
1396 * Input:
1397 * AX = 4F09h
1398 * Output:
1399 * AX = VBE Return Status
1400 *
1401 * FIXME: incomplete API description, Input & Output
1402 */
1403 void vbe_biosfn_set_get_palette_data(AX)
1404 {
1405 }
1406
1407 /** Function 0Ah - Return VBE Protected Mode Interface
1408 * Input: AX = 4F0Ah VBE 2.0 Protected Mode Interface
1409 * BL = 00h Return protected mode table
1410 *
1411 *
1412 * Output: AX = Status
1413 * ES = Real Mode Segment of Table
1414 * DI = Offset of Table
1415 * CX = Length of Table including protected mode code
1416 * (for copying purposes)
1417 */
1418 ASM_START
1419 vbe_biosfn_return_protected_mode_interface:
1420 test bl, bl
1421 jnz _fail
1422 mov di, #0xc000
1423 mov es, di
1424 mov di, # vesa_pm_start
1425 mov cx, # vesa_pm_end
1426 sub cx, di
1427 mov ax, #0x004f
1428 ret
1429 _fail:
1430 mov ax, #0x014f
1431 ret
1432 ASM_END
VGABios