/***************************************************************************
* NAME: IRQ.C
** COPYRIGHT:
** "Copyright (c) 1992, by FORTE
**
** "This software is furnished under a license and may be used,
** copied, or disclosed only in accordance with the terms of such
** license and with the inclusion of the above copyright notice.
** This software or any other copies thereof may not be provided or
** otherwise made available to any other person. No title to and
** ownership of the software is hereby transfered."
****************************************************************************
* CREATION DATE: 11/18/92
*--------------------------------------------------------------------------*
* VERSION DATE NAME DESCRIPTION
*> 1.0 11/18/92 Original
***************************************************************************/
#include <stdio.h>
#include <dos.h>
// #include <conio.h>
#include "forte.h"
#include "gf1proto.h"
#include "osproto.h"
/* internal include files */
#include "gf1hware.h"
#include "dma.h"
#include "irq.h"
#include "gf1os.h"
/* #pragma inline */
extern IRQ_ENTRY _gf1_irq[];
extern DMA_ENTRY _gf1_dma[];
extern ULTRA_DATA _gf1_data;
extern void SaveSegRegs();
extern void GetSegRegs();
void
gf1_setvect( int int_number, PVI isr )
{
#ifdef METAWARE
SaveSegRegs();
/* set protected mode irq handler ... */
_setpvect(int_number,isr);
// _setrpvectp(int_number,isr);
#endif
#ifdef WATCOMC
/* set protected mode irq handler ... */
union REGS r;
r.x.eax = 0x0205;
r.h.bl = int_number;
r.x.edx = FP_OFF (isr);
r.w.cx = FP_SEG (isr);
int386 (0x31, &r, &r); /* set prot. vector thru DPMI */
#endif /* WATCOMC */
#ifdef MSOFTC
asm push ds;
asm lds dx,isr;
asm mov ah,0x25;
asm mov al,int_number;
asm int 21h;
asm pop ds;
#endif
#ifdef BORLANDC
asm push ds;
asm lds dx,isr;
asm mov ah,0x25;
_AL = int_number;
asm int 21h;
asm pop ds;
#endif
}
PVI
gf1_getvect( int int_number )
{
#ifdef METAWARE
return(_getpvect(int_number));
#endif
#ifdef WATCOMC
union REGS r;
r.x.eax = 0x0204;
r.h.bl = int_number;
int386 (0x31, &r, &r);
return ((PVI)MK_FP (r.w.cx, r.x.edx));
#endif
#ifdef MSOFTC
asm push ds;
asm mov ah,0x35;
asm mov al,int_number;
asm int 21h;
asm mov dx,es;
asm mov ax,bx;
asm pop ds;
#endif
#ifdef BORLANDC
asm push ds;
asm mov ah,0x35;
_AL = int_number;
asm int 21h;
asm mov dx,es;
asm mov ax,bx;
asm pop ds;
#endif
}
void
ReSetIrqHandlers(int gf1_irq,int midi_irq)
{
int temp_irq;
temp_irq = gf1_irq;
if (temp_irq != 0)
{
if (gf1_irq > 7)
gf1_irq += 0x68;
else
gf1_irq += 0x08;
gf1_setvect (gf1_irq,_gf1_data.old_gf1_vec);
}
if ((temp_irq != midi_irq) && (midi_irq != 0))
{
if (midi_irq > 7)
midi_irq += 0x68;
else
midi_irq += 0x08;
gf1_setvect (midi_irq,_gf1_data.old_midi_vec);
}
}
void
SetIrqs(int gf1_irq,int midi_irq)
{
unsigned char val;
#ifdef MEATWARE
_gf1_data.gf1_sema4 = 0;
_gf1_data.irq_pending = 0;
#endif
if (gf1_irq != 0)
{
/* unmask gf1 interrupt */
val = inp(_gf1_irq[gf1_irq].imr);
val &= _gf1_irq[gf1_irq].mask;
outp(_gf1_irq[gf1_irq].imr,val);
/* send a specific EOI in case of pending interrupt */
outp(_gf1_irq[gf1_irq].ocr,_gf1_irq[gf1_irq].spec_eoi);
}
if ((midi_irq != gf1_irq) && (midi_irq != 0))
{
/* unmask midi interrupt */
val = inp(_gf1_irq[midi_irq].imr);
val &= _gf1_irq[midi_irq].mask;
outp(_gf1_irq[midi_irq].imr,val);
/* send a specific EOI in case of pending interrupt */
outp(_gf1_irq[midi_irq].ocr,_gf1_irq[midi_irq].spec_eoi);
}
/* Un-mask IRQ 2 from first controller if using 2nd controller */
if (midi_irq > 7 || gf1_irq > 7)
{
val = inp(_gf1_irq[2].imr);
val &= _gf1_irq[2].mask;
outp(_gf1_irq[2].imr,val);
/* send a specific EOI in case of pending interrupt */
outp(_gf1_irq[2].ocr,_gf1_irq[2].spec_eoi);
}
}
void
ResetIrqs(int gf1_irq,int midi_irq)
{
unsigned char val;
/* unmask gf1 interrupt */
if ((gf1_irq != 2) && (gf1_irq != 0))
{
/* turn mask bit back on ... */
val = inp(_gf1_irq[gf1_irq].imr);
val |= ~_gf1_irq[gf1_irq].mask;
outp(_gf1_irq[gf1_irq].imr,val);
}
if ((midi_irq != 2) && (midi_irq != 0))
{
/* unmask midi interrupt */
val = inp(_gf1_irq[midi_irq].imr);
val |= ~_gf1_irq[midi_irq].mask;
outp(_gf1_irq[midi_irq].imr,val);
}
}
/* static */ void
handle_dma_tc(void)
{
DMA_ENTRY *tdma;
unsigned char val;
/* First, check to see if we need to service dram dma terminal count */
/* Note: This read also clears the pending irq ... */
ENTER_CRITICAL;
outp(_gf1_data.reg_select,DMA_CONTROL);
val = inp(_gf1_data.data_hi);
LEAVE_CRITICAL;
if (val & DMA_IRQ_PENDING)
{
tdma = &_gf1_dma[_gf1_data.dram_dma_chan-1];
if (tdma->flags & TWO_FLAG)
{
UltraDmaNext(tdma,FALSE); /* handle cross over page */
}
else
{
tdma->flags &= ~DMA_PENDING;
/* show foreground its done */
_gf1_data.flags &= ~DRAM_DMA_BUSY;
tdma->amnt_sent += tdma->cur_size; /* accumulate totals */
/* Call playback processing function.... */
_gf1_data.dram_dma_tc_func();
}
}
/* Now check recording's terminal count */
/* Note: This read also clears the pending irq ... */
ENTER_CRITICAL;
outp(_gf1_data.reg_select,SAMPLE_CONTROL);
val = inp(_gf1_data.data_hi);
LEAVE_CRITICAL;
if (val & ADC_IRQ_PENDING)
{
tdma = &_gf1_dma[_gf1_data.adc_dma_chan-1];
if (tdma->flags & TWO_FLAG)
{
UltraDmaNext(tdma,TRUE); /* handle cross over page */
}
else
{
tdma->flags &= ~DMA_PENDING;
/* show foreground its done */
_gf1_data.flags &= ~ADC_DMA_BUSY;
tdma->amnt_sent += tdma->cur_size; /* accumulate totals */
/* Call ADC processing function.... */
_gf1_data.record_dma_tc_func();
}
}
}
static void
handle_voice(void)
{
unsigned char irq_source;
unsigned int voice;
unsigned long wave_ignore;
unsigned long volume_ignore;
unsigned long voice_bit;
unsigned char temp1;
unsigned char temp2;
/* clear the ignore flags. These flags are needed because we get lots of */
/* 'double' interrupts. This will only allow one interrupt per voice */
wave_ignore = 0L;
volume_ignore = 0L;
/* The GF1 has a fifo (sort of) of all pending wave table irq's. You */
/* should stay here & service ALL pending waveform IRQ's before returning. */
while (TRUE)
{
ENTER_CRITICAL;
outp(_gf1_data.reg_select,GET_IRQV);
irq_source = inp(_gf1_data.data_hi);
LEAVE_CRITICAL;
voice = irq_source & 0x1F; /* pick off the voice # */
irq_source &= (VOICE_VOLUME_IRQ | VOICE_WAVE_IRQ);/* isolate the irq bits */
if (irq_source == (VOICE_VOLUME_IRQ | VOICE_WAVE_IRQ))/* negative logic */
{
break; /* No pending irqs left ... */
}
voice_bit = 1L << (long)voice;
/* See if any waveform irqs first */
if (!(irq_source & VOICE_WAVE_IRQ))
{
/* See if we have already serviced this voice ... */
if (!(wave_ignore & voice_bit))
{
outp(_gf1_data.voice_select,voice);
outp(_gf1_data.reg_select,GET_CONTROL);
temp1 = inp (_gf1_data.data_hi);
outp(_gf1_data.reg_select,GET_VOLUME_CONTROL);
temp2 = inp (_gf1_data.data_hi);
/* If EITHER looping is on OR ROLLOVER is on, don't stop voice */
if (!((temp1 & VC_LOOP_ENABLE) || (temp2 & VC_ROLLOVER)))
{
UltraStopVoice(voice);
wave_ignore |= voice_bit;
}
/* Call waveform processing function.... */
_gf1_data.wavetable_func(voice);
}
}
if (!(irq_source & VOICE_VOLUME_IRQ))
{
if (!(volume_ignore & voice_bit))
{
outp(_gf1_data.voice_select,voice);
outp(_gf1_data.reg_select,GET_VOLUME_CONTROL);
temp1 = inp (_gf1_data.data_hi);
/* If volume looping is enabled, don't stop it */
if (!(temp1 & VL_LOOP_ENABLE))
{
UltraStopVolume(voice);
volume_ignore |= voice_bit;
}
/* Call envelope processing function.... */
_gf1_data.volume_func(voice);
}
}
}
}
static void
gf1_handler(void)
{
unsigned char irq_source;
unsigned int midi_status;
unsigned int data;
#ifdef METAWARE
if (_gf1_data.gf1_sema4)
{
_gf1_data.irq_pending = 1;
return;
}
#endif
/* IRQ's that will be vectored here */
/* 1) DAC sampling. (PC DMA) */
/* 2) Voice Volume Envelope */
/* 3) WAVE table end */
/* 4) DMA to dram. */
/* 5) Possible MIDI */
/* Handle ALL irqs that may be pending */
while (TRUE)
{
/* First, find out who has an interrupt pending */
irq_source = inp(_gf1_data.irq_status);
if (irq_source == 0)
break; /* No more irqs ... */
if (irq_source & DMA_TC_IRQ)
{
handle_dma_tc();
}
if (irq_source & (MIDI_TX_IRQ|MIDI_RX_IRQ))
{
midi_status = (unsigned int)inp(_gf1_data.midi_control);
if (irq_source & MIDI_TX_IRQ)
{
/* Call midi transmit data processing function.... */
_gf1_data.midi_xmit_func(midi_status);
}
if (irq_source & MIDI_RX_IRQ)
{
/* reading data will clear IRQ */
data = (unsigned int)inp(_gf1_data.midi_data);
/* Call midi recieve data processing function.... */
_gf1_data.midi_recv_func(midi_status,data);
}
}
if (irq_source & GF1_TIMER1_IRQ)
{
ENTER_CRITICAL;
outp( _gf1_data.reg_select, TIMER_CONTROL );
outp( _gf1_data.data_hi, _gf1_data.timer_ctrl & ~0x04);
outp( _gf1_data.reg_select, TIMER_CONTROL );
outp( _gf1_data.data_hi, _gf1_data.timer_ctrl );
_gf1_data.timer1_func();
LEAVE_CRITICAL;
}
if (irq_source & GF1_TIMER2_IRQ)
{
ENTER_CRITICAL;
outp( _gf1_data.reg_select, TIMER_CONTROL );
outp( _gf1_data.data_hi, _gf1_data.timer_ctrl & ~0x08);
outp( _gf1_data.reg_select, TIMER_CONTROL );
outp( _gf1_data.data_hi, _gf1_data.timer_ctrl );
_gf1_data.timer2_func();
LEAVE_CRITICAL;
}
if (irq_source & (WAVETABLE_IRQ | ENVELOPE_IRQ))
{
handle_voice();
}
}
_gf1_data.aux_irq_func(); /* aux interrupt handler (ultramax) */
}
#ifdef METAWARE
static _Far _INTERRPT void
#else
static void interrupt
#endif
gf1_irq_handler(void)
{
int irq_num;
#ifdef METAWARE
GetSegRegs();
#endif
irq_num = _gf1_data.gf1_irq_num;
/* clear PC's interrupt controller(s) */
outp(_gf1_irq[irq_num].ocr,_gf1_irq[irq_num].spec_eoi);
/* gotta send EOI to BOTH controllers */
if (irq_num > 7)
outp(OCR1,EOI);
gf1_handler(); /* Go to handler */
}
#ifdef METAWARE
static _Far _INTERRPT void
#else
static void interrupt
#endif
midi_irq_handler(void)
{
int irq_num;
irq_num = _gf1_data.midi_irq_num;
/* clear PC's interrupt controller(s) */
outp(_gf1_irq[irq_num].ocr,_gf1_irq[irq_num].spec_eoi);
/* gotta send EOI to BOTH controllers */
if (irq_num > 7)
outp(OCR1,EOI);
gf1_handler(); /* Go to handler (same for now ...) */
}
/* This is the function that gets executed if no other handler is defined */
void
default_func(void)
{
}
void
SetIrqHandlers(int gf1_irq,int midi_irq)
{
int temp_irq;
temp_irq = gf1_irq;
if (temp_irq != 0)
{
if (gf1_irq > 7)
gf1_irq += 0x68;
else
gf1_irq += 0x08;
_gf1_data.old_gf1_vec = gf1_getvect (gf1_irq);
gf1_setvect (gf1_irq,gf1_irq_handler);
}
if ((midi_irq != 0) && (midi_irq != temp_irq))
{
if (midi_irq > 7)
midi_irq += 0x68;
else
midi_irq += 0x08;
_gf1_data.old_midi_vec = gf1_getvect (midi_irq);
gf1_setvect (midi_irq,midi_irq_handler);
}
}
#ifdef METAWARE
void
leave_critical()
{
_gf1_data.gf1_sema4--;
if (_gf1_data.gf1_sema4 == 0)
{
if (_gf1_data.irq_pending)
{
_gf1_data.irq_pending = 0;
gf1_handler();
}
}
}
#endif
