windows-xp/Source/XPSP1/NT/drivers/wdm/dvd/mini/tecra/zivachip.cpp

//***************************************************************************
//
//	FileName:
//		$Workfile: ZIVACHIP.CPP $
//
//	Author:
//		TOSHIBA [PCS](PSY) Seiichi Nakamura
//		Copyright (c) 1997 TOSHIBA CORPORATION
//
//	Description:
//
//***************************************************************************
// $Header: /DVD Drivers/ZiVA.WDM/ZIVACHIP.CPP 26    99/02/12 4:44p Yagi $
// $Modtime: 99/02/10 1:24p $
// $Nokeywords:$
//***************************************************************************

// for ziva debug
//#define		DEBUG_ZIVA

// for ziva command print out
//#define		DEBUG_ZIVA_COMMAND

//---------------------------------------------------------------------------
//	INCLUDES
//---------------------------------------------------------------------------

#include "includes.h"

#include "ioif.h"
#include "timeout.h"
#include "zivachip.h"

#include "dvd1cmd.h"	// from C-CUBE
#include "dramcfg.h"	// from C-CUBE

// Ziva Command time out setting.	1000 is 1 sec
#define COMMAND_TIMEOUT	(1000)


//---------------------------------------------------------------------------
//	Constructor for CViZAMemory
//---------------------------------------------------------------------------
CZiVA::CZiVAMemory::CZiVAMemory(void):Address(0),m_ziva(NULL)
{
};

//---------------------------------------------------------------------------
//	CZiVAMemory::Init
//---------------------------------------------------------------------------
void	CZiVA::CZiVAMemory::Init( CZiVA *pziva, DWORD addr )
{
	Address = addr;
	m_ziva = pziva;
};

//---------------------------------------------------------------------------
//	CZiVAMemory::Get
//---------------------------------------------------------------------------
DWORD	CZiVA::CZiVAMemory::Get( DWORD *pData )
{
	ASSERT( m_ziva != NULL );
#ifdef ZIVA_DEBUG
	DBG_PRINTF( ("CZiVAMemory::Get Addr = 0x%x\n", Address ) );
#endif
	return m_ziva->ZiVAReadMemory( Address, pData );
};

//---------------------------------------------------------------------------
//	CZiVAMemory::Set
//---------------------------------------------------------------------------
DWORD	CZiVA::CZiVAMemory::Set( DWORD Data )
{
	ASSERT( m_ziva != NULL );
#ifdef ZIVA_DEBUG
	DBG_PRINTF( ("CZiVAMemory::Set Addr = 0x%x Data = 0x%x\n", Address, Data) );
#endif
	return m_ziva->ZiVAWriteMemory( Address, Data );
};


//---------------------------------------------------------------------------
//	CZiVAMemory::GetAndSet
//---------------------------------------------------------------------------
DWORD	CZiVA::CZiVAMemory::GetAndSet( DWORD Mask, DWORD Data )
{
	ASSERT( m_ziva != NULL );
	DWORD GetData = 0;
	m_ziva->ZiVAReadMemory( Address, &GetData );
	GetData = GetData & Mask;
	GetData = GetData | Data;
#ifdef ZIVA_DEBUG
//	DBG_PRINTF( ("CZiVAMemory::GetAndSet Addr = 0x%x Mask = 0x%x Data = 0x%x WriteData = 0x%x \n", Address, Mask, Data,GetData ) );
#endif
	return m_ziva->ZiVAWriteMemory( Address, GetData );
};

//---------------------------------------------------------------------------
//	CZiVAMemory::operator&=
//---------------------------------------------------------------------------
CZiVA::CZiVAMemory& CZiVA::CZiVAMemory::operator&=(const DWORD &Data )
{
	ASSERT( m_ziva != NULL );
	DWORD GetData = 0;
	m_ziva->ZiVAReadMemory( Address, &GetData );
	GetData = GetData & Data;
#ifdef ZIVA_DEBUG
//	DBG_PRINTF( ("CZiVAMemory::operator &= Addr = 0x%x Data = 0x%x WriteData = 0x%x \n", Address, Data,GetData ) );
#endif
	m_ziva->ZiVAWriteMemory( Address, GetData );
	return *this;
};

//---------------------------------------------------------------------------
//	CZiVAMemory::operator|=
//---------------------------------------------------------------------------
CZiVA::CZiVAMemory& CZiVA::CZiVAMemory::operator|=(const DWORD &Data )
{
	ASSERT( m_ziva != NULL );
	DWORD GetData = 0;
	m_ziva->ZiVAReadMemory( Address, &GetData );
	GetData = GetData | Data;
#ifdef ZIVA_DEBUG
//	DBG_PRINTF( ("CZiVAMemory::operator |= Addr = 0x%x Data = 0x%x WriteData = 0x%x \n", Address, Data,GetData ) );
#endif
	m_ziva->ZiVAWriteMemory( Address, GetData );
	return *this;
};


//---------------------------------------------------------------------------
//	CZiVA constructor
//---------------------------------------------------------------------------
CZiVA::CZiVA( void ): m_pioif(NULL),m_pKernelObj( NULL )
{
};

//---------------------------------------------------------------------------
//	CZiVA::ZiVAWriteMemory
//---------------------------------------------------------------------------
DWORD	CZiVA::ZiVAWriteMemory( DWORD Addr, DWORD Data )
{
	ASSERT( m_pKernelObj != NULL );
	ASSERT( m_pioif != NULL );

	m_pKernelObj->DisableHwInt();

#ifdef ZIVA_DEBUG
//	DBG_PRINTF(( "ZiVAWriteMemory  Addr = 0x%x  Data = 0x%x\n", Addr,Data ));
#endif

	// set auto increment off
    m_pioif->zivaio.HIO[7] &= (BYTE)(~0x08);

	m_pioif->zivaio.HIO[4] = (BYTE)( Addr & 0xff );
	m_pioif->zivaio.HIO[5] = (BYTE)( ( Addr >> 8  ) & 0xff );
	m_pioif->zivaio.HIO[6] = (BYTE)( ( Addr >> 16 ) & 0xff );

	m_pioif->zivaio.HIO[3] = (BYTE)( (Data >> 24 ) & 0xff );
	m_pioif->zivaio.HIO[2] = (BYTE)( (Data >> 16 ) & 0xff );
	m_pioif->zivaio.HIO[1] = (BYTE)( (Data >>  8 ) & 0xff );
	m_pioif->zivaio.HIO[0] = (BYTE)( Data & 0xff );

	m_pKernelObj->EnableHwInt();
	return 0;
};

//---------------------------------------------------------------------------
//	CZiVA::ZiVAReadMemory
//---------------------------------------------------------------------------
DWORD	CZiVA::ZiVAReadMemory( DWORD Addr, DWORD *Data )
{
	ASSERT( m_pioif != NULL );
	ASSERT( m_pKernelObj != NULL );

	m_pKernelObj->DisableHwInt();

	DWORD rcData = 0;
	
	// set auto increment off
    m_pioif->zivaio.HIO[7] &= (BYTE)(~0x08);

	m_pioif->zivaio.HIO[4] = (BYTE)( Addr & 0xff );
	m_pioif->zivaio.HIO[5] = (BYTE)( ( Addr >> 8  ) & 0xff );
	m_pioif->zivaio.HIO[6] = (BYTE)( ( Addr >> 16 ) & 0xff );

	rcData  = (BYTE)m_pioif->zivaio.HIO[3];	rcData = rcData << 8;
	rcData += (BYTE)m_pioif->zivaio.HIO[2];	rcData = rcData << 8;
	rcData += (BYTE)m_pioif->zivaio.HIO[1];	rcData = rcData << 8;
	rcData += (BYTE)m_pioif->zivaio.HIO[0];
	
	*Data = rcData;

#ifdef ZIVA_DEBUG
	DBG_PRINTF(( "ZiVAReadMemory  Addr = 0x%x  Ret = 0x%x\n", Addr, *Data ));
#endif

	m_pKernelObj->EnableHwInt();
	return 0;
};

