kolibrios-fun/kernel/trunk/kernel.asm

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved.
;; PROGRAMMING:
;; Ivan Poddubny
;; Marat Zakiyanov (Mario79)
;; VaStaNi
;; Trans
;; Mihail Semenyako (mike.dld)
;; Sergey Kuzmin (Wildwest)
;; Andrey Halyavin (halyavin)
;; Mihail Lisovin (Mihasik)
;; Andrey Ignatiev (andrew_programmer)
;; NoName
;; Evgeny Grechnikov (Diamond)
;; Iliya Mihailov (Ghost)
;; Sergey Semyonov (Serge)
;; Johnny_B
;; SPraid (simba)
;; Hidnplayr
;; Alexey Teplov (<Lrz>)
;;
;; Data in this file was originally part of MenuetOS project which is
;; distributed under the terms of GNU GPL. It is modified and redistributed as
;; part of KolibriOS project under the terms of GNU GPL.
;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa
;; PROGRAMMING:
;;
;; Ville Mikael Turjanmaa, villemt@itu.jyu.fi
;; - main os coding/design
;; Jan-Michael Brummer, BUZZ2@gmx.de
;; Felix Kaiser, info@felix-kaiser.de
;; Paolo Minazzi, paolo.minazzi@inwind.it
;; quickcode@mail.ru
;; Alexey, kgaz@crosswinds.net
;; Juan M. Caravaca, bitrider@wanadoo.es
;; kristol@nic.fi
;; Mike Hibbett, mikeh@oceanfree.net
;; Lasse Kuusijarvi, kuusijar@lut.fi
;; Jarek Pelczar, jarekp3@wp.pl
;;
;; KolibriOS is distributed in the hope that it will be useful, but WITHOUT ANY
;; WARRANTY. No author or distributor accepts responsibility to anyone for the
;; consequences of using it or for whether it serves any particular purpose or
;; works at all, unless he says so in writing. Refer to the GNU General Public
;; License (the "GPL") for full details.
;
;; Everyone is granted permission to copy, modify and redistribute KolibriOS,
;; but only under the conditions described in the GPL. A copy of this license
;; is supposed to have been given to you along with KolibriOS so you can know
;; your rights and responsibilities. It should be in a file named COPYING.
;; Among other things, the copyright notice and this notice must be preserved
;; on all copies.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

include 'macros.inc'

$Revision$


USE_COM_IRQ	equ 1	   ; make irq 3 and irq 4 available for PCI devices

; Enabling the next line will enable serial output console
;debug_com_base  equ 0x3f8  ; 0x3f8 is com1, 0x2f8 is com2, 0x3e8 is com3, 0x2e8 is com4, no irq's are used

include "proc32.inc"
include "kglobals.inc"
include "lang.inc"

include "const.inc"
max_processes	 equ   255
tss_step	 equ   (128+8192) ; tss & i/o - 65535 ports, * 256=557056*4


os_stack       equ  (os_data_l-gdts)	; GDTs
os_code        equ  (os_code_l-gdts)
graph_data     equ  (3+graph_data_l-gdts)
tss0	       equ  (tss0_l-gdts)
app_code       equ  (3+app_code_l-gdts)
app_data       equ  (3+app_data_l-gdts)
app_tls        equ  (3+tls_data_l-gdts)
pci_code_sel   equ  (pci_code_32-gdts)
pci_data_sel   equ  (pci_data_32-gdts)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;   Included files:
;;
;;   Kernel16.inc
;;    - Booteng.inc   English text for bootup
;;    - Bootcode.inc  Hardware setup
;;    - Pci16.inc     PCI functions
;;
;;   Kernel32.inc
;;    - Sys32.inc     Process management
;;    - Shutdown.inc  Shutdown and restart
;;    - Fat32.inc     Read / write hd
;;    - Vesa12.inc    Vesa 1.2 driver
;;    - Vesa20.inc    Vesa 2.0 driver
;;    - Vga.inc       VGA driver
;;    - Stack.inc     Network interface
;;    - Mouse.inc     Mouse pointer
;;    - Scincode.inc  Window skinning
;;    - Pci32.inc     PCI functions
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                      ;;
;;                  16 BIT ENTRY FROM BOOTSECTOR                        ;;
;;                                                                      ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

use16
		  org	0x0
		  jmp	start_of_code

version db    'Kolibri OS  version 0.7.7.0+     ',13,10,13,10,0

include "boot/bootstr.inc"     ; language-independent boot messages
include "boot/preboot.inc"

if lang eq en
include "boot/booteng.inc"     ; english system boot messages
else if lang eq ru
include "boot/bootru.inc"      ; russian system boot messages
include "boot/ru.inc"	       ; Russian font
else if lang eq et
include "boot/bootet.inc"      ; estonian system boot messages
include "boot/et.inc"	       ; Estonian font
else
include "boot/bootge.inc"      ; german system boot messages
end if

include "boot/bootcode.inc"    ; 16 bit system boot code
include "bus/pci/pci16.inc"
include "detect/biosdisk.inc"

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                      ;;
;;                  SWITCH TO 32 BIT PROTECTED MODE                     ;;
;;                                                                      ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


; CR0 Flags - Protected mode and Paging

	mov ecx, CR0_PE

; Enabling 32 bit protected mode

	sidt	[cs:old_ints_h]

	cli				; disable all irqs
	cld
	mov	al,255			; mask all irqs
	out	0xa1,al
	out	0x21,al
   l.5: in	al, 0x64		; Enable A20
	test	al, 2
	jnz	l.5
	mov	al, 0xD1
	out	0x64, al
   l.6: in	al, 0x64
	test	al, 2
	jnz	l.6
	mov	al, 0xDF
	out	0x60, al
   l.7: in	al, 0x64
	test	al, 2
	jnz	l.7
	mov	al, 0xFF
	out	0x64, al

	lgdt	[cs:tmp_gdt]		; Load GDT
	mov	eax, cr0		; protected mode
	or	eax, ecx
	and	eax, 10011111b *65536*256 + 0xffffff ; caching enabled
	mov	cr0, eax
	jmp	pword os_code:B32	; jmp to enable 32 bit mode

align 8
tmp_gdt:

	dw     23
	dd     tmp_gdt+0x10000
	dw     0

	dw     0xffff
	dw     0x0000
	db     0x00
	dw     11011111b *256 +10011010b
	db     0x00

	dw     0xffff
	dw     0x0000
	db     0x00
	dw     11011111b *256 +10010010b
	db     0x00

include "data16.inc"

use32
org $+0x10000

align 4
B32:
	   mov	 ax,os_stack	   ; Selector for os
	   mov	 ds,ax
	   mov	 es,ax
	   mov	 fs,ax
	   mov	 gs,ax
	   mov	 ss,ax
	   mov	 esp,0x3ec00	   ; Set stack

; CLEAR 0x280000 - HEAP_BASE

	   xor	 eax,eax
	   mov	 edi,0x280000
	   mov	 ecx,(HEAP_BASE-OS_BASE-0x280000) / 4
	   cld
	   rep	 stosd

	   mov	 edi,0x40000
	   mov	 ecx,(0x90000-0x40000)/4
	   rep	 stosd

; CLEAR KERNEL UNDEFINED GLOBALS
	   mov	 edi, endofcode-OS_BASE
	   mov	 ecx, (uglobals_size/4)+4
	   rep	 stosd

; SAVE & CLEAR 0-0xffff

	   xor	 esi, esi
	   mov	 edi,0x2F0000
	   mov	 ecx,0x10000 / 4
	   rep	 movsd
	   mov	 edi,0x1000
	   mov	 ecx,0xf000 / 4
	   rep	 stosd

	   call test_cpu
	   bts [cpu_caps-OS_BASE], CAPS_TSC	;force use rdtsc

	   call init_BIOS32
; MEMORY MODEL
	   call mem_test
	   call init_mem
	   call init_page_map

; ENABLE PAGING

	   mov eax, sys_pgdir-OS_BASE
	   mov cr3, eax

	   mov eax,cr0
	   or eax,CR0_PG+CR0_WP
	   mov cr0,eax

	   lgdt [gdts]
	   jmp pword os_code:high_code

align 4
bios32_entry	dd ?
tmp_page_tabs	dd ?

use16
org $-0x10000
include "boot/shutdown.inc" ; shutdown or restart
org $+0x10000
use32

__DEBUG__ fix 1
__DEBUG_LEVEL__ fix 1
include 'init.inc'

org OS_BASE+$

align 4
high_code:
	   mov ax, os_stack
	   mov bx, app_data
	   mov cx, app_tls
	   mov ss, ax
	   add esp, OS_BASE

	   mov ds, bx
	   mov es, bx
	   mov fs, cx
	   mov gs, bx

	   bt [cpu_caps], CAPS_PGE
	   jnc @F

	   or dword [sys_pgdir+(OS_BASE shr 20)], PG_GLOBAL

	   mov ebx, cr4
	   or ebx, CR4_PGE
	   mov cr4, ebx
@@:
	   xor eax, eax
	   mov dword [sys_pgdir], eax
	   mov dword [sys_pgdir+4], eax

	   mov eax, cr3
	   mov cr3, eax 	  ; flush TLB

; SAVE REAL MODE VARIABLES
	mov	ax, [BOOT_VAR + 0x9031]
	mov	[IDEContrRegsBaseAddr], ax
; --------------- APM ---------------------

; init selectors
    mov ebx,[BOOT_VAR+0x9040]			; offset of APM entry point
    movzx eax,word [BOOT_VAR+0x9050]	; real-mode segment base address of
										; protected-mode 32-bit code segment
    movzx ecx,word [BOOT_VAR+0x9052]	; real-mode segment base address of
										; protected-mode 16-bit code segment
    movzx edx,word [BOOT_VAR+0x9054]	; real-mode segment base address of
										; protected-mode 16-bit data segment

    shl    eax, 4
    mov    [dword apm_code_32 + 2], ax
    shr    eax, 16
    mov    [dword apm_code_32 + 4], al

    shl    ecx, 4
    mov    [dword apm_code_16 + 2], cx
    shr    ecx, 16
    mov    [dword apm_code_16 + 4], cl

    shl    edx, 4
    mov    [dword apm_data_16 + 2], dx
    shr    edx, 16
    mov    [dword apm_data_16 + 4], dl

    mov    dword[apm_entry], ebx
    mov    word [apm_entry + 4], apm_code_32 - gdts

    mov    eax, [BOOT_VAR + 0x9044]    ; version & flags
    mov    [apm_vf], eax
; -----------------------------------------
;        movzx eax,byte [BOOT_VAR+0x9010]       ; mouse port
;        mov   [0xF604],byte 1  ;al
		mov	al, [BOOT_VAR+0x901F]		; DMA access
	mov	[allow_dma_access], al
	movzx eax, byte [BOOT_VAR+0x9000]	 ; bpp
	mov [ScreenBPP],al

	mov [_display.bpp], eax
	mov [_display.vrefresh], 60
	mov [_display.disable_mouse],  __sys_disable_mouse

	movzx eax,word [BOOT_VAR+0x900A]  ; X max
	mov [_display.width], eax
	dec   eax
	mov   [Screen_Max_X],eax
	mov   [screen_workarea.right],eax
	movzx eax,word [BOOT_VAR+0x900C]  ; Y max
	mov [_display.height], eax
	dec   eax
	mov   [Screen_Max_Y],eax
	mov   [screen_workarea.bottom],eax
	movzx eax,word [BOOT_VAR+0x9008]  ; screen mode
	mov   [SCR_MODE],eax
	mov   eax,[BOOT_VAR+0x9014]	  ; Vesa 1.2 bnk sw add
	mov   [BANK_SWITCH],eax
	mov   [BytesPerScanLine],word 640*4	    ; Bytes PerScanLine
	cmp   [SCR_MODE],word 0x13	    ; 320x200
	je    @f
	cmp   [SCR_MODE],word 0x12	    ; VGA 640x480
	je    @f
	movzx eax, word[BOOT_VAR+0x9001]	; for other modes
	mov   [BytesPerScanLine],ax
	mov [_display.pitch], eax
@@:
	mov eax, [_display.width]
	mul [_display.height]
	mov [_WinMapSize], eax

	mov	esi, BOOT_VAR+0x9080
	movzx	ecx, byte [esi-1]
	mov	[NumBiosDisks], ecx
	mov	edi, BiosDisksData
	rep	movsd

; GRAPHICS ADDRESSES

	and	byte [BOOT_VAR+0x901e],0x0
	mov	eax,[BOOT_VAR+0x9018]
	mov	[LFBAddress],eax

	cmp	[SCR_MODE],word 0100000000000000b
	jge	setvesa20
	cmp	[SCR_MODE],word 0x13
	je	v20ga32
	mov	[PUTPIXEL],dword Vesa12_putpixel24  ; Vesa 1.2
	mov	[GETPIXEL],dword Vesa12_getpixel24
	cmp	[ScreenBPP],byte 24
	jz	ga24
	mov	[PUTPIXEL],dword Vesa12_putpixel32
	mov	[GETPIXEL],dword Vesa12_getpixel32
      ga24:
	jmp	v20ga24
      setvesa20:
	mov	[PUTPIXEL],dword Vesa20_putpixel24  ; Vesa 2.0
	mov	[GETPIXEL],dword Vesa20_getpixel24
	cmp	[ScreenBPP],byte 24
	jz	v20ga24
      v20ga32:
	mov	[PUTPIXEL],dword Vesa20_putpixel32
	mov	[GETPIXEL],dword Vesa20_getpixel32
      v20ga24:
	cmp	[SCR_MODE],word 0x12		    ; 16 C VGA 640x480
	jne	no_mode_0x12
	mov	[PUTPIXEL],dword VGA_putpixel
	mov	[GETPIXEL],dword Vesa20_getpixel32
      no_mode_0x12:

; -------- Fast System Call init ----------
; Intel SYSENTER/SYSEXIT (AMD CPU support it too)
	   bt [cpu_caps], CAPS_SEP
	   jnc .SEnP   ; SysEnter not Present
	   xor edx, edx
	   mov ecx, MSR_SYSENTER_CS
	   mov eax, os_code
	   wrmsr
	   mov ecx, MSR_SYSENTER_ESP
;           mov eax, sysenter_stack ; Check it
	   xor	   eax, eax
	   wrmsr
	   mov ecx, MSR_SYSENTER_EIP
	   mov eax, sysenter_entry
	   wrmsr
.SEnP:
; AMD SYSCALL/SYSRET
	   cmp byte[cpu_vendor], 'A'
	   jne .noSYSCALL
	   mov eax, 0x80000001
	   cpuid
	   test edx, 0x800  ; bit_11 - SYSCALL/SYSRET support
	   jz .noSYSCALL
	   mov ecx, MSR_AMD_EFER
	   rdmsr
	   or eax, 1   ; bit_0 - System Call Extension (SCE)
	   wrmsr

	; !!!! It`s dirty hack, fix it !!!
	; Bits of EDX :
	; Bit 31<33>16 During the SYSRET instruction, this field is copied into the CS register
	;  and the contents of this field, plus 8, are copied into the SS register.
	; Bit 15<31>0 During the SYSCALL instruction, this field is copied into the CS register
	;  and the contents of this field, plus 8, are copied into the SS register.

	; mov   edx, (os_code + 16) * 65536 + os_code
	   mov edx, 0x1B0008

	   mov eax, syscall_entry
	   mov ecx, MSR_AMD_STAR
	   wrmsr
.noSYSCALL:
; -----------------------------------------
	stdcall alloc_page
	stdcall map_page, tss-0xF80, eax, PG_SW
	stdcall alloc_page
	inc	eax
	mov	[SLOT_BASE+256+APPDATA.io_map], eax
	stdcall map_page, tss+0x80, eax, PG_SW
	stdcall alloc_page
	inc	eax
	mov	dword [SLOT_BASE+256+APPDATA.io_map+4], eax
	stdcall map_page, tss+0x1080, eax, PG_SW

; LOAD IDT

	   call build_interrupt_table ;lidt is executed
	  ;lidt [idtreg]

	   call init_kernel_heap
	   stdcall kernel_alloc, RING0_STACK_SIZE+512
	   mov [os_stack_seg], eax

	   lea esp, [eax+RING0_STACK_SIZE]

	   mov [tss._ss0], os_stack
	   mov [tss._esp0], esp
	   mov [tss._esp], esp
	   mov [tss._cs],os_code
	   mov [tss._ss],os_stack
	   mov [tss._ds],app_data
	   mov [tss._es],app_data
	   mov [tss._fs],app_data
	   mov [tss._gs],app_data
	   mov [tss._io],128
;Add IO access table - bit array of permitted ports
	   mov edi, tss._io_map_0
	   xor eax, eax
	   not eax
	   mov ecx, 8192/4
	   rep stosd		     ; access to 4096*8=65536 ports

	   mov	ax,tss0
	   ltr	ax

	   mov [LFBSize], 0x800000
	   call init_LFB
	   call init_fpu
	   call init_malloc

	   stdcall alloc_kernel_space, 0x51000
	   mov [default_io_map], eax

	   add eax, 0x2000
	   mov [ipc_tmp], eax
	   mov ebx, 0x1000

	   add eax, 0x40000
	   mov [proc_mem_map], eax

	   add eax, 0x8000
	   mov [proc_mem_pdir], eax

	   add eax, ebx
	   mov [proc_mem_tab], eax

	   add eax, ebx
	   mov [tmp_task_pdir], eax

	   add eax, ebx
	   mov [tmp_task_ptab], eax

	   add eax, ebx
	   mov [ipc_pdir], eax

	   add eax, ebx
	   mov [ipc_ptab], eax

	   stdcall kernel_alloc, (unpack.LZMA_BASE_SIZE+(unpack.LZMA_LIT_SIZE shl \
				 (unpack.lc+unpack.lp)))*4

	   mov [unpack.p], eax

	   call init_events
	   mov eax, srv.fd-SRV_FD_OFFSET
	   mov [srv.fd], eax
	   mov [srv.bk], eax

	   mov edi, irq_tab
	   xor eax, eax
	   mov ecx, 16
	   rep stosd

;Set base of graphic segment to linear address of LFB
	mov	eax,[LFBAddress]	  ; set for gs
	mov	[graph_data_l+2],ax
	shr	eax,16
	mov	[graph_data_l+4],al
	mov	[graph_data_l+7],ah

	stdcall kernel_alloc, [_WinMapSize]
	mov [_WinMapAddress], eax

	xor  eax,eax
	inc  eax
	mov [CURRENT_TASK],eax		;dword 1
	mov [TASK_COUNT],eax		;dword 1
	mov [TASK_BASE],dword TASK_DATA
	mov [current_slot], SLOT_BASE+256

; set background

	mov   [BgrDrawMode],eax
	mov   [BgrDataWidth],eax
	mov   [BgrDataHeight],eax
	mov    [mem_BACKGROUND], 4
	mov [img_background], static_background_data

	mov	[SLOT_BASE + 256 + APPDATA.dir_table], sys_pgdir - OS_BASE

	stdcall kernel_alloc, 0x10000/8
	mov	edi, eax
	mov	[network_free_ports], eax
	or	eax, -1
	mov	ecx, 0x10000/32
	rep	stosd

; REDIRECT ALL IRQ'S TO INT'S 0x20-0x2f

	call  rerouteirqs

; Initialize system V86 machine
	call	init_sys_v86

; TIMER SET TO 1/100 S

	mov   al,0x34		   ; set to 100Hz
	out   0x43,al
	mov   al,0x9b		   ; lsb    1193180 / 1193
	out   0x40,al
	mov   al,0x2e		   ; msb
	out   0x40,al

; Enable timer IRQ (IRQ0) and hard drives IRQs (IRQ14, IRQ15)
; they are used: when partitions are scanned, hd_read relies on timer
; Also enable IRQ2, because in some configurations
; IRQs from slave controller are not delivered until IRQ2 on master is enabled
	mov	al, 0xFA
	out	0x21, al
	mov	al, 0x3F
	out	0xA1, al

; Enable interrupts in IDE controller
	mov	al, 0
	mov	dx, 0x3F6
	out	dx, al
	mov	dl, 0x76
	out	dx, al

;!!!!!!!!!!!!!!!!!!!!!!!!!!
include 'detect/disks.inc'
;!!!!!!!!!!!!!!!!!!!!!!!!!!

  call Parser_params

; READ RAMDISK IMAGE FROM HD

;!!!!!!!!!!!!!!!!!!!!!!!
include 'boot/rdload.inc'
;!!!!!!!!!!!!!!!!!!!!!!!
;    mov    [dma_hdd],1
; CALCULATE FAT CHAIN FOR RAMDISK

	call  calculatefatchain

; LOAD VMODE DRIVER

;!!!!!!!!!!!!!!!!!!!!!!!
include 'vmodeld.inc'
;!!!!!!!!!!!!!!!!!!!!!!!

if 0
  mov ax,[OS_BASE+0x10000+bx_from_load]
  cmp ax,'r1'		; if using not ram disk, then load librares and parameters {SPraid.simba}
  je  no_lib_load
; LOADING LIBRARES
   stdcall dll.Load,@IMPORT		    ; loading librares for kernel (.obj files)
   call load_file_parse_table		    ; prepare file parse table
   call set_kernel_conf 		    ; configure devices and gui
no_lib_load:
end if

; LOAD FONTS I and II

	stdcall read_file, char, FONT_I, 0, 2304
	stdcall read_file, char2, FONT_II, 0, 2560

	mov   esi,boot_fonts
	call  boot_log

; PRINT AMOUNT OF MEMORY
	mov	esi, boot_memdetect
	call	boot_log

	movzx	ecx, word [boot_y]
	or	ecx, (10+29*6) shl 16 ; "Determining amount of memory"
	sub	ecx, 10
	mov	edx, 0xFFFFFF
	mov	ebx, [MEM_AMOUNT]
	shr	ebx, 20
	xor	edi,edi
	mov	eax, 0x00040000
		inc		edi
	call	display_number_force

; BUILD SCHEDULER

	call   build_scheduler ; sys32.inc

	mov    esi,boot_devices
	call   boot_log

	mov  [pci_access_enabled],1


; SET PRELIMINARY WINDOW STACK AND POSITIONS

	mov   esi,boot_windefs
	call  boot_log
	call  set_window_defaults

; SET BACKGROUND DEFAULTS

	mov   esi,boot_bgr
	call  boot_log
	call  init_background
	call  calculatebackground

; RESERVE SYSTEM IRQ'S JA PORT'S

	mov   esi,boot_resirqports
	call  boot_log
	call  reserve_irqs_ports

; SET PORTS FOR IRQ HANDLERS

	;mov  esi,boot_setrports
	;call boot_log
	;call setirqreadports

; SET UP OS TASK

	mov  esi,boot_setostask
	call boot_log

	xor  eax, eax
	mov  dword [SLOT_BASE+APPDATA.fpu_state], fpu_data
	mov  dword [SLOT_BASE+APPDATA.exc_handler], eax
	mov  dword [SLOT_BASE+APPDATA.except_mask], eax

	; name for OS/IDLE process

	mov dword [SLOT_BASE+256+APPDATA.app_name],   dword 'OS/I'
	mov dword [SLOT_BASE+256+APPDATA.app_name+4], dword 'DLE '
	mov edi, [os_stack_seg]
	mov dword [SLOT_BASE+256+APPDATA.pl0_stack], edi
	add edi, 0x2000-512
	mov dword [SLOT_BASE+256+APPDATA.fpu_state], edi
	mov dword [SLOT_BASE+256+APPDATA.saved_esp0], edi ; just for case
	; [SLOT_BASE+256+APPDATA.io_map] was set earlier

	mov esi, fpu_data
	mov ecx, 512/4
	cld
	rep movsd

	mov dword [SLOT_BASE+256+APPDATA.exc_handler], eax
	mov dword [SLOT_BASE+256+APPDATA.except_mask], eax

	mov ebx, SLOT_BASE+256+APP_OBJ_OFFSET
	mov  dword [SLOT_BASE+256+APPDATA.fd_obj], ebx
	mov  dword [SLOT_BASE+256+APPDATA.bk_obj], ebx

	mov  dword [SLOT_BASE+256+APPDATA.cur_dir], sysdir_path
	mov dword [SLOT_BASE+256+APPDATA.tls_base], eax

	; task list
	mov  dword [TASK_DATA+TASKDATA.mem_start],eax	; process base address
	inc  eax
	mov  dword [CURRENT_TASK],eax
	mov  dword [TASK_COUNT],eax
	mov  [current_slot], SLOT_BASE+256
	mov  [TASK_BASE],dword TASK_DATA
	mov  byte[TASK_DATA+TASKDATA.wnd_number],al	; on screen number
	mov  dword [TASK_DATA+TASKDATA.pid], eax	; process id number

	call init_display
	mov eax, [def_cursor]
	mov [SLOT_BASE+APPDATA.cursor],eax
	mov [SLOT_BASE+APPDATA.cursor+256],eax

  ; READ TSC / SECOND

	mov   esi,boot_tsc
	call  boot_log
	cli
	rdtsc ;call  _rdtsc
	mov   ecx,eax
	mov   esi,250		    ; wait 1/4 a second
	call  delay_ms
	rdtsc ;call  _rdtsc
	sti
	sub   eax,ecx
	shl   eax,2
	mov   [CPU_FREQ],eax	      ; save tsc / sec
;       mov ebx, 1000000
;       div ebx
; <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>-<2D><> <20>ந<EFBFBD><E0AEA8><EFBFBD><EFBFBD><EFBFBD>⥫쭮<E2A5AB><ECADAE><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>⭮<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
; ᮢ<><E1AEA2>襭<EFBFBD><E8A5AD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>筠, <20><> <20>⮡<EFBFBD> <20><>⪭<EFBFBD><E2AAAD><EFBFBD> <20>⥫<EEA1A8><E2A5AB>
; <20><>⨬<EFBFBD><E2A8AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>஢ <20><><EFBFBD>...
	mov	edx, 2251799814
	mul	edx
	shr	edx, 19
	mov [stall_mcs], edx
; PRINT CPU FREQUENCY
	mov	esi, boot_cpufreq
	call	boot_log

	mov	ebx, edx
	movzx	ecx, word [boot_y]
	add	ecx, (10+17*6) shl 16 - 10 ; 'CPU frequency is '
	mov	edx, 0xFFFFFF
	xor	edi,edi
	mov	eax, 0x00040000
		inc		edi
	call	display_number_force

; SET VARIABLES

	call  set_variables

; SET MOUSE

	;call   detect_devices
	stdcall load_driver, szPS2MDriver
;        stdcall load_driver, szCOM_MDriver

	mov   esi,boot_setmouse
	call  boot_log
	call  setmouse


; STACK AND FDC

	call  stack_init
	call  fdc_init

; PALETTE FOR 320x200 and 640x480 16 col

	cmp   [SCR_MODE],word 0x12
	jne   no_pal_vga
	mov   esi,boot_pal_vga
	call  boot_log
	call  paletteVGA
      no_pal_vga:

	cmp   [SCR_MODE],word 0x13
	jne   no_pal_ega
	mov   esi,boot_pal_ega
	call  boot_log
	call  palette320x200
      no_pal_ega:

; LOAD DEFAULT SKIN

	call	load_default_skin

;protect io permission map

	   mov esi, [default_io_map]
	   stdcall map_page,esi,[SLOT_BASE+256+APPDATA.io_map], PG_MAP
	   add esi, 0x1000
	   stdcall map_page,esi,[SLOT_BASE+256+APPDATA.io_map+4], PG_MAP

	   stdcall map_page,tss._io_map_0,\
		   [SLOT_BASE+256+APPDATA.io_map], PG_MAP
	   stdcall map_page,tss._io_map_1,\
		   [SLOT_BASE+256+APPDATA.io_map+4], PG_MAP

  mov ax,[OS_BASE+0x10000+bx_from_load]
  cmp ax,'r1'		; if not rused ram disk - load network configuration from files {SPraid.simba}
  je  no_st_network
	call set_network_conf
  no_st_network:

; LOAD FIRST APPLICATION
	cli

	cmp   byte [BOOT_VAR+0x9030],1
	jne   no_load_vrr_m

	mov	ebp, vrr_m
	call	fs_execute_from_sysdir

;        cmp   eax,2                  ; if vrr_m app found (PID=2)
	sub   eax,2
	jz    first_app_found

no_load_vrr_m:

	mov	ebp, firstapp
	call	fs_execute_from_sysdir

;        cmp   eax,2                  ; continue if a process has been loaded
	sub   eax,2
	jz    first_app_found

	mov	esi, boot_failed
	call	boot_log

	mov   eax, 0xDEADBEEF	     ; otherwise halt
	hlt

first_app_found:

	cli

	;mov   [TASK_COUNT],dword 2
	push  1
	pop   dword [CURRENT_TASK]	; set OS task fisrt

; SET KEYBOARD PARAMETERS
	mov   al, 0xf6	       ; reset keyboard, scan enabled
	call  kb_write

	; wait until 8042 is ready
	xor ecx,ecx
      @@:
	in     al,64h
	and    al,00000010b
	loopnz @b

       ; mov   al, 0xED       ; svetodiody - only for testing!
       ; call  kb_write
       ; call  kb_read
       ; mov   al, 111b
       ; call  kb_write
       ; call  kb_read

	mov   al, 0xF3	     ; set repeat rate & delay
	call  kb_write
;        call  kb_read
	mov   al, 0 ; 30 250 ;00100010b ; 24 500  ;00100100b  ; 20 500
	call  kb_write
;        call  kb_read
     ;// mike.dld [
	call  set_lights
     ;// mike.dld ]


; Setup serial output console (if enabled)

if defined debug_com_base

	; enable Divisor latch

	mov	dx, debug_com_base+3
	mov	al, 1 shl 7
	out	dx, al

	; Set speed to 115200 baud (max speed)

	mov	dx, debug_com_base
	mov	al, 0x01
	out	dx, al

	mov	dx, debug_com_base+1
	mov	al, 0x00
	out	dx, al

	; No parity, 8bits words, one stop bit, dlab bit back to 0

	mov	dx, debug_com_base+3
	mov	al, 3
	out	dx, al

	; disable interrupts

	mov	dx, debug_com_base+1
	mov	al, 0
	out	dx, al

	; clear +  enable fifo (64 bits)

	mov	dx, debug_com_base+2
	mov	al, 0x7 + 1 shl 5
	out	dx, al


end if

; START MULTITASKING

if preboot_blogesc
	mov	esi, boot_tasking
	call	boot_log
.bll1:	in	al, 0x60	; wait for ESC key press
	cmp	al, 129
	jne	.bll1
end if

;       mov   [ENABLE_TASKSWITCH],byte 1        ; multitasking enabled

; UNMASK ALL IRQ'S

;        mov   esi,boot_allirqs
;        call  boot_log
;
;        cli                          ;guarantee forbidance of interrupts.
;        mov   al,0                   ; unmask all irq's
;        out   0xA1,al
;        out   0x21,al
;
;        mov   ecx,32
;
;     ready_for_irqs:
;
;        mov   al,0x20                ; ready for irqs
;        out   0x20,al
;        out   0xa0,al
;
;        loop  ready_for_irqs         ; flush the queue

	stdcall attach_int_handler, 1, irq1, 0

;        mov    [dma_hdd],1
	cmp	[IDEContrRegsBaseAddr], 0
	setnz	[dma_hdd]
	mov [timer_ticks_enable],1		; for cd driver

	sti
	call change_task

	jmp osloop

;        jmp   $                      ; wait here for timer to take control

	; Fly :)

include 'unpacker.inc'
include 'fdo.inc'

align 4
boot_log:
	 pushad

	mov   ebx,10*65536
	mov   bx,word [boot_y]
	add   [boot_y],dword 10
	mov   ecx,0x80ffffff   ; ASCIIZ string with white color
		xor	  edi,edi
	mov   edx,esi
		inc	  edi
	call  dtext

	mov   [novesachecksum],1000
	call  checkVga_N13

	popad

	ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                    ;
;                    MAIN OS LOOP START                              ;
;                                                                    ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 32
osloop:
	call   [draw_pointer]
	call	window_check_events
	call	mouse_check_events
	call   checkmisc
	call   checkVga_N13
	call   stack_handler
	call   checkidle
	call   check_fdd_motor_status
	call   check_ATAPI_device_event
	jmp    osloop
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                    ;
;                      MAIN OS LOOP END                              ;
;                                                                    ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
checkidle:
	pushad
	call	change_task
	jmp	idle_loop_entry
  idle_loop:
	cmp	eax,[idlemem]	  ; eax == [timer_ticks]
	jne	idle_exit
	rdtsc	;call _rdtsc
	mov	ecx,eax
	hlt
	rdtsc	;call _rdtsc
	sub	eax,ecx
	add	[idleuse],eax
  idle_loop_entry:
	mov	eax,[timer_ticks] ; eax =  [timer_ticks]
	cmp	[check_idle_semaphore],0
	je	idle_loop
	dec	[check_idle_semaphore]
  idle_exit:
	mov	[idlemem],eax	  ; eax == [timer_ticks]
	popad
	ret

uglobal
  idlemem		dd   0x0
  idleuse		dd   0x0
  idleusesec		dd   0x0
  check_idle_semaphore	dd   0x0
endg



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                      ;
;                   INCLUDED SYSTEM FILES                              ;
;                                                                      ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


include "kernel32.inc"


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                      ;
;                       KERNEL FUNCTIONS                               ;
;                                                                      ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

reserve_irqs_ports:

	push eax
	xor	eax,eax
		inc	eax
	mov  byte [irq_owner+4*0],al		;1    ; timer
	;mov  [irq_owner+4*1], 1    ; keyboard
	mov  byte [irq_owner+4*6],al		;1    ; floppy diskette
	mov  byte [irq_owner+4*13],al	;1   ; math co-pros
	mov  byte [irq_owner+4*14],al	;1   ; ide I
	mov  byte [irq_owner+4*15],al	;1   ; ide II
	pop  eax

; RESERVE PORTS
	push  4
	pop   dword [RESERVED_PORTS]	;,edi

	push  1
	pop   dword [RESERVED_PORTS+16+0]	;,dword 1
	and   dword [RESERVED_PORTS+16+4],0	;,dword 0x0
	mov   dword [RESERVED_PORTS+16+8],0x2d	;,dword 0x2d

	push  1
	pop   dword [RESERVED_PORTS+32+0]	;,dword 1
	push  0x30
	pop   dword [RESERVED_PORTS+32+4]	;,dword 0x30
	push  0x4d
	pop   dword [RESERVED_PORTS+32+8]	;,dword 0x4d

	push  1
	pop   dword [RESERVED_PORTS+48+0]	;,dword 1
	push  0x50
	pop   dword [RESERVED_PORTS+48+4]	;,dword 0x50
	mov   dword [RESERVED_PORTS+48+8],0xdf	;,dword 0xdf

	push  1
	pop   dword [RESERVED_PORTS+64+0]	;,dword 1

	mov   dword [RESERVED_PORTS+64+4],0xe5	;,dword 0xe5
	mov   dword [RESERVED_PORTS+64+8],0xff	;,dword 0xff

	ret

setirqreadports:

	mov   [irq12read+0],dword 0x60 + 0x01000000  ; read port 0x60 , byte
	    and   dword [irq12read+4],0 		  ; end of port list
;        mov   [irq12read+4],dword 0                  ; end of port list
	;mov   [irq04read+0],dword 0x3f8 + 0x01000000 ; read port 0x3f8 , byte
	;mov   [irq04read+4],dword 0                  ; end of port list
	;mov   [irq03read+0],dword 0x2f8 + 0x01000000 ; read port 0x2f8 , byte
	;mov   [irq03read+4],dword 0                  ; end of port list

	ret

iglobal
  process_number dd 0x1
endg

set_variables:

	mov   ecx,0x100 		      ; flush port 0x60
.fl60:	in    al,0x60
	loop  .fl60
	push  eax

	mov   ax,[BOOT_VAR+0x900c]
	shr   ax,1
	shl   eax,16
	mov   ax,[BOOT_VAR+0x900A]
	shr   ax,1
	mov   [MOUSE_X],eax

	xor   eax,eax
	mov   [BTN_ADDR],dword BUTTON_INFO    ; address of button list

	mov   byte [MOUSE_BUFF_COUNT],al		 ; mouse buffer
	mov   byte [KEY_COUNT],al		  ; keyboard buffer
	mov   byte [BTN_COUNT],al		  ; button buffer
;        mov   [MOUSE_X],dword 100*65536+100    ; mouse x/y

     ;!! IP 04.02.2005:
	mov   byte [DONT_SWITCH],al ; change task if possible
	pop   eax
	ret

align 4
;input  eax=43,bl-byte of output, ecx - number of port
sys_outport:

    mov   edi,ecx	   ; separate flag for read / write
    and   ecx,65535

    mov   eax,[RESERVED_PORTS]
    test  eax,eax
    jnz   .sopl8
    inc   eax
	mov   [esp+32],eax
    ret

  .sopl8:
    mov   edx,[TASK_BASE]
    mov   edx,[edx+0x4]
    ;and   ecx,65535
    ;cld - set on interrupt 0x40
  .sopl1:

    mov   esi,eax
    shl   esi,4
    add   esi,RESERVED_PORTS
    cmp   edx,[esi+0]
    jne   .sopl2
    cmp   ecx,[esi+4]
    jb	  .sopl2
    cmp   ecx,[esi+8]
    jg	  .sopl2
.sopl3:

    test  edi,0x80000000 ; read ?
    jnz   .sopl4

	mov	  eax,ebx
    mov   dx,cx 	 ; write
    out   dx,al
    and   [esp+32],dword 0
    ret

	.sopl2:

    dec   eax
    jnz   .sopl1
	inc	  eax
    mov   [esp+32],eax
    ret

  
  .sopl4:

    mov   dx,cx 	 ; read
    in	  al,dx
    and   eax,0xff
    and   [esp+32],dword 0
    mov   [esp+20],eax
    ret

display_number:
;It is not optimization
	mov	eax, ebx
	mov	ebx, ecx
	mov	ecx, edx
	mov	edx, esi
	mov	esi, edi
; eax = print type, al=0 -> ebx is number
;                   al=1 -> ebx is pointer
;                   ah=0 -> display decimal
;                   ah=1 -> display hexadecimal
;                   ah=2 -> display binary
;                   eax bits 16-21 = number of digits to display (0-32)
;                   eax bits 22-31 = reserved
;
; ebx = number or pointer
; ecx = x shl 16 + y
; edx = color
    xor     edi, edi
display_number_force:
    push  eax
    and   eax,0x3fffffff
    cmp   eax,0xffff		; length > 0 ?
    pop   eax
    jge   cont_displ
    ret
   cont_displ:
     push  eax
     and   eax,0x3fffffff
     cmp   eax,61*0x10000	 ; length <= 60 ?
     pop   eax
     jb    cont_displ2
     ret
   cont_displ2:

     pushad

     cmp   al,1 		 ; ecx is a pointer ?
     jne   displnl1
     mov   ebp,ebx
     add   ebp,4
     mov   ebp,[ebp+std_application_base_address]
     mov   ebx,[ebx+std_application_base_address]
 displnl1:
     sub   esp,64

    test   ah,ah		  ; DECIMAL
    jnz   no_display_desnum
    shr   eax,16
    and   eax,0xC03f
;     and   eax,0x3f
    push  eax
    and   eax,0x3f
    mov   edi,esp
    add   edi,4+64-1
    mov   ecx,eax
    mov   eax,ebx
    mov   ebx,10
 d_desnum:
     xor   edx,edx
     call  division_64_bits
     div   ebx
     add   dl,48
     mov   [edi],dl
     dec   edi
     loop  d_desnum
     pop   eax
     call  normalize_number
     call  draw_num_text
     add   esp,64
     popad
     ret
   no_display_desnum:

     cmp   ah,0x01		 ; HEXADECIMAL
     jne   no_display_hexnum
     shr   eax,16
     and   eax,0xC03f
;     and   eax,0x3f
     push  eax
     and   eax,0x3f
     mov   edi,esp
     add   edi,4+64-1
     mov   ecx,eax
     mov   eax,ebx
     mov   ebx,16
   d_hexnum:
     xor   edx,edx
     call  division_64_bits
     div   ebx
   hexletters = __fdo_hexdigits
     add   edx,hexletters
     mov   dl,[edx]
     mov   [edi],dl
     dec   edi
     loop  d_hexnum
     pop   eax
     call  normalize_number
     call  draw_num_text
     add   esp,64
     popad
     ret
   no_display_hexnum:

     cmp   ah,0x02		 ; BINARY
     jne   no_display_binnum
     shr   eax,16
     and   eax,0xC03f
;     and   eax,0x3f
     push  eax
     and   eax,0x3f
     mov   edi,esp
     add   edi,4+64-1
     mov   ecx,eax
     mov   eax,ebx
     mov   ebx,2
   d_binnum:
     xor   edx,edx
     call  division_64_bits
     div   ebx
     add   dl,48
     mov   [edi],dl
     dec   edi
     loop  d_binnum
     pop   eax
     call  normalize_number
     call  draw_num_text
     add   esp,64
     popad
     ret
   no_display_binnum:

     add   esp,64
     popad
     ret

normalize_number:
     test  ah,0x80
     jz   .continue
     mov  ecx,48
     and   eax,0x3f
@@:
     inc   edi
     cmp   [edi],cl
     jne   .continue
     dec   eax
     cmp   eax,1
     ja    @r
     mov   al,1
.continue:
     and   eax,0x3f
     ret

division_64_bits:
     test  [esp+1+4],byte 0x40
     jz   .continue
     push  eax
     mov   eax,ebp
     div   ebx
     mov   ebp,eax
     pop   eax
.continue:
     ret

draw_num_text:
     mov   esi,eax
     mov   edx,64+4
     sub   edx,eax
     add   edx,esp
     mov   ebx,[esp+64+32-8+4]
; add window start x & y
     mov   ecx,[TASK_BASE]

     mov   edi,[CURRENT_TASK]
     shl   edi,8

     mov   eax,[ecx-twdw+WDATA.box.left]
     add   eax,[edi+SLOT_BASE+APPDATA.wnd_clientbox.left]
     shl   eax,16
     add   eax,[ecx-twdw+WDATA.box.top]
     add   eax,[edi+SLOT_BASE+APPDATA.wnd_clientbox.top]
     add   ebx,eax
     mov   ecx,[esp+64+32-12+4]
	and	ecx, not 0x80000000	; force counted string
	mov	eax, [esp+64+8] 	; background color (if given)
	mov	edi, [esp+64+4]
     jmp   dtext

align 4

sys_setup:

; 1=roland mpu midi base , base io address
; 2=keyboard   1, base kaybap 2, shift keymap, 9 country 1eng 2fi 3ger 4rus
; 3=cd base    1, pri.master 2, pri slave 3 sec master, 4 sec slave
; 5=system language, 1eng 2fi 3ger 4rus
; 7=hd base    1, pri.master 2, pri slave 3 sec master, 4 sec slave
; 8=fat32 partition in hd
; 9
; 10 = sound dma channel
; 11 = enable lba read
; 12 = enable pci access


	and  [esp+32],dword 0
	dec	ebx				; MIDI
	jnz  nsyse1
	cmp  ecx,0x100

	jb   nsyse1
	mov	esi,65535
	cmp	esi,ecx

	jb   nsyse1
	mov  [midi_base],cx	;bx
	mov  word [mididp],cx	;bx
	inc  cx 		;bx
	mov  word [midisp],cx	;bx
	ret

iglobal
midi_base dw 0
endg

   nsyse1:
	dec	ebx				 ; KEYBOARD
	jnz  nsyse2
	mov  edi,[TASK_BASE]
	mov  eax,[edi+TASKDATA.mem_start]
	add  eax,edx

	dec	ecx
	jnz  kbnobase
	mov  ebx,keymap
	mov  ecx,128
	call memmove
	ret
   kbnobase:
	dec  ecx
	jnz  kbnoshift

	mov  ebx,keymap_shift
	mov  ecx,128
	call memmove
	ret
   kbnoshift:
	dec  ecx
	jnz  kbnoalt
	mov  ebx,keymap_alt
	mov  ecx,128
	call memmove
	ret
   kbnoalt:
	sub  ecx,6
	jnz  kbnocountry
	mov  word [keyboard],dx
	ret
   kbnocountry:
	mov  [esp+32],dword 1
	ret
   nsyse2:
	dec  ebx			    ; CD
	jnz  nsyse4

	test ecx,ecx
	jz   nosesl

	cmp  ecx, 4
	ja   nosesl
	mov  [cd_base],cl

	dec	ecx
	jnz  noprma
	mov  [cdbase],0x1f0
	mov  [cdid],0xa0
   noprma:

	dec	ecx
	jnz  noprsl
	mov  [cdbase],0x1f0
	mov  [cdid],0xb0
   noprsl:
	dec	ecx
	jnz  nosema
	mov  [cdbase],0x170
	mov  [cdid],0xa0
   nosema:
	dec	ecx
	jnz  nosesl
	mov  [cdbase],0x170
	mov  [cdid],0xb0
   nosesl:
	ret

iglobal
cd_base db 0

endg
   nsyse4:
		 
	sub  ebx,2		 ; SYSTEM LANGUAGE
	jnz  nsyse5
	mov  [syslang],ecx
	ret
   nsyse5:
	 
	sub  ebx,2		; HD BASE
	jnz  nsyse7

	test ecx,ecx
	jz   nosethd

	cmp  ecx,4
	ja   nosethd
	mov  [hd_base],cl

	cmp  ecx,1
	jnz  noprmahd
	mov  [hdbase],0x1f0
	and  dword [hdid],0x0
	mov  dword [hdpos],ecx
;     call set_FAT32_variables
   noprmahd:

	cmp  ecx,2
	jnz  noprslhd
	mov  [hdbase],0x1f0
	mov  [hdid],0x10
	mov  dword [hdpos],ecx
;     call set_FAT32_variables
   noprslhd:

	cmp  ecx,3
	jnz  nosemahd
	mov  [hdbase],0x170
	and  dword [hdid],0x0
	mov  dword [hdpos],ecx
;     call set_FAT32_variables
   nosemahd:

	cmp  ecx,4
	jnz  noseslhd
	mov  [hdbase],0x170
	mov  [hdid],0x10
	mov  dword [hdpos],ecx
;     call set_FAT32_variables
   noseslhd:
	call  reserve_hd1
	call  reserve_hd_channel
	call  free_hd_channel
	and   dword [hd1_status],0	  ; free
   nosethd:
	ret

iglobal
hd_base db 0
endg

nsyse7:

;     cmp  eax,8                      ; HD PARTITION
	dec  ebx
	jnz  nsyse8
	mov  [fat32part],ecx
;     call set_FAT32_variables
	call  reserve_hd1
	call  reserve_hd_channel
	call  free_hd_channel
;       pusha
	call  choice_necessity_partition_1
;       popa
	and dword [hd1_status],0	; free
	ret

nsyse8:
;     cmp  eax,11                     ; ENABLE LBA READ
	and  ecx,1
	sub  ebx,3
	jnz  no_set_lba_read
	mov  [lba_read_enabled],ecx
	ret

no_set_lba_read:
;     cmp  eax,12                     ; ENABLE PCI ACCESS
	dec  ebx
	jnz  no_set_pci_access
	mov  [pci_access_enabled],ecx
	ret
no_set_pci_access:

;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
include 'vmodeint.inc'
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

sys_setup_err:
	or  [esp+32],dword -1
	ret

align 4

sys_getsetup:

; 1=roland mpu midi base , base io address
; 2=keyboard   1, base kaybap 2, shift keymap, 9 country 1eng 2fi 3ger 4rus
; 3=cd base    1, pri.master 2, pri slave 3 sec master, 4 sec slave
; 5=system language, 1eng 2fi 3ger 4rus
; 7=hd base    1, pri.master 2, pri slave 3 sec master, 4 sec slave
; 8=fat32 partition in hd
; 9=get hs timer tic

;     cmp  eax,1
	dec	ebx
	jnz  ngsyse1
	movzx eax,[midi_base]
	mov  [esp+32],eax
	ret
ngsyse1:
;     cmp  eax,2
	dec	ebx
	jnz  ngsyse2

	mov  edi,[TASK_BASE]
	mov  ebx,[edi+TASKDATA.mem_start]
	add  ebx,edx

;     cmp  ebx,1
	dec	ecx
	jnz  kbnobaseret
	mov  eax,keymap
	mov  ecx,128
	call memmove
	ret
kbnobaseret:
;     cmp  ebx,2
	dec	ecx
	jnz  kbnoshiftret

	mov  eax,keymap_shift
	mov  ecx,128
	call memmove
	ret
kbnoshiftret:
;     cmp  ebx,3
	dec	ecx
	jne  kbnoaltret

	mov  eax,keymap_alt
	mov  ecx,128
	call memmove
	ret
kbnoaltret:
;     cmp  ebx,9
	sub	ecx,6
	jnz  ngsyse2
	movzx eax,word [keyboard]
	mov  [esp+32],eax
	ret


ngsyse2:
;         cmp  eax,3
	dec	ebx
	jnz  ngsyse3
	movzx eax,[cd_base]
	mov  [esp+32],eax
	ret
ngsyse3:
;         cmp  eax,5
	sub	ebx,2
	jnz  ngsyse5
	mov  eax,[syslang]
	mov  [esp+32],eax
	ret
ngsyse5:
;     cmp  eax,7
	sub	ebx,2
	jnz  ngsyse7
	movzx eax,[hd_base]
	mov  [esp+32],eax
	ret
ngsyse7:
;     cmp  eax,8
	dec	ebx
	jnz  ngsyse8
	mov eax,[fat32part]
	mov  [esp+32],eax
	ret
ngsyse8:
;     cmp  eax,9
	dec	ebx
	jnz  ngsyse9
	mov  eax,[timer_ticks] ;[0xfdf0]
	mov  [esp+32],eax
	ret
ngsyse9:
;     cmp  eax,11
	sub	ebx,2
	jnz  ngsyse11
	mov eax,[lba_read_enabled]
	mov  [esp+32],eax
	ret
ngsyse11:
;     cmp  eax,12
	dec	ebx
	jnz  ngsyse12
	mov eax,[pci_access_enabled]
	mov  [esp+32],eax
	ret
ngsyse12:
	mov  [esp+32],dword 1
	ret

	
get_timer_ticks:
	mov eax,[timer_ticks]
	ret

iglobal
align 4
mousefn dd msscreen, mswin, msbutton, msset
	dd app_load_cursor
	dd app_set_cursor
	dd app_delete_cursor
	dd msz
endg

readmousepos:

; eax=0 screen relative
; eax=1 window relative
; eax=2 buttons pressed
; eax=3 set mouse pos   ; reserved
; eax=4 load cursor
; eax=5 set cursor
; eax=6 delete cursor   ; reserved
; eax=7 get mouse_z

	   cmp ebx, 7
	   ja msset
	   jmp [mousefn+ebx*4]
msscreen:
	   mov	eax,[MOUSE_X]
	   shl	eax,16
	   mov	ax,[MOUSE_Y]
	   mov	[esp+36-4],eax
	   ret
mswin:
	   mov	eax,[MOUSE_X]
	   shl	eax,16
	   mov	ax,[MOUSE_Y]
	   mov	esi,[TASK_BASE]
	   mov	bx, word [esi-twdw+WDATA.box.left]
	   shl	ebx,16
	   mov	bx, word [esi-twdw+WDATA.box.top]
	   sub	eax,ebx

	   mov	edi,[CURRENT_TASK]
	   shl	edi,8
	   sub	ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.top]
	   rol	eax,16
	   sub	ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.left]
	   rol	eax,16
	   mov	[esp+36-4],eax
	   ret
msbutton:
	   movzx eax,byte [BTN_DOWN]
	   mov	[esp+36-4],eax
	   ret
msz:
	   mov	 edi, [TASK_COUNT]
	   movzx edi, word [WIN_POS + edi*2]
	   cmp	 edi, [CURRENT_TASK]
	   jne	 @f
	   mov	 ax,[MOUSE_SCROLL_H]
	   shl	 eax,16
	   mov	 ax,[MOUSE_SCROLL_V]
	   mov	 [esp+36-4],eax
	   and	 [MOUSE_SCROLL_H],word 0
	   and	 [MOUSE_SCROLL_V],word 0
	   ret
       @@:
	   and	[esp+36-4],dword 0
;           ret
msset:
	   ret

app_load_cursor:
	   cmp ecx, OS_BASE
	   jae msset
	   stdcall load_cursor, ecx, edx
	   mov [esp+36-4], eax
	   ret

app_set_cursor:
	   stdcall set_cursor, ecx
	   mov [esp+36-4], eax
	   ret

app_delete_cursor:
	   stdcall delete_cursor, ecx
	   mov [esp+36-4], eax
	   ret

is_input:

   push edx
   mov	dx,word [midisp]
   in	al,dx
   and	al,0x80
   pop	edx
   ret

is_output:

   push edx
   mov	dx,word [midisp]
   in	al,dx
   and	al,0x40
   pop	edx
   ret


get_mpu_in:

   push edx
   mov	dx,word [mididp]
   in	al,dx
   pop	edx
   ret


put_mpu_out:

   push edx
   mov	dx,word [mididp]
   out	dx,al
   pop	edx
   ret



align 4

sys_midi:
	cmp  [mididp],0
	jnz  sm0
	mov  [esp+36],dword 1
	ret
sm0:
	and  [esp+36],dword 0
	dec  ebx
	jnz  smn1
 ;    call setuart
su1:
	call is_output
	test al,al
	jnz  su1
	mov  dx,word [midisp]
	mov  al,0xff
	out  dx,al
su2:
	mov  dx,word [midisp]
	mov  al,0xff
	out  dx,al
	call is_input
	test al,al
	jnz  su2
	call get_mpu_in
	cmp  al,0xfe
	jnz  su2
su3:
	call is_output
	test  al,al
	jnz  su3
	mov  dx,word [midisp]
	mov  al,0x3f
	out  dx,al
	ret
smn1:
	dec  ebx
	jnz  smn2
sm10:
	call get_mpu_in
	call is_output
	test al,al
	jnz  sm10
	mov  al,bl
	call put_mpu_out
	smn2:
	ret

detect_devices:
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;include 'detect/commouse.inc'
;include 'detect/ps2mouse.inc'
;include 'detect/dev_fd.inc'
;include 'detect/dev_hdcd.inc'
;include 'detect/sear_par.inc'
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    ret

sys_end:

     mov ecx, [current_slot]
     mov eax, [ecx+APPDATA.tls_base]
     test eax, eax
     jz @F

     stdcall user_free, eax
@@:

     mov   eax,[TASK_BASE]
     mov   [eax+TASKDATA.state], 3  ; terminate this program

    waitterm:		 ; wait here for termination
     mov   ebx,100
     call  delay_hs
     jmp   waitterm

iglobal
align 4
sys_system_table:
	dd	exit_for_anyone 	; 1 = obsolete
	dd	sysfn_terminate 	; 2 = terminate thread
	dd	sysfn_activate		; 3 = activate window
	dd	sysfn_getidletime	; 4 = get idle time
	dd	sysfn_getcpuclock	; 5 = get cpu clock
	dd	sysfn_saveramdisk	; 6 = save ramdisk
	dd	sysfn_getactive 	; 7 = get active window
	dd	sysfn_sound_flag	; 8 = get/set sound_flag
	dd	sysfn_shutdown		; 9 = shutdown with parameter
	dd	sysfn_minimize		; 10 = minimize window
	dd	sysfn_getdiskinfo	; 11 = get disk subsystem info
	dd	sysfn_lastkey		; 12 = get last pressed key
	dd	sysfn_getversion	; 13 = get kernel version
	dd	sysfn_waitretrace	; 14 = wait retrace
	dd	sysfn_centermouse	; 15 = center mouse cursor
	dd	sysfn_getfreemem	; 16 = get free memory size
	dd	sysfn_getallmem 	; 17 = get total memory size
	dd	sysfn_terminate2	; 18 = terminate thread using PID
					;                 instead of slot
	dd	sysfn_mouse_acceleration; 19 = set/get mouse acceleration
	dd	sysfn_meminfo		; 20 = get extended memory info
	dd	sysfn_pid_to_slot	; 21 = get slot number for pid
	dd	sysfn_min_rest_window	; 22 = minimize and restore any window
sysfn_num = ($ - sys_system_table)/4
endg

sys_system:
	dec	ebx
	cmp	ebx, sysfn_num
	jae	@f
	jmp	dword [sys_system_table + ebx*4]
@@:
	ret


sysfn_shutdown: 	 ; 18.9 = system shutdown
     cmp  ecx,1
     jl   exit_for_anyone
     cmp  ecx,4
     jg   exit_for_anyone
     mov  [BOOT_VAR+0x9030],cl

     mov  eax,[TASK_COUNT]
     mov  [SYS_SHUTDOWN],al
     mov  [shutdown_processes],eax
     and  dword [esp+32], 0
 exit_for_anyone:
     ret
  uglobal
   shutdown_processes: dd 0x0
  endg

sysfn_terminate:	; 18.2 = TERMINATE
     cmp  ecx,2
     jb   noprocessterminate
     mov  edx,[TASK_COUNT]
     cmp  ecx,edx
     ja   noprocessterminate
     mov  eax,[TASK_COUNT]
     shl  ecx,5
     mov  edx,[ecx+CURRENT_TASK+TASKDATA.pid]
     add  ecx,CURRENT_TASK+TASKDATA.state
     cmp  byte [ecx], 9
     jz   noprocessterminate

     ;call MEM_Heap_Lock      ;guarantee that process isn't working with heap
     mov  [ecx],byte 3	     ; clear possible i40's
     ;call MEM_Heap_UnLock

     cmp  edx,[application_table_status]    ; clear app table stat
     jne  noatsc
     and  [application_table_status],0
   noatsc:
   noprocessterminate:
     ret

sysfn_terminate2:
;lock application_table_status mutex
.table_status:
    cli
    cmp    [application_table_status],0
    je	   .stf
    sti
    call   change_task
    jmp    .table_status
.stf:
    call   set_application_table_status
    mov    eax,ecx
    call   pid_to_slot
    test   eax,eax
    jz	   .not_found
    mov    ecx,eax
    cli
    call   sysfn_terminate
    and    [application_table_status],0
    sti
    and    dword [esp+32],0
    ret
.not_found:
    mov    [application_table_status],0
    or	   dword [esp+32],-1
    ret

sysfn_activate: 	; 18.3 = ACTIVATE WINDOW
     cmp  ecx,2
     jb   .nowindowactivate
     cmp  ecx,[TASK_COUNT]
     ja   .nowindowactivate

     mov   [window_minimize], 2   ; restore window if minimized

     movzx esi, word [WIN_STACK + ecx*2]
     cmp   esi, [TASK_COUNT]
     je    .nowindowactivate ; already active

     mov   edi, ecx
     shl   edi, 5
     add   edi, window_data
     movzx esi, word [WIN_STACK + ecx * 2]
     lea   esi, [WIN_POS + esi * 2]
     call  waredraw
.nowindowactivate:
     ret

sysfn_getidletime:		; 18.4 = GET IDLETIME
     mov  eax,[idleusesec]
     mov  [esp+32], eax
     ret

sysfn_getcpuclock:		; 18.5 = GET TSC/SEC
     mov  eax,[CPU_FREQ]
     mov  [esp+32], eax
     ret

;  SAVE ramdisk to /hd/1/menuet.img
;!!!!!!!!!!!!!!!!!!!!!!!!
   include 'blkdev/rdsave.inc'
;!!!!!!!!!!!!!!!!!!!!!!!!
align 4
sysfn_getactive:	; 18.7 = get active window
     mov  eax, [TASK_COUNT]
   movzx  eax, word [WIN_POS + eax*2]
     mov  [esp+32],eax
     ret

sysfn_sound_flag:	; 18.8 = get/set sound_flag
;     cmp  ecx,1
     dec  ecx
     jnz  nogetsoundflag
     movzx  eax,byte [sound_flag] ; get sound_flag
     mov  [esp+32],eax
     ret
 nogetsoundflag:
;     cmp  ecx,2
     dec  ecx
     jnz  nosoundflag
     xor  byte [sound_flag], 1
 nosoundflag:
     ret

sysfn_minimize: 	; 18.10 = minimize window
     mov   [window_minimize],1
     ret
align 4
sysfn_getdiskinfo:	; 18.11 = get disk info table
;     cmp  ecx,1
     dec  ecx
     jnz  full_table
  small_table:
     call for_all_tables
     mov ecx,10
     cld
     rep movsb
     ret
   for_all_tables:
     mov edi,edx
     mov esi,DRIVE_DATA
     ret
  full_table:
;     cmp  ecx,2
     dec  ecx
     jnz  exit_for_anyone
     call for_all_tables
     mov ecx,16384
     cld
     rep movsd
     ret

sysfn_lastkey:		; 18.12 = return 0 (backward compatibility)
	and	dword [esp+32], 0
	ret

sysfn_getversion:	; 18.13 = get kernel ID and version
     mov edi,ecx
     mov esi,version_inf
     mov ecx,version_end-version_inf
     rep movsb
     ret

sysfn_waitretrace:     ; 18.14 = sys wait retrace
     ;wait retrace functions
 sys_wait_retrace:
     mov edx,0x3da
 WaitRetrace_loop:
     in al,dx
     test al,1000b
     jz WaitRetrace_loop
     and [esp+32],dword 0
     ret

align 4
sysfn_centermouse:	; 18.15 = mouse centered
; removed here by <Lrz>
;     call  mouse_centered
;* mouse centered - start code- Mario79
;mouse_centered:
;        push  eax
	mov   eax,[Screen_Max_X]
	shr   eax,1
	mov   [MOUSE_X],ax
	mov   eax,[Screen_Max_Y]
	shr   eax,1
	mov   [MOUSE_Y],ax
;        ret
;* mouse centered - end code- Mario79
	xor   eax,eax
	and   [esp+32],eax
;        pop   eax

     ret
align 4
sysfn_mouse_acceleration: ; 18.19 = set/get mouse features
     test ecx,ecx  ; get mouse speed factor
     jnz  .set_mouse_acceleration
     xor  eax,eax
     mov  ax,[mouse_speed_factor]
     mov  [esp+32],eax
     ret
 .set_mouse_acceleration:
;     cmp  ecx,1  ; set mouse speed factor
     dec  ecx
     jnz  .get_mouse_delay
     mov  [mouse_speed_factor],dx
     ret
 .get_mouse_delay:
;     cmp  ecx,2  ; get mouse delay
     dec  ecx
     jnz  .set_mouse_delay
     mov  eax,[mouse_delay]
     mov  [esp+32],eax
     ret
 .set_mouse_delay:
;     cmp  ecx,3  ; set mouse delay
     dec  ecx
     jnz  .set_pointer_position
     mov  [mouse_delay],edx
     ret
 .set_pointer_position:
;     cmp  ecx,4  ; set mouse pointer position
     dec   ecx
     jnz  .set_mouse_button
     cmp   dx, word[Screen_Max_X]
     ja    .end
     rol   edx,16
     cmp   dx, word[Screen_Max_Y]
     ja    .end
     rol   edx,16
     mov   [MOUSE_X], edx
     ret
 .set_mouse_button:
;     cmp   ecx,5  ; set mouse button features
     dec   ecx
     jnz  .end
     mov   [BTN_DOWN],dl
     mov   [mouse_active],1
 .end:
     ret

sysfn_getfreemem:
     mov eax, [pg_data.pages_free]
     shl eax, 2
     mov [esp+32],eax
     ret

sysfn_getallmem:
     mov  eax,[MEM_AMOUNT]
     shr eax, 10
     mov  [esp+32],eax
     ret

; // Alver, 2007-22-08 // {
sysfn_pid_to_slot:
     mov   eax, ecx
     call  pid_to_slot
     mov   [esp+32], eax
     ret

sysfn_min_rest_window:
     pushad
     mov   eax, edx	 ; ebx - operating
     shr   ecx, 1
     jnc    @f
     call  pid_to_slot
@@:
     or    eax, eax	 ; eax - number of slot
     jz    .error
     cmp   eax, 255	    ; varify maximal slot number
     ja    .error
     movzx eax, word [WIN_STACK + eax*2]
     shr   ecx, 1
     jc    .restore
 ; .minimize:
     call  minimize_window
     jmp   .exit
.restore:
     call  restore_minimized_window
.exit:
     popad
     xor   eax, eax
     mov   [esp+32], eax
     ret
.error:
     popad
     xor   eax, eax
     dec   eax
     mov   [esp+32], eax
     ret
; } \\ Alver, 2007-22-08 \\

uglobal
;// mike.dld, 2006-29-01 [
screen_workarea RECT
;// mike.dld, 2006-29-01 ]
window_minimize db 0
sound_flag	db 0
endg

iglobal
version_inf:
  db 0,7,7,0  ; version 0.7.7.0
  db UID_KOLIBRI
  dd __REV__
version_end:
endg

UID_NONE=0
UID_MENUETOS=1	 ;official
UID_KOLIBRI=2	 ;russian

sys_cachetodiskette:
	cmp	ebx, 1
	jne	.no_floppy_a_save
	mov	[flp_number], 1
	jmp	.save_image_on_floppy
.no_floppy_a_save:
	cmp	ebx, 2
	jne	.no_floppy_b_save
	mov	[flp_number], 2
.save_image_on_floppy:
	call	save_image
	mov	[esp + 32], dword 0
	cmp	[FDC_Status], 0
	je	.yes_floppy_save
.no_floppy_b_save:
	mov	[esp + 32], dword 1
.yes_floppy_save:
	ret

uglobal
;  bgrchanged  dd  0x0
align 4
bgrlockpid dd 0
bgrlock db 0
endg

sys_background:

    cmp   ebx,1 			   ; BACKGROUND SIZE
    jnz   nosb1
    test  ecx,ecx
;    cmp   ecx,0
    jz	  sbgrr
    test  edx,edx
;    cmp   edx,0
    jz	  sbgrr
@@:
;;Maxis use atomic bts for mutexes  4.4.2009
	bts	dword [bgrlock], 0
	jnc	@f
	call	change_task
	jmp	@b
@@:
    mov   [BgrDataWidth],ecx
    mov   [BgrDataHeight],edx
;    mov   [bgrchanged],1

    pushad
; return memory for old background
	mov	eax, [img_background]
	cmp	eax, static_background_data
	jz	@f
	stdcall kernel_free, eax
@@:
; calculate RAW size
    xor  eax,eax
    inc  eax
    cmp  [BgrDataWidth],eax
    jae   @f
    mov [BgrDataWidth],eax
@@:
    cmp  [BgrDataHeight],eax
    jae   @f
    mov [BgrDataHeight],eax
@@:
    mov  eax,[BgrDataWidth]
    imul eax,[BgrDataHeight]
    lea  eax,[eax*3]
    mov  [mem_BACKGROUND],eax
; get memory for new background
    stdcall kernel_alloc, eax
    test eax, eax
    jz .memfailed
    mov [img_background], eax
    jmp .exit
.memfailed:
; revert to static monotone data
	mov	[img_background], static_background_data
	xor	eax, eax
	inc	eax
	mov	[BgrDataWidth], eax
	mov	[BgrDataHeight], eax
	mov	[mem_BACKGROUND], 4
.exit:
    popad
	mov	[bgrlock], 0

  sbgrr:
    ret

nosb1:

    cmp   ebx,2 			   ; SET PIXEL
    jnz   nosb2

    mov   eax, [img_background]
    test  ecx, ecx
    jz	  @f
    cmp   eax, static_background_data
    jz	  .ret
@@:
    mov ebx, [mem_BACKGROUND]
    add ebx, 4095
    and ebx, -4096
    sub ebx, 4
    cmp   ecx, ebx
    ja	 .ret

    mov   ebx,[eax+ecx]
    and   ebx,0xFF000000 ;255*256*256*256
    and   edx,0x00FFFFFF ;255*256*256+255*256+255
    add   edx,ebx
    mov   [eax+ecx],edx
.ret:
    ret
nosb2:

    cmp   ebx,3 			   ; DRAW BACKGROUND
    jnz   nosb3
draw_background_temp:
;    cmp   [bgrchanged],1 ;0
;    je    nosb31
;draw_background_temp:
;    mov   [bgrchanged],1 ;0
    mov    [background_defined], 1
    mov    byte[BACKGROUND_CHANGED], 1
    call  force_redraw_background
   nosb31:
    ret
  nosb3:

    cmp   ebx,4 			   ; TILED / STRETCHED
    jnz   nosb4
    cmp   ecx,[BgrDrawMode]
    je	  nosb41
    mov   [BgrDrawMode],ecx
;    mov   [bgrchanged],1
   nosb41:
    ret
  nosb4:

    cmp   ebx,5 			   ; BLOCK MOVE TO BGR
    jnz   nosb5
    cmp   [img_background], static_background_data
    jnz   @f
    test  edx, edx
    jnz   .fin
    cmp   esi, 4
    ja	  .fin
  @@:
  ; bughere
    mov   eax, ecx
    mov   ebx, edx
    add   ebx, [img_background]   ;IMG_BACKGROUND
    mov   ecx, esi
    call  memmove
  .fin:
    ret
  nosb5:

	cmp	ebx, 6
	jnz	nosb6
;;Maxis use atomic bts for mutex 4.4.2009
@@:
	bts	dword [bgrlock], 0
	jnc	@f
	call	change_task
	jmp	@b
@@:
	mov	eax, [CURRENT_TASK]
	mov	[bgrlockpid], eax
	cmp	[img_background], static_background_data
	jz	.nomem
	stdcall user_alloc, [mem_BACKGROUND]
	mov	[esp+32], eax
	test	eax, eax
	jz	.nomem
	mov	ebx, eax
	shr	ebx, 12
	or	dword [page_tabs+(ebx-1)*4], DONT_FREE_BLOCK
	mov	esi, [img_background]
	shr	esi, 12
	mov	ecx, [mem_BACKGROUND]
	add	ecx, 0xFFF
	shr	ecx, 12
.z:
	mov	eax, [page_tabs+ebx*4]
	test	al, 1
	jz	@f
	call	free_page
@@:
	mov	eax, [page_tabs+esi*4]
	or	al, PG_UW
	mov	[page_tabs+ebx*4], eax
	mov	eax, ebx
	shl	eax, 12
	invlpg	[eax]
	inc	ebx
	inc	esi
	loop	.z
	ret
.nomem:
	and	[bgrlockpid], 0
	mov	[bgrlock], 0
nosb6:
	cmp	ebx, 7
	jnz	nosb7
	cmp	[bgrlock], 0
	jz	.err
	mov	eax, [CURRENT_TASK]
	cmp	[bgrlockpid], eax
	jnz	.err
	mov	eax, ecx
	mov	ebx, ecx
	shr	eax, 12
	mov	ecx, [page_tabs+(eax-1)*4]
	test	cl, USED_BLOCK+DONT_FREE_BLOCK
	jz	.err
	jnp	.err
	push	eax
	shr	ecx, 12
	dec	ecx
@@:
	and	dword [page_tabs+eax*4], 0
	mov	edx, eax
	shl	edx, 12
	push eax
	invlpg	[edx]
	pop eax
	inc	eax
	loop	@b
	pop	eax
	and	dword [page_tabs+(eax-1)*4], not DONT_FREE_BLOCK
	stdcall user_free, ebx
	mov	[esp+32], eax
	and	[bgrlockpid], 0
	mov	[bgrlock], 0
	ret
.err:
	and	dword [esp+32], 0
	ret

nosb7:
    ret

force_redraw_background:
    and   [draw_data+32 + RECT.left], 0
    and   [draw_data+32 + RECT.top], 0
    push  eax ebx
    mov   eax,[Screen_Max_X]
    mov   ebx,[Screen_Max_Y]
    mov   [draw_data+32 + RECT.right],eax
    mov   [draw_data+32 + RECT.bottom],ebx
    pop   ebx eax
    inc   byte[REDRAW_BACKGROUND]
    ret

align 4

sys_getbackground:
;    cmp   eax,1                                  ; SIZE
    dec   ebx
    jnz   nogb1
    mov   eax,[BgrDataWidth]
    shl   eax,16
    mov   ax,[BgrDataHeight]
    mov   [esp+32],eax
    ret

nogb1:
;    cmp   eax,2                                  ; PIXEL
    dec   ebx
    jnz   nogb2

	mov	eax, [img_background]
	test	ecx, ecx
	jz	@f
	cmp	eax, static_background_data
	jz	.ret
@@:
    mov ebx, [mem_BACKGROUND]
    add ebx, 4095
    and ebx, -4096
    sub ebx, 4
    cmp ecx, ebx
    ja	.ret

    mov   eax,[ecx+eax]

    and   eax, 0xFFFFFF
    mov   [esp+32],eax
.ret:
    ret
  nogb2:

;    cmp   eax,4                                  ; TILED / STRETCHED
    dec   ebx
    dec   ebx
    jnz   nogb4
    mov   eax,[BgrDrawMode]
  nogb4:
    mov   [esp+32],eax
    ret

align 4

sys_getkey:
	mov	[esp + 32],dword 1
	; test main buffer
	mov	ebx, [CURRENT_TASK]			     ; TOP OF WINDOW STACK
	movzx	ecx, word [WIN_STACK + ebx * 2]
	mov	edx, [TASK_COUNT]
	cmp	ecx, edx
	jne	.finish
	cmp	[KEY_COUNT], byte 0
	je	.finish
	movzx	eax, byte [KEY_BUFF]
	shl	eax, 8
	push	eax
	dec	byte [KEY_COUNT]
	and	byte [KEY_COUNT], 127
	movzx	ecx, byte [KEY_COUNT]
	add	ecx, 2
	mov	eax, KEY_BUFF + 1
	mov	ebx, KEY_BUFF
	call	memmove
	pop	eax
.ret_eax:
	mov	[esp + 32], eax
	ret
.finish:
; test hotkeys buffer
	mov	ecx, hotkey_buffer
@@:
	cmp	[ecx], ebx
	jz	.found
	add	ecx, 8
	cmp	ecx, hotkey_buffer + 120 * 8
	jb	@b
	ret
.found:
	mov	ax, [ecx + 6]
	shl	eax, 16
	mov	ah, [ecx + 4]
	mov	al, 2
	and	dword [ecx + 4], 0
	and	dword [ecx], 0
	jmp	.ret_eax

align 4

sys_getbutton:

	mov	ebx, [CURRENT_TASK]			    ; TOP OF WINDOW STACK
	mov	[esp + 32], dword 1
	movzx	ecx, word [WIN_STACK + ebx * 2]
	mov	edx, [TASK_COUNT] ; less than 256 processes
	cmp	ecx, edx
	jne	.exit
	movzx	eax, byte [BTN_COUNT]
	test	eax, eax
	jz	.exit
	mov	eax, [BTN_BUFF]
	and	al, 0xFE				    ; delete left button bit
	mov	[BTN_COUNT], byte 0
	mov	[esp + 32], eax
.exit:
	ret


align 4

sys_cpuusage:

;  RETURN:
;
;  +00 dword     process cpu usage
;  +04  word     position in windowing stack
;  +06  word     windowing stack value at current position (cpu nro)
;  +10 12 bytes  name
;  +22 dword     start in mem
;  +26 dword     used mem
;  +30 dword     PID , process idenfification number
;

    cmp  ecx,-1 	; who am I ?
    jne  .no_who_am_i
    mov  ecx,[CURRENT_TASK]
  .no_who_am_i:
	cmp	ecx, max_processes
	ja	.nofillbuf

; +4: word: position of the window of thread in the window stack
	mov	ax, [WIN_STACK + ecx * 2]
	mov	[ebx+4], ax
; +6: word: number of the thread slot, which window has in the window stack
;           position ecx (has no relation to the specific thread)
	mov	ax, [WIN_POS + ecx * 2]
	mov	[ebx+6], ax

	shl	ecx, 5

; +0: dword: memory usage
	mov	eax, [ecx+CURRENT_TASK+TASKDATA.cpu_usage]
	mov	[ebx], eax
; +10: 11 bytes: name of the process
	push	ecx
	lea	eax, [ecx*8+SLOT_BASE+APPDATA.app_name]
	add	ebx, 10
	mov	ecx, 11
	call	memmove
	pop	ecx

; +22: address of the process in memory
; +26: size of used memory - 1
	push	edi
	lea	edi, [ebx+12]
	xor	eax, eax
	mov	edx, 0x100000*16
	cmp	ecx, 1 shl 5
	je	.os_mem
	mov	edx, [SLOT_BASE+ecx*8+APPDATA.mem_size]
	mov	eax, std_application_base_address
.os_mem:
	stosd
	lea	eax, [edx-1]
	stosd

; +30: PID/TID
	mov	eax, [ecx+CURRENT_TASK+TASKDATA.pid]
	stosd

    ; window position and size
	push	esi
	lea	esi, [ecx + window_data + WDATA.box]
	movsd
	movsd
	movsd
	movsd

    ; Process state (+50)
	mov	eax, dword [ecx+CURRENT_TASK+TASKDATA.state]
	stosd

    ; Window client area box
	lea	esi, [ecx*8 + SLOT_BASE + APPDATA.wnd_clientbox]
	movsd
	movsd
	movsd
	movsd

    ; Window state
	mov	al, [ecx+window_data+WDATA.fl_wstate]
	stosb

	pop	esi
	pop	edi

.nofillbuf:
    ; return number of processes

    mov    eax,[TASK_COUNT]
    mov    [esp+32],eax
    ret

align 4
sys_clock:
	cli
  ; Mikhail Lisovin  xx Jan 2005
  @@:	mov   al, 10
	out   0x70, al
	in    al, 0x71
	test  al, al
	jns   @f
	mov   esi, 1
	call  delay_ms
	jmp   @b
  @@:
  ; end Lisovin's fix

	xor   al,al	      ; seconds
	out   0x70,al
	in    al,0x71
	movzx ecx,al
	mov   al,02	      ; minutes
	shl   ecx,16
	out   0x70,al
	in    al,0x71
	movzx edx,al
	mov   al,04	      ; hours
	shl   edx,8
	out   0x70,al
	in    al,0x71
	add   ecx,edx
	movzx edx,al
	add   ecx,edx
	sti
	mov	[esp + 32], ecx
	ret


align 4

sys_date:

	cli
  @@:	mov   al, 10
	out   0x70, al
	in    al, 0x71
	test  al, al
	jns   @f
	mov   esi, 1
	call  delay_ms
	jmp   @b
  @@:

	mov	ch,0
	mov	al,7		; date
	out	0x70,al
	in	al,0x71
	mov	cl,al
	mov	al,8		; month
	shl	ecx,16
	out	0x70,al
	in	al,0x71
	mov	ch,al
	mov	al,9		; year
	out	0x70,al
	in	al,0x71
	mov	cl,al
	sti
	mov	[esp+32], ecx
	ret


; redraw status

sys_redrawstat:
	cmp	ebx, 1
	jne	no_widgets_away
	; buttons away
	mov	ecx,[CURRENT_TASK]
  sys_newba2:
	mov	edi,[BTN_ADDR]
	cmp	[edi], dword 0	; empty button list ?
	je	end_of_buttons_away
	movzx	ebx, word [edi]
	inc	ebx
	mov	eax,edi
  sys_newba:
	dec	ebx
	jz	end_of_buttons_away

	add	eax, 0x10
	cmp	cx, [eax]
	jnz	sys_newba

	push	eax ebx ecx
	mov	ecx,ebx
	inc	ecx
	shl	ecx, 4
	mov	ebx, eax
	add	eax, 0x10
	call	memmove
	dec	dword [edi]
	pop	ecx ebx eax

	jmp	sys_newba2

  end_of_buttons_away:

	ret

  no_widgets_away:

	cmp	ebx, 2
	jnz	srl1

	mov	edx, [TASK_BASE]      ; return whole screen draw area for this app
	add	edx, draw_data - CURRENT_TASK
	mov	[edx + RECT.left], 0
	mov	[edx + RECT.top], 0
	mov	eax, [Screen_Max_X]
	mov	[edx + RECT.right], eax
	mov	eax, [Screen_Max_Y]
	mov	[edx + RECT.bottom], eax

	mov	edi, [TASK_BASE]
	or	[edi - twdw + WDATA.fl_wdrawn], 1   ; no new position & buttons from app
	call	sys_window_mouse
	ret

  srl1:
	ret

;ok - 100% work
;nt - not tested
;---------------------------------------------------------------------------------------------
;eax
;0 - task switch counter. Ret switch counter in eax. Block. ok.
;1 - change task. Ret nothing. Block. ok.
;2 - performance control
; ebx
; 0 - enable or disable (inversion) PCE flag on CR4 for rdmpc in user mode.
; returned new cr4 in eax. Ret cr4 in eax. Block. ok.
; 1 - is cache enabled. Ret cr0 in eax if enabled else zero in eax. Block. ok.
; 2 - enable cache. Ret 1 in eax. Ret nothing. Block. ok.
; 3 - disable cache. Ret 0 in eax. Ret nothing. Block. ok.
;eax
;3 - rdmsr. Counter in edx. (edx:eax) [esi:edi, edx] => [edx:esi, ecx]. Ret in ebx:eax. Block. ok.
;4 - wrmsr. Counter in edx. (edx:eax) [esi:edi, edx] => [edx:esi, ecx]. Ret in ebx:eax. Block. ok.
;---------------------------------------------------------------------------------------------
iglobal
align 4
sheduler:
	dd	sys_sheduler.00
	dd	change_task
	dd	sys_sheduler.02
	dd	sys_sheduler.03
	dd	sys_sheduler.04
endg
sys_sheduler:	
;rewritten by <Lrz>  29.12.2009
	jmp	dword [sheduler+ebx*4]
;.shed_counter:
.00:
	mov eax,[context_counter]
	mov [esp+32],eax
	ret

.02:
;.perf_control:
	inc	ebx			;before ebx=2, ebx=3
	cmp	ebx,ecx 		;if ecx=3, ebx=3
	jz	cache_disable		

	dec	ebx			;ebx=2
	cmp	ebx,ecx 		;
	jz	cache_enable		;if ecx=2 and ebx=2

	dec	ebx			;ebx=1
	cmp	ebx,ecx
	jz	is_cache_enabled	;if ecx=1 and ebx=1

	dec	ebx
	test	ebx,ecx 		;ebx=0 and ecx=0
	jz	modify_pce		;if ecx=0

	ret

.03:	
;.rdmsr_instr:
;now counter in ecx
;(edx:eax) esi:edi => edx:esi
	mov	eax,esi
	mov	ecx,edx
	rdmsr
	mov	[esp+32],eax
	mov	[esp+20],edx		;ret in ebx?
	ret

.04:
;.wrmsr_instr:
;now counter in ecx
;(edx:eax) esi:edi => edx:esi
	; Fast Call MSR can't be destroy
	; <20><> MSR_AMD_EFER <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20>.<2E>. <20> <20>⮬ ॣ<><E0A5A3><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>
	; <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F>몫<EFBFBD><EBAAAB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>७<EFBFBD><E0A5AD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	cmp	edx,MSR_SYSENTER_CS
	je	@f
	cmp	edx,MSR_SYSENTER_ESP
	je	@f
	cmp	edx,MSR_SYSENTER_EIP
	je	@f
	cmp	edx,MSR_AMD_STAR
	je	@f

	mov	eax,esi
	mov	ecx,edx
	wrmsr
	; mov   [esp + 32], eax
	; mov   [esp + 20], edx ;ret in ebx?
@@:
	ret

cache_disable:
       mov eax,cr0
       or  eax,01100000000000000000000000000000b
       mov cr0,eax
       wbinvd ;set MESI
ret

cache_enable:
       mov eax,cr0
       and eax,10011111111111111111111111111111b
       mov cr0,eax
ret

is_cache_enabled:
       mov eax,cr0
       mov ebx,eax
       and eax,01100000000000000000000000000000b
       jz cache_disabled
       mov [esp+32],ebx
cache_disabled:
       mov dword [esp+32],eax ;0
ret

modify_pce:
       mov eax,cr4
;       mov ebx,0
;       or  bx,100000000b ;pce
;       xor eax,ebx ;invert pce
       bts eax,8 ;pce=cr4[8]
       mov cr4,eax
       mov [esp+32],eax
ret
;---------------------------------------------------------------------------------------------


; check if pixel is allowed to be drawn

checkpixel:
	push eax edx

	mov  edx,[Screen_Max_X]     ; screen x size
	inc  edx
	imul edx, ebx
	add  eax, [_WinMapAddress]
	mov  dl, [eax+edx] ; lea eax, [...]

	xor  ecx, ecx
	mov  eax, [CURRENT_TASK]
	cmp  al, dl
	setne cl

	pop  edx eax
	ret

iglobal
  cpustring db 'CPU',0
endg

uglobal
background_defined    db    0	 ; diamond, 11.04.2006
endg

align 4
; check misc

checkmisc:

    cmp   [ctrl_alt_del], 1
    jne   nocpustart

	mov	ebp, cpustring
	call	fs_execute_from_sysdir

    mov   [ctrl_alt_del], 0

nocpustart:
    cmp   [mouse_active], 1
    jne   mouse_not_active
    mov   [mouse_active], 0
    xor   edi, edi
    mov   ecx,	[TASK_COUNT]
set_mouse_event:
    add   edi, 256
    or	  [edi+SLOT_BASE+APPDATA.event_mask], dword 100000b
    loop  set_mouse_event

mouse_not_active:
    cmp   byte[BACKGROUND_CHANGED], 0
    jz	  no_set_bgr_event
    xor   edi, edi
    mov   ecx, [TASK_COUNT]
set_bgr_event:
    add   edi, 256
    or	  [edi+SLOT_BASE+APPDATA.event_mask], 16
    loop  set_bgr_event
    mov   byte[BACKGROUND_CHANGED], 0
no_set_bgr_event:
    cmp   byte[REDRAW_BACKGROUND], 0		   ; background update ?
    jz	  nobackgr
    cmp    [background_defined], 0
    jz	  nobackgr
;    mov   [draw_data+32 + RECT.left],dword 0
;    mov   [draw_data+32 + RECT.top],dword 0
;    mov   eax,[Screen_Max_X]
;    mov   ebx,[Screen_Max_Y]
;    mov   [draw_data+32 + RECT.right],eax
;    mov   [draw_data+32 + RECT.bottom],ebx
@@:
    call  drawbackground
    xor   eax, eax
    xchg  al, [REDRAW_BACKGROUND]
    test  al, al				   ; got new update request?
    jnz   @b
    mov   [draw_data+32 + RECT.left], eax
    mov   [draw_data+32 + RECT.top], eax
    mov   [draw_data+32 + RECT.right], eax
    mov   [draw_data+32 + RECT.bottom], eax
    mov   [MOUSE_BACKGROUND],byte 0

nobackgr:

    ; system shutdown request

    cmp  [SYS_SHUTDOWN],byte 0
    je	 noshutdown

    mov  edx,[shutdown_processes]

    cmp  [SYS_SHUTDOWN],dl
    jne  no_mark_system_shutdown

    lea   ecx,[edx-1]
    mov   edx,OS_BASE+0x3040
    jecxz @f
markz:
    mov   [edx+TASKDATA.state],byte 3
    add   edx,0x20
    loop  markz
@@:

  no_mark_system_shutdown:

    call [_display.disable_mouse]

    dec  byte [SYS_SHUTDOWN]
    je	 system_shutdown

noshutdown:


    mov   eax,[TASK_COUNT]		    ; termination
    mov   ebx,TASK_DATA+TASKDATA.state
    mov   esi,1

newct:
    mov   cl,[ebx]
    cmp   cl,byte 3
    jz	  terminate
    cmp   cl,byte 4
    jz	  terminate

    add   ebx,0x20
    inc   esi
    dec   eax
    jnz   newct
    ret

; redraw screen

redrawscreen:

; eax , if process window_data base is eax, do not set flag/limits

	 pushad
	 push  eax

;;;         mov   ebx,2
;;;         call  delay_hs

	 ;mov   ecx,0               ; redraw flags for apps
	 xor   ecx,ecx
       newdw2:

	 inc   ecx
	 push  ecx

	 mov   eax,ecx
	 shl   eax,5
	 add   eax,window_data

	 cmp   eax,[esp+4]
	 je    not_this_task
				   ; check if window in redraw area
	 mov   edi,eax

	 cmp   ecx,1		   ; limit for background
	 jz    bgli

	 mov   eax, [edi + WDATA.box.left]
	 mov   ebx, [edi + WDATA.box.top]
	 mov   ecx, [edi + WDATA.box.width]
	 mov   edx, [edi + WDATA.box.height]
	 add   ecx,eax
	 add   edx,ebx

	 mov   ecx,[draw_limits.bottom]   ; ecx = area y end     ebx = window y start
	 cmp   ecx,ebx
	 jb    ricino

	 mov   ecx,[draw_limits.right]	 ; ecx = area x end     eax = window x start
	 cmp   ecx,eax
	 jb    ricino

	 mov   eax, [edi + WDATA.box.left]
	 mov   ebx, [edi + WDATA.box.top]
	 mov   ecx, [edi + WDATA.box.width]
	 mov   edx, [edi + WDATA.box.height]
	 add   ecx, eax
	 add   edx, ebx

	 mov   eax,[draw_limits.top]	; eax = area y start     edx = window y end
	 cmp   edx,eax
	 jb    ricino

	 mov   eax,[draw_limits.left]	 ; eax = area x start     ecx = window x end
	 cmp   ecx,eax
	 jb    ricino

	bgli:

	 cmp   dword[esp], 1
	 jnz   .az
;         cmp   byte[BACKGROUND_CHANGED], 0
;         jnz   newdw8
	 cmp   byte[REDRAW_BACKGROUND], 0
	 jz    .az
	 mov   dl, 0
	 lea   eax,[edi+draw_data-window_data]
	 mov   ebx,[draw_limits.left]
	 cmp   ebx,[eax+RECT.left]
	 jae   @f
	 mov   [eax+RECT.left],ebx
	 mov   dl, 1
	@@:
	 mov   ebx,[draw_limits.top]
	 cmp   ebx,[eax+RECT.top]
	 jae   @f
	 mov   [eax+RECT.top],ebx
	 mov   dl, 1
	@@:
	 mov   ebx,[draw_limits.right]
	 cmp   ebx,[eax+RECT.right]
	 jbe   @f
	 mov   [eax+RECT.right],ebx
	 mov   dl, 1
	@@:
	 mov   ebx,[draw_limits.bottom]
	 cmp   ebx,[eax+RECT.bottom]
	 jbe   @f
	 mov   [eax+RECT.bottom],ebx
	 mov   dl, 1
	@@:
	 add   byte[REDRAW_BACKGROUND], dl
	 jmp   newdw8
	.az:

	 mov   eax,edi
	 add   eax,draw_data-window_data

	 mov   ebx,[draw_limits.left]	       ; set limits
	 mov   [eax + RECT.left], ebx
	 mov   ebx,[draw_limits.top]
	 mov   [eax + RECT.top], ebx
	 mov   ebx,[draw_limits.right]
	 mov   [eax + RECT.right], ebx
	 mov   ebx,[draw_limits.bottom]
	 mov   [eax + RECT.bottom], ebx

	 sub   eax,draw_data-window_data

	 cmp   dword [esp],1
	 jne   nobgrd
	 inc   byte[REDRAW_BACKGROUND]

       newdw8:
       nobgrd:

	 mov   [eax + WDATA.fl_redraw],byte 1	 ; mark as redraw

       ricino:

       not_this_task:

	 pop   ecx

	 cmp   ecx,[TASK_COUNT]
	 jle   newdw2

	 pop  eax
	 popad

	 ret

calculatebackground:   ; background

	mov   edi, [_WinMapAddress]		   ; set os to use all pixels
	mov   eax,0x01010101
	mov   ecx, [_WinMapSize]
	shr   ecx, 2
	rep   stosd

	mov   byte[REDRAW_BACKGROUND], 0	      ; do not draw background!
	mov   byte[BACKGROUND_CHANGED], 0

	ret

uglobal
  imax	  dd 0x0
endg



delay_ms:     ; delay in 1/1000 sec


	push  eax
	push  ecx

	mov   ecx,esi
	; <CPU clock fix by Sergey Kuzmin aka Wildwest>
	imul  ecx, 33941
	shr   ecx, 9
	; </CPU clock fix>

	in    al,0x61
	and   al,0x10
	mov   ah,al
	cld

 cnt1:	in    al,0x61
	and   al,0x10
	cmp   al,ah
	jz    cnt1

	mov   ah,al
	loop  cnt1

	pop   ecx
	pop   eax

	ret


set_app_param:
	mov	edi, [TASK_BASE]
	mov	eax, [edi + TASKDATA.event_mask]
	mov	[edi + TASKDATA.event_mask], ebx
	mov	[esp+32], eax
	ret



delay_hs:     ; delay in 1/100 secs
; ebx = delay time
	push  ecx
	push  edx

	mov   edx,[timer_ticks]

      newtic:
	mov   ecx,[timer_ticks]
	sub   ecx,edx
	cmp   ecx,ebx
	jae   zerodelay

	call  change_task

	jmp   newtic

      zerodelay:
	pop   edx
	pop   ecx

	ret

align 16	;very often call this subrutine
memmove:       ; memory move in bytes

; eax = from
; ebx = to
; ecx = no of bytes
    test ecx, ecx
    jle  .ret

    push esi edi ecx

    mov  edi, ebx
    mov  esi, eax

    test ecx, not 11b
    jz	 @f

    push ecx
    shr  ecx, 2
    rep  movsd
    pop  ecx
    and  ecx, 11b
    jz	 .finish
  @@:
    rep  movsb

  .finish:
    pop  ecx edi esi
  .ret:
    ret


; <diamond> Sysfunction 34, read_floppy_file, is obsolete. Use 58 or 70 function instead.
;align 4
;
;read_floppy_file:
;
;; as input
;;
;; eax pointer to file
;; ebx file lenght
;; ecx start 512 byte block number
;; edx number of blocks to read
;; esi pointer to return/work area (atleast 20 000 bytes)
;;
;;
;; on return
;;
;; eax = 0 command succesful
;;       1 no fd base and/or partition defined
;;       2 yet unsupported FS
;;       3 unknown FS
;;       4 partition not defined at hd
;;       5 file not found
;; ebx = size of file
;
;     mov   edi,[TASK_BASE]
;     add   edi,0x10
;     add   esi,[edi]
;     add   eax,[edi]
;
;     pushad
;     mov  edi,esi
;     add  edi,1024
;     mov  esi,0x100000+19*512
;     sub  ecx,1
;     shl  ecx,9
;     add  esi,ecx
;     shl  edx,9
;     mov  ecx,edx
;     cld
;     rep  movsb
;     popad
;
;     mov   [esp+36],eax
;     mov   [esp+24],ebx
;     ret



align 4

sys_programirq:

    mov   eax, [TASK_BASE]
    add   ebx, [eax + TASKDATA.mem_start]

    cmp   ecx, 16
    jae   .not_owner
    mov   edi, [eax + TASKDATA.pid]
    cmp   edi, [irq_owner + 4 * ecx]
    je	  .spril1
.not_owner:
    xor   ecx, ecx
    inc   ecx
    jmp   .end
  .spril1:

    shl   ecx, 6
    mov   esi, ebx
    lea   edi, [irq00read + ecx]
    push  16
    pop   ecx

    cld
    rep   movsd
  .end:
    mov   [esp+32], ecx
    ret


align 4

get_irq_data:
     movzx esi, bh			 ; save number of subfunction, if bh = 1, return data size, otherwise, read data
     xor   bh, bh
     cmp   ebx, 16
     jae   .not_owner
     mov   edx, [4 * ebx + irq_owner]	 ; check for irq owner

     mov   eax,[TASK_BASE]

     cmp   edx,[eax+TASKDATA.pid]
     je    gidril1
.not_owner:
     xor   edx, edx
     dec   edx
     jmp   gid1

  gidril1:

     shl   ebx, 12
     lea   eax, [ebx + IRQ_SAVE]	 ; calculate address of the beginning of buffer + 0x0 - data size
     mov   edx, [eax]			 ;                                              + 0x4 - data offset
     dec   esi
     jz    gid1
     test  edx, edx			 ; check if buffer is empty
     jz    gid1

     mov   ebx, [eax + 0x4]
     mov   edi, ecx

     mov   ecx, 4000			 ; buffer size, used frequently

     cmp   ebx, ecx			 ; check for the end of buffer, if end of buffer, begin cycle again
     jb    @f

     xor   ebx, ebx

   @@:

     lea   esi, [ebx + edx]		 ; calculate data size and offset
     cld
     cmp   esi, ecx			 ; if greater than the buffer size, begin cycle again
     jbe   @f

     sub   ecx, ebx
     sub   edx, ecx

     lea   esi, [eax + ebx + 0x10]
     rep   movsb

     xor   ebx, ebx
   @@:
     lea   esi, [eax + ebx + 0x10]
     mov   ecx, edx
     add   ebx, edx

     rep   movsb
     mov   edx, [eax]
     mov   [eax], ecx			 ; set data size to zero
     mov   [eax + 0x4], ebx		 ; set data offset

   gid1:
     mov   [esp+32], edx		 ; eax
     ret


set_io_access_rights:
      push edi eax
      mov edi, tss._io_map_0
;     mov   ecx,eax
;     and   ecx,7    ; offset in byte
;     shr   eax,3    ; number of byte
;     add   edi,eax
;     mov   ebx,1
;     shl   ebx,cl
     test  ebp,ebp
;     cmp   ebp,0                ; enable access - ebp = 0
     jnz   siar1
;     not   ebx
;     and   [edi],byte bl
     btr [edi], eax
     pop eax edi
     ret
siar1:
     bts [edi], eax
  ;  or    [edi],byte bl        ; disable access - ebp = 1
     pop eax edi
     ret
;reserve/free group of ports
;  * eax = 46 - number function
;  * ebx = 0 - reserve, 1 - free
;  * ecx = number start arrea of ports
;  * edx = number end arrea of ports (include last number of port)
;Return value:
;  * eax = 0 - succesful 
;  * eax = 1 - error
;  * The system has reserve this ports:
;    0..0x2d, 0x30..0x4d, 0x50..0xdf, 0xe5..0xff (include last number of port).
;destroys eax,ebx, ebp
r_f_port_area:

     test  ebx, ebx
     jnz   free_port_area
;     je    r_port_area
;     jmp   free_port_area

;   r_port_area:

;     pushad

     cmp   ecx,edx	      ; beginning > end ?
     ja    rpal1
     cmp   edx,65536
     jae   rpal1
     mov   eax,[RESERVED_PORTS]
     test  eax,eax	      ; no reserved areas ?
     je    rpal2
     cmp   eax,255	      ; max reserved
     jae   rpal1
 rpal3:
     mov   ebx,eax
     shl   ebx,4
     add   ebx,RESERVED_PORTS
     cmp   ecx,[ebx+8]
     ja    rpal4
     cmp   edx,[ebx+4]
     jae   rpal1
;     jb    rpal4
;     jmp   rpal1
 rpal4:
     dec   eax
     jnz   rpal3
     jmp   rpal2
   rpal1:
;     popad
;     mov   eax,1
     xor    eax,eax
     inc    eax
     ret
   rpal2:
;     popad
     ; enable port access at port IO map
	cli
	pushad			      ; start enable io map

	cmp   edx,65536 ;16384
	jae   no_unmask_io ; jge
	mov   eax,ecx
;       push    ebp
	xor	ebp,ebp 	       ; enable - eax = port
new_port_access:
;     pushad
	call	set_io_access_rights
;     popad
     inc   eax
     cmp   eax,edx
     jbe   new_port_access
;       pop     ebp
no_unmask_io:
	popad			      ; end enable io map
     sti

     mov   eax,[RESERVED_PORTS]
     add   eax,1
     mov   [RESERVED_PORTS],eax
     shl   eax,4
     add   eax,RESERVED_PORTS
     mov   ebx,[TASK_BASE]
     mov   ebx,[ebx+TASKDATA.pid]
     mov   [eax],ebx
     mov   [eax+4],ecx
     mov   [eax+8],edx

     xor   eax, eax
     ret

free_port_area:

;     pushad
     mov   eax,[RESERVED_PORTS]     ; no reserved areas ?
     test  eax,eax
     jz    frpal2
     mov   ebx,[TASK_BASE]
     mov   ebx,[ebx+TASKDATA.pid]
   frpal3:
     mov   edi,eax
     shl   edi,4
     add   edi,RESERVED_PORTS
     cmp   ebx,[edi]
     jne   frpal4
     cmp   ecx,[edi+4]
     jne   frpal4
     cmp   edx,[edi+8]
     jne   frpal4
     jmp   frpal1
   frpal4:
     dec   eax
     jnz   frpal3
   frpal2:
;     popad
     inc   eax
     ret
   frpal1:
	push	ecx
	mov   ecx,256
	sub   ecx,eax
	shl   ecx,4
	mov   esi,edi
	add   esi,16
	cld
	rep   movsb

	dec   dword [RESERVED_PORTS]
;popad
;disable port access at port IO map

;     pushad                        ; start disable io map
     pop	eax	;start port
     cmp   edx,65536 ;16384
     jge   no_mask_io

;     mov   eax,ecx
	xor	ebp,ebp
	inc	ebp
new_port_access_disable:
;     pushad
;     mov   ebp,1                  ; disable - eax = port
     call  set_io_access_rights
;     popad
     inc   eax
     cmp   eax,edx
     jbe   new_port_access_disable
no_mask_io:
;     popad                         ; end disable io map
     xor   eax, eax
     ret


reserve_free_irq:

     xor   esi, esi
     inc   esi
     cmp   ecx, 16
     jae   ril1

     push  ecx
     lea   ecx, [irq_owner + 4 * ecx]
     mov   edx, [ecx]
     mov   eax, [TASK_BASE]
     mov   edi, [eax + TASKDATA.pid]
     pop   eax
     dec   ebx
     jnz   reserve_irq

     cmp   edx, edi
     jne   ril1
     dec   esi
     mov   [ecx], esi

     jmp   ril1

  reserve_irq:

     cmp   dword [ecx], 0
     jne   ril1

     mov   ebx, [f_irqs + 4 * eax]

     stdcall attach_int_handler, eax, ebx, dword 0

     mov   [ecx], edi

     dec   esi
   ril1:
     mov   [esp+32], esi ; return in eax
     ret

iglobal
f_irqs:
     dd 0x0
     dd 0x0
     dd p_irq2
     dd p_irq3
     dd p_irq4
     dd p_irq5
     dd p_irq6
     dd p_irq7
     dd p_irq8
     dd p_irq9
     dd p_irq10
     dd p_irq11
     dd 0x0
     dd 0x0
     dd p_irq14
     dd p_irq15

endg

drawbackground:
       inc   [mouse_pause]
       cmp   [SCR_MODE],word 0x12
       je   dbrv20
     dbrv12:
       cmp  [SCR_MODE],word 0100000000000000b
       jge  dbrv20
       cmp  [SCR_MODE],word 0x13
       je   dbrv20
       call  vesa12_drawbackground
       dec   [mouse_pause]
       call   [draw_pointer]
       ret
     dbrv20:
       cmp   [BgrDrawMode],dword 1
       jne   bgrstr
       call  vesa20_drawbackground_tiled
       dec   [mouse_pause]
       call   [draw_pointer]
       ret
     bgrstr:
       call  vesa20_drawbackground_stretch
       dec   [mouse_pause]
       call   [draw_pointer]
       ret

align 4

syscall_putimage:			; PutImage
sys_putimage:
     test  ecx,0x80008000
     jnz   .exit
     test  ecx,0x0000FFFF
     jz    .exit
     test  ecx,0xFFFF0000
     jnz   @f
  .exit:
     ret
 @@:
	mov	edi,[current_slot]
	add	dx,word[edi+APPDATA.wnd_clientbox.top]
	rol	edx,16
	add	dx,word[edi+APPDATA.wnd_clientbox.left]
	rol	edx,16
  .forced:
	push	ebp esi 0
	mov	ebp, putimage_get24bpp
	mov	esi, putimage_init24bpp
sys_putimage_bpp:
;        call    [disable_mouse] ; this will be done in xxx_putimage
;        mov     eax, vga_putimage
	cmp	[SCR_MODE], word 0x12
	jz	@f   ;.doit
	mov	eax, vesa12_putimage
	cmp	[SCR_MODE], word 0100000000000000b
	jae	@f
	cmp	[SCR_MODE], word 0x13
	jnz	.doit
@@:
	mov	eax, vesa20_putimage
.doit:
	inc	[mouse_pause]
	call	eax
	dec	[mouse_pause]
	pop	ebp esi ebp
	jmp	[draw_pointer]
align 4
sys_putimage_palette:
; ebx = pointer to image
; ecx = [xsize]*65536 + [ysize]
; edx = [xstart]*65536 + [ystart]
; esi = number of bits per pixel, must be 8, 24 or 32
; edi = pointer to palette
; ebp = row delta
	mov	eax, [CURRENT_TASK]
	shl	eax, 8
	add	dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.top]
	rol	edx, 16
	add	dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.left]
	rol	edx, 16
.forced:
	cmp	esi, 1
	jnz	@f
	push	edi
	mov	eax, [edi+4]
	sub	eax, [edi]
	push	eax
	push	dword [edi]
	push	0ffffff80h
	mov	edi, esp
	call	put_mono_image
	add	esp, 12
	pop	edi
	ret
@@:
	cmp	esi, 2
	jnz	@f
	push	edi
	push	0ffffff80h
	mov	edi, esp
	call	put_2bit_image
	pop	eax
	pop	edi
	ret
@@:
	cmp	esi, 4
	jnz	@f
	push	edi
	push	0ffffff80h
	mov	edi, esp
	call	put_4bit_image
	pop	eax
	pop	edi
	ret
@@:
	push	ebp esi ebp
	cmp	esi, 8
	jnz	@f
	mov	ebp, putimage_get8bpp
	mov	esi, putimage_init8bpp
	jmp	sys_putimage_bpp
@@:
	cmp	esi, 15
	jnz	@f
	mov	ebp, putimage_get15bpp
	mov	esi, putimage_init15bpp
	jmp	sys_putimage_bpp
@@:
	cmp	esi, 16
	jnz	@f
	mov	ebp, putimage_get16bpp
	mov	esi, putimage_init16bpp
	jmp	sys_putimage_bpp
@@:
	cmp	esi, 24
	jnz	@f
	mov	ebp, putimage_get24bpp
	mov	esi, putimage_init24bpp
	jmp	sys_putimage_bpp
@@:
	cmp	esi, 32
	jnz	@f
	mov	ebp, putimage_get32bpp
	mov	esi, putimage_init32bpp
	jmp	sys_putimage_bpp
@@:
	pop	ebp esi ebp
	ret

put_mono_image:
	push	ebp esi ebp
	mov	ebp, putimage_get1bpp
	mov	esi, putimage_init1bpp
	jmp	sys_putimage_bpp
put_2bit_image:
	push	ebp esi ebp
	mov	ebp, putimage_get2bpp
	mov	esi, putimage_init2bpp
	jmp	sys_putimage_bpp
put_4bit_image:
	push	ebp esi ebp
	mov	ebp, putimage_get4bpp
	mov	esi, putimage_init4bpp
	jmp	sys_putimage_bpp

putimage_init24bpp:
	lea	eax, [eax*3]
putimage_init8bpp:
	ret

align 16
putimage_get24bpp:
	movzx	eax, byte [esi+2]
	shl	eax, 16
	mov	ax, [esi]
	add	esi, 3
	ret	4
align 16
putimage_get8bpp:
	movzx	eax, byte [esi]
	push	edx
	mov	edx, [esp+8]
	mov	eax, [edx+eax*4]
	pop	edx
	inc	esi
	ret	4

putimage_init1bpp:
	add	eax, ecx
	push	ecx
	add	eax, 7
	add	ecx, 7
	shr	eax, 3
	shr	ecx, 3
	sub	eax, ecx
	pop	ecx
	ret
align 16
putimage_get1bpp:
	push	edx
	mov	edx, [esp+8]
	mov	al, [edx]
	add	al, al
	jnz	@f
	lodsb
	adc	al, al
@@:
	mov	[edx], al
	sbb	eax, eax
	and	eax, [edx+8]
	add	eax, [edx+4]
	pop	edx
	ret	4

putimage_init2bpp:
	add	eax, ecx
	push	ecx
	add	ecx, 3
	add	eax, 3
	shr	ecx, 2
	shr	eax, 2
	sub	eax, ecx
	pop	ecx
	ret
align 16
putimage_get2bpp:
	push	edx
	mov	edx, [esp+8]
	mov	al, [edx]
	mov	ah, al
	shr	al, 6
	shl	ah, 2
	jnz	.nonewbyte
	lodsb
	mov	ah, al
	shr	al, 6
	shl	ah, 2
	add	ah, 1
.nonewbyte:
	mov	[edx], ah
	mov	edx, [edx+4]
	movzx	eax, al
	mov	eax, [edx+eax*4]
	pop	edx
	ret	4

putimage_init4bpp:
	add	eax, ecx
	push	ecx
	add	ecx, 1
	add	eax, 1
	shr	ecx, 1
	shr	eax, 1
	sub	eax, ecx
	pop	ecx
	ret
align 16
putimage_get4bpp:
	push	edx
	mov	edx, [esp+8]
	add	byte [edx], 80h
	jc	@f
	movzx	eax, byte [edx+1]
	mov	edx, [edx+4]
	and	eax, 0x0F
	mov	eax, [edx+eax*4]
	pop	edx
	ret	4
@@:
	movzx	eax, byte [esi]
	add	esi, 1
	mov	[edx+1], al
	shr	eax, 4
	mov	edx, [edx+4]
	mov	eax, [edx+eax*4]
	pop	edx
	ret	4

putimage_init32bpp:
	shl	eax, 2
	ret
align 16
putimage_get32bpp:
	lodsd
	ret	4

putimage_init15bpp:
putimage_init16bpp:
	add	eax, eax
	ret
align 16
putimage_get15bpp:
; 0RRRRRGGGGGBBBBB -> 00000000RRRRR000GGGGG000BBBBB000
	push	ecx edx
	movzx	eax, word [esi]
	add	esi, 2
	mov	ecx, eax
	mov	edx, eax
	and	eax, 0x1F
	and	ecx, 0x1F shl 5
	and	edx, 0x1F shl 10
	shl	eax, 3
	shl	ecx, 6
	shl	edx, 9
	or	eax, ecx
	or	eax, edx
	pop	edx ecx
	ret	4

align 16
putimage_get16bpp:
; RRRRRGGGGGGBBBBB -> 00000000RRRRR000GGGGGG00BBBBB000
	push	ecx edx
	movzx	eax, word [esi]
	add	esi, 2
	mov	ecx, eax
	mov	edx, eax
	and	eax, 0x1F
	and	ecx, 0x3F shl 5
	and	edx, 0x1F shl 11
	shl	eax, 3
	shl	ecx, 5
	shl	edx, 8
	or	eax, ecx
	or	eax, edx
	pop	edx ecx
	ret	4

; eax x beginning
; ebx y beginning
; ecx x end
	; edx y end
; edi color

__sys_drawbar:
	mov	esi,[current_slot]
	add	eax,[esi+APPDATA.wnd_clientbox.left]
	add	ecx,[esi+APPDATA.wnd_clientbox.left]
	add	ebx,[esi+APPDATA.wnd_clientbox.top]
	add	edx,[esi+APPDATA.wnd_clientbox.top]
  .forced:
    inc   [mouse_pause]
;        call    [disable_mouse]
    cmp   [SCR_MODE],word 0x12
    je	 dbv20
   sdbv20:
    cmp  [SCR_MODE],word 0100000000000000b
    jge  dbv20
    cmp  [SCR_MODE],word 0x13
    je	 dbv20
    call vesa12_drawbar
    dec   [mouse_pause]
    call   [draw_pointer]
    ret
  dbv20:
    call vesa20_drawbar
    dec   [mouse_pause]
    call   [draw_pointer]
    ret



kb_read:

	push	ecx edx

	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
      kr_loop:
	in	al,0x64
	test	al,1
	jnz	kr_ready
	loop	kr_loop
	mov	ah,1
	jmp	kr_exit
      kr_ready:
	push	ecx
	mov	ecx,32
      kr_delay:
	loop	kr_delay
	pop	ecx
	in	al,0x60
	xor	ah,ah
      kr_exit:

	pop	edx ecx

	ret


kb_write:

	push	ecx edx

	mov	dl,al
;        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
;      kw_loop1:
;        in      al,0x64
;        test    al,0x20
;        jz      kw_ok1
;        loop    kw_loop1
;        mov     ah,1
;        jmp     kw_exit
;      kw_ok1:
	in	al,0x60
	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
      kw_loop:
	in	al,0x64
	test	al,2
	jz	kw_ok
	loop	kw_loop
	mov	ah,1
	jmp	kw_exit
      kw_ok:
	mov	al,dl
	out	0x60,al
	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
      kw_loop3:
	in	al,0x64
	test	al,2
	jz	kw_ok3
	loop	kw_loop3
	mov	ah,1
	jmp	kw_exit
      kw_ok3:
	mov	ah,8
      kw_loop4:
	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
      kw_loop5:
	in	al,0x64
	test	al,1
	jnz	kw_ok4
	loop	kw_loop5
	dec	ah
	jnz	kw_loop4
      kw_ok4:
	xor	ah,ah
      kw_exit:

	pop	edx ecx

	ret


kb_cmd:

	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
      c_wait:
	in	al,0x64
	test	al,2
	jz	c_send
	loop	c_wait
	jmp	c_error
      c_send:
	mov	al,bl
	out	0x64,al
	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
      c_accept:
	in	al,0x64
	test	al,2
	jz	c_ok
	loop	c_accept
      c_error:
	mov	ah,1
	jmp	c_exit
      c_ok:
	xor	ah,ah
      c_exit:
	ret


setmouse:  ; set mousepicture -pointer
	   ; ps2 mouse enable

     mov     [MOUSE_PICTURE],dword mousepointer

     cli

     ret

if used _rdtsc
_rdtsc:
     bt [cpu_caps], CAPS_TSC
     jnc ret_rdtsc
     rdtsc
     ret
   ret_rdtsc:
     mov   edx,0xffffffff
     mov   eax,0xffffffff
     ret
end if

rerouteirqs:

	cli

	mov	al,0x11 	;  icw4, edge triggered
	out	0x20,al
	call	pic_delay
	out	0xA0,al
	call	pic_delay

	mov	al,0x20 	;  generate 0x20 +
	out	0x21,al
	call	pic_delay
	mov	al,0x28 	;  generate 0x28 +
	out	0xA1,al
	call	pic_delay

	mov	al,0x04 	;  slave at irq2
	out	0x21,al
	call	pic_delay
	mov	al,0x02 	;  at irq9
	out	0xA1,al
	call	pic_delay

	mov	al,0x01 	;  8086 mode
	out	0x21,al
	call	pic_delay
	out	0xA1,al
	call	pic_delay

	mov	al,255		; mask all irq's
	out	0xA1,al
	call	pic_delay
	out	0x21,al
	call	pic_delay

	mov	ecx,0x1000
	cld
picl1:	call	pic_delay
	loop	picl1

	mov	al,255		; mask all irq's
	out	0xA1,al
	call	pic_delay
	out	0x21,al
	call	pic_delay

	cli

	ret


pic_delay:

	jmp	pdl1
pdl1:	ret


sys_msg_board_str:

     pushad
   @@:
     cmp    [esi],byte 0
     je     @f
     mov    eax,1
     movzx  ebx,byte [esi]
     call   sys_msg_board
     inc    esi
     jmp    @b
   @@:
     popad
     ret

sys_msg_board_byte:
; in: al = byte to display
; out: nothing
; destroys: nothing
	pushad
	mov	ecx, 2
	shl	eax, 24
	jmp	@f

sys_msg_board_word:
; in: ax = word to display
; out: nothing
; destroys: nothing
	pushad
	mov	ecx, 4
	shl	eax, 16
	jmp	@f

sys_msg_board_dword:
; in: eax = dword to display
; out: nothing
; destroys: nothing
	pushad
	mov	ecx, 8
@@:
	push	ecx
	rol	eax, 4
	push	eax
	and	al, 0xF
	cmp	al, 10
	sbb	al, 69h
	das
	mov	bl, al
	xor	eax, eax
	inc	eax
	call	sys_msg_board
	pop	eax
	pop	ecx
	loop	@b
	popad
	ret

uglobal
  msg_board_data: times 4096 db 0
  msg_board_count dd 0x0
endg

sys_msg_board:

; eax=1 : write :  bl byte to write
; eax=2 :  read :  ebx=0 -> no data, ebx=1 -> data in al

	mov	ecx, [msg_board_count]
	cmp	eax, 1
	jne	.smbl1

if defined debug_com_base

	push	dx ax

       @@:				; Wait for empty transmit register  (yes, this slows down system..)
	mov	dx, debug_com_base+5
	in	al, dx
	test	al, 1 shl 5
	jz	@r

	mov	dx, debug_com_base	; Output the byte
	mov	al, bl
	out	dx, al

	pop	ax dx

end if

	mov	[msg_board_data+ecx],bl
	inc	ecx
	and	ecx, 4095
	mov	[msg_board_count], ecx
	mov	[check_idle_semaphore], 5
	ret
.smbl1:
	cmp	eax, 2
	jne	.smbl2
	test	ecx, ecx
	jz	.smbl21
	mov	eax, msg_board_data+1
	mov	ebx, msg_board_data
	movzx	edx, byte [ebx]
	call	memmove
	dec	[msg_board_count]
	mov	[esp + 36], edx ;eax
	mov	[esp + 24], dword 1
	ret
.smbl21:
	mov	[esp+36], ecx
	mov	[esp+24], ecx
.smbl2:
	ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 66 sys function.                                                ;;
;; in eax=66,ebx in [0..5],ecx,edx                                 ;;
;; out eax                                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
iglobal
align 4
f66call:
	   dd sys_process_def.1   ; 1 = set keyboard mode
	   dd sys_process_def.2   ; 2 = get keyboard mode
	   dd sys_process_def.3   ; 3 = get keyboard ctrl, alt, shift
	   dd sys_process_def.4
	   dd sys_process_def.5
endg




sys_process_def:
	dec	ebx
	cmp	ebx,5
	jae	.not_support	;if >=6 then or eax,-1

	mov	edi, [CURRENT_TASK]
	jmp	dword [f66call+ebx*4]

.not_support:
	or	eax,-1
	ret

.1:
     shl   edi,8
     mov   [edi+SLOT_BASE + APPDATA.keyboard_mode],cl

     ret

.2:				; 2 = get keyboard mode
     shl   edi,8
     movzx eax, byte [SLOT_BASE+edi + APPDATA.keyboard_mode]
     mov   [esp+32],eax
     ret
;     xor   eax,eax
;     movzx eax,byte [shift]
;     movzx ebx,byte [ctrl]
;     shl   ebx,2
;     add   eax,ebx
;     movzx ebx,byte [alt]
;     shl   ebx,3
;     add   eax,ebx
.3:				;3 = get keyboard ctrl, alt, shift
 ;// mike.dld [
     mov   eax, [kb_state]
 ;// mike.dld ]
     mov   [esp+32],eax
     ret

.4:
	mov	eax, hotkey_list
@@:
	cmp	dword [eax+8], 0
	jz	.found_free
	add	eax, 16
	cmp	eax, hotkey_list+16*256
	jb	@b
	mov	dword [esp+32], 1
	ret
.found_free:
	mov	[eax+8], edi
	mov	[eax+4], edx
	movzx	ecx, cl
	lea	ecx, [hotkey_scancodes+ecx*4]
	mov	edx, [ecx]
	mov	[eax], edx
	mov	[ecx], eax
	mov	[eax+12], ecx
	jecxz	@f
	mov	[edx+12], eax
@@:
	and	dword [esp+32], 0
	ret

.5:
	movzx	ebx, cl
	lea	ebx, [hotkey_scancodes+ebx*4]
	mov	eax, [ebx]
.scan:
	test	eax, eax
	jz	.notfound
	cmp	[eax+8], edi
	jnz	.next
	cmp	[eax+4], edx
	jz	.found
.next:
	mov	eax, [eax]
	jmp	.scan
.notfound:
	mov	dword [esp+32], 1
	ret
.found:
	mov	ecx, [eax]
	jecxz	@f
	mov	edx, [eax+12]
	mov	[ecx+12], edx
@@:
	mov	ecx, [eax+12]
	mov	edx, [eax]
	mov	[ecx], edx
	xor	edx, edx
	mov	[eax+4], edx
	mov	[eax+8], edx
	mov	[eax+12], edx
	mov	[eax], edx
	mov	[esp+32], edx
	ret


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 61 sys function.                                                ;;
;; in eax=61,ebx in [1..3]                                         ;;
;; out eax                                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
iglobal
align 4
f61call:
	   dd sys_gs.1	 ; resolution
	   dd sys_gs.2	 ; bits per pixel
	   dd sys_gs.3	 ; bytes per scanline
endg


align 4

sys_gs: 			; direct screen access
	dec	ebx
	cmp	ebx,2
	ja	.not_support
	jmp	dword [f61call+ebx*4]
.not_support:
	or  [esp+32],dword -1
	ret


.1:				; resolution
     mov  eax,[Screen_Max_X]
     shl  eax,16
     mov  ax,[Screen_Max_Y]
     add  eax,0x00010001
     mov  [esp+32],eax
     ret
.2:				; bits per pixel
     movzx eax,byte [ScreenBPP]
     mov   [esp+32],eax
     ret
.3:				; bytes per scanline
     mov   eax,[BytesPerScanLine]
     mov   [esp+32],eax
     ret


align 4 ; PCI functions

sys_pci:

     call  pci_api
     mov   [esp+36],eax
     ret


align 4  ;  system functions

syscall_setpixel:			; SetPixel

	mov	eax, ebx
	mov	ebx, ecx
	mov	ecx, edx
	mov	edx, [TASK_BASE]
	add	eax, [edx-twdw+WDATA.box.left]
	add	ebx, [edx-twdw+WDATA.box.top]
	mov	edi, [current_slot]
	add	eax, [edi+APPDATA.wnd_clientbox.left]
	add	ebx, [edi+APPDATA.wnd_clientbox.top]
	xor	edi, edi ; no force
;       mov     edi, 1
	call	[_display.disable_mouse]
	jmp	[putpixel]

align 4

syscall_writetext:			; WriteText

	mov   eax,[TASK_BASE]
	mov   ebp,[eax-twdw+WDATA.box.left]
	push  esi
	mov   esi,[current_slot]
	add   ebp,[esi+APPDATA.wnd_clientbox.left]
	shl   ebp,16
	add   ebp,[eax-twdw+WDATA.box.top]
	add   bp,word[esi+APPDATA.wnd_clientbox.top]
	pop   esi
	add   ebx,ebp
	mov   eax,edi
	xor   edi,edi
	jmp   dtext

align 4

syscall_openramdiskfile:		; OpenRamdiskFile

	mov	eax, ebx
	mov	ebx, ecx
	mov	ecx, edx
	mov	edx, esi
	mov	esi, 12
	call	fileread
	mov	[esp+32], eax
	ret

align 4

syscall_drawrect:			; DrawRect

	mov	edi, edx ; color + gradient
	and	edi, 0x80FFFFFF
	test	bx, bx	; x.size
	je	.drectr
	test	cx, cx ; y.size
	je	.drectr

	mov	eax, ebx ; bad idea
	mov	ebx, ecx

	movzx	ecx, ax ; ecx - x.size
	shr	eax, 16 ; eax - x.coord
	movzx	edx, bx ; edx - y.size
	shr	ebx, 16 ; ebx - y.coord
	mov	esi, [current_slot]

	add	eax, [esi + APPDATA.wnd_clientbox.left]
	add	ebx, [esi + APPDATA.wnd_clientbox.top]
	add	ecx, eax
	add	edx, ebx
	jmp	[drawbar]
.drectr:
	ret

align 4
syscall_getscreensize:			; GetScreenSize
	mov	ax, [Screen_Max_X]
	shl	eax, 16
	mov	ax, [Screen_Max_Y]
	mov	[esp + 32], eax
	ret

align 4

syscall_cdaudio:			; CD

	cmp	ebx, 4
	jb	.audio
	jz	.eject
	cmp	ebx, 5
	jnz	.ret
.load:
	call	.reserve
	call	LoadMedium
	;call    .free
		jmp		.free
;        ret
.eject:
	call	.reserve
	call	clear_CD_cache
	call	allow_medium_removal
	call	EjectMedium
;        call    .free
		jmp		.free
;        ret
.audio:
     call  sys_cd_audio
     mov   [esp+36-4],eax
.ret:
     ret

.reserve:
	call	reserve_cd
	mov	eax, ecx
	shr	eax, 1
	and	eax, 1
	inc	eax
	mov	[ChannelNumber], ax
	mov	eax, ecx
	and	eax, 1
	mov	[DiskNumber], al
	call	reserve_cd_channel
	and	ebx, 3
	inc	ebx
	mov	[cdpos], ebx
	add	ebx, ebx
	mov	cl, 8
	sub	cl, bl
	mov	al, [DRIVE_DATA+1]
	shr	al, cl
	test	al, 2
	jz	.free;.err
	ret
.free:
	call	free_cd_channel
	and	[cd_status], 0
	ret
.err:
	call	.free
;        pop     eax
	ret

align 4

syscall_getpixel:			; GetPixel
     mov   ecx, [Screen_Max_X]
     inc   ecx
     xor   edx, edx
     mov   eax, ebx
     div   ecx
     mov   ebx, edx
     xchg  eax, ebx
     call  dword [GETPIXEL] ; eax - x, ebx - y
     mov   [esp + 32], ecx
     ret

align 4

syscall_getarea:
;eax = 36
;ebx = pointer to bufer for img BBGGRRBBGGRR...
;ecx = [size x]*65536 + [size y]
;edx = [start x]*65536 + [start y]
     pushad
	 inc   [mouse_pause]
; Check of use of the hardware cursor.
      cmp  [_display.disable_mouse],__sys_disable_mouse
	  jne  @f
; Since the test for the coordinates of the mouse should not be used,
; then use the call [disable_mouse] is not possible!
      cmp  dword [MOUSE_VISIBLE],dword 0
      jne  @f
      pushf
      cli
      call draw_mouse_under
      popf
      mov  [MOUSE_VISIBLE],dword 1
@@:
     mov   edi,ebx
     mov   eax,edx
     shr   eax,16
     mov   ebx,edx
     and   ebx,0xffff
     dec   eax
	   dec	 ebx
     ; eax - x, ebx - y
     mov   edx,ecx
     
     shr   ecx,16
     and   edx,0xffff
     mov   esi,ecx
     ; ecx - size x, edx - size y
	 
	 mov   ebp,edx
	 dec   ebp
     lea   ebp,[ebp*3]
	 
	 imul  ebp,esi
	 
	 mov   esi,ecx
	 dec   esi
	 lea   esi,[esi*3]
	 
     add   ebp,esi
     add   ebp,edi

     add   ebx,edx
	 
.start_y:
     push  ecx edx
.start_x:
     push  eax ebx ecx
     add   eax,ecx

     call  dword [GETPIXEL] ; eax - x, ebx - y
     
     mov   [ebp],cx
     shr   ecx,16
     mov   [ebp+2],cl

     pop   ecx ebx eax
     sub   ebp,3
     dec   ecx
     jnz   .start_x
	 pop   edx ecx
	 dec   ebx
     dec   edx
     jnz   .start_y
     dec	[mouse_pause]
; Check of use of the hardware cursor.
      cmp  [_display.disable_mouse],__sys_disable_mouse
	  jne  @f
	 call  [draw_pointer]
@@:
     popad
     ret

align 4

syscall_drawline:			; DrawLine

	mov	edi, [TASK_BASE]
	movzx	eax, word[edi-twdw+WDATA.box.left]
	mov	ebp, eax
	mov	esi, [current_slot]
	add	ebp, [esi+APPDATA.wnd_clientbox.left]
	add	ax, word[esi+APPDATA.wnd_clientbox.left]
	add	ebp,ebx
	shl	eax, 16
	movzx	ebx, word[edi-twdw+WDATA.box.top]
	add	eax, ebp
	mov	ebp, ebx
	add	ebp, [esi+APPDATA.wnd_clientbox.top]
	add	bx, word[esi+APPDATA.wnd_clientbox.top]
	add	ebp, ecx
	shl	ebx, 16
	xor	edi, edi
	add	ebx, ebp
	mov	ecx, edx
	jmp	[draw_line]

align 4

syscall_getirqowner:			; GetIrqOwner

     cmp   ebx,16
     jae   .err

     cmp   [irq_rights + 4 * ebx], dword 2
     je    .err

     mov   eax,[4 * ebx + irq_owner]
     mov   [esp+32],eax

     ret
.err:
     or    dword [esp+32], -1
     ret

align 4

syscall_reserveportarea:		; ReservePortArea and FreePortArea

     call  r_f_port_area
     mov   [esp+32],eax
     ret

align 4

syscall_threads:			; CreateThreads
; eax=1 create thread
;
;   ebx=thread start
;   ecx=thread stack value
;
; on return : eax = pid

     call  new_sys_threads

     mov   [esp+32],eax
     ret

align 4

stack_driver_stat:

     call  app_stack_handler		; Stack status

;     mov   [check_idle_semaphore],5    ; enable these for zero delay
;     call  change_task                 ; between sent packet

     mov   [esp+32],eax
     ret

align 4

socket: 				; Socket interface
     call  app_socket_handler

;     mov   [check_idle_semaphore],5    ; enable these for zero delay
;     call  change_task                 ; between sent packet

     mov   [esp+36],eax
     mov   [esp+24],ebx
     ret

align 4

read_from_hd:				; Read from hd - fn not in use

     mov   edi,[TASK_BASE]
     add   edi,TASKDATA.mem_start
     add   eax,[edi]
     add   ecx,[edi]
     add   edx,[edi]
     call  file_read

     mov   [esp+36],eax
     mov   [esp+24],ebx

     ret

paleholder:
	ret

align 4
set_screen:
	cmp eax, [Screen_Max_X]
	jne .set

	cmp edx, [Screen_Max_Y]
	jne .set
	ret
.set:
	pushfd
	cli

	mov [Screen_Max_X], eax
	mov [Screen_Max_Y], edx
	mov [BytesPerScanLine], ecx

	mov [screen_workarea.right],eax
	mov [screen_workarea.bottom], edx

	push ebx
	push esi
	push edi

	pushad

	stdcall kernel_free, [_WinMapAddress]

	mov eax, [_display.width]
	mul [_display.height]
	mov [_WinMapSize], eax

	stdcall kernel_alloc, eax
	mov [_WinMapAddress], eax
	test eax, eax
	jz .epic_fail

	popad

	call	repos_windows
	xor eax, eax
	xor ebx, ebx
	mov	ecx, [Screen_Max_X]
	mov	edx, [Screen_Max_Y]
	call	calculatescreen
	pop edi
	pop esi
	pop ebx

	popfd
	ret

.epic_fail:
	hlt			; Houston, we've had a problem

; --------------- APM ---------------------
uglobal
apm_entry	dp	0
apm_vf		dd	0
endg

align 4
sys_apm:
	xor	eax,eax
	cmp	word [apm_vf], ax	; Check APM BIOS enable
	jne	@f
	inc	eax
	or	dword [esp + 44], eax	; error
	add	eax,7
	mov	dword [esp + 32], eax	; 32-bit protected-mode interface not supported
	ret

@@:
;       xchg    eax, ecx
;       xchg    ebx, ecx

	cmp	dx, 3
	ja	@f
	and	[esp + 44], byte 0xfe	 ; emulate func 0..3 as func 0
	mov	eax,[apm_vf]
	mov	[esp + 32], eax
	shr	eax, 16
	mov	[esp + 28], eax
	ret

@@:

	mov	esi,[master_tab+(OS_BASE shr 20)]
	xchg	[master_tab], esi
	push	esi
	mov	edi, cr3
	mov	cr3, edi		;flush TLB

	call	pword [apm_entry]	;call APM BIOS

	xchg	eax, [esp]
	mov	[master_tab], eax
	mov	eax, cr3
	mov	cr3, eax
	pop eax

	mov	[esp + 4 ], edi
	mov	[esp + 8], esi
	mov	[esp + 20], ebx
	mov	[esp + 24], edx
	mov	[esp + 28], ecx
	mov	[esp + 32], eax
	setc	al
	and	[esp + 44], byte 0xfe
	or	[esp + 44], al
	ret
; -----------------------------------------

align 4

undefined_syscall:			; Undefined system call
     mov   [esp + 32], dword -1
     ret

align 4
system_shutdown:	  ; shut down the system

	   cmp byte [BOOT_VAR+0x9030], 1
	   jne @F
	   ret
@@:
	   call stop_all_services
	   push 3		 ; stop playing cd
	   pop	eax
	   call sys_cd_audio

yes_shutdown_param:
	   cli

	   mov	eax, kernel_file ; load kernel.mnt to 0x7000:0
	   push 12
	   pop	esi
	   xor	ebx,ebx
	   or	ecx,-1
	   mov	edx, OS_BASE+0x70000
	   call fileread

	   mov	esi, restart_kernel_4000+OS_BASE+0x10000 ; move kernel re-starter to 0x4000:0
	   mov	edi,OS_BASE+0x40000
	   mov	ecx,1000
	   rep	movsb

	   mov	esi,OS_BASE+0x2F0000	; restore 0x0 - 0xffff
	   mov	edi, OS_BASE
	   mov	ecx,0x10000/4
	   cld
	   rep movsd

	   call restorefatchain

	   mov al, 0xFF
	   out 0x21, al
	   out 0xA1, al

if 0
	   mov	word [OS_BASE+0x467+0],pr_mode_exit
	   mov	word [OS_BASE+0x467+2],0x1000

	   mov	al,0x0F
	   out	0x70,al
	   mov	al,0x05
	   out	0x71,al

	   mov	al,0xFE
	   out	0x64,al

	   hlt
	   jmp $-1

else
	cmp	byte [OS_BASE + 0x9030], 2
	jnz	no_acpi_power_off

; scan for RSDP
; 1) The first 1 Kb of the Extended BIOS Data Area (EBDA).
	movzx	eax, word [OS_BASE + 0x40E]
	shl	eax, 4
	jz	@f
	mov	ecx, 1024/16
	call	scan_rsdp
	jnc	.rsdp_found
@@:
; 2) The BIOS read-only memory space between 0E0000h and 0FFFFFh.
	mov	eax, 0xE0000
	mov	ecx, 0x2000
	call	scan_rsdp
	jc	no_acpi_power_off
.rsdp_found:
	mov	esi, [eax+16]	; esi contains physical address of the RSDT
	mov	ebp, [ipc_tmp]
	stdcall map_page, ebp, esi, PG_MAP
	lea	eax, [esi+1000h]
	lea	edx, [ebp+1000h]
	stdcall map_page, edx, eax, PG_MAP
	and	esi, 0xFFF
	add	esi, ebp
	cmp	dword [esi], 'RSDT'
	jnz	no_acpi_power_off
	mov	ecx, [esi+4]
	sub	ecx, 24h
	jbe	no_acpi_power_off
	shr	ecx, 2
	add	esi, 24h
.scan_fadt:
	lodsd
	mov	ebx, eax
	lea	eax, [ebp+2000h]
	stdcall map_page, eax, ebx, PG_MAP
	lea	eax, [ebp+3000h]
	add	ebx, 0x1000
	stdcall map_page, eax, ebx, PG_MAP
	and	ebx, 0xFFF
	lea	ebx, [ebx+ebp+2000h]
	cmp	dword [ebx], 'FACP'
	jz	.fadt_found
	loop	.scan_fadt
	jmp	no_acpi_power_off
.fadt_found:
; ebx is linear address of FADT
	mov	edi, [ebx+40] ; physical address of the DSDT
	lea	eax, [ebp+4000h]
	stdcall map_page, eax, edi, PG_MAP
	lea	eax, [ebp+5000h]
	lea	esi, [edi+0x1000]
	stdcall map_page, eax, esi, PG_MAP
	and	esi, 0xFFF
	sub	edi, esi
	cmp	dword [esi+ebp+4000h], 'DSDT'
	jnz	no_acpi_power_off
	mov	eax, [esi+ebp+4004h] ; DSDT length
	sub	eax, 36+4
	jbe	no_acpi_power_off
	add	esi, 36
.scan_dsdt:
	cmp	dword [esi+ebp+4000h], '_S5_'
	jnz	.scan_dsdt_cont
	cmp	byte [esi+ebp+4000h+4], 12h ; DefPackage opcode
	jnz	.scan_dsdt_cont
	mov	dl, [esi+ebp+4000h+6]
	cmp	dl, 4 ; _S5_ package must contain 4 bytes
		      ; ...in theory; in practice, VirtualBox has 2 bytes
	ja	.scan_dsdt_cont
	cmp	dl, 1
	jb	.scan_dsdt_cont
	lea	esi, [esi+ebp+4000h+7]
	xor	ecx, ecx
	cmp	byte [esi], 0 ; 0 means zero byte, 0Ah xx means byte xx
	jz	@f
	cmp	byte [esi], 0xA
	jnz	no_acpi_power_off
	inc	esi
	mov	cl, [esi]
@@:
	inc	esi
	cmp	dl, 2
	jb	@f
	cmp	byte [esi], 0
	jz	@f
	cmp	byte [esi], 0xA
	jnz	no_acpi_power_off
	inc	esi
	mov	ch, [esi]
@@:
	jmp	do_acpi_power_off
.scan_dsdt_cont:
	inc	esi
	cmp	esi, 0x1000
	jb	@f
	sub	esi, 0x1000
	add	edi, 0x1000
	push	eax
	lea	eax, [ebp+4000h]
	stdcall map_page, eax, edi, PG_MAP
	push	PG_MAP
	lea	eax, [edi+1000h]
	push	eax
	lea	eax, [ebp+5000h]
	push	eax
	stdcall map_page
	pop	eax
@@:
	dec	eax
	jnz	.scan_dsdt
	jmp	no_acpi_power_off
do_acpi_power_off:
	mov	edx, [ebx+48]
	test	edx, edx
	jz	.nosmi
	mov	al, [ebx+52]
	out	dx, al
	mov	edx, [ebx+64]
@@:
	in	ax, dx
	test	al, 1
	jz	@b
.nosmi:
	and	cx, 0x0707
	shl	cx, 2
	or	cx, 0x2020
	mov	edx, [ebx+64]
	in	ax, dx
	and	ax, 203h
	or	ah, cl
	out	dx, ax
	mov	edx, [ebx+68]
	test	edx, edx
	jz	@f
	in	ax, dx
	and	ax, 203h
	or	ah, ch
	out	dx, ax
@@:
	jmp	$


no_acpi_power_off:
	   mov	word [OS_BASE+0x467+0],pr_mode_exit
	   mov	word [OS_BASE+0x467+2],0x1000

	   mov	al,0x0F
	   out	0x70,al
	   mov	al,0x05
	   out	0x71,al

	   mov	al,0xFE
	   out	0x64,al

	   hlt
	   jmp $-1

scan_rsdp:
	add	eax, OS_BASE
.s:
	cmp	dword [eax], 'RSD '
	jnz	.n
	cmp	dword [eax+4], 'PTR '
	jnz	.n
	xor	edx, edx
	xor	esi, esi
@@:
	add	dl, [eax+esi]
	inc	esi
	cmp	esi, 20
	jnz	@b
	test	dl, dl
	jz	.ok
.n:
	add	eax, 10h
	loop	.s
	stc
.ok:
	ret
end if

include "data32.inc"

__REV__ = __REV

uglobals_size = $ - endofcode
diff16 "end of kernel code",0,$