ml2011drv.c

OkiML2011Driver

*	VOLUME FUNCTION
*	--------------------------
*	 -L2011drv_SetMainVolume
*	 -L2011drv_SetSpVolume
******************************************************************************/
/*******************************************************************************
*	L2011drv_SetMainVolume()
*****************************************************************************/
signed short L2011drv_SetMainVolume(DRV_CTRL *drvCtrl, unsigned char value)
{
	if(value <= 0x0F){
		value |= (value << 4);
		L2011drv_WriteReg(drvCtrl, IDX_AUDIOVOL, value);
	}else{	// param error
		return(L2011DRV_ERR_PARAM);
	}
	return(L2011DRV_OK);
}

/*******************************************************************************
*	L2011drv_SetSpVolume()
*******************************************************************************/
signed short L2011drv_SetSpVolume(DRV_CTRL *drvCtrl, unsigned char value)
{
	if(value <= 0x0F){
		L2011drv_WriteReg(drvCtrl, IDX_SPVOL, value);
	}else{	// param error
		return(L2011DRV_ERR_PARAM);
	}
	return(L2011DRV_OK);
}

/*_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/
/	STATUS CHECK
/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_*/
/******************************************************************************
*	STATUS CHECK
*	--------------------------------
*	PUBLIC
*	 -L2011drv_GetProductID()
*	 -L2011drv_GetDacStatus
******************************************************************************/
/*******************************************************************************
*	L2011drv_GetProductID()
*******************************************************************************/
unsigned char L2011drv_GetProductID(DRV_CTRL *drvCtrl)
{
	return(L2011drv_ReadReg(drvCtrl, IDX_PRODUCTID));	/*Get Product ID*/
}
/*******************************************************************************
*	L2011drv_GetDacStatus()
*******************************************************************************/
unsigned char L2011drv_GetDacStatus(DRV_CTRL *drvCtrl)
{
	return(drvCtrl->DacStatus);
}


/*_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/
/	MP3 CONTROL
/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_*/
/***************************************************************
*	MP3 Control Function
*		- L2011drv_WriteMP3Fifo()
*		- L2011drv_SetMP3FifoTh()
*		- L2011drv_ClearMP3Fifo()
*		- L2011drv_GetMP3FifoStatus()
*		- L2011drv_SetMP3ReqMethod()
*		- L2011drv_GetMP3FifoDataSize()
*		- L2011drv_SetMP3DualChSel()
*		- L2011drv_MP3DecStart()
*		- L2011drv_MP3Start()
*		- L2011drv_MP3Pause()
*		- L2011drv_MP3Stop()
*		- L2011drv_GetMP3ErrorStatus()
*		- L2011drv_ClearMP3ErrorStatus()
*		- L2011drv_GetMP3Status()
*		- L2011drv_ClearMP3Status()
*		- L2011drv_GetMp3Info()
***************************************************************/
/***************************************************************
*	L2011drv_WriteMP3Fifo()
****************************************************************/
unsigned short L2011drv_WriteMP3Fifo(DRV_CTRL *drvCtrl, unsigned char *buff, unsigned short size)
{
	if(buff == NULL){
		return(0);
	}
	if((size != 0) && (size <= L2011DRV_MP3FIFO_SIZE)){
		L2011drv_WriteFifo(drvCtrl, IDX_MP3FIFO, buff, size);
	}else{
		return(0);
	}
	return(size);
}

/***************************************************************
*	L2011drv_SetMP3FifoTh()
****************************************************************/
signed short L2011drv_SetMP3FifoTh(DRV_CTRL *drvCtrl, unsigned short th)
{
	if(th >= L2011DRV_MP3FIFO_SIZE){
		return(L2011DRV_ERR_PARAM);
	}
	L2011drv_WriteReg(drvCtrl, IDX_MP3FIFOT0, (unsigned char)(th & 0x00FF));
	L2011drv_WriteReg(drvCtrl, IDX_MP3FIFOT1, (unsigned char)((th >> 8) & 0x0007));
	return(L2011DRV_OK);
}

/***************************************************************
*	L284Xdrv_ClearMP3Fifo()
****************************************************************/
void L2011drv_ClearMP3Fifo(DRV_CTRL *drvCtrl)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3FIFOCLR, DRV_SET);
}

