Subversion Repositories Kolibri OS

Rev

Rev 4923 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
  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: 4291 $
  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:                         ; Use BIOS INT 16h to read a key from the keyboard
  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       ; 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.
  63.         call    putchar
  64.         pop     ax
  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'
  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.  
  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.  
  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.  
  162. include 'bootvesa.inc'                 ;Include source for boot vesa
  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
  179.         mov     ax, 3000h
  180.         mov     ss, ax
  181.         mov     sp, 0EC00h
  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
  296.         mov     ax, 3000h
  297.         mov     ss, ax
  298.         mov     sp, 0EC00h
  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
  403.  
  404.         xor     cx, cx
  405. @@:
  406.         in      al, 64h
  407.         test    al, 2
  408.         loopnz  @b
  409.  
  410.         mov     al, 0xf6        ; Сброс клавиатуры, разрешить сканирование
  411.         out     0x60, al
  412.         xor     cx, cx
  413. @@:
  414.         in      al, 64h
  415.         test    al, 1
  416.         loopz   @b
  417.         in      al, 0x60
  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
  426.         test    al, 1
  427.         loopz   @b
  428.         in      al, 0x60
  429.         mov     al, 0
  430.         out     0x60, al
  431.         xor     cx, cx
  432. @@:
  433.         in      al, 64h
  434.         test    al, 1
  435.         loopz   @b
  436.         in      al, 0x60
  437. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  438.         sti
  439. ; --------------- APM ---------------------
  440.         and     word [es:BOOT_APM_VERSION], 0     ; ver = 0.0 (APM not found)
  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
  447.         mov     [es:BOOT_APM_VERSION], ax         ; Save APM Version
  448.         mov     [es:BOOT_APM_FLAGS], cx           ; Save APM flags
  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.  
  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
  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?
  498. ; b) preboot_biosdisk  = use BIOS disks through V86 emulation? // (earlier was: preboot_dma  = use DMA access?)
  499. ; c) preboot_debug = duplicates kernel debug output to the screen // (earlier was: preboot_vrrm = use VRR?)
  500. ;    // VRR is an obsolete functionality, used only with CRT monitors: increase display frequency by reducing screen resolution
  501. ; d) preboot_launcher = start the first app (right now it's LAUNCHER) after kernel is loaded?
  502. ; e) preboot_device = from where to boot?
  503.  
  504. ; determine default settings
  505. if ~ defined extended_primary_loader
  506.         mov     [.bSettingsChanged], 0
  507. end if
  508.  
  509. ;.preboot_gr_end:
  510.         mov     di, preboot_device
  511. ; if image in memory is present and [preboot_device] is uninitialized,
  512. ; set it to use this preloaded image
  513.         cmp     byte [di], 0
  514.         jnz     .preboot_device_inited
  515. if defined extended_primary_loader
  516.         inc     byte [di]
  517.         cmp     byte [bootdevice], 'f' ; floppy?
  518.         jz      .preboot_device_inited
  519.         inc     byte [di]
  520. else
  521.         cmp     [.loader_block], -1
  522.         jz      @f
  523.         les     bx, [.loader_block]
  524.         test    byte [es:bx+1], 1
  525.         jz      @f
  526.         mov     byte [di], 3
  527.         jmp     .preboot_device_inited
  528. @@:
  529. ; otherwise, set [preboot_device] to 1 (default value - boot from floppy)
  530.         mov     byte [di], 1
  531. end if
  532. .preboot_device_inited:
  533. ; following 4 lines set variables to 1 if its current value is 0
  534.         cmp     byte [di+preboot_dma-preboot_device], 1
  535.         adc     byte [di+preboot_dma-preboot_device], 0
  536.         cmp     byte [di+preboot_launcher-preboot_device], 1        ; Start LAUNCHER by default
  537.         adc     byte [di+preboot_launcher-preboot_device], 0
  538. ;        cmp     byte [di+preboot_biosdisk-preboot_device], 1
  539. ;        adc     byte [di+preboot_biosdisk-preboot_device], 0
  540. ;; default value for VRR is OFF
  541. ;        cmp     byte [di+preboot_vrrm-preboot_device], 0
  542. ;        jnz    @f
  543. ;        mov    byte [di+preboot_vrrm-preboot_device], 2
  544. ;@@:
  545. ; notify user
  546.         _setcursor 5,2
  547.  
  548.         mov     si, linef
  549.         call    printplain
  550.         mov     si, start_msg
  551.         call    print
  552.         mov     si, time_msg
  553.         call    print
  554. ; get start time
  555.         call    .gettime
  556.         mov     [.starttime], eax
  557.         mov     word [.timer], .newtimer
  558.         mov     word [.timer+2], cs
  559. .printcfg:
  560.  
  561.         _setcursor 9,0
  562.         mov     si, current_cfg_msg
  563.         call    print
  564.         mov     si, curvideo_msg
  565.         call    print
  566.  
  567.         call    draw_current_vmode
  568.  
  569.         mov     si, usebd_msg
  570.         cmp     [preboot_biosdisk], 1
  571.         call    .say_on_off
  572. ;        mov     si, vrrm_msg
  573. ;        cmp     [preboot_vrrm], 1
  574. ;        call    .say_on_off
  575.         mov     si, debug_mode_msg
  576.         cmp     [preboot_debug], 1
  577.         call    .say_on_off
  578.         mov     si, launcher_msg
  579.         cmp     [preboot_launcher], 1
  580.         call    .say_on_off
  581.         mov     si, preboot_device_msg
  582.         call    print
  583.         mov     al, [preboot_device]
  584. if defined extended_primary_loader
  585.         and     eax, 3
  586. else
  587.         and     eax, 7
  588. end if
  589.         mov     si, [preboot_device_msgs+eax*2]
  590.         call    printplain
  591. .show_remarks:
  592. ; show remarks in gray color
  593.         mov     di, ((21-num_remarks)*80 + 2)*2
  594.         push    0xB800
  595.         pop     es
  596.         mov     cx, num_remarks
  597.         mov     si, remarks
  598. .write_remarks:
  599.         lodsw
  600.         push    si
  601.         xchg    ax, si
  602.         mov     ah, 1*16+7      ; background: blue (1), foreground: gray (7)
  603.         push    di
  604. .write_remark:
  605.         lodsb
  606.         test    al, al
  607.         jz      @f
  608.         stosw
  609.         jmp     .write_remark
  610. @@:
  611.         pop     di
  612.         pop     si
  613.         add     di, 80*2
  614.         loop    .write_remarks
  615. .wait:
  616.         _setcursor 25,0         ; out of screen
  617. ; set timer interrupt handler
  618.         cli
  619.         push    0
  620.         pop     es
  621.         push    dword [es:8*4]
  622.         pop     dword [.oldtimer]
  623.         push    dword [.timer]
  624.         pop     dword [es:8*4]
  625. ;        mov     eax, [es:8*4]
  626. ;        mov     [.oldtimer], eax
  627. ;        mov     eax, [.timer]
  628. ;        mov     [es:8*4], eax
  629.         sti
  630. ; wait for keypressed
  631.         xor     ax, ax
  632.         int     16h
  633.         push    ax
  634. ; restore timer interrupt
  635. ;        push    0
  636. ;        pop     es
  637.         mov     eax, [.oldtimer]
  638.         mov     [es:8*4], eax
  639.         mov     [.timer], eax
  640.  
  641.         _setcursor 7,0
  642.         mov     si, space_msg
  643.         call    printplain
  644. ; clear remarks and restore normal attributes
  645.         push    es
  646.         mov     di, ((21-num_remarks)*80 + 2)*2
  647.         push    0xB800
  648.         pop     es
  649.         mov     cx, num_remarks
  650.         mov     ax, ' ' + (1*16 + 15)*100h
  651. @@:
  652.         push    cx
  653.         mov     cx, 76
  654.         rep stosw
  655.         pop     cx
  656.         add     di, 4*2
  657.         loop    @b
  658.         pop     es
  659.         pop     ax
  660. ; switch on key
  661.         cmp     al, 13
  662.         jz      .continue
  663.         or      al, 20h
  664.         cmp     al, 'a'         ; select graphical mode
  665.         jz      .change_a
  666.         cmp     al, 'q'         ; Trick to make 'A' key on azerty keyboard work
  667.         je      .change_a
  668.         cmp     al, 'b'         ; use BIOS disks? // (selecting YES will make BIOS disks visible as /bd)
  669.         jz      .change_b
  670.         cmp     al, 'c'         ; load kernel in debug mode?  // (earlier was: use VRR?)
  671.         jz      .change_c
  672.         cmp     al, 'd'         ; start launcher after kernel is loaded?
  673.         jz      .change_d
  674.         cmp     al, 'e'         ; select boot origin
  675.         jnz     .show_remarks
  676. ; e) preboot_device = from where to boot?
  677. if defined extended_primary_loader
  678.         _ask_question bdev,'12',preboot_device              ; range accepted for answer: 1-2
  679. else
  680.         _ask_question bdev,'14',preboot_device              ; range accepted for answer: 1-4
  681. end if
  682.         _setcursor 14,0
  683.  
  684. .d:
  685. if ~ defined extended_primary_loader
  686.         mov     [.bSettingsChanged], 1
  687. end if
  688. .esc_pressed:
  689.         call    clear_vmodes_table             ;clear vmodes_table
  690.         jmp     .printcfg
  691.  
  692. .change_a:
  693.         call    clear_vmodes_table             ;clear vmodes_table
  694.  
  695.         mov     si, word [cursor_pos]
  696.         mov     word [cursor_pos_old], si
  697. .loops:
  698.         call    draw_vmodes_table
  699.         _setcursor 25,0         ; out of screen
  700.         xor     ax, ax
  701.         int     0x16
  702. ;        call    clear_table_cursor             ;clear current position of cursor
  703.  
  704.         mov     si, word [cursor_pos]
  705.  
  706.         cmp     al, 27              ; If ESC was pressed, do not change the value
  707.         jnz     @f                   ; Just exit the resolution selection box
  708.  
  709.         mov     si, word [cursor_pos_old]
  710.         mov     word [cursor_pos], si
  711.         jmp     .esc_pressed
  712. @@:
  713.         cmp     ah, 0x48;x,0x48E0               ; up
  714.         jne     .down
  715.         cmp     si, modes_table
  716.         jbe     .loops
  717.         sub     word [cursor_pos], size_of_step
  718.         jmp     .loops
  719.  
  720. .down:
  721.         cmp     ah, 0x50;x,0x50E0               ; down
  722.         jne     .pgup
  723.         cmp     word[es:si+10], -1
  724.         je      .loops
  725.         add     word [cursor_pos], size_of_step
  726.         jmp     .loops
  727.  
  728. .pgup:
  729.         cmp     ah, 0x49                ; page up
  730.         jne     .pgdn
  731.         sub     si, size_of_step*long_v_table
  732.         cmp     si, modes_table
  733.         jae     @f
  734.         mov     si, modes_table
  735. @@:
  736.         mov     word [cursor_pos], si
  737.         mov     si, word [home_cursor]
  738.         sub     si, size_of_step*long_v_table
  739.         cmp     si, modes_table
  740.         jae     @f
  741.         mov     si, modes_table
  742. @@:
  743.         mov     word [home_cursor], si
  744.         jmp     .loops
  745.  
  746. .pgdn:
  747.         cmp     ah, 0x51                ; page down
  748.         jne     .enter
  749.         mov     ax, [end_cursor]
  750.         add     si, size_of_step*long_v_table
  751.         cmp     si, ax
  752.         jb      @f
  753.         mov     si, ax
  754.         sub     si, size_of_step
  755. @@:
  756.         mov     word [cursor_pos], si
  757.         mov     si, word [home_cursor]
  758.         sub     ax, size_of_step*long_v_table
  759.         add     si, size_of_step*long_v_table
  760.         cmp     si, ax
  761.         jb      @f
  762.         mov     si, ax
  763. @@:
  764.         mov     word [home_cursor], si
  765.         jmp     .loops
  766.  
  767. .enter:
  768.         cmp     al, 0x0D;x,0x1C0D               ; enter
  769.         jne     .loops
  770.         push    word [cursor_pos]
  771.         pop     bp
  772.         push    word [es:bp]
  773.         pop     word [x_save]
  774.         push    word [es:bp+2]
  775.         pop     word [y_save]
  776.         push    word [es:bp+6]
  777.         pop     word [number_vm]
  778.         mov     word [preboot_graph], bp          ;save choose
  779.  
  780.         jmp     .d
  781.  
  782. .change_b:                      ; b) preboot_biosdisk  = use BIOS disks through V86 emulation?
  783. ;        _setcursor 16,0
  784. ;        mov     si, ask_dma    // (earlier was: preboot_dma  = use DMA access?)
  785. ;        call    print
  786. ;        mov     bx, '13'       ; range accepted for answer: 1-3
  787. ;        call    getkey
  788. ;        mov     [preboot_dma], al
  789.         _ask_question ask_bd,'12',preboot_biosdisk              ; range accepted for answer: 1-2
  790.         _setcursor 11,0
  791.         jmp     .d
  792. ;.change_c:                     ; //  VRR is an obsolete functionality, used only with CRT monitors
  793. ;        _setcursor 16,0
  794. ;        mov     si, vrrmprint
  795. ;        call    print
  796. ;        mov     bx, '12'       ; range accepted for answer: 1-2
  797. ;        call    getkey
  798. ;        mov     [preboot_vrrm], al
  799. ;        _setcursor 12,0
  800. ;        jmp     .d
  801. .change_c:                      ; c) preboot_debug = duplicates kernel debug output to the screen
  802.         _ask_question ask_debug,'12',preboot_debug              ; range accepted for answer: 1-2
  803.         _setcursor 12,0
  804.         jmp     .d
  805. .change_d:                      ; d) preboot_launcher = start the first app (right now it's LAUNCHER) after kernel is loaded?
  806.         _ask_question ask_launcher,'12',preboot_launcher        ; range accepted for answer: 1-2
  807.         _setcursor 13,0
  808.         jmp     .d
  809. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  810. .say_on_off:
  811.         pushf
  812.         call    print
  813.         mov     si, on_msg
  814.         popf
  815.         jz      @f
  816.         mov     si, off_msg
  817. @@:
  818.         jmp     printplain
  819. ; novesa and vervesa strings are not used at the moment of executing this code
  820. virtual at novesa
  821. .oldtimer dd ?
  822. .starttime dd ?
  823. if ~ defined extended_primary_loader
  824. .bSettingsChanged db ?
  825. end if
  826. .timer dd ?
  827. end virtual
  828. if ~ defined extended_primary_loader
  829. .loader_block dd -1
  830. end if
  831. .gettime:
  832.         mov     ah, 0
  833.         int     1Ah
  834.         xchg    ax, cx
  835.         shl     eax, 10h
  836.         xchg    ax, dx
  837.         ret
  838. .newtimer:
  839.         push    ds
  840.         push    cs
  841.         pop     ds
  842.         pushf
  843.         call    [.oldtimer]
  844.         pushad
  845.         call    .gettime
  846.         sub     eax, [.starttime]
  847. if defined extended_primary_loader
  848.         sub     ax, [preboot_timeout]
  849. else
  850.         sub     ax, 18*5
  851. end if
  852.         jae     .timergo
  853.         neg     ax
  854.         add     ax, 18-1
  855.         mov     bx, 18
  856.         xor     dx, dx
  857.         div     bx
  858. if lang eq ru
  859. ; подождите 5 секунд, 4/3/2 секунды, 1 секунду
  860.         cmp     al, 5
  861.         mov     cl, ' '
  862.         jae     @f
  863.         cmp     al, 1
  864.         mov     cl, 0xE3 ; 'у' in cp866
  865.         jz      @f
  866.         mov     cl, 0xEB ; 'ы' in cp866
  867. @@:
  868.         mov     [time_str+9], cl
  869. else if lang eq et
  870.         cmp     al, 1
  871.         ja      @f
  872.         mov     byte [time_str+9], ' '
  873.         mov     byte [time_str+10], ' '
  874. @@:
  875. else if lang eq sp
  876. ; esperar 5/4/3/2 segundos, 1 segundo
  877.         cmp     al, 1
  878.         mov     cl, 's'
  879.         ja      @f
  880.         mov     cl, ' '
  881. @@:
  882.         mov     [time_str+10], cl
  883. else
  884. ; wait 5/4/3/2 seconds, 1 second
  885.         cmp     al, 1
  886.         mov     cl, 's'
  887.         ja      @f
  888.         mov     cl, ' '
  889. @@:
  890.         mov     [time_str+9], cl
  891. end if
  892.         add     al, '0'
  893.         mov     [time_str+1], al
  894.         mov     si, time_msg
  895.         _setcursor 7,0
  896.         call    print
  897.         _setcursor 25,0
  898.         popad
  899.         pop     ds
  900.         iret
  901. .timergo:
  902.         push    0
  903.         pop     es
  904.         mov     eax, [.oldtimer]
  905.         mov     [es:8*4], eax
  906.         mov     sp, 0EC00h
  907. .continue:
  908.         sti
  909.         _setcursor 6,0
  910.         mov     si, space_msg
  911.         call    printplain
  912.         call    printplain
  913.         _setcursor 6,0
  914.         mov     si, loading_msg
  915.         call    print
  916.         _setcursor 16,0
  917. if ~ defined extended_primary_loader
  918.         cmp     [.bSettingsChanged], 0
  919.         jz      .load
  920.         cmp     [.loader_block], -1
  921.         jz      .load
  922.         les     bx, [.loader_block]
  923.         mov     eax, [es:bx+3]
  924.         push    ds
  925.         pop     es
  926.         test    eax, eax
  927.         jz      .load
  928.         push    eax
  929.         mov     si, save_quest
  930.         call    print
  931. .waityn:
  932.         mov     ah, 0
  933.         int     16h
  934.         or      al, 20h
  935.         cmp     al, 'n'
  936.         jz      .loadc
  937.         if lang eq sp
  938.         cmp     al, 's'
  939.         else
  940.         cmp     al, 'y'
  941.         end if
  942.         jnz     .waityn
  943.         call    putchar
  944.         mov     byte [space_msg+80], 186
  945.  
  946.         pop     eax
  947.         push    cs
  948.         push    .cont
  949.         push    eax
  950.         retf                          ;call back
  951. .loadc:
  952.         pop     eax
  953. .cont:
  954.         push    cs
  955.         pop     ds
  956.         mov     si, space_msg
  957.         mov     byte [si+80], 0
  958.         _setcursor 16,0
  959.         call    printplain
  960.         _setcursor 16,0
  961. .load:
  962. end if
  963. ; \end{diamond}[02.12.2005]
  964.  
  965. ; ASK GRAPHICS MODE
  966.  
  967.         call    set_vmode
  968.  
  969. ; GRAPHICS ACCELERATION
  970. ; force yes
  971.         mov     [es:BOOT_MTRR], byte 1
  972.  
  973. ; DMA ACCESS TO HD
  974.  
  975.         mov     al, [preboot_dma]
  976.         mov     [es:BOOT_DMA], al
  977.  
  978. ;; VRR_M USE
  979. ;
  980. ;        mov     al,[preboot_vrrm]
  981. ;        mov     [es:BOOT_VRR], al              ;// 0x9030
  982.  
  983. ; Set kernel DEBUG mode - if nonzero, duplicates debug output to the screen.
  984.         mov     al, [preboot_debug]
  985.         mov     [es:BOOT_DEBUG_PRINT], al       ;// 0x901E
  986.  
  987. ; Start the first app (right now it's LAUNCHER) after kernel is loaded?
  988.         mov     al, [preboot_launcher]
  989.         mov     [es:BOOT_LAUNCHER_START], al    ;// 0x901D
  990.  
  991. ; BOOT DEVICE
  992.  
  993.         mov     al, [preboot_device]
  994.         dec     al
  995.         mov     [boot_dev], al
  996.  
  997. ; GET MEMORY MAP
  998. include '../detect/biosmem.inc'
  999.  
  1000. ; READ DISKETTE TO MEMORY
  1001.  
  1002.         cmp     [boot_dev], 0
  1003.         jne     no_sys_on_floppy
  1004.         mov     si, diskload
  1005.         call    print
  1006.         xor     ax, ax            ; reset drive
  1007.         xor     dx, dx
  1008.         int     0x13
  1009. ; do we boot from CD-ROM?
  1010.         mov     ah, 41h
  1011.         mov     bx, 55AAh
  1012.         xor     dx, dx
  1013.         int     0x13
  1014.         jc      .nocd
  1015.         cmp     bx, 0AA55h
  1016.         jnz     .nocd
  1017.         mov     ah, 48h
  1018.         push    ds
  1019.         push    es
  1020.         pop     ds
  1021.         mov     si, 0xa000
  1022.         mov     word [si], 30
  1023.         int     0x13
  1024.         pop     ds
  1025.         jc      .nocd
  1026.         push    ds
  1027.         lds     si, [es:si+26]
  1028.         test    byte [ds:si+10], 40h
  1029.         pop     ds
  1030.         jz      .nocd
  1031. ; yes - read all floppy by 18 sectors
  1032.  
  1033. ; TODO: !!!! read only first sector and set variables !!!!!
  1034. ; ...
  1035. ; TODO: !!! then read flippy image track by track
  1036.  
  1037.         mov     cx, 0x0001      ; startcyl,startsector
  1038. .a1:
  1039.         push    cx dx
  1040.         mov     al, 18
  1041.         mov     bx, 0xa000
  1042.         call    boot_read_floppy
  1043.         mov     si, movedesc
  1044.         push    es
  1045.         push    ds
  1046.         pop     es
  1047.         mov     cx, 256*18
  1048.         mov     ah, 0x87
  1049.         int     0x15
  1050.         pop     es
  1051.         pop     dx cx
  1052.         test    ah, ah
  1053.         jnz     sayerr_floppy
  1054.         add     dword [si+8*3+2], 512*18
  1055.         inc     dh
  1056.         cmp     dh, 2
  1057.         jnz     .a1
  1058.         mov     dh, 0
  1059.         inc     ch
  1060.         cmp     ch, 80
  1061.         jae     ok_sys_on_floppy
  1062.         pusha
  1063.         mov     al, ch
  1064.         shr     ch, 2
  1065.         add     al, ch
  1066.         aam
  1067.         xchg    al, ah
  1068.         add     ax, '00'
  1069.         mov     si, pros
  1070.         mov     [si], ax
  1071.         call    printplain
  1072.         popa
  1073.         jmp     .a1
  1074. .nocd:
  1075. ; no - read only used sectors from floppy
  1076. ; now load floppy image to memory
  1077. ; at first load boot sector and first FAT table
  1078.  
  1079. ; read only first sector and fill variables
  1080.         mov     cx, 0x0001      ; first logical sector
  1081.         xor     dx, dx          ; head = 0, drive = 0 (a:)
  1082.         mov     al, 1           ; read one sector
  1083.         mov     bx, 0xB000      ; es:bx -> data area
  1084.         call    boot_read_floppy
  1085. ; fill the necessary parameters to work with a floppy
  1086.         mov     ax, word [es:bx+24]
  1087.         mov     word [BPB_SecPerTrk], ax
  1088.         mov     ax, word [es:bx+26]
  1089.         mov     word [BPB_NumHeads], ax
  1090.         mov     ax, word [es:bx+17]
  1091.         mov     word [BPB_RootEntCnt], ax
  1092.         mov     ax, word [es:bx+14]
  1093.         mov     word [BPB_RsvdSecCnt], ax
  1094.         mov     ax, word [es:bx+19]
  1095.         mov     word [BPB_TotSec16], ax
  1096.         mov     al, byte [es:bx+13]
  1097.         mov     byte [BPB_SecPerClus], al
  1098.         mov     al, byte [es:bx+16]
  1099.         mov     byte [BPB_NumFATs], al
  1100. ;<Lrz> 18.11.2008
  1101.         mov     ax, word [es:bx+22]
  1102.         mov     word [BPB_FATSz16], ax
  1103.         mov     cx, word [es:bx+11]
  1104.         mov     word [BPB_BytsPerSec], cx
  1105.  
  1106. ; count of clusters in FAT12 ((size_of_FAT*2)/3)
  1107. ;        mov     ax, word [BPB_FATSz16]
  1108. ;        mov     cx, word [BPB_BytsPerSec]
  1109. ;end <Lrz> 18.11.2008
  1110.         xor     dx, dx
  1111.         mul     cx
  1112.         shl     ax, 1
  1113.         mov     cx, 3
  1114.         div     cx              ; now ax - number of clusters in FAT12
  1115.         mov     word [end_of_FAT], ax
  1116.  
  1117. ; load first FAT table
  1118.         mov     cx, 0x0002      ; startcyl,startsector          ; TODO!!!!!
  1119.         xor     dx, dx          ; starthead,drive
  1120.         mov     al, byte [BPB_FATSz16]     ; no of sectors to read
  1121.         add     bx, word [BPB_BytsPerSec]  ; es:bx -> data area
  1122.         call    boot_read_floppy
  1123.         mov     bx, 0xB000
  1124.  
  1125. ; and copy them to extended memory
  1126.         mov     si, movedesc
  1127.         mov     [si+8*2+3], bh          ; from
  1128.  
  1129.         mov     ax, word [BPB_BytsPerSec]
  1130.         shr     ax, 1                   ; words per sector
  1131.         mov     cx, word [BPB_RsvdSecCnt]
  1132.         add     cx, word [BPB_FATSz16]
  1133.         mul     cx
  1134.         push    ax                      ; save to stack count of words in boot+FAT
  1135.         xchg    ax, cx
  1136.  
  1137.         push    es
  1138.         push    ds
  1139.         pop     es
  1140.         mov     ah, 0x87
  1141.         int     0x15
  1142.         pop     es
  1143.         test    ah, ah
  1144.         jz      @f
  1145. sayerr_floppy:
  1146.         mov     dx, 0x3f2
  1147.         mov     al, 0
  1148.         out     dx, al
  1149. sayerr_memmove:
  1150.         mov     si, memmovefailed
  1151.         jmp     sayerr_plain
  1152. @@:
  1153.         pop     ax                      ; restore from stack count of words in boot+FAT
  1154.         shl     ax, 1                   ; make bytes count from count of words
  1155.         and     eax, 0ffffh
  1156.         add     dword [si+8*3+2], eax
  1157.  
  1158. ; copy first FAT to second copy
  1159. ; TODO: BPB_NumFATs !!!!!
  1160.         add     bx, word [BPB_BytsPerSec]       ; !!! TODO: may be need multiply by BPB_RsvdSecCnt !!!
  1161.         mov     byte [si+8*2+3], bh     ; bx - begin of FAT
  1162.  
  1163.         mov     ax, word [BPB_BytsPerSec]
  1164.         shr     ax, 1                   ; words per sector
  1165.         mov     cx, word [BPB_FATSz16]
  1166.         mul     cx
  1167.         mov     cx, ax                  ; cx - count of words in FAT
  1168.  
  1169.         push    es
  1170.         push    ds
  1171.         pop     es
  1172.         mov     ah, 0x87
  1173.         int     0x15
  1174.         pop     es
  1175.         test    ah, ah
  1176.         jnz     sayerr_floppy
  1177.  
  1178.         mov     ax, cx
  1179.         shl     ax, 1
  1180.         and     eax, 0ffffh             ; ax - count of bytes in FAT
  1181.         add     dword [si+8*3+2], eax
  1182.  
  1183. ; reading RootDir
  1184. ; TODO: BPB_NumFATs
  1185.         add     bx, ax
  1186.         add     bx, 100h
  1187.         and     bx, 0ff00h                      ; bx - place in buffer to write RootDir
  1188.         push    bx
  1189.  
  1190.         mov     bx, word [BPB_BytsPerSec]
  1191.         shr     bx, 5                           ; divide bx by 32
  1192.         mov     ax, word [BPB_RootEntCnt]
  1193.         xor     dx, dx
  1194.         div     bx
  1195.         push    ax                              ; ax - count of RootDir sectors
  1196.  
  1197.         mov     ax, word [BPB_FATSz16]
  1198.         xor     cx, cx
  1199.         mov     cl, byte [BPB_NumFATs]
  1200.         mul     cx
  1201.         add     ax, word [BPB_RsvdSecCnt]       ; ax - first sector of RootDir
  1202.  
  1203.         mov     word [FirstDataSector], ax
  1204.         pop     bx
  1205.         push    bx
  1206.         add     word [FirstDataSector], bx      ; Begin of data region of floppy
  1207.  
  1208. ; read RootDir
  1209.         call    conv_abs_to_THS
  1210.         pop     ax
  1211.         pop     bx                              ; place in buffer to write
  1212.         push    ax
  1213.         call    boot_read_floppy                ; read RootDir into buffer
  1214. ; copy RootDir
  1215.         mov     byte [si+8*2+3], bh             ; from buffer
  1216.         pop     ax                              ; ax = count of RootDir sectors
  1217.         mov     cx, word [BPB_BytsPerSec]
  1218.         mul     cx
  1219.         shr     ax, 1
  1220.         mov     cx, ax                          ; count of words to copy
  1221.         push    es
  1222.         push    ds
  1223.         pop     es
  1224.         mov     ah, 0x87
  1225.         int     0x15
  1226.         pop     es
  1227.  
  1228.         mov     ax, cx
  1229.         shl     ax, 1
  1230.         and     eax, 0ffffh             ; ax - count of bytes in RootDir
  1231.         add     dword [si+8*3+2], eax   ; add count of bytes copied
  1232.  
  1233. ; Reading data clusters from floppy
  1234.         mov     byte [si+8*2+3], bh
  1235.         push    bx
  1236.  
  1237.         mov     di, 2                   ; First data cluster
  1238. .read_loop:
  1239.         mov     bx, di
  1240.         shr     bx, 1                   ; bx+di = di*1.5
  1241.         jnc     .even
  1242.         test    word [es:bx+di+0xB200], 0xFFF0  ; TODO: may not be 0xB200 !!!
  1243.         jmp     @f
  1244. .even:
  1245.         test    word [es:bx+di+0xB200], 0xFFF   ; TODO: may not be 0xB200 !!!
  1246.  
  1247. @@:
  1248.         jz      .skip
  1249. ; read cluster di
  1250. ;.read:
  1251.         ;conv cluster di to abs. sector ax
  1252.         ; ax = (N-2) * BPB_SecPerClus + FirstDataSector
  1253.         mov     ax, di
  1254.         sub     ax, 2
  1255.         xor     bx, bx
  1256.         mov     bl, byte [BPB_SecPerClus]
  1257.         mul     bx
  1258.         add     ax, word [FirstDataSector]
  1259.         call    conv_abs_to_THS
  1260.         pop     bx
  1261.         push    bx
  1262.         mov     al, byte [BPB_SecPerClus]       ; number of sectors in cluster
  1263.         call    boot_read_floppy
  1264.         push    es
  1265.         push    ds
  1266.         pop     es
  1267.         pusha
  1268. ;
  1269.         mov     ax, word [BPB_BytsPerSec]
  1270.         xor     cx, cx
  1271.         mov     cl, byte [BPB_SecPerClus]
  1272.         mul     cx
  1273.         shr     ax, 1                           ; ax = (BPB_BytsPerSec * BPB_SecPerClus)/2
  1274.         mov     cx, ax                          ; number of words to copy (count words in cluster)
  1275. ;
  1276.         mov     ah, 0x87
  1277.         int     0x15                            ; copy data
  1278.         test    ah, ah
  1279.         popa
  1280.         pop     es
  1281.         jnz     sayerr_floppy
  1282. ; skip cluster di
  1283. .skip:
  1284.         mov     ax, word [BPB_BytsPerSec]
  1285.         xor     cx, cx
  1286.         mov     cl, byte [BPB_SecPerClus]
  1287.         mul     cx
  1288.         and     eax, 0ffffh             ; ax - count of bytes in cluster
  1289.         add     dword [si+8*3+2], eax
  1290.  
  1291.         mov     ax, word [end_of_FAT]   ; max cluster number
  1292.         pusha
  1293. ; draw percentage
  1294. ; total clusters: ax
  1295. ; read clusters: di
  1296.         xchg    ax, di
  1297.         mov     cx, 100
  1298.         mul     cx
  1299.         div     di
  1300.         aam
  1301.         xchg    al, ah
  1302.         add     ax, '00'
  1303.         mov     si, pros
  1304.         cmp     [si], ax
  1305.         jz      @f
  1306.         mov     [si], ax
  1307.         call    printplain
  1308. @@:
  1309.         popa
  1310.         inc     di
  1311.         cmp     di, word [end_of_FAT]   ; max number of cluster
  1312.         jnz     .read_loop
  1313.         pop     bx                      ; clear stack
  1314.  
  1315. ok_sys_on_floppy:
  1316.         mov     si, backspace2
  1317.         call    printplain
  1318.         mov     si, okt
  1319.         call    printplain
  1320. no_sys_on_floppy:
  1321.         xor     ax, ax          ; reset drive
  1322.         xor     dx, dx
  1323.         int     0x13
  1324.         mov     dx, 0x3f2       ; floppy motor off
  1325.         mov     al, 0
  1326.         out     dx, al
  1327.  
  1328. if defined extended_primary_loader
  1329.         cmp     [boot_dev], 1
  1330.         jne     no_sys_from_primary
  1331. ; load kolibri.img using callback from primary loader
  1332.         and     word [movedesc + 24 + 2], 0
  1333.         mov     byte [movedesc + 24 + 4], 10h
  1334. ; read in blocks of 64K until file is fully loaded
  1335.         mov     ax, 1
  1336. .repeat:
  1337.         mov     di, image_file_struct
  1338.         call    [bootcallback]
  1339.         push    cs
  1340.         pop     ds
  1341.         push    cs
  1342.         pop     es
  1343.         cmp     bx, 1
  1344.         ja      sayerr_badsect
  1345.         push    bx
  1346.         mov     si, movedesc
  1347.         and     word [si + 16 + 2], 0
  1348.         mov     byte [si + 16 + 4], 4
  1349.         mov     ah, 87h
  1350.         mov     cx, 8000h
  1351.         int     15h
  1352.         pop     bx
  1353.         test    ah, ah
  1354.         jnz     sayerr_memmove
  1355.         inc     byte [si + 24 + 4]
  1356.         test    bx, bx
  1357.         jz      no_sys_from_primary
  1358.         mov     ax, 2
  1359.         jmp     .repeat
  1360. no_sys_from_primary:
  1361. end if
  1362.  
  1363. ; SET GRAPHICS
  1364.  
  1365.         xor     ax, ax
  1366.         mov     es, ax
  1367.  
  1368.         mov     ax, [es:BOOT_VESA_MODE]         ; vga & 320x200
  1369.         mov     bx, ax
  1370.         cmp     ax, 0x13
  1371.         je      setgr
  1372.         cmp     ax, 0x12
  1373.         je      setgr
  1374.         mov     ax, 0x4f02              ; Vesa
  1375. setgr:
  1376.         int     0x10
  1377.         test    ah, ah
  1378.         mov     si, fatalsel
  1379.         jnz     v_mode_error
  1380. ; set mode 0x12 graphics registers:
  1381.         cmp     bx, 0x12
  1382.         jne     gmok2
  1383.  
  1384.         mov     al, 0x05
  1385.         mov     dx, 0x03ce
  1386.         push    dx
  1387.         out     dx, al      ; select GDC mode register
  1388.         mov     al, 0x02
  1389.         inc     dx
  1390.         out     dx, al      ; set write mode 2
  1391.  
  1392.         mov     al, 0x02
  1393.         mov     dx, 0x03c4
  1394.         out     dx, al      ; select VGA sequencer map mask register
  1395.         mov     al, 0x0f
  1396.         inc     dx
  1397.         out     dx, al      ; set mask for all planes 0-3
  1398.  
  1399.         mov     al, 0x08
  1400.         pop     dx
  1401.         out     dx, al      ; select GDC bit mask register
  1402.                            ; for writes to 0x03cf
  1403. gmok2:
  1404.         push    ds
  1405.         pop     es
  1406.  
  1407.         sidt    [cs:old_ints_h]
  1408.  
  1409.         cli                             ; disable all irqs
  1410.         mov     al, 255                 ; mask all irqs
  1411.         out     0xa1, al
  1412.         out     0x21, al
  1413.    l.5:
  1414.         in      al, 0x64                ; Enable A20
  1415.         test    al, 2
  1416.         jnz     l.5
  1417.         mov     al, 0xD1
  1418.         out     0x64, al
  1419.    l.6:
  1420.         in      al, 0x64
  1421.         test    al, 2
  1422.         jnz     l.6
  1423.         mov     al, 0xDF
  1424.         out     0x60, al
  1425.    l.7:
  1426.         in      al, 0x64
  1427.         test    al, 2
  1428.         jnz     l.7
  1429.         mov     al, 0xFF
  1430.         out     0x64, al
  1431.  
  1432.