mirror of
https://github.com/SEPPDROID/Digital-Research-Source-Code.git
synced 2025-10-25 17:34:06 +00:00
186 lines
4.8 KiB
Plaintext
186 lines
4.8 KiB
Plaintext
;*****************************************************
|
|
;*
|
|
;* Flag Management
|
|
;*
|
|
;* FLAGS-flag table offset NFLAGS-number of flags
|
|
;*
|
|
;* Format of Flag Table Entry:
|
|
;* +-------------+------+
|
|
;* | flag |ignore|
|
|
;* +-------------+------+
|
|
;* flag - 00000h, flag can be allocated
|
|
;* flag - 0ffffh, flag is off but is allocated to some
|
|
;* function.
|
|
;* 0fffeh, flag is set
|
|
;* 0xxxxh, PD that is waiting
|
|
;* ignore- 0ffh, normal case
|
|
;* 0xxh, number of flags to ignore-1
|
|
;*
|
|
;* GENSYS initializes the flags reserved by the system
|
|
;* and the XIOS header to 0ffh's. The rest of the
|
|
;* flags are initialized to 0 by GENSYS.
|
|
;*
|
|
;*****************************************************
|
|
|
|
;============
|
|
;getfree_flag:
|
|
;============
|
|
|
|
; input: DX = 0 then allocate a flag
|
|
; else
|
|
; if DH = 0FFH then release flag number
|
|
; DL (0 relative)
|
|
; output:
|
|
; BX = flag allocated if getting a flag
|
|
; or 0FFFFH if no flag is available
|
|
; BX = 0FFFFH if attempting to release a
|
|
; no existent flag
|
|
; CX = 0 no error
|
|
; CX = 4 if illegal flag number
|
|
; CX = 27H if no more flags to allocate
|
|
;
|
|
; Flags reserved by CCP/M or MP/M and the XIOS
|
|
; header, cannot be released.
|
|
;
|
|
;turn off interrupts
|
|
;
|
|
; test dx,dx ! jz rf_alloc
|
|
; inc dh ! jnz rf_enum
|
|
; cmp dl,nrsv_flags ! jbe rf_enum
|
|
; cmp dl,nflags ! jae rf_enum
|
|
; xor ax,ax ! mov bx,ax ! mov cx,ax
|
|
; mov al,dl
|
|
; add al,dl ! add al,dl
|
|
; mov si,ax ! mov word ptr flags[si],0
|
|
; mov byte ptr flags 2[si],0
|
|
; ret
|
|
|
|
;rf_alloc:
|
|
|
|
; mov si,flags ! xor ax,ax
|
|
; mov bx,ax ! mov cx,nflags
|
|
;rf_nxt:
|
|
; cmp ax,[si] ! je rf_foundone ;got one
|
|
; add si,3 ! inc bx
|
|
; loop rf_nxt
|
|
; mov cx,e_noflags ! jmps rf_err
|
|
;rf_foundone:
|
|
; mov cx,ax ;0 CX
|
|
; dec ax
|
|
; mov [si],ax ;set the 3 bytes to 0ffh
|
|
; mov 2[si],al
|
|
; ret
|
|
;rf_enum:
|
|
; mov cx,e_illflag
|
|
;rf_err:
|
|
; mov bx,0ffffh
|
|
; ret
|
|
|
|
;============== ==========================
|
|
flag_set_entry: ; Set Logical Interrupt Flag
|
|
;============== ==========================
|
|
; NOTE: the flagset routine can (must?) be called from outside
|
|
; the operating system through an interrupt
|
|
; routine. UDA variables cannot be used. This
|
|
; is the only function an interrupt routine can
|
|
; call.
|
|
;
|
|
; input: DL = flag number
|
|
; output: BX = 0 if okay,0ffffh if error
|
|
; CX = if error: e_flag_ovrrun
|
|
|
|
call flag_valid
|
|
cmp cl,flag_tick ! jne notick
|
|
mov bx,dlr
|
|
test bx,bx ! jz dlr_null ;no process waiting
|
|
dec p_wait[bx] ! jnz nxt_tick
|
|
nxt_tpd:
|
|
mov si,p_link[bx] ! mov dlr,si ;SI,DLR=next waiting PD
|
|
mov p_stat[bx],ps_run ;put PD done waiting
|
|
mov ax,drl ! mov p_link[bx],ax ;on DRL
|
|
mov drl,bx
|
|
test si,si ! jz dlr_null ;SI=next waiting PD
|
|
cmp p_wait[si],0 ! jnz nxt_tick
|
|
mov bx,si ! jmps nxt_tpd;another process was waiting
|
|
;the same number of ticks
|
|
nxt_tick: jmp flag_exit ;wait for next tick
|
|
|
|
dlr_null: ;DLR is empty turn off
|
|
mov tick,false ! jmp flag_exit ;XIOS tick flag
|
|
|
|
no_tick:
|
|
cmp flg_ignore[si],flag_zig ! je fs_set
|
|
dec flg_ignore[si] ! jmp flag_exit
|
|
|
|
fs_set: cmp bx,flag_on ! jne fs_non
|
|
mov cx,e_flag_ovrrun ! jmp flag_bexit
|
|
|
|
fs_non: cmp bx,flag_off ! jne fs_noff
|
|
mov flg_pd[si],flag_on
|
|
jmp flag_exit
|
|
|
|
fs_noff:mov ax,drl ! mov p_link[bx],ax
|
|
mov drl,bx ! mov p_stat[bx],ps_run
|
|
or p_flag[bx],pf_resource ;12/4/83
|
|
mov flg_pd[si],flag_off
|
|
jmp flag_exit
|
|
|
|
;=============== ===============================
|
|
flag_wait_entry: ; Wait for Logical Interrupt Flag
|
|
;=============== ===============================
|
|
; input: DL = flag number
|
|
; output: BX = 0 if everything okay
|
|
; BX = 0ffffh if Error
|
|
; CX = Error Code:0,e_flag_underrun
|
|
|
|
|
|
call flag_valid
|
|
cmp bx,flag_on ! jne fw_non
|
|
mov flg_pd[si],flag_off
|
|
jmp flag_exit
|
|
fw_non: cmp bx,flag_off ! jne fw_noff
|
|
mov bx,rlr
|
|
mov p_stat[bx],ps_flagwait
|
|
mov u_dparam,si
|
|
call dsptch ! jmp flag_exit
|
|
fw_noff:mov cx,e_flag_underrun ! jmp flag_bexit
|
|
|
|
flag_valid: ; Check validity of flag number
|
|
;---------- -----------------------------
|
|
; entry: DL = flag number
|
|
; output: SI = ptr to flag entry
|
|
; BX = contents of flag entry
|
|
; CL = flag number
|
|
; clear interrupt flag - Flags on stack
|
|
|
|
pop ax ! pushf ;AX=return address
|
|
cmp dl,nflags ! jb flag_good
|
|
flag_bad:
|
|
mov cx,e_ill_flag ! jmp flag_bexit ;flags and next return
|
|
flag_good: ;address on stack
|
|
mov cl,dl ;save flag number
|
|
xor dh,dh ! push ax ! cli ;return to fset/fwait on stack
|
|
mov ax,dx ;multiply flag number
|
|
mov bx,ax ;times 3
|
|
add ax,ax ;*2
|
|
add ax,bx ;*3
|
|
mov si,flags ! add si,ax
|
|
mov bx,[si]
|
|
;test bx,bx ;FLAG field cannot be 0
|
|
;jz flag_bad
|
|
ret
|
|
|
|
flag_exit: ; Successful Exit
|
|
;--------- ---------------
|
|
; entry: flags and return from flagset or flagwait on stack
|
|
|
|
xor bx,bx ! popf ! ret
|
|
|
|
|
|
flag_bexit: ; Exit with Error
|
|
;---------- ---------------
|
|
; entry: flags and return from flagset or flagwait on stack
|
|
|
|
xor bx,bx ! dec bx
|
|
popf ! ret
|