DRESULT disk_read ( BYTE drv, /* Physical drive nmuber (0..) */ BYTE *buff, /* Data buffer to store read data */ DWORD sector, /* Sector address (LBA) */ BYTE count /* Number of sectors to read (1..255) */ ) { if(count==1) { err1 = SD_ReadBlock( &buff[0], sector , SECTOR_SIZE ); SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } else { err1 = SD_ReadMultiBlocks( &buff[0] , sector ,SECTOR_SIZE , count ); SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } if( err1 == SD_OK) return RES_OK; else return RES_ERROR; }
/** * @brief Tests the SD card Single Blocks operations. * @param None * @retval None */ static void SD_SingleBlockTest(void) { SD_Error status; /*---------------Block Read/Write----------------*/ /* Fill the buffer to send */ Fill_Buffer(aBuffer_Block_Tx, BLOCK_SIZE, 0x320F); /* Write Block of 512 bytes on address 0 */ status = SD_WriteBlock(aBuffer_Block_Tx, 0x00, BLOCK_SIZE); /* check if the Transfer finished */ status = SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); if(status == SD_OK) { /* Read Block of 512 bytes on address 0 */ status = SD_ReadBlock(aBuffer_Block_Rx, 0x00, BLOCK_SIZE); /* check if the Transfer finished */ status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } /* Check the correctness of written data */ if(status == SD_OK) { TransferStatus1 = Buffercmp(aBuffer_Block_Tx, aBuffer_Block_Rx,BLOCK_SIZE); } if(TransferStatus1 == PASSED) printf("SD single block test passed!\n\r"); }
/** * @brief Tests the SD card Multiple Blocks operations. * @param None * @retval None */ static void SD_MultiBlockTest(void) { SD_Error status; /* Fill the buffer to send */ Fill_Buffer(aBuffer_MultiBlock_Tx, MULTI_BUFFER_SIZE, 0x0); /* Write Multiple Block of many bytes on address 0 */ status = SD_WriteMultiBlocksFIXED(aBuffer_MultiBlock_Tx, 0, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* check if the Transfer finished */ status = SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); if(status == SD_OK) { /* Read Block of many bytes from address 0 */ status = SD_ReadMultiBlocksFIXED(aBuffer_MultiBlock_Rx, 0, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* check if the Transfer finished */ status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } /* Check the correctness of written data */ if(status == SD_OK) { TransferStatus2 = Buffercmp(aBuffer_MultiBlock_Tx, aBuffer_MultiBlock_Rx,MULTI_BUFFER_SIZE); } if(TransferStatus2 == PASSED) printf("SD Multiple block test passed!\n\r"); }
DRESULT disk_read ( BYTE pdrv, /* Physical drive nmuber to identify the drive */ BYTE *buff, /* Data buffer to store read data */ DWORD sector, /* Sector address in LBA */ UINT count /* Number of sectors to read */ ) { if(count>1) { SD_ReadMultiBlocks(buff, sector*BLOCK_SIZE, BLOCK_SIZE, count); // check transfer finished SD_WaitReadOperation(); // wait the DMA transfer finished while(SD_GetStatus() != SD_TRANSFER_OK); } else { SD_ReadBlock(buff, sector*BLOCK_SIZE, BLOCK_SIZE); // check transfer finished SD_WaitReadOperation(); // wait the DMA transfer finished while(SD_GetStatus() != SD_TRANSFER_OK); } return RES_OK; }
DRESULT disk_write ( BYTE pdrv, /* Physical drive nmuber to identify the drive */ const BYTE *buff, /* Data to be written */ DWORD sector, /* Sector address in LBA */ UINT count /* Number of sectors to write */ ) { if(count>1) { SD_WriteMultiBlocks((uint8_t *)buff, sector*BLOCK_SIZE, BLOCK_SIZE, count); // check transfer finished SD_WaitWriteOperation(); // wait the DMA transfer finished while(SD_GetStatus() != SD_TRANSFER_OK); } else { SD_WriteBlock((uint8_t *)buff, sector*BLOCK_SIZE, BLOCK_SIZE); // check transfer finished SD_WaitReadOperation(); // wait the DMA transfer finished while(SD_GetStatus() != SD_TRANSFER_OK); } return RES_OK; }
DRESULT disk_write ( BYTE drv, /* Physical drive nmuber (0..) */ const BYTE *buff, /* Data to be written */ DWORD sector, /* Sector address (LBA) */ BYTE count /* Number of sectors to write (1..255) */ ) { //memset(buff2, 0, sizeof(buff2)); if(count==1) { //memcpy(buff2,buff,SECTOR_SIZE); err1 = SD_WriteBlock((uint8_t *)(&buff[0]),sector ,SECTOR_SIZE); SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } else { //memcpy(buff2,buff,SECTOR_SIZE * count); err1 = SD_WriteMultiBlocks((uint8_t *)(&buff[0]),sector ,SECTOR_SIZE,count); SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } if( err1 == SD_OK) return RES_OK; else return RES_ERROR; }
DRESULT disk_read ( BYTE drv, /* Physical drive nmuber (0..) */ BYTE *buff, /* Data buffer to store read data */ DWORD sector, /* Sector address (LBA) */ BYTE count /* Number of sectors to read (1..255) */ ) { u8 res=0; if (!count)return RES_PARERR;//count不能等于0,否则返回参数错误 switch(drv) { case SD_CARD://SD卡 if (count > 1) { SD_ReadMultiBlocks(buff, sector*BLOCK_SIZE, BLOCK_SIZE, count); /* Check if the Transfer is finished */ SD_WaitReadOperation(); //循环查询dma传输是否结束 /* Wait until end of DMA transfer */ while(SD_GetStatus() != SD_TRANSFER_OK); } else { SD_ReadBlock(buff, sector*BLOCK_SIZE, BLOCK_SIZE); /* Check if the Transfer is finished */ SD_WaitReadOperation(); //循环查询dma传输是否结束 /* Wait until end of DMA transfer */ while(SD_GetStatus() != SD_TRANSFER_OK); } break; case EX_FLASH://外部flash for(;count>0;count--) { SPI_Flash_Read(buff,sector*BLOCK_SIZE,BLOCK_SIZE); sector++; buff+=BLOCK_SIZE; } res=0; break; default: res=1; } //处理返回值,将SPI_SD_driver.c的返回值转成ff.c的返回值 if(res==0x00)return RES_OK; else return RES_ERROR; }
DRESULT disk_write ( BYTE drv, /* Physical drive nmuber (0..) */ const BYTE *buff, /* Data to be written */ DWORD sector, /* Sector address (LBA) */ BYTE count /* Number of sectors to write (1..255) */ ) { u8 res=0; if (!count)return RES_PARERR;//count不能等于0,否则返回参数错误 switch(drv) { case SD_CARD://SD卡 if (count > 1) { SD_WriteMultiBlocks((uint8_t *)buff, sector*BLOCK_SIZE, BLOCK_SIZE, count); /* Check if the Transfer is finished */ SD_WaitWriteOperation(); //等待dma传输结束 while(SD_GetStatus() != SD_TRANSFER_OK); //等待sdio到sd卡传输结束 } else { SD_WriteBlock((uint8_t *)buff,sector*BLOCK_SIZE, BLOCK_SIZE); /* Check if the Transfer is finished */ SD_WaitWriteOperation(); //等待dma传输结束 while(SD_GetStatus() != SD_TRANSFER_OK); //等待sdio到sd卡传输结束 } break; case EX_FLASH://外部flash for(;count>0;count--) { SPI_Flash_Write((u8*)buff,sector*BLOCK_SIZE,BLOCK_SIZE); sector++; buff+=BLOCK_SIZE; } res=0; break; default: res=1; } //处理返回值,将SPI_SD_driver.c的返回值转成ff.c的返回值 if(res == 0x00)return RES_OK; else return RES_ERROR; }
DRESULT disk_read ( BYTE drv, /* Physical drive number (0) */ BYTE *buff, /* Pointer to the data buffer to store read data */ DWORD sector, /* Start sector number (LBA) */ BYTE count /* Sector count (1..255) */ ) { uint32_t timeout = 100000; SD_Error sdstatus = SD_OK; SD_ReadMultiBlocks((BYTE *)buff, (uint32_t )(sector * 512), 512, count); /* Check if the Transfer is finished */ sdstatus = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK) { if (timeout-- == 0) { return RES_ERROR; } } if (sdstatus == SD_OK) { return RES_OK; } return RES_NOTRDY; }
/******************************************************************************* * Function Name : MAL_Read * Description : Read sectors * Input : None * Output : None * Return : Buffer pointer *******************************************************************************/ uint16_t MAL_Read(uint8_t lun, uint32_t Memory_Offset, uint32_t *Readbuff, uint16_t Transfer_Length) { switch (lun) { case 0: // SD_ReadMultiBlocks((uint8_t*)Readbuff, Memory_Offset, Transfer_Length, 1); SD_ReadBlock((uint8_t*)Readbuff, Memory_Offset, Transfer_Length); Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK) { } // Status = SD_WaitWriteOperation(); // while(SD_GetStatus() != SD_TRANSFER_OK); if ( Status != SD_OK ) { return MAL_FAIL; } break; // case 1: // NAND_Read(Memory_Offset, Readbuff, Transfer_Length); // ; // break; default: return MAL_FAIL; } return MAL_OK; }
/** * @brief check whether the medium is ready * @param lun : logical unit number * @retval Status */ int8_t STORAGE_IsReady (uint8_t lun) { #ifndef USE_STM3210C_EVAL static int8_t last_status = 0; if(last_status < 0) { SD_Init(); last_status = 0; } if(SD_GetStatus() != 0) { last_status = -1; return (-1); } #else if( SD_Init() != 0) { return (-1); } #endif return (0); }
/** * @brief Tests the SD card erase operation. * @param None * @retval None */ static void SD_EraseTest(void) { SD_Error status = SD_OK; /*---------------Block Erase----------------*/ /* Erase NumberOfBlocks Blocks of WRITE_BL_LEN(512 Bytes) */ status = SD_Erase(0x00, (BLOCK_SIZE * NUMBER_OF_BLOCKS)); if(status != SD_OK) printf("SD_Erase failed: %d.\n\r",status); if(status == SD_OK) { printf("SD_Erase ok, performing SD_ReadMultiBlocks.\n\r"); status = SD_ReadMultiBlocks(aBuffer_MultiBlock_Rx, 0x0, BLOCK_SIZE, NUMBER_OF_BLOCKS); if(status != SD_OK){printf("SD_ReadMultiBlocks Failed\n\r");} /* Check if the Transfer is finished */ status = SD_WaitReadOperation(); if(status != SD_OK){printf("SD_WaitReadOperation Failed\n\r");} /* Wait until end of the DMA transfer */ while(SD_GetStatus() != SD_TRANSFER_OK); printf("SD_TRANSFER OK\n\r"); } /* Check the correctness of erased blocks */ if(status == SD_OK) { EraseStatus = eBuffercmp(aBuffer_MultiBlock_Rx, MULTI_BUFFER_SIZE); } if(EraseStatus == PASSED) printf("SD erase test passed!\n\r"); }
/******************************************************************************* * Function Name : MAL_Read * Description : Read sectors * Input : None * Output : None * Return : Buffer pointer *******************************************************************************/ uint16_t MAL_Read(uint8_t lun, uint32_t Memory_Offset, uint32_t *Readbuff, uint16_t Transfer_Length) { if(ejected) return MAL_FAIL; switch (lun) { case 0: SD_ReadMultiBlocks((uint8_t*)Readbuff, Memory_Offset, Transfer_Length, 1); // #if defined(USE_STM3210E_EVAL) || defined(USE_STM32L152D_EVAL) Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK) { } if ( Status != SD_OK ) { return MAL_FAIL; } // #endif /* USE_STM3210E_EVAL */ break; // #ifdef USE_STM3210E_EVAL // case 1: // NAND_Read(Memory_Offset, Readbuff, Transfer_Length); // ; // break; // #endif default: return MAL_FAIL; } return MAL_OK; }
static int8_t SDStorage_StateChanged (void) { SDTransferState status = SD_TRANSFER_OK; static SDTransferState prev_status = SD_TRANSFER_OK; if((status = SD_GetStatus()) != SD_TRANSFER_OK) { SD_Init(); } if (prev_status != status) { prev_status = status; if(status != SD_TRANSFER_OK) { return -1; } else { return 0; } } return 0; }
/** * @brief Tests the SD card erase operation. * @param None * @retval None */ void SD_EraseTest(void) { /*------------------- Block Erase ------------------------------------------*/ if (Status == SD_OK) { /* Erase NumberOfBlocks Blocks of WRITE_BL_LEN(512 Bytes) */ Status = SD_Erase(0x00, (BLOCK_SIZE * NUMBER_OF_BLOCKS)); } if (Status == SD_OK) { Status = SD_ReadMultiBlocks(Buffer_MultiBlock_Rx, 0x00, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* Check if the Transfer is finished */ Status = SD_WaitReadOperation(); /* Wait until end of DMA transfer */ while(SD_GetStatus() != SD_TRANSFER_OK); } /* Check the correctness of erased blocks */ if (Status == SD_OK) { EraseStatus = eBuffercmp(Buffer_MultiBlock_Rx, MULTI_BUFFER_SIZE); } if(EraseStatus == PASSED) { xprintf("Erase test passed\n"); } else { xprintf("Erase test failed\n"); } }
/******************************************************************************* * Function Name : MAL_Write * Description : Write sectors * Input : None * Output : None * Return : None *******************************************************************************/ uint16_t MAL_Write(uint8_t lun, uint32_t Memory_Offset, uint32_t *Writebuff, uint16_t Transfer_Length) { switch (lun) { case 0: Status = SD_WriteMultiBlocks((uint8_t*)Writebuff, Memory_Offset, Transfer_Length,1); #if defined(USE_STM3210E_EVAL) || defined(USE_STM32L152D_EVAL) Status = SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); if ( Status != SD_OK ) { return MAL_FAIL; } #endif /* USE_STM3210E_EVAL ||USE_STM32L152D_EVAL*/ break; #ifdef USE_STM3210E_EVAL case 1: NAND_Write(Memory_Offset, Writebuff, Transfer_Length); break; #endif /* USE_STM3210E_EVAL */ default: return MAL_FAIL; } return MAL_OK; }
/*-----------------------------------------------------------------------*/ DRESULT disk_read ( BYTE pdrv, /* Physical drive nmuber (0..) */ BYTE *buff, /* Data buffer to store read data */ DWORD sector, /* Sector address (LBA) */ UINT count /* Number of sectors to read (1..128) */ ) { SD_Error Status; if(pdrv || !count) return RES_PARERR; if(count==1) Status = SD_ReadBlock(buff ,sector<< 9 , SDCardInfo.CardBlockSize ); else Status = SD_ReadMultiBlocks(buff ,sector<< 9 ,SDCardInfo.CardBlockSize,count); /* Check if the Transfer is finished */ Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); if(Status == SD_OK) return RES_OK; else return RES_ERROR; }
/** * @brief Read Sector(s) * @param drv : driver index * @retval DSTATUS : operation status */ DRESULT disk_read ( BYTE drv, /* Physical drive number (0) */ BYTE *buff, /* Pointer to the data buffer to store read data */ DWORD sector, /* Start sector number (LBA) */ BYTE count /* Sector count (1..255) */ ) { SD_Error sdstatus = SD_OK; if (drv == 0) { SD_ReadMultiBlocks(buff, sector << 9, 512, count); /* Check if the Transfer is finished */ sdstatus = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); if (sdstatus == SD_OK) { return RES_OK; } } return RES_ERROR; }
DRESULT disk_write ( BYTE pdrv, /* Physical drive nmuber (0..) */ const BYTE *buff, /* Data to be written */ DWORD sector, /* Sector address (LBA) */ UINT count /* Number of sectors to write (1..128) */ ) { SD_Error Status; if(pdrv || !count) return RES_PARERR; if(count==1) Status = SD_WriteBlock((u8 *)buff ,sector << 9 , SDCardInfo.CardBlockSize); else { Status = SD_WriteMultiBlocks((u8 *)buff ,sector << 9 ,SDCardInfo.CardBlockSize,count); Status = SD_WaitWriteOperation(); } /* Check if the Transfer is finished */ Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); if(Status == SD_OK) return RES_OK; else return RES_ERROR; }
//========================================================================================= DSTATUS FATFS_SD_SDIO_disk_status(void) { Stat = STA_NOINIT; /* Check SDCARD status */ if (SD_GetStatus() == MSD_OK) Stat &= ~STA_NOINIT; else Stat |= STA_NOINIT; return Stat; }
/** * @brief Tests the SD card Multiple Blocks operations. * @param None * @retval None */ void SD_MultiBlockTest(void) { /*--------------- Multiple Block Read/Write ---------------------*/ /* Fill the buffer to send */ Fill_Buffer(Buffer_MultiBlock_Tx, MULTI_BUFFER_SIZE, 0x0); if (Status == SD_OK) { /* Write multiple block of many bytes on address 0 */ Status = SD_WriteMultiBlocks(Buffer_MultiBlock_Tx, 0x00, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* Check if the Transfer is finished */ Status = SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } if (Status == SD_OK) { /* Read block of many bytes from address 0 */ Status = SD_ReadMultiBlocks(Buffer_MultiBlock_Rx, 0x00, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* Check if the Transfer is finished */ Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } /* Check the correctness of written data */ if (Status == SD_OK) { TransferStatus2 = Buffercmp(Buffer_MultiBlock_Tx, Buffer_MultiBlock_Rx, MULTI_BUFFER_SIZE); } if(TransferStatus2 == PASSED) { STM_EVAL_LEDOn(LED3); LCD_DisplayStringLine(LCD_LINE_2, "Passed"); } else { STM_EVAL_LEDOff(LED3); STM_EVAL_LEDOn(LED4); LCD_DisplayStringLine(LCD_LINE_2, "failed"); } }
/** * @brief Tests the SD card Single Blocks operations. * @param None * @retval None */ void SD_SingleBlockTest(void) { /*------------------- Block Read/Write --------------------------*/ /* Fill the buffer to send */ Fill_Buffer(Buffer_Block_Tx, BLOCK_SIZE, 0x320F); if (Status == SD_OK) { /* Write block of 512 bytes on address 0 */ Status = SD_WriteBlock(Buffer_Block_Tx, 0x00, BLOCK_SIZE); /* Check if the Transfer is finished */ Status = SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } if (Status == SD_OK) { /* Read block of 512 bytes from address 0 */ Status = SD_ReadBlock(Buffer_Block_Rx, 0x00, BLOCK_SIZE); /* Check if the Transfer is finished */ Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } /* Check the correctness of written data */ if (Status == SD_OK) { TransferStatus1 = Buffercmp(Buffer_Block_Tx, Buffer_Block_Rx, BLOCK_SIZE); } if(TransferStatus1 == PASSED) { STM_EVAL_LEDOn(LED2); LCD_DisplayStringLine(LCD_LINE_2, "Passed"); } else { STM_EVAL_LEDOff(LED2); STM_EVAL_LEDOn(LED4); LCD_DisplayStringLine(LCD_LINE_2, "failed"); } }
DRESULT disk_read ( BYTE drv, /* Physical drive nmuber (0..) */ BYTE *buff, /* Data buffer to store read data */ DWORD sector, /* Sector address (LBA) */ BYTE count /* Number of sectors to read (1..255) */ ) { SD_Error Status; #ifdef DBGIO printf("disk_read %d %p %10d %d\n",drv,buff,sector,count); #endif if (SD_Detect() != SD_PRESENT) return(RES_NOTRDY); if ((DWORD)buff & 3) // DMA Alignment failure, do single up to aligned buffer { DRESULT res = RES_OK; DWORD scratch[BLOCK_SIZE / 4]; // Alignment assured, you'll need a sufficiently big stack while(count--) { res = disk_read(drv, (void *)scratch, sector++, 1); if (res != RES_OK) break; memcpy(buff, scratch, BLOCK_SIZE); buff += BLOCK_SIZE; } return(res); } Status = SD_ReadMultiBlocksFIXED(buff, sector, BLOCK_SIZE, count); // 4GB Compliant if (Status == SD_OK) { SDTransferState State; Status = SD_WaitReadOperation(); // Check if the Transfer is finished while((State = SD_GetStatus()) == SD_TRANSFER_BUSY); // BUSY, OK (DONE), ERROR (FAIL) if ((State == SD_TRANSFER_ERROR) || (Status != SD_OK)) return(RES_ERROR); else return(RES_OK); } else return(RES_ERROR); }
/** * @brief Get Disk Status * @param drv : driver index * @retval DSTATUS : operation status */ DSTATUS disk_status ( BYTE drv ) { Stat = STA_NOINIT; if ((drv == 0) && (SD_GetStatus() == 0)) { Stat &= ~STA_NOINIT; } return Stat; }
BOOL SD_GetStatus_WithTimeOut(int timeout) { //while(SD_GetStatus() != SD_TRANSFER_OK); for (;timeout>0; timeout--) { HAL_Time_Sleep_MicroSeconds_InterruptEnabled(1); if (SD_GetStatus() == SD_TRANSFER_OK) return TRUE; } return FALSE; }
bool SdioSecureDigitalCard::handleWriteReturn(SD_Error sdError,uint32_t errorCode) { if(sdError==SD_OK) { if((sdError=SD_WaitWriteOperation())!=SD_OK) return handleReturnCode(sdError,errorCode); while(SD_GetStatus()!=SD_TRANSFER_OK); return true; } else return handleReturnCode(sdError,errorCode); }
/** * @brief Tests the SD card Single Blocks operations. * @param None * @retval None */ void SD_SingleBlockTest(void) { /*------------------- Block Read/Write --------------------------*/ /* Fill the buffer to send */ Fill_Buffer(Buffer_Block_Tx, BLOCK_SIZE, 0x320F); if (Status == SD_OK) { /* Write block of 512 bytes on address 0 */ Status = SD_WriteBlock(Buffer_Block_Tx, 0x00, BLOCK_SIZE); /* Check if the Transfer is finished */ Status = SD_WaitWriteOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } if (Status == SD_OK) { /* Read block of 512 bytes from address 0 */ Status = SD_ReadBlock(Buffer_Block_Rx, 0x00, BLOCK_SIZE); /* Check if the Transfer is finished */ Status = SD_WaitReadOperation(); while(SD_GetStatus() != SD_TRANSFER_OK); } /* Check the correctness of written data */ if (Status == SD_OK) { TransferStatus1 = Buffercmp(Buffer_Block_Tx, Buffer_Block_Rx, BLOCK_SIZE); } if(TransferStatus1 == PASSED) { xprintf("Block test passed\n"); } else { xprintf("Block test failed\n"); } }
/** * @brief Tests the SD card Multiple Blocks operations. * @param None * @retval None */ static void SD_MultiBlockTest (void) { /* Fill the buffer to send */ Fill_Buffer (aBuffer_MultiBlock_Tx, MULTI_BUFFER_SIZE, 0x0); if (Status == SD_OK) { /* Write multiple block of many bytes on address 0 */ Status = SD_WriteMultiBlocks (aBuffer_MultiBlock_Tx, 0, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* Check if the Transfer is finished */ Status = SD_WaitWriteOperation (); while (SD_GetStatus () != SD_TRANSFER_OK) ; } if (Status == SD_OK) { /* Read block of many bytes from address 0 */ Status = SD_ReadMultiBlocks (aBuffer_MultiBlock_Rx, 0, BLOCK_SIZE, NUMBER_OF_BLOCKS); /* Check if the Transfer is finished */ Status = SD_WaitReadOperation (); while (SD_GetStatus () != SD_TRANSFER_OK) ; } /* Check the correctness of written data */ if (Status == SD_OK) { TransferStatus2 = Buffercmp (aBuffer_MultiBlock_Tx, aBuffer_MultiBlock_Rx, MULTI_BUFFER_SIZE); } if (TransferStatus2 == PASSED) { logf ("Multiple block test passed\r\n"); } else { logf ("Multiple block test failed\r\n"); } }
BOOL SD_BS_Driver::ReadSector(SectorAddress Address, UINT32 Offset, UINT32 NumBytes, BYTE *pSectorBuff, UINT32 BytesPerSector) { __IO SD_Error errorstatus = SD_OK; errorstatus = SD_ReadBlock(pSectorBuff, ((Address * BytesPerSector) + Offset), BytesPerSector); while(SD_GetStatus() != SD_TRANSFER_OK); //CPU_FlushCaches(); if(errorstatus == SD_OK) return TRUE; else return FALSE; }
/* Read Sector(s) */ DRESULT disk_read ( BYTE drv, /* Physical drive nmuber (0..) */ BYTE *buff, /* Data buffer to store read data */ DWORD sector, /* Sector address (LBA) */ BYTE count /* Number of sectors to read (1..255) */ ) { //printf("Disk read: Drive %x, Sector: %x, Count: %x\r\n", drv, sector, count); SD_Error Status; //uint32_t timeout = 1000000; if (!count) return RES_PARERR; if(drv==0) { //DMA // Status = SD_ReadMultiBlocks(buff, (uint32_t)(sector*512), BlockSize, count); // Status = SD_WaitReadOperation(); // while(SD_GetStatus() != SD_TRANSFER_OK) // { // if(timeout-- == 0) // { // printf("SDIO Timeout\r\n"); // return RES_ERROR; // } // } //Polling for(int i = 0; i < count; i++) { Status = SD_ReadBlock((BYTE*)(((uintptr_t)buff)+BlockSize*i), (uint32_t)(sector*BlockSize), BlockSize); while(SD_GetStatus() != SD_TRANSFER_OK); if(Status != SD_OK) return RES_ERROR; } if(Status == SD_OK) return RES_OK; else return RES_ERROR; } else return RES_ERROR; }