sdmemcardio.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

	                              StartBlock,
	                              SD_READ,
	                              ResponseR1,
	                              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