📄 madevdrv.c
字号:
pgMaDevDrvInfo->SbufInfo.dBufSize[i] = 0;
}
/* clear EOS flag */
pgMaDevDrvInfo->dEndofSequence = 0;
/* Clear Pending IRQ */
pgMaDevDrvInfo->dPendingIrq = 0;
/* enable interrupt if needed */
if ( (--pgMaDevDrvInfo->bMaskInterrupt)==0 )
{
WriteStatusFlagReg( MAB_IRQ_ENABLE );
}
return MASMW_SUCCESS;
}
/****************************************************************************
* MaDevDrv_Fifo
*
* Description:
* Update sequence data to sequence FIFO.
* Argument:
* dCtrl loop count
* Return:
* None
*
****************************************************************************/
void MaDevDrv_Fifo( UINT32 dCtrl )
{
UINT8 * pbBuf;
UINT32 dBufSize;
SINT32 dWroteSize;
UINT32 i;
MADEVDRV_DBGMSG(("MaDevDrv_Fifo: dCtrl=%ld\n", dCtrl));
dWroteSize = 0;
dBufSize = 0;
for ( i = 0; i <= dCtrl; i++ )
{
/* transfer packet data from S/W buffer to H/W FIFO */
pbBuf = pgMaDevDrvInfo->bSbufBuffer[pgMaDevDrvInfo->SbufInfo.dReadNum];
dBufSize = pgMaDevDrvInfo->SbufInfo.dBufSize[pgMaDevDrvInfo->SbufInfo.dReadNum];
/* data exist ? */
if ( dBufSize != 0 )
{
/* S/W buffer 仺 H/W FIFO */
MaDevDrv_SendDelayedPacket( pbBuf, dBufSize );
pgMaDevDrvInfo->SbufInfo.dBufSize[pgMaDevDrvInfo->SbufInfo.dReadNum] = 0;
/* update read buffer pointer */
pgMaDevDrvInfo->SbufInfo.dReadNum++;
if ( pgMaDevDrvInfo->SbufInfo.dReadNum == MA_SBUF_NUM )
{
pgMaDevDrvInfo->SbufInfo.dReadNum = 0;
}
}
if( pgMaDevDrvInfo->dEndofSequence==1 ) continue;
/* update S/W buffer */
pbBuf = pgMaDevDrvInfo->bSbufBuffer[pgMaDevDrvInfo->SbufInfo.dWriteNum];
dBufSize = MA_FIFO_SIZE;
if ( dBufSize != 0 )
{
/* update */
dWroteSize = MaSndDrv_UpdateSequence( MASNDDRV_UPDATE_FIFO, pbBuf, dBufSize );
if ( dWroteSize >= 0 )
pgMaDevDrvInfo->SbufInfo.dBufSize[pgMaDevDrvInfo->SbufInfo.dWriteNum] = dWroteSize;
/* update write buffer pointer */
pgMaDevDrvInfo->SbufInfo.dWriteNum++;
if ( pgMaDevDrvInfo->SbufInfo.dWriteNum == MA_SBUF_NUM )
{
pgMaDevDrvInfo->SbufInfo.dWriteNum = 0;
}
}
}
if( dWroteSize==0 && dBufSize==0 && pgMaDevDrvInfo->dEndofSequence==1 )
{
/* Disable FIFO IRQ */
ControlInterrupt( MAI_IRQ_CONTROL_1, DISABLE_IRQ, MAB_IRQCTRL_EFIFO );
}
#ifdef COLORLED_SUPPORT
/* output to CPU GPIO */
switch( abLedPattern[dwLedCount] ){
case 0: //RGB -- 000
Red_Off();
Green2_Off();
Blue_Off();
break;
case 1: //RGB-- 001
Red_Off();
Green2_Off();
Blue_On();
break;
case 2: //RGB -- 010
Red_Off();
Green2_On();
Blue_Off();
break;
case 3: //RGB-- 011
Red_Off();
Green2_On();
Blue_On();
break;
case 4: //RGB -100
Red_On();
Green2_Off();
Blue_Off();
break;
case 5: //RGB -101
Red_On();
Green2_Off();
Blue_On();
break;
case 6://RGB -110
Red_On();
Green2_On();
Blue_Off();
case 7://RGB -111
Red_On();
Green2_On();
Blue_On();
break;
}
dwLedCount++;
if ( dwLedCount >= MADEVDRV_LED_PATTERN_NUM ) {
dwLedCount = 0;
}
#endif
}
/****************************************************************************
* MaDevDrv_GetSeekBuffer
*
* Description:
* Return pointer to buffer and size of buffer for setting control
* values when seek.
* Arguments:
* *pdSize pointer to buffer size
* Return:
* pointer to buffer
*
****************************************************************************/
UINT8 * MaDevDrv_GetSeekBuffer( UINT32 * pdSize )
{
*pdSize = MA_FIFO_SIZE * MA_SBUF_NUM;
return pgMaDevDrvInfo->bSbufBuffer[0];
}
/****************************************************************************
* MaDevDrv_SeekControl
*
* Description:
* Send control values when seek.
* Arguments:
* dSize buffer byte size
* Return:
* 0 success
* < 0 error code
*
****************************************************************************/
SINT32 MaDevDrv_SeekControl( UINT32 dSize )
{
UINT8 * pbBuf; /* pointer to buffer */
SINT32 sdResult; /* sdResult of function */
if( dSize==0 ) return MASMW_SUCCESS;
/* start the H/W sequencer */
MaDevDrv_WriteIntermediateReg( MAI_SEQ_CTRL, 0x01 );
/* write control data to H/W FIFO for seek */
pbBuf = pgMaDevDrvInfo->bSbufBuffer[0];
MaDevDrv_SendDelayedPacket( pbBuf, dSize );
/* waiting for FIFO empty */
sdResult = machdep_WaitDelayedFifoEmpty();
/* stop the H/W sequencer */
MaDevDrv_WriteIntermediateReg( MAI_SEQ_CTRL, 0x00 );
return sdResult;
}
/****************************************************************************
* MaDevDrv_IntHandler
*
* Description:
* Interrupt handler for hardware interrupts.
* Argument:
* None
* Return:
* None
*
****************************************************************************/
void MaDevDrv_IntHandler( void )
{
UINT8 bOldSetting;
UINT8 bIrqFlag1;
UINT8 bIrqFlag2;
UINT32 dIrqFlag;
MADEVDRV_DBGMSG((" MaDevDrv_IntHandler\n"));
/* increment access counter */
pgMaDevDrvInfo->bMaskInterrupt++;
/* set REG_ID #0 */
bOldSetting = WriteStatusFlagReg( MAI_IRQ_FLAG_1 );
/* read IRQ_FLAG_1 */
bIrqFlag1 = machdep_ReadDataReg();
/* set REG_ID #16 */
WriteStatusFlagReg( MAI_IRQ_FLAG_2 );
/* read IRQ_FLAG_2 */
bIrqFlag2 = machdep_ReadDataReg();
dIrqFlag = ((UINT32)bIrqFlag2<<8)|(UINT32)bIrqFlag1;
if ( dIrqFlag != 0 )
{
pgMaDevDrvInfo->bIrqProc = 1;
machdep_GenerateIrqProcTask(dIrqFlag, bOldSetting);
}
--pgMaDevDrvInfo->bMaskInterrupt;
WriteStatusFlagReg( bOldSetting );
}
/****************************************************************************
* MaDevDrv_StreamHandler
*
* Description:
* Control the stream audio.
* Arguments:
* dSeqId sequence number
* dSaId stream audio slot number
* dCtrl 0: setup
* 1: update
* bRamVal SINT RAM register value
* dSeek Seek Position
* Return:
* None
*
****************************************************************************/
SINT32 MaDevDrv_StreamHandler( UINT32 dSeqId, UINT32 dSaId, UINT32 dCtrl,
UINT8 bRamVal, UINT32 dSeek )
{
UINT8 bPacket[16];
UINT32 dFormat[2];
UINT8 * pbWaveData;
UINT32 dWaveSize;
UINT32 dWaveId[2];
UINT32 dSaSlot[2];
SINT32 sdResult;
UINT32 dRegIndex;
UINT32 dNumSaon;
UINT32 i,j;
UINT32 dPp;
UINT8 bCh;
static const UINT32 dRegIndexTbl[2] = {
MAC_EXT_WT_VOICE_ADDRESS + 9*6 + 5,
MAC_EXT_WT_VOICE_ADDRESS + 10*6 + 5
};
MADEVDRV_DBGMSG(("MaDevDrv_StreamHandler: dSaId=%d ctrl=%d ram_val=%d\n", dSaId, dCtrl, bRamVal));
/* error */
if ( dSaId >= MA_MAX_STREAM_AUDIO ) return MASMW_ERROR;
sdResult = MASMW_SUCCESS;
if( dCtrl&0x80 )
{
pgMaDevDrvInfo->bSlave = (UINT8)(bRamVal & 0x1F);
return sdResult;
}
pgMaDevDrvInfo->dSeqId = dSeqId;
dCtrl &= 0x01;
if ( dCtrl == 0 ) /* setup */
{
/* Start or Stop? */
if ( ( bRamVal & 0x40 ) != 0 )
{
/* Start */
dWaveId[0] = (UINT32)( bRamVal & 0x1F );
dSaSlot[0] = dSaId;
dNumSaon = 1;
/* master ? */
if ( bRamVal & 0x20 )
{
dSaSlot[1] = (UINT32)( ( dSaId == 0 ) ? 1 : 0 );
/* read slave wave# */
dWaveId[1] = (UINT32)pgMaDevDrvInfo->bSlave;
dNumSaon++;
pgMaDevDrvInfo->bSlave = 0xff;
}
for ( i = 0; i < dNumSaon; i++ )
{
/* get stream information */
sdResult = MaResMgr_GetStreamAudioInfo( dWaveId[i], &dFormat[dSaSlot[i]], &pbWaveData, &dWaveSize );
/* error */
if ( sdResult != MASMW_SUCCESS )
{
return sdResult;
}
/* data error */
if ( pbWaveData==NULL || dWaveSize==0 || dSeek>=dWaveSize )
{
return MASMW_ERROR;
}
/* save stream information */
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].dPrvPoint = (UINT32)MA_MIN_PG;
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].pbWaveData = pbWaveData;
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].dWaveSize = dWaveSize;
if( dSaSlot[i]==1 && (dFormat[1]&0x80) )
{
return MASMW_ERROR;
}
}
if( dNumSaon==2 && ((dFormat[0]&0x80)||(dFormat[1]&0x80)))
{
return MASMW_ERROR;
}
/* stop stereo stream */
if( pgMaDevDrvInfo->StreamInfo[0].bState != MADEVDRV_STREAM_STATE_IDLE &&
(pgMaDevDrvInfo->StreamInfo[0].dFormat&0x80) )
{
/* disable streamPG#0 Irq */
if( dSeqId==0 )
{
ControlInterrupt( MAI_IRQ_CONTROL_1, DISABLE_IRQ, (UINT8)(0x01<<0) );
}
/* Stream#0 <-> WT#25 */
dRegIndex = dRegIndexTbl[0];
sdResult = MaDevDrv_ReceiveData( dRegIndex );
/* error */
if ( sdResult < MASMW_SUCCESS )
{
return sdResult;
}
bCh = (UINT8)( sdResult & 0x0F );
bPacket[0] = (UINT8)( dRegIndex & 0x7F ); /* address part */
bPacket[1] = (UINT8)( (dRegIndex >> 7) | 0x80 );
bPacket[2] = (UINT8)( 0x30 | bCh | 0x80 ); /* data part, KeyOff */
dRegIndex += 6;
bPacket[3] = (UINT8)( dRegIndex & 0x7F ); /* address part */
bPacket[4] = (UINT8)( (dRegIndex >> 7) | 0x80 );
bPacket[5] = (UINT8)( 0x30 | bCh | 0x80 ); /* data part, KeyOff */
/* write packet */
sdResult = MaDevDrv_SendDirectPacket( bPacket, 6 );
/* error */
if ( sdResult != MASMW_SUCCESS )
{
return sdResult;
}
/* wait 20us */
machdep_Wait( 20000 );
/* clear STEREO bit */
MaDevDrv_WriteIntermediateReg( MAI_STM_CTRL, 0 );
pgMaDevDrvInfo->StreamInfo[0].bState = MADEVDRV_STREAM_STATE_IDLE;
}
/* stop all streams if NEW stream is stereo */
else if( dSaId==0 && (dFormat[0]&0x80) )
{
for ( i = 0; i < 2 ; i++ )
{
/* stop stream if active */
if ( pgMaDevDrvInfo->StreamInfo[i].bState != MADEVDRV_STREAM_STATE_IDLE )
{
/* disable streamPG Irq */
if( dSeqId==0 )
{
ControlInterrupt( MAI_IRQ_CONTROL_1, DISABLE_IRQ, (UINT8)(0x01<<i) );
}
/* Stream#0/#1 <-> WT#25/#26 */
dRegIndex = dRegIndexTbl[i];
sdResult = MaDevDrv_ReceiveData( dRegIndex );
/* error */
if ( sdResult < MASMW_SUCCESS )
{
return sdResult;
}
bCh = (UINT8)( sdResult & 0x0F );
bPacket[0] = (UINT8)( dRegIndex & 0x7F ); /* address part */
bPacket[1] = (UINT8)( (dRegIndex >> 7) | 0x80 );
bPacket[2] = (UINT8)( 0x30 | bCh | 0x80 ); /* data part, KeyOff */
/* write packet */
sdResult = MaDevDrv_SendDirectPacket( bPacket, 3 );
/* error */
if ( sdResult != MASMW_SUCCESS )
{
return sdResult;
}
pgMaDevDrvInfo->StreamInfo[i].bState = MADEVDRV_STREAM_STATE_IDLE;
}
}
}
/* stop overlapping stream */
else {
for ( i = 0; i < dNumSaon; i++ )
{
if ( pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].bState != MADEVDRV_STREAM_STATE_IDLE )
{
/* disable streamPG Irq */
if( dSeqId==0 )
{
ControlInterrupt( MAI_IRQ_CONTROL_1, DISABLE_IRQ, (UINT8)(0x01<<dSaSlot[i]) );
}
/* Stream#0/#1 <-> WT#25/#26 */
dRegIndex = dRegIndexTbl[dSaSlot[i]];
sdResult = MaDevDrv_ReceiveData( dRegIndex );
/* error */
if ( sdResult < MASMW_SUCCESS )
{
return sdResult;
}
bCh = (UINT8)( sdResult & 0x0F );
bPacket[0] = (UINT8)( dRegIndex & 0x7F ); /* address part */
bPacket[1] = (UINT8)( (dRegIndex >> 7) | 0x80 );
bPacket[2] = (UINT8)( 0x30 | bCh | 0x80 ); /* data part, KeyOff */
/* write packet */
sdResult = MaDevDrv_SendDirectPacket( bPacket, 3 );
/* error */
if ( sdResult != MASMW_SUCCESS )
{
return sdResult;
}
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].bState = MADEVDRV_STREAM_STATE_IDLE;
}
}
}
dPp = 0;
for ( i = 0; i < dNumSaon ; i++ )
{
/* update format info */
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].dFormat = dFormat[dSaSlot[i]];
/* seek */
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].pbWaveData += dSeek;
pgMaDevDrvInfo->StreamInfo[dSaSlot[i]].dWaveSize -= dSeek;
/* Stream Setup */
sdResult = StreamSetup( dSaSlot[i] );
/* error */
if ( sdResult != MASMW_SUCCESS )
{
return sdResult;
}
/* make packet for KeyOn */
/* Stream#0/#1 <-> WT#25/#26 */
dRegIndex = dRegIndexTbl[dSaSlot[i]];
/* read channel */
sdResult = MaDevDrv_ReceiveData( dRegIndex );
/* error */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -