waveinpdd.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

/*

  Copyright(c) 1998,1999 SIC/Hitachi,Ltd.

	Module Name:

		waveInpdd.c

	Revision History:

		26th April		1999		Released
		30th June		1999		Modified audio in buffer address
									Added AudioInInterrupt Flag
		26th October	1999		Modified WaveData length thin out
        29-Nov-1999 cea		Changed for SH3 (7709A) DMA control
*/

#include <windows.h>
#include <types.h>
#include <memory.h>
#include <excpt.h>
#include <waveddsi.h>
#include <wavedbg.h>
#include <mmsystem.h>
#include <Excpt.h>
#include "wavepdd.h"
#include "waveInpdd.h"

#include "shx.h"
#include "cc.h"
/****************************************************************************
 * Modification done by Maneesh Gupta
 *
 * Replaced mobytel.h with platform.h
 ****************************************************************************/
#include "platform.h"
/****************************************************************************
 * End of Modification done by Maneesh Gupta
 ****************************************************************************/
#include "drv_glob.h"

extern PWAVEFORMATEX g_pwfx[2];
extern PCM_TYPE g_pcmtype[2];

// audio in globals

// pointer to the physical memory addresses

PVBYTE *pAudioRecAddress;

// Double Buffer for Audio Playback
//
static PVBYTE dma_page[2];
static const ULONG dma_pagePhysicalAddress[2] =
{
	AUDIO_BUFFER_REC_BASE,
	(AUDIO_BUFFER_REC_BASE + AUDIO_DMA_PAGE_REC_SIZE )
};

static ULONG v_recPage;

static  PBYTE   pDMAC_RegBase;		// page-base for register offsets

/****************************************************************************
 * Modification done by Naresh Gupta
 *   Instead of separate Area_1 and Area_7, i'm using INTC_REGBASE
 *   for SH4
 ****************************************************************************/
#if ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
static  PBYTE   pINTC_RegBase;		// page-base for register offsets
#else // ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
static  PBYTE   pINTC_Area_1_RegBase;		// page-base for register offsets
static  PBYTE   pINTC_Area_7_RegBase;		// page-base for register offsets
#endif // ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
/****************************************************************************
 * End of Modification done by Naresh Gupta
 ****************************************************************************/

static  PBYTE   pCC_CODEC_RegBase;	// Companion chip  SERIAL CODEC register offsets
static  PBYTE   pCC_SYS_RegBase;	// Companion chip  SMSCR
static  PBYTE   pAudioBufferBase;	// Audio buffer

volatile PDRIVER_GLOBALS	pDriverGlobals;		// Drivers Globals

// DMA Operation Registor

PVUSHORT pDMAOR;						// virtual address of DMA Operation Register

// DMA Channel 1 Registers (audio record channel)

PVULONG pSAR1, pDAR1, pDMATCR1, pCHCR1; //virtual addrs of DMA1 control regs
PVULONG pCHCR0,pCHCR2,pCHCR3;			//virtual addrs of DMA1 control regs

// Companion Chip Registers

PVUSHORT pCODEC_CR;						// virtual addrs of C.C. registers
PVULONG  pCODEC_ACR, pCODEC_CAR, pCODEC_CDR;
PVULONG  pCODEC_ATAGR;
PVULONG  pCODEC_PCML;
PVULONG  pSMSCR;
PVUSHORT pCODEC_FSR;

// statistics

DWORD g_dwOverruns;		// # of overrun errors
DWORD g_dwFrames;		// # of 48 word frames filled

LPWAVEFORMATEX lpFormat2 = 0;

#define DUMPEXCEPTION() \
	DEBUGMSG(ZONE_ERROR,(TEXT("Exception %d @ %s:%d\r\n"), GetExceptionCode(), __FILE__, __LINE__ ))

/*****************************************************************************
*   FUNCTION :  	private_AudioInGetInterruptType
*   DESCRIPTION :   decodes type of audio interrupt
*   INPUTS :		None
*   OUTPUTS :     	interrupt type
*   DESIGN NOTES :  
*   CAUTIONS :		
*****************************************************************************/
AUDIO_STATE 
private_AudioInGetInterruptType(
   VOID
   )
{
	if ( pDriverGlobals->aud.inInt == (USHORT)NULL )
	{
		return AUDIO_STATE_IGNORE;
	}
	else
	{
		pDriverGlobals->aud.inInt--;
		return AUDIO_STATE_IN_RECORDING;
	}
}

/*****************************************************************************
*   FUNCTION :  	private_AudioInInitialize
*   DESCRIPTION :   sets up register access for audio-in
*					sets delay time for audio-in start-up
*   INPUTS :		TRUE iff successful
*   OUTPUTS :     	None
*   DESIGN NOTES :  
*   CAUTIONS :		
*****************************************************************************/
BOOL
private_AudioInInitialize(
   VOID
   )
{
	ULONG SizeOfBuffer;
	char here[] = "PDD_AudioInInitialize";

	FUNC_WPDD("+PDD_AudioInInitialize");
	RETAILMSG( 1, (TEXT("WaveInpdd.c private_AudioInInitialize: START\r\n")));

	// Set pointers to virtual addresses of playback registers
	pDMAC_RegBase =(PBYTE)GetVirtualAddressOfUncachedMemory(
		(PBYTE)DMAC_REGBASE,
		(DWORD)DMAC_REGSIZE,
		"PDD_AudioInitialize, pDMAC_RegBase");
	if (pDMAC_RegBase == NULL) return FALSE;

	pDMAOR   = (PVUSHORT)(pDMAC_RegBase + DMAC_DMAOR_OFFSET );
	pSAR1    = (PVULONG)(pDMAC_RegBase + DMAC_SAR1_OFFSET   );
	pDAR1    = (PVULONG)(pDMAC_RegBase + DMAC_DAR1_OFFSET   );
	pDMATCR1 = (PVULONG)(pDMAC_RegBase + DMAC_DMATCR1_OFFSET);
	pCHCR1   = (PVULONG)(pDMAC_RegBase + DMAC_CHCR1_OFFSET  );

	pCHCR0   = (PVULONG)(pDMAC_RegBase + DMAC_CHCR0_OFFSET  );
	pCHCR2   = (PVULONG)(pDMAC_RegBase + DMAC_CHCR2_OFFSET  );
	pCHCR3   = (PVULONG)(pDMAC_RegBase + DMAC_CHCR3_OFFSET  );

/****************************************************************************
 * Modification done by Naresh Gupta
 *   Instead of separate Area_1 and Area_7, i'm using INTC_REGBASE
 *   for SH4
 ****************************************************************************/
#if ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
	pINTC_RegBase =(PBYTE)GetVirtualAddressOfUncachedMemory(
		(PBYTE)INTC_REGBASE,
		(DWORD)INTC_REGSIZE,
		"PDD_AudioInitialize, pINTC_RegBase");

	if (pINTC_RegBase == NULL) return FALSE;


#else // ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))

	pINTC_Area_1_RegBase =(PBYTE)GetVirtualAddressOfUncachedMemory(
		(PBYTE)INTC_AREA_1_REGBASE,
		(DWORD)INTC_AREA_1_REGSIZE,
		"PDD_AudioInitialize, pINTC_Area_1_RegBase");

	if (pINTC_Area_1_RegBase == NULL) return FALSE;

	pINTC_Area_7_RegBase =(PBYTE)GetVirtualAddressOfUncachedMemory(
		(PBYTE)INTC_AREA_7_REGBASE,
		(DWORD)INTC_AREA_7_REGSIZE,
		"PDD_AudioInitialize, pINTC_Area_7_RegBase");

	if (pINTC_Area_7_RegBase == NULL) return FALSE;

#endif // ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
/****************************************************************************
 * End of Modification done by Naresh Gupta
 ****************************************************************************/

	pCC_CODEC_RegBase =(PBYTE)GetVirtualAddressOfUncachedMemory(
		(PBYTE)CC_CODEC_REGBASE,
		(DWORD)CC_CODEC_REGSIZE,
		"PDD_AudioInitialize, pCC_CODEC_RegBase");

	if (pCC_CODEC_RegBase == NULL) return FALSE;

	pCODEC_CR    = (PVUSHORT) (pCC_CODEC_RegBase + CC_CODEC_CR_OFFSET     );
	pCODEC_CAR   = (PVULONG ) (pCC_CODEC_RegBase + CC_CODEC_CAR_OFFSET    );
	pCODEC_CDR   = (PVULONG ) (pCC_CODEC_RegBase + CC_CODEC_CDR_OFFSET    );
	pCODEC_ACR   = (PVULONG ) (pCC_CODEC_RegBase + CC_CODEC_ACR_OFFSET    );
	pCODEC_ATAGR = (PVULONG ) (pCC_CODEC_RegBase + CC_CODEC_ATAGR_OFFSET  );
	pCODEC_PCML  = (PVULONG ) (pCC_CODEC_RegBase + CC_CODEC_PCML_OFFSET   );
	pCODEC_FSR   = (PVUSHORT) (pCC_CODEC_RegBase + CC_CODEC_FSR_OFFSET    );

	pCC_SYS_RegBase =(PBYTE)GetVirtualAddressOfUncachedMemory(
		(PBYTE)CC_SYS_SMSCR,
		(DWORD)CC_SYS_REGSIZE,
		"PDD_AudioInitialize, pCC_SYS_RegBase");

	if (pCC_SYS_RegBase == NULL) return FALSE;
	pSMSCR       = (PVULONG ) (pCC_SYS_RegBase );

	// Set pointers to virtual addresses of audio buffers

	SizeOfBuffer = (AUDIO_DMA_PAGE_REC_SIZE * 2);

	pAudioBufferBase = VirtualAlloc(
		NULL,
		SizeOfBuffer,
		MEM_RESERVE,
		PAGE_NOACCESS);

	if (pAudioBufferBase == NULL) return FALSE;

	if (!VirtualCopy((PVOID)pAudioBufferBase,
		(PVOID)dma_pagePhysicalAddress[0],
		(DWORD)SizeOfBuffer,
		PAGE_READWRITE | PAGE_NOCACHE))
	{
		VirtualFree((PVOID)pAudioBufferBase, 0, MEM_RELEASE);
		return FALSE;
	}

	if (pAudioBufferBase == NULL)
	{
		RETAILMSG( 1, (TEXT("pAudioBufferBase ---error---\r\n")));
		return FALSE;
	}

	// Setup a Access to AudioPlayingAddress and AudioInInterrupt

	pDriverGlobals = VirtualAlloc(
		NULL,
		DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,
		MEM_RESERVE,
		PAGE_NOACCESS);

	if (pDriverGlobals == NULL) return FALSE;

	if (!VirtualCopy((PVOID)pDriverGlobals,
		(PVOID)DRIVER_GLOBALS_PHYSICAL_MEMORY_START,
		(DWORD)DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,
		PAGE_READWRITE | PAGE_NOCACHE))
	{
		VirtualFree((PVOID)pDriverGlobals, 0, MEM_RELEASE);
		return FALSE;
	}

// Initialize AudioInInterrupt Flag
//	pAudioRecAddress = pDriverGlobals->aud.play;
	pDriverGlobals->aud.rec_address = (ULONG)NULL;
	pDriverGlobals->aud.inInt = (USHORT)NULL;

	RETAILMSG(1, (TEXT("PDD_AudioInInitialize: Successful Init\r\n")));
	RETAILMSG(1, (TEXT("WaveInpdd.c private_AudioInInitialize: END\r\n")));
	FUNC("-PDD_AudioInInitialize");
	return TRUE;
}

/*****************************************************************************
*   FUNCTION :  	private_AudioInPowerHandler
*   DESCRIPTION :   performs power on/off, this also happens at open/close!
*   INPUTS :		bPowerDown 1=power off, 0=power on
*					bInKernel 1=in kernel (don't call OS), 0=in IST
*   OUTPUTS :     	None
*   DESIGN NOTES :  
*   CAUTIONS :		Don't call OS when in kernel mode
*****************************************************************************/
VOID
private_AudioInPowerHandler(
	BOOL bPowerDown,
	BOOL bInKernel
	)
{
}

VOID
AudioOutPowerHandler(
	BOOL bPowerDown
	)
{
	return; // Power Handling Not Yet Implemented
}

/*****************************************************************************
*   FUNCTION :  	private_AudioInDeinitialize
*   DESCRIPTION :   Free memory required by driver
*   INPUTS :		None
*   OUTPUTS :     	None
*   DESIGN NOTES :  
*   CAUTIONS :		
*****************************************************************************/
VOID 
private_AudioInDeinitialize(
	VOID
	)
{
	FUNC("+PDD_AudioInDeinitialize");
	FUNC("-PDD_AudioInDisable");
}

/*****************************************************************************
*   FUNCTION :  	private_AudioInStart
*   DESCRIPTION :   start recording a sound
*   INPUTS :		pwh: wave header to insert sound into
*   OUTPUTS :     	None
*   DESIGN NOTES :  
*   CAUTIONS :		
*****************************************************************************/
VOID
private_WaveInStart(
	PWAVEHDR pwh
	)
{
	FUNC_WPDD("+PDD_WaveInStart");
	v_recPage  = 0;

	//Stop DMA
	
	READ_REGISTER_ULONG((PULONG)pCHCR1  );

/****************************************************************************
 * Modification done by Naresh Gupta
 *   Change bit names for SH4. Similar changes have been made at other places
 *   also where SH3 was used.
 ****************************************************************************/
#if ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
	WRITE_REGISTER_ULONG((PULONG)pCHCR1,
		DMAC_CHCR_RL_ACTIVE_HIGH |
		DMAC_CHCR_DM_INCREMENTED |
		DMAC_CHCR_TS_32 |
		DMAC_CHCR_IE_NOT_GENARATED |
		DMAC_CHCR_DE_DISABLED);
#else // ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))
	WRITE_REGISTER_ULONG((PULONG)pCHCR1, 
		SH3_DMAC_CHCR_RL_ACTIVE_HIGH |
		SH3_DMAC_CHCR_DM_INCREMENTED |
		SH3_DMAC_CHCR_TS_32 |
		SH3_DMAC_CHCR_IE_NOT_GENARATED |
		SH3_DMAC_CHCR_DE_DISABLED );
#endif // ((SH_PLATFORM == PLATFORM_ASPEN) || (SH_PLATFORM == PLATFORM_BIGSUR))