//---------------------------------------------------------------------------
//	CZiVA::Init
//---------------------------------------------------------------------------
void	CZiVA::Init( IKernelService *pKernelObj, CIOIF *pioif )
{
	m_pioif = pioif;
	m_pKernelObj = pKernelObj;

	Host_Control.Init( this , 0x00 | 0x800000 );

	ROM_INFO.Init(						this, ADDR_ROM_INFO );
	DRAM_INFO.Init(						this, ADDR_DRAM_INFO );
	UCODE_MEMORY.Init(					this, ADDR_UCODE_MEMORY );
	VIDEO_MODE.Init(					this, ADDR_VIDEO_MODE );
	DISPLAY_ASPECT_RATIO.Init(			this, ADDR_DISPLAY_ASPECT_RATIO );
	ASPECT_RATIO_MODE.Init(				this, ADDR_ASPECT_RATIO_MODE );
	PAN_SCAN_SOURCE.Init(				this, ADDR_PAN_SCAN_SOURCE );
	PAN_SCAN_HORIZONTAL_OFFSET.Init(	this, ADDR_PAN_SCAN_HORIZONTAL_OFFSET );
	TOP_BORDER.Init(					this, ADDR_TOP_BORDER );
	BORDER_COLOR.Init(					this, ADDR_BORDER_COLOR );
	BACKGROUND_COLOR.Init(				this, ADDR_BACKGROUND_COLOR );
	OSD_EVEN_FIELD.Init(				this, ADDR_OSD_EVEN_FIELD );
	OSD_ODD_FIELD.Init(					this, ADDR_OSD_ODD_FIELD );
	IC_TYPE.Init(						this, ADDR_IC_TYPE );
	ERR_CONCEALMENT_LEVEL.Init(			this, ADDR_ERR_CONCEALMENT_LEVEL );
	ERR_HORIZONTAL_SIZE.Init(			this, ADDR_ERR_HORIZONTAL_SIZE );
	ERR_VERTICAL_SIZE.Init(				this, ADDR_ERR_VERTICAL_SIZE );
	ERR_ASPECT_RATIO_INFORMATION.Init(	this, ADDR_ERR_ASPECT_RATIO_INFORMATION );
	ERR_FRAME_RATE_CODE.Init(			this, ADDR_ERR_FRAME_RATE_CODE );
	FORCE_CODED_ASPECT_RATIO.Init(		this, ADDR_FORCE_CODED_ASPECT_RATIO );
	AUDIO_CONFIG.Init(					this, ADDR_AUDIO_CONFIG );
	AUDIO_DAC_MODE.Init(				this, ADDR_AUDIO_DAC_MODE );
	AUDIO_CLOCK_SELECTION.Init(			this, ADDR_AUDIO_CLOCK_SELECTION );
	IEC_958_DELAY.Init(					this, ADDR_IEC_958_DELAY );
	AUDIO_ATTENUATION.Init(				this, ADDR_AUDIO_ATTENUATION );
	IEC_958_CHANNEL_STATUS_BITS.Init(	this, ADDR_IEC_958_CHANNEL_STATUS_BITS );
	AC3_OUTPUT_MODE.Init(				this, ADDR_AC3_OUTPUT_MODE );
	AC3_OPERATIONAL_MODE.Init(			this, ADDR_AC3_OPERATIONAL_MODE );
	AC3_LOW_BOOST.Init(					this, ADDR_AC3_LOW_BOOST );
	AC3_HIGH_CUT.Init(					this, ADDR_AC3_HIGH_CUT );
	AC3_PCM_SCALE_FACTOR.Init(			this, ADDR_AC3_PCM_SCALE_FACTOR );
	AC3_LFE_OUTPUT_ENABLE.Init(			this, ADDR_AC3_LFE_OUTPUT_ENABLE );
	AC3_VOICE_SELECT.Init(				this, ADDR_AC3_VOICE_SELECT );
	AC3_L_LEVEL.Init(					this, ADDR_AC3_L_LEVEL );
	AC3_C_LEVEL.Init(					this, ADDR_AC3_C_LEVEL );
	AC3_R_LEVEL.Init(					this, ADDR_AC3_R_LEVEL );
	AC3_SL_LEVEL.Init(					this, ADDR_AC3_SL_LEVEL );
	AC3_SR_LEVEL.Init(					this, ADDR_AC3_SR_LEVEL );
	AC3_CENTER_DELAY.Init(				this, ADDR_AC3_CENTER_DELAY );
	AC3_SURROUND_DELAY.Init(			this, ADDR_AC3_SURROUND_DELAY );
	BITSTREAM_TYPE.Init(				this, ADDR_BITSTREAM_TYPE );
	BITSTREAM_SOURCE.Init(				this, ADDR_BITSTREAM_SOURCE );
	SD_MODE.Init(						this, ADDR_SD_MODE );
	CD_MODE.Init(						this, ADDR_CD_MODE );
	AV_SYNC_MODE.Init(					this, ADDR_AV_SYNC_MODE );
	VIDEO_PTS_SKIP_INTERVAL.Init(		this, ADDR_VIDEO_PTS_SKIP_INTERVAL );
	VIDEO_PTS_REPEAT_INTERVAL.Init(		this, ADDR_VIDEO_PTS_REPEAT_INTERVAL );
	AUTOPAUSE_ENABLE.Init(				this, ADDR_AUTOPAUSE_ENABLE );
	VIDEO_ENV_CHANGE.Init(				this, ADDR_VIDEO_ENV_CHANGE );
    MEMCOPY_XFER_BLOCKSIZE.Init(        this, ADDR_MEMCOPY_XFER_BLOCKSIZE );
	INT_MASK.Init(						this, ADDR_INT_MASK );
	AUTO_FLUSH_INTERVAL.Init(			this, ADDR_AUTO_FLUSH_INTERVAL );
	RDY_S_THRESHOLD_LOW.Init(			this, ADDR_RDY_S_THRESHOLD_LOW );
	MEMORY_MAP.Init(					this, ADDR_MEMORY_MAP );
	PCI_BUFFER_START.Init(				this, ADDR_PCI_BUFFER_START );
	PCI_BUFFER_END.Init(				this, ADDR_PCI_BUFFER_END );
	DSI_BUFFER_START.Init(				this, ADDR_DSI_BUFFER_START );
	DSI_BUFFER_END.Init(				this, ADDR_DSI_BUFFER_END );
	OSD_BUFFER_START.Init(				this, ADDR_OSD_BUFFER_START );
	OSD_BUFFER_END.Init(				this, ADDR_OSD_BUFFER_END );
	OSD_BUFFER_IDLE_START.Init(			this, ADDR_OSD_BUFFER_IDLE_START );
	USER_DATA_BUFFER_START.Init(		this, ADDR_USER_DATA_BUFFER_START );
	USER_DATA_BUFFER_END.Init(			this, ADDR_USER_DATA_BUFFER_END );
	USER_DATA_READ.Init(				this, ADDR_USER_DATA_READ );
	USER_DATA_WRITE.Init(				this, ADDR_USER_DATA_WRITE );
	DUMP_DATA_BUFFER_START.Init(		this, ADDR_DUMP_DATA_BUFFER_START );
	DUMP_DATA_BUFFER_END.Init(			this, ADDR_DUMP_DATA_BUFFER_END );
	SUB_PICTURE_PALETTE_START.Init(		this, ADDR_SUB_PICTURE_PALETTE_START );
	SUB_PICTURE_PALETTE_END.Init(		this, ADDR_SUB_PICTURE_PALETTE_END );
	PROC_STATE.Init(					this, ADDR_PROC_STATE );
	MRC_ID.Init(						this, ADDR_MRC_ID );
	MRC_STATUS.Init(					this, ADDR_MRC_STATUS );
	INT_STATUS.Init(					this, ADDR_INT_STATUS );
	HLI_INT_SRC.Init(					this, ADDR_HLI_INT_SRC );
	BUFF_INT_SRC.Init(					this, ADDR_BUFF_INT_SRC );
	UND_INT_SRC.Init(					this, ADDR_UND_INT_SRC );
	PBT_INT_SRC.Init(					this, ADDR_PBT_INT_SRC );
	AOR_INT_SRC.Init(					this, ADDR_AOR_INT_SRC );
	AEE_INT_SRC.Init(					this, ADDR_AEE_INT_SRC );
	ERR_INT_SRC.Init(					this, ADDR_ERR_INT_SRC );
	VIDEO_EMPTINESS.Init(					this, ADDR_VIDEO_EMPTINESS );
	AUDIO_EMPTINESS.Init(					this, ADDR_AUDIO_EMPTINESS );
	CURR_PIC_DISPLAYED.Init(					this, ADDR_CURR_PIC_DISPLAYED );
	NEXT_PIC_DISPLAYED.Init(					this, ADDR_NEXT_PIC_DISPLAYED );
	VIDEO_FIELD.Init(					this, ADDR_VIDEO_FIELD );
	OSD_VALID.Init(					this, ADDR_OSD_VALID );
	NUM_DECODED.Init(					this, ADDR_NUM_DECODED );
	NUM_SKIPPED.Init(					this, ADDR_NUM_SKIPPED );
	NUM_REPEATED.Init(					this, ADDR_NUM_REPEATED );
	MRC_PIC_PTS.Init(					this, ADDR_MRC_PIC_PTS );
	MRC_PIC_STC.Init(					this, ADDR_MRC_PIC_STC );
	N_AUD_DECODED.Init(					this, ADDR_N_AUD_DECODED );
	NEXT_SECTOR_ADDR.Init(					this, ADDR_NEXT_SECTOR_ADDR );
	N_SYS_ERRORS.Init(					this, ADDR_N_SYS_ERRORS );
	N_VID_ERRORS.Init(					this, ADDR_N_VID_ERRORS );
	N_AUD_ERRORS.Init(					this, ADDR_N_AUD_ERRORS );
	DATE_TIME.Init(								this, ADDR_DATE_TIME );
	VERSION.Init(								this, ADDR_VERSION );
	EXTENDED_VERSION.Init(						this, ADDR_EXTENDED_VERSION );
	PIC1_BUFFER_START.Init(						this, ADDR_PIC1_BUFFER_START );
	PIC1_PTS.Init(								this, ADDR_PIC1_PTS );
	PIC1_PAN_SCAN.Init(							this, ADDR_PIC1_PAN_SCAN );
	PIC1_USER_DATA.Init(						this, ADDR_PIC1_USER_DATA );
	PIC1_TREF_PTYP_FLGS.Init(					this, ADDR_PIC1_TREF_PTYP_FLGS );
	PIC2_BUFFER_START.Init(						this, ADDR_PIC2_BUFFER_START );
	PIC2_PTS.Init(								this, ADDR_PIC2_PTS );
	PIC2_PAN_SCAN.Init(							this, ADDR_PIC2_PAN_SCAN );
	PIC2_USER_DATA.Init(						this, ADDR_PIC2_USER_DATA );
	PIC2_TREF_PTYP_FLGS.Init(					this, ADDR_PIC2_TREF_PTYP_FLGS );
	PIC3_BUFFER_START.Init(						this, ADDR_PIC3_BUFFER_START );
	PIC3_PTS.Init(								this, ADDR_PIC3_PTS );
	PIC3_PAN_SCAN.Init(							this, ADDR_PIC3_PAN_SCAN );
	PIC3_USER_DATA.Init(						this, ADDR_PIC3_USER_DATA );
	PIC3_TREF_PTYP_FLGS.Init(					this, ADDR_PIC3_TREF_PTYP_FLGS );
	STREAM_ID.Init(								this, ADDR_STREAM_ID );
	PACKET_LEN.Init(							this, ADDR_PACKET_LEN );
	PES_HEADER.Init(							this, ADDR_PES_HEADER );
	SUBPIC_EMPTINESS.Init(						this, ADDR_SUBPIC_EMPTINESS );
	H_SIZE.Init(								this, ADDR_H_SIZE );
	V_SIZE.Init(								this, ADDR_V_SIZE );
	APSECT_RATIO.Init(							this, ADDR_APSECT_RATIO );
	FRAME_RATE.Init(							this, ADDR_FRAME_RATE );
	BIT_RATE.Init(								this, ADDR_BIT_RATE );
	VBV_SIZE.Init(								this, ADDR_VBV_SIZE );
	SEQ_FLAGS.Init(								this, ADDR_SEQ_FLAGS );
	DISP_SIZE_H_V.Init(							this, ADDR_DISP_SIZE_H_V );
	TIME_CODE.Init(								this, ADDR_TIME_CODE );
	GOP_FLAGS.Init(								this, ADDR_GOP_FLAGS );
	TEMP_REF.Init(								this, ADDR_TEMP_REF );
	PIC_TYPE.Init(								this, ADDR_PIC_TYPE );
	VBV_DELAY.Init(								this, ADDR_VBV_DELAY );
	PIC_HEADER.Init(							this, ADDR_PIC_HEADER );
	AUDIO_TYPE.Init(							this, ADDR_AUDIO_TYPE );
	MPEG_AUDIO_HEADER1.Init(					this, ADDR_MPEG_AUDIO_HEADER1 );
	AC3_FRAME_NUMBER.Init(						this, ADDR_AC3_FRAME_NUMBER );
	LPCM_AUDIO_EMPHASIS_FLAG.Init(				this, ADDR_LPCM_AUDIO_EMPHASIS_FLAG );
	MPEG_AUDIO_HEADER2.Init(					this, ADDR_MPEG_AUDIO_HEADER2 );
	LPCM_AUDIO_MUTE_FLAG.Init(					this, ADDR_LPCM_AUDIO_MUTE_FLAG );
	AC3_BSI_IS_BEING_READ.Init(					this, ADDR_AC3_BSI_IS_BEING_READ );
	LPCM_AUDIO_FRAME_NUMBER.Init(				this, ADDR_LPCM_AUDIO_FRAME_NUMBER );
	AC3_BSI_VALID.Init(							this, ADDR_AC3_BSI_VALID );
	LPCM_AUDIO_QUANTIZATION_WORD_LENGTH.Init(	this, ADDR_LPCM_AUDIO_QUANTIZATION_WORD_LENGTH );
	AC3_BSI_FRAME.Init(							this, ADDR_AC3_BSI_FRAME );
	LPCM_AUDIO_SAMPLING_FREQUENCY.Init(			this, ADDR_LPCM_AUDIO_SAMPLING_FREQUENCY );
	AC3_FSCOD_FRMSIZECOD.Init(					this, ADDR_AC3_FSCOD_FRMSIZECOD );
	LPCM_AUDIO_NUMBER_OF_AUDIO_CHANNELS.Init(	this, ADDR_LPCM_AUDIO_NUMBER_OF_AUDIO_CHANNELS );
	AC3_BSID_BSMOD.Init(						this, ADDR_AC3_BSID_BSMOD );
	LPCM_AUDIO_DYNAMIC_RANGE_CONTROL.Init(		this, ADDR_LPCM_AUDIO_DYNAMIC_RANGE_CONTROL );
	AC3_ACMOD_CMIXLEV.Init(						this, ADDR_AC3_ACMOD_CMIXLEV );
	AC3_SURMIXLEV_DSURMOD.Init(					this, ADDR_AC3_SURMIXLEV_DSURMOD );
	AC3_LFEON_DIALNORM.Init(					this, ADDR_AC3_LFEON_DIALNORM );
	AC3_COMPR_LANGCOD.Init(						this, ADDR_AC3_COMPR_LANGCOD );
	AC3_MIXLEV_ROOMTYP.Init(					this, ADDR_AC3_MIXLEV_ROOMTYP );
	AC3_DIALNORM2_COMPR2.Init(					this, ADDR_AC3_DIALNORM2_COMPR2 );
	AC3_LANGCOD2_MIXLEV2.Init(					this, ADDR_AC3_LANGCOD2_MIXLEV2 );
	AC3_ROOMTYP2_COPYRIGHTB.Init(				this, ADDR_AC3_ROOMTYP2_COPYRIGHTB );
	AC3_ORIGBS_TIMECOD1.Init(					this, ADDR_AC3_ORIGBS_TIMECOD1 );
//	AC3_TIMECOD2.Init(							this, ADDR_AC3_TIMECOD2 );          // 98.04.02 H.Yagi
	AC3_TIMECOD2.Init(							this, ADDR_AC3_TIMECOD2_EBITS );    // 98.04.02 H.Yagi
	SE_STATUS.Init(								this, ADDR_SE_STATUS );
	NEW_AUDIO_MODE.Init(						this, ADDR_NEW_AUDIO_MODE );
	NEW_SUBPICTURE_PALETTE.Init(				this, ADDR_NEW_SUBPICTURE_PALETTE );
	NEW_AUDIO_CONFIG.Init(						this, ADDR_NEW_AUDIO_CONFIG );
	VSYNC_HEARTBEAT.Init(						this, ADDR_VSYNC_HEARTBEAT );
	ML_HEARTBEAT.Init(							this, ADDR_ML_HEARTBEAT );
	SUBPICTURE_ENABLE.Init(						this, ADDR_SUBPICTURE_ENABLE );
	HIGHLIGHT_ENABLE.Init(						this, ADDR_HIGHLIGHT_ENABLE );
	CURRENT_BUTTON.Init(						this, ADDR_CURRENT_BUTTON );

    ERR_MPEG_VERSION.Init(                      this, ADDR_ERR_MPEG_VERSION );          // 98.04.02 H.Yagi
    VERTICAL_DISPLAYMODE.Init(                  this, ADDR_VERTICAL_DISPLAYMODE );      // 98.04.02 H.Yagi
	AC3_ENGINE_VERSION.Init(					this, ADDR_AC3_ENGINE_VERSION );        // 98.04.02 H.Yagi
	ROM_END_POINTER.Init(						this, ADDR_ROM_END_POINTER );           // 98.04.02 H.Yagi
	CURRENT_VOB_CELL_ID.Init(					this, ADDR_CURRENT_VOB_CELL_ID );       // 98.04.02 H.Yagi
	PREV_VOBU_VIDEO_RLBN.Init(					this, ADDR_PREV_VOBU_VIDEO_RLBN );      // 98.04.02 H.Yagi


	// Authentication for only ZiVA1.1 or later     // Yagi
	KEY_ADDRESS.Init( 					this, 0x480 );
	KEY_LENGTH.Init(					this, 0x484 );

	// toshiba special
	AU_CLK_INOUT.Init(					this, 0xf8 );
    IDLE_DELAY.Init(                  this, ADDR_IDLE_DELAY );

    // 98.05.29 H.Yagi
    HOST_OPTIONS.Init(          this, ADDR_HOST_OPTIONS );
};



