eaw/TZFS
1
0
Fork 0
Code Issues Packages Projects Releases 1 Wiki Activity
Files
44d8c635f89b17492793517d0a57a336e192d1cd
TZFS/zOS/MZ2000/common/tools.c

1297 lines
40 KiB
C
Raw Blame History

////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Name: tools.c
// Created: January 2019
// Author(s): Philip Smart
// Description: zOS tools.
// A set of tools to be used by zOS application.
//
// Credits:
// Copyright: (c) 2019 Philip Smart <philip.smart@net2net.org>
//
// History: January 2019 - Initial script written.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// This source file is free software: you can redistribute it and#or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This source file is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#endif
#if defined __ZPU__
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "uart.h"
#include "zpu_soc.h"
#elif defined __K64F__
#if ! defined __APP__
#include <WProgram.h>
#endif
#include "k64f_soc.h"
#elif defined __M68K__
#endif
#if defined(__SD_CARD__)
#include "ff.h"
#endif
#include "utils.h"
#include "tools.h"
#if (defined(__ZPUTA__) || defined(__ZOS__)) && !defined(__APP__)
// Method to decode a command into a key which is used to select the associated command logic.
//
int16_t decodeCommand(char **ptr)
{
uint8_t idx;
char *paramptr = (*ptr);
// If no command entered, exit.
if(*ptr == 0x0)
return CMD_NOKEY;
// Find the end of the command and terminate it for comparison.
while(*paramptr == ' ') paramptr++;
// Loop through all the commands and try to find a match.
for (idx=0; idx < NCMDKEYS; idx++)
{
t_cmdstruct *sym = &cmdTable[idx];
if (strncmp(sym->cmd, paramptr, strlen(sym->cmd)) == 0 && sym->builtin == 1)
{
paramptr += strlen(sym->cmd);
(*ptr) = paramptr;
return sym->key;
}
}
// No command found, so raise error.
return CMD_BADKEY;
}
// Method to obtain and return the output screen width.
//
uint8_t getScreenWidth(void)
{
#if defined __SHARPMZ__
return(mzGetScreenWidth());
#else
return(MAX_SCREEN_WIDTH);
#endif
}
#endif
#if defined(__SD_CARD__)
// List of known filesystem types.
static const char* const fileSystemTypeTable[] = {"", "FAT12", "FAT16", "FAT32", "exFAT"};
BYTE fsBuff[SECTOR_SIZE]; /* File system working buffer */
DWORD AccSize;
WORD AccFiles;
WORD AccDirs;
uint32_t blockLen = SECTOR_SIZE;
// Function to write out result code after a FatFS call.
//
#if !defined(__APP__)
void printFSCode(FRESULT result)
{
switch(result)
{
case FR_DISK_ERR:
puts("Disk Error");
break;
case FR_INT_ERR:
puts("Internal error.");
break;
case FR_NOT_READY:
puts("Disk not ready.");
break;
case FR_NO_FILE:
puts("No file found.");
break;
case FR_NO_PATH:
puts("No path found.");
break;
case FR_INVALID_NAME:
puts("Invalid filename.");
break;
case FR_DENIED:
puts("Access denied.");
break;
case FR_EXIST:
puts("File already exists.");
break;
case FR_INVALID_OBJECT:
puts("File handle invalid.");
break;
case FR_WRITE_PROTECTED:
puts("SD is write protected.");
break;
case FR_INVALID_DRIVE:
puts("Drive number is invalid.");
break;
case FR_NOT_ENABLED:
puts("Disk not enabled.");
break;
case FR_NO_FILESYSTEM:
puts("No compatible filesystem found on disk.");
break;
case FR_MKFS_ABORTED:
puts("Format aborted.");
break;
case FR_TIMEOUT:
puts("Timeout, operation cancelled.");
break;
case FR_LOCKED:
puts("File is locked.");
break;
case FR_NOT_ENOUGH_CORE:
puts("Insufficient memory.");
break;
case FR_TOO_MANY_OPEN_FILES:
puts("Too many open files.");
break;
case FR_INVALID_PARAMETER:
puts("Parameters incorrect.");
break;
case FR_OK:
puts("Success.");
break;
default:
puts("Unknown error.");
break;
}
}
#endif
// Method to calculate throughput of an SD transaction and display.
//
void printBytesPerSec(uint32_t bytes, uint32_t mSec, const char *action)
{
uint32_t bytesPerSec;
if(mSec < 1000)
{
bytesPerSec = bytes * 1000 / mSec;
} else
{
bytesPerSec = bytes / (mSec / 1000);
}
printf("\n%lu bytes %s at %lu bytes/sec.\n", bytes, action, bytesPerSec);
}
// Method to scan a directory and return the list of filenames present therein.
//
#if defined(BUILTIN_FS_STATUS) && BUILTIN_FS_STATUS == 1
FRESULT scan_files(char* path) /* Pointer to the working buffer with start path */
{
DIR dirs;
int i;
FILINFO Finfo;
FRESULT fr;
fr = f_opendir(&dirs, path);
if (fr == FR_OK) {
while (((fr = f_readdir(&dirs, &Finfo)) == FR_OK) && Finfo.fname[0]) {
if (Finfo.fattrib & AM_DIR) {
AccDirs++;
i = strlen(path);
path[i] = '/'; strcpy(path+i+1, Finfo.fname);
fr = scan_files(path);
path[i] = 0;
if (fr != FR_OK) break;
} else {
AccFiles++;
AccSize += Finfo.fsize;
}
}
}
return fr;
}
// Method to print out the logical drive status information.
//
FRESULT printFatFSStatus(char *path)
{
uint32_t labelPtr;
uint32_t dspacePtr;
FATFS *fsPtr;
FRESULT fr0;
FRESULT fr1;
// Get space information
fr0 = f_getfree(path, (DWORD*)&dspacePtr, &fsPtr);
if(!fr0)
{
printf("FAT type = %s\nBytes/Cluster = %lu\nNumber of FATs = %u\n"
"Root DIR entries = %u\nSectors/FAT = %lu\nNumber of clusters = %lu\n"
"Volume start (lba) = %lu\nFAT start (lba) = %lu\nDIR start (lba,clustor) = %lu\nData start (lba) = %lu\n\n",
fileSystemTypeTable[fsPtr->fs_type], (DWORD)fsPtr->csize * SECTOR_SIZE, fsPtr->n_fats,
fsPtr->n_rootdir, fsPtr->fsize, fsPtr->n_fatent - 2,
fsPtr->volbase, fsPtr->fatbase, fsPtr->dirbase, fsPtr->database);
#if FF_USE_LABEL
// Get disk label information.
fr0 = f_getlabel(path, (char*)fsBuff, (DWORD*)&labelPtr);
if(!fr0)
{
printf(fsBuff[0] ? "Volume name is %s\n" : "No volume label\n", fsBuff);
printf("Volume S/N is %04X-%04X\n", (WORD)((DWORD)labelPtr >> 16), (WORD)(labelPtr & 0xFFFF));
}
#endif
printf("...");
// Get number of files, directories and space used.
AccSize = AccFiles = AccDirs = 0;
strcpy((char*)fsBuff, path);
fr1 = scan_files((char*)fsBuff);
}
if(!fr0 && !fr1)
{
printf("%u files, %lu bytes.\n%u folders.\n"
"%lu KB total disk space.\n%lu KB available.\n",
AccFiles, AccSize, AccDirs,
(fsPtr->n_fatent - 2) * fsPtr->csize / 2, dspacePtr * fsPtr->csize / 2);
}
return(fr0 ? fr0 : (fr1 ? fr1 : FR_OK));
}
#endif
// Method to print out the files in a directory of a given (or default) directory.
#if defined(BUILTIN_FS_DIRLIST) && BUILTIN_FS_DIRLIST == 1
FRESULT printDirectoryListing(char *path)
{
// Locals.
uint32_t dirCount;
uint32_t fileCount;
uint32_t totalSize;
DIR Dir;
FRESULT fr0;
FILINFO fInfo;
FATFS *fsPtr;
// Open the directory for given path (path == NULL -> current path).
fr0 = f_opendir(&Dir, path);
// No errors then process.
if(!fr0)
{
totalSize = fileCount = dirCount = 0;
do {
// Get one entry in the directory.
fr0 = f_readdir(&Dir, &fInfo);
if(!fr0 && fInfo.fname[0])
{
if (fInfo.fattrib & AM_DIR) {
dirCount++;
} else {
fileCount++; totalSize += fInfo.fsize;
}
printf("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n",
(fInfo.fattrib & AM_DIR) ? 'D' : '-',
(fInfo.fattrib & AM_RDO) ? 'R' : '-',
(fInfo.fattrib & AM_HID) ? 'H' : '-',
(fInfo.fattrib & AM_SYS) ? 'S' : '-',
(fInfo.fattrib & AM_ARC) ? 'A' : '-',
(fInfo.fdate >> 9) + 1980, (fInfo.fdate >> 5) & 15, fInfo.fdate & 31,
(fInfo.ftime >> 11), (fInfo.ftime >> 5) & 63,
(DWORD)fInfo.fsize,
fInfo.fname);
}
} while(!fr0 && fInfo.fname[0]);
if(!fr0)
{
printf("%4lu File(s),%10lu bytes total\n%4lu Dir(s)", fileCount, totalSize, dirCount);
if (f_getfree(path, (DWORD*)&totalSize, &fsPtr) == FR_OK)
{
printf(", %10luKiB free\n", totalSize * fsPtr->csize / 2);
}
}
}
return(fr0 ? fr0 : FR_OK);
}
#endif
// Method to concatenate two source files into one destination file.
//
#if defined(BUILTIN_FS_CONCAT) && BUILTIN_FS_CONCAT == 1
FRESULT fileConcatenate(char *src1, char *src2, char *dst)
{
// Locals.
//
FIL File[3];
uint32_t dstSize = 0L;
uint32_t perfTime = 0L;
unsigned int readSize;
unsigned int writeSize;
FRESULT fr0;
FRESULT fr1;
FRESULT fr2;
// Sanity check on filenames.
if(src1 == NULL || src2 == NULL || dst == NULL)
return(FR_INVALID_PARAMETER);
// Try and open the source files and create the destination file.
fr0 = f_open(&File[0], src1, FA_OPEN_EXISTING | FA_READ);
fr1 = f_open(&File[1], src2, FA_OPEN_EXISTING | FA_READ);
fr2 = f_open(&File[2], dst, FA_CREATE_ALWAYS | FA_WRITE);
// If no errors in opening the files, proceed with concatenation.
if(!fr0 && !fr1 && !fr2)
{
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
dstSize = 0;
for (;;) {
fr0 = f_read(&File[0], fsBuff, SECTOR_SIZE, &readSize);
if (fr0 || readSize == 0) break; // error or eof
fr2 = f_write(&File[2], fsBuff, readSize, &writeSize);
dstSize += writeSize;
if (fr2 || writeSize < readSize) break; // error or disk full
}
if(!fr0 && !fr2)
{
for (;;) {
fr1 = f_read(&File[1], fsBuff, SECTOR_SIZE, &readSize);
if (fr1 || readSize == 0) break; // error or eof
fr2 = f_write(&File[2], fsBuff, readSize, &writeSize);
dstSize += writeSize;
if (fr2 || writeSize < readSize) break; // error or disk full
}
}
}
// Close to sync files.
f_close(&File[0]);
f_close(&File[1]);
f_close(&File[2]);
// Any errors occured, dont print out timings.
if(!fr0 && !fr1 && !fr2)
#if defined __ZPU__
printBytesPerSec(dstSize, TIMER_MILLISECONDS_UP, "copied");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(dstSize, perfTime - *G->millis, "copied");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(dstSize, perfTime - millis(), "copied");
#elif defined __M68K__
printBytesPerSec(dstSize, TIMER_MILLISECONDS_UP, "copied");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : (fr1 ? fr1 : (fr2 ? fr2 : FR_OK)));
}
#endif
// Method to copy a file to a destination. The filenames should be fully qualified if using
// multiple drives.
//
#if defined(BUILTIN_FS_COPY) && BUILTIN_FS_COPY == 1
FRESULT fileCopy(char *src, char *dst)
{
// Locals.
//
FIL File[2];
uint32_t dstSize = 0L;
uint32_t perfTime = 0L;
unsigned int readSize;
unsigned int writeSize;
FRESULT fr0;
FRESULT fr1;
// Sanity check on filenames.
if(src == NULL || dst == NULL)
return(FR_INVALID_PARAMETER);
// Try and open the source file and create the destination file.
fr0 = f_open(&File[0], src, FA_OPEN_EXISTING | FA_READ);
fr1 = f_open(&File[1], dst, FA_CREATE_ALWAYS | FA_WRITE);
// If no errors in opening the files, proceed with concatenation.
if(!fr0 && !fr1)
{
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
dstSize = 0;
for (;;) {
fr0 = f_read(&File[0], fsBuff, SECTOR_SIZE, &readSize);
if (fr0 || readSize == 0) break; // error or eof
fr1 = f_write(&File[1], fsBuff, readSize, &writeSize);
dstSize += writeSize;
if (fr1 || writeSize < readSize) break; // error or disk full
}
}
// Close to sync files.
f_close(&File[0]);
f_close(&File[1]);
// Any errors occured, close files and return error code else return OK.
if(!fr0 && !fr1)
#if defined __ZPU__
printBytesPerSec(dstSize, TIMER_MILLISECONDS_UP, "copied");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(dstSize, perfTime - *G->millis, "copied");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(dstSize, perfTime - millis(), "copied");
#elif defined __M68K__
printBytesPerSec(dstSize, TIMER_MILLISECONDS_UP, "copied");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : (fr1 ? fr1 : FR_OK));
}
#endif
// Method to extract a portion of a source file and write it into a destination file.
// multiple drives.
//
#if defined(BUILTIN_FS_XTRACT) && BUILTIN_FS_XTRACT == 1
FRESULT fileXtract(char *src, char *dst, uint32_t startPos, uint32_t len)
{
// Locals.
//
FIL File[2];
uint32_t sizeToRead;
uint32_t dstSize = 0L;
uint32_t perfTime = 0L;
unsigned int readSize;
unsigned int writeSize;
FRESULT fr0;
FRESULT fr1;
// Sanity check on filenames.
if(src == NULL || dst == NULL)
return(FR_INVALID_PARAMETER);
// Try and open the source file and create the destination file.
fr0 = f_open(&File[0], src, FA_OPEN_EXISTING | FA_READ);
fr1 = f_open(&File[1], dst, FA_CREATE_ALWAYS | FA_WRITE);
// If no errors in opening the files, proceed with copying.
if(!fr0 && !fr1)
{
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
dstSize = 0;
// Seek to start position in file and commence copying.
fr0 = f_lseek(&File[0], startPos);
if(!fr0)
{
for (;;) {
sizeToRead = (len-dstSize) > SECTOR_SIZE ? SECTOR_SIZE : len - dstSize;
fr0 = f_read(&File[0], fsBuff, sizeToRead, &readSize);
if (fr0 || readSize == 0) break; // error or eof
fr1 = f_write(&File[1], fsBuff, readSize, &writeSize);
dstSize += writeSize;
if (fr1 || writeSize < readSize) break; // error or disk full
}
}
}
// Close to sync files.
f_close(&File[0]);
f_close(&File[1]);
// Any errors occured, dont print out timings.
if(!fr0 && !fr1)
#if defined __ZPU__
printBytesPerSec(dstSize, TIMER_MILLISECONDS_UP, "copied");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(dstSize, perfTime - *G->millis, "copied");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(dstSize, perfTime - millis(), "copied");
#elif defined __M68K__
printBytesPerSec(dstSize, TIMER_MILLISECONDS_UP, "copied");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : (fr1 ? fr1 : FR_OK));
}
#endif
// Method to cat/output a file to the screen.
//
#if defined(BUILTIN_FS_CAT) && BUILTIN_FS_CAT == 1
FRESULT fileCat(char *src)
{
// Locals.
//
FIL File[1];
unsigned int readSize;
int idx;
FRESULT fr0;
// Sanity check on filenames.
if(src == NULL)
return(FR_INVALID_PARAMETER);
// Try and open the source file.
fr0 = f_open(&File[0], src, FA_OPEN_EXISTING | FA_READ);
// If no errors in opening the files, proceed with reading.
if(!fr0)
{
while ((fr0 = f_read(&File[0], fsBuff, SECTOR_SIZE, &readSize)) == FR_OK)
{
if (fr0 || readSize == 0) break; /* error or eof */
idx=0;
do {
fputc(fsBuff[idx], stdout);
} while(idx++ < readSize);
if (f_eof(&File[0])) break;
}
fputc('\n', stdout);
}
// Close to sync files.
f_close(&File[0]);
// Any errors occured, pass back to caller.
return(fr0 ? fr0 : FR_OK);
}
#endif
// Method to load a file into memory.
//
#if defined(BUILTIN_FS_LOAD) && BUILTIN_FS_LOAD == 1
FRESULT fileLoad(char *src, uint32_t addr, uint8_t showStats)
{
// Locals.
//
FIL File[1];
uint32_t loadSize = 0L;
uint32_t perfTime = 0L;
unsigned int readSize;
char *memPtr = (char *)addr;
FRESULT fr0;
// Sanity check on filenames.
if(src == NULL || addr < 0x400)
return(FR_INVALID_PARAMETER);
// Try and open the source file.
fr0 = f_open(&File[0], src, FA_OPEN_EXISTING | FA_READ);
// If no errors in opening the file, proceed with reading and loading into memory.
if(!fr0)
{
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
loadSize = 0;
for (;;) {
fr0 = f_read(&File[0], memPtr, SECTOR_SIZE, &readSize);
if (fr0 || readSize == 0) break; /* error or eof */
loadSize += readSize;
memPtr += readSize;
}
}
// Close to sync files.
f_close(&File[0]);
// Any errors occured, dont print out timings.
if(!fr0 && showStats)
#if defined __ZPU__
printBytesPerSec(loadSize, TIMER_MILLISECONDS_UP, "read");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(loadSize, perfTime - *G->millis, "read");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(loadSize, perfTime - millis(), "read");
#elif defined __M68K__
printBytesPerSec(loadSize, TIMER_MILLISECONDS_UP, "read");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : FR_OK);
}
#endif
// Method to save memory contents into a file.
//
#if defined(BUILTIN_FS_SAVE) && BUILTIN_FS_SAVE == 1
FRESULT fileSave(char *dst, uint32_t addr, uint32_t len)
{
// Locals.
//
FIL File[1];
uint32_t saveSize = 0L;
uint32_t perfTime = 0L;
uint32_t sizeToWrite;
unsigned int writeSize;
char *memPtr = (char *)addr;
FRESULT fr0;
// Sanity check on filenames.
if(dst == NULL || len == 0)
return(FR_INVALID_PARAMETER);
// Try and create the destination file.
fr0 = f_open(&File[0], dst, FA_CREATE_ALWAYS | FA_WRITE);
// If no errors in creating the file, proceed with reading memory and saving.
if(!fr0)
{
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
saveSize = 0;
for (;;) {
sizeToWrite = (len-saveSize) > SECTOR_SIZE ? SECTOR_SIZE : len - saveSize;
fr0 = f_write(&File[0], (char *)memPtr, sizeToWrite, &writeSize);
saveSize += writeSize;
memPtr += writeSize;
if (fr0 || writeSize < sizeToWrite || saveSize >= len) break; // error, disk full or range written.
}
}
// Close to sync files.
f_close(&File[0]);
// Any errors occured, dont print out timings.
if(!fr0)
#if defined __ZPU__
printBytesPerSec(saveSize, TIMER_MILLISECONDS_UP, "written");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(saveSize, perfTime - *G->millis, "written");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(saveSize, perfTime - millis(), "written");
#elif defined __M68K__
printBytesPerSec(saveSize, TIMER_MILLISECONDS_UP, "written");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : FR_OK);
}
#endif
// Method to dump a file in hex.
//
#if defined(BUILTIN_FS_DUMP) && BUILTIN_FS_DUMP == 1
FRESULT fileDump(char *src, uint32_t width)
{
// Locals.
//
FIL File[1];
uint32_t sizeToRead;
uint32_t perfTime = 0L;
uint32_t loadSize = 0L;
unsigned int readSize;
FRESULT fr0;
// Sanity check on parameters.
if(src == NULL || (width != 8 && width != 16 && width != 32))
return(FR_INVALID_PARAMETER);
// Try and open the source file.
fr0 = f_open(&File[0], src, FA_OPEN_EXISTING | FA_READ);
// If no errors in opening the file, proceed with reading into the buffer then printing out buffer in hex.
if(!fr0)
{
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
loadSize = 0;
for (;;) {
sizeToRead = (f_size(&File[0])-loadSize) > SECTOR_SIZE ? SECTOR_SIZE : f_size(&File[0]) - loadSize;
fr0 = f_read(&File[0], fsBuff, sizeToRead, &readSize);
if (fr0 || readSize == 0) break; /* error or eof */
if(memoryDump((uint32_t)fsBuff, readSize, width, loadSize, 0) == 0) { break; }
loadSize += readSize;
}
}
// Close to sync files.
f_close(&File[0]);
// Any errors occured, dont print out timings.
if(!fr0)
#if defined __ZPU__
printBytesPerSec(loadSize, TIMER_MILLISECONDS_UP, "read");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(loadSize, perfTime - *G->millis, "read");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(loadSize, perfTime - millis(), "read");
#elif defined __M68K__
printBytesPerSec(loadSize, TIMER_MILLISECONDS_UP, "read");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : FR_OK);
}
#endif
#if defined __ZPU__
extern uint32_t _memreg;
#endif
// Method to load a file into memory and execute it.
//
#if defined(BUILTIN_FS_EXEC) && BUILTIN_FS_EXEC == 1
uint32_t fileExec(char *src, uint32_t addr, uint32_t execAddr, uint8_t execMode, uint32_t param1, uint32_t param2, uint32_t G, uint32_t cfg)
{
// Locals.
//
uint32_t retCode = 0xffffffff;
#if defined __K64F__
// Need to set bit 0 of the vector to ensure T(humb) flag is set otherwise an invalid state fault will occur. The compiler should do this but the declaration of the
// function based on an address seems to confuse it.
execAddr += 1;
uint32_t (*func)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t) = (uint32_t (*)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t))execAddr;
#elif defined __ZPU__
uint32_t (*func)(uint32_t, uint32_t, uint32_t *, uint32_t, uint32_t, uint32_t) = (uint32_t (*)(uint32_t, uint32_t, uint32_t *, uint32_t, uint32_t, uint32_t))execAddr;
#elif defined __M68K__
uint32_t (*func)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t) = (uint32_t (*)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t))execAddr;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
void *gotoptr = (void *)execAddr;
FRESULT fr0;
// Load the file.
fr0 = fileLoad(src, addr, 0);
// If no errors occurred,
if(!fr0)
{
switch(execMode)
{
// Call the loaded program entry address, return expected.
case EXEC_MODE_CALL:
#if defined __ZPU__
//printf("0=%08lx, 1=%08lx, 2=%08lx, _IOB=%08lx %08lx %08lx\n", __iob[0], __iob[1], __iob[2], (uint32_t)(__iob), (uint32_t *)__iob, __iob );
//printf("ExecAddr=%08lx, execMode=%02x, param1=%08lx, param2=%08lx, G=%08lx, cfg=%08lx\n", execAddr, execMode, param1, param2, G, cfg);
retCode = func(param1, param2, &_memreg, G, cfg, (uint32_t)__iob);
#elif defined __K64F__
retCode = func(param1, param2, G, cfg, (uint32_t)stdin, (uint32_t)stdout, (uint32_t)stderr);
#elif defined __M68K__
retCode = func(param1, param2, G, cfg, (uint32_t)stdin, (uint32_t)stdout, (uint32_t)stderr);
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
break;
// Jump to the loaded program entry address, no return expected.
case EXEC_MODE_JMP:
goto *gotoptr;
break;
default:
break;
}
}
return(retCode);
}
#endif
// Method to read an open file block into buffer.
//
#if defined(BUILTIN_FS_READ) && BUILTIN_FS_READ == 1
FRESULT fileBlockRead(FIL *fp, uint32_t len)
{
// Locals.
//
uint32_t loadSize = len;
uint32_t perfTime = 0L;
uint32_t sizeToRead;
unsigned int readSize;
FRESULT fr0 = FR_OK;
// Sanity check on filehandle.
if(fp == NULL || len > SECTOR_SIZE)
return(FR_INVALID_PARAMETER);
// Load the requested data from the file into the buffer in the given blockLen chunks.
loadSize = 0;
f_lseek(fp, 0);
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
while (loadSize && !fr0) {
if (loadSize >= blockLen) { sizeToRead = blockLen; loadSize -= blockLen; }
else { sizeToRead = (WORD)loadSize; loadSize = 0; }
fr0 = f_read(fp, &fsBuff[loadSize], sizeToRead, &readSize);
if(!fr0)
{
loadSize += readSize;
if (sizeToRead != readSize) break;
}
}
// Any errors occured, dont print out timings.
if(!fr0)
#if defined __ZPU__
printBytesPerSec(loadSize, TIMER_MILLISECONDS_UP, "read");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(loadSize, perfTime - *G->millis, "read");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(loadSize, perfTime - millis(), "read");
#elif defined __M68K__
printBytesPerSec(loadSize, TIMER_MILLISECONDS_UP, "read");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : FR_OK);
}
#endif
// Method to write a portion of the buffer into an open file.
//
#if defined(BUILTIN_FS_WRITE) && BUILTIN_FS_WRITE == 1
FRESULT fileBlockWrite(FIL *fp, uint32_t len)
{
// Locals.
//
uint32_t saveSize = len;
uint32_t sizeToWrite;
uint32_t perfTime = 0L;
unsigned int writeSize;
FRESULT fr0 = FR_OK;
// Sanity check on filehandle.
if(fp == NULL || len > SECTOR_SIZE)
return(FR_INVALID_PARAMETER);
// Save the requested data into the file at the current file position.
#if defined __ZPU__
TIMER_MILLISECONDS_UP = 0;
#elif defined __K64F__ && defined (__APP__)
perfTime = *G->millis;
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
perfTime = millis();
#elif defined __M68K__
TIMER_MILLISECONDS_UP = 0;
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
while (saveSize && !fr0) {
if (saveSize >= blockLen) { sizeToWrite = blockLen; saveSize -= blockLen; }
else { sizeToWrite = (WORD)saveSize; saveSize = 0; }
fr0 = f_write(fp, fsBuff, sizeToWrite, &writeSize);
if(!fr0)
{
if (sizeToWrite != writeSize) break;
}
}
// Any errors occured, dont print out timings.
if(!fr0)
#if defined __ZPU__
printBytesPerSec(len, TIMER_MILLISECONDS_UP, "written");
#elif defined __K64F__ && defined (__APP__)
printBytesPerSec(len, perfTime - *G->millis, "written");
#elif defined __K64F__ && (defined (__ZPUTA__) || defined (__ZOS__))
printBytesPerSec(len, perfTime - millis(), "written");
#elif defined __M68K__
printBytesPerSec(len, TIMER_MILLISECONDS_UP, "written");
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
return(fr0 ? fr0 : FR_OK);
}
#endif
// Method to dump out the current buffer in hex for inspection.
//
#if defined(BUILTIN_FS_INSPECT) && BUILTIN_FS_INSPECT == 1
FRESULT fileBlockDump(uint32_t offset, uint32_t len)
{
// Locals.
//
uint32_t dumpSize = (len == 0 ? SECTOR_SIZE - offset : len);
FRESULT fr0 = FR_OK;
// Sanity check on parameters.
if(offset > SECTOR_SIZE || (offset+dumpSize) > SECTOR_SIZE)
return(FR_INVALID_PARAMETER);
// Dump out the memory.
memoryDump((uint32_t)&fsBuff[offset], dumpSize, 16, offset, 0);
return(fr0);
}
#endif
// Method to set the block length to operate with on read/write block functions.
//
FRESULT fileSetBlockLen(uint32_t len)
{
// Sanity check on parameters.
if(len == 0 || len > SECTOR_SIZE)
return(FR_INVALID_PARAMETER);
// Set length.
blockLen = len;
// All ok.
return(FR_OK);
}
#endif // __SD_CARD__
// Function to dump out a given section of memory via the UART.
//
#if (defined(BUILTIN_FS_DUMP) && BUILTIN_FS_DUMP == 1) || (defined(BUILTIN_FS_INSPECT) && BUILTIN_FS_INSPECT == 1) || (defined(BUILTIN_DISK_DUMP) && BUILTIN_DISK_DUMP == 1) || (defined(BUILTIN_DISK_STATUS) && BUILTIN_DISK_STATUS == 1) || (defined(BUILTIN_BUFFER_DUMP) && BUILTIN_BUFFER_DUMP == 1) || (defined(BUILTIN_MEM_DUMP) && BUILTIN_MEM_DUMP == 1)
int memoryDump(uint32_t memaddr, uint32_t memsize, uint32_t memwidth, uint32_t dispaddr, uint8_t dispwidth)
{
uint8_t displayWidth = dispwidth;;
uint32_t pnt = memaddr;
uint32_t endAddr = memaddr + memsize;
uint32_t addr = dispaddr;
uint32_t i = 0;
//uint32_t data;
int8_t keyIn;
char c = 0;
// If not set, calculate output line width according to connected display width.
//
if(displayWidth == 0)
{
switch(getScreenWidth())
{
case 40:
displayWidth = 8;
break;
case 80:
displayWidth = 16;
break;
default:
displayWidth = 32;
break;
}
}
while (1)
{
printf("%08lX", addr); // print address
printf(": ");
// print hexadecimal data
for (i=0; i < displayWidth; )
{
switch(memwidth)
{
case 16:
if(pnt+i < endAddr)
printf("%04X", *(uint16_t *)(pnt+i));
else
printf(" ");
//printf(" ");
i+=2;
break;
case 32:
if(pnt+i < endAddr)
printf("%08lX", *(uint32_t *)(pnt+i));
else
printf(" ");
i+=4;
break;
case 8:
default:
if(pnt+i < endAddr)
printf("%02X", *(uint8_t *)(pnt+i));
else
printf(" ");
i++;
break;
}
fputc((char)' ', stdout);
}
// print ascii data
printf(" |");
// print single ascii char
for (i=0; i < displayWidth; i++)
{
c = (char)*(uint8_t *)(pnt+i);
if ((pnt+i < endAddr) && (c >= ' ') && (c <= '~'))
fputc((char)c, stdout);
else
fputc((char)' ', stdout);
}
puts("|");
// Move on one row.
pnt += displayWidth;
addr += displayWidth;
// User abort (ESC), pause (Space) or all done?
//
keyIn = getKey(0);
if(keyIn == ' ')
{
do {
keyIn = getKey(0);
} while(keyIn != ' ' && keyIn != 0x1b);
}
// Escape key pressed, exit with 0 to indicate this to caller.
if (keyIn == 0x1b)
{
return(0);
}
// End of buffer, exit the loop.
if(pnt >= (memaddr + memsize))
{
break;
}
}
// Normal exit, return -1 to show no key pressed.
return(-1);
}
#endif
// Method to output a help page based on the current set of enabled commands. This is done via
// the group and command tables defined in the header.
#if defined(BUILTIN_MISC_HELP) && BUILTIN_MISC_HELP == 1
void displayHelp(char *cmd)
{
uint8_t gidx;
uint8_t cidx;
uint8_t hidx;
uint8_t dispColumn = 0;
uint8_t dispWidth = getScreenWidth();
uint8_t noParam;
uint8_t matchCmd;
uint8_t matchGroup;
int8_t keyIn;
char cmdSynopsis[50];
// Display the program details.
if(*cmd == 0x0) printVersion(0);
// Parameter given?
noParam = *cmd == 0x0 ? 1 : 0;
// Go through all the groups, outputting group at at time.
for (gidx=0; gidx < NGRPKEYS; gidx++)
{
t_groupstruct *grpsym = &groupTable[gidx];
dispColumn = 0;
// Any matches on Group filter?
matchGroup = strstr(grpsym->name, cmd) != NULL ? 1 : 0;
if(noParam || (!noParam && matchGroup)) printf("[%s]\n", grpsym->name);
for (cidx=0; cidx < NCMDKEYS; cidx++)
{
// Match on group key.
t_cmdstruct *cmdsym = &cmdTable[cidx];
// Any matches on Cmd filter?
matchCmd = strstr(cmdsym->cmd, cmd) != NULL ? 1 : 0;
if(grpsym->key == cmdsym->group && (noParam || (!noParam && (matchGroup || matchCmd))))
{
// Lookup the help text according to command key.
for(hidx=0; hidx < NHELPKEYS && helpTable[hidx].key != cmdTable[cidx].key; hidx++);
if(hidx < NHELPKEYS)
{
t_helpstruct *helpsym = &helpTable[hidx];
strcpy(cmdSynopsis, cmdsym->cmd);
strcat(cmdSynopsis, " ");
strcat(cmdSynopsis, helpsym->params);
printf("%-40s %c %-36s", cmdSynopsis, cmdsym->builtin == 1 ? '-' : '*', helpsym->description);
} else
{
strcpy(cmdSynopsis, cmdsym->cmd);
strcat(cmdSynopsis, " No help available.");
printf("%-40s %c %-36s", cmdSynopsis, cmdsym->builtin == 1 ? '-' : '*', " No help available.");
}
if(dispColumn++ == 1 || dispWidth <= 80)
{
dispColumn = 0;
fputc('\n', stdout);
}
}
// User abort (ESC), pause (Space) or all done?
//
keyIn = getKey(0);
if(keyIn == ' ')
{
do {
keyIn = getKey(0);
} while(keyIn != ' ' && keyIn != 0x1b);
}
// Escape key pressed, exit with 0 to indicate this to caller.
if (keyIn == 0x1b)
{
return;
}
}
if(dispColumn == 1) { fputc('\n', stdout); }
if(noParam || (!noParam && matchGroup)) { fputc('\n', stdout); }
}
}
#endif
// Function to output the ZOS version information and optionally the
// configured hardware details.
#if !defined(__APP__) || (defined(BUILTIN_MISC_HELP) && BUILTIN_MISC_HELP == 1)
void printVersion(uint8_t showConfig)
{
// Basic title showing name and Cpu Id.
#if !defined(__APP__)
#if defined __ZPU__
#if !defined __SHARPMZ__
printf("\n");
#endif
printf("** %s (", PROGRAM_NAME);
printZPUId(cfgSoC.zpuId);
printf(" ZPU, rev %02x) %s %s **\n\n", (uint8_t)cfgSoC.zpuId, VERSION, VERSION_DATE);
#elif defined __K64F__
printf("\n** %s (", PROGRAM_NAME);
printCPU();
printf(" CPU) %s %s **\n\n", VERSION, VERSION_DATE);
#elif defined __M68K__
printf("** %s (", PROGRAM_NAME);
printM68KId(cfgSoC.m68kId);
printf(" CPU) %s %s **\n\n", VERSION, VERSION_DATE);
#else
#error "Target CPU not defined, use __ZPU__, __K64F__ or __M68K__"
#endif
// Show configuration if requested.
if(showConfig)
{
showSoCConfig();
printf("OS:\n");
printf(" Base Address = %08lx\n", (uint32_t)OS_BASEADDR);
printf(" App Address = %08lx\n", (uint32_t)OS_APPADDR);
}
#else
printf("\n** %s %s %s **\n\n", APP_NAME, VERSION, VERSION_DATE);
#endif
}
#endif
#ifdef __cplusplus
}
#endif
Reference in New Issue View Git Blame Copy Permalink