file.c File Reference

FAT 12/16/32 Services. More...

#include "conf_explorer.h"
#include "file.h"
#include "navigation.h"
#include <LIB_MEM>
#include <LIB_CTRLACCESS>

Include dependency graph for file.c:

Go to the source code of this file.

Functions
static void	file_load_segment_value (Fs_file_segment _MEM_TYPE_SLOW_ *segment)
	This function stores the global segment variable in other variable.
Bool	file_ispresent (void)
	This function checks if a file is selected.
Bool	file_open (U8 fopen_mode)
	This function opens the selected file.
Bool	file_read (Fs_file_segment _MEM_TYPE_SLOW_ *segment)
	This function returns a segment (position & size) in a physical memory corresponding at the file.
U16	file_read_buf (U8 _MEM_TYPE_SLOW_ *buffer, U16 u16_buf_size)
	This function copys in a buffer the file data corresponding at the current position.
U16	file_getc (void)
	This function returns the next byte of file.
U32	file_getpos (void)
	This function returns the position in the file.
Bool	file_seek (U32 u32_pos, U8 u8_whence)
	This function changes the position in the file.
U8	file_bof (void)
	This function checks the beginning of file.
U8	file_eof (void)
	This function checks the end of file.
void	file_flush (void)
	This function flushs the internal cache (file datas and file information).
void	file_close (void)
	This function closes the file.
Variables
_MEM_TYPE_SLOW_ U8	fs_g_sector [512]
	Use "FAT sector cache" to store a sector from a file (see file_putc(), file_getc(), file_read_buf(), file_write_buf()).

---

Detailed Description

FAT 12/16/32 Services.

This file defines a useful set of functions for the file accesses on AVR32 devices.

Author:

Atmel Corporation: http://www.atmel.com
Support and FAQ: http://support.atmel.no/

Definition in file file.c.

---

Function Documentation

static void file_load_segment_value

(

Fs_file_segment _MEM_TYPE_SLOW_ *

segment

)

[static]

This function stores the global segment variable in other variable.

Parameters:

segment

Pointer on the variable to fill

Definition at line 144 of file file.c.

References fs_g_nav, fs_g_seg, Fs_segment::u32_addr, Fs_segment::u32_size_or_pos, and Fs_management::u8_lun.

Referenced by file_read().

{
   segment->u8_lun = fs_g_nav.u8_lun;
   segment->u32_addr = fs_g_seg.u32_addr;
   segment->u16_size = fs_g_seg.u32_size_or_pos;
}

Here is the caller graph for this function:

Bool file_ispresent

(

void

)

This function checks if a file is selected.

Returns:

TRUE, a file is selected

FALSE, otherwise

Definition at line 69 of file file.c.

{
   if( !fat_check_mount_select() )
      return FALSE;
   return fat_check_is_file();
}

Bool file_open

(

U8

fopen_mode

)

This function opens the selected file.

Parameters:

fopen_mode

option to open the file : FOPEN_MODE_R R access, flux pointer = 0, size not modify FOPEN_MODE_R_PLUS R/W access, flux pointer = 0, size not modify FOPEN_MODE_W W access, flux pointer = 0, size = 0 FOPEN_MODE_W_PLUS R/W access, flux pointer = 0, size = 0 FOPEN_MODE_APPEND W access, flux pointer = at the end, size not modify

Returns:

FALSE in case of error, see global value "fs_g_status" for more detail

TRUE otherwise

Definition at line 89 of file file.c.

Referenced by firm_upgrade_run(), firm_upgrade_status(), ushell_cmd_append_file(), ushell_cmd_cat(), and ushell_cmd_perform_alloc().

