270 lines
7.9 KiB
C
270 lines
7.9 KiB
C
/*
|
|
ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "ch.h"
|
|
#include "hal.h"
|
|
#include "sama_sdmmc_lld.h"
|
|
|
|
#if SDMMC_USE_RELEDGE_LIB == 1
|
|
#include "chprintf.h"
|
|
#include <redfs.h>
|
|
#include <redposix.h>
|
|
#include <redfse.h>
|
|
#include <redconf.h>
|
|
#include <redtypes.h>
|
|
#include <redmacs.h>
|
|
#include <redvolume.h>
|
|
|
|
static int32_t format(uint8_t volnum);
|
|
static void readfiles(void);
|
|
static void writefiles(uint8_t volnum);
|
|
|
|
#define fsRAM_BUFFER_SIZE 30
|
|
static char cRAMBuffer[ fsRAM_BUFFER_SIZE ];
|
|
|
|
static const char *pcDirectory1 = "/DIR1", *pcDirectory2 = "/DIR1/DIR2";
|
|
extern BaseSequentialStream * ts;
|
|
extern const VOLCONF gaRedVolConf[REDCONF_VOLUME_COUNT];
|
|
|
|
void relianceedge_demo(void)
|
|
{
|
|
int32_t ret;
|
|
int volnum = 0;
|
|
const char *pszVolume = gaRedVolConf[volnum].pszPathPrefix;
|
|
|
|
chprintf(ts,"Init Reliance Edge FS\r\n" );
|
|
ret = red_init();
|
|
|
|
chprintf(ts,"Start formatting fs ... " );
|
|
ret = format(volnum);
|
|
|
|
if ( ret == 0 )
|
|
{
|
|
chprintf(ts,"OK , mounting volume .." );
|
|
|
|
ret = red_mount(pszVolume);
|
|
if ( ret == 0 )
|
|
{
|
|
chprintf(ts,"OK\r\n writing files ..\r\n" );
|
|
writefiles(volnum);
|
|
chprintf(ts,"OK\r\n reading files ..\r\n" );
|
|
readfiles();
|
|
chprintf(ts,"OK\r\n" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chprintf(ts,"FAILED! \r\n" );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void writefiles(uint8_t volnum)
|
|
{
|
|
uint32_t i, j;
|
|
char path[ 64 ];
|
|
const uint32_t filen = 5;
|
|
|
|
uint32_t ulEventMask;
|
|
int32_t written, filedescr, status;
|
|
int iByte;
|
|
|
|
const char *pszVolume = gaRedVolConf[volnum].pszPathPrefix;
|
|
/* Save the current transaction point settings. */
|
|
status = red_gettransmask( pszVolume, &ulEventMask );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Disable automatic transaction points so that all of the files can be
|
|
created in one atomic operation. */
|
|
status = red_settransmask( pszVolume, RED_TRANSACT_MANUAL );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Create filen files. Each created file will be
|
|
( i * fsRAM_BUFFER_SIZE ) bytes in length, and filled
|
|
with a different repeating character. */
|
|
for( i = 1; i <= filen; i++ )
|
|
{
|
|
/* Generate a file name. */
|
|
sprintf( path, "/root%03d.txt", (int)i );
|
|
|
|
/* Print out the file name and the directory into which the file is
|
|
being written. */
|
|
chprintf(ts,"Creating file %s\r\n", path );
|
|
|
|
/* Open the file, creating the file if it does not already exist. */
|
|
filedescr = red_open( path, RED_O_CREAT|RED_O_TRUNC|RED_O_WRONLY );
|
|
osalDbgCheck( filedescr != -1 );
|
|
|
|
/* Fill the RAM buffer with data that will be written to the file. This
|
|
is just a repeating ascii character that indicates the file number. */
|
|
memset( cRAMBuffer, ( int ) ( '0' + i ), fsRAM_BUFFER_SIZE );
|
|
|
|
/* Write the RAM buffer to the opened file a number of times. The
|
|
number of times the RAM buffer is written to the file depends on the
|
|
file number, so the length of each created file will be different. */
|
|
for( j = 0; j < i; j++ )
|
|
{
|
|
written = red_write( filedescr, cRAMBuffer, fsRAM_BUFFER_SIZE );
|
|
osalDbgCheck( written == fsRAM_BUFFER_SIZE );
|
|
}
|
|
|
|
/* Close the file so another file can be created. */
|
|
status = red_close( filedescr );
|
|
osalDbgCheck( status == 0 );
|
|
}
|
|
|
|
/* Commit a transaction point, atomically adding the set of files to the
|
|
transacted state. */
|
|
status = red_transact( pszVolume );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Create a sub directory. */
|
|
chprintf(ts,"Creating directory %s\r\n", pcDirectory1 );
|
|
|
|
status = red_mkdir( pcDirectory1 );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Create a subdirectory in the new directory. */
|
|
chprintf(ts, "Creating directory %s\r\n", pcDirectory2 );
|
|
|
|
status = red_mkdir( pcDirectory2 );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Generate the file name. */
|
|
sprintf( path, "%s/file.txt", pcDirectory2 );
|
|
|
|
/* Print out the file name and the directory into which the file is being
|
|
written. */
|
|
chprintf(ts, "Writing file %s\r\n", path );
|
|
|
|
filedescr = red_open( path, RED_O_CREAT|RED_O_TRUNC|RED_O_WRONLY );
|
|
|
|
/* Write the file. It is filled with incrementing ascii characters starting
|
|
from '0'. */
|
|
for( iByte = 0; iByte < fsRAM_BUFFER_SIZE; iByte++ )
|
|
{
|
|
cRAMBuffer[ iByte ] = ( char ) ( ( int ) '0' + iByte );
|
|
}
|
|
|
|
written = red_write( filedescr, cRAMBuffer, fsRAM_BUFFER_SIZE );
|
|
osalDbgCheck( written == fsRAM_BUFFER_SIZE );
|
|
|
|
/* Finished so close the file. */
|
|
status = red_close( filedescr );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Commit a transaction point, atomically adding the set of files and
|
|
directories to the transacted state. */
|
|
status = red_transact( pszVolume );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
/* Restore previous transaction point settings. */
|
|
status = red_settransmask( pszVolume, ulEventMask );
|
|
osalDbgCheck( status == 0 );
|
|
}
|
|
|
|
static void readfiles(void)
|
|
{
|
|
uint32_t i, j;
|
|
char path[ 64 ];
|
|
const uint32_t filen = 5;
|
|
long lChar;
|
|
int32_t lBytesRead, filedescr, status;
|
|
int iByte;
|
|
|
|
|
|
/* Read back the files that were created by prvCreateDemoFiles(). */
|
|
for( i = 1; i <= filen; i++ )
|
|
{
|
|
/* Generate the file name. */
|
|
sprintf( path, "/root%03d.txt",(int) i );
|
|
|
|
/* Print out the file name and the directory from which the file is
|
|
being read. */
|
|
chprintf(ts,"Reading file %s\r\n", path );
|
|
|
|
/* Open the file for reading. */
|
|
filedescr = red_open( path, RED_O_RDONLY );
|
|
osalDbgCheck( filedescr != -1 );
|
|
|
|
/* Read the file into the RAM buffer, checking the file contents are as
|
|
expected. The size of the file depends on the file number. */
|
|
for( j = 0; j < i; j++ )
|
|
{
|
|
/* Start with the RAM buffer clear. */
|
|
memset( cRAMBuffer, 0x00, fsRAM_BUFFER_SIZE );
|
|
|
|
lBytesRead = red_read( filedescr, cRAMBuffer, fsRAM_BUFFER_SIZE );
|
|
osalDbgCheck( lBytesRead == fsRAM_BUFFER_SIZE );
|
|
|
|
/* Check the RAM buffer is filled with the expected data. Each
|
|
file contains a different repeating ascii character that indicates
|
|
the number of the file. */
|
|
for( lChar = 0; lChar < fsRAM_BUFFER_SIZE; lChar++ )
|
|
{
|
|
osalDbgCheck( cRAMBuffer[ lChar ] == ( '0' + ( char ) i ) );
|
|
}
|
|
}
|
|
|
|
/* Close the file. */
|
|
status = red_close( filedescr );
|
|
osalDbgCheck( status == 0 );
|
|
}
|
|
|
|
/* Generate the file name. */
|
|
sprintf( path, "%s/file.txt", pcDirectory2 );
|
|
|
|
/* Print out the file name and the directory from which the file is being
|
|
read. */
|
|
chprintf(ts, "Reading file %s\r\n", path );
|
|
|
|
/* This time the file is opened for reading. */
|
|
filedescr = red_open( path, RED_O_RDONLY );
|
|
osalDbgCheck( filedescr != -1 );
|
|
|
|
/* Read the file. */
|
|
lBytesRead = red_read( filedescr, cRAMBuffer, fsRAM_BUFFER_SIZE );
|
|
osalDbgCheck( lBytesRead == fsRAM_BUFFER_SIZE );
|
|
|
|
/* Verify the file 1 byte at a time. */
|
|
for( iByte = 0; iByte < fsRAM_BUFFER_SIZE; iByte++ )
|
|
{
|
|
osalDbgCheck( cRAMBuffer[ iByte ] == ( char ) ( ( int ) '0' + iByte ) );
|
|
}
|
|
|
|
/* Finished so close the file. */
|
|
status = red_close( filedescr );
|
|
osalDbgCheck( status == 0 );
|
|
|
|
}
|
|
|
|
|
|
static int32_t format(uint8_t volnum)
|
|
{
|
|
int32_t ret=-1;
|
|
#if REDCONF_API_POSIX_FORMAT == 1
|
|
const char *pszVolume = gaRedVolConf[volnum].pszPathPrefix;
|
|
ret = red_format(pszVolume);
|
|
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
#endif
|
|
|