sdhcslot.cpp

s3c2450 bsp for wince 5.0 经验证,完全没问题

      if (wIntStatus & NORMAL_INT_STATUS_DMA) {
        WriteWord(SDHC_NORMAL_INT_STATUS, 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_STATUS, 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_STATUS, 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_STATUS, 
          NORMAL_INT_STATUS_TRX_COMPLETE | NORMAL_INT_STATUS_DMA);
      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);
      //WriteWord(SDHC_NORMAL_INT_STATUS, NORMAL_INT_STATUS_CARD_INT);
      //RETAILMSG(1,(TEXT("SDHC_NORMAL_INT_STATUS=0x%X\n"),ReadWord(SDHC_NORMAL_INT_STATUS)));			
      IndicateSlotStateChange(DeviceInterrupting);
    }

    // Card Detect Interrupt Handling
    if (wIntStatus & (NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL)) {
      WriteWord(
          SDHC_NORMAL_INT_STATUS,
          NORMAL_INT_STATUS_CARD_INSERTION | NORMAL_INT_STATUS_CARD_REMOVAL);
      m_fCheckSlot = TRUE;
    }
  }			
  if (m_fCheckSlot) {
    m_fCheckSlot = FALSE;

    // check card inserted or removed
    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)
VOID 
CSDHCSlotBase::HandleInterrupt(
    )
{
  Validate();

  WORD wIntStatus = ReadWord(SDHC_NORMAL_INT_STATUS);
  //  if(g_initialInsertion != 1) {
  //    while(( wIntStatus=ReadWord(SDHC_NORMAL_INT_STATUS)) == 0);
  //  }

  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("1. 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;
    }
  }

  if (m_fCheckSlot) {
    m_fCheckSlot = FALSE;

    // check card inserted or removed
    DWORD dwPresentState = ReadDword(SDHC_PRESENT_STATE);
    if (dwPresentState & STATE_CARD_INSERTED) {
      DEBUGMSG(SDHC_INTERRUPT_ZONE, (TEXT("SDHCControllerIst - Card is Inserted! \n")));
      RETAILMSG(1, (TEXT("[HSMMC1] Card is Inserted! \n")));
      m_fFakeCardRemoval = FALSE;	// KYS
      if (m_fCardPresent == FALSE ) {
        Start();
        HandleInsertion();
      }
    }
    else {
      DEBUGMSG(SDHC_INTERRUPT_ZONE, (TEXT("SDHCControllerIst - Card is Removed! \n")));
      RETAILMSG(1, (TEXT("[HSMMC1] Card is Removed! \n")));
      m_fFakeCardRemoval = FALSE;	// KYS
      if (m_fCardPresent) {
        HandleRemoval(TRUE);
      }
    }
  }
}
#endif  // !(BSP_TYPE == BSP_SMDK2443)


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);

  g_initialInsertion = 0;
#endif
  m_fCardPresent = TRUE;

  // Apply the initial voltage to the c