PS2 Mousedriver in 16 bit mode at boot time

[Jens Kallup]

Hallo,

ich schlage mich im Moment mit OS Entwicklung rum, und bin soeben
beim booten angelangt.
Jetzt wollte ich (ohne int 0x33) PS2 Maustreiber implementieren,
was mir aber arge Probleme bereitet.

Ich habe hier ein wenig Code zusammengestellt, der eigentlich für
einen DOS Treiber vorgesehen war.
Kann man den auch für eigene Zwecke verwenden?

Wäre nett wenn hier eine kleine Diskussion entstehen würde.
Danke.

P.S.: Bitte schaut Euch das mal an und testet mal ob man den Code
auch so verwenden kann - Danke.

Jens

;; compiliert mit: nasm -f win32 -o maus.o maus.asm
;; für Test's mit dem ReactOS booter

section .text

global _mouse_install, _mouse_handler

_mouse_install:
cli

mov bl, 0xa8
call keyboard_cmd

mov bl, 0x20
call keyboard_cmd
call keyboard_read
or al, 2
mov bl, 0x60
push ax
call keyboard_cmd
pop ax
call keyboard_write

mov bl, 0xd4
call keyboard_cmd
mov al, 0xf4
call keyboard_write

mouse_user_isr:
db 0x60
mov cx, [pos_x]
mov dx, [pos_y]
mov di, 0
mov si, 0
mov word [cs:x_move], 0
mov word [cs:y_move], 0
mov bl, [buttons]
xor bh, bh
call dword [user_subroutine]
db 0x60
ret


_mouse_handler:
pushf

cli

push ax
push bx
push cx
push dx
push di
push si
push es
push ds

push cs
pop ds

mov bl,0adh
call keyboard_cmd

cmp byte [first_time],0
je not_first_time

mov byte [first_time],0

call keyboard_read
call keyboard_read
call keyboard_read

jmp no_show

not_first_time:
mov word [temp_mask],0

mov cx, [pos_x]
mov dx, [pos_y]

call keyboard_read
and al,7 ;3
mov ah,[buttons]
mov [buttons],al
cmp al,ah
je no_button_change

and al,3
and ah,3

xor al,ah
xor bx,bx

push ax

test al,2
jz no_right_button_change

and ah,2
jz right_button_pressed

or bx,16
jmp no_right_button_change

right_button_pressed:
or bx,8

no_right_button_change:
pop ax

test al,1
jz no_left_button_change

and ah,1
jz left_button_pressed
or bx,4
jmp no_left_button_change

left_button_pressed:
or bx,2

no_left_button_change:
mov [temp_mask],bx

no_button_change:
call keyboard_read
cbw
add word [pos_x],ax
add word [x_move],ax
mov ax, [x_min]
cmp word [pos_x],ax
jg good_hor1
mov word [pos_x],ax
good_hor1:
mov ax,[x_max]
cmp word [pos_x],ax
jle good_hor2
mov word [pos_x],ax
good_hor2:
call keyboard_read
neg al
cbw
add word [pos_y],ax
add word [y_move],ax
mov ax, [y_min]
cmp word [pos_y],ax
jg good_ver1
mov word [pos_y],ax
good_ver1:
mov ax,[y_max]
cmp word [pos_y],ax
jle good_ver2
mov word [pos_y],ax
good_ver2:
mov ax,[x_move]
or ax,[y_move]
or ax,ax
jz no_change_position
or word [temp_mask],1
no_change_position:
mov ax, [temp_mask]
and ax, [user_mask]
jz no_call_user
call mouse_user_isr
no_call_user:
cmp byte [sm_flag],1
jne no_show
shr cx,3
shr dx,3
mov ax,80
mul dl
add ax,cx
shl ax,1
mov di,ax
mov ax,0xb800
mov es,ax
mov ax,word [save_char]

stosw

mov cx,word [pos_x]
mov dx,word [pos_y]
shr cx,3
shr dx,3
mov ax,80
mul dl
add ax,cx
shl ax,1
mov di,ax
mov ax,0b800h
mov es,ax
mov ax,word [di]
mov word [save_char],ax
not ah
and ah,7fh

stosw

no_show:
mov bl,0xae
call keyboard_cmd

mov al,0x20
out 0a0h,al
out 0x20,al

pop ds
pop es
pop si
pop di
pop dx
pop cx
pop bx
pop ax
popf

ret ; iret

first_time db 1
buttons db 0
pos_x dw 0
pos_y dw 0
sm_flag dw 0
save_char dw 0
x_move dw 0
y_move dw 0
x_max dw 639
x_min dw 0
y_max dw 199
y_min dw 0
user_subroutine dw 0,0
user_mask dw 0
temp_mask dw 0

keyboard_read:
push cx
push dx
xor cx,cx

key_read_loop:
in al,64h
jmp $+2
jmp $+2
test al,1
jnz key_read_ready
loop key_read_loop
mov ah,1
jmp key_read_exit

key_read_ready:
push cx
mov cx,32

key_read_delay:
jmp $+2
jmp $+2
loop key_read_delay

pop cx

in al,60h
jmp $+2
jmp $+2

xor ah,ah

key_read_exit:
pop dx
pop cx
ret

keyboard_write:
push cx
push dx
mov dl,al
xor cx,cx

kbd_wrt_loop1:
in al,64h
jmp $+2
jmp $+2

test al,20h
jz kbd_wrt_ok1

loop kbd_wrt_loop1

mov ah,1
jmp kbd_wrt_exit