void    CZiVA::CppInit(  DWORD gKeyAddress )
{
        KEY_COMMAND.Init( this, gKeyAddress );
        KEY_STATUS.Init( this, gKeyAddress+1*4 );
        DRIVE_CHALLENGE_0.Init( this, gKeyAddress+2*4 );
        DRIVE_CHALLENGE_1.Init( this, gKeyAddress+3*4 );
        DRIVE_CHALLENGE_2.Init( this, gKeyAddress+4*4 );
        DRIVE_CHALLENGE_3.Init( this, gKeyAddress+5*4 );
        DRIVE_CHALLENGE_4.Init( this, gKeyAddress+6*4 );
        DRIVE_CHALLENGE_5.Init( this, gKeyAddress+7*4 );
        DRIVE_CHALLENGE_6.Init( this, gKeyAddress+8*4 );
        DRIVE_CHALLENGE_7.Init( this, gKeyAddress+9*4 );
        DRIVE_CHALLENGE_8.Init( this, gKeyAddress+10*4 );
        DRIVE_CHALLENGE_9.Init( this, gKeyAddress+11*4 );
        DECODER_CHALLENGE_0.Init( this, gKeyAddress+12*4 );
        DECODER_CHALLENGE_1.Init( this, gKeyAddress+13*4 );
        DECODER_CHALLENGE_2.Init( this, gKeyAddress+14*4 );
        DECODER_CHALLENGE_3.Init( this, gKeyAddress+15*4 );
        DECODER_CHALLENGE_4.Init( this, gKeyAddress+16*4 );
        DECODER_CHALLENGE_5.Init( this, gKeyAddress+17*4 );
        DECODER_CHALLENGE_6.Init( this, gKeyAddress+18*4 );
        DECODER_CHALLENGE_7.Init( this, gKeyAddress+19*4 );
        DECODER_CHALLENGE_8.Init( this, gKeyAddress+20*4 );
        DECODER_CHALLENGE_9.Init( this, gKeyAddress+21*4 );
        DRIVE_RESULT_0.Init( this, gKeyAddress+22*4 );
        DRIVE_RESULT_1.Init( this, gKeyAddress+23*4 );
        DRIVE_RESULT_2.Init( this, gKeyAddress+24*4 );
        DRIVE_RESULT_3.Init( this, gKeyAddress+25*4 );
        DRIVE_RESULT_4.Init( this, gKeyAddress+26*4 );
        DECODER_RESULT_0.Init( this, gKeyAddress+27*4 );
        DECODER_RESULT_1.Init( this, gKeyAddress+28*4 );
        DECODER_RESULT_2.Init( this, gKeyAddress+29*4 );
        DECODER_RESULT_3.Init( this, gKeyAddress+30*4 );
        DECODER_RESULT_4.Init( this, gKeyAddress+31*4 );
        TITLE_KEY_0.Init( this, gKeyAddress+32*4 );
        TITLE_KEY_1.Init( this, gKeyAddress+33*4 );
        TITLE_KEY_2.Init( this, gKeyAddress+34*4 );
        TITLE_KEY_3.Init( this, gKeyAddress+35*4 );
        TITLE_KEY_4.Init( this, gKeyAddress+36*4 );
};



//---------------------------------------------------------------------------
//	CZiVA::ZiVACommand
//---------------------------------------------------------------------------
ZIVARESULT		CZiVA::ZiVACommand( DWORD CommandID, DWORD d1, DWORD d2,  DWORD d3, DWORD d4, DWORD d5, DWORD d6 )
{
	ASSERT( m_pioif != NULL );
	
	DWORD StatusPointer = 0;
	DWORD ZiVAStatus = 0;
	
	CTimeOut TimeOut( COMMAND_TIMEOUT, 1 , m_pKernelObj );

	// status pointer check?
	while( TRUE ) 
	{
		ZiVAReadMemory(ADDR_STATUS_ADDRESS, &StatusPointer);
		if( StatusPointer != 0 )
		{
			ZiVAReadMemory( StatusPointer, &ZiVAStatus );
//			DBG_PRINTF( ("ZiVA Status = 0x%x\n", ZiVAStatus ));
			break;
		};
		// Sleep
		TimeOut.Sleep();

		// check Time out....... 1 sec
		if( TimeOut.CheckTimeOut() == TRUE )
			return ZIVARESULT_TIMEOUT;
	};
	
	m_pKernelObj->DisableHwInt();
	
    ZiVAWriteMemory( ADDR_COMMAND, CommandID );
	ZiVAWriteMemory( ADDR_PARAMETER_1, d1 );
	ZiVAWriteMemory( ADDR_PARAMETER_2, d2 );
	ZiVAWriteMemory( ADDR_PARAMETER_3, d3 );
	ZiVAWriteMemory( ADDR_PARAMETER_4, d4 );
	ZiVAWriteMemory( ADDR_PARAMETER_5, d5 );
	ZiVAWriteMemory( ADDR_PARAMETER_6, d6 );
	ZiVAWriteMemory( ADDR_STATUS_ADDRESS, 0x00 );		// zero the status pointer
	
	// interrupt
//	Host_Control |= 0x10C2;

	m_pKernelObj->EnableHwInt();

    CTimeOut TimeOut2( COMMAND_TIMEOUT, 1, m_pKernelObj );

	// status pointer check?
	while( TRUE ) 
	{
		ZiVAReadMemory(ADDR_STATUS_ADDRESS, &StatusPointer);
		if( StatusPointer != 0 )
		{
			ZiVAReadMemory( StatusPointer, &ZiVAStatus );
			DBG_PRINTF( ("ZiVA Status = 0x%x\n", ZiVAStatus ));
			break;
		};
		// Sleep
        TimeOut2.Sleep();

		// check Time out....... 1 sec
        if( TimeOut2.CheckTimeOut() == TRUE )
			return ZIVARESULT_TIMEOUT;
	};
	
	
	return ZIVARESULT_NOERROR;
};


