FileX I/O (rm_filex_block_media)

Functions
fsp_err_t	RM_FILEX_BLOCK_MEDIA_Open (rm_filex_block_media_ctrl_t *const p_ctrl, rm_filex_block_media_cfg_t const *const p_cfg)
fsp_err_t	RM_FILEX_BLOCK_MEDIA_Close (rm_filex_block_media_ctrl_t *const p_ctrl)
void	RM_FILEX_BLOCK_MEDIA_BlockDriver (FX_MEDIA *p_fx_media)
	Access Block Media device functions open, close, read, write and control. More...

Detailed Description

Middleware for the Azure RTOS FileX File System control using Block Media on RA MCUs.

Overview

This module provides the hardware port layer for FileX file system. After initializing this module, refer to the FileX API reference to use the file system: https://docs.microsoft.com/en-us/azure/rtos/filex/

Features

The FileX Block Media module supports the following features:

• Callbacks for insertion and removal for removable devices.
• ThreadX is typically required for FileX. To use FileX without ThreadX FX_STANDALONE_ENABLE must be defined.
• Unless FX_SINGLE_THREAD or FX_STANDALONE_ENABLE are defined, all FileX operations are thread safe.

Configuration

Build Time Configurations for rm_filex_block_media

The following build time configurations are defined in fsp_cfg/middleware/rm_filex_block_media_cfg.h:

Configuration	Options	Default	Description
Parameter Checking	Default (BSP) Enabled Disabled	Default (BSP)	Selects if code for parameter checking is to be included in the build.

Configurations for Storage > FileX I/O (rm_filex_block_media)

Configuration	Options	Default	Description
Name	Name must be a valid C symbol	g_rm_filex_block_media_0	Module name.
Callback	Name must be a valid C symbol	g_rm_filex_block_media_0_callback	A user callback function can be provided. If this callback function is provided, it will be called when media is inserted or removed. It will also be called during operations by the lower level block media as a way for the user to provide their desired waiting functionality.
Partition Number	0 1 2 3	0	The partition to use for partitioned media. This partition will only be used if a Master Boot Record with partition table exists at block 0 of the media, otherwise the FileX FAT boot record should exist or be formatted to block 0.

Build Time Configurations for fx

The following build time configurations are defined in fsp_cfg/azure/fx/fx_user.h:

