sdhcslot.cpp

s3c2450 bsp for wince 5.0 PM_REL_0.04_080519 经验证,完全没问题

		DWORD dwPresentState = ReadDword(SDHC_PRESENT_STATE);
		if (dwPresentState & STATE_CARD_INSERTED) {
			RETAILMSG(1, (TEXT("+++++++++++++++++++++SDHCControllerIst - Card is Inserted! 0x%08X\n"),this));			
			DEBUGMSG(SDHC_INTERRUPT_ZONE, (TEXT("SDHCControllerIst - Card is Inserted! \n")));
			m_fFakeCardRemoval = FALSE;			// added by JJG 06.11.13
			if (m_fCardPresent == FALSE ) {
				HandleInsertion();
			}
		}
		else {
			RETAILMSG(1, (TEXT("------------------------SDHCControllerIst - Card is Removed! 0x%08X\n"),this));	

			DEBUGMSG(SDHC_INTERRUPT_ZONE, (TEXT("SDHCControllerIst - Card is Removed! \n")));
			m_fFakeCardRemoval = FALSE;			// added by JJG 06.11.13
			if (m_fCardPresent) {
				HandleRemoval(TRUE);
			}
		}
	}
}

#elif (BSP_TYPE == BSP_SMDK2450)

#ifndef _SMDK2450_CH0_EXTCD_
VOID CSDHCSlotBase::HandleInterrupt()
#else
	// 08.03.20 by KYS
	// New Interrupt handler function can process factors on new card detect interrupt of HSMMC ch0 on SMDK450.
VOID CSDHCSlotBase::HandleInterrupt(SDSLOT_INT_TYPE intType)
#endif
{
	Validate();
#ifdef _SMDK2450_CH0_EXTCD_
	// in case of it is occurred a card detect interrupt of HSMMC ch0 on SMDK2450.
	if (intType == SDSLOT_INT_CARD_DETECTED) {
		RETAILMSG(0,(TEXT("[HSMMC0] Card Insertion or Removal Detect!!\n")));	
		m_fCheckSlot = TRUE;
	} else {  
#endif
		WORD wIntStatus = 0;
		wIntStatus = ReadWord(SDHC_NORMAL_INT_STATUS);

		if (m_fFakeCardRemoval && m_fCardPresent) {
			m_fFakeCardRemoval = FALSE;
			HandleRemoval(TRUE);
		}

		if (wIntStatus != 0) {
			DEBUGMSG(SDHC_INTERRUPT_ZONE, 
					(TEXT("HandleInterrupt (%u) - Normal Interrupt_Status=0x%02x\n"),
					 m_dwSlot, wIntStatus));
			RETAILMSG(0, 
					(TEXT("HandleInterrupt (%u) - Normal Interrupt_Status=0x%02x\n"),
					 m_dwSlot, wIntStatus));

			// Error handling. Make sure to handle errors first. 
			if ( wIntStatus & NORMAL_INT_STATUS_ERROR_INT ) {
				HandleErrors();
			}

			// Command Complete handling.
			if ( wIntStatus & NORMAL_INT_STATUS_CMD_COMPLETE ) {
				// Clear status
				m_fCommandCompleteOccurred = TRUE;
				WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) & ~(NORMAL_INT_STATUS_CMD_COMPLETE)));
				WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) & ~(NORMAL_INT_STATUS_CMD_COMPLETE)));
				do {
					WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_CMD_COMPLETE);
				}while(ReadWord(SDHC_NORMAL_INT_STATUS) & (NORMAL_INT_STATUS_CMD_COMPLETE));
				WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | NORMAL_INT_STATUS_CMD_COMPLETE));
				WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | NORMAL_INT_STATUS_CMD_COMPLETE));

				if ( HandleCommandComplete() ) {
					wIntStatus &= ~NORMAL_INT_STATUS_TRX_COMPLETE; // this is command-only request. 
				}
			}

			// Sometimes at the lowest clock rate, the Read/WriteBufferReady
			// interrupt actually occurs before the CommandComplete interrupt.
			// This confuses our debug validation code and could potentially
			// cause problems. This is why we will verify that the CommandComplete
			// occurred before processing any data transfer interrupts.
			if (m_fCommandCompleteOccurred) {
				if (wIntStatus & NORMAL_INT_STATUS_DMA) {
					WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) & ~(NORMAL_INT_STATUS_DMA)));
					WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) & ~(NORMAL_INT_STATUS_DMA)));
					do {
						WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_DMA);
					}while(ReadWord(SDHC_NORMAL_INT_STATUS) & NORMAL_INT_STATUS_DMA);
					WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | NORMAL_INT_STATUS_DMA));
					WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | NORMAL_INT_STATUS_DMA));

					HandleDma();
					// do not break here. Continue to check TransferComplete. 
				}

				// Buffer Read Ready handling
				if (wIntStatus & NORMAL_INT_STATUS_BUF_READ_RDY ) {
					// Clear status
					WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) & ~(NORMAL_INT_STATUS_BUF_READ_RDY)));
					WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) & ~(NORMAL_INT_STATUS_BUF_READ_RDY)));
					do {
						WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_BUF_READ_RDY);
					}while((ReadWord(SDHC_NORMAL_INT_STATUS) & NORMAL_INT_STATUS_BUF_READ_RDY));
					WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | NORMAL_INT_STATUS_BUF_READ_RDY));
					WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE, (ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | NORMAL_INT_STATUS_BUF_READ_RDY));

					HandleReadReady();
					// do not break here. Continue to check TransferComplete. 
				}

				// Buffer Write Ready handling
				if (wIntStatus & NORMAL_INT_STATUS_BUF_WRITE_RDY ) {
					// Clear status
					WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) & ~(NORMAL_INT_STATUS_BUF_WRITE_RDY)));
					WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) & ~(NORMAL_INT_STATUS_BUF_WRITE_RDY)));
					do {
						WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_BUF_WRITE_RDY);
					}while((ReadWord(SDHC_NORMAL_INT_STATUS) & NORMAL_INT_STATUS_BUF_WRITE_RDY));
					WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | NORMAL_INT_STATUS_BUF_WRITE_RDY));
					WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | NORMAL_INT_STATUS_BUF_WRITE_RDY));

					HandleWriteReady();
					// do not break here. Continue to check TransferComplete. 
				}
			}
			else {
				// We received data transfer interrupt before command 
				// complete interrupt. Wait for the command complete before
				// processing the data interrupt.
			}

			// Transfer Complete handling
			if ( wIntStatus & NORMAL_INT_STATUS_TRX_COMPLETE ) {
				// Clear status
				WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) & ~(NORMAL_INT_STATUS_TRX_COMPLETE)));
				WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) & ~(NORMAL_INT_STATUS_TRX_COMPLETE)));
				do {
					WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_TRX_COMPLETE | NORMAL_INT_STATUS_DMA);
				}while(ReadWord(SDHC_NORMAL_INT_STATUS) & (NORMAL_INT_STATUS_TRX_COMPLETE|NORMAL_INT_STATUS_DMA));
				WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | NORMAL_INT_STATUS_TRX_COMPLETE));
				WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | NORMAL_INT_STATUS_TRX_COMPLETE));


				HandleTransferDone();
			}

			// SDIO Interrupt Handling
			if ( wIntStatus & NORMAL_INT_STATUS_CARD_INT ) {
				DEBUGCHK(m_fSDIOInterruptsEnabled);
				DEBUGMSG(SDHC_INTERRUPT_ZONE, (_T("SDHCControllerIst: Card interrupt!\n")));

				// Because SDIO Interrupt is level triggered, we are not able to clear
				// the status. The status should be cleared by the card
				// we just disable the interrupt from Interrupt Signal Register
				// and Interrupt Status Enable register, and indicate that 
				// the card is interrupting
				EnableSDIOInterrupts(FALSE);
				IndicateSlotStateChange(DeviceInterrupting);
			}

			// Card Detect Interrupt Handling
			if (wIntStatus & (NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL)) {
				WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,
						(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) &~(NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL)));
				WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,
						(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) &~(NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL)));
				do {
					WriteWord(
							SDHC_NORMAL_INT_STATUS,
							NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL);
				}while(ReadWord(SDHC_NORMAL_INT_STATUS) & (NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL));
				WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,
						(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | (NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL)));
				WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE,
						(ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | (NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL)));

				m_fCheckSlot = TRUE;
			}
		}
#ifdef _SMDK2450_CH0_EXTCD_
	} // The end of "if(intType == SDSLOT_INT_CARD_DETECTED)"