/***************************************************************
*	L2011drv_GetMP3FifoStatus()
****************************************************************/
unsigned char L2011drv_GetMP3FifoStatus(DRV_CTRL *drvCtrl)
{
	unsigned char tmp = 0;

	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3FIFOST);
	tmp = tmp & 0x07;
	return(tmp);
}

/***************************************************************
*	L2011drv_SetMP3ReqMethod()
****************************************************************/
void L2011drv_SetMP3ReqMethod(DRV_CTRL *drvCtrl, unsigned char mode)
{
	if(mode == L2011DRV_MP3FIFOREQ_THRE){
		L2011drv_WriteReg(drvCtrl, IDX_MP3DRQSEL, L2011DRV_MP3FIFOREQ_THRE);
	}else{
		L2011drv_WriteReg(drvCtrl, IDX_MP3DRQSEL, L2011DRV_MP3FIFOREQ_DREQ);
	}
}

/***************************************************************
*	L2011drv_GetMP3FifoDataSize()
****************************************************************/
unsigned short L2011drv_GetMP3FifoDataSize(DRV_CTRL *drvCtrl)
{
	unsigned short size = 0;

	size = (unsigned short)(L2011drv_ReadReg(drvCtrl, IDX_MP3FIFON1));
	if(size){
		size<<=4;
	}else{
		size = (unsigned short)(L2011drv_ReadReg(drvCtrl, IDX_MP3FIFON0));
	}
	return(size);
}

/***************************************************************
*	L2011drv_SetMP3DualChSel()
****************************************************************/
void L2011drv_SetMP3DualChSel(DRV_CTRL *drvCtrl, unsigned char mode)
{
	if(mode >= 0x03){
		mode = 0x00;
	}
	L2011drv_WriteReg(drvCtrl, IDX_MP3CHSEL, mode);
}


/***************************************************************
*	MP3 Control Function (Play Control)
*		- L2011drv_MP3DecStart()
*		- L2011drv_MP3Start()
*		- L2011drv_MP3Pause()
*		- L2011drv_MP3Stop()
***************************************************************/
/***************************************************************
*	L2011drv_MP3DecStart()
****************************************************************/
void L2011drv_MP3DecStart(DRV_CTRL *drvCtrl)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3CNT, DRV_MP3_DEC_START);
}

/***************************************************************
*	L2011drv_MP3Start()
****************************************************************/
void L2011drv_MP3Start(DRV_CTRL *drvCtrl)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3CNT, DRV_MP3_PLAY);
}

/***************************************************************
*	L2011drv_MP3Pause()
****************************************************************/
void L2011drv_MP3Pause(DRV_CTRL *drvCtrl)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3CNT, DRV_MP3_PAUSE);
}
/***************************************************************
*	L2011drv_MP3Stop()
****************************************************************/
void L2011drv_MP3Stop(DRV_CTRL *drvCtrl)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3CNT, DRV_MP3_STOP);
}


/***************************************************************
*	L2011drv_GetMP3ErrorStatus()
****************************************************************/
unsigned char L2011drv_GetMP3ErrorStatus(DRV_CTRL *drvCtrl)
{
	unsigned char tmp = 0;
	
	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3ERR);
	tmp = tmp & 0x07;
	return(tmp);
}

/***************************************************************
*	L2011drv_ClearMP3ErrorStatus()
****************************************************************/
void L2011drv_ClearMP3ErrorStatus(DRV_CTRL *drvCtrl, unsigned char err)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3ERR, (unsigned char)(err & 0x07));
}
/***************************************************************
*	L2011drv_GetMP3WarnStatus()
****************************************************************/
unsigned char L2011drv_GetMP3WarnStatus(DRV_CTRL *drvCtrl)
{
	unsigned char tmp = 0;
	
	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3WARN);
	tmp = tmp & 0x07;
	return(tmp);
}

/***************************************************************
*	L2011drv_ClearMP3WarnStatus()
****************************************************************/
void L2011drv_ClearMP3WarnStatus(DRV_CTRL *drvCtrl, unsigned char warn)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3WARN, (unsigned char)(warn & 0x07));
}

/***************************************************************
*	L2011drv_GetMP3Status()
****************************************************************/
unsigned char L2011drv_GetMP3Status(DRV_CTRL *drvCtrl)
{
	unsigned char tmp = 0;

	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3STAT);
	tmp = tmp & 0x03;
	return(tmp);
}

/***************************************************************
*	L2011drv_ClearMP3Status()
****************************************************************/
void L2011drv_ClearMP3Status(DRV_CTRL *drvCtrl, unsigned char stat)
{
	L2011drv_WriteReg(drvCtrl, IDX_MP3STAT, (unsigned char)(stat & 0x03));
}

/***************************************************************
*	L2011drv_GetMp3Info()
****************************************************************/
void L2011drv_GetMp3Info(DRV_CTRL *drvCtrl, MP3_INFO *mp3Info)
{
	unsigned char tmp; 

	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3FMT0);
	mp3Info->Layer = tmp & 0x03;
#ifdef MP3INFO_FULL
	mp3Info->Crc = (tmp>>2) & 0x01;
	mp3Info->Pad = (tmp>>3) & 0x01;
#endif

	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3FMT1);
	mp3Info->Sam = (unsigned short)((tmp>>4) & 0x0F);
	tmp &= 0x0F;
	if(mp3Info->Sam > 0x05){	//MPEG1
		if(tmp == 0){
			mp3Info->Bitrate = 0;
		}else if(tmp <= 5){
			mp3Info->Bitrate = (unsigned short)(8 * tmp + 24);
		}else if(tmp <= 9){
			mp3Info->Bitrate = (unsigned short)(16 * tmp - 16);	//64 + (16 * (tmp - 5));
		}else if(tmp <= 13){
			mp3Info->Bitrate = (unsigned short)(32 * tmp - 160);	//128 + (32 * (tmp - 9));
		}else if(tmp == 14){
			mp3Info->Bitrate = 320;
		}else{
			mp3Info->Bitrate = 0;
		}
	}else{	//MPEG2/2.5
		if(tmp <= 8){
			mp3Info->Bitrate = (unsigned short)(8 * tmp);
		}else if(tmp <= 0x0E){
			mp3Info->Bitrate = (unsigned short)(16 * tmp - 64);		//64 + (16 * (tmp - 8));
		}else{
			mp3Info->Bitrate = 0;
		}
	}

	if(mp3Info->Sam > 0x05){
		mp3Info->MpegVer = 0x03;	//MPEG_VER_1
	}else if(mp3Info->Sam > 0x02){
		mp3Info->MpegVer = 0x02;	//MPEG_VER_2
	}else{
		mp3Info->MpegVer = 0x00;	//MPEG_VER_2.5
	}

	mp3Info->Sam = sampleRateForML2841[mp3Info->Sam];

	tmp = L2011drv_ReadReg(drvCtrl, IDX_MP3FMT2);
	mp3Info->Mode = tmp & 0x03;
#ifdef MP3INFO_FULL
	mp3Info->Exm = (tmp>>2) & 0x03;
	mp3Info->Cprt = (tmp>>4) & 0x01;
	mp3Info->Orignal = (tmp>>5) & 0x01;
	mp3Info->Ep = (tmp>>6) & 0x03;
#endif
	return;
}


/***************************************************************
*	IRQ Control Function
*		- L2011drv_GetMp3IrqStat()
*		- L2011drv_ClearMp3IrqStat()
*		- L2011drv_Mp3IrqEnable()
***************************************************************/
/***************************************************************
*	L2011drv_GetMp3IrqStat()
****************************************************************/
unsigned char L2011drv_GetMp3IrqStat(DRV_CTRL *drvCtrl)
{
	unsigned char tmp = 0;

	tmp = L2011drv_ReadReg(drvCtrl, IDX_IRQSTA);
	tmp = tmp & 0x7F;
	return(tmp);
}

/***************************************************************
*	L2011drv_ClearMp3IrqStat()
****************************************************************/
void L2011drv_ClearMp3IrqStat(DRV_CTRL *drvCtrl, unsigned char stat)
{
	L2011drv_WriteReg(drvCtrl, IDX_IRQSTA, (unsigned char)(stat));
	return;
}

/***************************************************************
*	L2011drv_Mp3IrqEnable()
****************************************************************/
void L2011drv_Mp3IrqEnable(DRV_CTRL *drvCtrl, unsigned char enable)
{
	enable = (enable & 0x7F) | (unsigned char)(DEFAULT_ISS_BIT & 0x80);

	L2011drv_WriteReg(drvCtrl, IDX_IRQENA, enable);
	return;
}