;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; ;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;; ;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;; ;; Distributed under terms of the GNU General Public License ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; $Revision$ VKEY_LSHIFT = 00000000_00000001b VKEY_RSHIFT = 00000000_00000010b VKEY_LCONTROL = 00000000_00000100b VKEY_RCONTROL = 00000000_00001000b VKEY_LALT = 00000000_00010000b VKEY_RALT = 00000000_00100000b VKEY_CAPSLOCK = 00000000_01000000b VKEY_NUMLOCK = 00000000_10000000b VKEY_SCRLOCK = 00000001_00000000b VKEY_LWIN = 00000010_00000000b VKEY_RWIN = 00000100_00000000b VKEY_SHIFT = VKEY_LSHIFT + VKEY_RSHIFT VKEY_CONTROL = VKEY_LCONTROL + VKEY_RCONTROL VKEY_ALT = VKEY_LALT + VKEY_RALT uglobal align 4 kb_state dd 0 ext_code db 0 keyboard_mode db 0 keyboard_data db 0 altmouseb db 0 ctrl_alt_del db 0 kb_lights db 0 old_kb_lights db 0 align 4 hotkey_scancodes rd 256 ; we have 256 scancodes hotkey_list rd 256*4 ; max 256 defined hotkeys hotkey_buffer rd 120*2 ; buffer for 120 hotkeys endg iglobal hotkey_tests dd hotkey_test0 dd hotkey_test1 dd hotkey_test2 dd hotkey_test3 dd hotkey_test4 hotkey_tests_num = 5 endg ;--------------------------------------------------------------------- hotkey_test0: test al, al setz al ret ;--------------------------------------------------------------------- hotkey_test1: test al, al setnp al ret ;--------------------------------------------------------------------- hotkey_test2: cmp al, 3 setz al ret ;--------------------------------------------------------------------- hotkey_test3: cmp al, 1 setz al ret ;--------------------------------------------------------------------- hotkey_test4: cmp al, 2 setz al ret ;--------------------------------------------------------------------- hotkey_do_test: push eax mov edx, [kb_state] shr edx, cl add cl, cl mov eax, [eax+4] shr eax, cl and eax, 15 cmp al, hotkey_tests_num jae .fail xchg eax, edx and al, 3 call [hotkey_tests + edx*4] cmp al, 1 pop eax ret ;-------------------------------------- .fail: stc pop eax ret ;--------------------------------------------------------------------- align 4 ; @brief Export function - Add new scancode in buffer ; @param ecx - scancode ; @return not return set_keyboard_data: movzx eax, word[thread_count]; top window process movzx eax, word[WIN_POS + eax*2] shl eax, BSF sizeof.APPDATA mov al, [SLOT_BASE + eax + APPDATA.keyboard_mode] mov [keyboard_mode], al mov eax, ecx push ebx esi edi ebp call send_scancode pop ebp edi esi ebx ret ;--------------------------------------------------------------------- struct KEYBOARD next dd ? prev dd ? functions dd ? userdata dd ? ends struct KBDFUNC strucsize dd ? close dd ? setlights dd ? ends iglobal keyboards: dd keyboards dd keyboards endg uglobal keyboard_list_mutex MUTEX endg ; @brief Export function - Registration new keyboard ; @param [esp + 4] - pointer on KBDFUNC this keyboard ; @param [esp + 8] - userdata for callback function ; @return eax = pointer on KEYBOARD structure or 0 on error register_keyboard: push ebx movi eax, sizeof.KEYBOARD call malloc test eax, eax jz .nothing mov ecx, [esp+4+4] mov [eax + KEYBOARD.functions], ecx mov ecx, [esp+8+4] mov [eax + KEYBOARD.userdata], ecx xchg eax, ebx mov ecx, keyboard_list_mutex call mutex_lock mov ecx, keyboards mov edx, [ecx + KEYBOARD.prev] mov [ebx + KEYBOARD.next], ecx mov [ebx + KEYBOARD.prev], edx mov [edx + KEYBOARD.next], ebx mov [ecx + KEYBOARD.prev], ebx mov ecx, [ebx + KEYBOARD.functions] cmp [ecx + KBDFUNC.strucsize], KBDFUNC.setlights jbe .unlock mov ecx, [ecx + KBDFUNC.setlights] test ecx, ecx jz .unlock stdcall ecx, [ebx + KEYBOARD.userdata], dword [kb_lights] .unlock: mov ecx, keyboard_list_mutex call mutex_unlock xchg eax, ebx .nothing: pop ebx ret 8 ; @brief Export function - Delete keyboard ; @param [esp + 4] - pointer on KEYBOARD structure ; @return not return delete_keyboard: push ebx mov ebx, [esp+4+4] mov ecx, keyboard_list_mutex call mutex_lock mov eax, [ebx + KEYBOARD.next] mov edx, [ebx + KEYBOARD.prev] mov [eax + KEYBOARD.prev], edx mov [edx + KEYBOARD.next], eax call mutex_unlock mov ecx, [ebx + KEYBOARD.functions] cmp [ecx + KBDFUNC.strucsize], KBDFUNC.close jbe .nothing mov ecx, [ecx + KBDFUNC.close] test ecx, ecx jz .nothing stdcall ecx, [ebx + KEYBOARD.userdata] .nothing: pop ebx ret 4 ;--------------------------------------------------------------------- align 4 irq1: movzx eax, word[thread_count]; top window process movzx eax, word[WIN_POS + eax*2] shl eax, BSF sizeof.APPDATA mov al, [SLOT_BASE + eax + APPDATA.keyboard_mode] mov [keyboard_mode], al in al, 0x60 ;-------------------------------------- send_scancode: ;DEBUGF 1, "K : Scan code: %x \n", al mov [keyboard_data], al ; ch = scancode ; cl = ext_code ; bh = 0 - normal key ; bh = 1 - modifier (Shift/Ctrl/Alt) ; bh = 2 - extended code mov ch, al cmp al, 0xE0 je @f cmp al, 0xE1 jne .normal_code @@: mov bh, 2 mov [ext_code], al jmp .writekey ;-------------------------------------- .normal_code: mov cl, 0 xchg cl, [ext_code] and al, 0x7F mov bh, 1 ;-------------------------------------- @@: cmp al, 0x5B jne @f cmp cl, 0xE0 jne @f mov eax, VKEY_LWIN mov bh, 0 jmp .modifier ;-------------------------------------- @@: cmp al, 0x5C jne @f cmp cl, 0xE0 jne @f mov eax, VKEY_RWIN mov bh, 0 jmp .modifier ;-------------------------------------- @@: cmp al, 0x2A jne @f cmp cl, 0xE0 je .writekey mov eax, VKEY_LSHIFT jmp .modifier ;-------------------------------------- @@: cmp al, 0x36 jne @f cmp cl, 0xE0 je .writekey mov eax, VKEY_RSHIFT jmp .modifier ;-------------------------------------- @@: cmp al, 0x38 jne @f mov eax, VKEY_LALT test cl, cl jz .modifier mov al, VKEY_RALT jmp .modifier ;-------------------------------------- @@: cmp al, 0x1D jne @f mov eax, VKEY_LCONTROL test cl, cl jz .modifier mov al, VKEY_RCONTROL cmp cl, 0xE0 jz .modifier mov [ext_code], cl jmp .writekey ;-------------------------------------- @@: cmp al, 0x3A jne @f mov bl, 4 mov eax, VKEY_CAPSLOCK jmp .no_key.xor ;-------------------------------------- @@: cmp al, 0x45 jne @f test cl, cl jnz .writekey mov bl, 2 mov eax, VKEY_NUMLOCK jmp .no_key.xor ;-------------------------------------- @@: cmp al, 0x46 jne @f mov bl, 1 mov eax, VKEY_SCRLOCK jmp .no_key.xor ;-------------------------------------- @@: xor ebx, ebx test ch, ch js .writekey movzx eax, ch ; plain key mov bl, [keymap + eax] mov edx, [kb_state] test dl, VKEY_CONTROL ; ctrl alt del jz .noctrlaltdel test dl, VKEY_ALT jz .noctrlaltdel cmp ch, 53h jne .noctrlaltdel mov [ctrl_alt_del], 1 call wakeup_osloop .noctrlaltdel: test dl, VKEY_CONTROL ; ctrl on ? jz @f sub bl, 0x60 @@: test dl, VKEY_CAPSLOCK ; caps lock on ? jz .no_caps_lock test dl, VKEY_SHIFT ; shift on ? jz .keymap_shif jmp @f ;-------------------------------------- .no_caps_lock: test dl, VKEY_SHIFT ; shift on ? jz @f .keymap_shif: mov bl, [keymap_shift + eax] @@: test dl, VKEY_ALT ; alt on ? jz @f mov bl, [keymap_alt + eax] @@: jmp .writekey ;-------------------------------------- .modifier: test ch, ch js .modifier.up or [kb_state], eax jmp .writekey ;-------------------------------------- .modifier.up: not eax and [kb_state], eax jmp .writekey ;-------------------------------------- .no_key.xor: mov bh, 0 test ch, ch js .writekey xor [kb_state], eax xor [kb_lights], bl .writekey: pushad ; test for system hotkeys movzx eax, ch cmp bh, 1 ja .nohotkey jb @f xor eax, eax @@: mov eax, [hotkey_scancodes + eax*4] .hotkey_loop: test eax, eax jz .nohotkey mov cl, 0 call hotkey_do_test jc .hotkey_cont mov cl, 2 call hotkey_do_test jc .hotkey_cont mov cl, 4 call hotkey_do_test jnc .hotkey_found .hotkey_cont: mov eax, [eax] jmp .hotkey_loop ;-------------------------------------- .hotkey_found: mov eax, [eax+8] ; put key in buffer for process in slot eax mov edi, hotkey_buffer @@: cmp dword [edi], 0 jz .found_free add edi, 8 cmp edi, hotkey_buffer+120*8 jb @b ; no free space - replace first entry mov edi, hotkey_buffer .found_free: mov [edi], eax movzx eax, ch cmp bh, 1 jnz @f xor eax, eax @@: mov [edi+4], ax mov eax, [kb_state] mov [edi+6], ax cmp [PID_lock_input], dword 0 je .nohotkey popad jmp .exit.irq1 ;-------------------------------------- .nohotkey: popad cmp [keyboard_mode], 0; return from keymap jne .scancode test bh, bh jnz .exit.irq1 test bl, bl jz .exit.irq1 cmp cl, 0xE0 ; extended keycode jne @f cmp ch, 53 jne .dowrite mov bl, '/' jmp .dowrite @@: cmp ch, 55 jne @f mov bl, '*' jmp .dowrite @@: cmp ch, 74 jne @f mov bl, '-' jmp .dowrite @@: cmp ch, 78 jne @f mov bl, '+' jmp .dowrite @@: test [kb_state], VKEY_NUMLOCK jz .dowrite cmp ch, 71 jb .dowrite cmp ch, 83 ja .dowrite movzx eax, ch mov bl, [numlock_map + eax - 71] jmp .dowrite ;-------------------------------------- .scancode: mov bl, ch .dowrite: movzx eax, byte[KEY_COUNT] cmp al, 120 jae .exit.irq1 inc eax mov [KEY_COUNT], al ; store ascii or scancode mov [KEY_BUFF + eax -1], bl ; store original scancode add eax, 120+2 push ecx cmp [keyboard_mode], 0; return from keymap je @f xor ch, ch @@: mov [KEY_BUFF + eax -1], ch pop ecx sub eax, 120+2 .exit.irq1: ret ;--------------------------------------------------------------------- set_lights: push ebx esi mov ecx, keyboard_list_mutex call mutex_lock mov esi, keyboards .loop: mov esi, [esi + KEYBOARD.next] cmp esi, keyboards jz .done mov eax, [esi + KEYBOARD.functions] cmp dword [eax], KBDFUNC.setlights jbe .loop mov eax, [eax + KBDFUNC.setlights] test eax, eax jz .loop stdcall eax, [esi + KEYBOARD.userdata], dword [kb_lights] jmp .loop .done: mov ecx, keyboard_list_mutex call mutex_unlock pop esi ebx ret ps2_set_lights: stdcall disable_irq, 1 mov al, 0xED call kb_write_wait_ack mov al, [esp+8] call kb_write_wait_ack stdcall enable_irq, 1 ret 8 ;// mike.dld ] proc check_lights_state_has_work? mov al, [kb_lights] cmp al, [old_kb_lights] ret endp check_lights_state: call check_lights_state_has_work? jz .nothing mov [old_kb_lights], al call set_lights .nothing: ret ;--------------------------------------------------------------------- iglobal numlock_map db '789-456+1230.' endg ;--------------------------------------------------------------------- align 4 kb_write_wait_ack: push ecx edx mov dl, al mov ecx, 0x1ffff; last 0xffff, new value in view of fast CPU's .wait_output_ready: in al, 0x64 test al, 2 jz @f loop .wait_output_ready mov ah, 1 jmp .nothing @@: mov al, dl out 0x60, al mov ecx, 0xfffff; last 0xffff, new value in view of fast CPU's .wait_ack: in al, 0x64 test al, 1 jnz @f loop .wait_ack mov ah, 1 jmp .nothing @@: in al, 0x60 xor ah, ah .nothing: pop edx ecx ret ;----------------------------------------------------------------------------- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; 66 sys function. ;; ;; in eax=66,ebx in [0..5],ecx,edx ;; ;; out eax ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; iglobal align 4 f66call: dd sys_process_def.1 ; 1 = set keyboard mode dd sys_process_def.2 ; 2 = get keyboard mode dd sys_process_def.3 ; 3 = get keyboard ctrl, alt, shift dd sys_process_def.4 ; 4 = set system-wide hotkey dd sys_process_def.5 ; 5 = delete installed hotkey dd sys_process_def.6 ; 6 = disable input, work only hotkeys dd sys_process_def.7 ; 7 = enable input, opposition to f.66.6 endg ;----------------------------------------------------------------------------- align 4 sys_process_def: dec ebx cmp ebx, 7 jae .not_support ;if >=8 then or eax,-1 mov edi, [current_slot] jmp dword [f66call + ebx*4] .not_support: or [esp + SYSCALL_STACK.eax], -1 ret ;----------------------------------------------------------------------------- align 4 .1: mov [edi + APPDATA.keyboard_mode], cl ret ;----------------------------------------------------------------------------- align 4 .2: ; 2 = get keyboard mode movzx eax, byte [edi + APPDATA.keyboard_mode] mov [esp + SYSCALL_STACK.eax], eax ret ;----------------------------------------------------------------------------- align 4 .3: ;3 = get keyboard ctrl, alt, shift mov eax, [kb_state] mov [esp + SYSCALL_STACK.eax], eax ret ;----------------------------------------------------------------------------- align 4 .4: mov edi, [current_slot_idx] 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 + SYSCALL_STACK.eax], 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 test edx, edx jz @f mov [edx + 12], eax @@: and dword [esp + SYSCALL_STACK.eax], 0 ret ;----------------------------------------------------------------------------- align 4 .5: mov edi, [current_slot_idx] movzx ebx, cl lea ebx, [hotkey_scancodes+ebx*4] mov eax, [ebx] .scan: test eax, eax jz .notfound cmp [eax + 8], edi jnz .next cmp [eax + 4], edx jz .found .next: mov eax, [eax] jmp .scan .notfound: mov dword [esp + SYSCALL_STACK.eax], 1 ret .found: mov ecx, [eax] jecxz @f mov edx, [eax + 12] mov [ecx + 12], edx @@: mov ecx, [eax + 12] mov edx, [eax] mov [ecx], edx xor edx, edx mov [eax + 4], edx mov [eax + 8], edx mov [eax + 12], edx mov [eax], edx mov [esp + SYSCALL_STACK.eax], edx ret ;----------------------------------------------------------------------------- align 4 .6: pushfd cli mov eax, [PID_lock_input] test eax, eax jnz @f ; get current PID mov eax, [current_slot] mov eax, [eax + APPDATA.tid] ; set current PID for lock input mov [PID_lock_input], eax @@: popfd ret ;----------------------------------------------------------------------------- align 4 .7: mov eax, [PID_lock_input] test eax, eax jz @f ; get current PID mov ebx, [current_slot] mov ebx, [ebx + APPDATA.tid] ; compare current lock input with current PID cmp ebx, eax jne @f xor eax, eax mov [PID_lock_input], eax @@: ret ;----------------------------------------------------------------------------- uglobal PID_lock_input dd 0x0 endg ;----------------------------------------------------------------------------- align 4 ; @brief System function 2 - Get pressed key ; @param eax = 2- number function ; @return eax = 1 - buffer empty, else ; al = 0, ah = code pressed key, ; 16-23 bits - scancode pressed key(in ASCII mode) ; if al=2 ah=scancode pressed key, 16-31 bits - state control keys sys_getkey: mov [esp + SYSCALL_STACK.eax], dword 1 ; test main buffer mov ebx, [current_slot_idx] ; TOP OF WINDOW STACK movzx ecx, word [WIN_STACK + ebx * 2] mov edx, [thread_count] cmp ecx, edx jne .finish cmp [KEY_COUNT], byte 0 je .finish movzx ax, byte [KEY_BUFF + 120 + 2] shl eax, 8 mov al, 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 add eax, 120 + 2 add ebx, 120 + 2 call memmove pop eax ;-------------------------------------- align 4 .ret_eax: mov [esp + SYSCALL_STACK.eax], eax ret ;-------------------------------------- align 4 .finish: ; test hotkeys buffer mov ecx, hotkey_buffer ;-------------------------------------- align 4 @@: cmp [ecx], ebx jz .found add ecx, 8 cmp ecx, hotkey_buffer + 120 * 8 jb @b ret ;-------------------------------------- align 4 .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 ;------------------------------------------------------------------------------