/***************************************************************************
*	NAME:  SAMPLE.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"
#include "gf1hware.h"
#include "gf1os.h"
#include "ultraerr.h"
#include "dma.h"	/* Hardware defs for PC's dma controllers */

extern DMA_ENTRY _gf1_dma[]; /* Structure that holds data on PC's dma chan */
extern ULTRA_DATA _gf1_data;

int
UltraRecordDmaBusy(void)
{
return(_gf1_dma[_gf1_data.adc_dma_chan-1].flags & DMA_PENDING);
}

void
UltraWaitRecordDma(void)
{
	_gf1_data.flags &= ~ADC_DMA_NOWAIT;

	ENTER_CRITICAL_ON;

	while (_gf1_data.flags & ADC_DMA_BUSY)	/* wait for irq to clear this */
		{
		}

	LEAVE_CRITICAL_ON;
}

void
UltraSetRecordFrequency(unsigned long rate)
{
unsigned char adsr;

		/* First calculate as if its for a record */
		/* Use the formula:
			rate = CLOCK_RATE / (16*(ADRS+2))
		*/
		adsr = ((CLOCK_RATE>>4)/rate)-2;

ENTER_CRITICAL;

		outp(_gf1_data.reg_select,SET_SAMPLE_RATE);
		outp(_gf1_data.data_hi,(unsigned char)adsr);
LEAVE_CRITICAL;

}

int
UltraPrimeRecord(void far *pc_ptr,unsigned int size,int repeat)
{
int mode;
int val;

if (repeat)
	mode = INDEF_READ;
else
	mode = READ_DMA;

/* Make sure the channel is not busy (recording or playback ... )*/
val = PrimeDma(pc_ptr,mode,size,_gf1_data.adc_dma_chan);
return(val);
}

int
UltraGoRecord(unsigned char control)
{
DMA_ENTRY *tdma;

tdma  = &_gf1_dma[_gf1_data.adc_dma_chan-1];		/* point to this dma data */

/* Set flag that irq handler clears when the xfer is complete */
_gf1_data.flags |= ADC_DMA_BUSY;

/* Now tell GF1 to start xfer ... */
tdma->cur_control = control;

UltraStartRecordDma(control);

return(ULTRA_OK);
}

int
UltraRecordData(void far *pc_ptr,unsigned char control,unsigned int size,int wait,int repeat)
{
int ret;


ret=UltraPrimeRecord(pc_ptr,size,repeat);
if (ret != ULTRA_OK)
	return(ret);

UltraGoRecord(control);

/* if required, wait till dma is done ... */
if (wait)
	UltraWaitRecordDma();
else
	_gf1_data.flags |= ADC_DMA_NOWAIT;

return(ULTRA_OK);
}


#ifdef NEVER
// This code will hang if there is a memory manager that virtualizes
// the dma controller. It takes too much time and we will never read
// the same count twice ....
// Use the other GetRecordDmaPos routine ....

unsigned int
GetRecordDmaPos(int chan_num)
{
DMA_ENTRY *tdma;
unsigned int val1,val2;
unsigned int low1,low2;
unsigned int high1,high2;

	tdma  = &_gf1_dma[chan_num-1]; /* point to this dma data */

	ENTER_CRITICAL;

	while (TRUE)
		{
		outp(tdma->clear_ff,0);						/* clear f/f */
		low1  = (unsigned int)inp( tdma->count );
		high1 = (unsigned int)inp( tdma->count );

		outp(tdma->clear_ff,0);						/* clear f/f */
		low2  = (unsigned int)inp( tdma->count );
		high2 = (unsigned int)inp( tdma->count );

		val1 = (high1<<8) + low1;
		val2 = (high2<<8) + low2;

		if( val1 < val2 )
			val1 = val2 - val1;
		else
			val1 = val1 - val2;
		if( val1 < 10 )
			break;
		}

	LEAVE_CRITICAL;

	return(val2);
}

#endif
unsigned int
GetRecordDmaPos(int chan_num)
{
DMA_ENTRY *tdma;
unsigned int val1,val2;
unsigned int low1,low2;
unsigned int high1,high2;
static unsigned int threshold[MAX_DMA+1] = {30,30,30,30,30,30,30,30};
int i=5;

	tdma  = &_gf1_dma[chan_num-1]; /* point to this dma data */

	ENTER_CRITICAL;

	if (tdma->flags & CALIB_COUNT)
		{

// This code is necessary to accomodate a virtualized DMA controller.
// If something (like emm386) virtualizes the DMA controller, we have
// to adjust our threshold point to accomodate the rollover problem
// in the DMA controller. The problem is when you read the low byte
// and the high byte rolls over before we get a chance to read it.
// A virtualized DMA controller aggravates the problem since it will
// take longer between reads ...

		tdma->flags &= ~CALIB_COUNT;
		while(i-- > 0)	/* try up to 5 times, then use default */
			{
			outp(tdma->clear_ff,0);						/* clear f/f */
			low1  = (unsigned int)inp( tdma->count );
			high1 = (unsigned int)inp( tdma->count );
			low2  = (unsigned int)inp( tdma->count );
			high2 = (unsigned int)inp( tdma->count );
			if (high1 == high2)
				{
				threshold[chan_num] = (low1 - low2)/2 + 2;
				break;
				}
			}
		}

	val2 = 1;	/* first time thru condition ... */
	
	while (TRUE)
		{
		outp(tdma->clear_ff,0);						/* clear f/f */
		low1  = (unsigned int)inp( tdma->count );
		high1 = (unsigned int)inp( tdma->count );

		val1 = (high1<<8) + low1;

		/* If count is not about to roll over, use this count */
		/* or if count equals 0xffff (dma complete) use this count */
		if ((low1 > threshold[chan_num] && low1 != 0xff) || (val1 == 0xffff))
			{
			val2 = val1;
			break;
			}
		if (val2 == val1)
			break;
		val2 = val1;
		}

	LEAVE_CRITICAL;

	return(val2+1);
}

unsigned int
UltraReadRecordPosition(void)
{
DMA_ENTRY *tdma;
unsigned int actual_dma;
unsigned int this_size;
unsigned int total_size;

	tdma  = &_gf1_dma[_gf1_data.adc_dma_chan-1]; /* point to this dma data */

	actual_dma = GetRecordDmaPos(_gf1_data.adc_dma_chan);

	/* Since it counts backwards, subtract this from size of transfer */
	this_size = tdma->cur_size - actual_dma;

	/* Now add in the amount sent (in case it crosses page) */
	total_size = tdma->amnt_sent + this_size;

	if ( _gf1_data.adc_dma_chan >= 4)
		total_size <<= 1;

return(total_size);
}