61,7 → 61,7 |
$Revision$ |
|
|
USE_COM_IRQ equ 1 ; make irq 3 and irq 4 available for PCI devices |
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 |
70,14 → 70,14 |
include "kglobals.inc" |
|
include "const.inc" |
max_processes equ 255 |
tss_step equ (128+8192) ; tss & i/o - 65535 ports, * 256=557056*4 |
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_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) |
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) |
116,8 → 116,8 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|
use16 |
org 0x0 |
jmp start_of_code |
org 0x0 |
jmp start_of_code |
|
version db 'Kolibri OS version 0.7.7.0+ ',13,10,13,10,0 |
|
130,6 → 130,8 |
include "bus/pci/pci16.inc" |
include "detect/biosdisk.inc" |
|
diff16 "end of code16 ",0,$ |
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; SWITCH TO 32 BIT PROTECTED MODE ;; |
139,124 → 141,109 |
|
; CR0 Flags - Protected mode and Paging |
|
mov ecx, CR0_PE |
mov ecx, CR0_PE |
|
; Enabling 32 bit protected mode |
|
sidt [cs:old_ints_h] |
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 |
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 |
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 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 +10011010b |
db 0x00 |
|
dw 0xffff |
dw 0x0000 |
db 0x00 |
dw 11011111b *256 +10010010b |
db 0x00 |
dw 0xffff |
dw 0x0000 |
db 0x00 |
dw 11011111b *256 +10010010b |
db 0x00 |
|
diff16 "end of tmp_gdt ",0,$ |
|
include "data16.inc" |
|
diff16 "end of data16 ",0,$ |
|
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 |
diff16 "32-bit code start ",0,$ |
mov ax,os_stack ; Selector for os |
mov ds,ax |
mov es,ax |
mov fs,ax |
mov gs,ax |
mov ss,ax |
mov esp,0x4ec00 ; Set stack |
|
; CLEAR 0x280000 - HEAP_BASE |
;------------------------------------------------------------------------------- |
call preinit_mem ; (init.inc) |
|
xor eax,eax |
mov edi,0x280000 |
mov ecx,(HEAP_BASE-OS_BASE-0x280000) / 4 |
cld |
rep stosd |
call test_cpu ; (init.inc - to be moved to bus/CPU.inc) |
bts [cpu_caps-OS_BASE], CAPS_TSC ;force use rdtsc |
|
mov edi,0x40000 |
mov ecx,(0x90000-0x40000)/4 |
rep stosd |
call init_BIOS32 ; (init.inc - to be removed later) |
|
; CLEAR KERNEL UNDEFINED GLOBALS |
mov edi, endofcode-OS_BASE |
mov ecx, (uglobals_size/4)+4 |
rep stosd |
; PCIe extended config space access |
call rs7xx_pcie_init ; (bus/HT.inc) |
|
; 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 init_mem |
call init_page_map |
call init_mem ; (init.inc) |
call init_page_map ; (init.inc) |
|
; ENABLE PAGING |
|
mov eax, sys_pgdir-OS_BASE |
mov cr3, eax |
mov eax, sys_pgdir-OS_BASE |
mov cr3, eax |
|
mov eax,cr0 |
or eax,CR0_PG+CR0_WP |
mov cr0,eax |
mov eax,cr0 |
or eax,CR0_PG+CR0_WP |
mov cr0,eax |
|
lgdt [gdts] |
jmp pword os_code:high_code |
lgdt [gdts] |
jmp pword os_code:high_code |
|
align 4 |
bios32_entry dd ? |
tmp_page_tabs dd ? |
bios32_entry dd ? |
tmp_page_tabs dd ? |
|
use16 |
org $-0x10000 |
272,45 → 259,45 |
|
align 4 |
high_code: |
mov ax, os_stack |
mov bx, app_data |
mov cx, app_tls |
mov ss, ax |
add esp, OS_BASE |
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 |
mov ds, bx |
mov es, bx |
mov fs, cx |
mov gs, bx |
|
bt [cpu_caps], CAPS_PGE |
jnc @F |
bt [cpu_caps], CAPS_PGE |
jnc @F |
|
or dword [sys_pgdir+(OS_BASE shr 20)], PG_GLOBAL |
or dword [sys_pgdir+(OS_BASE shr 20)], PG_GLOBAL |
|
mov ebx, cr4 |
or ebx, CR4_PGE |
mov cr4, ebx |
mov ebx, cr4 |
or ebx, CR4_PGE |
mov cr4, ebx |
@@: |
xor eax, eax |
mov dword [sys_pgdir], eax |
mov dword [sys_pgdir+4], eax |
xor eax, eax |
mov dword [sys_pgdir], eax |
mov dword [sys_pgdir+4], eax |
|
mov eax, cr3 |
mov cr3, eax ; flush TLB |
mov eax, cr3 |
mov cr3, eax ; flush TLB |
|
; SAVE REAL MODE VARIABLES |
mov ax, [BOOT_VAR + 0x9031] |
mov [IDEContrRegsBaseAddr], ax |
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 |
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 |
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 |
movzx edx,word [BOOT_VAR+0x9054] ; real-mode segment base address of |
; protected-mode 16-bit data segment |
|
shl eax, 4 |
334,261 → 321,237 |
mov eax, [BOOT_VAR + 0x9044] ; version & flags |
mov [apm_vf], eax |
; ----------------------------------------- |
; movzx eax,byte [BOOT_VAR+0x9010] ; mouse port |
; 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 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 |
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 |
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 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 |
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 |
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 0100000000000000b |
jge setvesa20 |
mov eax, 0xDEADBEEF |
hlt |
; === EGA, VGA & Vesa 1.2 modes not supported === |
setvesa20: |
; mov [PUTPIXEL],dword Vesa20_putpixel24 ; Vesa 2.0 24bpp modes |
; mov [GETPIXEL],dword Vesa20_getpixel24 |
; cmp [ScreenBPP],byte 24 |
; jz v20ga24 |
v20ga32: |
mov [PUTPIXEL],dword Vesa20_putpixel32 |
mov [GETPIXEL],dword Vesa20_getpixel32 |
setvesa20: |
v20ga32: |
mov [PUTPIXEL],dword Vesa20_putpixel32 |
mov [GETPIXEL],dword Vesa20_getpixel32 |
|
; -------- 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 |
mov ecx, MSR_AMD_EFER |
rdmsr |
or eax, 1 ; bit_0 - System Call Extension (SCE) |
wrmsr |
|
; Bits of EDX : |
; Bit 3116 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 150 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. |
; Bits of EDX : |
; Bit 31..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..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, 0x1B000B ; RING3 task stack will be used for fast syscalls! |
mov edx, 0x1B000B ; RING3 task stack will be used for fast syscalls! |
|
mov eax, syscall_entry |
mov ecx, MSR_AMD_STAR |
wrmsr |
mov eax, syscall_entry |
mov ecx, MSR_AMD_STAR |
wrmsr |
.noSYSCALL: |
; ----------------------------------------- |
stdcall alloc_page |
stdcall map_page, tss-0xF80, eax, PG_SW ; lower 0xF80 bytes might be used for something |
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 |
stdcall alloc_page |
stdcall map_page, tss-0xF80, eax, PG_SW ; lower 0xF80 bytes might be used for something |
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 build_interrupt_table ;lidt is executed |
;lidt [idtreg] |
|
call init_kernel_heap |
stdcall kernel_alloc, RING0_STACK_SIZE+512 |
mov [os_stack_seg], eax |
call init_kernel_heap |
stdcall kernel_alloc, RING0_STACK_SIZE+512 |
mov [os_stack_seg], eax |
|
lea esp, [eax+RING0_STACK_SIZE] |
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 |
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 |
mov edi, tss._io_map_0 |
xor eax, eax |
mov ecx, 2047 |
rep stosd ; access to 65504 ports granted |
not eax ; the last 32 ports blocked |
stosd |
|
mov ax,tss0 |
ltr ax |
mov ax,tss0 |
ltr ax |
|
mov [LFBSize], 0x800000 |
call init_LFB |
call init_fpu |
call init_malloc |
mov [LFBSize], 0x800000 |
call init_LFB |
call init_fpu |
call init_malloc |
;- |
stdcall alloc_kernel_space, 0x51000 |
mov [default_io_map], eax |
|
stdcall alloc_kernel_space, 0x51000 |
mov [default_io_map], eax |
add eax, 0x2000 |
mov [ipc_tmp], eax |
mov ebx, 0x1000 |
|
add eax, 0x2000 |
mov [ipc_tmp], eax |
mov ebx, 0x1000 |
add eax, 0x40000 |
mov [proc_mem_map], eax |
|
add eax, 0x40000 |
mov [proc_mem_map], eax |
add eax, 0x8000 |
mov [proc_mem_pdir], eax |
|
add eax, 0x8000 |
mov [proc_mem_pdir], eax |
add eax, ebx |
mov [proc_mem_tab], eax |
|
add eax, ebx |
mov [proc_mem_tab], eax |
add eax, ebx |
mov [tmp_task_pdir], eax |
|
add eax, ebx |
mov [tmp_task_pdir], eax |
add eax, ebx |
mov [tmp_task_ptab], eax |
|
add eax, ebx |
mov [tmp_task_ptab], eax |
add eax, ebx |
mov [ipc_pdir], eax |
|
add eax, ebx |
mov [ipc_pdir], eax |
add eax, ebx |
mov [ipc_ptab], 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 |
|
stdcall kernel_alloc, (unpack.LZMA_BASE_SIZE+(unpack.LZMA_LIT_SIZE shl \ |
(unpack.lc+unpack.lp)))*4 |
mov [unpack.p], eax |
|
mov [unpack.p], eax |
call init_events |
mov eax, srv.fd-SRV_FD_OFFSET |
mov [srv.fd], eax |
mov [srv.bk], 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 |
|
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 |
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 |
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 |
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 [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 |
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 |
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 |
call rerouteirqs |
|
; Initialize system V86 machine |
call init_sys_v86 |
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 |
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 |
mov al, 0xFA |
out 0x21, al |
mov al, 0x3F |
out 0xA1, al |
|
;!!!!!!!!!!!!!!!!!!!!!!!!!! |
include 'detect/disks.inc' |
604,7 → 567,7 |
; mov [dma_hdd],1 |
; CALCULATE FAT CHAIN FOR RAMDISK |
|
call calculatefatchain |
call calculatefatchain |
|
; LOAD VMODE DRIVER |
|
614,60 → 577,60 |
|
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} |
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 |
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 |
stdcall read_file, char, FONT_I, 0, 2304 |
stdcall read_file, char2, FONT_II, 0, 2560 |
|
mov esi,boot_fonts |
call boot_log |
mov esi,boot_fonts |
call boot_log |
|
; PRINT AMOUNT OF MEMORY |
mov esi, boot_memdetect |
call boot_log |
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 |
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 |
call display_number_force |
|
; BUILD SCHEDULER |
|
call build_scheduler ; sys32.inc |
call build_scheduler ; sys32.inc |
|
mov esi,boot_devices |
call boot_log |
mov esi,boot_devices |
call boot_log |
|
mov [pci_access_enabled],1 |
mov [pci_access_enabled],1 |
|
|
; SET PRELIMINARY WINDOW STACK AND POSITIONS |
|
mov esi,boot_windefs |
call boot_log |
call set_window_defaults |
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 |
mov esi,boot_bgr |
call boot_log |
call init_background |
call calculatebackground |
|
; RESERVE SYSTEM IRQ'S JA PORT'S |
|
678,202 → 641,182 |
|
; SET UP OS TASK |
|
mov esi,boot_setostask |
call boot_log |
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 |
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 |
; 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 |
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 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 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 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 |
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 |
; 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 |
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 |
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 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 |
; ¢®®¡é¥-â® ¯à®¨§¢®¤¨â¥«ì®áâì ¢ ¤ ®¬ ª®ªà¥â®¬ ¬¥á⥠|
; ᮢ¥à襮 ¥ªà¨â¨ç , ® çâ®¡ë § âªãâì «î¡¨â¥«¥© |
; ®¯â¨¬¨§¨àãîé¨å ª®¬¯¨«ïâ®à®¢ ... |
mov edx, 2251799814 |
mul edx |
shr edx, 19 |
mov [stall_mcs], edx |
; faster division possible: |
mov edx, 2251799814 |
mul edx |
shr edx, 19 |
mov [stall_mcs], edx |
; PRINT CPU FREQUENCY |
mov esi, boot_cpufreq |
call boot_log |
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 |
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 |
call display_number_force |
|
; SET VARIABLES |
|
call set_variables |
call set_variables |
|
; SET MOUSE |
|
;call detect_devices |
stdcall load_driver, szPS2MDriver |
;call detect_devices |
stdcall load_driver, szPS2MDriver |
; stdcall load_driver, szCOM_MDriver |
|
mov esi,boot_setmouse |
call boot_log |
call setmouse |
mov esi,boot_setmouse |
call boot_log |
call setmouse |
|
|
; STACK AND FDC |
|
call stack_init |
call fdc_init |
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 |
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 |
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 |
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} |
cmp ax,'r1' ; if not rused ram disk - load network configuration from files {SPraid.simba} |
je no_st_network |
call set_network_conf |
call set_network_conf |
no_st_network: |
|
call init_userDMA ; <<<<<<<<< ============== core/memory.inc ================= |
mov esi, boot_uDMA_ok |
call boot_log |
; call pci_ext_config ; <<<<<<<<< bus/pci/pcie.inc |
;------------------------------------------------------------------------------- |
call rs7xx_pcie_init ; <<<<<<<<< bus/ht.inc |
call init_userDMA ; <<<<<<<<< ============== core/memory.inc ================= |
mov esi, boot_uDMA_ok |
call boot_log |
|
; LOAD FIRST APPLICATION |
cli |
cli |
|
cmp byte [BOOT_VAR+0x9030],1 |
jne no_load_vrr_m |
cmp byte [BOOT_VAR+0x9030],1 |
jne no_load_vrr_m |
|
mov ebp, vrr_m |
call fs_execute_from_sysdir |
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 |
jz first_app_found |
|
no_load_vrr_m: |
|
mov ebp, firstapp |
call fs_execute_from_sysdir |
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 |
jz first_app_found |
|
mov esi, boot_failed |
call boot_log |
mov esi, boot_failed |
call boot_log |
|
mov eax, 0xDEADBEEF ; otherwise halt |
hlt |
mov eax, 0xDEADBEEF ; otherwise halt |
hlt |
|
first_app_found: |
|
cli |
cli |
|
;mov [TASK_COUNT],dword 2 |
;mov [TASK_COUNT],dword 2 |
push 1 |
pop dword [CURRENT_TASK] ; set OS task fisrt |
pop dword [CURRENT_TASK] ; set OS task fisrt |
|
; SET KEYBOARD PARAMETERS |
mov al, 0xf6 ; reset keyboard, scan enabled |
call kb_write |
mov al, 0xf6 ; reset keyboard, scan enabled |
call kb_write |
|
; wait until 8042 is ready |
xor ecx,ecx |
; wait until 8042 is ready |
xor ecx,ecx |
@@: |
in al,64h |
and al,00000010b |
loopnz @b |
in al,64h |
and al,00000010b |
loopnz @b |
|
; mov al, 0xED ; svetodiody - only for testing! |
; call kb_write |
882,14 → 825,14 |
; call kb_write |
; call kb_read |
|
mov al, 0xF3 ; set repeat rate & delay |
call kb_write |
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 |
mov al, 0 ; 30 250 ;00100010b ; 24 500 ;00100100b ; 20 500 |
call kb_write |
; call kb_read |
;// mike.dld [ |
call set_lights |
call set_lights |
;// mike.dld ] |
|
|
897,39 → 840,39 |
|
if defined debug_com_base |
|
; enable Divisor latch |
; enable Divisor latch |
|
mov dx, debug_com_base+3 |
mov al, 1 shl 7 |
out dx, al |
mov dx, debug_com_base+3 |
mov al, 1 shl 7 |
out dx, al |
|
; Set speed to 115200 baud (max speed) |
; Set speed to 115200 baud (max speed) |
|
mov dx, debug_com_base |
mov al, 0x01 |
out dx, al |
mov dx, debug_com_base |
mov al, 0x01 |
out dx, al |
|
mov dx, debug_com_base+1 |
mov al, 0x00 |
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 |
; No parity, 8bits words, one stop bit, dlab bit back to 0 |
|
mov dx, debug_com_base+3 |
mov al, 3 |
out dx, al |
mov dx, debug_com_base+3 |
mov al, 3 |
out dx, al |
|
; disable interrupts |
; disable interrupts |
|
mov dx, debug_com_base+1 |
mov al, 0 |
out dx, al |
mov dx, debug_com_base+1 |
mov al, 0 |
out dx, al |
|
; clear + enable fifo (64 bits) |
; clear + enable fifo (64 bits) |
|
mov dx, debug_com_base+2 |
mov al, 0x7 + 1 shl 5 |
out dx, al |
mov dx, debug_com_base+2 |
mov al, 0x7 + 1 shl 5 |
out dx, al |
|
|
end if |
937,11 → 880,11 |
; 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 |
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 |
966,21 → 909,21 |
; |
; loop ready_for_irqs ; flush the queue |
|
stdcall attach_int_handler, 1, irq1, 0 |
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 |
cmp [IDEContrRegsBaseAddr], 0 |
setnz [dma_hdd] |
mov [timer_ticks_enable],1 ; for cd driver |
|
sti |
call change_task |
sti |
call change_task |
|
jmp osloop |
jmp osloop |
|
; jmp $ ; wait here for timer to take control |
|
; Fly :) |
; Fly :) |
|
include 'unpacker.inc' |
include 'fdo.inc' |
987,23 → 930,23 |
|
align 4 |
boot_log: |
pushad |
pushad |
|
mov ebx,10*65536 |
mov bx,word [boot_y] |
add [boot_y],dword 10 |
mov ecx,0x80ffffff ; ASCIIZ string with white color |
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 |
mov edx,esi |
inc edi |
call dtext |
call dtext |
|
; mov [novesachecksum],1000 |
; call checkVga_N13 |
|
popad |
popad |
|
ret |
ret |
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; ; |
1012,16 → 955,16 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
align 32 |
osloop: |
call [draw_pointer] |
call window_check_events |
call mouse_check_events |
call checkmisc |
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 stack_handler |
call checkidle |
call check_fdd_motor_status |
; call check_ATAPI_device_event |
jmp osloop |
jmp osloop |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; ; |
; MAIN OS LOOP END ; |
1029,33 → 972,33 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
align 4 |
checkidle: |
pushad |
call change_task |
jmp idle_loop_entry |
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 |
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] |
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 |
mov [idlemem],eax ; eax == [timer_ticks] |
popad |
ret |
|
uglobal |
idlemem dd 0x0 |
idleuse dd 0x0 |
idleusesec dd 0x0 |
check_idle_semaphore dd 0x0 |
idlemem dd 0x0 |
idleuse dd 0x0 |
idleusesec dd 0x0 |
check_idle_semaphore dd 0x0 |
endg |
|
|
1077,8 → 1020,8 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|
reserve_irqs_ports: |
; removed |
ret |
; removed |
ret |
|
setirqreadports: |
; removed |
1090,30 → 1033,30 |
|
set_variables: |
|
mov ecx,0x100 ; flush port 0x60 |
.fl60: in al,0x60 |
loop .fl60 |
push eax |
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 |
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 |
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 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 |
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 |
1123,11 → 1066,11 |
|
display_number: |
;It is not optimization |
mov eax, ebx |
mov ebx, ecx |
mov ecx, edx |
mov edx, esi |
mov esi, edi |
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 |
1143,7 → 1086,7 |
display_number_force: |
push eax |
and eax,0x3fffffff |
cmp eax,0xffff ; length > 0 ? |
cmp eax,0xffff ; length > 0 ? |
pop eax |
jge cont_displ |
ret |
1150,7 → 1093,7 |
cont_displ: |
push eax |
and eax,0x3fffffff |
cmp eax,61*0x10000 ; length <= 60 ? |
cmp eax,61*0x10000 ; length <= 60 ? |
pop eax |
jb cont_displ2 |
ret |
1158,7 → 1101,7 |
|
pushad |
|
cmp al,1 ; ecx is a pointer ? |
cmp al,1 ; ecx is a pointer ? |
jne displnl1 |
mov ebp,ebx |
add ebp,4 |
1167,7 → 1110,7 |
displnl1: |
sub esp,64 |
|
test ah,ah ; DECIMAL |
test ah,ah ; DECIMAL |
jnz no_display_desnum |
shr eax,16 |
and eax,0xC03f |
1195,7 → 1138,7 |
ret |
no_display_desnum: |
|
cmp ah,0x01 ; HEXADECIMAL |
cmp ah,0x01 ; HEXADECIMAL |
jne no_display_hexnum |
shr eax,16 |
and eax,0xC03f |
1225,7 → 1168,7 |
ret |
no_display_hexnum: |
|
cmp ah,0x02 ; BINARY |
cmp ah,0x02 ; BINARY |
jne no_display_binnum |
shr eax,16 |
and eax,0xC03f |
1304,9 → 1247,9 |
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] |
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 |
1325,7 → 1268,7 |
; 12 = enable pci access |
|
|
and [esp+32],dword 0 |
and [esp+32],dword 0 |
dec ebx ; MIDI |
jnz nsyse1 |
cmp ecx,0x100 |
1337,7 → 1280,7 |
jb nsyse1 |
mov [midi_base],cx ;bx |
mov word [mididp],cx ;bx |
inc cx ;bx |
inc cx ;bx |
mov word [midisp],cx ;bx |
ret |
|
1404,16 → 1347,16 |
mov [cdid],0xb0 |
noprsl: |
dec ecx |
jnz nosema |
mov [cdbase],0x170 |
mov [cdid],0xa0 |
jnz nosema |
mov [cdbase],0x170 |
mov [cdid],0xa0 |
nosema: |
dec ecx |
jnz nosesl |
mov [cdbase],0x170 |
mov [cdid],0xb0 |
jnz nosesl |
mov [cdbase],0x170 |
mov [cdid],0xb0 |
nosesl: |
ret |
ret |
|
iglobal |
cd_base db 0 |
1420,60 → 1363,60 |
|
endg |
nsyse4: |
|
sub ebx,2 ; SYSTEM LANGUAGE |
jnz nsyse5 |
mov [syslang],ecx |
ret |
|
sub ebx,2 ; SYSTEM LANGUAGE |
jnz nsyse5 |
mov [syslang],ecx |
ret |
nsyse5: |
|
sub ebx,2 ; HD BASE |
jnz nsyse7 |
|
test ecx,ecx |
jz nosethd |
sub ebx,2 ; HD BASE |
jnz nsyse7 |
|
cmp ecx,4 |
ja nosethd |
mov [hd_base],cl |
test ecx,ecx |
jz nosethd |
|
cmp ecx,1 |
jnz noprmahd |
mov [hdbase],0x1f0 |
and dword [hdid],0x0 |
mov dword [hdpos],ecx |
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 |
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 |
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 |
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 |
call reserve_hd1 |
call reserve_hd_channel |
call free_hd_channel |
and dword [hd1_status],0 ; free |
nosethd: |
ret |
ret |
|
iglobal |
hd_base db 0 |
1482,33 → 1425,33 |
nsyse7: |
|
; cmp eax,8 ; HD PARTITION |
dec ebx |
jnz nsyse8 |
mov [fat32part],ecx |
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 |
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 |
and ecx,1 |
sub ebx,3 |
jnz no_set_lba_read |
mov [lba_read_enabled],ecx |
ret |
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 |
dec ebx |
jnz no_set_pci_access |
mov [pci_access_enabled],ecx |
ret |
no_set_pci_access: |
|
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
1516,8 → 1459,8 |
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|
sys_setup_err: |
or [esp+32],dword -1 |
ret |
or [esp+32],dword -1 |
ret |
|
align 4 |
|
1533,118 → 1476,118 |
|
; cmp eax,1 |
dec ebx |
jnz ngsyse1 |
movzx eax,[midi_base] |
mov [esp+32],eax |
ret |
jnz ngsyse1 |
movzx eax,[midi_base] |
mov [esp+32],eax |
ret |
ngsyse1: |
; cmp eax,2 |
dec ebx |
jnz ngsyse2 |
jnz ngsyse2 |
|
mov edi,[TASK_BASE] |
mov ebx,[edi+TASKDATA.mem_start] |
add ebx,edx |
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 |
jnz kbnobaseret |
mov eax,keymap |
mov ecx,128 |
call memmove |
ret |
kbnobaseret: |
; cmp ebx,2 |
dec ecx |
jnz kbnoshiftret |
jnz kbnoshiftret |
|
mov eax,keymap_shift |
mov ecx,128 |
call memmove |
ret |
mov eax,keymap_shift |
mov ecx,128 |
call memmove |
ret |
kbnoshiftret: |
; cmp ebx,3 |
dec ecx |
jne kbnoaltret |
jne kbnoaltret |
|
mov eax,keymap_alt |
mov ecx,128 |
call memmove |
ret |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
jnz ngsyse12 |
mov eax,[pci_access_enabled] |
mov [esp+32],eax |
ret |
ngsyse12: |
mov [esp+32],dword 1 |
ret |
mov [esp+32],dword 1 |
ret |
|
|
|
get_timer_ticks: |
mov eax,[timer_ticks] |
ret |
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 |
dd app_load_cursor |
dd app_set_cursor |
dd app_delete_cursor |
dd msz |
endg |
|
readmousepos: |
1658,88 → 1601,88 |
; eax=6 delete cursor ; reserved |
; eax=7 get mouse_z |
|
cmp ebx, 7 |
ja msset |
jmp [mousefn+ebx*4] |
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 |
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 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 |
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 |
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 |
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 |
and [esp+36-4],dword 0 |
; ret |
msset: |
ret |
ret |
|
app_load_cursor: |
cmp ecx, OS_BASE |
jae msset |
stdcall load_cursor, ecx, edx |
mov [esp+36-4], eax |
ret |
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 |
stdcall set_cursor, ecx |
mov [esp+36-4], eax |
ret |
|
app_delete_cursor: |
stdcall delete_cursor, ecx |
mov [esp+36-4], eax |
ret |
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 |
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 |
mov dx,word [midisp] |
in al,dx |
and al,0x40 |
pop edx |
ret |
|
|
1746,9 → 1689,9 |
get_mpu_in: |
|
push edx |
mov dx,word [mididp] |
in al,dx |
pop edx |
mov dx,word [mididp] |
in al,dx |
pop edx |
ret |
|
|
1755,9 → 1698,9 |
put_mpu_out: |
|
push edx |
mov dx,word [mididp] |
out dx,al |
pop edx |
mov dx,word [mididp] |
out dx,al |
pop edx |
ret |
|
|
1835,7 → 1778,7 |
mov eax,[TASK_BASE] |
mov [eax+TASKDATA.state], 3 ; terminate this program |
|
waitterm: ; wait here for termination |
waitterm: ; wait here for termination |
mov ebx,100 |
call delay_hs |
jmp waitterm |
1843,42 → 1786,42 |
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 |
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] |
dec ebx |
cmp ebx, sysfn_num |
jae @f |
jmp dword [sys_system_table + ebx*4] |
@@: |
ret |
ret |
|
|
sysfn_shutdown: ; 18.9 = system shutdown |
sysfn_shutdown: ; 18.9 = system shutdown |
cmp ecx,1 |
jl exit_for_anyone |
cmp ecx,4 |
1895,7 → 1838,7 |
shutdown_processes: dd 0x0 |
endg |
|
sysfn_terminate: ; 18.2 = TERMINATE |
sysfn_terminate: ; 18.2 = TERMINATE |
cmp ecx,2 |
jb noprocessterminate |
mov edx,[TASK_COUNT] |
1909,7 → 1852,7 |
jz noprocessterminate |
|
;call MEM_Heap_Lock ;guarantee that process isn't working with heap |
mov [ecx],byte 3 ; clear possible i40's |
mov [ecx],byte 3 ; clear possible i40's |
;call MEM_Heap_UnLock |
|
cmp edx,[application_table_status] ; clear app table stat |
1925,7 → 1868,7 |
.table_status: |
cli |
cmp [application_table_status],0 |
je .stf |
je .stf |
sti |
call change_task |
jmp .table_status |
1934,7 → 1877,7 |
mov eax,ecx |
call pid_to_slot |
test eax,eax |
jz .not_found |
jz .not_found |
mov ecx,eax |
cli |
call sysfn_terminate |
1944,10 → 1887,10 |
ret |
.not_found: |
mov [application_table_status],0 |
or dword [esp+32],-1 |
or dword [esp+32],-1 |
ret |
|
sysfn_activate: ; 18.3 = ACTIVATE WINDOW |
sysfn_activate: ; 18.3 = ACTIVATE WINDOW |
cmp ecx,2 |
jb .nowindowactivate |
cmp ecx,[TASK_COUNT] |
1968,12 → 1911,12 |
.nowindowactivate: |
ret |
|
sysfn_getidletime: ; 18.4 = GET IDLETIME |
sysfn_getidletime: ; 18.4 = GET IDLETIME |
mov eax,[idleusesec] |
mov [esp+32], eax |
ret |
|
sysfn_getcpuclock: ; 18.5 = GET TSC/SEC |
sysfn_getcpuclock: ; 18.5 = GET TSC/SEC |
mov eax,[CPU_FREQ] |
mov [esp+32], eax |
ret |
1983,13 → 1926,13 |
include 'blkdev/rdsave.inc' |
;!!!!!!!!!!!!!!!!!!!!!!!! |
align 4 |
sysfn_getactive: ; 18.7 = get active window |
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 |
sysfn_sound_flag: ; 18.8 = get/set sound_flag |
; cmp ecx,1 |
dec ecx |
jnz nogetsoundflag |
2004,11 → 1947,11 |
nosoundflag: |
ret |
|
sysfn_minimize: ; 18.10 = minimize window |
sysfn_minimize: ; 18.10 = minimize window |
mov [window_minimize],1 |
ret |
align 4 |
sysfn_getdiskinfo: ; 18.11 = get disk info table |
sysfn_getdiskinfo: ; 18.11 = get disk info table |
; cmp ecx,1 |
dec ecx |
jnz full_table |
2032,11 → 1975,11 |
rep movsd |
ret |
|
sysfn_lastkey: ; 18.12 = return 0 (backward compatibility) |
and dword [esp+32], 0 |
ret |
sysfn_lastkey: ; 18.12 = return 0 (backward compatibility) |
and dword [esp+32], 0 |
ret |
|
sysfn_getversion: ; 18.13 = get kernel ID and version |
sysfn_getversion: ; 18.13 = get kernel ID and version |
mov edi,ecx |
mov esi,version_inf |
mov ecx,version_end-version_inf |
2055,22 → 1998,22 |
ret |
|
align 4 |
sysfn_centermouse: ; 18.15 = mouse centered |
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 |
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 |
and [esp+32],eax |
; pop eax |
|
ret |
2140,14 → 2083,14 |
|
sysfn_min_rest_window: |
pushad |
mov eax, edx ; ebx - operating |
mov eax, edx ; ebx - operating |
shr ecx, 1 |
jnc @f |
call pid_to_slot |
@@: |
or eax, eax ; eax - number of slot |
or eax, eax ; eax - number of slot |
jz .error |
cmp eax, 255 ; varify maximal slot number |
cmp eax, 255 ; varify maximal slot number |
ja .error |
movzx eax, word [WIN_STACK + eax*2] |
shr ecx, 1 |
2175,7 → 2118,7 |
screen_workarea RECT |
;// mike.dld, 2006-29-01 ] |
window_minimize db 0 |
sound_flag db 0 |
sound_flag db 0 |
endg |
|
iglobal |
2187,27 → 2130,27 |
endg |
|
UID_NONE=0 |
UID_MENUETOS=1 ;official |
UID_KOLIBRI=2 ;russian |
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 |
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 |
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 |
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 |
mov [esp + 32], dword 1 |
.yes_floppy_save: |
ret |
ret |
|
uglobal |
; bgrchanged dd 0x0 |
2218,20 → 2161,20 |
|
sys_background: |
|
cmp ebx,1 ; BACKGROUND SIZE |
cmp ebx,1 ; BACKGROUND SIZE |
jnz nosb1 |
test ecx,ecx |
; cmp ecx,0 |
jz sbgrr |
jz sbgrr |
test edx,edx |
; cmp edx,0 |
jz sbgrr |
jz sbgrr |
@@: |
;;Maxis use atomic bts for mutexes 4.4.2009 |
bts dword [bgrlock], 0 |
jnc @f |
call change_task |
jmp @b |
bts dword [bgrlock], 0 |
jnc @f |
call change_task |
jmp @b |
@@: |
mov [BgrDataWidth],ecx |
mov [BgrDataHeight],edx |
2239,10 → 2182,10 |
|
pushad |
; return memory for old background |
mov eax, [img_background] |
cmp eax, static_background_data |
jz @f |
stdcall kernel_free, eax |
mov eax, [img_background] |
cmp eax, static_background_data |
jz @f |
stdcall kernel_free, eax |
@@: |
; calculate RAW size |
xor eax,eax |
2267,15 → 2210,15 |
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 |
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 |
mov [bgrlock], 0 |
|
sbgrr: |
ret |
2282,14 → 2225,14 |
|
nosb1: |
|
cmp ebx,2 ; SET PIXEL |
cmp ebx,2 ; SET PIXEL |
jnz nosb2 |
|
mov eax, [img_background] |
test ecx, ecx |
jz @f |
jz @f |
cmp eax, static_background_data |
jz .ret |
jz .ret |
@@: |
mov ebx, [mem_BACKGROUND] |
add ebx, 4095 |
2296,7 → 2239,7 |
and ebx, -4096 |
sub ebx, 4 |
cmp ecx, ebx |
ja .ret |
ja .ret |
|
mov ebx,[eax+ecx] |
and ebx,0xFF000000 ;255*256*256*256 |
2307,7 → 2250,7 |
ret |
nosb2: |
|
cmp ebx,3 ; DRAW BACKGROUND |
cmp ebx,3 ; DRAW BACKGROUND |
jnz nosb3 |
draw_background_temp: |
; cmp [bgrchanged],1 ;0 |
2321,10 → 2264,10 |
ret |
nosb3: |
|
cmp ebx,4 ; TILED / STRETCHED |
cmp ebx,4 ; TILED / STRETCHED |
jnz nosb4 |
cmp ecx,[BgrDrawMode] |
je nosb41 |
je nosb41 |
mov [BgrDrawMode],ecx |
; mov [bgrchanged],1 |
nosb41: |
2331,7 → 2274,7 |
ret |
nosb4: |
|
cmp ebx,5 ; BLOCK MOVE TO BGR |
cmp ebx,5 ; BLOCK MOVE TO BGR |
jnz nosb5 |
cmp [img_background], static_background_data |
jnz @f |
2338,7 → 2281,7 |
test edx, edx |
jnz .fin |
cmp esi, 4 |
ja .fin |
ja .fin |
@@: |
; bughere |
mov eax, ecx |
2350,87 → 2293,87 |
ret |
nosb5: |
|
cmp ebx, 6 |
jnz nosb6 |
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 |
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 |
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+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 |
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 |
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 |
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 |
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 |
and dword [esp+32], 0 |
ret |
|
nosb7: |
ret |
2451,7 → 2394,7 |
|
sys_getbackground: |
; cmp eax,1 ; SIZE |
dec ebx |
dec ebx |
jnz nogb1 |
mov eax,[BgrDataWidth] |
shl eax,16 |
2461,14 → 2404,14 |
|
nogb1: |
; cmp eax,2 ; PIXEL |
dec ebx |
dec ebx |
jnz nogb2 |
|
mov eax, [img_background] |
test ecx, ecx |
jz @f |
cmp eax, static_background_data |
jz .ret |
mov eax, [img_background] |
test ecx, ecx |
jz @f |
cmp eax, static_background_data |
jz .ret |
@@: |
mov ebx, [mem_BACKGROUND] |
add ebx, 4095 |
2475,7 → 2418,7 |
and ebx, -4096 |
sub ebx, 4 |
cmp ecx, ebx |
ja .ret |
ja .ret |
|
mov eax,[ecx+eax] |
|
2497,67 → 2440,67 |
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 |
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 |
mov [esp + 32], eax |
ret |
.finish: |
; test hotkeys buffer |
mov ecx, hotkey_buffer |
mov ecx, hotkey_buffer |
@@: |
cmp [ecx], ebx |
jz .found |
add ecx, 8 |
cmp ecx, hotkey_buffer + 120 * 8 |
jb @b |
ret |
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 |
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 |
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 |
ret |
|
|
align 4 |
2575,78 → 2518,78 |
; +30 dword PID , process idenfification number |
; |
|
cmp ecx,-1 ; who am I ? |
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 |
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 |
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 |
mov ax, [WIN_POS + ecx * 2] |
mov [ebx+6], ax |
|
shl ecx, 5 |
shl ecx, 5 |
|
; +0: dword: memory usage |
mov eax, [ecx+CURRENT_TASK+TASKDATA.cpu_usage] |
mov [ebx], eax |
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 |
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 |
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 |
stosd |
lea eax, [edx-1] |
stosd |
|
; +30: PID/TID |
mov eax, [ecx+CURRENT_TASK+TASKDATA.pid] |
stosd |
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 |
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 |
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 |
lea esi, [ecx*8 + SLOT_BASE + APPDATA.wnd_clientbox] |
movsd |
movsd |
movsd |
movsd |
|
; Window state |
mov al, [ecx+window_data+WDATA.fl_wstate] |
stosb |
mov al, [ecx+window_data+WDATA.fl_wstate] |
stosb |
|
pop esi |
pop edi |
pop esi |
pop edi |
|
.nofillbuf: |
; return number of processes |
2657,38 → 2600,38 |
|
align 4 |
sys_clock: |
cli |
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 |
@@: 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 |
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 |
2695,95 → 2638,95 |
|
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 |
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 |
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] |
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 |
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 |
dec ebx |
jz end_of_buttons_away |
|
add eax, 0x10 |
cmp cx, [eax] |
jnz sys_newba |
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 |
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 |
jmp sys_newba2 |
|
end_of_buttons_away: |
|
ret |
ret |
|
no_widgets_away: |
|
cmp ebx, 2 |
jnz srl1 |
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 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 |
mov edi, [TASK_BASE] |
or [edi - twdw + WDATA.fl_wdrawn], 1 ; no new position & buttons from app |
call sys_window_mouse |
ret |
|
srl1: |
ret |
ret |
|
;ok - 100% work |
;nt - not tested |
2811,7 → 2754,7 |
dd sys_sheduler.03 |
dd sys_sheduler.04 |
endg |
sys_sheduler: |
sys_sheduler: |
;rewritten by <Lrz> 29.12.2009 |
jmp dword [sheduler+ebx*4] |
;.shed_counter: |
2823,32 → 2766,32 |
.02: |
;.perf_control: |
inc ebx ;before ebx=2, ebx=3 |
cmp ebx,ecx ;if ecx=3, ebx=3 |
jz cache_disable |
cmp ebx,ecx ;if ecx=3, ebx=3 |
jz cache_disable |
|
dec ebx ;ebx=2 |
cmp ebx,ecx ; |
dec ebx ;ebx=2 |
cmp ebx,ecx ; |
jz cache_enable ;if ecx=2 and ebx=2 |
|
dec ebx ;ebx=1 |
dec ebx ;ebx=1 |
cmp ebx,ecx |
jz is_cache_enabled ;if ecx=1 and ebx=1 |
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 |
test ebx,ecx ;ebx=0 and ecx=0 |
jz modify_pce ;if ecx=0 |
|
ret |
|
.03: |
.03: |
;.rdmsr_instr: |
;now counter in ecx |
;(edx:eax) esi:edi => edx:esi |
mov eax,esi |
mov eax,esi |
mov ecx,edx |
rdmsr |
mov [esp+32],eax |
mov [esp+20],edx ;ret in ebx? |
mov [esp+32],eax |
mov [esp+20],edx ;ret in ebx? |
ret |
|
.04: |
2855,23 → 2798,23 |
;.wrmsr_instr: |
;now counter in ecx |
;(edx:eax) esi:edi => edx:esi |
; Fast Call MSR can't be destroy |
; ® MSR_AMD_EFER ¬®¦® ¨§¬¥ïâì, â.ª. ¢ í⮬ ॣ¨áâॠ«¨è |
; ¢ª«îç îâáï/¢ëª«îç îâáï à áè¨à¥ë¥ ¢®§¬®¦®á⨠|
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 |
; Fast Call MSR can't be destroy |
; ® MSR_AMD_EFER ¬®¦® ¨§¬¥ïâì, â.ª. ¢ í⮬ ॣ¨áâॠ«¨è |
; ¢ª«îç îâáï/¢ëª«îç îâáï à áè¨à¥ë¥ ¢®§¬®¦®á⨠|
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 eax,esi |
mov ecx,edx |
wrmsr |
; mov [esp + 32], eax |
; mov [esp + 20], edx ;ret in ebx? |
wrmsr |
; mov [esp + 32], eax |
; mov [esp + 20], edx ;ret in ebx? |
@@: |
ret |
|
2913,21 → 2856,21 |
; check if pixel is allowed to be drawn |
|
checkpixel: |
push eax edx |
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, [...] |
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 |
xor ecx, ecx |
mov eax, [CURRENT_TASK] |
cmp al, dl |
setne cl |
|
pop edx eax |
ret |
pop edx eax |
ret |
|
iglobal |
cpustring db 'CPU',0 |
2934,7 → 2877,7 |
endg |
|
uglobal |
background_defined db 0 ; diamond, 11.04.2006 |
background_defined db 0 ; diamond, 11.04.2006 |
endg |
|
align 4 |
2945,8 → 2888,8 |
cmp [ctrl_alt_del], 1 |
jne nocpustart |
|
mov ebp, cpustring |
call fs_execute_from_sysdir |
mov ebp, cpustring |
call fs_execute_from_sysdir |
|
mov [ctrl_alt_del], 0 |
|
2955,27 → 2898,27 |
jne mouse_not_active |
mov [mouse_active], 0 |
xor edi, edi |
mov ecx, [TASK_COUNT] |
mov ecx, [TASK_COUNT] |
set_mouse_event: |
add edi, 256 |
or [edi+SLOT_BASE+APPDATA.event_mask], dword 100000b |
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 |
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 |
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 byte[REDRAW_BACKGROUND], 0 ; background update ? |
jz nobackgr |
cmp [background_defined], 0 |
jz nobackgr |
jz nobackgr |
; mov [draw_data+32 + RECT.left],dword 0 |
; mov [draw_data+32 + RECT.top],dword 0 |
; mov eax,[Screen_Max_X] |
2986,7 → 2929,7 |
call drawbackground |
xor eax, eax |
xchg al, [REDRAW_BACKGROUND] |
test al, al ; got new update request? |
test al, al ; got new update request? |
jnz @b |
mov [draw_data+32 + RECT.left], eax |
mov [draw_data+32 + RECT.top], eax |
2999,7 → 2942,7 |
; system shutdown request |
|
cmp [SYS_SHUTDOWN],byte 0 |
je noshutdown |
je noshutdown |
|
mov edx,[shutdown_processes] |
|
3020,12 → 2963,12 |
call [_display.disable_mouse] |
|
dec byte [SYS_SHUTDOWN] |
je system_shutdown |
je system_shutdown |
|
noshutdown: |
|
|
mov eax,[TASK_COUNT] ; termination |
mov eax,[TASK_COUNT] ; termination |
mov ebx,TASK_DATA+TASKDATA.state |
mov esi,1 |
|
3032,9 → 2975,9 |
newct: |
mov cl,[ebx] |
cmp cl,byte 3 |
jz terminate |
jz terminate |
cmp cl,byte 4 |
jz terminate |
jz terminate |
|
add ebx,0x20 |
inc esi |
3048,151 → 2991,151 |
|
; eax , if process window_data base is eax, do not set flag/limits |
|
pushad |
push eax |
pushad |
push eax |
|
;;; mov ebx,2 |
;;; call delay_hs |
|
;mov ecx,0 ; redraw flags for apps |
xor ecx,ecx |
;mov ecx,0 ; redraw flags for apps |
xor ecx,ecx |
newdw2: |
|
inc ecx |
push ecx |
inc ecx |
push ecx |
|
mov eax,ecx |
shl eax,5 |
add eax,window_data |
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 eax,[esp+4] |
je not_this_task |
; check if window in redraw area |
mov edi,eax |
|
cmp ecx,1 ; limit for background |
jz bgli |
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 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.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 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, [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.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 |
mov eax,[draw_limits.left] ; eax = area x start ecx = window x end |
cmp ecx,eax |
jb ricino |
|
bgli: |
bgli: |
|
cmp dword[esp], 1 |
jnz .az |
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: |
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 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 |
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 |
sub eax,draw_data-window_data |
|
cmp dword [esp],1 |
jne nobgrd |
inc byte[REDRAW_BACKGROUND] |
cmp dword [esp],1 |
jne nobgrd |
inc byte[REDRAW_BACKGROUND] |
|
newdw8: |
nobgrd: |
|
mov [eax + WDATA.fl_redraw],byte 1 ; mark as redraw |
mov [eax + WDATA.fl_redraw],byte 1 ; mark as redraw |
|
ricino: |
|
not_this_task: |
|
pop ecx |
pop ecx |
|
cmp ecx,[TASK_COUNT] |
jle newdw2 |
cmp ecx,[TASK_COUNT] |
jle newdw2 |
|
pop eax |
popad |
pop eax |
popad |
|
ret |
ret |
|
calculatebackground: ; background |
|
mov edi, [_WinMapAddress] ; set os to use all pixels |
mov eax,0x01010101 |
mov ecx, [_WinMapSize] |
shr ecx, 2 |
rep stosd |
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 |
mov byte[REDRAW_BACKGROUND], 0 ; do not draw background! |
mov byte[BACKGROUND_CHANGED], 0 |
|
ret |
ret |
|
uglobal |
imax dd 0x0 |
imax dd 0x0 |
endg |
|
|
3200,65 → 3143,65 |
delay_ms: ; delay in 1/1000 sec |
|
|
push eax |
push ecx |
push eax |
push ecx |
|
mov ecx,esi |
; <CPU clock fix by Sergey Kuzmin aka Wildwest> |
imul ecx, 33941 |
shr ecx, 9 |
; </CPU clock fix> |
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 |
in al,0x61 |
and al,0x10 |
mov ah,al |
cld |
|
cnt1: in al,0x61 |
and al,0x10 |
cmp al,ah |
jz cnt1 |
cnt1: in al,0x61 |
and al,0x10 |
cmp al,ah |
jz cnt1 |
|
mov ah,al |
loop cnt1 |
mov ah,al |
loop cnt1 |
|
pop ecx |
pop eax |
pop ecx |
pop eax |
|
ret |
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 |
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 |
push ecx |
push edx |
|
mov edx,[timer_ticks] |
mov edx,[timer_ticks] |
|
newtic: |
mov ecx,[timer_ticks] |
sub ecx,edx |
cmp ecx,ebx |
jae zerodelay |
mov ecx,[timer_ticks] |
sub ecx,edx |
cmp ecx,ebx |
jae zerodelay |
|
call change_task |
call change_task |
|
jmp newtic |
jmp newtic |
|
zerodelay: |
pop edx |
pop ecx |
pop edx |
pop ecx |
|
ret |
ret |
|
align 16 ;very often call this subrutine |
memmove: ; memory move in bytes |
3275,7 → 3218,7 |
mov esi, eax |
|
test ecx, not 11b |
jz @f |
jz @f |
|
push ecx |
shr ecx, 2 |
3282,7 → 3225,7 |
rep movsd |
pop ecx |
and ecx, 11b |
jz .finish |
jz .finish |
@@: |
rep movsb |
|
3343,7 → 3286,7 |
align 4 |
|
sys_programirq: |
; removed |
; removed |
mov dword [esp+32], 1 ; operation failed |
ret |
|
3352,7 → 3295,7 |
|
get_irq_data: |
; removed |
mov dword [esp+32], -1 |
mov dword [esp+32], -1 |
ret |
|
|
3454,7 → 3397,7 |
|
align 4 |
|
syscall_putimage: ; PutImage |
syscall_putimage: ; PutImage |
sys_putimage: |
test ecx,0x80008000 |
jnz .exit |
3465,15 → 3408,15 |
.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 |
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 |
push ebp esi 0 |
mov ebp, putimage_get24bpp |
mov esi, putimage_init24bpp |
sys_putimage_bpp: |
; cmp [SCR_MODE], word 0x12 |
; jz @f ;.doit |
3483,13 → 3426,13 |
; cmp [SCR_MODE], word 0x13 |
; jnz .doit |
;@@: |
mov eax, vesa20_putimage |
mov eax, vesa20_putimage |
.doit: |
inc [mouse_pause] |
call eax |
dec [mouse_pause] |
pop ebp esi ebp |
jmp [draw_pointer] |
inc [mouse_pause] |
call eax |
dec [mouse_pause] |
pop ebp esi ebp |
jmp [draw_pointer] |
align 4 |
sys_putimage_palette: |
; ebx = pointer to image |
3498,277 → 3441,277 |
; 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 |
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, 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, 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 |
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 |
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, 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, 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, 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 |
cmp esi, 32 |
jnz @f |
mov ebp, putimage_get32bpp |
mov esi, putimage_init32bpp |
jmp sys_putimage_bpp |
@@: |
pop ebp esi ebp |
ret |
pop ebp esi ebp |
ret |
|
put_mono_image: |
push ebp esi ebp |
mov ebp, putimage_get1bpp |
mov esi, putimage_init1bpp |
jmp sys_putimage_bpp |
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 |
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 |
push ebp esi ebp |
mov ebp, putimage_get4bpp |
mov esi, putimage_init4bpp |
jmp sys_putimage_bpp |
|
putimage_init24bpp: |
lea eax, [eax*3] |
lea eax, [eax*3] |
putimage_init8bpp: |
ret |
ret |
|
align 16 |
putimage_get24bpp: |
movzx eax, byte [esi+2] |
shl eax, 16 |
mov ax, [esi] |
add esi, 3 |
ret 4 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
shl eax, 2 |
ret |
align 16 |
putimage_get32bpp: |
lodsd |
ret 4 |
lodsd |
ret 4 |
|
putimage_init15bpp: |
putimage_init16bpp: |
add eax, eax |
ret |
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 |
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 |
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 |
; 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] |
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 |
je dbv20 |
sdbv20: |
; cmp [SCR_MODE],word 0100000000000000b |
; jge dbv20 |
3788,36 → 3731,36 |
|
kb_read: |
|
push ecx edx |
push ecx edx |
|
mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
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 |
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 |
push ecx |
mov ecx,32 |
kr_delay: |
loop kr_delay |
pop ecx |
in al,0x60 |
xor ah,ah |
loop kr_delay |
pop ecx |
in al,0x60 |
xor ah,ah |
kr_exit: |
|
pop edx ecx |
pop edx ecx |
|
ret |
ret |
|
|
kb_write: |
|
push ecx edx |
push ecx edx |
|
mov dl,al |
mov dl,al |
; mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
; kw_loop1: |
; in al,0x64 |
3827,75 → 3770,75 |
; mov ah,1 |
; jmp kw_exit |
; kw_ok1: |
in al,0x60 |
mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
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 |
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 |
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 |
in al,0x64 |
test al,2 |
jz kw_ok3 |
loop kw_loop3 |
mov ah,1 |
jmp kw_exit |
kw_ok3: |
mov ah,8 |
mov ah,8 |
kw_loop4: |
mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
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 |
in al,0x64 |
test al,1 |
jnz kw_ok4 |
loop kw_loop5 |
dec ah |
jnz kw_loop4 |
kw_ok4: |
xor ah,ah |
xor ah,ah |
kw_exit: |
|
pop edx ecx |
pop edx ecx |
|
ret |
ret |
|
|
kb_cmd: |
|
mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
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 |
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 |
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 |
in al,0x64 |
test al,2 |
jz c_ok |
loop c_accept |
c_error: |
mov ah,1 |
jmp c_exit |
mov ah,1 |
jmp c_exit |
c_ok: |
xor ah,ah |
xor ah,ah |
c_exit: |
ret |
ret |
|
|
setmouse: ; set mousepicture -pointer |
; ps2 mouse enable |
; ps2 mouse enable |
|
mov [MOUSE_PICTURE],dword mousepointer |
|
3917,60 → 3860,60 |
|
rerouteirqs: |
|
cli |
cli |
|
mov al,0x11 ; icw4, edge triggered |
out 0x20,al |
call pic_delay |
out 0xA0,al |
call pic_delay |
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,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,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,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 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 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 |
mov al,255 ; mask all irq's |
out 0xA1,al |
call pic_delay |
out 0x21,al |
call pic_delay |
|
cli |
cli |
|
ret |
ret |
|
|
pic_delay: |
|
jmp pdl1 |
pdl1: ret |
jmp pdl1 |
pdl1: ret |
|
|
sys_msg_board_str: |
3992,43 → 3935,43 |
; in: al = byte to display |
; out: nothing |
; destroys: nothing |
pushad |
mov ecx, 2 |
shl eax, 24 |
jmp @f |
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 |
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 |
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 |
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 |
4040,52 → 3983,52 |
; 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 |
mov ecx, [msg_board_count] |
cmp eax, 1 |
jne .smbl1 |
|
if defined debug_com_base |
|
push dx ax |
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 |
@@: ; 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 |
mov dx, debug_com_base ; Output the byte |
mov al, bl |
out dx, al |
|
pop ax dx |
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 |
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 |
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 |
mov [esp+36], ecx |
mov [esp+24], ecx |
.smbl2: |
ret |
ret |
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; 66 sys function. ;; |
4095,11 → 4038,11 |
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 |
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 |
|
|
4110,7 → 4053,7 |
cmp ebx,5 |
jae .not_support ;if >=6 then or eax,-1 |
|
mov edi, [CURRENT_TASK] |
mov edi, [CURRENT_TASK] |
jmp dword [f66call+ebx*4] |
|
.not_support: |
4144,63 → 4087,63 |
ret |
|
.4: |
mov eax, hotkey_list |
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 |
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 |
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 |
and dword [esp+32], 0 |
ret |
|
.5: |
movzx ebx, cl |
lea ebx, [hotkey_scancodes+ebx*4] |
mov eax, [ebx] |
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 |
test eax, eax |
jz .notfound |
cmp [eax+8], edi |
jnz .next |
cmp [eax+4], edx |
jz .found |
.next: |
mov eax, [eax] |
jmp .scan |
mov eax, [eax] |
jmp .scan |
.notfound: |
mov dword [esp+32], 1 |
ret |
mov dword [esp+32], 1 |
ret |
.found: |
mov ecx, [eax] |
jecxz @f |
mov edx, [eax+12] |
mov [ecx+12], edx |
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 |
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 |
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
4211,15 → 4154,15 |
iglobal |
align 4 |
f61call: |
dd sys_gs.1 ; resolution |
dd sys_gs.2 ; bits per pixel |
dd sys_gs.3 ; bytes per scanline |
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 |
sys_gs: ; direct screen access |
dec ebx |
cmp ebx,2 |
ja .not_support |
4226,10 → 4169,10 |
jmp dword [f61call+ebx*4] |
.not_support: |
or [esp+32],dword -1 |
ret |
ret |
|
|
.1: ; resolution |
.1: ; resolution |
mov eax,[Screen_Max_X] |
shl eax,16 |
mov ax,[Screen_Max_Y] |
4240,7 → 4183,7 |
movzx eax,byte [ScreenBPP] |
mov [esp+32],eax |
ret |
.3: ; bytes per scanline |
.3: ; bytes per scanline |
mov eax,[BytesPerScanLine] |
mov [esp+32],eax |
ret |
4257,88 → 4200,88 |
|
align 4 ; system functions |
|
syscall_setpixel: ; SetPixel |
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 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] |
call [_display.disable_mouse] |
jmp [putpixel] |
|
align 4 |
|
syscall_writetext: ; WriteText |
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 |
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 |
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 |
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 |
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 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 |
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] |
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] |
add eax, [esi + APPDATA.wnd_clientbox.left] |
add ebx, [esi + APPDATA.wnd_clientbox.top] |
add ecx, eax |
add edx, ebx |
jmp [drawbar] |
.drectr: |
ret |
ret |
|
align 4 |
syscall_getscreensize: ; GetScreenSize |
mov ax, [Screen_Max_X] |
shl eax, 16 |
mov ax, [Screen_Max_Y] |
mov [esp + 32], eax |
ret |
syscall_getscreensize: ; GetScreenSize |
mov ax, [Screen_Max_X] |
shl eax, 16 |
mov ax, [Screen_Max_Y] |
mov [esp + 32], eax |
ret |
|
align 4 |
|
4345,7 → 4288,7 |
|
align 4 |
|
syscall_getpixel: ; GetPixel |
syscall_getpixel: ; GetPixel |
mov ecx, [Screen_Max_X] |
inc ecx |
xor edx, edx |
4365,10 → 4308,10 |
;ecx = [size x]*65536 + [size y] |
;edx = [start x]*65536 + [start y] |
pushad |
inc [mouse_pause] |
inc [mouse_pause] |
; Check of use of the hardware cursor. |
cmp [_display.disable_mouse],__sys_disable_mouse |
jne @f |
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 |
4385,30 → 4328,30 |
mov ebx,edx |
and ebx,0xffff |
dec eax |
dec ebx |
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 |
|
mov ebp,edx |
dec ebp |
lea ebp,[ebp*3] |
|
imul ebp,esi |
|
mov esi,ecx |
dec esi |
lea esi,[esi*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: |
4416,7 → 4359,7 |
add eax,ecx |
|
call dword [GETPIXEL] ; eax - x, ebx - y |
|
|
mov [ebp],cx |
shr ecx,16 |
mov [ebp+2],cl |
4425,15 → 4368,15 |
sub ebp,3 |
dec ecx |
jnz .start_x |
pop edx ecx |
dec ebx |
pop edx ecx |
dec ebx |
dec edx |
jnz .start_y |
dec [mouse_pause] |
dec [mouse_pause] |
; Check of use of the hardware cursor. |
cmp [_display.disable_mouse],__sys_disable_mouse |
jne @f |
call [draw_pointer] |
jne @f |
call [draw_pointer] |
@@: |
popad |
ret |
4440,31 → 4383,31 |
|
align 4 |
|
syscall_drawline: ; DrawLine |
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] |
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 |
syscall_getirqowner: ; GetIrqOwner |
|
cmp ebx,16 |
jae .err |
4482,7 → 4425,7 |
|
align 4 |
|
syscall_reserveportarea: ; ReservePortArea and FreePortArea |
syscall_reserveportarea: ; ReservePortArea and FreePortArea |
|
call r_f_port_area |
mov [esp+32],eax |
4490,7 → 4433,7 |
|
align 4 |
|
syscall_threads: ; CreateThreads |
syscall_threads: ; CreateThreads |
; eax=1 create thread |
; |
; ebx=thread start |
4507,7 → 4450,7 |
|
stack_driver_stat: |
|
call app_stack_handler ; Stack status |
call app_stack_handler ; Stack status |
|
; mov [check_idle_semaphore],5 ; enable these for zero delay |
; call change_task ; between sent packet |
4517,7 → 4460,7 |
|
align 4 |
|
socket: ; Socket interface |
socket: ; Socket interface |
call app_socket_handler |
|
; mov [check_idle_semaphore],5 ; enable these for zero delay |
4529,7 → 4472,7 |
|
align 4 |
|
read_from_hd: ; Read from hd - fn not in use |
read_from_hd: ; Read from hd - fn not in use |
|
mov edi,[TASK_BASE] |
add edi,TASKDATA.mem_start |
4544,61 → 4487,61 |
ret |
|
paleholder: |
ret |
ret |
|
align 4 |
set_screen: |
cmp eax, [Screen_Max_X] |
jne .set |
cmp eax, [Screen_Max_X] |
jne .set |
|
cmp edx, [Screen_Max_Y] |
jne .set |
ret |
cmp edx, [Screen_Max_Y] |
jne .set |
ret |
.set: |
pushfd |
cli |
pushfd |
cli |
|
mov [Screen_Max_X], eax |
mov [Screen_Max_Y], edx |
mov [BytesPerScanLine], ecx |
mov [Screen_Max_X], eax |
mov [Screen_Max_Y], edx |
mov [BytesPerScanLine], ecx |
|
mov [screen_workarea.right],eax |
mov [screen_workarea.bottom], edx |
mov [screen_workarea.right],eax |
mov [screen_workarea.bottom], edx |
|
push ebx |
push esi |
push edi |
push ebx |
push esi |
push edi |
|
pushad |
pushad |
|
stdcall kernel_free, [_WinMapAddress] |
stdcall kernel_free, [_WinMapAddress] |
|
mov eax, [_display.width] |
mul [_display.height] |
mov [_WinMapSize], eax |
mov eax, [_display.width] |
mul [_display.height] |
mov [_WinMapSize], eax |
|
stdcall kernel_alloc, eax |
mov [_WinMapAddress], eax |
test eax, eax |
jz .epic_fail |
stdcall kernel_alloc, eax |
mov [_WinMapAddress], eax |
test eax, eax |
jz .epic_fail |
|
popad |
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 |
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 |
popfd |
ret |
|
.epic_fail: |
hlt ; Houston, we've had a problem |
hlt ; Houston, we've had a problem |
|
; --------------- APM --------------------- |
uglobal |
4614,16 → 4557,16 |
inc eax |
or dword [esp + 44], eax ; error |
add eax,7 |
mov dword [esp + 32], eax ; 32-bit protected-mode interface not supported |
mov dword [esp + 32], eax ; 32-bit protected-mode interface not supported |
ret |
|
@@: |
; xchg eax, ecx |
; xchg ebx, ecx |
; xchg eax, ecx |
; xchg ebx, ecx |
|
cmp dx, 3 |
ja @f |
and [esp + 44], byte 0xfe ; emulate func 0..3 as func 0 |
and [esp + 44], byte 0xfe ; emulate func 0..3 as func 0 |
mov eax,[apm_vf] |
mov [esp + 32], eax |
shr eax, 16 |
4635,15 → 4578,15 |
mov esi,[master_tab+(OS_BASE shr 20)] |
xchg [master_tab], esi |
push esi |
mov edi, cr3 |
mov cr3, edi ;flush TLB |
mov edi, cr3 |
mov cr3, edi ;flush TLB |
|
call pword [apm_entry] ;call APM BIOS |
call pword [apm_entry] ;call APM BIOS |
|
xchg eax, [esp] |
mov [master_tab], eax |
mov eax, cr3 |
mov cr3, eax |
xchg eax, [esp] |
mov [master_tab], eax |
mov eax, cr3 |
mov cr3, eax |
pop eax |
|
mov [esp + 4 ], edi |
4660,250 → 4603,253 |
|
align 4 |
|
undefined_syscall: ; Undefined system call |
undefined_syscall: ; Undefined system call |
mov [esp + 32], dword -1 |
ret |
|
align 4 |
system_shutdown: ; shut down the system |
system_shutdown: ; shut down the system |
|
cmp byte [BOOT_VAR+0x9030], 1 |
jne @F |
ret |
cmp byte [BOOT_VAR+0x9030], 1 |
jne @F |
ret |
@@: |
call stop_all_services |
call stop_all_services |
|
yes_shutdown_param: |
cli |
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 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, 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 |
mov esi,OS_BASE+0x2F0000 ; restore 0x0 - 0xffff |
mov edi, OS_BASE |
mov ecx,0x10000/4 |
cld |
rep movsd |
|
call restorefatchain |
call restorefatchain |
|
mov al, 0xFF |
out 0x21, al |
out 0xA1, al |
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 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,0x0F |
out 0x70,al |
mov al,0x05 |
out 0x71,al |
|
mov al,0xFE |
out 0x64,al |
mov al,0xFE |
out 0x64,al |
|
hlt |
jmp $-1 |
hlt |
jmp $-1 |
|
else |
cmp byte [OS_BASE + 0x9030], 2 |
jnz no_acpi_power_off |
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 |
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 |
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 |
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 |
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 |
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] |
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] |
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 |
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 |
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 |
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] |
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 |
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 |
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 $ |
jmp $ |
|
|
no_acpi_power_off: |
mov word [OS_BASE+0x467+0],pr_mode_exit |
mov word [OS_BASE+0x467+2],0x1000 |
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,0x0F |
out 0x70,al |
mov al,0x05 |
out 0x71,al |
|
mov al,0xFE |
out 0x64,al |
mov al,0xFE |
out 0x64,al |
|
hlt |
jmp $-1 |
hlt |
jmp $-1 |
|
scan_rsdp: |
add eax, OS_BASE |
add eax, OS_BASE |
.s: |
cmp dword [eax], 'RSD ' |
jnz .n |
cmp dword [eax+4], 'PTR ' |
jnz .n |
xor edx, edx |
xor esi, esi |
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 |
add dl, [eax+esi] |
inc esi |
cmp esi, 20 |
jnz @b |
test dl, dl |
jz .ok |
.n: |
add eax, 10h |
loop .s |
stc |
add eax, 10h |
loop .s |
stc |
.ok: |
ret |
ret |
end if |
|
diff16 "End of 32-code ",0,$ |
|
include "data32.inc" |
|
__REV__ = __REV |
|
uglobals_size = $ - endofcode |
diff16 "end of kernel code",0,$ |
diff16 "Zero-filled blk",0,endofcode |
diff16 "End of kernel ",0,$ |