sdmemcardio.cpp

SMDK2416_BSP

	                              NumBlocks,
	                              SD_BLOCK_SIZE,
	                              pBuffer,
	                              SD_MOVINAND_PRE_DEFINE); 	
	}

/*************************************************************************/    
#endif
    return SDMemDoBusRequest( pMemCard,
                              SD_CMD_READ_MULTIPLE_BLOCK,
                              StartBlock,
                              SD_READ,
                              ResponseR1,
                              NumBlocks,
                              SD_BLOCK_SIZE,
                              pBuffer,
                              SD_AUTO_ISSUE_CMD12);  // auto issue CMD12
 
}

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

#ifdef _FOR_MOVI_NAND_
/*************************************************************************/
/****** Date : 07.05.28                                         	******/
/****** Developer : HS.JANG											******/
/****** Description : moviNAND dose not support Single-Block write 	******/
/*************************************************************************/
	if ( pMemCard->IsHSMMC == TRUE )
	{    
	}
	else

/*************************************************************************/    
#endif 
	{
	    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 _FOR_MOVI_NAND_
/*************************************************************************/
/****** Date : 07.05.28                                         	******/
/****** Developer : HS.JANG											******/
/****** Description : To use Pre-Define. Set the flag as 	******/
/******               for moviANND. If you do not use moviNAND		******/
/******               Do NOT define FOR_MOVI_NAND					******/
/*************************************************************************/
	if ( pMemCard->IsHSMMC == TRUE )
	{    
		return SDMemDoBusRequest( pMemCard,
                              SD_CMD_WRITE_MULTIPLE_BLOCK,
                              StartBlock,
                              SD_WRITE,
                              ResponseR1,
                              NumBlocks,
                              SD_BLOCK_SIZE,
                              pBuffer,
                              SD_MOVINAND_PRE_DEFINE);
	}

/*************************************************************************/    
#endif 
    return SDMemDoBusRequest( pMemCard,
                              SD_CMD_WRITE_MULTIPLE_BLOCK,
                              StartBlock,
                              SD_WRITE,
                              ResponseR1,
                              NumBlocks,
                              SD_BLOCK_SIZE,
                              pBuffer,
                              SD_AUTO_ISSUE_CMD12);
                             
}

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

        DWORD dwOffset = StartBlock + block;
        if (!pMemCard->HighCapacity) {
            dwOffset *= SD_BLOCK_SIZE;
        }
        
            // issue single block write request
        status = SDMemDoBusRequest( pMemCard,
                                    SD_CMD_WRITE_BLOCK,
                                    dwOffset,
                                    SD_WRITE,
                                    ResponseR1,
                                    1,
                                    SD_BLOCK_SIZE,
                                    pBuffer + (block*SD_BLOCK_SIZE),
                                    0);
        
        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