Subversion Repositories Kolibri OS

Rev

Rev 5790 | Rev 7129 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2288 clevermous 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2
;;                                                              ;;
5363 yogev_ezra 3
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
2288 clevermous 4
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
5
;; Distributed under terms of the GNU General Public License    ;;
6
;;                                                              ;;
7
;;  BOOTCODE.INC                                                ;;
8
;;                                                              ;;
9
;;  KolibriOS 16-bit loader,                                    ;;
10
;;                        based on bootcode for MenuetOS        ;;
11
;;                                                              ;;
12
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13
 
14
$Revision: 7121 $
15
 
16
 
17
;==========================================================================
18
;
19
;                           16 BIT FUNCTIONS
20
;
21
;==========================================================================
22
 
23
 
24
putchar:
25
; in: al=character
26
        mov     ah, 0Eh
27
        mov     bh, 0
28
        int     10h
29
        ret
30
 
31
print:
32
; in: si->string
33
        mov     al, 186
34
        call    putchar
35
        mov     al, ' '
36
        call    putchar
37
 
38
printplain:
39
; in: si->string
40
        pusha
41
        lodsb
42
@@:
43
        call    putchar
44
        lodsb
45
        test    al, al
46
        jnz     @b
47
        popa
48
        ret
49
 
3796 yogev_ezra 50
getkey:                         ; Use BIOS INT 16h to read a key from the keyboard
2288 clevermous 51
; get number in range [bl,bh] (bl,bh in ['0'..'9'])
52
; in: bx=range
53
; out: ax=digit (1..9, 10 for 0)
3989 yogev_ezra 54
        mov     ah, 0       ; If 'int 16h' is called with 'ah' equal to zero, the BIOS will not return control to the caller
55
        int     16h         ; until a key is available in the system type ahead buffer. On return, 'al' contains the ASCII
56
        cmp     al, 27      ; code for the key read from the buffer and 'ah' contains the keyboard scan code. (27=>ESC)
