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