//! 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; }