devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Snapshot of file writing code. Bugs remain. Only short names are supported yet.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@2726 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Björn Stenberg 2002-10-20 22:50:58 +00:00
parent 1df1e51a03
commit b7b48fea02
10 changed files with 613 additions and 295 deletions
Download patch file Download diff file Expand all files Collapse all files

3
firmware/common/dir.c
View file

@ -105,8 +105,7 @@ struct dirent* readdir(DIR* dir)
return NULL; return NULL;
if ( !entry.name[0] ) if ( !entry.name[0] )
return NULL; return NULL;
strncpy(theent->d_name, entry.name, sizeof( theent->d_name ) ); strncpy(theent->d_name, entry.name, sizeof( theent->d_name ) );
theent->attribute = entry.attr; theent->attribute = entry.attr;

178
firmware/common/file.c
View file

@ -42,23 +42,25 @@ struct filedesc {
int size; int size;
struct fat_file fatfile; struct fat_file fatfile;
bool busy; bool busy;
bool write;
}; };
static struct filedesc openfiles[MAX_OPEN_FILES]; static struct filedesc openfiles[MAX_OPEN_FILES];
int open(char* pathname, int flags) int creat(const char *pathname, int mode)
{
(void)mode;
return open(pathname, O_WRONLY);
}
int open(const char* pathname, int flags)
{ {
DIR* dir; DIR* dir;
struct dirent* entry; struct dirent* entry;
int fd; int fd;
char* name; char* name;
/* For now, we don't support writing */ LDEBUGF("open(\"%s\",%d)\n",pathname,flags);
if(flags & (O_WRONLY | O_RDWR))
{
errno = EROFS;
return -1;
}
if ( pathname[0] != '/' ) { if ( pathname[0] != '/' ) {
DEBUGF("'%s' is not an absolute path.\n",pathname); DEBUGF("'%s' is not an absolute path.\n",pathname);
@ -75,44 +77,74 @@ int open(char* pathname, int flags)
if ( fd == MAX_OPEN_FILES ) { if ( fd == MAX_OPEN_FILES ) {
DEBUGF("Too many files open\n"); DEBUGF("Too many files open\n");
errno = EMFILE; errno = EMFILE;
return -1; return -2;
} }
switch ( flags ) {
case O_RDONLY:
openfiles[fd].write = false;
break;
case O_WRONLY:
openfiles[fd].write = true;
break;
default:
DEBUGF("Only O_RDONLY and O_WRONLY is supported\n");
errno = EROFS;
return -3;
}
openfiles[fd].busy = true; openfiles[fd].busy = true;
/* locate filename */ /* locate filename */
name=strrchr(pathname+1,'/'); name=strrchr(pathname+1,'/');
if ( name ) { if ( name ) {
*name = 0; *name = 0;
dir = opendir(pathname); dir = opendir((char*)pathname);
*name = '/'; *name = '/';
name++; name++;
} }
else { else {
dir = opendir("/"); dir = opendir("/");
name = pathname+1; name = (char*)pathname+1;
} }
if (!dir) { if (!dir) {
DEBUGF("Failed opening dir\n"); DEBUGF("Failed opening dir\n");
errno = EIO; errno = EIO;
openfiles[fd].busy = false; openfiles[fd].busy = false;
return -1; return -4;
} }
/* scan dir for name */ /* scan dir for name */
while ((entry = readdir(dir))) { while ((entry = readdir(dir))) {
if ( !strcasecmp(name, entry->d_name) ) { if ( !strcasecmp(name, entry->d_name) ) {
fat_open(entry->startcluster, &(openfiles[fd].fatfile)); fat_open(entry->startcluster,
&(openfiles[fd].fatfile),
&(dir->fatdir));
openfiles[fd].size = entry->size; openfiles[fd].size = entry->size;
break; break;
} }
} }
closedir(dir); closedir(dir);
if ( !entry ) { if ( !entry ) {
DEBUGF("Couldn't find %s in %s\n",name,pathname); LDEBUGF("Didn't find file %s\n",name);
errno = ENOENT; if ( openfiles[fd].write ) {
openfiles[fd].busy = false; if (fat_create_file(name,
return -1; &(openfiles[fd].fatfile),
&(dir->fatdir)) < 0) {
DEBUGF("Couldn't create %s in %s\n",name,pathname);
errno = EIO;
openfiles[fd].busy = false;
return -5;
}
openfiles[fd].size = 0;
}
else {
DEBUGF("Couldn't find %s in %s\n",name,pathname);
errno = ENOENT;
openfiles[fd].busy = false;
return -6;
}
} }
openfiles[fd].cacheoffset = -1; openfiles[fd].cacheoffset = -1;
@ -122,19 +154,37 @@ int open(char* pathname, int flags)
int close(int fd) int close(int fd)
{ {
int rc = 0;
LDEBUGF("close(%d)\n",fd);
if (fd < 0 || fd > MAX_OPEN_FILES-1) { if (fd < 0 || fd > MAX_OPEN_FILES-1) {
errno = EINVAL; errno = EINVAL;
return -1; return -1;
} }
if (!openfiles[fd].busy) { if (!openfiles[fd].busy) {
errno = EBADF; errno = EBADF;
return -1; return -2;
}
if (openfiles[fd].write) {
/* flush sector cache */
if ( openfiles[fd].cacheoffset != -1 ) {
if ( fat_readwrite(&(openfiles[fd].fatfile), 1,
&(openfiles[fd].cache),true) < 0 ) {
DEBUGF("Failed flushing cache\n");
errno = EIO;
rc = -1;
}
}
/* tie up all loose ends */
fat_closewrite(&(openfiles[fd].fatfile), openfiles[fd].size);
} }
openfiles[fd].busy = false; openfiles[fd].busy = false;
return 0; return rc;
} }
int read(int fd, void* buf, int count) static int readwrite(int fd, void* buf, int count, bool write)
{ {
int sectors; int sectors;
int nread=0; int nread=0;
@ -144,9 +194,16 @@ int read(int fd, void* buf, int count)
return -1; return -1;
} }
/* attempt to read past EOF? */ LDEBUGF( "readwrite(%d,%x,%d,%s)\n",
if ( count > openfiles[fd].size - openfiles[fd].fileoffset ) fd,buf,count,write?"write":"read");
count = openfiles[fd].size - openfiles[fd].fileoffset;
/* attempt to access past EOF? */
if (count > openfiles[fd].size - openfiles[fd].fileoffset) {
if ( write )
openfiles[fd].size = openfiles[fd].fileoffset + count;
else
count = openfiles[fd].size - openfiles[fd].fileoffset;
}
/* any head bytes? */ /* any head bytes? */
if ( openfiles[fd].cacheoffset != -1 ) { if ( openfiles[fd].cacheoffset != -1 ) {
@ -163,23 +220,38 @@ int read(int fd, void* buf, int count)
openfiles[fd].cacheoffset = -1; openfiles[fd].cacheoffset = -1;
} }
/* eof? */ if (write) {
if ( openfiles[fd].fileoffset + headbytes > openfiles[fd].size ) memcpy( openfiles[fd].cache + offs, buf, headbytes );
headbytes = openfiles[fd].size - openfiles[fd].fileoffset; if (offs+headbytes == SECTOR_SIZE) {
int rc = fat_readwrite(&(openfiles[fd].fatfile), 1,
openfiles[fd].cache, true );
if ( rc < 0 ) {
DEBUGF("Failed read/writing %d sectors\n",sectors);
errno = EIO;
return -2;
}
openfiles[fd].cacheoffset = -1;
}
}
else {
memcpy( buf, openfiles[fd].cache + offs, headbytes );
}
memcpy( buf, openfiles[fd].cache + offs, headbytes );
nread = headbytes; nread = headbytes;
count -= headbytes; count -= headbytes;
LDEBUGF("readwrite incache: offs=%d\n",openfiles[fd].cacheoffset);
} }
/* read whole sectors right into the supplied buffer */ /* read whole sectors right into the supplied buffer */
sectors = count / SECTOR_SIZE; sectors = count / SECTOR_SIZE;
if ( sectors ) { if ( sectors ) {
int rc = fat_read(&(openfiles[fd].fatfile), sectors, buf+nread ); int rc = fat_readwrite(&(openfiles[fd].fatfile), sectors,
buf+nread, write );
if ( rc < 0 ) { if ( rc < 0 ) {
DEBUGF("Failed reading %d sectors\n",sectors); DEBUGF("Failed read/writing %d sectors\n",sectors);
errno = EIO; errno = EIO;
return -1; return -2;
} }
else { else {
if ( rc > 0 ) { if ( rc > 0 ) {
@ -197,18 +269,19 @@ int read(int fd, void* buf, int count)
/* any tail bytes? */ /* any tail bytes? */
if ( count ) { if ( count ) {
if ( fat_read(&(openfiles[fd].fatfile), 1, if (write) {
&(openfiles[fd].cache)) < 0 ) { memcpy( openfiles[fd].cache, buf + nread, count );
DEBUGF("Failed caching sector\n");
errno = EIO;
return -1;
} }
else {
/* eof? */ if ( fat_readwrite(&(openfiles[fd].fatfile), 1,
if ( openfiles[fd].fileoffset + count > openfiles[fd].size ) &(openfiles[fd].cache),false) < 0 ) {
count = openfiles[fd].size - openfiles[fd].fileoffset; DEBUGF("Failed caching sector\n");
errno = EIO;
memcpy( buf + nread, openfiles[fd].cache, count ); return -1;
}
memcpy( buf + nread, openfiles[fd].cache, count );
}
nread += count; nread += count;
openfiles[fd].cacheoffset = count; openfiles[fd].cacheoffset = count;
} }
@ -217,6 +290,17 @@ int read(int fd, void* buf, int count)
return nread; return nread;
} }
int write(int fd, void* buf, int count)
{
return readwrite(fd, buf, count, true);
}
int read(int fd, void* buf, int count)
{
return readwrite(fd, buf, count, false);
}
int lseek(int fd, int offset, int whence) int lseek(int fd, int offset, int whence)
{ {
int pos; int pos;
@ -225,6 +309,8 @@ int lseek(int fd, int offset, int whence)
int sectoroffset; int sectoroffset;
int rc; int rc;
LDEBUGF("lseek(%d,%d,%d)\n",fd,offset,whence);
if ( !openfiles[fd].busy ) { if ( !openfiles[fd].busy ) {
errno = EBADF; errno = EBADF;
return -1; return -1;
@ -245,11 +331,11 @@ int lseek(int fd, int offset, int whence)
default: default:
errno = EINVAL; errno = EINVAL;
return -1; return -2;
} }
if ((pos < 0) || (pos > openfiles[fd].size)) { if ((pos < 0) || (pos > openfiles[fd].size)) {
errno = EINVAL; errno = EINVAL;
return -1; return -3;
} }
/* new sector? */ /* new sector? */
@ -263,14 +349,14 @@ int lseek(int fd, int offset, int whence)
rc = fat_seek(&(openfiles[fd].fatfile), newsector); rc = fat_seek(&(openfiles[fd].fatfile), newsector);
if ( rc < 0 ) { if ( rc < 0 ) {
errno = EIO; errno = EIO;
return -1; return -4;
} }
} }
rc = fat_read(&(openfiles[fd].fatfile), 1, rc = fat_readwrite(&(openfiles[fd].fatfile), 1,
&(openfiles[fd].cache)); &(openfiles[fd].cache),false);
if ( rc < 0 ) { if ( rc < 0 ) {
errno = EIO; errno = EIO;
return -1; return -5;
} }
openfiles[fd].cacheoffset = sectoroffset; openfiles[fd].cacheoffset = sectoroffset;
} }

16
firmware/common/file.h
View file

@ -40,24 +40,22 @@
#endif #endif
#if defined(__MINGW32__) && defined(SIMULATOR) #if defined(__MINGW32__) && defined(SIMULATOR)
int open (const char*, int, ...); extern int open(const char*, int, ...);
extern int close(int fd); extern int close(int fd);
int read (int, void*, unsigned int); extern int read(int, void*, unsigned int);
long lseek (int, long, int); extern long lseek(int, long, int);
#else #else
#ifndef SIMULATOR #ifndef SIMULATOR
extern int open(char* pathname, int flags); extern int open(const char* pathname, int flags);
extern int close(int fd); extern int close(int fd);
extern int read(int fd, void* buf, int count); extern int read(int fd, void* buf, int count);
extern int lseek(int fd, int offset, int whence); extern int lseek(int fd, int offset, int whence);
extern int creat(const char *pathname, int mode);
#ifdef DISK_WRITE
extern int write(int fd, void* buf, int count); extern int write(int fd, void* buf, int count);
extern int remove(char* pathname); extern int remove(const char* pathname);
extern int rename(char* oldname, char* newname); extern int rename(const char* oldname, const char* newname);
#endif
#else #else
#ifdef WIN32 #ifdef WIN32

11
firmware/debug.c
View file

@ -195,7 +195,9 @@ static void debug(char *msg)
} }
#endif /* end of DEBUG section */ #endif /* end of DEBUG section */
#ifdef __GNUC__
void debugf(char *fmt, ...) void debugf(char *fmt, ...)
#endif
{ {
#ifdef DEBUG #ifdef DEBUG
va_list ap; va_list ap;
@ -223,4 +225,13 @@ void debugf(char *fmt, ...)
vfprintf( stderr, fmt, ap ); vfprintf( stderr, fmt, ap );
va_end( ap ); va_end( ap );
} }
void ldebugf(char* file, int line, char *fmt, ...)
{
va_list ap;
va_start( ap, fmt );
fprintf( stderr, "%s:%d ", file, line );
vfprintf( stderr, fmt, ap );
va_end( ap );
}
#endif #endif

6
firmware/debug.h
View file

@ -21,20 +21,24 @@
extern void debug_init(void); extern void debug_init(void);
extern void debugf(char* fmt,...); extern void debugf(char* fmt,...);
extern void ldebugf(char* file, int line, char *fmt, ...);
#ifdef __GNUC__ #ifdef __GNUC__
/* */ /* */
#if defined(DEBUG) || defined(SIMULATOR) #if defined(DEBUG) || defined(SIMULATOR)
//#define DEBUGF(...) debugf(__VA_ARGS__)
#define DEBUGF debugf #define DEBUGF debugf
#define LDEBUGF(...) ldebugf(__FILE__, __LINE__, __VA_ARGS__)
#else #else
#define DEBUGF(...) #define DEBUGF(...)
#define LDEBUGF(...)
#endif #endif
#else #else
#define DEBUGF debugf #define DEBUGF debugf
#define LDEBUGF debugf
#endif /* GCC */ #endif /* GCC */

591
firmware/drivers/fat.c
View file

@ -22,14 +22,11 @@
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include <ctype.h> #include <ctype.h>
#ifdef DISK_WRITE
#include <time.h>
#include <sys/timeb.h>
#endif
#include <stdbool.h> #include <stdbool.h>
#include "fat.h" #include "fat.h"
#include "ata.h" #include "ata.h"
#include "debug.h" #include "debug.h"
#include "panic.h"
#include "system.h" #include "system.h"
#define BYTES2INT16(array,pos) \ #define BYTES2INT16(array,pos) \
@ -38,11 +35,6 @@
(array[pos] | (array[pos+1] << 8 ) | \ (array[pos] | (array[pos+1] << 8 ) | \
(array[pos+2] << 16 ) | (array[pos+3] << 24 )) (array[pos+2] << 16 ) | (array[pos+3] << 24 ))
#define NUM_ROOT_DIR_ENTRIES 512
#define NUM_FATS 2
#define NUM_RESERVED_SECTORS 1
#define NUM_BLOCKS 10000
#define FATTYPE_FAT12 0 #define FATTYPE_FAT12 0
#define FATTYPE_FAT16 1 #define FATTYPE_FAT16 1
#define FATTYPE_FAT32 2 #define FATTYPE_FAT32 2
@ -107,6 +99,12 @@
#define FATDIR_FSTCLUSLO 26 #define FATDIR_FSTCLUSLO 26
#define FATDIR_FILESIZE 28 #define FATDIR_FILESIZE 28
#define CLUSTERS_PER_FAT_SECTOR (SECTOR_SIZE / 4)
#define DIR_ENTRIES_PER_SECTOR (SECTOR_SIZE / 32)
#define DIR_ENTRY_SIZE 32
#define FAT_BAD_MARK 0x0ffffff7
#define FAT_EOF_MARK 0x0ffffff8
struct fsinfo { struct fsinfo {
int freecount; /* last known free cluster count */ int freecount; /* last known free cluster count */
int nextfree; /* first cluster to start looking for free clusters, int nextfree; /* first cluster to start looking for free clusters,
@ -155,6 +153,7 @@ struct bpb
int rootdirsector; int rootdirsector;
int firstdatasector; int firstdatasector;
int startsector; int startsector;
struct fsinfo fsinfo;
}; };
static struct bpb fat_bpb; static struct bpb fat_bpb;
@ -167,6 +166,7 @@ static unsigned int getcurrdostime(unsigned short *dosdate,
unsigned short *dostime, unsigned short *dostime,
unsigned char *dostenth); unsigned char *dostenth);
static int create_dos_name(unsigned char *name, unsigned char *newname); static int create_dos_name(unsigned char *name, unsigned char *newname);
static int find_free_cluster(int start);
#endif #endif
#define FAT_CACHE_SIZE 0x20 #define FAT_CACHE_SIZE 0x20
@ -256,7 +256,6 @@ int fat_mount(int startsector)
fat_bpb.bpb_secperclus = buf[BPB_SECPERCLUS]; fat_bpb.bpb_secperclus = buf[BPB_SECPERCLUS];
fat_bpb.bpb_rsvdseccnt = BYTES2INT16(buf,BPB_RSVDSECCNT); fat_bpb.bpb_rsvdseccnt = BYTES2INT16(buf,BPB_RSVDSECCNT);
fat_bpb.bpb_numfats = buf[BPB_NUMFATS]; fat_bpb.bpb_numfats = buf[BPB_NUMFATS];
fat_bpb.bpb_rootentcnt = BYTES2INT16(buf,BPB_ROOTENTCNT);
fat_bpb.bpb_totsec16 = BYTES2INT16(buf,BPB_TOTSEC16); fat_bpb.bpb_totsec16 = BYTES2INT16(buf,BPB_TOTSEC16);
fat_bpb.bpb_media = buf[BPB_MEDIA]; fat_bpb.bpb_media = buf[BPB_MEDIA];
fat_bpb.bpb_fatsz16 = BYTES2INT16(buf,BPB_FATSZ16); fat_bpb.bpb_fatsz16 = BYTES2INT16(buf,BPB_FATSZ16);
@ -295,7 +294,7 @@ int fat_mount(int startsector)
#endif #endif
{ {
DEBUGF("This is not FAT32. Go away!\n"); DEBUGF("This is not FAT32. Go away!\n");
return -1; return -2;
} }
fat_bpb.bpb_extflags = BYTES2INT16(buf,BPB_EXTFLAGS); fat_bpb.bpb_extflags = BYTES2INT16(buf,BPB_EXTFLAGS);
@ -316,11 +315,23 @@ int fat_mount(int startsector)
if (bpb_is_sane() < 0) if (bpb_is_sane() < 0)
{ {
DEBUGF( "fat_mount() - BPB is not sane\n"); DEBUGF( "fat_mount() - BPB is not sane\n");
return -1; return -3;
} }
fat_bpb.rootdirsector = cluster2sec(fat_bpb.bpb_rootclus); fat_bpb.rootdirsector = cluster2sec(fat_bpb.bpb_rootclus);
/* Read the fsinfo sector */
err = ata_read_sectors(startsector + fat_bpb.bpb_fsinfo, 1, buf);
if (err)
{
DEBUGF( "fat_mount() - Couldn't read FSInfo (error code %d)\n", err);
return -1;
}
fat_bpb.fsinfo.freecount = BYTES2INT32(buf, FSINFO_FREECOUNT);
fat_bpb.fsinfo.nextfree = BYTES2INT32(buf, FSINFO_NEXTFREE);
LDEBUGF("Freecount: %x\n",fat_bpb.fsinfo.freecount);
LDEBUGF("Nextfree: %x\n",fat_bpb.fsinfo.nextfree);
return 0; return 0;
} }
@ -339,9 +350,9 @@ static int bpb_is_sane(void)
fat_bpb.bpb_bytspersec, fat_bpb.bpb_secperclus, fat_bpb.bpb_bytspersec, fat_bpb.bpb_secperclus,
fat_bpb.bpb_bytspersec * fat_bpb.bpb_secperclus); fat_bpb.bpb_bytspersec * fat_bpb.bpb_secperclus);
} }
if(fat_bpb.bpb_rsvdseccnt != 1) if (fat_bpb.bpb_rsvdseccnt != 32)
{ {
DEBUGF( "bpb_is_sane() - Warning: Reserved sectors is not 1 (%d)\n", DEBUGF( "bpb_is_sane() - Warning: Reserved sectors is not 32 (%d)\n",
fat_bpb.bpb_rsvdseccnt); fat_bpb.bpb_rsvdseccnt);
} }
if(fat_bpb.bpb_numfats != 2) if(fat_bpb.bpb_numfats != 2)
@ -349,11 +360,6 @@ static int bpb_is_sane(void)
DEBUGF( "bpb_is_sane() - Warning: NumFATS is not 2 (%d)\n", DEBUGF( "bpb_is_sane() - Warning: NumFATS is not 2 (%d)\n",
fat_bpb.bpb_numfats); fat_bpb.bpb_numfats);
} }
if(fat_bpb.bpb_rootentcnt != 512)
{
DEBUGF( "bpb_is_sane() - Warning: RootEntCnt is not 512 (%d)\n",
fat_bpb.bpb_rootentcnt);
}
if(fat_bpb.bpb_media != 0xf0 && fat_bpb.bpb_media < 0xf8) if(fat_bpb.bpb_media != 0xf0 && fat_bpb.bpb_media < 0xf8)
{ {
DEBUGF( "bpb_is_sane() - Warning: Non-standard " DEBUGF( "bpb_is_sane() - Warning: Non-standard "
@ -364,33 +370,42 @@ static int bpb_is_sane(void)
{ {
DEBUGF( "bpb_is_sane() - Error: Last word is not " DEBUGF( "bpb_is_sane() - Error: Last word is not "
"0xaa55 (0x%04x)\n", fat_bpb.last_word); "0xaa55 (0x%04x)\n", fat_bpb.last_word);
return -1; return -4;
} }
if (fat_bpb.fsinfo.freecount >
(fat_bpb.totalsectors - fat_bpb.firstdatasector)/
fat_bpb.bpb_secperclus)
{
DEBUGF( "bpb_is_sane() - Error: FSInfo.Freecount > disk size "
"(0x%04x)\n", fat_bpb.fsinfo.freecount);
return -5;
}
return 0; return 0;
} }
static void *cache_fat_sector(int secnum) static void *cache_fat_sector(int fatsector)
{ {
int secnum = fatsector + fat_bpb.bpb_rsvdseccnt;
int cache_index = secnum & FAT_CACHE_MASK; int cache_index = secnum & FAT_CACHE_MASK;
/* Delete the cache entry if it isn't the sector we want */ /* Delete the cache entry if it isn't the sector we want */
if(fat_cache[cache_index].inuse && if(fat_cache[cache_index].inuse &&
fat_cache[cache_index].secnum != secnum) fat_cache[cache_index].secnum != secnum)
{ {
#ifdef WRITE
/* Write back if it is dirty */ /* Write back if it is dirty */
if(fat_cache[cache_index].dirty) if(fat_cache[cache_index].dirty)
{ {
if(ata_write_sectors(secnum + fat_bpb.startsector, 1, sec)) if(ata_write_sectors(secnum + fat_bpb.startsector, 1,
fat_cache_sectors[cache_index]))
{ {
panic("cache_fat_sector() - Could" panicf("cache_fat_sector() - Could not write sector %d\n",
" not write sector %d\n", secnum);
secnum);
} }
} }
fat_cache[cache_index].secnum = 8; /* Normally an unused sector */ fat_cache[cache_index].secnum = 8; /* Normally an unused sector */
fat_cache[cache_index].dirty = false; fat_cache[cache_index].dirty = false;
#endif
fat_cache[cache_index].inuse = false; fat_cache[cache_index].inuse = false;
} }
@ -409,101 +424,107 @@ static void *cache_fat_sector(int secnum)
return fat_cache_sectors[cache_index]; return fat_cache_sectors[cache_index];
} }
#ifdef DISK_WRITE static int find_free_cluster(int startcluster)
static int update_entry(int entry, unsigned int val)
{ {
unsigned long *sec; int sector = startcluster / CLUSTERS_PER_FAT_SECTOR;
int fatoffset; int offset = startcluster % CLUSTERS_PER_FAT_SECTOR;
int thisfatsecnum; int i;
int thisfatentoffset;
fatoffset = entry * 4; LDEBUGF("find_free_cluster(%x)\n",startcluster);
thisfatsecnum = fatoffset / fat_bpb.bpb_bytspersec + fat_bpb.bpb_rsvdseccnt;
thisfatentoffset = fatoffset % fat_bpb.bpb_bytspersec;
/* Load the sector if it is not cached */ for (i = sector; i<fat_bpb.fatsize; i++) {
sec = cache_fat_sector(thisfatsecnum); int j;
if(!sec) unsigned int* fat = cache_fat_sector(i);
if ( !fat )
break;
for (j = offset; j < CLUSTERS_PER_FAT_SECTOR; j++)
if (!(SWAB32(fat[j]) & 0x0fffffff)) {
int c = i * CLUSTERS_PER_FAT_SECTOR + j;
LDEBUGF("Found free cluster %x\n",c);
fat_bpb.fsinfo.nextfree = c;
return c;
}
}
return 0; /* 0 is an illegal cluster number */
}
static int update_fat_entry(int entry, unsigned int val)
{
int sector = entry / CLUSTERS_PER_FAT_SECTOR;
int offset = entry % CLUSTERS_PER_FAT_SECTOR;
unsigned int* sec;
LDEBUGF("update_fat_entry(%x,%x)\n",entry,val);
sec = cache_fat_sector(sector);
if (!sec)
{ {
DEBUGF( "update_entry() - Could not cache sector %d\n", DEBUGF( "update_entry() - Could not cache sector %d\n", sector);
thisfatsecnum);
return -1; return -1;
} }
fat_cache[sector & FAT_CACHE_MASK].dirty = true;
/* We can safely assume that the correct sector is in the cache, if ( val ) {
so we mark it dirty without checking the sector number */ if (!(sec[offset] & 0x0fffffff))
fat_cache[thisfatsecnum & FAT_CACHE_MASK].dirty = 1; fat_bpb.fsinfo.freecount--;
}
else
fat_bpb.fsinfo.freecount++;
/* don't change top 4 bits */ /* don't change top 4 bits */
sec[thisfatentoffset/sizeof(int)] &= 0xf000000; sec[offset] &= SWAB32(0xf000000);
sec[thisfatentoffset/sizeof(int)] |= val & 0x0fffffff; sec[offset] |= SWAB32(val & 0x0fffffff);
return 0; return 0;
} }
#endif
static int read_entry(int entry) static int read_fat_entry(int entry)
{ {
unsigned long *sec; int sector = entry / CLUSTERS_PER_FAT_SECTOR;
int fatoffset; int offset = entry % CLUSTERS_PER_FAT_SECTOR;
int thisfatsecnum; unsigned int* sec;
int thisfatentoffset;
int val = -1;
fatoffset = entry * 4; sec = cache_fat_sector(sector);
thisfatsecnum = fatoffset / fat_bpb.bpb_bytspersec + fat_bpb.bpb_rsvdseccnt; if (!sec)
thisfatentoffset = fatoffset % fat_bpb.bpb_bytspersec;
/* Load the sector if it is not cached */
sec = cache_fat_sector(thisfatsecnum);
if(!sec)
{ {
DEBUGF( "read_entry() - Could not cache sector %d\n", DEBUGF( "read_fat_entry() - Could not cache sector %d\n", sector);
thisfatsecnum);
return -1; return -1;
} }
val = sec[thisfatentoffset/sizeof(int)]; return SWAB32(sec[offset]);
val = SWAB32(val);
return val;
} }
static int get_next_cluster(unsigned int cluster) static int get_next_cluster(unsigned int cluster)
{ {
int next_cluster; int next_cluster;
next_cluster = read_entry(cluster); next_cluster = read_fat_entry(cluster);
/* is this last cluster in chain? */ /* is this last cluster in chain? */
if ( next_cluster >= 0x0ffffff8 ) if ( next_cluster >= FAT_EOF_MARK )
return 0; return 0;
else else
return next_cluster; return next_cluster;
} }
#ifdef DISK_WRITE static int flush_fat(void)
static int flush_fat(struct bpb *bpb)
{ {
int i; int i;
int err; int err;
unsigned char *sec; unsigned char *sec;
int secnum; int secnum;
int fatsz; unsigned char fsinfo[SECTOR_SIZE];
unsigned short d, t; unsigned int* intptr;
char m;
fatsz = fat_bpb.fatsize; LDEBUGF("flush_fat()\n");
for(i = 0;i < FAT_CACHE_SIZE;i++) for(i = 0;i < FAT_CACHE_SIZE;i++)
{ {
if(fat_cache[i].ptr && fat_cache[i].dirty) if(fat_cache[i].inuse && fat_cache[i].dirty)
{ {
secnum = fat_cache[i].secnum + fat_bpb.bpb_rsvdseccnt + secnum = fat_cache[i].secnum + fat_bpb.startsector;
fat_bpb.startsector; LDEBUGF("Flushing FAT sector %x\n", secnum);
DEBUGF("Flushing FAT sector %d\n", secnum); sec = fat_cache_sectors[i];
sec = fat_cache[i].ptr;
/* Write to the first FAT */ /* Write to the first FAT */
err = ata_write_sectors(secnum, 1, sec); err = ata_write_sectors(secnum, 1, sec);
@ -514,19 +535,41 @@ static int flush_fat(struct bpb *bpb)
return -1; return -1;
} }
/* Write to the second FAT */ if(fat_bpb.bpb_numfats > 1 )
err = ata_write_sectors(secnum + fatsz, 1, sec);
if(err)
{ {
DEBUGF( "flush_fat() - Couldn't write" /* Write to the second FAT */
" sector (%d)\n", secnum + fatsz); err = ata_write_sectors(secnum + fat_bpb.fatsize, 1, sec);
return -1; if (err)
{
DEBUGF( "flush_fat() - Couldn't write"
" sector (%d)\n", secnum + fat_bpb.fatsize);
return -2;
}
} }
fat_cache[i].dirty = 0; fat_cache[i].dirty = false;
} }
} }
getcurrdostime(&d, &t, &m); /* update fsinfo */
err = ata_read_sectors(fat_bpb.startsector + fat_bpb.bpb_fsinfo, 1,fsinfo);
if (err)
{
DEBUGF( "flush_fat() - Couldn't read FSInfo (error code %d)\n", err);
return -1;
}
intptr = (int*)&(fsinfo[FSINFO_FREECOUNT]);
*intptr = SWAB32(fat_bpb.fsinfo.freecount);
intptr = (int*)&(fsinfo[FSINFO_NEXTFREE]);
*intptr = SWAB32(fat_bpb.fsinfo.nextfree);
err = ata_write_sectors(fat_bpb.startsector + fat_bpb.bpb_fsinfo,1,fsinfo);
if (err)
{
DEBUGF( "flush_fat() - Couldn't write FSInfo (error code %d)\n", err);
return -1;
}
return 0; return 0;
} }
@ -534,10 +577,9 @@ static unsigned int getcurrdostime(unsigned short *dosdate,
unsigned short *dostime, unsigned short *dostime,
unsigned char *dostenth) unsigned char *dostenth)
{ {
struct timeb tb; #if 0
struct tm *tm; struct tm *tm;
unsigned long now = time();
ftime(&tb);
tm = localtime(&tb.time); tm = localtime(&tb.time);
*dosdate = ((tm->tm_year - 80) << 9) | *dosdate = ((tm->tm_year - 80) << 9) |
@ -549,102 +591,92 @@ static unsigned int getcurrdostime(unsigned short *dosdate,
(tm->tm_sec >> 1); (tm->tm_sec >> 1);
*dostenth = (tm->tm_sec & 1) * 100 + tb.millitm / 10; *dostenth = (tm->tm_sec & 1) * 100 + tb.millitm / 10;
#else
*dosdate = 0;
*dostime = 0;
*dostenth = 0;
#endif
return 0; return 0;
} }
static int add_dir_entry(unsigned int currdir, struct fat_direntry *de) static int add_dir_entry(struct fat_dir* dir,
struct fat_direntry* de,
struct fat_file* file)
{ {
unsigned char buf[SECTOR_SIZE]; unsigned char buf[SECTOR_SIZE];
unsigned char *eptr; unsigned char *eptr;
int i; int i;
int err; int err;
unsigned int sec; int sec;
unsigned int sec_cnt; int sec_cnt;
int need_to_update_last_empty_marker = 0; bool need_to_update_last_empty_marker = false;
int is_rootdir = (currdir == 0); bool done = false;
int done = 0;
unsigned char firstbyte; unsigned char firstbyte;
int currdir = dir->startcluster;
bool is_rootdir = (currdir == 0);
if(is_rootdir) LDEBUGF( "add_dir_entry()\n");
{
if (is_rootdir)
sec = fat_bpb.rootdirsector; sec = fat_bpb.rootdirsector;
}
else else
{
sec = first_sector_of_cluster(currdir); sec = first_sector_of_cluster(currdir);
}
sec_cnt = 0; sec_cnt = 0;
while(!done) while(!done)
{ {
/* The root dir has a fixed size */ if (sec_cnt >= fat_bpb.bpb_secperclus)
if(is_rootdir)
{ {
if(sec_cnt >= fat_bpb.bpb_rootentcnt * 32 / fat_bpb.bpb_bytspersec) int oldcluster = currdir;
/* We have reached the end of this cluster */
LDEBUGF("Moving to the next cluster...");
currdir = get_next_cluster(currdir);
LDEBUGF("new cluster is %d\n", currdir);
if (!currdir)
{ {
/* We have reached the last sector of the root dir */ currdir = find_free_cluster(fat_bpb.fsinfo.nextfree);
if(need_to_update_last_empty_marker) if (!currdir) {
{ currdir = find_free_cluster(0);
/* Since the directory is full, there is no room for if (!currdir) {
a marker, so we just exit */ DEBUGF("add_dir_entry(): Disk full!\n");
return 0; return -1;
} }
else
{
DEBUGF( "add_dir_entry() -"
" Root dir is full\n");
return -1;
}
}
}
else
{
if(sec_cnt >= fat_bpb.bpb_secperclus)
{
/* We have reached the end of this cluster */
DEBUGF("Moving to the next cluster...");
currdir = get_next_cluster(currdir);
DEBUGF("new cluster is %d\n", currdir);
if(!currdir)
{
/* This was the last in the chain,
we have to allocate a new cluster */
/* TODO */
} }
update_fat_entry(oldcluster, currdir);
} }
} }
DEBUGF("Reading sector %d...\n", sec); LDEBUGF("Reading sector %d...\n", sec);
/* Read the next sector in the current dir */ /* Read the next sector in the current dir */
err = ata_read_sectors(sec + fat_bpb.startsector,1,buf); err = ata_read_sectors(sec + fat_bpb.startsector,1,buf);
if(err) if (err)
{ {
DEBUGF( "add_dir_entry() - Couldn't read dir sector" DEBUGF( "add_dir_entry() - Couldn't read dir sector"
" (error code %d)\n", err); " (error code %d)\n", err);
return -1; return -2;
} }
if(need_to_update_last_empty_marker) if (need_to_update_last_empty_marker)
{ {
/* All we need to do is to set the first entry to 0 */ /* All we need to do is to set the first entry to 0 */
DEBUGF("Clearing the first entry in sector %d\n", sec); LDEBUGF("Clearing the first entry in sector %x\n", sec);
buf[0] = 0; buf[0] = 0;
done = 1; done = true;
} }
else else
{ {
/* Look for a free slot */ /* Look for a free slot */
for(i = 0;i < SECTOR_SIZE;i+=32) for (i = 0; i < SECTOR_SIZE; i += DIR_ENTRY_SIZE)
{ {
firstbyte = buf[i]; firstbyte = buf[i];
if(firstbyte == 0xe5 || firstbyte == 0) if (firstbyte == 0xe5 || firstbyte == 0)
{ {
DEBUGF("Found free slot at entry %d in sector %d\n", LDEBUGF("Found free slot at entry %d in sector %x\n",
i/32, sec); i/DIR_ENTRY_SIZE, sec);
eptr = &buf[i]; eptr = &buf[i];
memset(eptr, 0, 32); memset(eptr, 0, DIR_ENTRY_SIZE);
strncpy(&eptr[FATDIR_NAME], de->name, 11); strncpy(&eptr[FATDIR_NAME], de->name, 11);
eptr[FATDIR_ATTR] = de->attr; eptr[FATDIR_ATTR] = de->attr;
eptr[FATDIR_NTRES] = 0; eptr[FATDIR_NTRES] = 0;
@ -665,31 +697,37 @@ static int add_dir_entry(unsigned int currdir, struct fat_direntry *de)
eptr[FATDIR_FILESIZE+2] = (de->filesize >> 16) & 0xff; eptr[FATDIR_FILESIZE+2] = (de->filesize >> 16) & 0xff;
eptr[FATDIR_FILESIZE+3] = (de->filesize >> 24) & 0xff; eptr[FATDIR_FILESIZE+3] = (de->filesize >> 24) & 0xff;
/* remember where the dir entry is located */
file->dirsector = sec;
file->direntry = i/DIR_ENTRY_SIZE;
/* Advance the last_empty_entry marker */ /* Advance the last_empty_entry marker */
if(firstbyte == 0) if (firstbyte == 0)
{ {
i += 32; i += DIR_ENTRY_SIZE;
if(i < SECTOR_SIZE) if (i < SECTOR_SIZE)
{ {
buf[i] = 0; buf[i] = 0;
/* We are done */ /* We are done */
done = 1; done = true;
} }
else else
{ {
/* We must fill in the first entry /* We must fill in the first entry
in the next sector */ in the next sector */
need_to_update_last_empty_marker = 1; need_to_update_last_empty_marker = true;
} }
} }
else
done = true;
err = ata_write_sectors(sec + fat_bpb.startsector,1,buf); err = ata_write_sectors(sec + fat_bpb.startsector,1,buf);
if(err) if (err)
{ {
DEBUGF( "add_dir_entry() - " DEBUGF( "add_dir_entry() - "
" Couldn't write dir" " Couldn't write dir"
" sector (error code %d)\n", err); " sector (error code %d)\n", err);
return -1; return -3;
} }
break; break;
} }
@ -746,11 +784,6 @@ static int create_dos_name(unsigned char *name, unsigned char *newname)
int i; int i;
char *ext; char *ext;
if(strlen(name) > 12)
{
return -1;
}
strcpy(n, name); strcpy(n, name);
ext = strchr(n, '.'); ext = strchr(n, '.');
@ -763,7 +796,7 @@ static int create_dos_name(unsigned char *name, unsigned char *newname)
In either case it is illegal. */ In either case it is illegal. */
if(n[0] == 0) if(n[0] == 0)
{ {
return -1; return -2;
} }
/* Name part */ /* Name part */
@ -781,10 +814,10 @@ static int create_dos_name(unsigned char *name, unsigned char *newname)
} }
/* Extension part */ /* Extension part */
for(i = 0;ext && ext[i] && (i < 3);i++) for (i = 0;ext && ext[i] && (i < 3);i++)
{ {
c = char2dos(ext[i]); c = char2dos(ext[i]);
if(c) if (c)
{ {
newname[8+i] = toupper(c); newname[8+i] = toupper(c);
} }
@ -796,50 +829,48 @@ static int create_dos_name(unsigned char *name, unsigned char *newname)
return 0; return 0;
} }
int fat_create_dir(unsigned int currdir, char *name) static void update_dir_entry( struct fat_file* file, int size )
{ {
struct fat_direntry de; unsigned char buf[SECTOR_SIZE];
int sector = file->dirsector + fat_bpb.startsector;
unsigned char* entry = buf + file->direntry * DIR_ENTRY_SIZE;
unsigned int* sizeptr;
unsigned short* clusptr;
int err; int err;
DEBUGF("fat_create_file()\n"); LDEBUGF("update_dir_entry(cluster:%x entry:%d size:%d)\n",
memset(&de, 0, sizeof(struct fat_direntry)); file->firstcluster,file->direntry,size);
if(create_dos_name(name, de.name) < 0)
{ if ( file->direntry >= (SECTOR_SIZE / DIR_ENTRY_SIZE) ) {
DEBUGF( "fat_create_file() - Illegal file name (%s)\n", name); DEBUGF("update_dir_entry(): Illegal entry %d!\n",file->direntry);
return -1; return;
} }
getcurrdostime(&de.crtdate, &de.crttime, &de.crttimetenth); err = ata_read_sectors(sector, 1, buf);
de.wrtdate = de.crtdate; if (err)
de.wrttime = de.crttime;
de.filesize = 0;
de.attr = FAT_ATTR_DIRECTORY;
err = add_dir_entry(currdir, &de);
return 0;
}
int fat_create_file(unsigned int currdir, char *name)
{
struct fat_direntry de;
int err;
DEBUGF("fat_create_file()\n");
memset(&de, 0, sizeof(struct fat_direntry));
if(create_dos_name(name, de.name) < 0)
{ {
DEBUGF( "fat_create_file() - Illegal file name (%s)\n", name); DEBUGF( "update_dir_entry() - Couldn't read dir sector %d"
return -1; " (error code %d)\n", sector, err);
return;
}
clusptr = (short*)(entry + FATDIR_FSTCLUSHI);
*clusptr = SWAB16(file->firstcluster >> 16);
clusptr = (short*)(entry + FATDIR_FSTCLUSLO);
*clusptr = SWAB16(file->firstcluster & 0xffff);
sizeptr = (int*)(entry + FATDIR_FILESIZE);
*sizeptr = SWAB32(size);
err = ata_write_sectors(sector, 1, buf);
if (err)
{
DEBUGF( "update_file_size() - Couldn't write dir sector %d"
" (error code %d)\n", sector, err);
return;
} }
getcurrdostime(&de.crtdate, &de.crttime, &de.crttimetenth);
de.wrtdate = de.crtdate;
de.wrttime = de.crttime;
de.filesize = 0;
err = add_dir_entry(currdir, &de);
return err;
} }
#endif
static int parse_direntry(struct fat_direntry *de, unsigned char *buf) static int parse_direntry(struct fat_direntry *de, unsigned char *buf)
{ {
@ -866,37 +897,138 @@ static int parse_direntry(struct fat_direntry *de, unsigned char *buf)
return 1; return 1;
} }
int fat_open( unsigned int startcluster, struct fat_file *file) int fat_open(unsigned int startcluster,
struct fat_file *file,
struct fat_dir* dir)
{ {
file->firstcluster = startcluster; file->firstcluster = startcluster;
file->nextcluster = startcluster; file->nextcluster = startcluster;
file->nextsector = cluster2sec(startcluster); file->nextsector = cluster2sec(startcluster);
file->sectornum = 0; file->sectornum = 0;
/* remember where the file's dir entry is located */
file->dirsector = dir->cached_sec;
file->direntry = (dir->entry % DIR_ENTRIES_PER_SECTOR) - 1;
LDEBUGF("fat_open: entry %d\n",file->direntry);
return 0; return 0;
} }
int fat_read( struct fat_file *file, int sectorcount, void* buf ) int fat_create_file(char* name,
struct fat_file* file,
struct fat_dir* dir)
{
struct fat_direntry de;
int err;
LDEBUGF("fat_create_file(\"%s\",%x,%x)\n",name,file,dir);
memset(&de, 0, sizeof(struct fat_direntry));
if (create_dos_name(name, de.name) < 0)
{
DEBUGF( "fat_create_file() - Illegal file name (%s)\n", name);
return -1;
}
getcurrdostime(&de.crtdate, &de.crttime, &de.crttimetenth);
de.wrtdate = de.crtdate;
de.wrttime = de.crttime;
de.filesize = 0;
err = add_dir_entry(dir, &de, file);
if (!err) {
file->firstcluster = 0;
file->nextcluster = 0;
file->nextsector = 0;
file->sectornum = 0;
}
return err;
}
int fat_closewrite(struct fat_file *file, int size)
{
int endcluster = file->nextcluster;
int next, last = endcluster;
/* free unused clusters, if any */
for ( next = get_next_cluster(last); next; last = next ) {
LDEBUGF("Clearing cluster %x\n",last);
update_fat_entry(last,0);
}
/* mark last used cluster as last in chain */
update_fat_entry(endcluster, FAT_EOF_MARK);
flush_fat();
update_dir_entry(file, size);
return 0;
}
int fat_readwrite( struct fat_file *file, int sectorcount,
void* buf, bool write )
{ {
int cluster = file->nextcluster; int cluster = file->nextcluster;
int sector = file->nextsector; int sector = file->nextsector;
int numsec = file->sectornum; int numsec = file->sectornum;
int first = sector, last = sector; int first, last;
int err, i; int err, i;
LDEBUGF( "fat_readwrite(file:%x,count:%d,buf:%x,%s)\n",
cluster,sectorcount,buf,write?"write":"read");
if ( sector == -1 ) if ( sector == -1 )
return 0; return 0;
/* find sequential sectors and read them all at once */ if ( write && !cluster) {
/* new file */
cluster = find_free_cluster(fat_bpb.fsinfo.nextfree);
if (!cluster) {
cluster = find_free_cluster(0);
if (!cluster) {
DEBUGF("fat_readwrite(): Disk full!\n");
return -3;
}
}
file->firstcluster = cluster;
sector = cluster2sec(cluster);
if (sector<0)
return -1;
}
first = sector;
last = sector;
/* find sequential sectors and read/write them all at once */
for (i=0; i<sectorcount && sector>=0; i++ ) { for (i=0; i<sectorcount && sector>=0; i++ ) {
numsec++; numsec++;
if ( numsec >= fat_bpb.bpb_secperclus ) { if ( numsec >= fat_bpb.bpb_secperclus ) {
int oldcluster = cluster;
cluster = get_next_cluster(cluster); cluster = get_next_cluster(cluster);
if (!cluster) { if (!cluster) {
/* end of file */ if ( write ) {
sector = -1; /* writing past end-of-file,
find a new free cluster to use. */
cluster = find_free_cluster(cluster);
if (!cluster) {
/* no cluster found after last,
search from beginning */
cluster = find_free_cluster(0);
if (!cluster) {
/* no free clusters. disk is full. */
sector = -1;
DEBUGF("fat_readwrite(): Disk full!\n");
}
}
if ( cluster )
update_fat_entry(oldcluster, cluster);
}
else {
/* reading past end-of-file */
sector = -1;
}
} }
else
{ if (cluster) {
sector = cluster2sec(cluster); sector = cluster2sec(cluster);
if (sector<0) if (sector<0)
return -1; return -1;
@ -910,11 +1042,14 @@ int fat_read( struct fat_file *file, int sectorcount, void* buf )
(i == sectorcount-1) || /* last sector requested? */ (i == sectorcount-1) || /* last sector requested? */
(last-first+1 == 256) ) { /* max 256 sectors per ata request */ (last-first+1 == 256) ) { /* max 256 sectors per ata request */
int count = last-first+1; int count = last-first+1;
err = ata_read_sectors(first + fat_bpb.startsector, count, buf); if (write)
if(err) { err = ata_write_sectors(first + fat_bpb.startsector, count, buf);
DEBUGF( "fat_read() - Couldn't read sector %d" else
err = ata_read_sectors(first + fat_bpb.startsector, count, buf);
if (err) {
DEBUGF( "fat_readwrite() - Couldn't read sector %d"
" (error code %d)\n", sector,err); " (error code %d)\n", sector,err);
return -1; return -2;
} }
((char*)buf) += count * SECTOR_SIZE; ((char*)buf) += count * SECTOR_SIZE;
first = sector; first = sector;
@ -970,9 +1105,9 @@ int fat_seek(struct fat_file *file, int seeksector )
return 0; return 0;
} }
int fat_opendir(struct fat_dir *dir, unsigned int currdir) int fat_opendir(struct fat_dir *dir, unsigned int startcluster)
{ {
int is_rootdir = (currdir == 0); int is_rootdir = (startcluster == 0);
unsigned int sec; unsigned int sec;
int err; int err;
@ -982,7 +1117,7 @@ int fat_opendir(struct fat_dir *dir, unsigned int currdir)
} }
else else
{ {
sec = first_sector_of_cluster(currdir); sec = first_sector_of_cluster(startcluster);
} }
/* Read the first sector in the current dir */ /* Read the first sector in the current dir */
@ -997,13 +1132,14 @@ int fat_opendir(struct fat_dir *dir, unsigned int currdir)
dir->entry = 0; dir->entry = 0;
dir->cached_sec = sec; dir->cached_sec = sec;
dir->num_sec = 0; dir->num_sec = 0;
dir->startcluster = startcluster;
return 0; return 0;
} }
int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
{ {
int done = 0; bool done = false;
int i; int i;
int err; int err;
unsigned char firstbyte; unsigned char firstbyte;
@ -1013,29 +1149,30 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
while(!done) while(!done)
{ {
for(i = dir->entry;i < SECTOR_SIZE/32;i++) for (i = dir->entry; i < SECTOR_SIZE/DIR_ENTRY_SIZE; i++)
{ {
firstbyte = dir->cached_buf[i*32]; firstbyte = dir->cached_buf[i*DIR_ENTRY_SIZE];
if(firstbyte == 0xe5) { if (firstbyte == 0xe5) {
/* free entry */ /* free entry */
sectoridx = 0; sectoridx = 0;
continue; continue;
} }
if(firstbyte == 0) { if (firstbyte == 0) {
/* last entry */ /* last entry */
entry->name[0] = 0; entry->name[0] = 0;
return 0; return 0;
} }
/* longname entry? */ /* longname entry? */
if ( ( dir->cached_buf[i*32 + FATDIR_ATTR] & if ( ( dir->cached_buf[i*DIR_ENTRY_SIZE + FATDIR_ATTR] &
FAT_ATTR_LONG_NAME_MASK ) == FAT_ATTR_LONG_NAME ) { FAT_ATTR_LONG_NAME_MASK ) == FAT_ATTR_LONG_NAME ) {
longarray[longs++] = i*32 + sectoridx; longarray[longs++] = i*DIR_ENTRY_SIZE + sectoridx;
} }
else { else {
if ( parse_direntry(entry, &dir->cached_buf[i*32]) ) { if ( parse_direntry(entry,
&dir->cached_buf[i*DIR_ENTRY_SIZE]) ) {
/* don't return volume id entry */ /* don't return volume id entry */
if ( entry->attr == FAT_ATTR_VOLUME_ID ) if ( entry->attr == FAT_ATTR_VOLUME_ID )
@ -1076,7 +1213,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
} }
entry->name[l]=0; entry->name[l]=0;
} }
done = 1; done = true;
sectoridx = 0; sectoridx = 0;
break; break;
} }
@ -1091,7 +1228,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
sectoridx += SECTOR_SIZE; sectoridx += SECTOR_SIZE;
/* Next sector? */ /* Next sector? */
if(i < SECTOR_SIZE/32) if (i < SECTOR_SIZE / DIR_ENTRY_SIZE)
{ {
i++; i++;
} }
@ -1100,7 +1237,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
dir->num_sec++; dir->num_sec++;
/* Do we need to advance one cluster? */ /* Do we need to advance one cluster? */
if(dir->num_sec < fat_bpb.bpb_secperclus) if (dir->num_sec < fat_bpb.bpb_secperclus)
{ {
dir->cached_sec++; dir->cached_sec++;
} }
@ -1113,16 +1250,16 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
} }
dir->num_sec = 0; dir->num_sec = 0;
cluster = get_next_cluster( cluster ); cluster = get_next_cluster( cluster );
if(!cluster) if (!cluster)
{ {
DEBUGF("End of cluster chain.\n"); DEBUGF("End of cluster chain.\n");
return -1; return -2;
} }
dir->cached_sec = cluster2sec(cluster); dir->cached_sec = cluster2sec(cluster);
if ( dir->cached_sec < 0 ) if ( dir->cached_sec < 0 )
{ {
DEBUGF("Invalid cluster: %d\n",cluster); DEBUGF("Invalid cluster: %d\n",cluster);
return -1; return -3;
} }
} }
@ -1130,11 +1267,11 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
/* Read the next sector */ /* Read the next sector */
err = ata_read_sectors(dir->cached_sec + fat_bpb.startsector, 1, err = ata_read_sectors(dir->cached_sec + fat_bpb.startsector, 1,
dir->cached_buf); dir->cached_buf);
if(err) if (err)
{ {
DEBUGF( "fat_getnext() - Couldn't read dir sector" DEBUGF( "fat_getnext() - Couldn't read dir sector"
" (error code %d)\n", err); " (error code %d)\n", err);
return -1; return -4;
} }
i = 0; i = 0;

19
firmware/drivers/fat.h
View file

@ -20,6 +20,8 @@
#ifndef FAT_H #ifndef FAT_H
#define FAT_H #define FAT_H
#include <stdbool.h>
#define SECTOR_SIZE 512 #define SECTOR_SIZE 512
struct fat_direntry struct fat_direntry
@ -50,6 +52,7 @@ struct fat_dir
int cached_sec; int cached_sec;
int num_sec; int num_sec;
unsigned char cached_buf[SECTOR_SIZE]; unsigned char cached_buf[SECTOR_SIZE];
int startcluster;
}; };
struct fat_file struct fat_file
@ -58,17 +61,23 @@ struct fat_file
int nextcluster; /* cluster of last access */ int nextcluster; /* cluster of last access */
int nextsector; /* sector of last access */ int nextsector; /* sector of last access */
int sectornum; /* sector number in this cluster */ int sectornum; /* sector number in this cluster */
int dirsector; /* sector where the dir entry is located */
int direntry; /* dir entry index in sector */
}; };
extern int fat_mount(int startsector); extern int fat_mount(int startsector);
#ifdef DISK_WRITE
extern int fat_create_file(unsigned int currdir, char *name);
extern int fat_create_dir(unsigned int currdir, char *name); extern int fat_create_dir(unsigned int currdir, char *name);
#endif
extern int fat_startsector(void); extern int fat_startsector(void);
extern int fat_open(unsigned int cluster, struct fat_file *ent); extern int fat_open(unsigned int cluster,
extern int fat_read(struct fat_file *ent, int sectorcount, void* buf ); struct fat_file* ent,
struct fat_dir* dir);
extern int fat_create_file(char* name,
struct fat_file* ent,
struct fat_dir* dir);
extern int fat_readwrite(struct fat_file *ent, int sectorcount,
void* buf, bool write );
extern int fat_closewrite(struct fat_file *ent, int size);
extern int fat_seek(struct fat_file *ent, int sector ); extern int fat_seek(struct fat_file *ent, int sector );
extern int fat_opendir(struct fat_dir *ent, unsigned int currdir); extern int fat_opendir(struct fat_dir *ent, unsigned int currdir);

25
firmware/test/fat/README Normal file
View file

@ -0,0 +1,25 @@
This code is for testing the Rockbox fat code on a dummy drive image file.
Dummy image
-----------
Here's how to create a 1 gig dummy drive image in linux:
# dd if=/dev/hda of=disk.img bs=1M count=1024
You can then format disk.img as a FAT32 partition:
# mkdosfs -F 32 disk.img
To mount the image, your linux kernel must include the loopback device:
# mount -o loop disk.img /mnt/image
Now copy some test data to the disk, umount it and start testing.
Test code
---------
The files in this dir build the 'fat' program. It will read 'disk.img' and
treat is as a real disk, thanks to the ata-sim.c module.
Modify the main.c source code to make it perform the tests you want.

7
firmware/test/fat/ata-sim.c
View file

@ -24,6 +24,13 @@ int ata_read_sectors(unsigned long start, unsigned char count, void* buf)
int ata_write_sectors(unsigned long start, unsigned char count, void* buf) int ata_write_sectors(unsigned long start, unsigned char count, void* buf)
{ {
DEBUGF("Writing block 0x%lx\n",start);
if (start == 0) {
DEBUGF("Holy crap! You're writing on sector 0!\n");
exit(0);
}
if(fseek(file,start*BLOCK_SIZE,SEEK_SET)) { if(fseek(file,start*BLOCK_SIZE,SEEK_SET)) {
perror("fseek"); perror("fseek");
return -1; return -1;

52
firmware/test/fat/main.c
View file

@ -1,6 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdarg.h>
#include "fat.h" #include "fat.h"
#include "debug.h" #include "debug.h"
#include "disk.h" #include "disk.h"
@ -14,6 +15,15 @@ void dbg_dump_sector(int sec);
void dbg_dump_buffer(unsigned char *buf); void dbg_dump_buffer(unsigned char *buf);
void dbg_console(void); void dbg_console(void);
void panicf( char *fmt, ...)
{
va_list ap;
va_start( ap, fmt );
vprintf( fmt, ap );
va_end( ap );
exit(0);
}
void dbg_dump_sector(int sec) void dbg_dump_sector(int sec)
{ {
unsigned char buf[512]; unsigned char buf[512];
@ -75,14 +85,16 @@ void dbg_dir(char* currdir)
void dbg_mkfile(char* name) void dbg_mkfile(char* name)
{ {
char* text = "Detta är en dummy-text\n"; char* text = "Detta är en dummy-text\n";
int i;
int fd = open(name,O_WRONLY); int fd = open(name,O_WRONLY);
if (fd<0) { if (fd<0) {
DEBUGF("Failed creating file\n"); DEBUGF("Failed creating file\n");
return; return;
} }
if (write(fd, text, strlen(text)) < 0) for (i=0;i<200;i++)
DEBUGF("Failed writing data\n"); if (write(fd, text, strlen(text)) < 0)
DEBUGF("Failed writing data\n");
close(fd); close(fd);
} }
@ -168,6 +180,33 @@ void dbg_tail(char* name)
close(fd); close(fd);
} }
void dbg_head(char* name)
{
unsigned char buf[SECTOR_SIZE*5];
int fd,rc;
fd = open(name,O_RDONLY);
if (fd<0)
return;
DEBUGF("Got file descriptor %d\n",fd);
rc = read(fd, buf, SECTOR_SIZE);
if( rc > 0 )
{
buf[rc]=0;
printf("%d: %s\n", strlen(buf), buf);
}
else if ( rc == 0 ) {
DEBUGF("EOF\n");
}
else
{
DEBUGF("Failed reading file: %d\n",rc);
}
close(fd);
}
char current_directory[256] = "\\"; char current_directory[256] = "\\";
int last_secnum = 0; int last_secnum = 0;
@ -284,9 +323,12 @@ int main(int argc, char *argv[])
} }
//dbg_console(); //dbg_console();
//dbg_tail("/fat.h");
//dbg_dir("/"); //dbg_dir("/");
dbg_mkfile("/apa.txt"); #if 1
dbg_head("/bepa.txt");
#else
dbg_mkfile("/bepa.txt");
#endif
dbg_dir("/"); dbg_dir("/");
return 0; return 0;