//---------------------------------------------------------------------------
//	CZiVA::ZiVACommandNoWait
//---------------------------------------------------------------------------
ZIVARESULT		CZiVA::ZiVACommandNoWait( DWORD CommandID, DWORD d1, DWORD d2,  DWORD d3, DWORD d4, DWORD d5, DWORD d6 )
{
	ASSERT( m_pioif != NULL );
	
	DWORD StatusPointer = 0;
//    DWORD ZiVAStatus = 0;
	
	// status pointer check?

	ZiVAReadMemory(ADDR_STATUS_ADDRESS, &StatusPointer);
	if( StatusPointer == 0 )
		return ZIVARESULT_TIMEOUT;

	m_pKernelObj->DisableHwInt();
	
	ZiVAWriteMemory( ADDR_COMMAND, CommandID );
	ZiVAWriteMemory( ADDR_PARAMETER_1, d1 );
	ZiVAWriteMemory( ADDR_PARAMETER_2, d2 );
	ZiVAWriteMemory( ADDR_PARAMETER_3, d3 );
	ZiVAWriteMemory( ADDR_PARAMETER_4, d4 );
	ZiVAWriteMemory( ADDR_PARAMETER_5, d5 );
	ZiVAWriteMemory( ADDR_PARAMETER_6, d6 );
	ZiVAWriteMemory( ADDR_STATUS_ADDRESS, 0x00 );		// zero the status pointer
	
	// interrupt
//	Host_Control |= 0x10C2;

	m_pKernelObj->EnableHwInt();

	ZiVAReadMemory(ADDR_STATUS_ADDRESS, &StatusPointer);
	if( StatusPointer == 0 )
		return ZIVARESULT_TIMEOUT;
	
	return ZIVARESULT_NOERROR;
};



//---------------------------------------------------------------------------
//	CZiVA::Abort
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Abort( DWORD Flush )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Abort 0x%x\n",Flush ));
#endif
	return ZiVACommand( ABORT , Flush );
};

//---------------------------------------------------------------------------
//	CZiVA::Digest
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Digest( DWORD x, DWORD y, DWORD decimation, DWORD threshold, DWORD start )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Digest 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", x, y, decimation, threshold, start  ));
#endif
	return ZiVACommand( DIGEST ,  x,  y,  decimation,  threshold,  start );
};

//---------------------------------------------------------------------------
//	CZiVA::DumpDumpData_VCD
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::DumpData_VCD( DWORD start, DWORD length, DWORD address )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::DumpData_VCD 0x%x, 0x%x, 0x%x\n", start, length, address ));
#endif
	return ZiVACommand( DUMPDATA_VCD ,  start,  length,  address );
};

//---------------------------------------------------------------------------
//	CZiVA::DumpData_DVD
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::DumpData_DVD( DWORD numberOfBytes )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("	CZiVA::DumpData_DVD 0x%x\n", numberOfBytes ));
#endif
	return ZiVACommand( DUMPDATA_DVD ,  numberOfBytes );
};

//---------------------------------------------------------------------------
//	CZiVA::Fade
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Fade( DWORD level, DWORD fadetime )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Fade 0x%x, 0x%x\n", level, fadetime  ));
#endif
	return ZiVACommand( FADE ,  level,  fadetime );
};

//---------------------------------------------------------------------------
//	CZiVA::Freeze
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Freeze( DWORD displayMode )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Freeze 0x%x\n", displayMode  ));
#endif
	return ZiVACommand( FREEZE ,  displayMode );
};

//---------------------------------------------------------------------------
//	CZiVA::HighLight
//---------------------------------------------------------------------------
// by oka
ZIVARESULT	CZiVA::HighLight( DWORD button, DWORD action )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::HighLight 0x%x, 0x%x, 0x%x\n", button, group, action ));
#endif
// by oka
	return ZiVACommand( HIGHLIGHT ,  button,  action );
};

//---------------------------------------------------------------------------
//	CZiVA::HighLight2
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::HighLight2( DWORD Contrast, DWORD Color, DWORD YGeom, DWORD XGeom )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::HighLight2 0x%x, 0x%x, 0x%x, 0x%x\n", Contrast, Color, YGeom, XGeom ));
#endif
	return ZiVACommand(  HIGHLIGHT2,Contrast, Color, YGeom, XGeom );
};

/*
//---------------------------------------------------------------------------
//	CZiVA::NewAudioMode
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::NewAudioMode( void )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::NewAudioMode\n" ));
#endif
	return ZiVACommand( 0x0027 );
};
*/

//---------------------------------------------------------------------------
//	CZiVA::NewPlayMode
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::NewPlayMode( void )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::NewPlayMode\n" ));
#endif
	return ZiVACommand( NEWPLAYMODE );
};

//---------------------------------------------------------------------------
//	CZiVA::Pause
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Pause( DWORD displaymode )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Pause 0x%x\n" , displaymode ));
#endif
	return ZiVACommand( PAUSE ,  displaymode );
};

//---------------------------------------------------------------------------
//	CZiVA::Play
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Play( DWORD playmode, DWORD fadetime, DWORD start, DWORD stop )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Play 0x%x, 0x%x, 0x%x, 0x%x\n" , playmode, fadetime, start, stop ));
#endif
	return ZiVACommand( PLAY ,  playmode,  fadetime,  start,  stop );
};

//---------------------------------------------------------------------------
//  CZiVA::MemCopy(ROMtoDRAM)
//---------------------------------------------------------------------------
ZIVARESULT  CZiVA::MemCopy( DWORD romAddr, DWORD dramAddr, DWORD Length )
{
#ifdef		DEBUG_ZIVA_COMMAND
    DBG_PRINTF( ("CZiVA::MemCopy 0x%x, 0x%x, 0x%x\n", romAddr, dramAddr, Length ));
#endif
    return ZiVACommand( MEMCOPY ,  romAddr,  dramAddr,  Length );
};

//---------------------------------------------------------------------------
//	CZiVA::Reset
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Reset( void )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Reset\n" ));
#endif
	return ZiVACommand( RESET );
};

//---------------------------------------------------------------------------
//	
//---------------------------------------------------------------------------
//ZIVARESULT      CZiVA::Resume( DWORD playmode )
//{
//        return ZiVACommand( 0x012e ,  playmode );
//};

//---------------------------------------------------------------------------
//	     CZiVA::Resume
//---------------------------------------------------------------------------
ZIVARESULT      CZiVA::Resume( void )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Resume\n" ));
#endif
        return ZiVACommand( RESUME );
};

//---------------------------------------------------------------------------
//	CZiVA::Scan
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Scan( DWORD skip, DWORD scanmode, DWORD displaymode )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Scan 0x%x, 0x%x, 0x%x\n", skip, scanmode, displaymode ));
#endif
	return ZiVACommand( SCAN ,  skip,  scanmode,  displaymode );
};

//---------------------------------------------------------------------------
//	CZiVA::ScreenLoad
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::ScreenLoad( DWORD address, DWORD length, DWORD displaymode )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::ScreenLoad 0x%x0, 0x%x, 0x%x\n", address, length, displaymode ));
#endif
	return ZiVACommand( SCREENLOAD ,  address,  length,  displaymode );
};