{
   if( !fat_check_mount_select_noopen())
      return FALSE;

   if( !fat_check_is_file())
      return FALSE;

   if(FOPEN_WRITE_ACCESS & fopen_mode)
   {
      if( !fat_check_nav_access_file( TRUE ) )
         return FALSE;
#if (FSFEATURE_WRITE == (FS_LEVEL_FEATURES & FSFEATURE_WRITE))
      if (FS_ATTR_READ_ONLY & fs_g_nav_entry.u8_attr)
      {
         fs_g_status = FS_ERR_READ_ONLY;  // File is read only
         return FALSE;
      }
      if( mem_wr_protect( fs_g_nav.u8_lun  ))
      {
         fs_g_status = FS_LUN_WP;  // Disk read only
         return FALSE;
      }
#else
      fs_g_status = FS_ERR_MODE_NOAVIALABLE;
      return FALSE;
#endif  // FS_LEVEL_FEATURES
   }
   else
   {
      if( !fat_check_nav_access_file( FALSE ) )
         return FALSE;
   }

   if(FOPEN_CLEAR_SIZE & fopen_mode)
   {
      fs_g_nav_entry.u32_size    = 0;     // The size is null
   }
   if(FOPEN_CLEAR_PTR & fopen_mode)
   {
      fs_g_nav_entry.u32_pos_in_file = 0;
   }
   else
   {  // Go to at the end of file
      fs_g_nav_entry.u32_pos_in_file = fs_g_nav_entry.u32_size;
   }
   fs_g_nav_entry.u8_open_mode = fopen_mode;
   return TRUE;
}

Here is the caller graph for this function:

Bool file_read

(

Fs_file_segment _MEM_TYPE_SLOW_ *

segment

)

This function returns a segment (position & size) in a physical memory corresponding at the file.

Parameters:

segment

Pointer on the segment structure: ->u32_size_or_pos IN, shall contains maximum number of sector to read in file (0 = unlimited) ->u32_size_or_pos OUT, containt the segment size (unit sector) ->other IN, ignored ->other OUT, contains the segment position

Returns:

FALSE in case of error, see global value "fs_g_status" for more detail

TRUE otherwise

//! This routine is interesting to read a file via a DMA and avoid the file system decode
//! because this routine returns a physical memory segment without File System information.
//! Note: the file can be fragmented and you must call file_read() for each fragments.
//! 

Definition at line 169 of file file.c.

{
   U8 u8_nb_sector_truncated;

   if( !fat_check_mount_select_open())
      return FALSE;

   if(!(FOPEN_READ_ACCESS & fs_g_nav_entry.u8_open_mode))
   {
      fs_g_status = FS_ERR_WRITE_ONLY;
      return FALSE;
   }

   if ( file_eof() )
   {
      // End of the file
      fs_g_status = FS_ERR_EOF;
      return FALSE;
   }

   if( !fat_read_file(FS_CLUST_ACT_SEG))
   {
      if( FS_ERR_OUT_LIST == fs_g_status )
         fs_g_status = FS_ERR_EOF;  // translate the error
      return FALSE;
   }
   // If the segment is too large then truncate it
   if( (segment->u16_size != 0)                          // if no limit then no truncate
   &&  (segment->u16_size < fs_g_seg.u32_size_or_pos) )
   {
      u8_nb_sector_truncated   = fs_g_seg.u32_size_or_pos - segment->u16_size;
      fs_g_seg.u32_size_or_pos = segment->u16_size ;
   }else{
      u8_nb_sector_truncated = 0;
   }

   // Update file position
   fs_g_nav_entry.u32_pos_in_file += (U32)fs_g_seg.u32_size_or_pos * FS_512B;
   if( fs_g_nav_entry.u32_size < fs_g_nav_entry.u32_pos_in_file )
   {
      // The segment is more larger then file
      // case possible: if the file don't use all cluster space
      // then compute sectors not used in last cluster of file cluster list
      U8 u8_nb_sector_not_used;

      // Compute the number of sector used in last cluster
      // remark: also the two first bytes of size is used, because the cluster size can't be more larger then 64KB
      u8_nb_sector_not_used = LSB1( fs_g_nav_entry.u32_size ) >> (FS_512B_SHIFT_BIT-8);
      if( 0 != (fs_g_nav_entry.u32_size & FS_512B_MASK) )
      {  // last sector of file isn't full, but it must been read
         u8_nb_sector_not_used++;
      }

      // Compute the number of sector not used in last cluster
      u8_nb_sector_not_used = fs_g_nav.u8_BPB_SecPerClus - (u8_nb_sector_not_used % fs_g_nav.u8_BPB_SecPerClus);
      // if all space of cluster isn't used, then it is wrong
      if( u8_nb_sector_not_used == fs_g_nav.u8_BPB_SecPerClus )
         u8_nb_sector_not_used = 0; // The file uses all last cluster space

      // Subtract this value a the file position and segment size
      u8_nb_sector_not_used -= u8_nb_sector_truncated;
      fs_g_seg.u32_size_or_pos -= u8_nb_sector_not_used;                                     // unit sector
      fs_g_nav_entry.u32_pos_in_file -= ((U16)u8_nb_sector_not_used) << FS_512B_SHIFT_BIT;   // unit byte
   }
   file_load_segment_value( segment );
   return TRUE;
}

U16 file_read_buf	(	U8 _MEM_TYPE_SLOW_ *	buffer,
		U16	u16_buf_size
	)

This function copys in a buffer the file data corresponding at the current position.

Parameters:

	buffer	buffer to fill
	u16_buf_size	buffer size

Returns:

number of byte read

0, in case of error

Definition at line 246 of file file.c.

{
   _MEM_TYPE_FAST_ U16 u16_nb_read_tmp;
   _MEM_TYPE_FAST_ U16 u16_nb_read;
   _MEM_TYPE_FAST_ U16 u16_pos_in_sector;
   _MEM_TYPE_FAST_ U32 u32_byte_remaining;

   if( !fat_check_mount_select_open())
      return FALSE;

   if(!(FOPEN_READ_ACCESS & fs_g_nav_entry.u8_open_mode))
   {
      fs_g_status = FS_ERR_WRITE_ONLY;
      return FALSE;
   }

   u16_nb_read = 0;

   while( 0 != u16_buf_size )
   {
      if ( file_eof() )
      {
         fs_g_status = FS_ERR_EOF;
         return u16_nb_read;     // End of the file
      }
      u32_byte_remaining = fs_g_nav_entry.u32_size-fs_g_nav_entry.u32_pos_in_file;
      u16_pos_in_sector = fs_g_nav_entry.u32_pos_in_file % FS_512B;

      if( (0== u16_pos_in_sector)
      &&  (FS_512B <= u32_byte_remaining)
      &&  (FS_512B <= u16_buf_size)
#if __GNUC__ && __AVR32__ || __ICCAVR32__
      &&  (Test_align((U32)buffer, sizeof(U32)))
#endif
      )
      {
         // The file data sector can been directly transfer from memory to buffer (don't use internal cache)
         if( u16_buf_size <= u32_byte_remaining)
         {
            u16_nb_read_tmp = u16_buf_size;
         }else{
            u16_nb_read_tmp = u32_byte_remaining;
         }
         u16_nb_read_tmp = u16_nb_read_tmp / FS_512B;  // read a modulo sector size

         // Get following sector segment of file
         if( !fat_read_file(FS_CLUST_ACT_SEG))
         {
            if( FS_ERR_OUT_LIST == fs_g_status )
               fs_g_status = FS_ERR_EOF;  // translate the error
            return u16_nb_read;
         }
         // Truncate the segment size found if more larger than asked size
         if( u16_nb_read_tmp > fs_g_seg.u32_size_or_pos )
         {
            u16_nb_read_tmp = fs_g_seg.u32_size_or_pos;
         }else{
            fs_g_seg.u32_size_or_pos = u16_nb_read_tmp;
         }

         // Directly data tranfert from memory to buffer
         while( 0 != fs_g_seg.u32_size_or_pos )
         {
            if( CTRL_GOOD != memory_2_ram( fs_g_nav.u8_lun  , fs_g_seg.u32_addr, buffer))
            {
               fs_g_status = FS_ERR_HW;
               return u16_nb_read;
            }
            fs_g_seg.u32_size_or_pos--;
            fs_g_seg.u32_addr++;
            buffer += FS_512B;
         }
         // Translate from sector unit to byte unit
         u16_nb_read_tmp *= FS_512B;
      }
      else
      {
         // The file data can't been directly transfer from memory to buffer, the internal cache must be used

         // Tranfer data from memory to internal cache
         if( !fat_read_file( FS_CLUST_ACT_ONE ))
         {
            if( FS_ERR_OUT_LIST == fs_g_status )
            {  // Translate the error
               fs_g_status = FS_ERR_EOF;   // End of file
            }
            return u16_nb_read;
         }

         // Compute the number of data to transfer
         u16_nb_read_tmp = FS_512B - u16_pos_in_sector;  // The number is limited at sector size
         if( u16_nb_read_tmp > u32_byte_remaining )
            u16_nb_read_tmp = u32_byte_remaining;
         if( u16_nb_read_tmp > u16_buf_size )
            u16_nb_read_tmp = u16_buf_size;

         // Tranfer data from internal cache to buffer
         memcpy_ram2ram( buffer , &fs_g_sector[ u16_pos_in_sector ], u16_nb_read_tmp );
         buffer += u16_nb_read_tmp;
      }
      // Update positions
      fs_g_nav_entry.u32_pos_in_file   += u16_nb_read_tmp;
      u16_nb_read                      += u16_nb_read_tmp;
      u16_buf_size                     -= u16_nb_read_tmp;
   }
   return u16_nb_read;  // Buffer is full
}

