sdiocontrollerbase.cpp

2440 SD卡驱动源码第二部分继续上传

            vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH;
        }


        //----- 6. If this is a data transfer, start the I/O operation; otherwise, finish the request -----
        if(pRequest->TransferClass == SD_COMMAND)
        {
            goto TRANSFER_DONE;
        }


        //----- 7. If this is a DMA transfer, we enable interrupts and wait for the DMA interrupt.  Otherwise, -----
        //         we use our polling routines to complete the I/O.
        if(m_bUseDMAForTransfer == FALSE)
        {

            //----- 8. Polling I/O, use our special routines to handle this request
            switch(pRequest->TransferClass)
            {
            case SD_READ:
                if(!PollingReceive(pRequest, m_dwNumBytesToTransfer))
                {
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:BusRequestHandler() - PollingReceive() failed\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:BusRequestHandler() - PollingReceive() failed\r\n")));		
                    goto TRANSFER_DONE;
                }
                break;

            case SD_WRITE:
                if(!PollingTransmit(pRequest, m_dwNumBytesToTransfer))
                {
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:BusRequestHandler() - PollingReceive() failed\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:BusRequestHandler() - PollingReceive() failed\r\n")));
                    goto TRANSFER_DONE;
                }
                break;
            }

            status = SD_API_STATUS_SUCCESS;
        }
		
      else
        {

		RETAILMSG(WGH_SDCARD, (TEXT("TransferIstThread(): DMA------SD_WRITE---------\r\n")));
            //----- 9. For WRITE requests, be sure to copy the write data from the caller's buffer into DMA memory-----
            if(pRequest->TransferClass == SD_WRITE)
            {

		 RETAILMSG(FUSQ_DEBUG, (TEXT("TransferIstThread(): pRequest->TransferClass == SD_WRITE---------\r\n")));
		 
                BOOL fNoException;
                DEBUGCHK(m_dwNumBytesToTransfer <= MAXIMUM_DMA_TRANSFER_SIZE);
            
                SD_SET_PROC_PERMISSIONS_FROM_REQUEST( pRequest ) 
			{               
                    fNoException = SDPerformSafeCopy( m_pDMABuffer, pRequest->pBlockBuffer, m_dwNumBytesToTransfer );
                     } 
			SD_RESTORE_PROC_PERMISSIONS();

                if (fNoException == FALSE) 
			{
			RETAILMSG(FUSQ_DEBUG, (TEXT("TransferIstThread(): fNoException == FALSE---SD_WRITE-------\r\n")));
                    status = SD_API_STATUS_ACCESS_VIOLATION;
                    goto TRANSFER_DONE;
                }
            }

            //----- 10. DMA I/O, enable the DMA channel -----
            Enable_SDIO_DMA_Channel();

            //----- 11. Wait for a DMA interrupt -----
            // first estimate the maximum DMA transfer time
            DWORD dwDelay = m_dwNumBytesToTransfer * m_dwDMATransferTimeoutFactor / ( m_dwClockRate / 2000 );
            if( Get_SDI_Bus_Width() != WIDE_BUS_ENABLE )
            {
                dwDelay *= 4;
            }
            dwDelay += m_dwDMATransferTimeoutConstant;

            // now wait for the interrupt
            if(WaitForSingleObject(m_hDMAInterruptEvent, dwDelay) != WAIT_OBJECT_0)
            {
                DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("TransferIstThread(): Wait Failed!\r\n")));
		RETAILMSG(WGH_SDCARD, (TEXT("TransferIstThread(): Wait Failed!\r\n")));		
                Stop_SDIO_DMA_Channel();
                status = SD_API_STATUS_DATA_TIMEOUT;
                goto TRANSFER_DONE;
            }

            if(m_bDriverShutdown) 
            {
                DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:TransferIstThread(): Thread Exiting\r\n")));
		RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:TransferIstThread(): Thread Exiting\r\n")));
                return FALSE;
            }

            //----- 12. ACK the DMA completion interrupt and stop the DMA channel -----
            InterruptDone(m_dwDMASysIntr);
            Stop_SDIO_DMA_Channel();

            DWORD dwWaitCount = 0;
            //----- 13. Wait until the I/O transfer is complete -----
            while(!(vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_FINISHED))
            {
                dwWaitCount++;
                if( dwWaitCount > WAIT_TIME )
                {
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - timeout waiting for DMA transfer completion!\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDHControllerIstThread() - timeout waiting for DMA transfer completion!\r\n")));
                    status = SD_API_STATUS_DATA_TIMEOUT;
                    goto TRANSFER_DONE;
                }

                if( !IsCardPresent() )
                {
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Card ejected!\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDHControllerIstThread() - Card ejected!\r\n")));		
                    status = SD_API_STATUS_DEVICE_REMOVED;
                    goto TRANSFER_DONE;
                }
                if((vm_pSDIReg->SDIFSTA & FIFO_FAIL_ERROR))
                {
                    vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH;
                    vm_pSDIReg->SDIFSTA &= FIFO_FAIL_ERROR;
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - FIFO Error waiting for DMA transfer completion!\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDHControllerIstThread() - FIFO Error waiting for DMA transfer completion!\r\n")));
                    status = SD_API_STATUS_DATA_ERROR;
                    goto TRANSFER_DONE;
                }
                if((vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_CRC_ERROR))
                {
                    vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_TRANSMIT_CRC_ERROR;
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Transmit CRC Error waiting for DMA transfer completion!\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDHControllerIstThread() - Transmit CRC Error waiting for DMA transfer completion!\r\n")));
                    status = SD_API_STATUS_DATA_ERROR;
                    goto TRANSFER_DONE;
                }
                if((vm_pSDIReg->SDIDSTA & DATA_RECEIVE_CRC_ERROR))
                {
                    vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_RECEIVE_CRC_ERROR;
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Receive CRC Error waiting for DMA transfer completion!\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDHControllerIstThread() - Receive CRC Error waiting for DMA transfer completion!\r\n")));
                    status = SD_API_STATUS_DATA_ERROR;
                    goto TRANSFER_DONE;
                }
                if((vm_pSDIReg->SDIDSTA & DATA_TIME_OUT))
                {
                    vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_TIME_OUT;
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Data timeout waiting for DMA transfer completion!\r\n")));
			RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDHControllerIstThread() - Data timeout waiting for DMA transfer completion!\r\n")));
                    status = SD_API_STATUS_DATA_TIMEOUT;
                    goto TRANSFER_DONE;
                }
            }

            vm_pSDIReg->SDIDSTA = DATA_TRANSMIT_FINISHED;

            //----- 14. For READ requests, be sure to copy the data read from the DMA memory into the caller's buffer -----
            if(pRequest->TransferClass == SD_READ)
            {
            	RETAILMSG(FUSQ_DEBUG, (TEXT("TransferIstThread(): pRequest->TransferClass == SD_READ---------\r\n")));
                BOOL fNoException;
                DEBUGCHK(m_dwNumBytesToTransfer <= MAXIMUM_DMA_TRANSFER_SIZE);
            
                SD_SET_PROC_PERMISSIONS_FROM_REQUEST( pRequest ) {               
                    fNoException = SDPerformSafeCopy( pRequest->pBlockBuffer, m_pDMABuffer, m_dwNumBytesToTransfer );
                } SD_RESTORE_PROC_PERMISSIONS();

                if (fNoException == FALSE) {
					RETAILMSG(FUSQ_DEBUG, (TEXT("TransferIstThread(): pRequest->TransferClass == SD_READ---FASLE------\r\n")));
                    status = SD_API_STATUS_ACCESS_VIOLATION;
                    goto TRANSFER_DONE;
                }
            }

            //----- 15. I/O is complete.  Finish the bus request! -----
            status = SD_API_STATUS_SUCCESS;
        }