57
        jz      @f          ; If ESC is pressed, return (user doesn't want to change any value).
58
        cmp     al, bl      ; Compare 'al' (ASCII code of key pressed) with 'bl' (lowest accepted char from the range).
59
        jb      getkey      ; ASCII code is below lowest accepted value => continue waiting for another key.
60
        cmp     al, bh      ; Compare 'al' (ASCII code of key pressed) with 'bh' (highest accepted char from the range).
61
        ja      getkey      ; ASCII code is above highest accepted value => continue waiting for another key.
62
        push    ax          ; If the pressed key is in the accepted range, save it on the stack and echo to screen.
2288 clevermous 63
        call    putchar
64
        pop     ax
3989 yogev_ezra 65
        and     ax, 0Fh     ; Convert ASCII code to number: '1'->1, '2'->2, etc. 0Fh=1111b.
66
        jnz     @f          ; ASCII code for '0' is 48 (110000b). (110000b AND 1111b) = 0
67
        mov     al, 10      ; So if key '0' was entered, return 10 in 'ax'
2288 clevermous 68
@@:
69
        ret
70
 
71
setcursor:
72
; in: dl=column, dh=row
73
        mov     ah, 2
74
        mov     bh, 0
75
        int     10h
76
        ret
77
 
78
macro _setcursor row,column
79
{
80
        mov     dx, row*256 + column
81
        call    setcursor
82
}
83
 
3989 yogev_ezra 84
macro _ask_question question,range,variable_to_set
85
{
86
        _setcursor 16,0
87
        mov     si, question    ; Print the question
88
        call    print
89
        mov     bx, range       ; range accepted for answer
90
        call    getkey
91
        cmp     al, 27          ; If ESC was pressed, do not change the value
92
        jz      .esc_pressed
93
        mov     [variable_to_set], al
94
}
95
 
2288 clevermous 96
boot_read_floppy:
97
        push    si
98
        xor     si, si
99
        mov     ah, 2   ; read
100
@@:
101
        push    ax
102
        int     0x13
103
        pop     ax
104
        jnc     @f
105
        inc     si
106
        cmp     si, 10
107
        jb      @b
108
sayerr_badsect:
109
        mov     si, badsect
110
sayerr_plain:
111
        call    printplain
112
        jmp     $
113
@@:
114
        pop     si
115
        ret
116
 
117
; convert abs. sector number (AX) to BIOS T:H:S
118
; sector number = (abs.sector%BPB_SecPerTrk)+1
119
; pre.track number = (abs.sector/BPB_SecPerTrk)
120
; head number = pre.track number%BPB_NumHeads
121
; track number = pre.track number/BPB_NumHeads
122
; Return: cl - sector number
123
;         ch - track number
124
;         dl - drive number (0 = a:)
125
;         dh - head number
126
conv_abs_to_THS:
127
        push    bx
128
        mov     bx, word [BPB_SecPerTrk]
129
        xor     dx, dx
130
        div     bx
131
        inc     dx
132
        mov     cl, dl                          ; cl = sector number
133
        mov     bx, word [BPB_NumHeads]
134
        xor     dx, dx
135
        div     bx
136
        ; !!!!!!! ax = track number, dx = head number
137
        mov     ch, al                          ; ch=track number
138
        xchg    dh, dl                          ; dh=head number
139
        mov     dl, 0                           ; dl=0 (drive 0 (a:))
140
        pop     bx
141
        retn
142
; needed variables
143
BPB_SecPerTrk   dw      0                       ; sectors per track
144
BPB_NumHeads    dw      0                       ; number of heads
145
BPB_FATSz16     dw      0                       ; size of FAT
146
BPB_RootEntCnt  dw      0                       ; count of root dir. entries
147
BPB_BytsPerSec  dw      0                       ; bytes per sector
148
BPB_RsvdSecCnt  dw      0                       ; number of reserved sectors
149
BPB_TotSec16    dw      0                       ; count of the sectors on the volume
150
BPB_SecPerClus  db      0                       ; number of sectors per cluster
151
BPB_NumFATs     db      0                       ; number of FAT tables
152
abs_sector_adj  dw      0                       ; adjustment to make abs. sector number
153
end_of_FAT      dw      0                       ; end of FAT table
154
FirstDataSector dw      0                       ; begin of data
155
 
156
;=========================================================================
157
;
158
;                           16 BIT CODE
159
;
160
;=========================================================================
161
 
5786 serge 162
include 'bootvesa.inc'                 ;Include source for boot vesa
2288 clevermous 163
if defined extended_primary_loader
164
include 'parsers.inc'
165
end if
166
 
167
start_of_code:
168
 
169
if defined extended_primary_loader
170
; save data from primary loader
171
        mov     word [cs:bootcallback], si
172
        mov     word [cs:bootcallback+2], ds
173
        push    cs
174
        pop     ds
175
        mov     [bootdevice], ax
176
        mov     [bootfs], bx
177
 
178
; set up stack
5790 serge 179
        mov     ax, (TMP_STACK_TOP and 0xF0000) shr 4
2288 clevermous 180
        mov     ss, ax
5786 serge 181
        mov     sp, TMP_STACK_TOP and 0xFFFF
2288 clevermous 182
 
183
; try to load configuration file
184
        mov     ax, 1
185
        mov     di, config_file_struct
186
        call    [bootcallback]
187
        cld
188
        push    cs
189
        pop     es
190
; bx=0 - ok, bx=1 - part of file loaded, assume this is ok
191
        cmp     bx, 1
192
        ja      .config_bad
193
; configuration file was loaded, parse
194
; if length is too big, use first 0FFFFh bytes
195
        test    dx, dx
196
        jz      @f
197
        mov     ax, 0FFFFh
198
@@:
199
; ds:si will be pointer to current data, dx = limit
200
        xchg    ax, dx
201
        push    4000h
202
        pop     ds
203
        xor     si, si
204
.parse_loop:
205
; skip spaces
206
        cmp     si, dx
207
        jae     .parse_done
208
        lodsb
209
        cmp     al, ' '
210
        jbe     .parse_loop
211
        dec     si
212
; loop over all possible configuration values
213
        mov     bx, config_file_variables
214
.find_variant:
215
; get length
216
        mov     cx, [es:bx]
217
; zero length = end of list
218
        jecxz   .find_newline
219
; skip over length
220
        inc     bx
221
        inc     bx
222
        mov     di, bx
223
; skip over string
224
        add     bx, cx
225
; test whether we have at least cx symbols left
226
        mov     ax, cx
227
        add     ax, si
228
        jc      .next_variant1
229
        cmp     ax, dx
230
        jae     .next_variant1
231
; save current position
232
        push    si
233
; compare strings
234
        repz cmpsb
235
        jnz     .next_variant2
236
; strings are equal; look for "=" with possible spaces before and after
237
@@:
238
        cmp     si, dx
239
        jae     .next_variant2
240
        lodsb
241
        cmp     al, ' '
242
        jbe     @b
243
        cmp     al, '='
244
        jnz     .next_variant2
245
; ok, we found the true variant
246
; ignore saved position on the stack
247
        pop     ax
248
; call the parser
249
        call    word [es:bx]
250
; line parsed, find next
251
.find_newline:
252
        cmp     si, dx
253
        jae     .parse_done
254
        lodsb
255
        cmp     al, 13
256
        jz      .parse_loop
257
        cmp     al, 10
258
        jz      .parse_loop
259
        jmp     .find_newline
260
.next_variant2:
261
; continue to the next variant, restoring current position
262
        pop     si
263
.next_variant1:
264
; continue to the next variant
265
; skip over the parser
266
        inc     bx
267
        inc     bx
268
        jmp     .find_variant
269
.parse_done:
270
.config_bad:
271
 
272
; set up segment registers
273
        push    cs
274
        pop     ds
275
else
276
        cld
277
; \begin{diamond}[02.12.2005]
278
; if bootloader sets ax = 'KL', then ds:si points to loader block
279
        cmp     ax, 'KL'
280
        jnz     @f
281
        mov     word [cs:cfgmanager.loader_block], si
282
        mov     word [cs:cfgmanager.loader_block+2], ds
283
@@:
284
; \end{diamond}[02.12.2005]
285
 
286
; if bootloader sets cx = 'HA' and dx = 'RD', then bx contains identifier of source hard disk
287
; (see comment to bx_from_load)
288
        cmp     cx, 'HA'
289
        jnz     no_hd_load
290
        cmp     dx, 'RD'
291
        jnz     no_hd_load
292
        mov     word [cs:bx_from_load], bx              ; {SPraid}[13.03.2007]
293
no_hd_load:
294
 
295
; set up stack
5790 serge 296
        mov     ax, (TMP_STACK_TOP and 0xF0000) shr 4
2288 clevermous 297
        mov     ss, ax
5786 serge 298
        mov     sp, TMP_STACK_TOP and 0xFFFF
2288 clevermous 299
; set up segment registers
300
        push    cs
301
        pop     ds
302
        push    cs
303
        pop     es
304
end if
305
 
306
; set videomode
307
        mov     ax, 3
308
        int     0x10
309
 
310
if lang eq ru
311
 ; Load & set russian VGA font (RU.INC)
312
        mov     bp, RU_FNT1             ; RU_FNT1 - First part
313
        mov     bx, 1000h               ; 768 bytes
314
        mov     cx, 30h                 ; 48 symbols
315
        mov     dx, 80h                 ; 128 - position of first symbol
316
        mov     ax, 1100h
317
        int     10h
318
 
319
        mov     bp, RU_FNT2             ; RU_FNT2 -Second part
320
        mov     bx, 1000h               ; 512 bytes
321
        mov     cx, 20h                 ; 32 symbols
322
        mov     dx, 0E0h                ; 224 - position of first symbol
323
        mov     ax, 1100h
324
        int     10h
325
 ; End set VGA russian font
326
else if lang eq et
327
        mov     bp, ET_FNT              ; ET_FNT1
328
        mov     bx, 1000h               ;
329
        mov     cx, 255                 ; 256 symbols
330
        xor     dx, dx                  ; 0 - position of first symbol
331
        mov     ax, 1100h
332
        int     10h
333
end if
334
 
335
; draw frames
336
        push    0xb800
337
        pop     es
338
        xor     di, di
339
        mov     ah, 1*16+15
340
 
341
; draw top
342
        mov     si, d80x25_top
343
        mov     cx, d80x25_top_num * 80
344
@@:
345
        lodsb
346
        stosw
347
        loop    @b
348
; draw spaces
349
        mov     si, space_msg
350
        mov     dx, 25 - d80x25_top_num - d80x25_bottom_num
351
dfl1:
352
        push    si
353
        mov     cx, 80
354
@@:
355
        lodsb
356
        stosw
357
        loop    @b
358
        pop     si
359
        dec     dx
360
        jnz     dfl1
361
; draw bottom
362
        mov     si, d80x25_bottom
363
        mov     cx, d80x25_bottom_num * 80
364
@@:
365
        lodsb
366
        stosw
367
        loop    @b
368
 
369
        mov     byte [space_msg+80], 0    ; now space_msg is null terminated
370
 
371
        _setcursor d80x25_top_num,0
372
 
373
 
374
; TEST FOR 386+
375
 
376
        mov     bx, 0x4000
377
        pushf
378
        pop     ax
379
        mov     dx, ax
380
        xor     ax, bx
381
        push    ax
382
        popf
383
        pushf
384
        pop     ax
385
        and     ax, bx
386
        and     dx, bx
387
        cmp     ax, dx
388
        jnz     cpugood
389
        mov     si, not386
390
sayerr:
391
        call    print
392
        jmp     $
393
     cpugood:
394
 
395
        push    0
396
        popf
397
 
398
; set up esp
399
        movzx   esp, sp
400
 
401
        push    0
402
        pop     es
3774 mario79 403
 
5012 clevermous 404
        xor     cx, cx
405
@@:
406
        in      al, 64h
407
        test    al, 2
408
        loopnz  @b
409
 
3539 clevermous 410
        mov     al, 0xf6        ; Сброс клавиатуры, разрешить сканирование
2288 clevermous 411
        out     0x60, al
412
        xor     cx, cx
5012 clevermous 413
@@:
2288 clevermous 414
        in      al, 64h
5012 clevermous 415
        test    al, 1
5028 clevermous 416
        loopz   @b
5012 clevermous 417
        in      al, 0x60
2288 clevermous 418
 
419
;;;/diamond today   5.02.2008
420
; set keyboard typematic rate & delay
421
        mov     al, 0xf3
422
        out     0x60, al
423
        xor     cx, cx
424
@@:
425
        in      al, 64h
5012 clevermous 426
        test    al, 1
5028 clevermous 427
        loopz   @b
5012 clevermous 428
        in      al, 0x60
2288 clevermous 429
        mov     al, 0
430
        out     0x60, al
431
        xor     cx, cx
432
@@:
433
        in      al, 64h
5012 clevermous 434
        test    al, 1
5028 clevermous 435
        loopz   @b
5012 clevermous 436
        in      al, 0x60
2288 clevermous 437
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5012 clevermous 438
        sti
2288 clevermous 439
; --------------- APM ---------------------
2466 Serge 440
        and     word [es:BOOT_APM_VERSION], 0     ; ver = 0.0 (APM not found)
2288 clevermous 441
        mov     ax, 0x5300
442
        xor     bx, bx
443
        int     0x15
444
        jc      apm_end                 ; APM not found
445
        test    cx, 2
446
        jz      apm_end                 ; APM 32-bit protected-mode interface not supported
2466 Serge 447
        mov     [es:BOOT_APM_VERSION], ax         ; Save APM Version
448
        mov     [es:BOOT_APM_FLAGS], cx           ; Save APM flags
2288 clevermous 449
 
450
        ; Write APM ver ----
451
        and     ax, 0xf0f
452
        add     ax, '00'
453
        mov     si, msg_apm
454
        mov     [si + 5], ah
455
        mov     [si + 7], al
456
        _setcursor 0, 3
457
        call    printplain
458
        ; ------------------
459
 
460
        mov     ax, 0x5304              ; Disconnect interface
461
        xor     bx, bx
462
        int     0x15
463
        mov     ax, 0x5303              ; Connect 32 bit mode interface
464
        xor     bx, bx
465
        int     0x15
466
 
2466 Serge 467
        mov     [es:BOOT_APM_ENTRY], ebx
468
        mov     [es:BOOT_APM_CODE_32], ax
469
        mov     [es:BOOT_APM_CODE_16], cx
470
        mov     [es:BOOT_APM_DATA_16], dx
2288 clevermous 471
 
472
apm_end:
473
        _setcursor d80x25_top_num, 0
474
 
475
if ~ defined extended_primary_loader
476
;CHECK current of code
477
        cmp     [cfgmanager.loader_block], -1
478
        jz      noloaderblock
479
        les     bx, [cfgmanager.loader_block]
480
        cmp     byte [es:bx], 1
481
        mov     si, loader_block_error
482
        jnz     sayerr
483
        push    0
484
        pop     es
485
end if
486
 
487
noloaderblock:
488
; DISPLAY VESA INFORMATION
489
        call    print_vesa_info
490
        call    calc_vmodes_table
491
        call    check_first_parm   ;check and enable cursor_pos
492
 
493
; \begin{diamond}[30.11.2005]
494
cfgmanager:
495
; settings:
496
; a) preboot_graph = graphical mode
497
;    preboot_gprobe = probe this mode?
3777 yogev_ezra 498
; b) preboot_biosdisk  = use BIOS disks through V86 emulation? // (earlier was: preboot_dma  = use DMA access?)
7121 dunkaist 499
; c) preboot_debug = duplicates kernel debug output to the screen
3777 yogev_ezra 500
; d) preboot_launcher = start the first app (right now it's LAUNCHER) after kernel is loaded?
501
; e) preboot_device = from where to boot?
2288 clevermous 502
 
503
; determine default settings
504
if ~ defined extended_primary_loader
505
        mov     [.bSettingsChanged], 0
506
end if
507
 
508
;.preboot_gr_end:
509
        mov     di, preboot_device
510
; if image in memory is present and [preboot_device] is uninitialized,
511
; set it to use this preloaded image
512
        cmp     byte [di], 0
513
        jnz     .preboot_device_inited
514
if defined extended_primary_loader
515
        inc     byte [di]
516
        cmp     byte [bootdevice], 'f' ; floppy?
517
        jz      .preboot_device_inited
518
        inc     byte [di]
519
else
520
        cmp     [.loader_block], -1
521
        jz      @f
522
        les     bx, [.loader_block]
523
        test    byte [es:bx+1], 1
524
        jz      @f
525
        mov     byte [di], 3
526
        jmp     .preboot_device_inited
527
@@:
528
; otherwise, set [preboot_device] to 1 (default value - boot from floppy)
529
        mov     byte [di], 1
530
end if
531
.preboot_device_inited:
532
; following 4 lines set variables to 1 if its current value is 0
533
        cmp     byte [di+preboot_dma-preboot_device], 1
534
        adc     byte [di+preboot_dma-preboot_device], 0
3777 yogev_ezra 535
        cmp     byte [di+preboot_launcher-preboot_device], 1        ; Start LAUNCHER by default
5786 serge 536
        adc     byte [di+preboot_launcher-preboot_device], 0
2288 clevermous 537
        _setcursor 5,2
538
 
539
        mov     si, linef
540
        call    printplain
541
        mov     si, start_msg
542
        call    print
543
        mov     si, time_msg
544
        call    print
545
; get start time
546
        call    .gettime
547
        mov     [.starttime], eax
548
        mov     word [.timer], .newtimer
549
        mov     word [.timer+2], cs
550
.printcfg:
551
 
552
        _setcursor 9,0
553
        mov     si, current_cfg_msg
554
        call    print
555
        mov     si, curvideo_msg
556
        call    print
557
 
558
        call    draw_current_vmode
559
 
560
        mov     si, usebd_msg
561
        cmp     [preboot_biosdisk], 1
562
        call    .say_on_off
3777 yogev_ezra 563
        mov     si, debug_mode_msg
564
        cmp     [preboot_debug], 1
565
        call    .say_on_off
566
        mov     si, launcher_msg
567
        cmp     [preboot_launcher], 1
568
        call    .say_on_off
2288 clevermous 569
        mov     si, preboot_device_msg
570
        call    print
571
        mov     al, [preboot_device]
572
if defined extended_primary_loader
573
        and     eax, 3
574
else
575
        and     eax, 7
576
end if
577
        mov     si, [preboot_device_msgs+eax*2]
578
        call    printplain
579
.show_remarks:
580
; show remarks in gray color
581
        mov     di, ((21-num_remarks)*80 + 2)*2
582
        push    0xB800
583
        pop     es
584
        mov     cx, num_remarks
585
        mov     si, remarks
586
.write_remarks:
587
        lodsw
588
        push    si
589
        xchg    ax, si
590
        mov     ah, 1*16+7      ; background: blue (1), foreground: gray (7)
591
        push    di
592
.write_remark:
593
        lodsb
594
        test    al, al
595
        jz      @f
596
        stosw
597
        jmp     .write_remark
598
@@:
599
        pop     di
600
        pop     si
601
        add     di, 80*2
602
        loop    .write_remarks
603
.wait:
604
        _setcursor 25,0         ; out of screen
605
; set timer interrupt handler
606
        cli
607
        push    0
608
        pop     es
609
        push    dword [es:8*4]
610
        pop     dword [.oldtimer]
611
        push    dword [.timer]
612
        pop     dword [es:8*4]
613
;        mov     eax, [es:8*4]
614
;        mov     [.oldtimer], eax
615
;        mov     eax, [.timer]
616
;        mov     [es:8*4], eax
617
        sti
618
; wait for keypressed
619
        xor     ax, ax
620
        int     16h
621
        push    ax
622
; restore timer interrupt
623
;        push    0
624
;        pop     es
625
        mov     eax, [.oldtimer]
626
        mov     [es:8*4], eax
627
        mov     [.timer], eax
628
 
629
        _setcursor 7,0
630
        mov     si, space_msg
631
        call    printplain
632
; clear remarks and restore normal attributes
633
        push    es
634
        mov     di, ((21-num_remarks)*80 + 2)*2
635
        push    0xB800
636
        pop     es
637
        mov     cx, num_remarks
638
        mov     ax, ' ' + (1*16 + 15)*100h
639
@@:
640
        push    cx
641
        mov     cx, 76
642
        rep stosw
643
        pop     cx
644
        add     di, 4*2
645
        loop    @b
646
        pop     es
647
        pop     ax
648
; switch on key
649
        cmp     al, 13
650
        jz      .continue
651
        or      al, 20h
3777 yogev_ezra 652
        cmp     al, 'a'         ; select graphical mode
2288 clevermous 653
        jz      .change_a
3760 hidnplayr 654
        cmp     al, 'q'         ; Trick to make 'A' key on azerty keyboard work
655
        je      .change_a
3777 yogev_ezra 656
        cmp     al, 'b'         ; use BIOS disks? // (selecting YES will make BIOS disks visible as /bd)
2288 clevermous 657
        jz      .change_b
7121 dunkaist 658
        cmp     al, 'c'         ; load kernel in debug mode?
3777 yogev_ezra 659
        jz      .change_c
660
        cmp     al, 'd'         ; start launcher after kernel is loaded?
661
        jz      .change_d
662
        cmp     al, 'e'         ; select boot origin
2288 clevermous 663
        jnz     .show_remarks
3777 yogev_ezra 664
; e) preboot_device = from where to boot?
2288 clevermous 665
if defined extended_primary_loader
3989 yogev_ezra 666
        _ask_question bdev,'12',preboot_device              ; range accepted for answer: 1-2
2288 clevermous 667
else
3989 yogev_ezra 668
        _ask_question bdev,'14',preboot_device              ; range accepted for answer: 1-4
5786 serge 669
end if
3777 yogev_ezra 670
        _setcursor 14,0
3989 yogev_ezra 671
 
2288 clevermous 672
.d:
673
if ~ defined extended_primary_loader
674
        mov     [.bSettingsChanged], 1
675
end if
3989 yogev_ezra 676
.esc_pressed:
2288 clevermous 677
        call    clear_vmodes_table             ;clear vmodes_table
678
        jmp     .printcfg
3989 yogev_ezra 679
 
2288 clevermous 680
.change_a:
3797 mario79 681
        call    clear_vmodes_table             ;clear vmodes_table
3999 mario79 682
 
683
        mov     si, word [cursor_pos]
684
        mov     word [cursor_pos_old], si
2288 clevermous 685
.loops:
686
        call    draw_vmodes_table
687
        _setcursor 25,0         ; out of screen
688
        xor     ax, ax
689
        int     0x16
690
;        call    clear_table_cursor             ;clear current position of cursor
691
 
692
        mov     si, word [cursor_pos]
693
 
3989 yogev_ezra 694
        cmp     al, 27              ; If ESC was pressed, do not change the value
3999 mario79 695
        jnz     @f                   ; Just exit the resolution selection box
696
 
697
        mov     si, word [cursor_pos_old]
698
        mov     word [cursor_pos], si
699
        jmp     .esc_pressed
700
@@:
2288 clevermous 701
        cmp     ah, 0x48;x,0x48E0               ; up
702
        jne     .down
703
        cmp     si, modes_table
704
        jbe     .loops
705
        sub     word [cursor_pos], size_of_step
706
        jmp     .loops
707
 
708
.down:
709
        cmp     ah, 0x50;x,0x50E0               ; down
710
        jne     .pgup
711
        cmp     word[es:si+10], -1
712
        je      .loops
713
        add     word [cursor_pos], size_of_step
714
        jmp     .loops
715
 
716
.pgup:
717
        cmp     ah, 0x49                ; page up
718
        jne     .pgdn
719
        sub     si, size_of_step*long_v_table
720
        cmp     si, modes_table
721
        jae     @f
722
        mov     si, modes_table
723
@@:
724
        mov     word [cursor_pos], si
725
        mov     si, word [home_cursor]
726
        sub     si, size_of_step*long_v_table
727
        cmp     si, modes_table
728
        jae     @f
729
        mov     si, modes_table
730
@@:
731
        mov     word [home_cursor], si
732
        jmp     .loops
733
 
734
.pgdn:
735
        cmp     ah, 0x51                ; page down
736
        jne     .enter
737
        mov     ax, [end_cursor]
738
        add     si, size_of_step*long_v_table
739
        cmp     si, ax
740
        jb      @f
741
        mov     si, ax
742
        sub     si, size_of_step
743
@@:
744
        mov     word [cursor_pos], si
745
        mov     si, word [home_cursor]
746
        sub     ax, size_of_step*long_v_table
747
        add     si, size_of_step*long_v_table
748
        cmp     si, ax
749
        jb      @f
750
        mov     si, ax
751
@@:
752
        mov     word [home_cursor], si
753
        jmp     .loops
754
 
755
.enter:
756
        cmp     al, 0x0D;x,0x1C0D               ; enter
757
        jne     .loops
758
        push    word [cursor_pos]
759
        pop     bp
760
        push    word [es:bp]
761
        pop     word [x_save]
762
        push    word [es:bp+2]
763
        pop     word [y_save]
764
        push    word [es:bp+6]
765
        pop     word [number_vm]
766
        mov     word [preboot_graph], bp          ;save choose
767
 
768
        jmp     .d
769
 
3777 yogev_ezra 770
.change_b:                      ; b) preboot_biosdisk  = use BIOS disks through V86 emulation?
3989 yogev_ezra 771
;        _setcursor 16,0
3777 yogev_ezra 772
;        mov     si, ask_dma    // (earlier was: preboot_dma  = use DMA access?)
2288 clevermous 773
;        call    print
3796 yogev_ezra 774
;        mov     bx, '13'       ; range accepted for answer: 1-3
2288 clevermous 775
;        call    getkey
776
;        mov     [preboot_dma], al
3989 yogev_ezra 777
        _ask_question ask_bd,'12',preboot_biosdisk              ; range accepted for answer: 1-2
2288 clevermous 778
        _setcursor 11,0
779
        jmp     .d
3796 yogev_ezra 780
.change_c:                      ; c) preboot_debug = duplicates kernel debug output to the screen
3989 yogev_ezra 781
        _ask_question ask_debug,'12',preboot_debug              ; range accepted for answer: 1-2
3777 yogev_ezra 782
        _setcursor 12,0
783
        jmp     .d