#endif

	if (m_fCheckSlot) {
		m_fCheckSlot = FALSE;
#ifdef _SMDK2450_CH0_EXTCD_
		// At this time, we have to validate the card present status.
		if((IsCardPresent() == TRUE) && (m_fCardPresent != TRUE))
#else	
			// check card inserted or removed
			DWORD dwPresentState = ReadDword(SDHC_PRESENT_STATE);
		if (dwPresentState & STATE_CARD_INSERTED)
#endif
		{
			DEBUGMSG(SDHC_INTERRUPT_ZONE, (TEXT("SDHCControllerIst - Card is Inserted! \n")));
			RETAILMSG(1, (TEXT("[HSMMC0] Card is Inserted! \n")));
			m_fFakeCardRemoval = FALSE;	// KYS
			if (m_fCardPresent == FALSE ) {
				Start();
				HandleInsertion();
			}
		}
#ifdef _SMDK2450_CH0_EXTCD_
		else if((IsCardPresent() == FALSE))
#else    
		else
#endif
		{
			DEBUGMSG(SDHC_INTERRUPT_ZONE, (TEXT("SDHCControllerIst - Card is Removed! \n")));
			RETAILMSG(1, (TEXT("[HSMMC0] Card is Removed! \n")));
			m_fFakeCardRemoval = FALSE;	// KYS
			if (m_fCardPresent) {
				HandleRemoval(TRUE);
			}
		}
	}
}
#endif  // !(BSP_TYPE == BSP_SMDK2443)


#ifdef _SMDK2450_CH0_EXTCD_
// New function can detect whether card is presented of HSMMC ch0 on SMDK2450.
BOOL CSDHCSlotBase::IsCardPresent()
{
	BOOL fRetVal;
	volatile S3C2450_IOPORT_REG *pIOPreg = NULL;
	pIOPreg = (volatile S3C2450_IOPORT_REG *)VirtualAlloc(0, sizeof(S3C2450_IOPORT_REG), MEM_RESERVE, PAGE_NOACCESS);
	if (pIOPreg == NULL) {
		RETAILMSG(1,(TEXT("[HSMMC0] GPIO registers is *NOT* allocated.\n")));
		return FALSE;
	}
	if (!VirtualCopy((PVOID)pIOPreg, (PVOID)(S3C2450_BASE_REG_PA_IOPORT >> 8),
				sizeof(S3C2450_IOPORT_REG), PAGE_PHYSICAL|PAGE_READWRITE|PAGE_NOCACHE)) {
		RETAILMSG(1,(TEXT("[HSMMC0] GPIO registers is *NOT* mapped.\n")));
		return FALSE;
	}

	if ( (pIOPreg->GPFDAT & (0x1<<1)) == 0 ) {
		fRetVal = TRUE;
	}	else {
		fRetVal = FALSE;
	}

	RETAILMSG(0,(TEXT("IsCardPresent() : fRetVal = %d  GPFDAT = 0x%x\n"), fRetVal, pIOPreg->GPFDAT));

	VirtualFree((PVOID) pIOPreg, 0, MEM_RELEASE);

	return fRetVal;
}
#endif


VOID 
CSDHCSlotBase::HandleRemoval(
		BOOL fCancelRequest
		)
{    
	m_fCardPresent = FALSE;
	m_fIsPowerManaged = FALSE;
	m_fSleepsWithPower = FALSE;
	m_fPowerUpDisabledInts = FALSE;
	m_f4BitMode = FALSE;
	m_cpsCurrent = D0;

	// Wake on SDIO interrupt must be set by the client
	m_bWakeupControl &= ~WAKEUP_INTERRUPT;

#if (BSP_TYPE == BSP_SMDK2443)

#elif (BSP_TYPE == BSP_SMDK2450)
	// To control the Data CRC error
	WORD wErrIntSignalEn = ReadWord(SDHC_ERROR_INT_SIGNAL_ENABLE);
	WORD wErrIntStatusEn = ReadWord(SDHC_ERROR_INT_STATUS_ENABLE);
	WORD wErrIntStatus = ReadWord(SDHC_ERROR_INT_STATUS);
	WriteWord(SDHC_ERROR_INT_SIGNAL_ENABLE, (wErrIntSignalEn & ~(0x20))); //Command and Data CRC error disable
	WriteWord(SDHC_ERROR_INT_STATUS_ENABLE, (wErrIntStatusEn & ~(0x20))); //Command and Data CRC error disable
#endif
	if (m_fSDIOInterruptsEnabled) {
		EnableSDIOInterrupts(FALSE);
	}

	IndicateSlotStateChange(DeviceEjected);

	// turn off clock and remove power from the slot
	SDClockOff();
	WriteByte(SDHC_POWER_CONTROL, 0);

	if (fCancelRequest) {
		// get the current request  
		PSD_BUS_REQUEST pRequest = GetAndLockCurrentRequest();

		if (pRequest != NULL) {
			DEBUGMSG(SDCARD_ZONE_WARN, 
					(TEXT("Card Removal Detected - Canceling current request: 0x%08X, command: %d\n"), 
					 pRequest, pRequest->CommandCode));
			DumpRequest(pRequest, SDHC_SEND_ZONE || SDHC_RECEIVE_ZONE);
			IndicateBusRequestComplete(pRequest, SD_API_STATUS_DEVICE_REMOVED);
		}
	}

	if (m_pbDmaBuffer) {
		DEBUGCHK(m_paDmaBuffer);
		FreePhysBuffer(m_pbDmaBuffer);
		m_pbDmaBuffer = NULL;
		m_paDmaBuffer = 0;

		// The Pegasus requires the following so that the next
		// insertion will work correctly.
		SoftwareReset(SOFT_RESET_CMD | SOFT_RESET_DAT);
		WriteDword(SDHC_SYSTEMADDRESS_LO, 0);
		WriteWord(SDHC_BLOCKSIZE, 0);
		WriteWord(SDHC_BLOCKCOUNT, 0);
#if (BSP_TYPE == BSP_SMDK2443)
		WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_DMA);

#elif (BSP_TYPE == BSP_SMDK2450)
		WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE, (ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) & ~(NORMAL_INT_STATUS_DMA)));
		WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE,(ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) & ~(NORMAL_INT_STATUS_DMA)));
		do {
			WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_DMA);
		}while(ReadWord(SDHC_NORMAL_INT_STATUS) & NORMAL_INT_STATUS_DMA);
		WriteWord(SDHC_NORMAL_INT_STATUS_ENABLE, (ReadWord(SDHC_NORMAL_INT_STATUS_ENABLE) | NORMAL_INT_STATUS_DMA));
		WriteWord(SDHC_NORMAL_INT_SIGNAL_ENABLE, (ReadWord(SDHC_NORMAL_INT_SIGNAL_ENABLE) | NORMAL_INT_STATUS_DMA));

		// To diable the Data CRC error interrupt
		WriteWord(SDHC_ERROR_INT_SIGNAL_ENABLE,0);  
		do
		{
			WriteWord(SDHC_ERROR_INT_STATUS,wErrIntStatus);
		}while(ReadWord(SDHC_ERROR_INT_STATUS));
		WriteWord(SDHC_ERROR_INT_SIGNAL_ENABLE,wErrIntSignalEn);