Configuration	Options	Default	Description
Common
Max Long Name Len	Value must be an integer greater than or equal to 13 and less than or equal to 256, or empty		Specifies the maximum file name size for FileX. If left blank the default value is 256. Legal values range between 13 and 256.
Max Last Name Len	Value must be an integer greater than or equal to 13 and less than or equal to 256, or empty		This value defines the maximum file name length, which includes full path name. If left blank the default value is 256. Legal values range between 13 and 256.
Max Sector Cache	Value must be an integer greater than 0 and power of 2 or empty		Specifies the maximum number of logical sectors that can be cached by FileX. The actual number of sectors that can be cached is lesser of this constant and how many sectors can fit in the amount of memory supplied at fx_media_open. The default value if left blank is 256. All values must be a power of 2.
Fat Map Size	Value must be an integer greater than 0 or empty		Specifies the number of sectors that can be represented in the FAT update map. The default value if left blank is 256. Larger values help reduce unneeded updates of secondary FAT sectors.
Max Fat Cache	Value must be an integer greater than 0 and power of 2 or empty		Specifies the number of entries in the internal FAT cache. The default value if left blank is 16. All values must be a power of 2.
Threading
Update Rate (Seconds)	Value must be an integer greater than 0 or empty		Specifies rate at which system time in FileX is adjusted. Default value if left blank is 10, specifying that the FileX system time is updated every 10 seconds.
No Timer	Enabled Disabled (default)	Disabled (default)	Eliminates the ThreadX timer setup to update the FileX system time and date. Doing so causes default time and date to be placed on all file operations.
Single Thread	Enabled Disabled (default)	Disabled (default)	Eliminates ThreadX protection logic from the FileX source. It should be used if FileX is being used only from one thread.
Standalone	Enabled Disabled (default)	Disabled (default)	Enables FileX to be used in standalone mode (without Azure RTOS).
Extra Features
Don't Update Open Files	Enabled Disabled (default)	Disabled (default)	When enabled, FileX does not update already opened files.
Media Search Cache	Enabled (default) Disabled	Enabled (default)	When disabled, the file search cache optimization is disabled.
Direct Data Read Cache Fill	Enabled (default) Disabled	Enabled (default)	When disabled, the direct read sector update of cache is disabled.
Media Statistics	Enabled (default) Disabled	Enabled (default)	When disabled, gathering of media statistics is disabled.
Single Open Legacy	Enabled Disabled (default)	Disabled (default)	When enabled, legacy single open logic for the same file is enabled.
Rename Path Inherit	Enabled Disabled (default)	Disabled (default)	When enabled, renaming inherits path information.
No Local Path	Enabled Disabled (default)	Disabled (default)	When enabled, removes local path logic from FileX, resulting in smaller code size.
64-bit LBA	Enabled Disabled (default)	Disabled (default)	When enabled, 64-bits sector addresses are used in I/O driver.
Cache	Enabled (default) Disabled	Enabled (default)	Enables or disables the cache, default is enabled.
File Close	Enabled (default) Disabled	Enabled (default)	Enables or disables file close, default is enabled.
Fast Close	Enabled (default) Disabled	Enabled (default)	Enables or disables fast open, default is enabled.
Force Memory Operation	Enabled (default) Disabled	Enabled (default)	Enables or disables force memory operation, default is enabled.
Build Options	Enabled (default) Disabled	Enabled (default)	Enables or disables build options, default is enabled.
One Line Function	Enabled (default) Disabled	Enabled (default)	Enables or disables one line function, default is enabled.
FAT Entry Refresh	Enabled (default) Disabled	Enabled (default)	Enables or disables FAT entry refresh, default is enabled.
Consecutive Detect	Enabled (default) Disabled	Enabled (default)	Enables or disables consecutive detect, default is enabled.
Enable exFAT	Enabled Disabled (default)	Disabled (default)	Enables exFAT support in FileX.
Fault Tolerant
Fault Tolerant Service	Enabled Disabled (default)	Disabled (default)	When enabled, enables the FileX Fault Tolerant Module. Enabling Fault Tolerant automatically defines the symbol FX_FAULT_TOLERANT and FX_FAULT_TOLERANT_DATA.
Fault Tolerant Data	Enabled Disabled (default)	Disabled (default)	When enabled, FileX immediately passes all file data write requests to the media's driver. This potentially decreases performance, but helps limit lost file data. Note that enabling this feature does not automatically enable FileX Fault Tolerant Module, which should be enabled separately.
Fault Tolerant	Enabled Disabled (default)	Disabled (default)	When enabled, FileX immediately passes write requests of all system sectors (boot, FAT, and directory sectors) to the media's driver. This potentially decreases performance, but helps limit corruption to lost clusters. Note that enabling this feature does not automatically enable FileX Fault Tolerant Module, which should be enabled separately.
Fault Tolerant Boot Index	Value must be an integer greater than or equal to 116 and less than or equal to 119		Defines byte offset in the boot sector where the cluster for the fault tolerant log is. By default if left blank this value is 116. This field takes 4 bytes. Bytes 116 through 119 are chosen because they are marked as reserved by FAT 12/16/32/exFAT specification.
Error Checking	Enabled (default) Disabled	Enabled (default)

Configurations for Storage > Azure RTOS FileX on Block Media

This module can be added to the Stacks tab via New Stack > Storage > Azure RTOS FileX on Block Media.

Configuration	Options	Default	Description
Name	Name must be a valid C symbol	g_fx_media0	Symbol used for media_ptr parameter in FileX APIs
Volume Name	Name must be a maximum of 11 characters	Volume 1	Volume name string, which is a maximum of 11 characters.
Number of FATs	Number of FATs must be an integer greater than 0	1	Number of FATs in the media. The minimal value is 1 for the primary FAT. Values greater than 1 result in additional FAT copies being maintained at run-time.
Directory Entries	Number of Directory Entries must be an integer greater than 0	256	Number of directory entries in the root directory.
Hidden Sectors	Number of Hidden Sectors must be an integer	0	Number of sectors hidden before this media’s boot sector. If using media formatted with multiple partitions this number should correspond to the starting block number for the desired partition.
Total Sectors	Total Sectors must be an integer greater than 0	65536	Total number of sectors in the media. When using a Renesas provided block media implementation, total sectors can be fetched by the infoGet from the block media API. Any removable media must be inserted and initialized first to retrieve this info.
Bytes per Sector	Bytes per Sector must be multiple of 32	512	Number of bytes per sector, which is typically 512. FileX requires this to be a multiple of 32. When using a Renesas provided block media implementation, bytes per sector can be fetched by the infoGet from the block media API. Any removable media must be inserted and initialized first to retrieve this info.
Sectors per Cluster	Sectors per Cluster must be an integer greater than 0	1	Number of sectors in each cluster. The cluster is the minimum allocation unit in a FAT file system.
Volume Serial Number (exFAT only)	Volume Serial Number must be an integer greater than 0	12345	Serial number to be used for this volume. exFAT only.
Boundary Unit (exFAT only)	Boundary unit must be an integer greater than 0	128	Physical data area alignment size, in number of sectors. exFAT only.
Working media memory size	Memory size must be an integer greater than or equal to the size of one sector	512	Memory allocated for file system. Memory size must be an integer greater than or equal to the size of one sector.

Usage Notes

Pending during Read/Write

The FileX Block Media driver provides a number of events in the user callback to handle waiting or pending while it is doing blocking operations. The events received in the callback will differ depending on the lower level block media driver in use.

If the lower level block media driver is rm_block_media_spi (SPI blocks on read/write operations):

• The user will receive RM_BLOCK_MEDIA_EVENT_POLL_STATUS in the user callback while the lower level driver is polling for the read/write operation to be complete. The user can choose to do a thread sleep or software delay upon receiving this event in the callback.
• Once the operation is complete no other callbacks will be received.

If the lower level block media driver is rm_block_media_sdmmc (SDMMC is interrupt based, the FileX Block Media driver will still block while waiting for interrupts from SDMMC):

• The user will receive RM_BLOCK_MEDIA_EVENT_WAIT in the user callback when the FileX Block Media driver begins waiting for an interrupt event from SDMMC. This is sent from a thread context. The user can choose to pend on a semaphore, sleep the thread, or do a software delay upon receiving this event in the callback. The FileX Block Media driver thread will block until an interrupt is received.
• Once an SDMMC interrupt is received the user will receive RM_BLOCK_MEDIA_EVENT_WAIT_END in the user callback. This is sent from an interrupt context. The user can choose to give a semaphore on this event or do nothing.
• If SDMMC is busy on a long erase after receiving the interrupt the FileX Block Media driver will send RM_BLOCK_MEDIA_EVENT_POLL_STATUS to the user callback and proceed to do a blocking poll on SDMMC status. The user can choose to do a thread sleep or software delay upon receiving this event in the callback. This event will not be received by the user on typical operations by FileX.

Partitioned Media

When using fx_format to format a partition the number of hidden sectors should match the starting block number of the partition and the total number of sectors should be equal to the number of sectors in the partition.

Unused User Callback Events

Certain events are defined in rm_block_media_event_t but not returned by the FileX Block Media user callback:

• RM_BLOCK_MEDIA_EVENT_OPERATION_COMPLETE: This event is handled internally and operation success is indicated by FileX API calls returning FX_SUCCESS.
• RM_BLOCK_MEDIA_EVENT_ERROR: This event is handled internally and operation failure will be indicated by an error return code from FileX API calls.

Erasing Flash Memory Prior to Usage

The area of the flash memory being used for the FileX instance should be erased using the lower level flash API prior to usage. Otherwise, FileX open operation may fail when fx_media_open( ) is called.

Examples

Basic Example

This is a basic example of FileX Block Media in an application.

#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_FILE_NAME                "TEST_FILE.txt"
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_BUFFER_SIZE_BYTES        (10240)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_PARTITION_NUMBER         (0)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_BLOCK_SIZE               (512)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_DIRECTORY_ENTRIES    (128)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_FATS                 (1)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_HIDDEN_SECTORS           (0)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_TOTAL_SECTORS            (1073741824)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTOR_SIZE              (512)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTORS_PER_CLUSTER      (1)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_HEADS                (1)
#define RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTORS_PER_TRACK        (1)

extern rm_filex_block_media_instance_t      g_filex_block_media0;
extern rm_filex_block_media_instance_ctrl_t g_filex_block_media0_ctrl;
extern rm_filex_block_media_cfg_t           g_filex_block_media0_cfg;

extern FX_MEDIA g_fx_media0;
extern uint8_t  g_fx_media0_memory[RM_FILEX_BLOCK_MEDIA_EXAMPLE_BLOCK_SIZE];
extern uint8_t  g_file_data[RM_FILEX_BLOCK_MEDIA_EXAMPLE_BUFFER_SIZE_BYTES];
extern uint8_t  g_read_buffer[RM_FILEX_BLOCK_MEDIA_EXAMPLE_BUFFER_SIZE_BYTES];

void rm_filex_block_media_example (void)
{

    /* Open media driver.*/
    fsp_err_t err = RM_FILEX_BLOCK_MEDIA_Open(&g_filex_block_media0_ctrl, &g_filex_block_media0_cfg);


    /* Handle any errors. This function should be defined by the user. */
    assert(FSP_SUCCESS == err);

    /* Initialize FileX */
    fx_system_initialize();

    /* Open the media. If the media is removable, it must be inserted before calling
     * fx_media_open. This assumes the disk is already partitioned and formatted. */
    UINT fx_err = fx_media_open(&g_fx_media0,
                                "filex_example_media",
                                RM_FILEX_BLOCK_MEDIA_BlockDriver,
                                &g_filex_block_media0,
                                g_fx_media0_memory,
                                sizeof(g_fx_media0_memory));
    handle_fx_error(fx_err);

    /* Create a file */
    fx_err = fx_file_create(&g_fx_media0, RM_FILEX_BLOCK_MEDIA_EXAMPLE_FILE_NAME);
    handle_fx_error(fx_err);

    /* Open source file for writing. */
    FX_FILE sourceFile;
    fx_err = fx_file_open(&g_fx_media0, &sourceFile, RM_FILEX_BLOCK_MEDIA_EXAMPLE_FILE_NAME, FX_OPEN_FOR_WRITE);
    handle_fx_error(fx_err);

    /* Write file data. */
    fx_err = fx_file_write(&sourceFile, g_file_data, sizeof(g_file_data));
    handle_fx_error(fx_err);

    /* Close the file. */
    fx_err = fx_file_close(&sourceFile);
    handle_fx_error(fx_err);

    /* Open the source file in read mode. */
    fx_err = fx_file_open(&g_fx_media0, &sourceFile, RM_FILEX_BLOCK_MEDIA_EXAMPLE_FILE_NAME, FX_OPEN_FOR_READ);
    handle_fx_error(fx_err);

    /* Read file data. */
    ULONG actual_size_read;
    fx_err = fx_file_read(&sourceFile, g_read_buffer, sizeof(g_file_data), &actual_size_read);
    handle_fx_error(fx_err);
    assert(sizeof(g_file_data) == actual_size_read);

    /* Close the file. */
    fx_err = fx_file_close(&sourceFile);
    handle_fx_error(fx_err);

    /* Verify the file data read matches the file written. */
    assert(0U == memcmp(g_file_data, g_read_buffer, sizeof(g_file_data)));

    /* Close the Media */
    fx_err = fx_media_close(&g_fx_media0);
    handle_fx_error(fx_err);
}

Format Example

This shows how to partition and format a disk if it is not already partitioned and formatted.

void rm_filex_block_media_format_example (void)
{
    /* Open media driver.*/
    fsp_err_t err = RM_FILEX_BLOCK_MEDIA_Open(&g_filex_block_media0_ctrl, &g_filex_block_media0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    assert(FSP_SUCCESS == err);

    /* Format the media */
    UINT fx_err = fx_media_format(&g_fx_media0,                                       // Pointer to FileX media control block.
                                  RM_FILEX_BLOCK_MEDIA_BlockDriver,                   // Driver entry
                                  &g_filex_block_media0,                              // Pointer to Block Media Driver
                                  g_fx_media0_memory,                                 // Media buffer pointer
                                  sizeof(g_fx_media0_memory),                         // Media buffer size
                                  "EXAMPLE_VOLUME",                                   // Volume Name
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_FATS,              // Number of FATs
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_DIRECTORY_ENTRIES, // Directory Entries
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_HIDDEN_SECTORS,        // Hidden sectors
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_TOTAL_SECTORS,         // Total sectors
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTOR_SIZE,           // Sector size
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTORS_PER_CLUSTER,   // Sectors per cluster
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_HEADS,             // Heads
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTORS_PER_TRACK);    // Sectors per track
    handle_fx_error(fx_err);
}

Callback Pend Example

This shows how to use the I/O driver callback with ThreadX in order to wait/pend for operations to complete.

TX_SEMAPHORE g_operation_wait_semaphore;

/* Callback called by FileX block media I/O driver needs to pend on operation. */
void rm_filex_block_media_test_callback_pend (rm_filex_block_media_callback_args_t * p_args)
{
    if (p_args->event & RM_BLOCK_MEDIA_EVENT_WAIT)
    {
        /* Interrupt has not happened for operation, get semaphore to wait for it. This will be called from the FileX I/O driver thread. */
        tx_semaphore_get(&g_operation_wait_semaphore, TX_WAIT_FOREVER);
    }

    if (p_args->event & RM_BLOCK_MEDIA_EVENT_WAIT_END)
    {
        /* Interrupt has occurred for operation, post semaphore so that wait will end. This will be called from an interrupt context. */
        tx_semaphore_put(&g_operation_wait_semaphore);
    }

    if (p_args->event & RM_BLOCK_MEDIA_EVENT_POLL_STATUS)
    {
        /* Interrupt has been received from block media device but operation is still ongoing. The FileX I/O driver will wait on the driver busy status.
         * This event can be used to put the thread to sleep while waiting. This will be called from the FileX I/O driver thread. */
        tx_thread_sleep(1);
    }
}

void rm_filex_block_media_callback_pend_example (void)
{
    /* Create semaphore for driver use */
    tx_semaphore_create(&g_operation_wait_semaphore, "operation_wait_semaphore", 0);

    /* Open media driver.*/
    fsp_err_t err = RM_FILEX_BLOCK_MEDIA_Open(&g_filex_block_media0_ctrl, &g_filex_block_media0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    assert(FSP_SUCCESS == err);

    /* Format the media */
    UINT fx_err = fx_media_format(&g_fx_media0,                                       // Pointer to FileX media control block.
                                  RM_FILEX_BLOCK_MEDIA_BlockDriver,                   // Driver entry
                                  &g_filex_block_media0,                              // Pointer to Block Media Driver
                                  g_fx_media0_memory,                                 // Media buffer pointer
                                  sizeof(g_fx_media0_memory),                         // Media buffer size
                                  "EXAMPLE_VOLUME",                                   // Volume Name
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_FATS,              // Number of FATs
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_DIRECTORY_ENTRIES, // Directory Entries
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_HIDDEN_SECTORS,        // Hidden sectors
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_TOTAL_SECTORS,         // Total sectors
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTOR_SIZE,           // Sector size
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTORS_PER_CLUSTER,   // Sectors per cluster
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_NUM_HEADS,             // Heads
                                  RM_FILEX_BLOCK_MEDIA_EXAMPLE_SECTORS_PER_TRACK);    // Sectors per track
    handle_fx_error(fx_err);
}

Media Insertion Example

This shows how to use the callback to wait for media insertion.

volatile uint32_t g_rm_filex_block_media_insertion_events = 0;
volatile uint32_t g_rm_filex_block_media_removal_events   = 0;

/* Callback called by media driver when a removable device is inserted or removed. */
void rm_filex_block_media_test_callback (rm_filex_block_media_callback_args_t * p_args)
{
    if (p_args->event & RM_BLOCK_MEDIA_EVENT_MEDIA_INSERTED)
    {
        g_rm_filex_block_media_insertion_events++;
    }

    if (p_args->event & RM_BLOCK_MEDIA_EVENT_MEDIA_REMOVED)
    {
        g_rm_filex_block_media_removal_events++;
    }
}

void rm_filex_block_media_media_insertion_example (void)
{
    /* Open media driver.*/
    fsp_err_t err = RM_FILEX_BLOCK_MEDIA_Open(&g_filex_block_media0_ctrl, &g_filex_block_media0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    assert(FSP_SUCCESS == err);

    /* Wait for media insertion. */
    while (0U == g_rm_filex_block_media_insertion_events)
    {
        /* Wait for media insertion. */
    }

    /* Open the media. If the media is removable, it must be inserted before calling
     * fx_media_open. This assumes the disk is already partitioned and formatted. */
    UINT fx_err = fx_media_open(&g_fx_media0,
                                "filex_example_media",
                                RM_FILEX_BLOCK_MEDIA_BlockDriver,
                                &g_filex_block_media0,
                                g_fx_media0_memory,
                                sizeof(g_fx_media0_memory));
    handle_fx_error(fx_err);
}

Using FileX with Custom Block Media Implementations

When using a Custom Block Media implementation with rm_filex_block_media the custom implementation must call rm_filex_block_media_memory_callback upon the completion of a read/write operation. This callback should be called with an event of RM_BLOCK_MEDIA_EVENT_OPERATION_COMPLETE and p_context of rm_filex_block_media_instance_ctrl_t *. The following example shows how this should be done in the context of a demo RAM block media read function.

#define EXAMPLE_BLOCK_MEDIA_RAM_START_ADDR          (0x20004AFE)
#define EXAMPLE_BLOCK_MEDIA_RAM_BLOCK_SIZE_BYTES    (512)

/* Example implementation of rm_block_media_api_t::read(), user should define custom block media RAM implementation. */
fsp_err_t RM_BLOCK_MEDIA_CUSTOM_RAM_Read (rm_block_media_ctrl_t * const p_ctrl,
                                          uint8_t * const               p_dest_address,
                                          uint32_t const                block_address,
                                          uint32_t const                num_blocks)
{
    FSP_PARAMETER_NOT_USED(p_ctrl);

    memcpy(p_dest_address,
           (void *) (EXAMPLE_BLOCK_MEDIA_RAM_START_ADDR + (block_address * EXAMPLE_BLOCK_MEDIA_RAM_BLOCK_SIZE_BYTES)),
           (EXAMPLE_BLOCK_MEDIA_RAM_BLOCK_SIZE_BYTES * num_blocks));

    /* Notify FileX port of operation complete through calling the callback, this is required for custom block media/FileX port integration */
    rm_block_media_callback_args_t args;
    args.event     = RM_BLOCK_MEDIA_EVENT_OPERATION_COMPLETE;
    args.p_context = (void *) &g_filex_block_media0_ctrl;
    rm_filex_block_media_memory_callback(&args);

    return FSP_SUCCESS;
}

Data Structures
struct	rm_filex_block_media_instance_ctrl_t

---

Data Structure Documentation

rm_filex_block_media_instance_ctrl_t

struct rm_filex_block_media_instance_ctrl_t

Common macro for FSP header files. There is also a corresponding FSP_FOOTER macro at the end of this file. FileX block media private control block. DO NOT MODIFY. Initialization occurs when RM_FILEX_BLOCK_MEDIA_Open is called.

Function Documentation

RM_FILEX_BLOCK_MEDIA_Open()

fsp_err_t RM_FILEX_BLOCK_MEDIA_Open	(	rm_filex_block_media_ctrl_t *const	p_ctrl,
		rm_filex_block_media_cfg_t const *const	p_cfg
	)

The file system relies on the media to be formatted prior to creating directories and files The sector size and sector count will change depending on the media type and size.

The File Allocation Table (FAT) starts after the reserved sectors in the media. The FAT area is basically an array of 12-bit, 16-bit, or 32-bit entries that determine if that cluster is allocated or part of a chain of clusters comprising a subdirectory or a file. The size of each FAT entry is determined by the number of clusters that need to be represented. If the number of clusters (derived from the total sectors divided by the sectors per cluster) is less than 4,086, 12-bit FAT entries are used. If the total number of clusters is greater than 4,086 and less than or equal to 65,525, 16-bit FAT entries are used. Otherwise, if the total number of clusters is greater than 65,525, 32-bit FAT entries are used. Initializes callback and configuration for FileX Block Media interface. Call this before calling any FileX functions.

Implements rm_filex_block_media_api_t::open().

Return values

FSP_SUCCESS	Success.
FSP_ERR_ASSERTION	An input parameter was invalid.
FSP_ERR_ALREADY_OPEN	Module is already open.

Returns

See Common Error Codes or functions called by this function for other possible return codes.

RM_FILEX_BLOCK_MEDIA_Close()

fsp_err_t RM_FILEX_BLOCK_MEDIA_Close

(

rm_filex_block_media_ctrl_t *const

p_ctrl

)

Closes media device.

Implements rm_filex_block_media_api_t::close().

Return values

FSP_SUCCESS	Media device closed.
FSP_ERR_ASSERTION	An input parameter was invalid.
FSP_ERR_NOT_OPEN	Module not open.

Returns

See Common Error Codes or functions called by this function for other possible return codes.

RM_FILEX_BLOCK_MEDIA_BlockDriver()

void RM_FILEX_BLOCK_MEDIA_BlockDriver

(

FX_MEDIA *

p_fx_media

)

Access Block Media device functions open, close, read, write and control.

The RM_FILEX_BLOCK_MEDIA_BlockDriver function is called from the FileX file system driver and issues requests to a Block Media device through the FSP Block Media Interface. Uses block media driver for accesses.

Parameters

[in,out]

p_fx_media

FileX media control block. All information about each open media device are maintained in the FX_MEDIA data type. The I/O driver communicates the success or failure of the request through the fx_media_driver_status member of FX_MEDIA (p_fx_media->fx_media_driver_status). Possible values are documented in the FileX User Guide.

Return values

None

Returns

Nothing, but updates FileX media control block.