//! This function initializes the memory for a write operation
//! from ram buffer to SD/MMC (1 sector)
//!
//! DATA FLOW is: RAM => SD/MMC
//!
//! (sector = 512B)
//! @param addr Sector address to write
//! @param ram Ram buffer pointer
//!
//! @return Ctrl_status
//! It is ready -> CTRL_GOOD
//! An error occurs -> CTRL_FAIL
//!
Ctrl_status sd_mmc_spi_ram_2_mem(uint32_t addr, const 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)
{
sd_mmc_spi_write_open(addr);
if (!sd_mmc_spi_write_sector_from_ram(ram))
{
sd_mmc_spi_write_close();
Sd_mmc_spi_access_signal_off();
return CTRL_NO_PRESENT;
}
sd_mmc_spi_write_close();
Sd_mmc_spi_access_signal_off();
return CTRL_GOOD;
}
Sd_mmc_spi_access_signal_off();
return CTRL_NO_PRESENT;
}
int media_write(unsigned long sector, unsigned char *buffer, unsigned long sector_count) {
#if 1
#else
unsigned long i;
bool status;
// PDCA write isn't implemented in ASF... ! dang
// for the moment use slower blocking write.
status = sd_mmc_spi_write_open(sector);
if(status == false) {
print_dbg("\r\n error opening sd_mmc_spi, sector: ");
print_dbg_hex(sector);
return 0;
}
for (i=0;i<sector_count;i++) {
status = sd_mmc_spi_write_sector_from_ram(buffer);
/////////// dbg
if(status == false) {
print_dbg("\r\n error writing sd_mmc_spi, sector: ");
print_dbg_hex(sector);
}
//////////////
sector++;
buffer += 512;
}
sd_mmc_spi_write_close();
return 1;
#endif
}
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;
}
static rt_size_t sd_mmc_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
rt_uint32_t count = size;
rt_uint32_t sector = sd_mmc_partition.offset + pos;
if (sd_mmc_spi_write_open(sector))
{
while (count)
{
if (sd_mmc_spi_write_sector_from_ram(buffer))
{
count--;
buffer += MMC_SECTOR_SIZE;
}
else
{
rt_kprintf("SD/MMC write error.\n");
size = 0;
break;
}
}
sd_mmc_spi_write_close();
}
else
{
rt_kprintf("Unable to initiate SD/MMC write command.\n");
return 0;
}
return size;
}
/**
* \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_write_10(uint32_t addr, uint16_t nb_sector)
{
bool status;
if (!sd_mmc_spi_init_done)
{
sd_mmc_spi_mem_init();
}
if (sd_mmc_spi_init_done)
{
Sd_mmc_spi_access_signal_on();
sd_mmc_spi_write_open(addr);
status = sd_mmc_spi_write_multiple_sector(nb_sector);
sd_mmc_spi_write_close();
Sd_mmc_spi_access_signal_off();
if (status)
return CTRL_GOOD;
else
return CTRL_NO_PRESENT;
}
else
return CTRL_NO_PRESENT;
}
Ctrl_status sd_mmc_spi_usb_write_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_write_open(addr);
status = sd_mmc_spi_write_multiple_sector(nb_sector);
sd_mmc_spi_write_close();
Sd_mmc_spi_access_signal_off();
if (status == OK)
return CTRL_GOOD;
else
return CTRL_NO_PRESENT;
}
else
return CTRL_NO_PRESENT;
}