//---------------------------------------------------------------------------
//	CZiVA::SelectStream
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::SelectStream( DWORD streamtype, DWORD streamnumber )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::SelectStream 0x%x, 0x%x\n", streamtype, streamnumber ));
#endif
	return ZiVACommand( SELECTSTREAM ,  streamtype,  streamnumber );
};

//---------------------------------------------------------------------------
//	CZiVA::SetFill
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::SetFill( DWORD x, DWORD y, DWORD length, DWORD height, DWORD color )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::SetFill 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", x, y, length, height, color  ));
#endif
	return ZiVACommand( SETFILL ,  x,  y,  length,  height,  color );
};

//---------------------------------------------------------------------------
//	CZiVA::SetStreams
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::SetStreams( DWORD videoID, DWORD audioID )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::SetStreams 0x%x, 0x%x\n", videoID, audioID ));
#endif
	return ZiVACommand( SETSTREAMS ,  videoID,  audioID );
};

//---------------------------------------------------------------------------
//	CZiVA::SingleStep
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::SingleStep( DWORD displaymode )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::SingleStep 0x%x\n", displaymode ));
#endif
	return ZiVACommand( SINGLESTEP ,  displaymode );
};

//---------------------------------------------------------------------------
//	CZiVA::SlowMotion
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::SlowMotion( DWORD N, DWORD displaymode )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::SlowMotion 0x%x, 0x%x\n", N, displaymode ));
#endif
	return ZiVACommand( SLOWMOTION ,  N,  displaymode );
};

// by oka
//---------------------------------------------------------------------------
//	CZiVA::Magnify
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::Magnify( DWORD x, DWORD y, DWORD factor )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("CZiVA::Magnify 0x%x, 0x%x\n", x,y,factor ));
#endif
	return ZiVACommand( MAGNIFY ,  x,  y,  factor );
};
/*
//---------------------------------------------------------------------------
//	CZiVA::SwitchOSDBuffer
//---------------------------------------------------------------------------
ZIVARESULT	CZiVA::SwitchOSDBuffer( DWORD evenfield, DWORD oddfield )
{
	return ZiVACommand( 0x8254 ,  evenfield,  oddfield );
}
*/

ZIVARESULT	CZiVA::TransferKey( DWORD KeyType, DWORD Authenticate )
{
#ifdef		DEBUG_ZIVA_COMMAND
	DBG_PRINTF( ("	CZiVA::TransferKey 0x%x, 0x%x\n", KeyType, Authenticate ));
#endif
        return ZiVACommand( 0x0137 ,  KeyType,  Authenticate );
}


//===================================================
//	ZiVA register ACCESS functions.
//===================================================

// CL6100 GBUS map
#define CF_read1          0x2d
#define CF_intrpt         0x1c    // all the CFIFO registers changed
#define CF_command        0x1f
#define CPU_imdt          0x34    // IMEM data register
#define CPU_imadr         0x36    // IMEM read/write pointer
#define CPU_index         0x3a    // index register for indirect regs
#define CPU_idxdt         0x3b    // data port for indirect regs
#define HOST_control      0x00
#define DMA_adr           0x22    // DMA Indirect Index registe
#define DMA_MODE          0x0f    // DMA Mode Setting register
#define DMA_data          0x23    // DMA Indirect Data register
#define DMA_CYCLE         0x11    // DMA Cycle register to define rom cycle/size
#define CPU_PC            0x9     // IMEM instruction pointer register
#define CPU_DIR           0xA     // instruction register


//---------------------------------------------------------------------------
//	CZiVA::ZiVAWriteReg
//---------------------------------------------------------------------------
DWORD	CZiVA::ZiVAWriteReg(DWORD Addr, DWORD Data )
{
	return ZiVAWriteMemory( Addr | 0x800000 , Data );
};

//---------------------------------------------------------------------------
//	CZiVA::ZiVAReadReg
//---------------------------------------------------------------------------
DWORD	CZiVA::ZiVAReadReg(DWORD Addr, DWORD *Data )
{
	return ZiVAReadMemory( Addr | 0x800000 , Data );
};

//---------------------------------------------------------------------------
//	ZiVA::ZiVAWriteIMEM
//---------------------------------------------------------------------------
DWORD	CZiVA::ZiVAWriteIMEM(DWORD Addr, DWORD Data )
{
	ZiVAWriteReg( CPU_imadr, Addr );
	return ZiVAWriteReg( CPU_imdt, Data );
};

//---------------------------------------------------------------------------
//	ZiVA::ZiVAReadIMEM
//---------------------------------------------------------------------------
DWORD	CZiVA::ZiVAReadIMEM(DWORD Addr, DWORD *Data )
{
	ZiVAWriteReg( CPU_index, 0x0b );
	ZiVAWriteReg( CPU_idxdt, Addr );
	ZiVAWriteReg( CPU_index, 0x0e );
	return ZiVAReadReg( CPU_idxdt , Data );
};


//---------------------------------------------------------------------------
//	CZiVA::load_GetDWORD
//---------------------------------------------------------------------------
DWORD CZiVA::load_GetDWORD()
{
	DWORD dwResult =  gpbRead[0] + (gpbRead[1] << 8) + (gpbRead[2] << 16) + (gpbRead[3] << 24);
	gpbRead += 4;
	return dwResult;
};

//---------------------------------------------------------------------------
//	CZiVA::load_GetDWORDSwap
//---------------------------------------------------------------------------
DWORD CZiVA::load_GetDWORDSwap()
{
	DWORD dwResult =  gpbRead[3] + (gpbRead[2] << 8) + (gpbRead[1] << 16) + (gpbRead[0] << 24);
	gpbRead += 4;
	return dwResult;
};

//---------------------------------------------------------------------------
//	CZiVA::load_GetDWORDSwapBackward
//---------------------------------------------------------------------------
DWORD CZiVA::load_GetDWORDSwapBackward()
{
	DWORD dwResult =  gpbRead[3] + (gpbRead[2] << 8) + (gpbRead[1] << 16) + (gpbRead[0] << 24);
	gpbRead -= 4;
	return dwResult;
};


#define IMEM_START_OFFSET       0x800   // byte offset
#define IMEM_LENGTH             0xFF    // in 32-bit words
#define DRAM_IMAGE_LENGTH       0x7FF   // in bytes

#define GBUS_TABLE_OFFSET       0xBFC   // byte offset
#define STREAM_SOURCE           0x0     // SD Interface

#define SD_MODE                 0xD   // For SD Interface



//===================================================
//	ZiVA Microcode Downloading 
//===================================================