3796 yogev_ezra 784
.change_d:                      ; d) preboot_launcher = start the first app (right now it's LAUNCHER) after kernel is loaded?
3989 yogev_ezra 785
        _ask_question ask_launcher,'12',preboot_launcher        ; range accepted for answer: 1-2
3777 yogev_ezra 786
        _setcursor 13,0
787
        jmp     .d
2288 clevermous 788
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
789
.say_on_off:
790
        pushf
791
        call    print
792
        mov     si, on_msg
793
        popf
794
        jz      @f
795
        mov     si, off_msg
796
@@:
797
        jmp     printplain
798
; novesa and vervesa strings are not used at the moment of executing this code
799
virtual at novesa
800
.oldtimer dd ?
801
.starttime dd ?
802
if ~ defined extended_primary_loader
803
.bSettingsChanged db ?
804
end if
805
.timer dd ?
806
end virtual
807
if ~ defined extended_primary_loader
808
.loader_block dd -1
809
end if
810
.gettime:
811
        mov     ah, 0
812
        int     1Ah
813
        xchg    ax, cx
814
        shl     eax, 10h
815
        xchg    ax, dx
816
        ret
817
.newtimer:
818
        push    ds
819
        push    cs
820
        pop     ds
821
        pushf
822
        call    [.oldtimer]
823
        pushad
824
        call    .gettime
825
        sub     eax, [.starttime]
826
if defined extended_primary_loader
827
        sub     ax, [preboot_timeout]
828
else
829
        sub     ax, 18*5
830
end if
831
        jae     .timergo
832
        neg     ax
833
        add     ax, 18-1
834
        mov     bx, 18
835
        xor     dx, dx
836
        div     bx
837
if lang eq ru
3539 clevermous 838
; подождите 5 секунд, 4/3/2 секунды, 1 секунду
2288 clevermous 839
        cmp     al, 5
840
        mov     cl, ' '
841
        jae     @f
842
        cmp     al, 1
3539 clevermous 843
        mov     cl, 0xE3 ; 'у' in cp866
2288 clevermous 844
        jz      @f
3539 clevermous 845
        mov     cl, 0xEB ; 'ы' in cp866
2288 clevermous 846
@@:
847
        mov     [time_str+9], cl
848
else if lang eq et
849
        cmp     al, 1
850
        ja      @f
3539 clevermous 851
        mov     byte [time_str+9], ' '
852
        mov     byte [time_str+10], ' '
2288 clevermous 853
@@:
3274 esevece 854
else if lang eq sp
855
; esperar 5/4/3/2 segundos, 1 segundo
856
        cmp     al, 1
857
        mov     cl, 's'
858
        ja      @f
859
        mov     cl, ' '
860
@@:
861
        mov     [time_str+10], cl
2288 clevermous 862
else
863
; wait 5/4/3/2 seconds, 1 second
864
        cmp     al, 1
865
        mov     cl, 's'
866
        ja      @f
867
        mov     cl, ' '
868
@@:
869
        mov     [time_str+9], cl
870
end if
871
        add     al, '0'
872
        mov     [time_str+1], al
873
        mov     si, time_msg
874
        _setcursor 7,0
875
        call    print
876
        _setcursor 25,0
877
        popad
878
        pop     ds
879
        iret
880
.timergo:
881
        push    0
882
        pop     es
883
        mov     eax, [.oldtimer]
884
        mov     [es:8*4], eax
885
        mov     sp, 0EC00h
886
.continue:
887
        sti
888
        _setcursor 6,0
889
        mov     si, space_msg
890
        call    printplain
891
        call    printplain
892
        _setcursor 6,0
893
        mov     si, loading_msg
894
        call    print
3777 yogev_ezra 895
        _setcursor 16,0
2288 clevermous 896
if ~ defined extended_primary_loader
897
        cmp     [.bSettingsChanged], 0
898
        jz      .load
899
        cmp     [.loader_block], -1
900
        jz      .load
901
        les     bx, [.loader_block]
902
        mov     eax, [es:bx+3]
903
        push    ds
904
        pop     es
905
        test    eax, eax
906
        jz      .load
907
        push    eax
908
        mov     si, save_quest
909
        call    print
910
.waityn:
911
        mov     ah, 0
912
        int     16h
913
        or      al, 20h
914
        cmp     al, 'n'
915
        jz      .loadc
3430 esevece 916
        if lang eq sp
917
        cmp     al, 's'
918
        else
2288 clevermous 919
        cmp     al, 'y'
3430 esevece 920
        end if
2288 clevermous 921
        jnz     .waityn
922
        call    putchar
923
        mov     byte [space_msg+80], 186
924
 
925
        pop     eax
926
        push    cs
927
        push    .cont
928
        push    eax
929
        retf                          ;call back
930
.loadc:
931
        pop     eax
932
.cont:
933
        push    cs
934
        pop     ds
935
        mov     si, space_msg
936
        mov     byte [si+80], 0
3777 yogev_ezra 937
        _setcursor 16,0
2288 clevermous 938
        call    printplain
3777 yogev_ezra 939
        _setcursor 16,0
2288 clevermous 940
.load:
941
end if
942
; \end{diamond}[02.12.2005]
943
 
944
; ASK GRAPHICS MODE
945
 
946
        call    set_vmode
947
 
948
; GRAPHICS ACCELERATION
949
; force yes
2466 Serge 950
        mov     [es:BOOT_MTRR], byte 1
2288 clevermous 951
 
952
; DMA ACCESS TO HD
953
 
954
        mov     al, [preboot_dma]
2466 Serge 955
        mov     [es:BOOT_DMA], al
2288 clevermous 956
 
3777 yogev_ezra 957
; Set kernel DEBUG mode - if nonzero, duplicates debug output to the screen.
958
        mov     al, [preboot_debug]
959
        mov     [es:BOOT_DEBUG_PRINT], al       ;// 0x901E
960
 
961
; Start the first app (right now it's LAUNCHER) after kernel is loaded?
962
        mov     al, [preboot_launcher]
963
        mov     [es:BOOT_LAUNCHER_START], al    ;// 0x901D
964
 
2288 clevermous 965
; BOOT DEVICE
966
 
967
        mov     al, [preboot_device]
968
        dec     al
969
        mov     [boot_dev], al
970
 
971
; GET MEMORY MAP
972
include '../detect/biosmem.inc'
973
 
974
; READ DISKETTE TO MEMORY
975
 
976
        cmp     [boot_dev], 0
977
        jne     no_sys_on_floppy
978
        mov     si, diskload
979
        call    print
980
        xor     ax, ax            ; reset drive
981
        xor     dx, dx
982
        int     0x13
983
; do we boot from CD-ROM?
984
        mov     ah, 41h
985
        mov     bx, 55AAh
986
        xor     dx, dx
987
        int     0x13
988
        jc      .nocd
989
        cmp     bx, 0AA55h
990
        jnz     .nocd
991
        mov     ah, 48h
992
        push    ds
993
        push    es
994
        pop     ds
995
        mov     si, 0xa000
996
        mov     word [si], 30
997
        int     0x13
998
        pop     ds
999
        jc      .nocd
1000
        push    ds
1001
        lds     si, [es:si+26]
1002
        test    byte [ds:si+10], 40h
1003
        pop     ds
1004
        jz      .nocd
1005
; yes - read all floppy by 18 sectors
1006
 
1007
; TODO: !!!! read only first sector and set variables !!!!!
1008
; ...
1009
; TODO: !!! then read flippy image track by track
1010
 
1011
        mov     cx, 0x0001      ; startcyl,startsector
1012
.a1:
1013
        push    cx dx
1014
        mov     al, 18
1015
        mov     bx, 0xa000
1016
        call    boot_read_floppy
1017
        mov     si, movedesc
1018
        push    es
1019
        push    ds
1020
        pop     es
1021
        mov     cx, 256*18
1022
        mov     ah, 0x87
1023
        int     0x15
1024
        pop     es
1025
        pop     dx cx
1026
        test    ah, ah
1027
        jnz     sayerr_floppy
1028
        add     dword [si+8*3+2], 512*18
1029
        inc     dh
1030
        cmp     dh, 2
1031
        jnz     .a1
1032
        mov     dh, 0
1033
        inc     ch
1034
        cmp     ch, 80
1035
        jae     ok_sys_on_floppy
1036
        pusha
1037
        mov     al, ch
1038
        shr     ch, 2
1039
        add     al, ch
1040
        aam
1041
        xchg    al, ah
1042
        add     ax, '00'
1043
        mov     si, pros
1044
        mov     [si], ax
1045
        call    printplain
1046
        popa
1047
        jmp     .a1
1048
.nocd:
1049
; no - read only used sectors from floppy
1050
; now load floppy image to memory
1051
; at first load boot sector and first FAT table
1052
 
1053
; read only first sector and fill variables
1054
        mov     cx, 0x0001      ; first logical sector
1055
        xor     dx, dx          ; head = 0, drive = 0 (a:)
1056
        mov     al, 1           ; read one sector
1057
        mov     bx, 0xB000      ; es:bx -> data area
1058
        call    boot_read_floppy
1059
; fill the necessary parameters to work with a floppy
1060
        mov     ax, word [es:bx+24]
1061
        mov     word [BPB_SecPerTrk], ax
1062
        mov     ax, word [es:bx+26]
1063
        mov     word [BPB_NumHeads], ax
1064
        mov     ax, word [es:bx+17]
1065
        mov     word [BPB_RootEntCnt], ax
1066
        mov     ax, word [es:bx+14]
1067
        mov     word [BPB_RsvdSecCnt], ax
1068
        mov     ax, word [es:bx+19]
1069
        mov     word [BPB_TotSec16], ax
1070
        mov     al, byte [es:bx+13]
1071
        mov     byte [BPB_SecPerClus], al
1072
        mov     al, byte [es:bx+16]
1073
        mov     byte [BPB_NumFATs], al
1074
; 18.11.2008
1075
        mov     ax, word [es:bx+22]
1076
        mov     word [BPB_FATSz16], ax
1077
        mov     cx, word [es:bx+11]
1078
        mov     word [BPB_BytsPerSec], cx
1079
 
1080
; count of clusters in FAT12 ((size_of_FAT*2)/3)
1081
;        mov     ax, word [BPB_FATSz16]
1082
;        mov     cx, word [BPB_BytsPerSec]
1083
;end  18.11.2008
1084
        xor     dx, dx
1085
        mul     cx
1086
        shl     ax, 1
1087
        mov     cx, 3
1088
        div     cx              ; now ax - number of clusters in FAT12
1089
        mov     word [end_of_FAT], ax
1090
 
1091
; load first FAT table
1092
        mov     cx, 0x0002      ; startcyl,startsector          ; TODO!!!!!
1093
        xor     dx, dx          ; starthead,drive
1094
        mov     al, byte [BPB_FATSz16]     ; no of sectors to read
1095
        add     bx, word [BPB_BytsPerSec]  ; es:bx -> data area
1096
        call    boot_read_floppy
1097
        mov     bx, 0xB000
1098
 
1099
; and copy them to extended memory
1100
        mov     si, movedesc
1101
        mov     [si+8*2+3], bh          ; from
1102
 
1103
        mov     ax, word [BPB_BytsPerSec]
1104
        shr     ax, 1                   ; words per sector
1105
        mov     cx, word [BPB_RsvdSecCnt]
1106
        add     cx, word [BPB_FATSz16]
1107
        mul     cx
1108
        push    ax                      ; save to stack count of words in boot+FAT
1109
        xchg    ax, cx
1110
 
1111
        push    es
1112
        push    ds
1113
        pop     es
1114
        mov     ah, 0x87
1115
        int     0x15
1116
        pop     es
1117
        test    ah, ah
1118
        jz      @f
1119
sayerr_floppy:
1120
        mov     dx, 0x3f2
1121
        mov     al, 0
1122
        out     dx, al
1123
sayerr_memmove:
1124
        mov     si, memmovefailed
1125
        jmp     sayerr_plain
1126
@@:
1127
        pop     ax                      ; restore from stack count of words in boot+FAT
1128
        shl     ax, 1                   ; make bytes count from count of words
1129
        and     eax, 0ffffh
1130
        add     dword [si+8*3+2], eax
1131
 
1132
; copy first FAT to second copy
1133
; TODO: BPB_NumFATs !!!!!
1134
        add     bx, word [BPB_BytsPerSec]       ; !!! TODO: may be need multiply by BPB_RsvdSecCnt !!!
1135
        mov     byte [si+8*2+3], bh     ; bx - begin of FAT
1136
 
1137
        mov     ax, word [BPB_BytsPerSec]
1138
        shr     ax, 1                   ; words per sector
1139
        mov     cx, word [BPB_FATSz16]
1140
        mul     cx
1141
        mov     cx, ax                  ; cx - count of words in FAT
1142
 
1143
        push    es
1144
        push    ds
1145
        pop     es
1146
        mov     ah, 0x87
1147
        int     0x15
1148
        pop     es
1149
        test    ah, ah
1150
        jnz     sayerr_floppy
1151
 
1152
        mov     ax, cx
1153
        shl     ax, 1
1154
        and     eax, 0ffffh             ; ax - count of bytes in FAT
1155
        add     dword [si+8*3+2], eax
1156
 
1157
; reading RootDir
1158
; TODO: BPB_NumFATs
1159
        add     bx, ax
1160
        add     bx, 100h
1161
        and     bx, 0ff00h                      ; bx - place in buffer to write RootDir
1162
        push    bx
1163
 
1164
        mov     bx, word [BPB_BytsPerSec]
1165
        shr     bx, 5                           ; divide bx by 32
1166
        mov     ax, word [BPB_RootEntCnt]
1167
        xor     dx, dx
1168
        div     bx
1169
        push    ax                              ; ax - count of RootDir sectors
1170
 
1171
        mov     ax, word [BPB_FATSz16]
1172
        xor     cx, cx
1173
        mov     cl, byte [BPB_NumFATs]
1174
        mul     cx
1175
        add     ax, word [BPB_RsvdSecCnt]       ; ax - first sector of RootDir
1176
 
1177
        mov     word [FirstDataSector], ax
1178
        pop     bx
1179
        push    bx
1180
        add     word [FirstDataSector], bx      ; Begin of data region of floppy
1181
 
1182
; read RootDir
1183
        call    conv_abs_to_THS
1184
        pop     ax
1185
        pop     bx                              ; place in buffer to write
1186
        push    ax
1187
        call    boot_read_floppy                ; read RootDir into buffer
1188
; copy RootDir
1189
        mov     byte [si+8*2+3], bh             ; from buffer
1190
        pop     ax                              ; ax = count of RootDir sectors
1191
        mov     cx, word [BPB_BytsPerSec]
1192
        mul     cx
1193
        shr     ax, 1
1194
        mov     cx, ax                          ; count of words to copy
1195
        push    es
1196
        push    ds
1197
        pop     es
1198
        mov     ah, 0x87
1199
        int     0x15
1200
        pop     es
1201
 
1202
        mov     ax, cx
1203
        shl     ax, 1
1204
        and     eax, 0ffffh             ; ax - count of bytes in RootDir
1205
        add     dword [si+8*3+2], eax   ; add count of bytes copied
1206
 
1207
; Reading data clusters from floppy
1208
        mov     byte [si+8*2+3], bh
1209
        push    bx
1210
 
1211
        mov     di, 2                   ; First data cluster
1212
.read_loop:
1213
        mov     bx, di
1214
        shr     bx, 1                   ; bx+di = di*1.5
1215
        jnc     .even
1216
        test    word [es:bx+di+0xB200], 0xFFF0  ; TODO: may not be 0xB200 !!!
1217
        jmp     @f
1218
.even:
1219
        test    word [es:bx+di+0xB200], 0xFFF   ; TODO: may not be 0xB200 !!!
1220
 
1221
@@:
1222
        jz      .skip
1223
; read cluster di
1224
;.read:
1225
        ;conv cluster di to abs. sector ax
1226
        ; ax = (N-2) * BPB_SecPerClus + FirstDataSector
1227
        mov     ax, di
1228
        sub     ax, 2
1229
        xor     bx, bx
1230
        mov     bl, byte [BPB_SecPerClus]
1231
        mul     bx
1232
        add     ax, word [FirstDataSector]
1233
        call    conv_abs_to_THS
1234
        pop     bx
1235
        push    bx
1236
        mov     al, byte [BPB_SecPerClus]       ; number of sectors in cluster
1237
        call    boot_read_floppy
1238
        push    es
1239
        push    ds
1240
        pop     es
1241
        pusha
1242
;
1243
        mov     ax, word [BPB_BytsPerSec]
1244
        xor     cx, cx
1245
        mov     cl, byte [BPB_SecPerClus]
1246
        mul     cx
1247
        shr     ax, 1                           ; ax = (BPB_BytsPerSec * BPB_SecPerClus)/2
1248
        mov     cx, ax                          ; number of words to copy (count words in cluster)
1249
;
1250
        mov     ah, 0x87
1251
        int     0x15                            ; copy data
1252
        test    ah, ah
1253
        popa
1254
        pop     es
1255
        jnz     sayerr_floppy
1256
; skip cluster di
1257
.skip:
1258
        mov     ax, word [BPB_BytsPerSec]
1259
        xor     cx, cx
1260
        mov     cl, byte [BPB_SecPerClus]
1261
        mul     cx
1262
        and     eax, 0ffffh             ; ax - count of bytes in cluster
1263
        add     dword [si+8*3+2], eax
1264
 
1265
        mov     ax, word [end_of_FAT]   ; max cluster number
1266
        pusha
1267
; draw percentage
1268
; total clusters: ax
1269
; read clusters: di
1270
        xchg    ax, di
1271
        mov     cx, 100
1272
        mul     cx
1273
        div     di
1274
        aam
1275
        xchg    al, ah
1276
        add     ax, '00'
1277
        mov     si, pros
1278
        cmp     [si], ax
1279
        jz      @f
1280
        mov     [si], ax
1281
        call    printplain
1282
@@:
1283
        popa
1284
        inc     di
1285
        cmp     di, word [end_of_FAT]   ; max number of cluster
1286
        jnz     .read_loop
1287
        pop     bx                      ; clear stack
1288
 
1289
ok_sys_on_floppy:
1290
        mov     si, backspace2
1291
        call    printplain
1292
        mov     si, okt
1293
        call    printplain
1294
no_sys_on_floppy:
1295
        xor     ax, ax          ; reset drive
1296
        xor     dx, dx
1297
        int     0x13
1298
        mov     dx, 0x3f2       ; floppy motor off
1299
        mov     al, 0
1300
        out     dx, al
1301
 
1302
if defined extended_primary_loader
1303
        cmp     [boot_dev], 1
1304
        jne     no_sys_from_primary
1305
; load kolibri.img using callback from primary loader
1306
        and     word [movedesc + 24 + 2], 0
1307
        mov     byte [movedesc + 24 + 4], 10h
1308
; read in blocks of 64K until file is fully loaded
1309
        mov     ax, 1
1310
.repeat:
1311
        mov     di, image_file_struct
1312
        call    [bootcallback]
1313
        push    cs
1314
        pop     ds
1315
        push    cs
1316
        pop     es
1317
        cmp     bx, 1
1318
        ja      sayerr_badsect
1319
        push    bx
1320
        mov     si, movedesc
1321
        and     word [si + 16 + 2], 0
1322
        mov     byte [si + 16 + 4], 4
1323
        mov     ah, 87h
1324
        mov     cx, 8000h
1325
        int     15h
1326
        pop     bx
1327
        test    ah, ah
1328
        jnz     sayerr_memmove
1329
        inc     byte [si + 24 + 4]
1330
        test    bx, bx
1331
        jz      no_sys_from_primary
1332
        mov     ax, 2
1333
        jmp     .repeat
1334
no_sys_from_primary:
1335
end if
1336
 
1337
; SET GRAPHICS
1338
 
1339
        xor     ax, ax
1340
        mov     es, ax
1341
 
2466 Serge 1342
        mov     ax, [es:BOOT_VESA_MODE]         ; vga & 320x200
2288 clevermous 1343
        mov     bx, ax
1344
        cmp     ax, 0x13
1345
        je      setgr
1346
        cmp     ax, 0x12
1347
        je      setgr
1348
        mov     ax, 0x4f02              ; Vesa
1349
setgr:
1350
        int     0x10
1351
        test    ah, ah
1352
        mov     si, fatalsel
1353
        jnz     v_mode_error
1354
; set mode 0x12 graphics registers:
1355
        cmp     bx, 0x12
1356
        jne     gmok2
1357
 
1358
        mov     al, 0x05
1359
        mov     dx, 0x03ce
1360
        push    dx
1361
        out     dx, al      ; select GDC mode register
1362
        mov     al, 0x02
1363
        inc     dx
1364
        out     dx, al      ; set write mode 2
1365
 
1366
        mov     al, 0x02
1367
        mov     dx, 0x03c4
1368
        out     dx, al      ; select VGA sequencer map mask register
1369
        mov     al, 0x0f
1370
        inc     dx
1371
        out     dx, al      ; set mask for all planes 0-3
1372
 
1373
        mov     al, 0x08
1374
        pop     dx
1375
        out     dx, al      ; select GDC bit mask register
1376
                           ; for writes to 0x03cf
1377
gmok2:
1378
        push    ds
1379
        pop     es