From 8693ae1bd880a758eb2efec4fccd32f89593855d Mon Sep 17 00:00:00 2001 From: Nebuleon Fumika Date: Sun, 3 Feb 2013 04:19:11 -0500 Subject: Add SDK modifications by BassAceGold as of 2011-04-14, as well as modified DMA functions as of 2013-01-29. --- sdk-modifications/libsrc/fs/fs_api.c | 452 +++++++++++++++++++++++++++++++++++ 1 file changed, 452 insertions(+) create mode 100644 sdk-modifications/libsrc/fs/fs_api.c (limited to 'sdk-modifications/libsrc/fs/fs_api.c') diff --git a/sdk-modifications/libsrc/fs/fs_api.c b/sdk-modifications/libsrc/fs/fs_api.c new file mode 100644 index 0000000..b23a450 --- /dev/null +++ b/sdk-modifications/libsrc/fs/fs_api.c @@ -0,0 +1,452 @@ +//fs_api.c + +#include +#include +#include +#include +#include +#include +#include "fs_common.h" +#include "fatfile.h" +#include "fatdir.h" + +typedef unsigned int size_t; +typedef unsigned int mode_t; + +typedef struct { + const char* mode; /* mode string */ + unsigned int flag; /* mode flag */ +// unsigned char mode_r; /* READ */ +// unsigned char mode_w; /* WRITE */ +// unsigned char mode_a; /* APPEND */ +// unsigned char mode_c; /* CREATE */ +} _fat_mode_type; + +static const _fat_mode_type _fat_valid_mode[] = { + { "r" , O_RDONLY }, + { "w" , O_WRONLY | O_TRUNC | O_CREAT }, + { "a" , O_WRONLY | O_APPEND | O_CREAT }, + { "rb" , O_RDONLY }, + { "wb" , O_WRONLY | O_TRUNC | O_CREAT }, + { "ab" , O_WRONLY | O_APPEND | O_CREAT }, + { "r+" , O_RDWR }, + { "w+" , O_RDWR | O_TRUNC | O_CREAT }, + { "a+" , O_RDWR | O_APPEND | O_CREAT }, + { "r+b" , O_RDWR }, + { "rb+" , O_RDWR }, + { "w+b" , O_RDWR | O_TRUNC | O_CREAT }, + { "wb+" , O_RDWR | O_TRUNC | O_CREAT }, + { "a+b" , O_RDWR | O_APPEND | O_CREAT }, + { "ab+" , O_RDWR | O_APPEND | O_CREAT } +}; + +#define MAX_OPEN_FILE 16 +#define MAX_OPEN_DIR 32 +#define MAX_PWD_LEN 512 +#define MAX_STDIO_BUF_SIZE 2048 + +#define FAT_VALID_MODE_NUM (sizeof(_fat_valid_mode)/sizeof(_fat_mode_type)) + +static FILE_STRUCT __FILEs[MAX_OPEN_FILE]; +struct _reent __REENT; +static DIR_STATE_STRUCT __DIRs[MAX_OPEN_DIR]; +static char __PWD[MAX_PWD_LEN]; + +int fat_init(void) +{ + int i, flag; + + for(i= 0; i < MAX_OPEN_FILE; i++) + __FILEs[i].inUse = false; + + for(i= 0; i < MAX_OPEN_DIR; i++) + __DIRs[i].inUse = false; + + flag = -1; + if(_FAT_Init() == true) //success + flag = 0; + + return flag; +} + +FILE_STRUCT* fat_fopen(const char *file, const char *mode) +{ + int i, k; + int fd; + FILE_STRUCT* fp; + + for(i= 0; i < MAX_OPEN_FILE; i++) + if(false == __FILEs[i].inUse) break; + + if(i >= MAX_OPEN_FILE) + { + __REENT._errno = EMFILE; /* Too many open files */ + return NULL; + } + + for(k = 0; k < FAT_VALID_MODE_NUM; k++) + if(!strcasecmp(_fat_valid_mode[k].mode, mode)) break; + + if(k >= FAT_VALID_MODE_NUM) + { + __REENT._errno = EINVAL; + return NULL; + } + + fd = _FAT_open_r(&__REENT, (void*)&__FILEs[i], file, _fat_valid_mode[k].flag); + if(-1 == fd) return NULL; + + fp = &__FILEs[i]; + fp -> fd = fd; + + return fp; +} + +size_t fat_fread(void *buf, size_t size, size_t count, FILE_STRUCT *fp) +{ + if(0 == size || 0 == count) + return 0; + + int len = _FAT_read_r(&__REENT, fp->fd, (char*)buf, size*count); + len /= size; + return len; +} + +size_t fat_fwrite(const void *buf, size_t size, size_t count, FILE_STRUCT *fp) +{ + if(0 == size || 0 == count) + return 0; + + int len = _FAT_write_r(&__REENT, fp->fd, (const char*)buf, size*count); + len /= size; + + return len; +} + +int fat_fclose(FILE_STRUCT *fp) +{ + return( _FAT_close_r(&__REENT, fp->fd) ); +} + +int fat_fseek(FILE_STRUCT *fp, long offset, int whence) +{ + int flag; + + //When success, _FAT_seek_r return file position pointer + flag = _FAT_seek_r (&__REENT, fp->fd, (int)offset, whence); + if(flag > 0) flag = 0; + + return flag; +} + +long fat_ftell(FILE_STRUCT *fp) +{ + return( (long)fp->currentPosition ); +} + +int fat_feof(FILE_STRUCT *fp) +{ + int result; + + result = 0; + if((fp->currentPosition +1) >= (fp->filesize)) + result = -1; + + return result; +} + +int fat_ferror(FILE_STRUCT *fp) +{ + return( __REENT._errno ); +} + +void fat_clearerr(FILE_STRUCT *fp) +{ + fp = fp; + + __REENT._errno = 0; +} + +int fat_fflush(FILE_STRUCT *fp) +{ + return(_FAT_cache_flush(fp->partition->cache)); +} + +int fat_fgetc(FILE_STRUCT *fp) +{ + char ch; + int result; + + result = _FAT_read_r(&__REENT, fp->fd, &ch, 1); + if(0 == result) + return EOF; + + return ( (int)ch ); +} + +char* fat_fgets(char* buf, int n, FILE_STRUCT* fp) +{ + int m; + char *s; + + buf[0] = '\0'; + if(n <= 1) return buf; + + n -= 1; + m = _FAT_read_r(&__REENT, fp->fd, buf, n); + if(0 == m) return NULL; + + buf[m] = '\0'; + s = strchr((const char*)buf, 0x0A); + + if(NULL != s) + { + *(++s)= '\0'; + m -= s - buf; + + //fix reading pointer + _FAT_seek_r (&__REENT, fp->fd, -m, SEEK_CUR); + } + else if(m == n) + { + if(0x0D == buf[n-1]) //0x0D,0x0A + { + buf[n-1] = '\0'; + _FAT_seek_r (&__REENT, fp->fd, -1, SEEK_CUR); + } + } + + return buf; +} + +int fat_fputc(int ch, FILE_STRUCT *fp) +{ + return( _FAT_write_r(&__REENT, fp->fd, (const char*)&ch, 1) ); +} + +int fat_fputs(const char *s, FILE_STRUCT *fp) +{ + unsigned int len; + + len = strlen(s); + return( _FAT_write_r(&__REENT, fp->fd, s, len) ); +} + +int fat_remove(const char *filename) +{ + return( _FAT_unlink_r (&__REENT, (const char*)filename) ); +} + +int fat_rename(const char *oldName, const char *newName) +{ + return( _FAT_rename_r(&__REENT, oldName, newName) ); +} + +int fat_setHidden(const char *name, unsigned char hide){ + return(_FAT_hideAttrib_r (&__REENT, name, hide)); +} + +#define S_ISHID(st_mode) ((st_mode & S_IHIDDEN) != 0) +int fat_isHidden(struct stat *st){ + return S_ISHID(st->st_mode); +} + +int fat_getShortName(const char *fullName, char *outName){ + return(_FAT_getshortname_r (&__REENT, fullName, outName)); +} + + +void fat_rewind(FILE_STRUCT *fp) +{ + _FAT_seek_r (&__REENT, fp->fd, 0, SEEK_SET); +} + +int fat_fstat(int fildes, struct stat *buf) +{ + return( _FAT_fstat_r (&__REENT, fildes, buf) ); +} + +//int fat_fprintf(FILE_STRUCT *fp, const char *format, ...) +int fat_fprintf(void* fp, const char *format, ...) +{ + int ret; + va_list ap; + char buf[MAX_STDIO_BUF_SIZE]; + + if(NULL == fp) + { + __REENT._errno = EINVAL; + return -1; + } + + //FIXME: stderr, stdout + if((void*)stderr == fp) return 0; + if((void*)stdout == fp) return 0; + + memset(buf, 0, MAX_STDIO_BUF_SIZE); + + va_start (ap, format); + ret = vsnprintf (buf, MAX_STDIO_BUF_SIZE, format, ap); + va_end (ap); + + //if output string too long, it will not put out to file + if(ret >= MAX_STDIO_BUF_SIZE) + return -1; + + return( _FAT_write_r(&__REENT, ((FILE_STRUCT*)fp)->fd, (const char*)buf, strlen(buf)) ); +} + +int fat_fscanf(FILE_STRUCT *fp, const char *format, ...) +{ + int ret; + va_list ap; + char buf[MAX_STDIO_BUF_SIZE]; + char *pt; + + if(NULL == fp) + { + __REENT._errno = EINVAL; + return -1; + } + + pt = fat_fgets(buf, MAX_STDIO_BUF_SIZE, fp); + if(NULL == pt) + return -1; + + va_start (ap, format); + ret = vsscanf (buf, format, ap); + + return ret; +} + +DIR_STATE_STRUCT* fat_opendir(const char *name) +{ + int i; + + for(i = 0; i < MAX_OPEN_DIR; i++) + { + if(false == __DIRs[i].inUse) break; + } + + if(i>= MAX_OPEN_DIR) + { + __REENT._errno = EMFILE; /* Too many open files */ + return NULL; + } + + return( _FAT_diropen_r(&__REENT, &__DIRs[i], name) ); +} + +DIR_ENTRY* fat_readdir(DIR_STATE_STRUCT *dirp) +{ + int isValid; + + isValid = _FAT_dirnext_r (&__REENT, dirp, NULL); + if(0 != isValid) + return NULL; + + return( &(dirp->currentEntry) ); +} + +long int fat_telldir(DIR_STATE_STRUCT *dirp) +{ + return( dirp->posEntry ); +} + +void fat_seekdir(DIR_STATE_STRUCT *dirp, long int loc) +{ + if (!dirp->inUse) { + __REENT._errno = EBADF; + return; + } + + if(0 == loc) + { + dirp->posEntry = 0; + } + else if(loc > 0) + { + while(dirp->posEntry < loc) + { + dirp->validEntry = _FAT_directory_getNextEntry (dirp->partition, &(dirp->currentEntry)); + dirp->posEntry += 1; + + if(!dirp->validEntry) break; + } + } + + return; +} + +int fat_closedir(DIR_STATE_STRUCT *dirp) +{ + return(_FAT_dirclose_r (&__REENT, dirp)); +} + +int fat_chdir(const char *path) +{ + int ret; + char *pt; + + ret = _FAT_chdir_r (&__REENT, path); + if(0 != ret) return -1; + + pt = strchr(path, ':'); + if(pt == NULL) + strcat(__PWD, path); + else + strcpy(__PWD, path); + + pt = strchr(__PWD, '\0'); + while(pt-- != __PWD) + { + if(pt[0] != DIR_SEPARATOR) break; + } + + pt[1] = DIR_SEPARATOR; + pt[2] = '\0'; + + return 0; +} + +char* fat_getcwd(char *buf, size_t size) +{ + int len; + + len = strlen(__PWD); + if(len >= size) + { + __REENT._errno = ERANGE; + return NULL; + } + + strcpy(buf, __PWD); + return buf; +} + +int fat_mkdir(const char *path, mode_t mode) +{ + return( _FAT_mkdir_r(&__REENT, path, mode) ); +} + +int fat_rmdir(const char *path) +{ + return( _FAT_unlink_r(&__REENT, path) ); +} + +int fat_lstat(const char *path, struct stat *buf) +{ + return( _FAT_stat_r (&__REENT, path, buf) ); +} + +DIR_ENTRY* fat_readdir_ex(DIR_STATE_STRUCT *dirp, struct stat *statbuf) +{ + int isValid; + + isValid = _FAT_dirnext_r (&__REENT, dirp, statbuf); + if(0 != isValid) + return NULL; + + return( &(dirp->currentEntry) ); +} + -- cgit v1.2.3 From d1a7bf5eb558e7db4a1a27e15ebedb02e6b7f804 Mon Sep 17 00:00:00 2001 From: Nebuleon Fumika Date: Mon, 4 Feb 2013 23:45:44 -0500 Subject: Fully integrate BassAceGold's libraries, finally. The README still states that 1.2 is required to overwrite 0.13's stuff; really, 0.13 is needed only for `gcc`. So the sequence goes 0.13's `gcc` -> 1.2 -> BassAceGold's libraries -> make `libds2a.a`. DMA function names changed to match BassAceGold's. --- sdk-modifications/libsrc/fs/fs_api.c | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 sdk-modifications/libsrc/fs/fs_api.c (limited to 'sdk-modifications/libsrc/fs/fs_api.c') diff --git a/sdk-modifications/libsrc/fs/fs_api.c b/sdk-modifications/libsrc/fs/fs_api.c old mode 100644 new mode 100755 -- cgit v1.2.3