//---------------------------------------------------------------------------
//	CZiVA::WriteMicrocode
//---------------------------------------------------------------------------
// Type 0:NTSC , 1:PAL
BOOL CZiVA::WriteMicrocode( DWORD Type )
{

  DWORD dwSectionLength;    // Section length in bytes
  DWORD dwSectionAddress;   // Start address in DRAM (WORD address)
  DWORD dwSectionChecksum;  // Section check sum value
  DWORD dwCnt;              // Counter of the bytes written to the DVD chip
  DWORD dwAddress;          // Current DRAM address (byte address)
  BYTE * pbUCodeStart;      // Sarting point of the UCode in the buffer (file)
  BYTE * pbFinalGBUSStart;  // Sarting point of the final GBUS writes.
  DWORD  dwTmp;
  BYTE TmpTmp;

  gpbRead = UXData;        // Set pointer to the beginning of the buffer

  // I-MODE SETING!!! 
  TmpTmp = m_pioif->zivaio.HIO[7];
	

  // A. Skip the initial header of the file (12 bytes)
  gpbRead += 12;

  // B. Skip data_type, section flags and unused (4 bytes)
  gpbRead += 4;

  dwSectionLength   = load_GetDWORD();
  dwSectionAddress  = load_GetDWORD();
  dwSectionChecksum = load_GetDWORD();

  // Remember the start of the UCode.
  pbUCodeStart = gpbRead;

  // C.1. Configuration-specific GBUS writes


  // Issue "Host Run" command
  Host_Control = 0x1000;

  // C.1.1 Set up the DRAM.
  ZiVAWriteReg( DMA_adr, DMA_MODE );
  //ZiVAWriteReg( DMA_data, 0x4EC );   // 16 Mbits DRAM
  ZiVAWriteReg( DMA_data, 0x14EC );   // 20 Mbits DRAM

  // C.1.2 Set up the ROM and SRAM (if any).
  ZiVAWriteReg( DMA_adr, DMA_CYCLE );
  ZiVAWriteReg( DMA_data, 0 );        // No ROM or SRAM present

  // C.2. Initial GBUS writes:
  gpbRead = pbUCodeStart + GBUS_TABLE_OFFSET;
  for ( dwCnt = load_GetDWORDSwapBackward(); dwCnt; dwCnt-- )
  {
    dwAddress = load_GetDWORDSwapBackward();
    ZiVAWriteReg( dwAddress, load_GetDWORDSwapBackward() );
  }

  // Remember the start of the Final GBUS writes table.
  pbFinalGBUSStart = gpbRead;

  // C.3. Copy bootstrap code into IMEM
  gpbRead = pbUCodeStart + IMEM_START_OFFSET;

  for ( dwAddress=0; dwAddress < IMEM_LENGTH; dwAddress ++ )
  {
    DWORD dwValue = load_GetDWORDSwap();
    ZiVAWriteIMEM( dwAddress, dwValue );
  }

  //return TRUE;

  // C.4. Copy default DVD1 configuration data into DRAM
  gpbRead = pbUCodeStart;

  for ( dwAddress=0; dwAddress < dwSectionLength/*DRAM_IMAGE_LENGTH*/; )
  {
    ZiVAWriteMemory( dwAddress, load_GetDWORDSwap() );
    dwAddress += 4; // Next 32-bit-WORD byte address in DRAM
  }

  // Check DRAM 12345
  ZiVAReadMemory( 0x128, &dwTmp );
  DBG_PRINTF( ("check DRAM 12345 ? Data = 0x%x\n", dwTmp ) );

/*
  // C.5. Update configuration data in DRAM for the specific system.
  DVD_WriteDRAM( DRAM_Stream_Source, STREAM_SOURCE );
  DVD_WriteDRAM( DRAM_SD_Mode, SD_MODE );
  DVD_WriteDRAM( DRAM_CFifo_Level, CFIFO_THRESHOLD );
  DVD_WriteDRAM( DRAM_INFO, 1 );        // one 4Mbits DRAM increment
  DVD_WriteDRAM( UCODE_MEMORY, 0 );     // Microcode is in DRAM
  DVD_WriteDRAM( MEMORY_MAP, 3 );       // for 20 Mbits DRAM
  DVD_WriteDRAM( AC3_OUTPUT_MODE, 7 );  // 6 channels audio

*/
	DRAM_INFO = 0x01;		// one 4Mbits DRAM increment
	UCODE_MEMORY = 0x00;	// microcode is in DRAM
	VIDEO_MODE = 0x03;		// VCLK slave, HSYNC and VSYNC master, CCIR-656 output

	switch( Type )
	{
		case 0:
			MEMORY_MAP = 0x03;		// 	for 20 Mbits DRAM And NTSC
			break;
		case 1:
			MEMORY_MAP = 0x06;		// 	for 20 Mbits DRAM And PAL
			break;
		default:
			DBG_BREAK();
			return FALSE;
	};
 
  // C.6. Perform final GBUS writes.
  gpbRead = pbFinalGBUSStart;

  for ( dwCnt = load_GetDWORDSwapBackward(); dwCnt; dwCnt-- )
  {
    dwAddress = load_GetDWORDSwapBackward();
    ZiVAWriteReg( dwAddress, load_GetDWORDSwapBackward() );
  }


    // Extend watchdog timer threashold.  by H.Yagi  99.02.10
    HOST_OPTIONS  |= 0x0400;

  //ZiVAWriteReg( CPU_cntl, 0x900000 ); // Run CPU.

  // D. Wait for the DVD1 to enter the Idle state
	


	// gets current time.
	CTimeOut TimeOut( COMMAND_TIMEOUT, 1, m_pKernelObj );	
	// status pointer check?
	DWORD State;
	while( TRUE ) 
	{
		State = (DWORD)PROC_STATE;
        DBG_PRINTF(( " Load UCode PROCSTATE = 0x%x\n" , State));
		if( State == ZIVA_STATE_IDLE )
			break;
		// Sleep
		TimeOut.Sleep();

		// check Time out....... 1 sec
		if( TimeOut.CheckTimeOut() == TRUE )
		{
			DBG_PRINTF(( " Load UCode failed:  State = 0x%x\n" , (DWORD)PROC_STATE ));
			DBG_BREAK();
			return FALSE;
		};
	};

    IDLE_DELAY = 0x10;                  // Power saving value
    HOST_OPTIONS |= 0x20;               // for NV interrupt correctly

	DBG_PRINTF( (" LOAD UCODE completed. State = 0x%x\n", (DWORD)PROC_STATE ));
//        _Debug_Printf_Service(" LOAD UCODE completed. State = 0x%x\n", (DWORD)PROC_STATE );

  return TRUE;
};


//***************************************************************************
//	End of 
//***************************************************************************