FileHandle *FATFileSystem::open(const char* name, int flags) { debug_if(FFS_DBG, "open(%s) on filesystem [%s], drv [%s]\n", name, _name, _fsid); char n[64]; sprintf(n, "%s:/%s", _fsid, name); /* POSIX flags -> FatFS open mode */ BYTE openmode; if (flags & O_RDWR) { openmode = FA_READ|FA_WRITE; } else if(flags & O_WRONLY) { openmode = FA_WRITE; } else { openmode = FA_READ; } if(flags & O_CREAT) { if(flags & O_TRUNC) { openmode |= FA_CREATE_ALWAYS; } else { openmode |= FA_OPEN_ALWAYS; } } FIL fh; FRESULT res = f_open(&fh, n, openmode); if (res) { debug_if(FFS_DBG, "f_open('w') failed: %d\n", res); return NULL; } if (flags & O_APPEND) { f_lseek(&fh, fh.fsize); } return new FATFileHandle(fh); }
FATFileSystem::FATFileSystem(const char* n) : FileSystemLike(n) { debug_if(FFS_DBG, "FATFileSystem(%s)\n", n); for(int i=0; i<_VOLUMES; i++) { if(_ffs[i] == 0) { _ffs[i] = this; _fsid = i; debug_if(FFS_DBG, "Mounting [%s] on ffs drive [%d]\n", _name, _fsid); f_mount(i, &_fs); return; } } error("Couldn't create %s in FATFileSystem::FATFileSystem\n", n); }
void OnRxTimeout(void) { Radio.Sleep(); Buffer[BufferSize] = 0; State = RX_TIMEOUT; debug_if(DEBUG_MESSAGE, "> OnRxTimeout\r\n"); }
void OnRxError(void) { Radio.Sleep(); SkipRx = 1; State = RX_ERROR; debug_if(DEBUG_MESSAGE, "> OnRxError\r\n"); }
DRESULT disk_read(BYTE pdrv, BYTE *buff, DWORD sector, UINT count) { debug_if(FFS_DBG, "disk_read(sector %d, count %d) on pdrv [%d]\n", sector, count, pdrv); DWORD ssize = disk_get_sector_size(pdrv); int err = _ffs[pdrv]->read(buff, sector*ssize, count*ssize); return err ? RES_PARERR : RES_OK; }
int FATFileSystem::mount(BlockDevice *bd, bool mount) { lock(); if (_id != -1) { unlock(); return -EINVAL; } for (int i = 0; i < FF_VOLUMES; i++) { if (!_ffs[i]) { _id = i; _ffs[_id] = bd; _fsid[0] = '0' + _id; _fsid[1] = ':'; _fsid[2] = '\0'; debug_if(FFS_DBG, "Mounting [%s] on ffs drive [%s]\n", getName(), _fsid); FRESULT res = f_mount(&_fs, _fsid, mount); unlock(); return fat_error_remap(res); } } unlock(); return -ENOMEM; }
int FATFileSystem::remove(const char *filename) { FRESULT res = f_unlink(filename); if (res) { debug_if(FFS_DBG, "f_unlink() failed: %d\n", res); return -1; } return 0; }
int FATFileSystem::rename(const char *oldname, const char *newname) { FRESULT res = f_rename(oldname, newname); if (res) { debug_if(FFS_DBG, "f_rename() failed: %d\n", res); return -1; } return 0; }
int FATFileSystem::format() { FRESULT res = f_mkfs(_fsid, 0, 512); // Logical drive number, Partitioning rule, Allocation unit size (bytes per cluster) if (res) { debug_if(FFS_DBG, "f_mkfs() failed: %d\n", res); return -1; } return 0; }
int FATFileSystem::mkdir(const char *name, mode_t mode) { // Added by Embedded Artists to fix implementation when using more than one volume debug_if(FFS_DBG, "mkdir(%s) on filesystem [%s], drv [%d]\n", name, _name, _fsid); char n[64]; snprintf(n, 64, "%d:/%s", _fsid, name); FRESULT res = f_mkdir(n); return res == 0 ? 0 : -1; }
static void SendTISReq() { debug_if(DEBUG_MESSAGE || CurCount == 0, "TIS_REQ %d %03d %03d\r\n", SID, CurCount+1, EndCount); Buffer[0] = 'c'; Buffer[1] = SID; sprintf(&Buffer[2], "%03d%03d", CurCount++, EndCount); Radio.Send((uint8_t*)Buffer, 2 + 6); }
////// File operations ////// int FATFileSystem::file_open(fs_file_t *file, const char *path, int flags) { debug_if(FFS_DBG, "open(%s) on filesystem [%s], drv [%s]\n", path, getName(), _id); FIL *fh = new FIL; Deferred<const char*> fpath = fat_path_prefix(_id, path); /* POSIX flags -> FatFS open mode */ BYTE openmode; if (flags & O_RDWR) { openmode = FA_READ | FA_WRITE; } else if (flags & O_WRONLY) { openmode = FA_WRITE; } else { openmode = FA_READ; } if (flags & O_CREAT) { if (flags & O_TRUNC) { openmode |= FA_CREATE_ALWAYS; } else { openmode |= FA_OPEN_ALWAYS; } } if (flags & O_APPEND) { openmode |= FA_OPEN_APPEND; } lock(); FRESULT res = f_open(fh, fpath, openmode); if (res != FR_OK) { unlock(); debug_if(FFS_DBG, "f_open('w') failed: %d\n", res); delete fh; return fat_error_remap(res); } unlock(); *file = fh; return 0; }
void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) { Radio.Sleep(); BufferSize = size; memcpy(Buffer, payload, BufferSize); RssiValue = rssi; SnrValue = snr; State = RX; debug_if(DEBUG_MESSAGE, "> OnRxDone\r\n"); }
static void SendTRPResp() { debug_if(DEBUG_MESSAGE || CurCount+1 == EndCount, "TRP_RESP %d %03d (%03d)\r\n", SID, CurCount, EndCount); Buffer[0] = 'b'; Buffer[1] = SID; sprintf(&Buffer[2], "%03d", CurCount++); sprintf(&Buffer[5], "%03d", AccRssi * -1); Radio.Send((uint8_t*)Buffer, 2 + 6); }
int FATFileSystem::file_sync(fs_file_t file) { FIL *fh = static_cast<FIL*>(file); lock(); FRESULT res = f_sync(fh); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_sync() failed: %d\n", res); } return fat_error_remap(res); }
int FATFileSystem::mkdir(const char *path, mode_t mode) { Deferred<const char*> fpath = fat_path_prefix(_id, path); lock(); FRESULT res = f_mkdir(fpath); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_mkdir() failed: %d\n", res); } return fat_error_remap(res); }
int FATFileSystem::rename(const char *oldpath, const char *newpath) { Deferred<const char*> oldfpath = fat_path_prefix(_id, oldpath); Deferred<const char*> newfpath = fat_path_prefix(_id, newpath); lock(); FRESULT res = f_rename(oldfpath, newfpath); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_rename() failed: %d\n", res); } return fat_error_remap(res); }
DirHandle *FATFileSystem::opendir(const char *name) { // Added by Embedded Artists to fix implementation when using more than one volume debug_if(FFS_DBG, "opendir(%s) on filesystem [%s], drv [%d]\n", name, _name, _fsid); char n[64]; snprintf(n, 64, "%d:/%s", _fsid, name); FATFS_DIR dir; FRESULT res = f_opendir(&dir, n); if (res != 0) { return NULL; } return new FATDirHandle(dir); }
bool ATCmdParser::process_oob() { if (!_fh->readable()) { return false; } int i = 0; while (true) { // Receive next character int c = getc(); if (c < 0) { return false; } _buffer[i++] = c; _buffer[i] = 0; // Check for oob data struct oob *oob = _oobs; while (oob) { if (i == (int)oob->len && memcmp( oob->prefix, _buffer, oob->len) == 0) { debug_if(_dbg_on, "AT! %s\r\n", oob->prefix); oob->cb(); return true; } oob = oob->next; } // Clear the buffer when we hit a newline or ran out of space // running out of space usually means we ran into binary data if (i+1 >= _buffer_size || strcmp(&_buffer[i-_output_delim_size], _output_delimiter) == 0) { debug_if(_dbg_on, "AT< %s", _buffer); i = 0; } } }
ssize_t FATFileSystem::file_write(fs_file_t file, const void *buffer, size_t len) { FIL *fh = static_cast<FIL*>(file); lock(); UINT n; FRESULT res = f_write(fh, buffer, len, &n); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_write() failed: %d", res); return fat_error_remap(res); } else { return n; } }
DRESULT disk_write(BYTE pdrv, const BYTE *buff, DWORD sector, UINT count) { debug_if(FFS_DBG, "disk_write(sector %d, count %d) on pdrv [%d]\n", sector, count, pdrv); DWORD ssize = disk_get_sector_size(pdrv); int err = _ffs[pdrv]->erase(sector*ssize, count*ssize); if (err) { return RES_PARERR; } err = _ffs[pdrv]->program(buff, sector*ssize, count*ssize); if (err) { return RES_PARERR; } return RES_OK; }
int FATFileSystem::remove(const char *path) { Deferred<const char*> fpath = fat_path_prefix(_id, path); lock(); FRESULT res = f_unlink(fpath); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_unlink() failed: %d\n", res); if (res == FR_DENIED) { return -ENOTEMPTY; } } return fat_error_remap(res); }
////// Dir operations ////// int FATFileSystem::dir_open(fs_dir_t *dir, const char *path) { FATFS_DIR *dh = new FATFS_DIR; Deferred<const char*> fpath = fat_path_prefix(_id, path); lock(); FRESULT res = f_opendir(dh, fpath); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_opendir() failed: %d\n", res); delete dh; return fat_error_remap(res); } *dir = dh; return 0; }
DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff) { debug_if(FFS_DBG, "disk_ioctl(%d)\n", cmd); switch (cmd) { case CTRL_SYNC: if (_ffs[pdrv] == NULL) { return RES_NOTRDY; } else { return RES_OK; } case GET_SECTOR_COUNT: if (_ffs[pdrv] == NULL) { return RES_NOTRDY; } else { *((DWORD*)buff) = disk_get_sector_count(pdrv); return RES_OK; } case GET_SECTOR_SIZE: if (_ffs[pdrv] == NULL) { return RES_NOTRDY; } else { *((WORD*)buff) = disk_get_sector_size(pdrv); return RES_OK; } case GET_BLOCK_SIZE: *((DWORD*)buff) = 1; // default when not known return RES_OK; case CTRL_TRIM: if (_ffs[pdrv] == NULL) { return RES_NOTRDY; } else { DWORD *sectors = (DWORD*)buff; DWORD ssize = disk_get_sector_size(pdrv); bd_addr_t addr = (bd_addr_t)sectors[0]*ssize; bd_size_t size = (bd_size_t)(sectors[1]-sectors[0]+1)*ssize; int err = _ffs[pdrv]->trim(addr, size); return err ? RES_PARERR : RES_OK; } } return RES_PARERR; }
off_t FATFileSystem::file_seek(fs_file_t file, off_t offset, int whence) { FIL *fh = static_cast<FIL*>(file); lock(); if (whence == SEEK_END) { offset += fh->fsize; } else if(whence==SEEK_CUR) { offset += fh->fptr; } FRESULT res = f_lseek(fh, offset); off_t noffset = fh->fptr; unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "lseek failed: %d\n", res); return fat_error_remap(res); } else { return noffset; } }
// Command parsing with line handling bool ATCmdParser::vsend(const char *command, va_list args) { // Create and send command if (vsprintf(_buffer, command, args) < 0) { return false; } for (int i = 0; _buffer[i]; i++) { if (putc(_buffer[i]) < 0) { return false; } } // Finish with newline for (size_t i = 0; _output_delimiter[i]; i++) { if (putc(_output_delimiter[i]) < 0) { return false; } } debug_if(_dbg_on, "AT> %s\n", _buffer); return true; }
DSTATUS disk_initialize(BYTE pdrv) { debug_if(FFS_DBG, "disk_initialize on pdrv [%d]\n", pdrv); return (DSTATUS)_ffs[pdrv]->init(); }
DSTATUS disk_status(BYTE pdrv) { debug_if(FFS_DBG, "disk_status on pdrv [%d]\n", pdrv); return RES_OK; }
static void mp4sys_adts_cleanup( importer_t *importer ) { debug_if( importer && importer->info ) remove_mp4sys_adts_importer( importer->info ); }
static void vc1_importer_cleanup( importer_t *importer ) { debug_if( importer && importer->info ) remove_vc1_importer( importer->info ); }