sdmemcardio.cpp

6410BSP3

  DEBUGMSG( SDMEM_ZONE_CARD_IO, (TEXT("SDMemReadMultiple: Reading blocks %d-%d\r\n"), 
        StartBlock, StartBlock+NumBlocks-1));
  // 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;
  }

  // perform block read request
  if (NumBlocks == 1) {
    // for single blocks 
    return SDMemDoBusRequest( pMemCard,
        SD_CMD_READ_SINGLE_BLOCK,
        StartBlock,
        SD_READ,
        ResponseR1,
        NumBlocks,
        SD_BLOCK_SIZE,
        pBuffer,
        0);  

  }
  // multi-block writes use the optimized command
  // we have to auto issue a stop command though
#ifdef _FOR_MOVI_NAND_
  /**
   * 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_READ_MULTIPLE_BLOCK,
        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_
  /**
   * 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_
  /**
   * 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;
}

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