Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector)
{
if (!sd_mmc_spi_init_done)
{
sd_mmc_spi_mem_init();
}
if (!sd_mmc_spi_init_done)
return CTRL_NO_PRESENT;
Sd_mmc_spi_access_signal_on();
if( !sd_mmc_spi_read_open(addr) )
goto sd_mmc_spi_usb_read_10_fail;
if( !sd_mmc_spi_read_multiple_sector(nb_sector) )
goto sd_mmc_spi_usb_read_10_fail;
if( !sd_mmc_spi_read_close() )
goto sd_mmc_spi_usb_read_10_fail;
Sd_mmc_spi_access_signal_off();
return CTRL_GOOD;
sd_mmc_spi_usb_read_10_fail:
Sd_mmc_spi_access_signal_off();
return CTRL_FAIL;
}
Ctrl_status sd_mmc_spi_mem_2_ram(uint32_t addr, void *ram)
{
Sd_mmc_spi_access_signal_on();
sd_mmc_spi_check_presence();
if (!sd_mmc_spi_init_done)
{
sd_mmc_spi_mem_init();
}
if (!sd_mmc_spi_init_done)
return CTRL_NO_PRESENT;
if( !sd_mmc_spi_read_open(addr) )
goto sd_mmc_spi_mem_2_ram_fail;
if( !sd_mmc_spi_read_sector_to_ram(ram))
goto sd_mmc_spi_mem_2_ram_fail;
if( !sd_mmc_spi_read_close() )
goto sd_mmc_spi_mem_2_ram_fail;
Sd_mmc_spi_access_signal_off();
return CTRL_GOOD;
sd_mmc_spi_mem_2_ram_fail:
Sd_mmc_spi_access_signal_off();
return CTRL_FAIL;
}
Ctrl_status sd_mmc_spi_mem_2_ram(U32 addr, void *ram)
{
Sd_mmc_spi_access_signal_on();
sd_mmc_spi_check_presence();
if (sd_mmc_spi_init_done == FALSE)
{
sd_mmc_spi_mem_init();
}
if (sd_mmc_spi_init_done == TRUE)
{
sd_mmc_spi_read_open(addr);
if (KO == sd_mmc_spi_read_sector_to_ram(ram))
{
sd_mmc_spi_write_close();
Sd_mmc_spi_access_signal_off();
return CTRL_NO_PRESENT;
}
sd_mmc_spi_read_close();
Sd_mmc_spi_access_signal_off();
return CTRL_GOOD;
}
Sd_mmc_spi_access_signal_off();
return CTRL_NO_PRESENT;
}
void rt_hw_sd_mmc_init()
{
if (sd_mmc_spi_internal_init())
{
rt_uint8_t *sector = rt_malloc(MMC_SECTOR_SIZE);
sd_mmc_spi_read_open(0);
if (sd_mmc_spi_read_sector_to_ram(sector))
{
if (dfs_filesystem_get_partition(&sd_mmc_partition, sector, 0) != RT_EOK)
{
sd_mmc_partition.offset = 0;
sd_mmc_partition.size = 0;
}
}
else
{
sd_mmc_partition.offset = 0;
sd_mmc_partition.size = 0;
}
sd_mmc_spi_read_close();
rt_free(sector);
rt_device_register(&sd_mmc_device, "sd0", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
}
else
{
rt_kprintf("Failed to initialize SD/MMC card.\n");
}
}
/**
* \brief Test the read and write multiple sector operations on the SD/MMC card
*
* This function will test the read and write functionalities of the SD/MMC SPI
* component using multiple sector access. It will first fill the \ref CONF_TEST_NB_SECTORS
* last sectors with a known pattern and read it back to test each value.
*
* \param test Current test case.
*/
static void run_multiple_sector_access_test(const struct test_case *test)
{
bool status;
/* Compute the SD card capacity to retrieve the last sector address
*/
sd_mmc_spi_get_capacity();
/* Write the ram sector to the SD/MMC card
*/
status = sd_mmc_spi_write_open(sd_mmc_spi_last_block_address - CONF_TEST_NB_SECTORS);
test_assert_true(test, status == true,
"Cannot open the SD/MMC memory for write access");
cur_sector = 0;
status = sd_mmc_spi_write_multiple_sector(CONF_TEST_NB_SECTORS);
test_assert_true(test, status == true,
"Error while writing sector # %i", cur_sector);
sd_mmc_spi_write_close();
/* Read back the sector from the SD/MMC card
*/
status = sd_mmc_spi_read_open(sd_mmc_spi_last_block_address - CONF_TEST_NB_SECTORS);
test_assert_true(test, status == true,
"Cannot open the SD/MMC memory for read access");
cur_sector = 0;
cur_test = (struct test_case *) test;
status = sd_mmc_spi_read_multiple_sector(CONF_TEST_NB_SECTORS);
test_assert_true(test, status == true,
"Error while reading sector # %i", cur_sector);
sd_mmc_spi_read_close();
}
/**
* \brief Test the read and write sector operations on the SD/MMC card
*
* This function will test the read and write functionalities of the SD/MMC SPI
* component using sector access. It will first fill the last sector of the
* device with a known pattern and read it back by testing each value read.
*
* \param test Current test case.
*/
static void run_sector_access_test(const struct test_case *test)
{
uint32_t i;
bool status;
/* Fills a ram sector with a known pattern
*/
for (i=0; i<MMC_SECTOR_SIZE; i++) {
sector_buf[i] = BYTE_PATTERN1(i);
}
/* Compute the SD card capacity to retrieve the last sector address
*/
sd_mmc_spi_get_capacity();
/* Write the ram sector to the SD/MMC card
*/
status = sd_mmc_spi_write_open(sd_mmc_spi_last_block_address);
test_assert_true(test, status == true,
"Cannot open the SD/MMC memory for write access");
status = sd_mmc_spi_write_sector_from_ram(sector_buf);
test_assert_true(test, status == true,
"Write sector operation error");
sd_mmc_spi_write_close();
/* Clear the ram sector buffer
*/
for (i=0; i<MMC_SECTOR_SIZE; i++) {
sector_buf[i] = 0;
}
/* Read back the sector from the SD/MMC card
*/
status = sd_mmc_spi_read_open(sd_mmc_spi_last_block_address);
test_assert_true(test, status == true,
"Cannot open the SD/MMC memory for read access");
status = sd_mmc_spi_read_sector_to_ram(sector_buf);
test_assert_true(test, status == true,
"Read sector operation error");
sd_mmc_spi_read_close();
/* Compare the values read from the SD/MMC card with the expected values
*/
for (i=0; i<MMC_SECTOR_SIZE; i++) {
test_assert_true(test, sector_buf[i] == BYTE_PATTERN1(i),
"Value not expected @ 0x%08x (read: 0x%02x,"
" expected: 0x%02x)", i, sector_buf[i],
BYTE_PATTERN1(i));
}
}
Ctrl_status sd_mmc_spi_usb_read_10(U32 addr, U16 nb_sector)
{
Bool status;
if (sd_mmc_spi_init_done == FALSE)
{
sd_mmc_spi_mem_init();
}
if (sd_mmc_spi_init_done == TRUE)
{
Sd_mmc_spi_access_signal_on();
sd_mmc_spi_read_open(addr);
status = sd_mmc_spi_read_multiple_sector(nb_sector);
sd_mmc_spi_read_close();
Sd_mmc_spi_access_signal_off();
if (status == OK)
return CTRL_GOOD;
else
return CTRL_NO_PRESENT;
}
else
return CTRL_NO_PRESENT;
}