U16 file_getc

(

void

)

This function returns the next byte of file.

Returns:

The byte readed

EOF, in case of error or end of file

Definition at line 360 of file file.c.

Referenced by firm_upgrade_readbyte(), firm_upgrade_readhexline(), and ushell_cmd_cat().

{
   U16   u16_byte;

   while(1)
   {
      if(!(FOPEN_READ_ACCESS & fs_g_nav_entry.u8_open_mode))
      {
         fs_g_status = FS_ERR_WRITE_ONLY;
         break;
      }
      if( fs_g_nav_entry.u32_size <= fs_g_nav_entry.u32_pos_in_file )
      {
         fs_g_status = FS_ERR_EOF;
         break;
      }

      if( !fat_read_file( FS_CLUST_ACT_ONE ))
      {
         if( FS_ERR_OUT_LIST == fs_g_status )
         {  // Translate the error
            fs_g_status = FS_ERR_EOF;   // End of file
         }
         break;
      }

      u16_byte = fs_g_sector[ fs_g_nav_entry.u32_pos_in_file & FS_512B_MASK ];
      fs_g_nav_entry.u32_pos_in_file++;
      return u16_byte;
   }
   return FS_EOF;   // No data readed
}

Here is the caller graph for this function:

U32 file_getpos

(

void

)

This function returns the position in the file.

Returns:

Position in file

Definition at line 629 of file file.c.

{
   if( !fat_check_mount_select_open() )
      return 0;

   return fs_g_nav_entry.u32_pos_in_file;
}

Bool file_seek	(	U32	u32_pos,
		U8	u8_whence
	)

This function changes the position in the file.

Parameters:

	u32_pos	number of byte to seek
	u8_whence	direction of seek FS_SEEK_SET , start at the beginning and foward FS_SEEK_END , start at the end of file and rewind FS_SEEK_CUR_RE, start at the current position and rewind FS_SEEK_CUR_FW, start at the current position and foward

Returns:

FALSE in case of error, see global value "fs_g_status" for more detail

TRUE otherwise

Definition at line 650 of file file.c.

Referenced by firm_upgrade_run().