kbd_wrt_ok1:
in al,60h
xor cx,cx

kbd_wrt_loop:
in al,64h
jmp $+2
jmp $+2

test al,2
jz kbd_wrt_ok

loop kbd_wrt_loop

mov ah,1
jmp kbd_wrt_exit

kbd_wrt_ok:
mov al,dl
out 60h,al
jmp $+2
jmp $+2

xor cx,cx

kbd_wrt_loop3:
in al,64h
jmp $+2
jmp $+2

test al,2
jz kbd_wrt_ok3

loop kbd_wrt_loop3
mov ah,1
jmp kbd_wrt_exit

kbd_wrt_ok3:
mov ah,8

kbd_wrt_loop4:
xor cx,cx

kbd_wrt_loop5:
in al,64h
jmp $+2
jmp $+2

test al,1
jnz kbd_wrt_ok4

loop kbd_wrt_loop5
dec ah
jnz kbd_wrt_loop4

kbd_wrt_ok4:
xor ah,ah

kbd_wrt_exit:
pop dx
pop cx
ret

keyboard_cmd:
xor cx,cx

cmd_wait:
in al,64h
jmp $+2
jmp $+2

test al,2
jz cmd_send

loop cmd_wait
jmp cmd_error

cmd_send:
mov al,bl
out 64h,al
jmp $+2
jmp $+2

xor cx,cx

cmd_accept:
in al,64h
jmp $+2
jmp $+2

test al,2
jz cmd_ok

loop cmd_accept

cmd_error:
mov ah,1
jmp cmd_exit

cmd_ok:
xor ah,ah

cmd_exit:
ret

new_33:
cli
cmp al,0
je reset_mouse
cmp al,1
je show_mouse
cmp al,2
je hide_mouse
cmp al,3
je get_pos
cmp al,4
je set_pos
cmp al,7
je set_hor_pos
cmp al,8
je set_ver_pos

cmp al,0bh
je get_mouse_movement

cmp al,0ch
je set_subroutines

cmp al,14h
je swap_subroutines

ret ; iret

reset_mouse:
jmp _reset_mouse
show_mouse:
jmp _show_mouse
hide_mouse:
jmp _hide_mouse
get_pos:
jmp _get_pos
set_pos:
jmp _set_pos
set_hor_pos:
jmp _set_hor_pos

set_ver_pos:
jmp _set_ver_pos
get_mouse_movement:
jmp _get_mouse_movement
set_subroutines:
jmp _set_subroutines
swap_subroutines:
jmp _swap_subroutines
_reset_mouse:
mov byte [buttons],0
mov word [pos_x],0
mov word [pos_y],0
mov word [x_move],0
mov word [y_move],0
mov word [x_max],639
mov word [x_min],0
mov word [y_max],199
mov word [y_min],0
mov word [user_mask],0
mov word [user_subroutine],0
mov word [user_subroutine+2],0
mov ax,0ffffh
mov bx,3
ret ; iret

_get_pos:
mov cx,word [pos_x]
mov dx,word [pos_y]
mov bx,word [buttons]
xor bh,bh
ret ; iret

_get_mouse_movement:
mov cx,word [x_move]
mov dx,word [y_move]
mov word [x_move],0
mov word [y_move],0
ret ; iret

_show_mouse:
push ax
push bx
push di
push es
mov byte [sm_flag],1
mov ax,word [pos_y]
shr ax,3
mov bl,80
mul bl
mov bx,word [pos_x] ; cs:
shr bx,3
add ax,bx
shl ax,1
mov di,ax
mov ax,0xb800
mov es,ax
mov ax,word [di]
mov [save_char],ax ; cs:
not ah
and ah,7fh
mov [di],ax
pop es
pop di
pop bx
pop ax
ret ; iret

_hide_mouse:
push ax
push bx
push di
push es
mov byte [sm_flag],0 ; cs:
mov ax,word [pos_y] ; cs:
shr ax,3
mov bl,80
mul bl
mov bx,word [pos_x] ; cs:
shr bx,3
add ax,bx
shl ax,1
mov di,ax
mov ax,0xb800
mov es,ax
mov ax,word [save_char] ; []
mov word [di],ax
pop es
pop di
pop bx
pop ax
ret ; iret

_set_pos:
mov cx,[pos_x]
mov dx,[pos_y]
mov word [x_move],0
mov word [y_move],0
ret ; iret

_set_hor_pos:
call max_min
mov [x_min],cx
mov [x_max],dx
cmp [pos_x],cx
jge good_hor_min
mov [pos_x],cx

good_hor_min:
cmp [pos_x],dx
jle good_hor_max
mov [pos_x],dx
good_hor_max:
ret ; iret

_set_ver_pos:
call max_min
mov [y_min],cx
mov [y_max],dx
cmp [pos_y],cx
jge good_ver_min
mov [pos_y],cx

good_ver_min:
cmp [pos_y],dx
jle good_ver_max
mov [pos_y],dx

good_ver_max:
ret ; iret

max_min:
cmp cx,dx
jle no_swap
xchg cx,dx

no_swap:
ret

_set_subroutines:
mov [user_subroutine],dx
mov [user_subroutine+2],es
mov [user_mask],cx
ret ; iret

_swap_subroutines:
push word [user_mask]
push word [user_subroutine+2]
push word [user_subroutine]
mov [user_subroutine],dx
mov [user_subroutine+2],es
mov [user_mask],cx
pop dx
pop es
pop cx
ret ; iret

end_of_tsr: