;
; 08h interrupt driver (from BYTE special issue, nov. 86, pp 249-262)
;
; Adaptation: Marc Savary, Ad Lib Inc, 1986/11/03
;

;	This module allows you to change the timer-0 interrupt rate,
;   without affecting the rate at which the currently installed
;   routine is called ( 18.2 Hz).
;
;	A user function (TimeOut()) is called after 'n'
;   interrupts, 'n' being reset after each call.


; Originally written for Lattice C Compiler, small model.  Adapted to
; Microsoft by using macros (notably BEGIN, P_END, EXTERN).  A flag for the
; type of compiler is defined in the file VERSION.INC.  According to this
; flag, the file containing the appropriate equates and macros is then
; included.

  INCLUDE VERSION.INC      ;*** compilation flags are defined in this file ***

  IF MICROSOFT
	INCLUDE CMICRO.MAC     ;memory model & equates for Microsoft environment
  ELSE
	INCLUDE DOS.MAC        ;memory model & equates for Lattice environment
  ENDIF

  INCLUDE COMMON.MAC       ;macros common to both environments


clk_int equ 08h     ; timer-0 interrupt vector number


; ============= vector structure ==========

vector	struc
regip	dw	?
regcs	dw	?
vector	ends


; ========================= DATA SEGMENT ============================

	DSEG

int_stack_size		equ	512

the_stack 		db	int_stack_size DUP ('S')
interrupt_stack_top dw  0

	ENDDS
		

;========================== CODE SEGMENT ============================

  IF MICROSOFT
	PSEG  <TIMER>
  ELSE
	PSEG
  ENDIF

  EXTERN  TimeOut


clkdivh	dw	?		; actual divisor ... high
clkdivl	dw	?		; ... low
clkmod	dw	?		; divisor modulus

int08	vector	<>

appl_ds dw	?
old_ss	dw	?		; interrupted code's SS
old_sp	dw	?		; SP .......

soundDelay	dw	?	; delay counter
user_routine_on	db	(?)	; flag to avoid reentrance




;	clkrate()
;
;	change timer-0 divider
;	IN : AX count divisor
;
	IF	LPROG
clkrate	proc FAR
	ELSE
clkrate	proc NEAR
	ENDIF
; load counter 0 of 8253:
	push    ax
	mov	al, 00110110b	; square wave mode
	out	43h, al
	pop	ax
	out	40h, al
	xchg	ah, al
	out	40h, al
	xchg	ah, al
	ret
clkrate endp


;   _SetInt( state)
;
;	enable/disable CPU interrupt.
;
BEGIN  SetInt

Sintframe struc
	dw	(?)
	db	CPSIZE DUP (?)
state	dw	(?)			; interrupt state
Sintframe ends
	push    bp
	mov	bp, sp

	cmp	[ bp].state, 0
	jne	s_on
; off:
	cli
	jmp	s_end
s_on:
	sti
s_end:
	pop	bp
	ret

P_END  SetInt




;   _SetClkRate( unsigned count)
;
;	Initialize interrupt rate to (1.119 MHz / count) cycles/sec.
;
BEGIN SetClkRate

scrframe struc
	dw	(?)
	db	CPSIZE DUP (?)
divid	dw	(?)			; timer's divider
scrframe ends
	push	bp
	mov	bp, sp

	mov	ax, [ bp].divid
	pushf
	cli	
	mov	CS:clkdivl, ax
	cmp	ax, 1
	mov	CS:clkdivh, 0
	adc	CS:clkdivh, 0
	call	clkrate
	popf
	pop	bp
	ret
P_END  SetClkRate



; Install clock-driver (soft int-08, timer-0).
; Save a copy of DS.
;
BEGIN  clk_install

; install clock interrupt handler
	push    ax
	push	dx

; init. clk variables:
	xor	ax, ax
	call	clkrate
	mov	CS:clkdivh, 1
	mov	CS:clkdivl, ax
	mov	CS:clkmod, ax

; init flag:
	mov	cs:user_routine_on, 0

; save application DS:
	mov	ax, ds
	mov	cs:appl_ds, ax

; save current int. vector
	push	es
	mov	ah, 35h
	mov	al, clk_int
	int	21h			; get old vector
	assume es:nothing
	mov	CS:int08.regip, bx
	mov	CS:int08.regcs, es
	pop	es
; install interrupt intercept vector:
	push	ds
	mov	ah, 25h
	mov	al, clk_int
	mov	dx, offset clkint
	mov	bx, CS
	mov	ds, bx
	int	21h			; set int. vector
	pop	ds
	pop	dx
	pop	ax

	ret
P_END  clk_install



;   _clk_uninstall()
;
BEGIN  clk_uninstall

	xor	ax, ax
	call	clkrate
; reset int. vector:
	push	ds
	mov	ah, 25h
	mov	al, clk_int
	lds	dx, CS:int08
	int	21h			; set vector ...
	pop	ds
	ret
P_END  clk_uninstall




;   _StartTimeOut( delay)
;
;	Initialize count-down delay to 'delay'.
;

BEGIN  StartTimeOut

istad	struc
	dw	(?)
	db	CPSIZE DUP (?)
delay	dw	(?)			; delay before doing the next call
istad	ends

	push	bp
	mov	bp, sp
	pushf
	cli
	mov     ax, [ bp].delay
	mov     cs:soundDelay, ax
	popf
	pop	bp
	ret

P_END  StartTimeOut



; 	clkint
;
; int-08 Interrupt Driver routine.
;
; Check for roll-over of 65536 cycles ( 18.2 hz ) and call
; old driver if so.
; 
; Count-down delay variable, and if zero, call routine 'TimeOut()'
; & set the new delay.
;
clkint	proc FAR

	push	ax

; check for roll-over of 65536 cycles ( 18.2 hz )
	mov	ax, CS:clkdivl
	add	CS:clkmod, ax
	mov	ax, CS:clkdivh
	adc	ax, 0
	jnz	clkint8
; not yet time, skip original interrupt
	mov	al, 00100000b
	out	20h, al			; 8259 ...
	jmp	clkint7
; do the original interrupt:
clkint8	label	near
	pushf
	call	CS:int08

clkint7	label	near

	dec	CS:soundDelay		; 16 bits unsigned counter
	jnz	clkint_end

; to avoid a reentrant call
	cmp	CS:user_routine_on, 0
	jnz	clkint_end		; already active ...

; end of delay. Prepare environment before calling TimeOut()
; (allocate temporary stack, set segment registers).
;

; save all registers...	
	push	bx
	push	cx
	push	dx
	push	ds
	push	es
	push	si
	push	di
	push	bp

; save active stack pointers
	mov	cs:old_ss, ss
	mov	cs:old_sp, sp

; get application's DS
	mov	ax, cs:appl_ds
	mov	es, ax
	mov	ds, ax

; set new stack:
	mov	ss, ax
	mov	sp, offset DGROUP:interrupt_stack_top


go_user	label near
public go_user

; protect call with flag
	inc	CS:user_routine_on

; call the C routine
	sti
	IF MICROSOFT
	call    _TimeOut         ; time-out driver ... ==> AX: new delay
	ELSE
	call    TimeOut         ; time-out driver ... ==> AX: new delay
	ENDIF

	cli
; 
	dec	CS:user_routine_on

; compute new delay
	mov	bx, CS:soundDelay
	neg	bx				; # of interrupt since call to TimeOut()
	cmp	bx, ax				; time-out ?
	jb	clk_delay_ok			; no ...

; we must recall TimeOut immediately
	mov	CS:soundDelay, 0
	jmp	go_user

clk_delay_ok	label near
	add	CS:soundDelay, ax		; leftover delay count

; restore stack
	mov	bx, CS:old_ss
	mov	ss, bx
	mov	sp, CS:old_sp

	sti

	pop	bp
	pop	di
	pop	si
	pop	es
	pop	ds
	pop	dx
	pop	cx
	pop	bx

clkint_end	label near
	pop	ax
	iret
clkint	endp


  IF MICROSOFT
	ENDPS  <TIMER>
  ELSE
	ENDPS
  ENDIF

	end