//!
//! @brief Synchronize the contents of two drives (limited to files).
//!
//! @param sync_direction uint8_t: DEVICE_TO_HOST, HOST_TO_DEVICE or FULL_SYNC
//!
//! @return bool: true on success
//!
//! @todo Do recursive directory copy...
//!
bool host_mass_storage_task_sync_drives(uint8_t sync_direction)
{
Fs_index local_index;
Fs_index sav_local_index;
Fs_index usb_index;
Fs_index sav_usb_index;
// First, check the host controller is in full operating mode with the
// B-device attached and enumerated
if (!Is_host_ready()) return false;
nav_reset();
// Try to mount local drive
nav_drive_set(LUN_ID_AT45DBX_MEM);
if (!nav_partition_mount()) return false;
local_index = nav_getindex();
sav_local_index = nav_getindex();
// Try to mount first USB device drive
nav_drive_set(LUN_ID_MEM_USB);
if (!nav_partition_mount()) return false;
usb_index = nav_getindex();
sav_usb_index = nav_getindex();
// First synchronization: USB/OUT -> Local/IN
if (sync_direction & DEVICE_TO_HOST)
{
if (!host_mass_storage_task_sync_dir(&local_index, DIR_LOCAL_IN_NAME, &usb_index, DIR_USB_OUT_NAME))
return false;
}
// Restore positions
nav_gotoindex(&sav_local_index);
local_index = nav_getindex();
nav_gotoindex(&sav_usb_index);
usb_index = nav_getindex();
nav_gotoindex(&local_index);
// Second synchronization: Local/OUT -> USB/IN
if (sync_direction & HOST_TO_DEVICE)
{
if (!host_mass_storage_task_sync_dir(&usb_index, DIR_USB_IN_NAME, &local_index, DIR_LOCAL_OUT_NAME))
return false;
}
return true;
}
//! @brief This function mount a drive
//!
void ushell_cmd_mount( void )
{
uint8_t u8_drive_lun;
Fs_index sav_index;
if( g_s_arg[0][0] == 0 )
return;
// Compute the logical unit number of drive
u8_drive_lun=g_s_arg[0][0]-'a';
// Check lun number
if( u8_drive_lun >= nav_drive_nb() )
{
fputs(MSG_ER_DRIVE, stdout);
return;
}
// Mount drive
sav_index = nav_getindex(); // Save previous position
if( nav_drive_set(u8_drive_lun))
{
if( nav_partition_mount() )
return; // Here, drive mounted
}
fputs(MSG_ER_MOUNT, stdout);
nav_gotoindex(&sav_index); // Restore previous position
}
//! @brief This function displays the free space of each drive present
//!
void ushell_cmd_free_space( void )
{
uint8_t u8_tmp;
Fs_index sav_index = nav_getindex(); // Save current position
for( u8_tmp=0; u8_tmp<nav_drive_nb(); u8_tmp++ )
{
nav_drive_set( u8_tmp ); // Select drive
if( !nav_partition_mount() ) // Mount drive
continue;
// Display drive letter name (a, b...)
printf("%c: %s\r\n", 'a'+u8_tmp, mem_name(u8_tmp) );
if( g_s_arg[0][0]=='l' ) // Choose command option
{
// Long and exact function
printf("Free space: %llu Bytes / %llu Bytes\n\r",
(uint64_t)(nav_partition_freespace() << FS_SHIFT_B_TO_SECTOR),
(uint64_t)(nav_partition_space() << FS_SHIFT_B_TO_SECTOR));
}
else
{
// Otherwise use fast command
printf("Free space: %u %%\n\r", nav_partition_freespace_percent() );
}
}
nav_gotoindex(&sav_index); // Restore position
}
//! This function selects a file in the navigator via a file index
//!
//! @param index structure with information about file to select (disk, partition, dir, file/dir selected )
//!
//! @return false in case of error, see global value "fs_g_status" for more detail
//! @return true otherwise
//!
//! @verbatim
//! This routine allow to reinit a navigator quickly via a file index (disk, partition, dir, file/dir selected )
//! To get a file index, you shall used the routine nav_getindex().
//! @endverbatim
//!
bool nav_filterlist_gotoindex( const Fs_index _MEM_TYPE_SLOW_ *index )
{
if( !nav_drive_set( index->u8_lun ))
return false;
#if (FS_MULTI_PARTITION == true)
if( !nav_partition_set(index->u8_partition))
return false;
#endif
if( !nav_partition_mount())
return false;
// Initialization of the current entry file with index information
fs_g_nav.u32_cluster_sel_dir = index->u32_cluster_sel_dir;
// Reset position
if ( !nav_filterlist_reset() )
return false;
// Research the index in directory
while( fs_g_nav_fast.u16_entry_pos_sel_file != index->u16_entry_pos_sel_file )
{
if( !nav_filterlist_next() )
{
nav_filterlist_reset();
return false;
}
}
return true;
}
static __inline__ uint8_t navauto_mov_ok_loop(bool b_direction, navauto_mov_options_t options)
{
bool b_ok_loop = false;
// If mode Disks, it should go to the next/previous disk
if (g_navauto_exp_mode == NAVAUTO_MODE_DISKS)
{
// Mount the next/previous disk
do
{
if (b_direction == FS_FIND_NEXT)
{
// Go to the next drive
if (!nav_drive_set(nav_drive_get() + 1))
{
nav_drive_set(0);
b_ok_loop = true;
}
}
else // direction PREVIOUS
{
// Go to the previous drive
if (!nav_drive_set(nav_drive_get() - 1))
{
nav_drive_set(nav_drive_nb() - 1);
b_ok_loop = true;
}
}
}while(!nav_partition_mount());
// If it reached a limit
if (b_ok_loop)
{
navauto_mov_explorer_rec(b_direction, options);
return NAVAUTO_MOV_OK_LOOP;
}
// Else return the result of the recursive function
return navauto_mov_explorer_rec(b_direction, options);
}
return NAVAUTO_MOV_OK_LOOP;
}
Fs_file_segment ushell_cmd_perform_alloc( uint8_t lun, uint16_t size_alloc )
{
const FS_STRING file_tmp_name = "tmp.bin";
Fs_file_segment g_recorder_seg;
g_recorder_seg.u16_size = 0;
if( !nav_drive_set(lun))
return g_recorder_seg;
if( !nav_partition_mount() )
return g_recorder_seg;
if( !nav_file_create((FS_STRING)file_tmp_name))
{
if( FS_ERR_FILE_EXIST != fs_g_status)
return g_recorder_seg;
nav_file_del(false);
if( !nav_file_create((FS_STRING)file_tmp_name))
return g_recorder_seg;
}
// Open file
if( !file_open(FOPEN_MODE_W) )
{
nav_file_del(false);
return g_recorder_seg;
}
// Define the size of segment to alloc (unit 512B)
// Note: you can alloc more in case of you don't know total size
g_recorder_seg.u16_size = size_alloc;
// Alloc in FAT a cluster list equal or inferior at segment size
if( !file_write( &g_recorder_seg ))
{
g_recorder_seg.u16_size = 0;
file_close();
nav_file_del(false);
}
return g_recorder_seg; //** File open and FAT allocated
}
//! This function mounts the selected partition
//!
//! @return false in case of error, see global value "fs_g_status" for more detail
//! @return true otherwise
//!
//! @verbatim
//! If the FS_MULTI_PARTITION option is disabled
//! then the mount routine selects the first partition supported by file system. <br>
//! After mount, the file list contains files and directories of ROOT directory
//! @endverbatim
//!
bool nav_flat_mount( void )
{
fs_g_nav.u8_flat_dir_level = 0;
fs_g_nav.u16_flat_pos_offset = 0;
return nav_partition_mount();
}
/*! \brief Main function. Execution starts here.
*/
int main(void)
{
sysclk_init();
irq_initialize_vectors();
cpu_irq_enable();
// Initialize the sleep manager
sleepmgr_init();
board_init();
ui_init();
// Reset File System
nav_reset();
// Start USB host stack
uhc_start();
// The USB management is entirely managed by interrupts.
// As a consequence, the user application does only have :
// - to play with the power modes
// - to create a file on each new LUN connected
while (true) {
sleepmgr_enter_sleep();
if (main_usb_sof_counter > 2000) {
main_usb_sof_counter = 0;
uint8_t lun;
for (lun = 0; (lun < uhi_msc_mem_get_lun()) && (lun < 8); lun++) {
// Mount drive
nav_drive_set(lun);
if (!nav_partition_mount()) {
if (fs_g_status == FS_ERR_HW_NO_PRESENT) {
// The test can not be done, if LUN is not present
lun_state &= ~(1 << lun); // LUN test reseted
continue;
}
lun_state |= (1 << lun); // LUN test is done.
ui_test_finish(false); // Test fail
continue;
}
// Check if LUN has been already tested
if (lun_state & (1 << lun)) {
continue;
}
// Create a test file on the disk
if (!nav_file_create((FS_STRING) "uhi_msc_test.txt")) {
if (fs_g_status != FS_ERR_FILE_EXIST) {
if (fs_g_status == FS_LUN_WP) {
// Test can be done only on no write protected device
continue;
}
lun_state |= (1 << lun); // LUN test is done.
ui_test_finish(false); // Test fail
continue;
}
}
if (!file_open(FOPEN_MODE_APPEND)) {
if (fs_g_status == FS_LUN_WP) {
// Test can be done only on no write protected device
continue;
}
lun_state |= (1 << lun); // LUN test is done.
ui_test_finish(false); // Test fail
continue;
}
if (!file_write_buf((uint8_t*)MSG_TEST, sizeof(MSG_TEST))) {
lun_state |= (1 << lun); // LUN test is done.
ui_test_finish(false); // Test fail
continue;
}
file_close();
lun_state |= (1 << lun); // LUN test is done.
ui_test_finish(true); // Test pass
}
if ((lun == 0) || (lun_state == 0)) {
ui_test_flag_reset();
}
}
}
}
//! This function mounts the selected partition
//!
//! @return false in case of error, see global value "fs_g_status" for more detail
//! @return true otherwise
//!
//! @verbatim
//! If the FS_MULTI_PARTITION option is disabled
//! then the mount routine selects the first partition supported by file system. <br>
//! After mount, the file list contains files and directories of ROOT directory
//! @endverbatim
//!
bool nav_filterlist_mount( void )
{
fs_g_nav.u16_pos_filterlist = FS_NO_SEL;
return nav_partition_mount();
}