#endif
	}

	// 08.04.03 by KYS
	// Below code lines are needed for working as a mass storage device
	v_gBspArgs->g_SDCardState = CARD_REMOVED;
	SetEvent( v_gBspArgs->g_SDCardDetectEvent ); 
}


VOID 
CSDHCSlotBase::HandleInsertion(
		)
{
	DWORD dwClockRate = SD_DEFAULT_CARD_ID_CLOCK_RATE;

#if (BSP_TYPE == BSP_SMDK2443)

#elif (BSP_TYPE == BSP_SMDK2450)
	WORD wErrIntSignalEn = ReadWord(SDHC_ERROR_INT_SIGNAL_ENABLE);
	WORD wErrIntStatusEn = ReadWord(SDHC_ERROR_INT_STATUS_ENABLE);
#endif
	m_fCardPresent = TRUE;

	// Apply the initial voltage to the card.
	SetVoltage(GetMaxVddWindow());

	// Send at least 74 clocks to the card over the course of at least 1 ms
	// with allowance for power supply ramp-up time. (SD Phys Layer 6.4)
	// Note that power supply ramp-up time occurs in SetVoltage().
	RETAILMSG(0,(TEXT("++SetClockRate(&dwClockRate)\n")));
	SetClockRate(&dwClockRate);

	SDClockOn();
	DWORD dwSleepMs = (74 / (dwClockRate / 1000)) + 1;
	Sleep(dwSleepMs);

	SDClockOff();

	if (GetCapabilities().bits.DMA) {
		RETAILMSG(0,(TEXT("Use DMA\n")));
		PHYSICAL_ADDRESS SystemAddr = { 0 };
		PVOID pvBuffer = AllocPhysBuffer(CB_DMA_BUFFER, &SystemAddr.LowPart);        
		if (pvBuffer) {
			PHYSICAL_ADDRESS BusAddr;

			// Translate physical address to logical (bus-relative) address.
			BOOL fSuccess = TranslateSystemAddr(m_hBusAccess, m_interfaceType, 
					m_dwBusNumber, SystemAddr, &BusAddr);
			if (fSuccess) {
				RETAILMSG(0,(TEXT("Use DMA Success.\n")));				
				m_pbDmaBuffer= (PBYTE) pvBuffer;
				m_paDmaBuffer = BusAddr.LowPart;
			}
			else {
				// If we fail, we will simply fall back to PIO mode
				FreePhysBuffer(pvBuffer);
			}
		}
	}

	// Interrupts are not enabled on a newly inserted card.
	EnableSDIOInterrupts(FALSE);

	// Indicate device