{
   if( !fat_check_mount_select_open())
      return FALSE;

   switch(u8_whence)
   {
      case FS_SEEK_CUR_RE:
      if( fs_g_nav_entry.u32_pos_in_file < u32_pos )
      {  // Out of the limit
         fs_g_status = FS_ERR_BAD_POS;
         return FALSE;
      }
      // update the position
      fs_g_nav_entry.u32_pos_in_file -= u32_pos;
      break;

      case FS_SEEK_SET:
      if( fs_g_nav_entry.u32_size < u32_pos )
      {  // Out of the limit
         fs_g_status = FS_ERR_BAD_POS;
         return FALSE;
      }
      // update the position
      fs_g_nav_entry.u32_pos_in_file = u32_pos;
      break;

      case FS_SEEK_END:
      if( fs_g_nav_entry.u32_size < u32_pos )
      {  // Out of the limit
         fs_g_status = FS_ERR_BAD_POS;
         return FALSE;
      }
      // update the position
      fs_g_nav_entry.u32_pos_in_file = fs_g_nav_entry.u32_size - u32_pos;
      break;

      case FS_SEEK_CUR_FW:
      u32_pos += fs_g_nav_entry.u32_pos_in_file;
      if( fs_g_nav_entry.u32_size < u32_pos )
      {  // Out of the limit
         fs_g_status = FS_ERR_BAD_POS;
         return FALSE;
      }
      // update the position
      fs_g_nav_entry.u32_pos_in_file = u32_pos;
      break;
   }
   return TRUE;
}

Here is the caller graph for this function:

U8 file_bof

(

void

)

This function checks the beginning of file.

Returns:

1 the position is at the beginning of file

0 the position isn't at the beginning of file

FFh error

Definition at line 708 of file file.c.

{
   if( !fat_check_mount_select_open() )
      return 0xFF;

   return (0 == fs_g_nav_entry.u32_pos_in_file );
}

U8 file_eof

(

void

)

This function checks the end of file.

Returns:

1 the position is at the end of file

0 the position isn't at the end of file

FFh error

Definition at line 723 of file file.c.

Referenced by file_read(), file_read_buf(), firm_upgrade_run(), and ushell_cmd_cat().

{
   if( !fat_check_mount_select_open() )
      return 0xFF;
   return (fs_g_nav_entry.u32_size <= fs_g_nav_entry.u32_pos_in_file );
}

Here is the caller graph for this function:

void file_flush

(

void

)

This function flushs the internal cache (file datas and file information).

Definition at line 733 of file file.c.

{
   U8 save_open_mode;
   save_open_mode = fs_g_nav_entry.u8_open_mode;
   file_close();
   fs_g_nav_entry.u8_open_mode = save_open_mode;
}

void file_close

(

void

)

This function closes the file.

Definition at line 744 of file file.c.

Referenced by file_flush(), firm_upgrade_run(), firm_upgrade_status(), nav_exit(), ushell_cmd_append_file(), ushell_cmd_cat(), ushell_cmd_perform(), and ushell_cmd_perform_alloc().

{
   // If a file is opened, then close this one
   if( fat_check_mount_select_open() )
   {

#if (FSFEATURE_WRITE == (FS_LEVEL_FEATURES & FSFEATURE_WRITE))
      if( FOPEN_WRITE_ACCESS & fs_g_nav_entry.u8_open_mode )
      {
         // Write file information
         if( !fat_read_dir() )
            return;           // error
         fat_write_entry_file();
         fat_cache_flush();   // In case of error during writing data, flush the data before exit function
      }
#endif  // FS_LEVEL_FEATURES
      Fat_file_close();
   }
}

Here is the caller graph for this function:

---

Variable Documentation

_MEM_TYPE_SLOW_ U8 fs_g_sector[512]

Use "FAT sector cache" to store a sector from a file (see file_putc(), file_getc(), file_read_buf(), file_write_buf()).

---