📄 clock.asm
字号:
; File : $CLOCK.ASM$
;
; Description :
;
; Original Author : DIGITAL RESEARCH
;
; Last Edited By : $CALDERA$
;
;-----------------------------------------------------------------------;
; Copyright Work of Caldera, Inc. All Rights Reserved.
;
; THIS WORK IS A COPYRIGHT WORK AND CONTAINS CONFIDENTIAL,
; PROPRIETARY AND TRADE SECRET INFORMATION OF CALDERA, INC.
; ACCESS TO THIS WORK IS RESTRICTED TO (I) CALDERA, INC. EMPLOYEES
; WHO HAVE A NEED TO KNOW TO PERFORM TASKS WITHIN THE SCOPE OF
; THEIR ASSIGNMENTS AND (II) ENTITIES OTHER THAN CALDERA, INC. WHO
; HAVE ACCEPTED THE CALDERA OPENDOS SOURCE LICENSE OR OTHER CALDERA LICENSE
; AGREEMENTS. EXCEPT UNDER THE EXPRESS TERMS OF THE CALDERA LICENSE
; AGREEMENT NO PART OF THIS WORK MAY BE USED, PRACTICED, PERFORMED,
; COPIED, DISTRIBUTED, REVISED, MODIFIED, TRANSLATED, ABRIDGED,
; CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED, RECAST,
; TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF
; CALDERA, INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT
; AUTHORIZATION COULD SUBJECT THE PERPETRATOR TO CRIMINAL AND
; CIVIL LIABILITY.
;-----------------------------------------------------------------------;
;
; *** Current Edit History ***
; *** End of Current Edit History ***
;
; $Log$
; CLOCK.ASM 1.12 93/07/22 19:43:10
; switch over to REQUEST.EQU
; ENDLOG
include BIOSGRPS.EQU
include DRMACROS.EQU ; standard DR macros
include IBMROS.EQU ; ROM BIOS equates
include REQUEST.EQU ; request header equates
include DRIVER.EQU ; device driver equates
page
CGROUP group CODE, RCODE, RESUMECODE, ICODE
CG equ offset CGROUP
TIME struc
DAYS dw ?
MINUTES db ?
HOURS db ?
HUNDREDTHS db ?
SECONDS db ?
TIME ends
Assume CS:CGROUP, DS:CGROUP, ES:Nothing, SS:Nothing
CODE segment 'CODE'
extrn endbios:word ; for device driver INIT function
extrn daycount:word
; There are 1193180/65536 ticks per second, or 0E90Bh/10000h ticks per 5/100th.
CONVERSION_FACTOR equ 0E90Bh
CODE ends
RCODE segment 'RCODE'
extrn DataSegment:word
monlen db 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
Public ClockTable
ClockTable:
db 9 ; Last supported function
dw CG:dd_init ; 0-initialize driver
dw CG:dd_error ; 1-media change check (disks only)
dw CG:dd_error ; 2-build BPB (disks only)
dw CG:dd_error ; 3-IOCTL string input
dw CG:dd_input ; 4-input
dw CG:dd_error ; 5-nondestructive input (char only)
dw CG:dd_error ; 6-input status (char only)
dw CG:dd_error ; 7-input flush
dw CG:dd_output ; 8-output
dw CG:dd_output ; 9-output with verify
page
driver proc near
dd_error: ; used for all unsupported driver functions
;--------
mov ax,RHS_ERROR+3 ; "invalid command" error
ret
dd_input: ; 4-input
;--------
les di,es:RH4_BUFFER[bx] ; ES:DI -> requested date/time buffer
call read_system_ticks ; read system tick counter
mov ax,daycount ; AX = date
stosw ; return date
push dx ; save low word of ticks
mov ax,5
mul cx ; multiply high word of ticks by 5
xchg ax,cx ; save result in CX
pop dx
mov ax,5
mul dx ; multiply low word of tick by 5
add dx,cx ; and add in high word
mov bx,CONVERSION_FACTOR
div bx ; convert to centi-secs
push ax ; save high word of result
xor ax,ax
div bx ; divide remainder
pop dx ; recover high word of result
; giving us time in centi-secs
mov bx,60*100 ; BX = centi-secs/minute
div bx ; AX = # minutes
push dx ; save centi-secs remainder
cwd ; DX = 0
mov bx,60+(256*100) ; BL = minutes/hour,BH = centi-secs/sec
div bl ; AL = hours, AH = minutes remainder
xchg al,ah
stosw ; return minutes then hours
pop ax ; recover centi-secs remainder
div bh ; AL = secs, AH = centi-secs remainder
xchg al,ah
stosw ; return centi-secs then secs
sub ax,ax
ret
page
dd_output: ; 8-output
;---------
les si,es:RH4_BUFFER[bx]
; First we'll convert the date & set the RTC if present:
mov ax,es:DAYS[si] ; # of days since 1/1/1980
mov daycount,ax
mov dx,1980 ; get initial year
output1:
mov cx,365 ; assumed year size
test dl,3 ; test for leap years
jnz output2 ; skip if not a leap year
inc cx ; leap years have 366 days
output2:
cmp ax,cx ; more days than this year?
jb output3 ; skip if less - same year
sub ax,cx ; else date in future year
inc dx ; subtract from total, next year
jmps output1 ; check again
output3: ; DX = binary year, AX = day in year
sub bx,bx ; start with January
sub cx,cx ; CH = 0
output4:
mov cl,cs:monlen[bx] ; CX = # of days in next month
cmp cl,28 ; is it february ?
jne output5
test dl,3 ; is it a leap year ?
jnz output5
inc cx ; leap years have 29 days in february
output5:
cmp ax,cx ; remaining day count >= month length?
jb output6 ; skip if right month found
sub ax,cx ; else subtract days in that month
inc bx ; move on to next month
jmps output4 ; repeat until month found
output6: ; DX = binary year
inc ax ; AX = day-1 => convert to day
inc bx ; BX = month-1 => convert to month
mov ah,bl ; high byte is month
call bin2bcd ; convert to month
xchg ax,dx ; DL, DH = day, month of date
; AX = binary year
mov bl,100
div bl ; AL = century, AH = year
xchg al,ah ; AH = century, AL = year
call bin2bcd ; convert AL, AH from binary to BCD
xchg ax,cx ; CL, CH = year, century for date
mov ah,5 ; set real time clock date
int RTC_INT ; on AT, XT-286, PS/2, etc.
; Now we'll convert the time & set the RTC if present
; mov ah,es:HOURS[si]
; mov al,es:MINUTES[si] ; get binary hours & minutes
mov ax,es:word ptr MINUTES[si]
call bin2bcd ; convert to BCD values
xchg ax,cx ; CH, CL = hh:mm in BCD
mov ah,es:SECONDS[si]
mov al,0 ; get binary seconds & no daylight saving
call bin2bcd ; convert to BCD values
xchg ax,dx ; DH, DL = ss.000 in BCD
mov ah,3 ; set real time clock time
int RTC_INT ; on AT, XT-286, PS/2, etc.
mov al,100
mul es:SECONDS[si] ; AX = seconds in hundredths
xchg ax,dx ; save in DX
mov al,es:HUNDREDTHS[si]
cbw ; AX = hundredths
add ax,dx ; AX = secs and hundredths in 1/100ths
cwd ; make the a dword
mov bx,5
div bx ; AX = secs and hundredths in 5/100ths
xchg ax,bx ; save in BX
mov al,60 ; convert hours into minutes
mul es:HOURS[si] ; AX = hours in mins
xchg ax,dx
mov al,es:MINUTES[si]
cbw ; AX = minutes value
add ax,dx ; AX = hours and mins in mins
mov dx,60*20
mul dx ; DX:AX = hours and mins in 5/100ths
add ax,bx
adc dx,0 ; DX:AX = total in 5/100ths
mov bx,CONVERSION_FACTOR ; load up our magic value
push dx ; save high word
mul bx ; DX = low word result
mov cx,dx ; save for later
pop ax ; recover high word
mul bx ; DX:AX = result from high word
add ax,cx ; add low and high word results
adc dx,0 ; together in DX:AX
xchg ax,dx ; DX = low word of result
xchg ax,cx ; CX = high word of result
mov ah,1 ; set system timer
int RTC_INT ; CX = high word, DX = low word
sub ax,ax ; return successfully when done
ret
Public read_system_ticks
read_system_ticks:
;-----------------
mov ah,0 ; read system tick counter
int RTC_INT
test al,al ; have we passed midnight ?
jz read_st10 ; if so a new day has dawned
inc daycount
read_st10:
ret
bin2bcd: ; convert AL and AH to BCD values
;-------
call bin2bcd1 ; swap AL, AH, convert to BCD
; call bin2bcd1
; ret
bin2bcd1:
push cx
mov ch,ah ; save AH in scratch register
aam ; AL = AL % 10; AH = AL/10;
mov cl,4
shl ah,cl ; shift tens into high nibble
or ah,al ; combine the nibbles
mov al,ch ; restore the high byte into low byte
pop cx
ret
driver endp
RCODE ends ; end of device driver code
RESUMECODE segment 'RESUMECODE'
; If the system ROM BIOS supports RESUME mode then it will call Int 6C
; when returning from sleep mode. We take this over and reset the clock
; based upon the RTC value. To save space we only relocate the code if
; required.
;
Public ResumeHandler
ResumeHandler proc far
sti
mov ax,cs:DataSegment ; we have been asleep and are being
mov ds,ax ; woken by the BIOS
mov es,ax ; lets re-read the RTC before
call set_clock ; we return to them
clc
ret 2
ResumeHandler endp
set_monlen db 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
set_clock:
;---------
; We may also be called after a RESUME when we have to reset the time.
mov ah,2 ; read real time clock
xor cx,cx
xor dx,dx ; assume it won't work
stc
int RTC_INT ; CH = hours, CL = mins, DH = secs
jc set_clock40 ; (all in BCD remember)
xchg al,dh ; AL = secs
call bcd2bin ; AL = secs in binary
cmp al,59
ja set_clock40 ; reject invalid seconds
mov ah,100
mul ah ; AX = seconds in hundredths
cwd ; make it a dword
mov bx,5
div bx ; AX = secs and hundredths in 5/100ths
xchg ax,bx ; save in BX
mov al,ch ; AL = hours in BCD
call bcd2bin ; AL = hours in binary
cmp al,23
ja set_clock40 ; reject invalid hours
mov ah,60 ; convert hours into minutes
mul ah ; AX = hours in mins
xchg ax,dx ; save in DX
mov al,cl ; AL = mins in BCD
call bcd2bin ; AL = mins in binary
cmp al,59
je set_clock40 ; reject invalid mins
cbw ; AX = minutes value
add ax,dx ; AX = hours and mins in mins
mov dx,60*20
mul dx ; DX:AX = hours and mins in 5/100ths
add ax,bx
adc dx,0 ; DX:AX = total in 5/100ths
mov bx,CONVERSION_FACTOR ; load up our magic value
push dx ; save high word
mul bx ; DX = low word result
mov cx,dx ; save for later
pop ax ; recover high word
mul bx ; DX:AX = result from high word
add ax,cx ; add low and high word results
adc dx,0 ; together in DX:AX
xchg ax,dx ; DX = low word of result
xchg ax,cx ; CX = high word of result
mov ah,1 ; set system timer
int RTC_INT ; CX = high word, DX = low word
set_clock40:
mov ah,4 ; read RTC (if present)
int RTC_INT ; validate date - CMOS may be corrupt
cmp cx,1980h ; Too low?
jb set_clock45 ; Yes so skip
cmp cx,2099h ; Too high ?
ja set_clock45 ; Yes so skip
cmp dx,0101h ; Too low?
jb set_clock45 ; Yes so skip
cmp dx,3112h ; Too high ?
jbe set_clock50 ; No its okay so scram
set_clock45:
mov cx,1980h ; assume the year 1980
mov dx,0101h ; assume 1st of January of that year
set_clock50:
xchg ax,cx ; AL, AH = year, century in BCD
call bcd2bin ; convert values to binary
xchg ax,cx
xchg ax,dx ; AL, AH = day, month in BCD
call bcd2bin ; convert values to binary
xchg ax,dx
mov daycount,0 ; zero the daycount in case of RESUME
mov ax,19*256 + 80 ; assume 1980
set_clock55:
cmp ax,cx ; same year?
je set_clock65
mov bx,365 ; assume 365 days in that year
test al,3 ; test for leap year
jnz set_clock60 ; (this works til 2400 A.D.)
inc bx ; add FEB 29 if divisible by four
set_clock60:
add daycount,bx ; add days in previous year to total
inc al ; next year
cmp al,100 ; end of century?
jb set_clock55 ; skip if same century
mov al,0 ; continue with XX00
inc ah ; ...next century
jmps set_clock55 ; check year again
set_clock65: ; same year by now
xchg ax,cx ; CX = year
sub dx,0101h ; make month, day 0 relative
sub bx,bx ; assume January
sub ax,ax ; AH = 0
set_clock70:
cmp dh,bl ; does current month match?
je set_clock80 ; skip if it does
mov al,cs:set_monlen[bx] ; get length of that month
cmp al,28 ; is it february ?
jne set_clock75
test cl,3 ; is it a leap year ?
jnz set_clock75
inc ax ; leap year, 29 days in february
set_clock75:
add daycount,ax ; add it to total day count
inc bx ; move on to next month
jmps set_clock70
set_clock80:
mov al,dl ; get days in that month
add daycount,ax ; add them to day count
ret
bcd2bin:
;-------
; entry: AL, AH = BCD values
; AL, AH = binary equivalents
call bcd2bin1 ; swap AL, AH, convert AL to binary
; call bcd2bin1 ; swap AL, AH, convert AL to binary
; ret
bcd2bin1: ; convert BCD to binary
xchg al,ah ; swap the two values
push bx
mov bl,0 ; start off without tens
bcd2bin2:
cmp al,10h ; check if more tens
jb bcd2bin3 ; all tens done
sub al,10h ; else subtract 10 in BCD
add bl,10 ; ...and add it in binary
jmps bcd2bin2 ; repeat for all tens
bcd2bin3: ; AL = ones, BL = tens
add al,bl ; AL = binary value
pop bx ; restore BX
ret
RESUMECODE ends
ICODE segment 'ICODE' ; initialization code
Assume CS:CGROUP, DS:CGROUP
dd_init: ; 0-initialize driver
;-------
call set_clock ; set elapsed ticks
les bx,REQUEST[bp] ; ES:BX -> request header
mov ax,endbios
mov es:RH0_RESIDENT[bx],ax ; set end of device driver
mov es:RH0_RESIDENT+2[bx],ds
sub ax,ax ; initialization succeeded
ret ; (BIOS init always does...)
ICODE ends
end
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -