1421 lines
34 KiB
C++
1421 lines
34 KiB
C++
//***************************************************************************
|
||
//
|
||
// FileName:
|
||
// $Workfile: mixhal.cpp $
|
||
//
|
||
// Author:
|
||
// TOSHIBA [PCS](PSY) Seiichi Nakamura
|
||
// Copyright (c) 1997 TOSHIBA CORPORATION
|
||
//
|
||
// Description:
|
||
//
|
||
//***************************************************************************
|
||
// $Header: /DVD Drivers/ZiVA.WDM/mixhal.cpp 65 99/03/02 11:03a Yagi $
|
||
// $Modtime: 99/03/02 10:26a $
|
||
// $Nokeywords:$
|
||
//***************************************************************************
|
||
// Date | Author | Description
|
||
// -----------+--------------+--------------------------------------------
|
||
// 1998.03.27 | Hideki Yagi | Add SetDataDirection method.
|
||
//
|
||
|
||
//***************************************************************************
|
||
//
|
||
//***************************************************************************
|
||
|
||
#include "includes.h"
|
||
#include "timeout.h"
|
||
#include "ioif.h"
|
||
#include "zivachip.h"
|
||
#include "adv.h"
|
||
#include "mixhal.h"
|
||
// by oka
|
||
#include "userdata.h"
|
||
#include "zivabrd.h"
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
// CMixHALStream Constructor
|
||
//---------------------------------------------------------------------------
|
||
|
||
CMixHALStream::CMixHALStream( void ): m_pZiVA(NULL), m_pKernelObj( NULL ), m_pioif(NULL), m_pZiVABoard( NULL )
|
||
{
|
||
pQueuedBuff[0] = NULL;
|
||
pQueuedBuff[1] = NULL;
|
||
fCanSendData = FALSE;
|
||
fCanDMA = FALSE;
|
||
m_StreamState = StreamStop;
|
||
};
|
||
|
||
//---------------------------------------------------------------------------
|
||
// CMixHALStream::Init
|
||
//---------------------------------------------------------------------------
|
||
|
||
void CMixHALStream::Init( CZiVA *pZiVA, IKernelService *pKernelObj, CIOIF *pioif , CMPEGBoardHAL *pZiVABoard)
|
||
{
|
||
pQueuedBuff[0] = NULL;
|
||
pQueuedBuff[1] = NULL;
|
||
m_StreamState = StreamStop;
|
||
|
||
m_pZiVA = pZiVA;
|
||
m_pKernelObj = pKernelObj;
|
||
m_pioif = pioif;
|
||
m_pZiVABoard = pZiVABoard;
|
||
fCanSendData = FALSE;
|
||
fCanDMA = FALSE;
|
||
};
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
// CMixHALStream Defifo
|
||
//---------------------------------------------------------------------------
|
||
HALRESULT CMixHALStream::DeFifo( void )
|
||
{
|
||
// if( m_StreamState == StreamPause )
|
||
// return HAL_SUCCESS;
|
||
|
||
// 1998/5/21 seichan
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD>ݏ<EFBFBD><DD8F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[<5B>`<60><><EFBFBD>ƒʏ<C692><CA8F>̃<EFBFBD><CC83>[<5B>`<60><><EFBFBD><EFBFBD><EFBFBD>瓯<EFBFBD><E793AF><EFBFBD>ɌĂ<C482><CE82>邱<EFBFBD>Ƃ<EFBFBD>
|
||
// <20>֎~<7E><><EFBFBD>邽<EFBFBD>߂ɁA<C981><41><EFBFBD><EFBFBD><EFBFBD>֎~<7E>ɐݒ<C990>
|
||
CAutoHwInt hwintlock( m_pKernelObj );
|
||
|
||
if( fCanDMA == FALSE )
|
||
return HAL_SUCCESS;
|
||
|
||
DWORD pQueueNum = m_DmaFifo.GetMaxSize() - m_DmaFifo.GetItemNum();
|
||
if( pQueueNum == 0 || m_HalFifo.GetItemNum() == 0 )
|
||
return HAL_SUCCESS;
|
||
|
||
IHALBuffer *pData;
|
||
m_HalFifo.GetItem( &pData );
|
||
return SendToDMA( pData );
|
||
};
|
||
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::SendData
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SendData( IHALBuffer *pData )
|
||
{
|
||
ASSERT( m_pioif != NULL );
|
||
ASSERT( pData != NULL );
|
||
|
||
|
||
DWORD QueueNum;
|
||
GetAvailableQueue( &QueueNum );
|
||
if( QueueNum == 0 || fCanSendData == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
if( m_HalFifo.AddItem( pData ) == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
return DeFifo();
|
||
};
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::SendToDMA
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SendToDMA( IHALBuffer *pData )
|
||
{
|
||
ASSERT( m_pioif != NULL );
|
||
ASSERT( pData != NULL );
|
||
|
||
/*
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
*/
|
||
|
||
DWORD i;
|
||
|
||
for( i = 0 ; i < ZIVA_QUEUE_SIZE; i ++ )
|
||
{
|
||
if( pQueuedBuff[i] == NULL )
|
||
break;
|
||
};
|
||
if( i == ZIVA_QUEUE_SIZE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
pQueuedBuff[i] = pData;
|
||
|
||
#ifdef _WDMDDK_NONEED_CAUSE_FIXED_BY_UCODE
|
||
// ZiVA 1.1<EFBFBD><EFBFBD>WDM<EFBFBD>Ń<EFBFBD><EFBFBD>j<EFBFBD><EFBFBD><EFBFBD>[<5B><><EFBFBD><EFBFBD><EFBFBD>܂<EFBFBD><DC82>\<5C><><EFBFBD>ł<EFBFBD><C582>Ȃ<EFBFBD><C882><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
{
|
||
UCHAR *Buffer = pData->GetLinBuffPointer();
|
||
|
||
ASSERT( Buffer != NULL );
|
||
|
||
if( Buffer != NULL )
|
||
{
|
||
// SCR check
|
||
if( ((Buffer[4] & 0x44) == 0x44 )
|
||
&& ((Buffer[6] & 0x04) == 0x04 )
|
||
&& ((Buffer[8] & 0x04) == 0x04 )
|
||
&& ((Buffer[9] & 0x01) == 0x01 ) )
|
||
{
|
||
DWORD SCR = 0;
|
||
SCR += ((Buffer[4] & 0x03) >> 0) << 28;
|
||
SCR += ((Buffer[5] & 0xff) >> 0) << 20;
|
||
SCR += ((Buffer[6] & 0xf8) >> 3) << 15;
|
||
SCR += ((Buffer[6] & 0x03) >> 0) << 13;
|
||
SCR += ((Buffer[7] & 0xff) >> 0) << 5;
|
||
SCR += ((Buffer[8] & 0xf8) >> 3) << 0;
|
||
|
||
/*
|
||
DWORD PTS = 0;
|
||
|
||
if( (Buffer[14+7] & 0x80 ) != 0 ) // check PTS_DTS Flags
|
||
{
|
||
PTS = ( ( Buffer[14+9] >> 1 ) & 0x7 ) << 30; // 32-30
|
||
PTS |= ( ( Buffer[14+10] >> 0 ) & 0xff ) << 22; // 29-22
|
||
PTS |= ( ( Buffer[14+11] >> 1 ) & 0x7f ) << 15; // 21-15
|
||
PTS |= ( ( Buffer[14+12] >> 0 ) & 0xff ) << 7; // 14-7
|
||
PTS |= ( ( Buffer[14+13] >> 1 ) & 0x7f ) << 0; // 6-0
|
||
|
||
if( Buffer[14+3] == 0xe0 )
|
||
DBG_PRINTF((" [%04d]SCR = 0x%x PTS = 0x%x Video \r\n",BuffCount, SCR,PTS ));
|
||
else
|
||
DBG_PRINTF((" [%04d]SCR = 0x%x PTS = 0x%x (0x%x)\r\n",BuffCount, SCR,PTS,Buffer[14+3] ));
|
||
}
|
||
else
|
||
{
|
||
if( Buffer[14+3] == 0xe0 )
|
||
DBG_PRINTF((" [%04d]SCR = 0x%x Video \r\n", BuffCount, SCR ));
|
||
else
|
||
DBG_PRINTF((" [%04d]SCR = 0x%x (0x%x)\r\n", BuffCount, SCR,Buffer[14+3] ));
|
||
};
|
||
*/
|
||
if( SCR < 500 *90 )
|
||
{
|
||
// set scr = 0 !!!!
|
||
Buffer[4] = 0x44;
|
||
Buffer[5] = 0x00;
|
||
Buffer[6] = 0x04;
|
||
Buffer[7] = 0x00;
|
||
Buffer[8] = 0x04;
|
||
Buffer[9] = 0x01;
|
||
};
|
||
}
|
||
else
|
||
{
|
||
DBG_PRINTF((" mixhal: SCR CHECK ERROR !!! LINE=%d\r\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
};
|
||
};
|
||
};
|
||
#endif
|
||
|
||
switch( i )
|
||
{
|
||
case 0:
|
||
// Select DMA0
|
||
m_pioif->luke2.IO_CONT &= 0xFFFFFFF8;
|
||
break;
|
||
case 1:
|
||
// Select DMA1
|
||
m_pioif->luke2.IO_CONT = ( m_pioif->luke2.IO_CONT & 0xFFFFFFF8 ) | 0x04;
|
||
break;
|
||
default:
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pioif->luke2.IO_MADR = (DWORD)pData->GetBuffPointer();
|
||
m_pioif->luke2.IO_MTC = pData->GetSize() -1;
|
||
|
||
switch( i )
|
||
{
|
||
case 0:
|
||
// Start DMA0
|
||
m_DmaFifo.AddItem( 0 );
|
||
m_pioif->luke2.IO_CONT = ( m_pioif->luke2.IO_CONT & 0xFFFFFFF8 ) | 0x01;
|
||
break;
|
||
case 1:
|
||
// Start DMA1
|
||
m_DmaFifo.AddItem( 1 );
|
||
m_pioif->luke2.IO_CONT = ( m_pioif->luke2.IO_CONT & 0xFFFFFFF8 ) | 0x04 | 0x02;
|
||
break;
|
||
default:
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::SetTransferMode
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetTransferMode( HALSTREAMMODE dwStreamMode )
|
||
{
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
switch( dwStreamMode )
|
||
{
|
||
case HALSTREAM_DVD_MODE:
|
||
if( ZiVADVDMode() == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
break;
|
||
default:
|
||
return HAL_NOT_IMPLEMENT;
|
||
}
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::GetAvailableQueue
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::GetAvailableQueue( DWORD *pQueueNum )
|
||
{
|
||
ASSERT( m_pKernelObj != NULL );
|
||
|
||
CAutoHwInt hwintlock( m_pKernelObj );
|
||
|
||
*pQueueNum = m_HalFifo.GetMaxSize() - m_HalFifo.GetItemNum();
|
||
|
||
// *pQueueNum = m_DmaFifo.GetMaxSize() - m_DmaFifo.GetItemNum();
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetPlayNormal
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetPlayNormal( void )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
VideoProperty_SkipFieldControl_Value ContData;
|
||
m_pZiVABoard->GetVideoProperty_SkipFieldControl( &ContData );
|
||
if( ContData == SkipFieldControl_On )
|
||
m_pZiVA->INT_MASK = m_pZiVABoard->GetEventIntMask() | ZIVA_INT_VSYNC;
|
||
else
|
||
m_pZiVA->INT_MASK = m_pZiVABoard->GetEventIntMask();
|
||
|
||
|
||
if( ZIVA_STATE_PLAY != m_pZiVA->PROC_STATE )
|
||
m_pZiVA->Resume();
|
||
|
||
DWORD Volume;
|
||
m_pZiVABoard->GetAudioProperty_Volume( (PVOID)&Volume );
|
||
m_pZiVABoard->SetAudioProperty_Volume( (PVOID)&Volume );
|
||
|
||
if( ZiVAStatusWait( ZIVA_STATE_PLAY ) == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
fCanSendData = TRUE;
|
||
fCanDMA = TRUE;
|
||
m_StreamState = StreamPlay;
|
||
|
||
DeFifo();
|
||
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetPlaySlow
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetPlaySlow( DWORD SlowFlag )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
if( (SlowFlag>31)||(SlowFlag<2) )
|
||
return HAL_INVALID_PARAM;
|
||
|
||
|
||
// ZiVA support 3<=param<=32, & 1.5<=speed<=16
|
||
DWORD SlowSpeed;
|
||
SlowSpeed = SlowFlag * 2;
|
||
if( SlowSpeed > 32 )
|
||
SlowSpeed = 32;
|
||
|
||
m_pZiVA->AUDIO_ATTENUATION = 0x96; // Audio Mute
|
||
m_pZiVA->INT_MASK = m_pZiVABoard->GetEventIntMask();
|
||
|
||
VideoProperty_TVSystem_Value TvSystem = TV_NTSC;
|
||
m_pZiVABoard->GetVideoProperty_TVSystem( &TvSystem );
|
||
|
||
if( TvSystem == TV_NTSC )
|
||
m_pZiVA->SlowMotion( SlowSpeed, 3 );
|
||
else
|
||
m_pZiVA->SlowMotion( SlowSpeed, 1 );
|
||
|
||
if( ZiVAStatusWait( ZIVA_STATE_SLOWMOTION ) == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
fCanSendData = TRUE;
|
||
fCanDMA = TRUE;
|
||
m_StreamState = StreamSlow;
|
||
|
||
DeFifo();
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetPlayPause
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetPlayPause( void )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
|
||
m_pZiVA->AUDIO_ATTENUATION = 0x96; // Audio Mute
|
||
|
||
if( m_StreamState == StreamStop )
|
||
{
|
||
//#ifdef _WDMDDK_
|
||
// CAutoHwInt hwintlock( m_pKernelObj );
|
||
//#endif
|
||
// wait play
|
||
if( m_pZiVABoard->m_NeedPowerOnDelay == TRUE )
|
||
{
|
||
m_pZiVABoard->m_NeedPowerOnDelay = FALSE;
|
||
DWORD CurrTime;
|
||
m_pKernelObj->GetTickCount( &CurrTime );
|
||
if( CurrTime < m_pZiVABoard->m_PowerOnTime + 600 )
|
||
m_pKernelObj->Sleep( m_pZiVABoard->m_PowerOnTime + 600 - CurrTime );
|
||
};
|
||
|
||
for( int counter = 0 ; counter < 5 ; counter ++ )
|
||
{
|
||
// Play Command Send to ZIVA
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->DisableHwInt();
|
||
//#endif
|
||
m_pZiVA->INT_MASK = ZIVA_INT_RDYD;
|
||
m_pZiVABoard->ClearRDYDEvent();
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->EnableHwInt();
|
||
//#endif
|
||
m_pZiVA->Play( 1, 0, 0, 0 );
|
||
|
||
// Wait RDYD interrupt
|
||
if( m_pZiVABoard->WaitRDYD() == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: SetPlayPause FAIL. LINE = %d\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
if( counter == 4 )
|
||
return HAL_ERROR;
|
||
|
||
DBG_PRINTF( ( "---------------- retry %d --------------\n", counter ));
|
||
// Abort Command Send to ZIVA
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->DisableHwInt();
|
||
//#endif
|
||
m_pZiVA->INT_MASK = ZIVA_INT_ENDC;
|
||
m_pZiVABoard->ClearENDCEvent();
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->EnableHwInt();
|
||
//#endif
|
||
m_pZiVA->Abort( 1 );
|
||
|
||
// Wait ENDC interrupt
|
||
if( m_pZiVABoard->WaitENDC() == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: SetPlayStop FAIL. LINE = %d\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
}
|
||
else
|
||
{
|
||
DBG_PRINTF( ( "RDYD OK!\n"));
|
||
break;
|
||
};
|
||
};
|
||
m_pZiVA->INT_MASK = (m_pZiVABoard->GetEventIntMask() & (~ZIVA_INT_EPTM));
|
||
fCanDMA = FALSE;
|
||
|
||
//#ifdef _WDMDDK_
|
||
// m_pZiVABoard->HALHwInterrupt();
|
||
//#endif
|
||
}
|
||
else
|
||
{
|
||
m_pZiVA->INT_MASK = (m_pZiVABoard->GetEventIntMask() & (~ZIVA_INT_EPTM));
|
||
|
||
m_pZiVA->Pause( 3 );
|
||
|
||
if( ZiVAStatusWait( ZIVA_STATE_PAUSE ) == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
fCanDMA = TRUE;
|
||
|
||
};
|
||
|
||
fCanSendData = TRUE;
|
||
m_StreamState = StreamPause;
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetPlayScan
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetPlayScan( DWORD ScanFlag )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->AUDIO_ATTENUATION = 0x96; // Audio Mute
|
||
|
||
// Ziva Playback timing host interrupt enable NV, GOP-V
|
||
m_pZiVA->INT_MASK = (m_pZiVABoard->GetEventIntMask() & (~ZIVA_INT_EPTM));
|
||
|
||
switch( ScanFlag )
|
||
{
|
||
case ScanOnlyI:
|
||
m_pZiVA->Scan( 0, 0, 3 );
|
||
break;
|
||
|
||
case ScanIandP:
|
||
m_pZiVA->Scan( 1, 0, 3 );
|
||
break;
|
||
|
||
default:
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->SelectStream( 2, 0xffff );
|
||
m_pZiVA->SelectStream( 1, 0xffff );
|
||
|
||
fCanSendData = TRUE;
|
||
fCanDMA = TRUE;
|
||
m_StreamState = StreamScan;
|
||
DeFifo();
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetPlaySingleStep
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetPlaySingleStep( void )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->AUDIO_ATTENUATION = 0x96; // Audio Mute
|
||
m_pZiVA->INT_MASK = m_pZiVABoard->GetEventIntMask();
|
||
|
||
VideoProperty_TVSystem_Value TvSystem = TV_NTSC;
|
||
m_pZiVABoard->GetVideoProperty_TVSystem( &TvSystem );
|
||
|
||
if( TvSystem == TV_NTSC )
|
||
m_pZiVA->SingleStep( 3 );
|
||
else
|
||
m_pZiVA->SingleStep( 1 );
|
||
|
||
if( ZiVAStatusWait( ZIVA_STATE_PAUSE ) == FALSE )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
fCanSendData = TRUE;
|
||
fCanDMA = TRUE;
|
||
m_StreamState = StreamSingleStep;
|
||
|
||
DeFifo();
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetPlayStop
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetPlayStop( void )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: SetPlayStop called.\n"));
|
||
ASSERT( m_pZiVA != NULL );
|
||
ASSERT( m_pioif != NULL );
|
||
|
||
fCanSendData = FALSE;
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
IHALBuffer *pFinishBuff;
|
||
|
||
DWORD Num, DmaNo ;
|
||
|
||
Num = m_DmaFifo.GetItemNum();
|
||
for( DWORD i = 0 ; i < Num ; i ++ )
|
||
{
|
||
m_DmaFifo.GetItem( &DmaNo );
|
||
pFinishBuff = DMAFinish( DmaNo );
|
||
if( pFinishBuff != NULL )
|
||
m_pZiVABoard->NotifyEvent( &m_pZiVABoard->m_SendDataEventList , (VOID *)pFinishBuff );
|
||
};
|
||
|
||
m_pZiVABoard->m_NaviCount = 0;
|
||
m_DmaFifo.Flush();
|
||
|
||
Num = m_HalFifo.GetItemNum();
|
||
for( i = 0 ; i < Num ; i ++ )
|
||
{
|
||
m_HalFifo.GetItem( &pFinishBuff );
|
||
if( pFinishBuff != NULL )
|
||
m_pZiVABoard->NotifyEvent( &m_pZiVABoard->m_SendDataEventList , (VOID *)pFinishBuff );
|
||
};
|
||
m_HalFifo.Flush();
|
||
|
||
m_StreamState = StreamStop;
|
||
fCanDMA = FALSE;
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
|
||
m_pZiVA->AUDIO_ATTENUATION = 0x96; // Audio Mute
|
||
m_pKernelObj->Sleep( 40 ); // wait 40 msec for Audio Mute
|
||
|
||
//#ifdef _WDMDDK_
|
||
// {
|
||
// CAutoHwInt hwintlock( m_pKernelObj );
|
||
//#endif
|
||
// Abort Command Send to ZIVA
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->DisableHwInt();
|
||
//#endif
|
||
m_pZiVA->INT_MASK = ZIVA_INT_ENDC;
|
||
m_pZiVABoard->ClearENDCEvent();
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->EnableHwInt();
|
||
//#endif
|
||
m_pZiVA->Abort( 1 );
|
||
|
||
// Wait ENDC interrupt
|
||
if( m_pZiVABoard->WaitENDC() == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: SetPlayStop FAIL. LINE = %d\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
// Wait IDLE STATE
|
||
CTimeOut TimeOutObj( 1000, 10, m_pKernelObj );
|
||
while( TRUE )
|
||
{
|
||
// Check IDLE State
|
||
if( m_pZiVA->PROC_STATE == (DWORD)ZIVA_STATE_IDLE )
|
||
break;
|
||
|
||
TimeOutObj.Sleep();
|
||
if( TimeOutObj.CheckTimeOut() == TRUE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: SetPlayStop FAIL. ZiVA Status = 0x%x\n", m_pZiVA->PROC_STATE ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
};
|
||
|
||
|
||
// Send DMA ABORT Command to LUKE2
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->DisableHwInt();
|
||
//#endif
|
||
m_pZiVABoard->ClearMasterAbortEvent();
|
||
m_pioif->luke2.IO_INTF |= 0x04; // DMA abort
|
||
m_pZiVA->INT_MASK = 0x0000; // disable all ziva interrupt
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->EnableHwInt();
|
||
//#endif
|
||
|
||
// Wait Master Abort interrupt
|
||
if( m_pZiVABoard->WaitMasterAbort() == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: SetPlayStop FAIL. LINE = %d\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
//#ifdef _WDMDDK_
|
||
// m_pZiVABoard->HALHwInterrupt();
|
||
// };
|
||
//#endif
|
||
|
||
ASSERT( m_DmaFifo.GetItemNum() == 0 );
|
||
ASSERT( m_HalFifo.GetItemNum() == 0 );
|
||
|
||
fCanDMA = FALSE;
|
||
m_StreamState = StreamStop;
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::CPPInit
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::CPPInit( void )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
ASSERT( m_pKernelObj != NULL );
|
||
ASSERT( m_StreamState == StreamStop );
|
||
|
||
m_CppState = CppState_OK;
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
//#ifdef _WDMDDK_
|
||
// {
|
||
// CAutoHwInt hwintlock( m_pKernelObj );
|
||
//#endif
|
||
// Abort Command Send to ZIVA
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->DisableHwInt();
|
||
//#endif
|
||
m_pZiVA->INT_MASK = ZIVA_INT_ENDC;
|
||
m_pZiVABoard->ClearENDCEvent();
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->EnableHwInt();
|
||
//#endif
|
||
m_pZiVA->Abort( 1 );
|
||
|
||
// Wait ENDC interrupt
|
||
if( m_pZiVABoard->WaitENDC() == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Abort FAIL. LINE = %d\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
CTimeOut TimeOutObj( 1000, 10, m_pKernelObj );
|
||
|
||
while( TRUE )
|
||
{
|
||
// Check IDLE State
|
||
if( m_pZiVA->PROC_STATE == (DWORD)ZIVA_STATE_IDLE )
|
||
break;
|
||
|
||
TimeOutObj.Sleep();
|
||
if( TimeOutObj.CheckTimeOut() == TRUE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: CPPInit FAIL. ZiVA Status = 0x%x\n", m_pZiVA->PROC_STATE ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
};
|
||
//#ifdef _WDMDDK_
|
||
// m_pZiVABoard->HALHwInterrupt();
|
||
// };
|
||
//#endif
|
||
|
||
m_pZiVA->CppInit( m_pZiVA->KEY_ADDRESS ); // Key Addr Setup
|
||
m_pZiVA->KEY_LENGTH = 0x1; // 2048 bytes
|
||
|
||
m_pZiVA->TransferKey( 1 , 0 ); // TransferKey( 1, 1 )?
|
||
|
||
// m_pZiVA->KEY_COMMAND = SET_DECRYPTION_MODE;
|
||
m_pZiVA->KEY_COMMAND = SET_PASS_THROUGH_MODE;
|
||
m_pZiVA->HOST_OPTIONS |= 0x04; // add by H. Yagi 99.03.02
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
ZiVACopyProtectStatusCheck( COMMAND_COMPLETE );
|
||
|
||
m_pZiVA->KEY_COMMAND = RESET_AUTHENTICATION;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
ZiVACopyProtectStatusCheck( COMMAND_COMPLETE );
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::GetDriveChallenge
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::GetDriveChallenge( UCHAR *pDriveChallenge )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->TransferKey( 1 , 0 ); // TransferKey( 1, 1 )?
|
||
|
||
m_pZiVA->KEY_COMMAND = GET_CHALLENGE_DATA;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
// wait for KEY_COMMAND complete.
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
pDriveChallenge[0] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_9;
|
||
pDriveChallenge[1] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_8;
|
||
pDriveChallenge[2] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_7;
|
||
pDriveChallenge[3] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_6;
|
||
pDriveChallenge[4] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_5;
|
||
pDriveChallenge[5] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_4;
|
||
pDriveChallenge[6] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_3;
|
||
pDriveChallenge[7] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_2;
|
||
pDriveChallenge[8] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_1;
|
||
pDriveChallenge[9] = (BYTE)m_pZiVA->DRIVE_CHALLENGE_0;
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetDriveResponse
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetDriveResponse( UCHAR *pDriveResponse )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->DRIVE_RESULT_4 = pDriveResponse[0];
|
||
m_pZiVA->DRIVE_RESULT_3 = pDriveResponse[1];
|
||
m_pZiVA->DRIVE_RESULT_2 = pDriveResponse[2];
|
||
m_pZiVA->DRIVE_RESULT_1 = pDriveResponse[3];
|
||
m_pZiVA->DRIVE_RESULT_0 = pDriveResponse[4];
|
||
|
||
m_pZiVA->KEY_COMMAND = SEND_RESPONSE_DATA;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetDecoderChallenge
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetDecoderChallenge( UCHAR *pDecoderChallenge )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->DECODER_CHALLENGE_9 = pDecoderChallenge[0];
|
||
m_pZiVA->DECODER_CHALLENGE_8 = pDecoderChallenge[1];
|
||
m_pZiVA->DECODER_CHALLENGE_7 = pDecoderChallenge[2];
|
||
m_pZiVA->DECODER_CHALLENGE_6 = pDecoderChallenge[3];
|
||
m_pZiVA->DECODER_CHALLENGE_5 = pDecoderChallenge[4];
|
||
m_pZiVA->DECODER_CHALLENGE_4 = pDecoderChallenge[5];
|
||
m_pZiVA->DECODER_CHALLENGE_3 = pDecoderChallenge[6];
|
||
m_pZiVA->DECODER_CHALLENGE_2 = pDecoderChallenge[7];
|
||
m_pZiVA->DECODER_CHALLENGE_1 = pDecoderChallenge[8];
|
||
m_pZiVA->DECODER_CHALLENGE_0 = pDecoderChallenge[9];
|
||
|
||
m_pZiVA->KEY_COMMAND = SEND_CHALLENGE_DATA;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::GetDecoderResponse
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::GetDecoderResponse( UCHAR *pDecoderResponse )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->KEY_COMMAND = GET_RESPONSE_DATA;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
pDecoderResponse[0] = (BYTE)m_pZiVA->DECODER_RESULT_4;
|
||
pDecoderResponse[1] = (BYTE)m_pZiVA->DECODER_RESULT_3;
|
||
pDecoderResponse[2] = (BYTE)m_pZiVA->DECODER_RESULT_2;
|
||
pDecoderResponse[3] = (BYTE)m_pZiVA->DECODER_RESULT_1;
|
||
pDecoderResponse[4] = (BYTE)m_pZiVA->DECODER_RESULT_0;
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetDiskKey
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetDiskKey( UCHAR *pDiskKey )
|
||
{
|
||
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->KEY_COMMAND = SEND_DISK_KEY;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
// wait for KEY_COMMAND complete.
|
||
if( ZiVACopyProtectStatusCheck( READY_DKEY ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
// DATA Transfer By DMA!!
|
||
|
||
DWORD QueueNum;
|
||
GetAvailableQueue( &QueueNum );
|
||
|
||
// check DMA
|
||
if( QueueNum != ZIVA_QUEUE_SIZE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
// Check MY DMA Buffer
|
||
if( m_pZiVABoard->GetDMABufferPhysicalAddr() == 0
|
||
|| m_pZiVABoard->GetDMABufferLinearAddr() == 0 )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
UCHAR *pDMABuffer = (UCHAR *)m_pZiVABoard->GetDMABufferLinearAddr();
|
||
// copy to My DMA Buffer
|
||
for( int i = 0 ; i < 2048 ; i ++ )
|
||
pDMABuffer[i] = pDiskKey[i];
|
||
|
||
//// output debug info.
|
||
// DBG_PRINTF( ("!!!!!!! Disc Key Transfer\n\r") );
|
||
// ULONG k, j;
|
||
// for( k=0; k<2048; ){
|
||
// DBG_PRINTF( ("DISCKEY: ") );
|
||
// for( j=0; j<8 && k<2048; j++, k++ ){
|
||
// DBG_PRINTF( ("0x%02x ", (UCHAR)pDMABuffer[k] ) );
|
||
// }
|
||
// DBG_PRINTF( ("\n\r") );
|
||
// }
|
||
|
||
|
||
// Select DMA0
|
||
m_pioif->luke2.IO_CONT &= 0xFFFFFFF8;
|
||
m_pioif->luke2.IO_MADR = m_pZiVABoard->GetDMABufferPhysicalAddr();
|
||
m_pioif->luke2.IO_MTC = 2048 -1;
|
||
// DMA0 START!!
|
||
m_pioif->luke2.IO_CONT = ( m_pioif->luke2.IO_CONT & 0xFFFFFFF8 ) | 0x01;
|
||
|
||
// wait for transfering Disk-Key
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
m_CppState = CppState_Error; // Yagi 98.02.09
|
||
// return HAL_ERROR; // Yagi 98.02.09
|
||
};
|
||
|
||
m_pZiVA->KEY_COMMAND = RESET_AUTHENTICATION;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
// wait KEY_COMMAND
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
if( m_CppState!=CppState_OK ){
|
||
return( HAL_ERROR );
|
||
}else{
|
||
return HAL_SUCCESS;
|
||
}
|
||
};
|
||
//---------------------------------------
|
||
// CMixHALStream::SetTitleKey
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetTitleKey( UCHAR *pTitleKey )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->TITLE_KEY_4 = pTitleKey[1];
|
||
m_pZiVA->TITLE_KEY_3 = pTitleKey[2];
|
||
m_pZiVA->TITLE_KEY_2 = pTitleKey[3];
|
||
m_pZiVA->TITLE_KEY_1 = pTitleKey[4];
|
||
m_pZiVA->TITLE_KEY_0 = pTitleKey[5];
|
||
|
||
m_pZiVA->KEY_COMMAND = SEND_TITLE_KEY;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
|
||
// wait foe SEND_TITLE_KEY complete.
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
// If you remove these commented mark( // ), you can play the bad disk-key
|
||
// title(Not encrypted but copy protected info). Yagi 98.02.09
|
||
// 98.05.29 H.Yagi
|
||
// if( m_CppState != CppState_Error ){
|
||
m_pZiVA->KEY_COMMAND = SET_DECRYPTION_MODE;
|
||
// }else{
|
||
// m_pZiVA->KEY_COMMAND = SET_PASS_THROUGH_MODE;
|
||
// m_pZiVA->HOST_OPTIONS |= 0x04;
|
||
// }
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
m_pZiVA->KEY_COMMAND = RESET_AUTHENTICATION;
|
||
m_pZiVA->KEY_STATUS = SET_NEW_COMMAND;
|
||
|
||
if( ZiVACopyProtectStatusCheck( COMMAND_COMPLETE ) == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
return HAL_SUCCESS;
|
||
};
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::ZiVACopyProtectStatusCheck
|
||
//---------------------------------------
|
||
BOOL CMixHALStream::ZiVACopyProtectStatusCheck( COPY_PROTECT_COMMAND Cmd )
|
||
{
|
||
ASSERT( m_pKernelObj != NULL );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Copyprotect ERROR!! line=%d\n",__LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
CTimeOut TimeOut( 1000, 10 , m_pKernelObj );
|
||
while( TRUE )
|
||
{
|
||
if( (DWORD)Cmd == m_pZiVA->KEY_STATUS )
|
||
return TRUE;
|
||
|
||
TimeOut.Sleep(); // Sleep
|
||
|
||
if( TimeOut.CheckTimeOut() == TRUE ){
|
||
DBG_PRINTF(("CPP STATUS ERROR = 0x%x\n", m_pZiVA->KEY_STATUS ));
|
||
DBG_BREAK();
|
||
return FALSE;
|
||
};
|
||
};
|
||
// DBG_BREAK();
|
||
// return FALSE;
|
||
};
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::ZiVAStatusWait
|
||
//---------------------------------------
|
||
BOOL CMixHALStream::ZiVAStatusWait( DWORD Status )
|
||
{
|
||
// debug debug
|
||
return TRUE;
|
||
|
||
// check power state
|
||
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
ASSERT( m_pKernelObj != NULL );
|
||
|
||
CTimeOut TimeOut( 1000, 10 , m_pKernelObj );
|
||
while( TRUE )
|
||
{
|
||
if( Status == m_pZiVA->PROC_STATE )
|
||
return TRUE;
|
||
|
||
TimeOut.Sleep(); // Sleep
|
||
|
||
if( TimeOut.CheckTimeOut() == TRUE ){
|
||
DBG_PRINTF(("ZIVA STATUS ERROR = 0x%x\n", m_pZiVA->PROC_STATE ));
|
||
DBG_BREAK();
|
||
return FALSE;
|
||
};
|
||
};
|
||
DBG_BREAK();
|
||
return FALSE;
|
||
|
||
};
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::DMAFinish
|
||
//---------------------------------------
|
||
IHALBuffer *CMixHALStream::DMAFinish( DWORD dwDMA_No )
|
||
{
|
||
IHALBuffer *pRetBuff;
|
||
if( ZIVA_QUEUE_SIZE <= dwDMA_No || pQueuedBuff[dwDMA_No] == NULL )
|
||
return NULL;
|
||
|
||
pRetBuff = pQueuedBuff[dwDMA_No ];
|
||
pQueuedBuff[dwDMA_No] = NULL;
|
||
return pRetBuff;
|
||
};
|
||
|
||
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::ZiVADVDMode
|
||
//---------------------------------------
|
||
BOOL CMixHALStream::ZiVADVDMode( void )
|
||
{
|
||
ASSERT( m_pZiVA != NULL );
|
||
ASSERT( m_StreamState == StreamStop );
|
||
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return FALSE;
|
||
};
|
||
|
||
// Audio Mute
|
||
// m_pioif->luke2.IO_CONT = ( m_pioif->luke2.IO_CONT & 0xffffff00) | 0x40;
|
||
m_pioif->luke2.IO_CONT = ( m_pioif->luke2.IO_CONT & 0xffffff00); // *Luke2Z specification is changed.
|
||
m_pioif->luke2.IO_PSCNT = 0x02; // I don't decide insert it
|
||
// in this place....
|
||
//#ifdef _WDMDDK_
|
||
// {
|
||
// CAutoHwInt hwintlock( m_pKernelObj );
|
||
//#endif
|
||
// Abort Command Send to ZIVA
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->DisableHwInt();
|
||
//#endif
|
||
m_pZiVA->INT_MASK = ZIVA_INT_ENDC;
|
||
m_pZiVABoard->ClearENDCEvent();
|
||
//#ifndef _WDMDDK_
|
||
m_pKernelObj->EnableHwInt();
|
||
//#endif
|
||
m_pZiVA->Abort( 1 );
|
||
|
||
// Wait ENDC interrupt
|
||
if( m_pZiVABoard->WaitENDC() == FALSE )
|
||
{
|
||
DBG_PRINTF( ( "mixhal: Abort FAIL. LINE = %d\n", __LINE__ ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
CTimeOut TimeOutObj( 1000, 10, m_pKernelObj );
|
||
|
||
while( TRUE )
|
||
{
|
||
// Check IDLE State
|
||
if( m_pZiVA->PROC_STATE == (DWORD)ZIVA_STATE_IDLE )
|
||
break;
|
||
|
||
TimeOutObj.Sleep();
|
||
if( TimeOutObj.CheckTimeOut() == TRUE )
|
||
{
|
||
DBG_PRINTF( ( "ZiVADVDMode ERROR !!! ZiVA Status = 0x%x\n", m_pZiVA->PROC_STATE ));
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
};
|
||
//#ifdef _WDMDDK_
|
||
// m_pZiVABoard->HALHwInterrupt();
|
||
// };
|
||
//#endif
|
||
|
||
// m_pZiVA->VIDEO_ENV_CHANGE = 0x01; // NTSC mode
|
||
|
||
m_pZiVA->BITSTREAM_TYPE = 0x00; // OK?
|
||
m_pZiVA->BITSTREAM_SOURCE = 0x00; // OK?
|
||
m_pZiVA->SD_MODE = 0x0D; // OK?
|
||
m_pZiVA->CD_MODE = 0x24; // OK?
|
||
m_pZiVA->AV_SYNC_MODE = 0x01; // SYNC_A/V
|
||
m_pZiVA->DISPLAY_ASPECT_RATIO = 0x00; // outout is 4:3
|
||
m_pZiVA->NewPlayMode();
|
||
|
||
// set several data for Audio Parameters.
|
||
// Note that these setting are implemented here now for only
|
||
// H/W debug.
|
||
m_pZiVA->AUDIO_CONFIG = 0x06;
|
||
m_pZiVA->AUDIO_DAC_MODE = 0x8;
|
||
// m_pZiVA->AUDIO_CLOCK_SELECTION = 0x00; // FS384
|
||
m_pZiVA->AUDIO_CLOCK_SELECTION = 0x01; // FS384
|
||
m_pZiVA->IEC_958_DELAY = 0x0;
|
||
m_pZiVA->AUDIO_ATTENUATION = 0x96; // Audio Mute
|
||
m_pZiVA->AU_CLK_INOUT = 0x01; // Toshiba special
|
||
|
||
m_pZiVA->HIGHLIGHT_ENABLE = 0x00; // ziva Hilight engine disable.
|
||
|
||
// AC-3 setting.
|
||
// Note that these setting are implemented here now for only
|
||
// H/W debug.
|
||
// m_pZiVA->AC3_OUT_MODE = 0x07;
|
||
// m_pZiVA->AC3_OUTPUT_MODE = 0x02;
|
||
m_pZiVA->AC3_OUTPUT_MODE = 0x00; // Dolby Pro-Logic
|
||
m_pZiVA->AC3_OPERATIONAL_MODE = 0x0; // OK?
|
||
|
||
m_pZiVA->NEW_AUDIO_CONFIG = 0x01;
|
||
|
||
CTimeOut TimeOut2( 1000, 10, m_pKernelObj ); // wait 1s, sleep 1ms
|
||
|
||
while( TRUE )
|
||
{
|
||
if( 0 == m_pZiVA->NEW_AUDIO_CONFIG )
|
||
break;
|
||
TimeOut2.Sleep();
|
||
if( TimeOut2.CheckTimeOut()==TRUE )
|
||
{
|
||
DBG_BREAK();
|
||
return FALSE;
|
||
};
|
||
|
||
}
|
||
|
||
// Audio Mute Off
|
||
// m_pioif->luke2.IO_CONT = m_pioif->luke2.IO_CONT & 0xffffffb8;
|
||
m_pioif->luke2.IO_CONT = ( (m_pioif->luke2.IO_CONT & 0xffffffb8)|0x40 ); // *Luke2Z spec is changed.
|
||
return TRUE;
|
||
};
|
||
|
||
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::SetDataDirection 1998.03.27 H.Yagi
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::SetDataDirection( DirectionType DataType )
|
||
{
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
switch( DataType )
|
||
{
|
||
case DataType_NormalAll:
|
||
case DataType_OpositeAll:
|
||
case DataType_IpicOnly:
|
||
return HAL_NOT_IMPLEMENT;
|
||
break;
|
||
default:
|
||
return HAL_NOT_IMPLEMENT;
|
||
}
|
||
|
||
return HAL_SUCCESS;
|
||
|
||
};
|
||
|
||
|
||
//---------------------------------------
|
||
// CMixHALStream::GetDataDirection 1998.03.27 H.Yagi
|
||
//---------------------------------------
|
||
HALRESULT CMixHALStream::GetDataDirection( DirectionType *pDataType )
|
||
{
|
||
// check power state
|
||
POWERSTATE PowerState;
|
||
ASSERT( m_pZiVABoard != NULL );
|
||
m_pZiVABoard->GetPowerState( &PowerState );
|
||
|
||
if( PowerState == POWERSTATE_OFF )
|
||
{
|
||
DBG_BREAK();
|
||
return HAL_ERROR;
|
||
};
|
||
|
||
return HAL_NOT_IMPLEMENT;
|
||
|
||
};
|
||
|
||
|
||
//***************************************************************************
|
||
// End of
|
||
//***************************************************************************
|