void halAudioGenerator_HbrClockDivider(IM_UINT16 baseAddress, IM_UINT16 value)
{
	LOG_TRACE1(value);
	/* 9-bit width */
	access_CoreWriteByte((u8) (value), baseAddress + AG_HBR_CLKDIV0);
	access_CoreWrite(value >> 8, baseAddress + AG_HBR_CLKDIV1, 0, 1);
}

int edid_GetSad(u16 baseAddr, unsigned int n, shortAudioDesc_t * sad)
{
	LOG_TRACE1(n);
	if (n < edid_GetSadCount(baseAddr))
	{
		*sad = edid_mSad[n];
		return TRUE;
	}
	return FALSE;
}

int edid_GetSvd(u16 baseAddr, unsigned int n, shortVideoDesc_t * svd)
{
	LOG_TRACE1(n);
	if (n < edid_GetSvdCount(baseAddr))
	{
		*svd = edid_mSvd[n];
		return TRUE;
	}
	return FALSE;
}

int edid_GetDtd(u16 baseAddr, unsigned int n, dtd_t * dtd)
{
	LOG_TRACE1(n);
	if (n < edid_GetDtdCount(baseAddr))
	{
		*dtd = edid_mDtd[n];
		return TRUE;
	}
	return FALSE;
}

void halVideoPacketizer_PixelRepetitionFactor(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	/* desired factor */
	access_CoreWrite(value, (baseAddr + VP_PR_CD), 0, 4);
	/* enable stuffing */
	access_CoreWrite(1, (baseAddr + VP_STUFF), 0, 1);
	/* enable block */
	access_CoreWrite((value > 1) ? 1 : 0, (baseAddr + VP_CONF), 4, 1);
	/* bypass block */
	access_CoreWrite((value > 1) ? 0 : 1, (baseAddr + VP_CONF), 2, 1);
}

VOID Signal_Post( Signal *pThis )
{
	//SEM_postBinary(pThis->Handle);
#ifdef	ToFindExcpError
	//LOG_TRACE1("Inside signalpost pThis->Handle : 0x%x",pThis->Handle);
if(CSL_chipReadDNUM ()==1)
{
	NumSignal++;
		LOG_TRACE1("signal posting :%d ",NumSignal);
}


#endif

	Semaphore_post(pThis->Handle);
#ifdef	ToFindExcpError
//	LOG_TRACE0(" signal posted");
#endif
}

void halAudioGenerator_UserLeft(IM_UINT16 baseAddress, IM_UINT8 bit, IM_UINT8 channelNo)
{
	LOG_TRACE1(bit);
	switch (channelNo)
	{
		case 0:
			access_CoreWrite(bit, baseAddress + AG_SPDIF_CONF, 2, 1);
			break;
		case 1:
			access_CoreWrite(bit, baseAddress + AG_GPA_USERBIT, 0, 1);
			break;
		case 2:
			access_CoreWrite(bit, baseAddress + AG_GPA_USERBIT, 2, 1);
			break;
		case 3:
			access_CoreWrite(bit, baseAddress + AG_GPA_USERBIT, 4, 1);
			break;
		default:
			LOG_ERROR("wrong channel number");
			break;
	}
}

void halAudioGenerator_IecChannelLeft(IM_UINT16 baseAddress, IM_UINT8 value, IM_UINT8 channelNo)
{
	LOG_TRACE1(value);
	switch (channelNo)
	{
		case 0:
			access_CoreWrite(value, baseAddress + AG_SPDIF_AUDSCHNLS3, 0, 4);
			break;
		case 1:
			access_CoreWrite(value, baseAddress + AG_GPA_CHNUM1, 0, 4);
			break;
		case 2:
			access_CoreWrite(value, baseAddress + AG_GPA_CHNUM2, 0, 4);
			break;
		case 3:
			access_CoreWrite(value, baseAddress + AG_GPA_CHNUM3, 0, 4);
			break;
		default:
			LOG_ERROR("wrong channel number");
			break;
	}	
}

void halVideoPacketizer_OutputSelector(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	if (value == 0)
	{ /* pixel packing */
		access_CoreWrite(0, (baseAddr + VP_CONF), 6, 1);
		/* enable pixel packing */
		access_CoreWrite(1, (baseAddr + VP_CONF), 5, 1);
		access_CoreWrite(0, (baseAddr + VP_CONF), 3, 1);
	}
	else if (value == 1)
	{ /* YCC422 */
		access_CoreWrite(0, (baseAddr + VP_CONF), 6, 1);
		access_CoreWrite(0, (baseAddr + VP_CONF), 5, 1);
		/* enable YCC422 */
		access_CoreWrite(1, (baseAddr + VP_CONF), 3, 1);
	}
	else if (value == 2 || value == 3)
	{ /* bypass */
		/* enable bypass */
		access_CoreWrite(1, (baseAddr + VP_CONF), 6, 1);
		access_CoreWrite(0, (baseAddr + VP_CONF), 5, 1);
		access_CoreWrite(0, (baseAddr + VP_CONF), 3, 1);
	}
	else
	{
		LOG_ERROR2("wrong output option: ", value);
		return;
	}

	/* YCC422 stuffing */
	access_CoreWrite(1, (baseAddr + VP_STUFF), 2, 1);
	/* pixel packing stuffing */
	access_CoreWrite(1, (baseAddr + VP_STUFF), 1, 1);

	/* ouput selector */
	access_CoreWrite(value, (baseAddr + VP_CONF), 0, 2);
}

void halFrameComposerAudio_PacketLayout(u16 baseAddr, u8 bit)
{
	LOG_TRACE1(bit);
	access_CoreWrite(bit, baseAddr + FC_AUDSCONF, 0, 1);
}

void halFrameComposerAudio_IecCgmsA(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWrite(value, baseAddr + FC_AUDSCHNLS0, 4, 2);
}

void halFrameComposerAudio_IecWordLength(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWrite(value, baseAddr + FC_AUDSCHNLS8, 0, 4);
}

void halFrameComposerAudio_PacketSampleFlat(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWrite(value, baseAddr + FC_AUDSCONF, 4, 4);
}

void halFrameComposerAudio_IecClockAccuracy(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWrite(value, baseAddr + FC_AUDSCHNLS7, 4, 2);
}

void halFrameComposerAudio_IecOriginalSamplingFreq(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWrite(value, baseAddr + FC_AUDSCHNLS8, 4, 4);
}

void halFrameComposerGcp_DefaultPhase(u16 baseAddr, u8 uniform)
{
	LOG_TRACE1(uniform);
	access_CoreWrite((uniform ? 1 : 0), (baseAddr + FC_GCP), DEFAULT_PHASE, 1);
}

void halFrameComposerAudio_IecPcmMode(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWrite(value, baseAddr + FC_AUDSCHNLS2, 4, 3);
}

void halFrameComposerAudio_IecCopyright(u16 baseAddr, u8 bit)
{
	LOG_TRACE1(bit);
	access_CoreWrite(bit, baseAddr + FC_AUDSCHNLS0, 0, 1);
}

void halFrameComposerGcp_AvMute(u16 baseAddr, u8 enable)
{
	LOG_TRACE1(enable);
	access_CoreWrite((enable ? 1 : 0), (baseAddr + FC_GCP), SET_AVMUTE, 1);
	access_CoreWrite((enable ? 0 : 1), (baseAddr + FC_GCP), CLEAR_AVMUTE, 1);
}

void halFrameComposerAudio_IecCategoryCode(u16 baseAddr, u8 value)
{
	LOG_TRACE1(value);
	access_CoreWriteByte(value, baseAddr + FC_AUDSCHNLS1);
}