Subversion Repositories Kolibri OS

Rev

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

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