TRANSFER_DONE:
        if( !( Is_SDIO_Interrupt_Enabled() && ( Get_SDI_Bus_Width() == WIDE_BUS_ENABLE ) ) )
        {
            Stop_SDI_Clock();
			RETAILMSG(WGH_SDCARD,(TEXT("TransferIstThread(): SDHCD: Clock stopped...--------Is_SDIO_Interrupt_Enabled---fail----------Get_SDI_Bus_Width() == WIDE_BUS_ENABLE-- \r\n")));
			
        }
        m_CurrentState = CommandComplete;   
        SDHCDIndicateBusRequestComplete(m_pHCContext, pRequest, status);
        pRequest = NULL;
    }

    return TRUE;
}



///////////////////////////////////////////////////////////////////////////////
//  CSDIOControllerBase::IOInterruptIstThread - IST thread for SDIO Interrupts
//  Input:  pHCDevice - the controller instance
//  Output: 
//  Return: thread exit code
//  Notes:  
///////////////////////////////////////////////////////////////////////////////
DWORD CSDIOControllerBase::IOInterruptIstThread()
{

    if( m_nSDIOIstThreadPriority != 0xffffffff && !CeSetThreadPriority( GetCurrentThread(), m_nSDIOIstThreadPriority ) ) 
    {
        DEBUGMSG(SDCARD_ZONE_WARN,(TEXT("SDHCDriver:SDIOInterruptIstThread(): warning, failed to set CEThreadPriority \r\n")));
	RETAILMSG(WGH_SDCARD,(TEXT("SDHCDriver:SDIOInterruptIstThread(): warning, failed to set CEThreadPriority \r\n")));	
    }
    
    for(;;)
    {
        //----- 1. Wait for a SDIO interrupt -----
        if(WaitForSingleObject(m_hSDIOInterruptEvent, INFINITE) != WAIT_OBJECT_0)
        {
            DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:SDIOInterruptIstThread(): Wait Failed!\r\n")));
		RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDIOInterruptIstThread(): Wait Failed!\r\n")));
		RETAILMSG(FUSQ_DEBUG, (TEXT("SDHCD:SDIOInterruptIstThread(): Wait Failed!-------------\r\n")));	
            return FALSE;
        }
        RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDIOInterruptIstThread(): Wait SECCESS\r\n")));	
        if(m_bDriverShutdown) 
        {
            DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:SDIOInterruptIstThread(): Thread Exiting\r\n")));
		RETAILMSG(WGH_SDCARD, (TEXT("SDHCD:SDIOInterruptIstThread(): Thread Exiting\r\n")));
		RETAILMSG(FUSQ_DEBUG, (TEXT("SDHCD:SDIOInterruptIstThread(): Thread Exiting------------\r\n")));		
            return FALSE;
        }

        if(m_bDevicePresent && IsCardPresent())
        {
            // indicate that the card is interrupting
            SDHCDIndicateSlotStateChange(m_pHCContext, 0, DeviceInterrupting);
            RETAILMSG(FUSQ_DEBUG, (TEXT("SDHCDIndicateSlotStateChange():------------\r\n")));
        }

        // NOTE: SDHCDIndicateSlotStateChange() is called above to inform the bus driver
        //       that the SDIO card has generated an interrupt.  After this notification, the
        //       bus driver will eventually call back SDHCDSlotOptionHandler() to enable/disable
        //       and ACK the SDIO interrupt as necessary.  Consequently, we DO NOT acknowledge 
        //       the interrupt here...

    }
}



///////////////////////////////////////////////////////////////////////////////
//  CSDIOControllerBase::CardDetectThread - thread for card insert/removal detection
//  Input:  
//  Output: 
//
//  Return: thread exit code
///////////////////////////////////////////////////////////////////////////////
DWORD CSDIOControllerBase::CardDetectThread()
{
    BOOL  bSlotStateChanged = FALSE;
    DWORD dwWaitResult  = WAIT_TIMEOUT;

    if( m_nCardDetectIstThreadPriority != 0xffffffff && !CeSetThreadPriority( GetCurrentThread(), m_nCardDetectIstThreadPriority ) )
    {
        DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCDriver:CardDetectThread(): warning, failed to set CEThreadPriority \r\n")));
	RETAILMSG(WGH_SDCARD, (TEXT("SDHCDriver:CardDetectThread(): warning, failed to set CEThreadPriority \r\n")));
    }

    for(;;)
    {
        //----- 1. Wait for the next insertion/removal interrupt -----
        dwWaitResult = WaitForSingleObject(m_hCardInsertInterruptEvent, m_dwPollingTimeout);
        
        if(m_bDriverShutdown) 
        {
            DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCardDetectIstThread: Thread Exiting\r\n")));
		RETAILMSG(WGH_SDCARD, (TEXT("SDHCardDetectIstThread: Thread Exiting\r\n")));
            return FALSE;
        }
			

        // Test if a card is present
        
        if( IsCardPresent() == m_bDevicePresent )
        {
            bSlotStateChanged = FALSE;
            
        }
        else
        {
            bSlotStateChanged = TRUE;
            RETAILMSG(FUSQ_DEBUG, (TEXT("---------------SD CARD SLOT CHANCHED ---\r\n")));
        }