//*******************************************************************
//			    	IRIS-MAINPモニタプログラム カード関数
//*******************************************************************
#include "IrisMon.h"



#ifdef TEST_CARD_BY_MAINP


//--------------------- グローバル 変数  -------------------------------


CardIntrWork  cardIntrWork;




//----------------------------------------------------------------------
//     					コマンド設定
//----------------------------------------------------------------------

void SetCardOp(const CardCtrlParam *paramp)
{
	int  i;

	WaitCardDma(paramp->dmaNo);										// カード転送終了待ち

	*(vu8 *)REG_CARD_MASTER_CNT = CARDMST_SEL_ROM					// マスターイネーブル
								| CARDMST_ENABLE | CARDMST_IF_ENABLE;

	for (i=0; i<2; i++) {											// コマンド設定
		u32	opTmp = paramp->op[1 - i];
		vu8 *opDestBasep = (vu8 *)(REG_CARD_CMD + i*4);

		opDestBasep[0] = opTmp >>24;
		opDestBasep[1] = opTmp >>16;
		opDestBasep[2] = opTmp >>8;
		opDestBasep[3] = opTmp >>0;
	}
}


//----------------------------------------------------------------------
//     					カード待ち ＆ DMA停止
//----------------------------------------------------------------------

void WaitCardDma(u32 dmaNo)
{
	WaitCard();

	if (dmaNo <= 3)		StopDma(dmaNo);
}


//----------------------------------------------------------------------
//     					カードページ読み込み（GAMEモード／同期）
//----------------------------------------------------------------------

void ReadCard4Game(void *romp, void *ramp, s32 size, u32 cntParam)
{
	CardCtrlParam param;
	s32  restSize = size;
	s32  blockSize = MROM_PAGE_SIZE;

	param.cardCnt = cntParam									// コントロール設定 
					| CARD_READ_MODE | CARD_1_PAGE
					| CARD_START | CARD_RESET_HI;
	param.dmaNo = 3;											// DMA番号指定

	while (restSize > 0) {										// ブロック分割読み込み
		ReadCardAsync4Game(romp, ramp, blockSize, &param);

		(u8 *)romp += blockSize;
		(u8 *)ramp += blockSize;
		restSize   -= blockSize;
	}

	WaitCardDma(param.dmaNo);
}


//----------------------------------------------------------------------
//     					カード読み込み（DMA非同期）
//----------------------------------------------------------------------

void ReadCardAsync(void *romp, void *ramp, s32 size, CardCtrlParam *paramp)
{
	SetCardOp(paramp);											// コマンド設定

	if (paramp->dmaNo <= 3) {
		DmaReadCard(paramp->dmaNo, ramp);						// DMA設定（最大設定 DMA0-2: 64KB / DMA3: 256KB）
		*(vu32 *)REG_CARDCNT = paramp->cardCnt;					// コントロール設定 & DMAスタート
	} else {
		void *ramEndp;
		u32 cardCntTmp;

		*(vu32 *)REG_CARDCNT = paramp->cardCnt;					// コントロール設定 

		ramEndp = (u8 *)ramp + size;							// 格納終了アドレス算出

		do {													// CPU読み込み
			cardCntTmp = *(vu32 *)REG_CARDCNT;

			if (cardCntTmp & CARD_DATA_READY) {
				u32 dataTmp = *(vu32 *)REG_CARD_DATA;

				if (ramp < ramEndp)	
					*((vu32 *)ramp) = dataTmp;					// 指定サイズまで格納（後続データは読み捨て）
				((vu32 *)ramp)++;
			}
		} while (cardCntTmp & CARD_START);
	}
}

//----------------------------------------------------------------------
//     					カード転送ブロックサイズ 獲得
//----------------------------------------------------------------------

s32 GetBlockSizeFromCardCnt(CardCnt *paramp)
{
	s32  blockSize = 0;
	s32  pages = paramp->pages;

	if (pages == ST_CARD_STATUS)		blockSize = 4;
	else if (pages >= ST_CARD_1_PAGE)	blockSize = 512 <<(pages - 1);

	return  blockSize;
}


//----------------------------------------------------------------------
//     					カードID読み込み（同期）
//----------------------------------------------------------------------

u32 ReadCardID(CardCtrlParam *paramp)
{
	paramp->dmaNo = -1;											// DMA不使用指定

	SetCardOp(paramp);											// コマンド設定

	*(vu32 *)REG_CARDCNT = paramp->cardCnt						// コントロール設定 
						 | CARD_READ_MODE | CARD_STATUS
						 | CARD_START | CARD_RESET_HI;
	WaitCardData();

	return  *(vu32 *)REG_CARD_DATA;
}

//----------------------------------------------------------------------
//     					カードID読み込み（NORMALモード）
//----------------------------------------------------------------------

u32 ReadCardID4Normal(void)
{
	CardCtrlParam param;

	param.cardCnt = GetCardCnt4Normal();						// コントロール設定（スクランブル設定クリア）
	param.op[0] = 0;											// コマンド設定
	param.op[1] = MROMOP_N_READ_ID;

	return  ReadCardID(&param);
}

//----------------------------------------------------------------------
//     					カードID読み込み（NORMALモード）
//----------------------------------------------------------------------

u32 ReadCardID4Game(void)
{
	CardCtrlParam param;

	param.cardCnt = GetCardCnt4Game();							// コントロール設定（スクランブル設定クリア）
	param.op[0] = 0;											// コマンド設定
	param.op[1] = MROMOP_G_READ_ID;

	return  ReadCardID(&param);
}


//----------------------------------------------------------------------
//     					カードデータ読み込み（GAMEモード／非同期）
//----------------------------------------------------------------------

void ReadCardAsync4Game(void *romp, void *ramp, s32 size, CardCtrlParam *paramp)
{
	paramp->op[0] = (u32 )romp <<24;							// コマンド設定
	paramp->op[1] = MROMOP_G_READ_PAGE | (u32 )romp >>8;

	ReadCardAsync(romp, ramp, size, paramp);
}


//----------------------------------------------------------------------
//     					カード割り込み 設定
//----------------------------------------------------------------------

void SetCardIntr(void *romp, void *ramp, s32 size, CardIntrWork *ciwp)
{
	ciwp->romp = romp;
	ciwp->ramp = ramp;
	ciwp->restSize  = size;
	ciwp->blockSize = GetBlockSizeFromCardCnt((CardCnt *)&ciwp->param.cardCnt);
	ciwp->param.dmaNo = 3;

	WaitCardDma(ciwp->param.dmaNo);

	*(vu32 *)REG_IME = 0;
//	*(vu32 *)INTR_CHECK_BUF &= (-1 ^ CARD_DATA_INTR_FLAG);	// カード割込チェックのクリア

	*(vu32 *)REG_IF  = CARD_DATA_INTR_FLAG;
	*(vu32 *)REG_IE |= CARD_DATA_INTR_FLAG;					// カード割り込み許可
	*(vu32 *)REG_IME = 1;

	ciwp->AsyncFuncp(ciwp->romp, ciwp->ramp, ciwp->blockSize, &ciwp->param);
}

//----------------------------------------------------------------------
//     					カード割り込み 終了待ち
//----------------------------------------------------------------------

void WaitCardIntr(void)
{
	WaitIntr(0, CARD_DATA_INTR_FLAG);

	{	CardIntrWork *ciwp = &cardIntrWork;

		WaitCardDma(ciwp->param.dmaNo);
	}

	*(vu32 *)REG_IME = 0;
	*(vu32 *)REG_IE &= (-1 ^ CARD_DATA_INTR_FLAG);			// カード割り込み禁止
	*(vu32 *)REG_IME = 1;
}


//----------------------------------------------------------------------
//     					カード割り込み 設定（GAMEモード）
//----------------------------------------------------------------------

void SetCardIntr4Game(void *romp, void *ramp, s32 size)
{
	CardIntrWork *ciwp = &cardIntrWork;

	ciwp->param.cardCnt = GetCardCnt4Game()					// コントロール設定 
						| CARD_READ_MODE | CARD_1_PAGE
						| CARD_START | CARD_RESET_HI;

	ciwp->AsyncFuncp = ReadCardAsync4Game;					// データ読み込み関数 セット

	SetCardIntr(romp, ramp, size, ciwp);
}


//----------------------------------------------------------------------
//     					カード割り込み
//----------------------------------------------------------------------

void CardIntr(void)
{
	CardIntrWork *ciwp = &cardIntrWork;
	s32  blockSize = ciwp->blockSize;

	// ブロック分割読み込み

	(u8 *)ciwp->romp += blockSize;
	(u8 *)ciwp->ramp += blockSize;
	ciwp->restSize   -= blockSize;

	if (ciwp->restSize > 0) {
		cardIntrWork.AsyncFuncp(ciwp->romp, ciwp->ramp, blockSize, &ciwp->param);
	} else {
		*(vu32 *)INTR_CHECK_BUF |= CARD_DATA_INTR_FLAG;	// カード割込チェックのセット
	}
}


#endif	// TEST_CARD_BY_MAINP


//----------------------------------------------------------------------
//     					カードアクセス
//----------------------------------------------------------------------

#ifndef TS_MON

void AccessCard(u32 dmaNo, s32 *srcp, s32 *destp, s32 size)
{
	int  i;

//    *(vu8 *)REG_EXMEMCNT = CTRDG_ACCESS_MAINP | CTRDG_AD16_1ST_10CYC | CTRDG_AD16_2ND_6CYC;  // 10-6アクセス

	CpuCopy16_32(srcp, destp, size, 32);							// カートリッジからの転送
}

#endif	// TS_MON