sdmemcardio.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

    } 

        // multi-block writes use the optimized command
        // we have to auto issue a stop command though
#ifdef __MMC_SPEC_4_2_SUPPORT__    
	if( 0 == pMemCard->bAccessMode ) 
#endif 
		return SDMemDoBusRequest( pMemCard, 
                              SD_CMD_READ_MULTIPLE_BLOCK, 
                              StartBlock * SD_BLOCK_SIZE, 
                              SD_READ, 
                              ResponseR1, 
                              NumBlocks, 
                              SD_BLOCK_SIZE, 
                              pBuffer, 
                              SD_AUTO_ISSUE_CMD12);  // auto issue CMD12 
#ifdef __MMC_SPEC_4_2_SUPPORT__ 
	else 
		return SDMemDoBusRequest( pMemCard, 
                              SD_CMD_READ_MULTIPLE_BLOCK, 
                              StartBlock, 
                              SD_READ, 
                              ResponseR1, 
                              NumBlocks, 
                              SD_BLOCK_SIZE, 
                              pBuffer, 
                              SD_AUTO_ISSUE_CMD12); 
#endif  
}

///////////////////////////////////////////////////////////////////////////////
//  SDMemWriteMultiple  - Write multiple 512 byte blocks of data to card
//  Input:  pMemCard    - SD memory card structure
//          StartBlock  - Starting 512 byte block for write
//          NumBlocks   - Number of blocks to write
//          pBuffer     - Pointer to buffer containing write data
//  Output:
//  Return:  win32 status code
//  Notes:
///////////////////////////////////////////////////////////////////////////////
DWORD SDMemWriteMultiple( PSD_MEMCARD_INFO pMemCard,
                          LONG             StartBlock,
                          LONG             NumBlocks,
                          PUCHAR           pBuffer )
{

    DEBUGMSG(SDMEM_ZONE_CARD_IO, (TEXT("SDMemWriteMultiple: Writing blocks %d-%d\r\n"), StartBlock, StartBlock+NumBlocks-1));

    if( pMemCard->SingleBlockWrites || (NumBlocks == 1)) {
        DEBUGMSG(SDMEM_ZONE_CARD_IO, (TEXT("SDMemWriteMultiple: Sending request to SDMemWriteUsingSingleBlocks\r\n")));
        
        return SDMemWriteUsingSingleBlocks( pMemCard,
                                            StartBlock,
                                            NumBlocks,
                                            pBuffer );
    }

        // high capacity cards just take the block offset.  standard cards
        // take a byte offset.
    if (!pMemCard->HighCapacity) {
        if (ULONG_MAX / SD_BLOCK_SIZE < StartBlock) {
            ASSERT(FALSE);
            return ERROR_INVALID_PARAMETER;
        }

        //StartBlock *= SD_BLOCK_SIZE;
    }

        // issue multi-block write request
#ifdef __MMC_SPEC_4_2_SUPPORT__  
	if( 0 == pMemCard->bAccessMode ) 
#endif 
		return SDMemDoBusRequest( pMemCard, 
                              SD_CMD_WRITE_MULTIPLE_BLOCK, 
                              StartBlock * SD_BLOCK_SIZE, 
                              SD_WRITE, 
                              ResponseR1, 
                              NumBlocks, 
                              SD_BLOCK_SIZE, 
                              pBuffer, 
                              SD_AUTO_ISSUE_CMD12); 
#ifdef __MMC_SPEC_4_2_SUPPORT__ 
	else 
		return SDMemDoBusRequest( pMemCard, 
                                SD_CMD_WRITE_MULTIPLE_BLOCK, 
                                StartBlock, 
                                SD_WRITE, 
                                ResponseR1, 
                                NumBlocks, 
                                SD_BLOCK_SIZE, 
                                pBuffer, 
                                SD_AUTO_ISSUE_CMD12); 
#endif 
}

///////////////////////////////////////////////////////////////////////////////
//  SDMemWriteUsingSingleBlocks  - Write using only single block commands
//  Input:  pMemCard    - SD memory card structure
//          StartBlock  - Starting 512 byte block for write
//          NumBlocks   - Number of blocks to write
//          pBuffer     - Pointer to buffer containing write data
//  Output:
//  Return: win32 status code
//  Notes:
///////////////////////////////////////////////////////////////////////////////
DWORD SDMemWriteUsingSingleBlocks( PSD_MEMCARD_INFO pMemCard,
                                   LONG             StartBlock,
                                   LONG             NumBlocks,
                                   PUCHAR           pBuffer )
{
    DWORD status = SD_API_STATUS_SUCCESS;   // intermediate win32 status
    LONG  block;    // block count

    if (StartBlock + NumBlocks < StartBlock) {
        // Check for arithmetic overflow
        return ERROR_INVALID_PARAMETER;
    }

    if (!pMemCard->HighCapacity) {
        if (ULONG_MAX / SD_BLOCK_SIZE < StartBlock + NumBlocks) {
            return ERROR_INVALID_PARAMETER;
        }
    }

        // Split write operation into single blocks
    for( block=0; block<NumBlocks; block++ ) {
        DEBUGMSG(SDMEM_ZONE_CARD_IO, (TEXT("SDMemWriteUsingSingleBlocks: Writing block %d\r\n"), StartBlock+block));
            // issue single block write request
#ifdef __MMC_SPEC_4_2_SUPPORT__ 
	if( 0 == pMemCard->bAccessMode ) //check Address Access Mode. 
#endif 
		status = SDMemDoBusRequest( pMemCard, 
                                    SD_CMD_WRITE_BLOCK, 
                                    (StartBlock+block) * SD_BLOCK_SIZE, 
                                    SD_WRITE, 
                                    ResponseR1, 
                                    1, 
                                    SD_BLOCK_SIZE, 
                                    pBuffer + (block*SD_BLOCK_SIZE), 
                                    0); 
#ifdef __MMC_SPEC_4_2_SUPPORT__ 
	else	 if( 1 == pMemCard->bAccessMode ) //check if a card is moviNAND
		status = SDMemDoBusRequest( pMemCard, 
                                      SD_CMD_WRITE_MULTIPLE_BLOCK, 
                                      (StartBlock+block), 
                                      SD_WRITE, 
                                      ResponseR1, 
                                      1, 
                                      SD_BLOCK_SIZE, 
                                      pBuffer + (block*SD_BLOCK_SIZE), 
                                      SD_AUTO_ISSUE_CMD12); 
                                      
	else	 if( 2 == pMemCard->bAccessMode ) //check if a card is SDHC
		status = SDMemDoBusRequest( pMemCard, 
                                      SD_CMD_WRITE_BLOCK, 
                                      (StartBlock+block), 
                                      SD_WRITE, 
                                      ResponseR1, 
                                      1, 
                                      SD_BLOCK_SIZE, 
                                      pBuffer + (block*SD_BLOCK_SIZE), 
                                      0); 
                                      
#endif         
        if( ERROR_SUCCESS != status )
            break;
    }

    return status;
}

#if 0
///////////////////////////////////////////////////////////////////////////////
//  SDMemDoErase - Erase a contiguous set of blocks
//  Input:  pMemCard    - SD memory card structure
//          StartBlock  - Starting 512 byte block for write
//          NumBlocks   - Number of blocks to write
//  Output:
//  Return: win32 status code
//  Notes:
///////////////////////////////////////////////////////////////////////////////
DWORD SDMemDoErase( PSD_MEMCARD_INFO pHandle,
                    LONG             StartBlock,
                    LONG             NumBlocks )
{
    DWORD dwStatus = ERROR_SUCCESS;

    DEBUGMSG(SDMEM_ZONE_CARD_IO, (TEXT("SDMemDoErase: Erasing {%u, %u}\r\n"),
        StartBlock, (StartBlock + NumBlocks)));
    
    // Specify starting block
    dwStatus = SDMemDoBusRequest(
        pHandle,
        SD_CMD_ERASE_WR_BLK_START,
        StartBlock,
        SD_COMMAND,
        ResponseR1,
        0,
        0,
        NULL,
        0
        );
    if (dwStatus != ERROR_SUCCESS) {
        goto EXIT;
    }

    // Specify ending block
    dwStatus = SDMemDoBusRequest(
        pHandle,
        SD_CMD_ERASE_WR_BLK_END,
        StartBlock + NumBlocks,
        SD_COMMAND,
        ResponseR1,
        0,
        0,
        NULL,
        0
        );
    if (dwStatus != ERROR_SUCCESS) {
        goto EXIT;
    }

    // Erase
    dwStatus = SDMemDoBusRequest(
        pHandle,
        SD_CMD_ERASE,
        0,
        SD_COMMAND,
        ResponseR1b,
        0,
        0,
        NULL,
        0
        );
    if (dwStatus != ERROR_SUCCESS) {
        goto EXIT;
    }    

EXIT:;
    if (dwStatus != ERROR_SUCCESS) {
        DEBUGMSG(SDMEM_ZONE_CARD_IO, (TEXT("SDMemDoErase: Failed\r\n")));
    }

    return dwStatus;
}

#endif

// DO NOT REMOVE --- END EXTERNALLY DEVELOPED SOURCE CODE ID --- DO NOT REMOVE