summaryrefslogtreecommitdiffstats
path: root/firmware
diff options
context:
space:
mode:
authorJens Arnold <amiconn@rockbox.org>2006-12-04 21:37:22 +0000
committerJens Arnold <amiconn@rockbox.org>2006-12-04 21:37:22 +0000
commitef3e129b6530b1694c0fcfa8ee2fbdf3ea95b083 (patch)
tree073e5fe264f0edcfc907254320b4f90e74042672 /firmware
parent74369b4a7b1b91371dc90905dc26e54b919d81a4 (diff)
downloadrockbox-ef3e129b6530b1694c0fcfa8ee2fbdf3ea95b083.tar.gz
rockbox-ef3e129b6530b1694c0fcfa8ee2fbdf3ea95b083.zip
Much simpler implementation of large virtual sector support, not needing larger sector buffers and not touching file.c at all. secmult is simply used to normalize all sector counts to 512-byte physical sectors. * Moved MAX_SECTOR_SIZE definition to config-*.h, and enabled it for iPod Video only. MAX_SECTOR_SIZE now only enables checking for alternate disk layouts due to sector size (as iPod Video G5.5 is presented as having 2048-byte _physical_ sectors to the PC). Large virtual sector support in fat.c is always enabled.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@11659 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'firmware')
-rw-r--r--firmware/common/disk.c29
-rw-r--r--firmware/common/file.c29
-rw-r--r--firmware/drivers/fat.c159
-rw-r--r--firmware/export/config-ipodvideo.h4
-rw-r--r--firmware/export/fat.h12
5 files changed, 94 insertions, 139 deletions
diff --git a/firmware/common/disk.c b/firmware/common/disk.c
index f5f9f194b2..c58ae3ee86 100644
--- a/firmware/common/disk.c
+++ b/firmware/common/disk.c
@@ -152,26 +152,29 @@ int disk_mount(int drive)
real problem. */
for (i=0; volume != -1 && i<4; i++)
{
- if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) pinfo[i].start))
+#ifdef MAX_SECTOR_SIZE
+ int j;
+
+ for (j = 1; j <= (MAX_SECTOR_SIZE/SECTOR_SIZE); j <<= 1)
{
- mounted++;
- vol_drive[volume] = drive; /* remember the drive for this volume */
- volume = get_free_volume(); /* prepare next entry */
- continue;
+ if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) pinfo[i].start * j))
+ {
+ pinfo[i].start *= j;
+ pinfo[i].size *= j;
+ mounted++;
+ vol_drive[volume] = drive; /* remember the drive for this volume */
+ volume = get_free_volume(); /* prepare next entry */
+ break;
+ }
}
-
-# if MAX_SECTOR_SIZE != PHYSICAL_SECTOR_SIZE
- /* Try again with sector size 2048 */
- if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) pinfo[i].start
- * (MAX_SECTOR_SIZE/PHYSICAL_SECTOR_SIZE)))
+#else
+ if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) pinfo[i].start))
{
- pinfo[i].start *= MAX_SECTOR_SIZE/PHYSICAL_SECTOR_SIZE;
- pinfo[i].size *= MAX_SECTOR_SIZE/PHYSICAL_SECTOR_SIZE;
mounted++;
vol_drive[volume] = drive; /* remember the drive for this volume */
volume = get_free_volume(); /* prepare next entry */
}
-# endif
+#endif
}
#endif
diff --git a/firmware/common/file.c b/firmware/common/file.c
index d1ba10569a..e24b44ce1f 100644
--- a/firmware/common/file.c
+++ b/firmware/common/file.c
@@ -36,7 +36,7 @@
*/
struct filedesc {
- unsigned char cache[MAX_SECTOR_SIZE];
+ unsigned char cache[SECTOR_SIZE];
int cacheoffset; /* invariant: 0 <= cacheoffset <= SECTOR_SIZE */
long fileoffset;
long size;
@@ -415,10 +415,9 @@ int ftruncate(int fd, off_t size)
{
int rc, sector;
struct filedesc* file = &openfiles[fd];
- int secsize = fat_get_secsize(&(file->fatfile));
- sector = size / secsize;
- if (size % secsize)
+ sector = size / SECTOR_SIZE;
+ if (size % SECTOR_SIZE)
sector++;
rc = fat_seek(&(file->fatfile), sector);
@@ -445,7 +444,7 @@ static int flush_cache(int fd)
{
int rc;
struct filedesc* file = &openfiles[fd];
- long sector = file->fileoffset / fat_get_secsize(&(file->fatfile));
+ long sector = file->fileoffset / SECTOR_SIZE;
DEBUGF("Flushing dirty sector cache\n");
@@ -474,7 +473,6 @@ static int readwrite(int fd, void* buf, long count, bool write)
long sectors;
long nread=0;
struct filedesc* file = &openfiles[fd];
- int secsize = fat_get_secsize(&(file->fatfile));
int rc;
if ( !file->busy ) {
@@ -492,7 +490,7 @@ static int readwrite(int fd, void* buf, long count, bool write)
/* any head bytes? */
if ( file->cacheoffset != -1 ) {
int offs = file->cacheoffset;
- int headbytes = MIN(count, secsize - offs);
+ int headbytes = MIN(count, SECTOR_SIZE - offs);
if (write) {
memcpy( file->cache + offs, buf, headbytes );
@@ -502,7 +500,7 @@ static int readwrite(int fd, void* buf, long count, bool write)
memcpy( buf, file->cache + offs, headbytes );
}
- if (offs + headbytes == secsize) {
+ if (offs + headbytes == SECTOR_SIZE) {
if (file->dirty) {
int rc = flush_cache(fd);
if ( rc < 0 ) {
@@ -525,7 +523,7 @@ static int readwrite(int fd, void* buf, long count, bool write)
* more data to follow in this call). Do NOT flush here. */
/* read/write whole sectors right into/from the supplied buffer */
- sectors = count / secsize;
+ sectors = count / SECTOR_SIZE;
if ( sectors ) {
int rc = fat_readwrite(&(file->fatfile), sectors,
(unsigned char*)buf+nread, write );
@@ -543,8 +541,8 @@ static int readwrite(int fd, void* buf, long count, bool write)
}
else {
if ( rc > 0 ) {
- nread += rc * secsize;
- count -= sectors * secsize;
+ nread += rc * SECTOR_SIZE;
+ count -= sectors * SECTOR_SIZE;
/* if eof, skip tail bytes */
if ( rc < sectors )
@@ -577,7 +575,7 @@ static int readwrite(int fd, void* buf, long count, bool write)
/* seek back one sector to put file position right */
rc = fat_seek(&(file->fatfile),
(file->fileoffset + nread) /
- secsize);
+ SECTOR_SIZE);
if ( rc < 0 ) {
DEBUGF("fat_seek() failed\n");
errno = EIO;
@@ -643,7 +641,6 @@ off_t lseek(int fd, off_t offset, int whence)
int sectoroffset;
int rc;
struct filedesc* file = &openfiles[fd];
- int secsize = fat_get_secsize(&(file->fatfile));
LDEBUGF("lseek(%d,%ld,%d)\n",fd,offset,whence);
@@ -675,9 +672,9 @@ off_t lseek(int fd, off_t offset, int whence)
}
/* new sector? */
- newsector = pos / secsize;
- oldsector = file->fileoffset / secsize;
- sectoroffset = pos % secsize;
+ newsector = pos / SECTOR_SIZE;
+ oldsector = file->fileoffset / SECTOR_SIZE;
+ sectoroffset = pos % SECTOR_SIZE;
if ( (newsector != oldsector) ||
((file->cacheoffset==-1) && sectoroffset) ) {
diff --git a/firmware/drivers/fat.c b/firmware/drivers/fat.c
index 004e2a78ca..f9d116eba8 100644
--- a/firmware/drivers/fat.c
+++ b/firmware/drivers/fat.c
@@ -109,9 +109,9 @@
#define FATLONG_TYPE 12
#define FATLONG_CHKSUM 13
-#define CLUSTERS_PER_FAT_SECTOR ((unsigned int)(fat_bpb->bpb_bytspersec / 4))
-#define CLUSTERS_PER_FAT16_SECTOR ((unsigned int)(fat_bpb->bpb_bytspersec / 2))
-#define DIR_ENTRIES_PER_SECTOR ((unsigned int)(fat_bpb->bpb_bytspersec / DIR_ENTRY_SIZE))
+#define CLUSTERS_PER_FAT_SECTOR (SECTOR_SIZE / 4)
+#define CLUSTERS_PER_FAT16_SECTOR (SECTOR_SIZE / 2)
+#define DIR_ENTRIES_PER_SECTOR (SECTOR_SIZE / DIR_ENTRY_SIZE)
#define DIR_ENTRY_SIZE 32
#define NAME_BYTES_PER_ENTRY 13
#define FAT_BAD_MARK 0x0ffffff7
@@ -128,6 +128,9 @@ struct fsinfo {
#define FSINFO_FREECOUNT 488
#define FSINFO_NEXTFREE 492
+/* Note: This struct doesn't hold the raw values after mounting if
+ * bpb_bytspersec isn't 512. All sector counts are normalized to 512 byte
+ * physical sectors. */
struct bpb
{
int bpb_bytspersec; /* Bytes per sector, typically 512 */
@@ -165,8 +168,6 @@ struct bpb
int drive; /* on which physical device is this located */
bool mounted; /* flag if this volume is mounted */
#endif
-
- int secmult; /* bpb_bytspersec / PHYSICAL_SECTOR_SIZE */
};
static struct bpb fat_bpbs[NUM_VOLUMES]; /* mounted partition info */
@@ -193,7 +194,7 @@ struct fat_cache_entry
#endif
};
-static char fat_cache_sectors[FAT_CACHE_SIZE][MAX_SECTOR_SIZE];
+static char fat_cache_sectors[FAT_CACHE_SIZE][SECTOR_SIZE];
static struct fat_cache_entry fat_cache[FAT_CACHE_SIZE];
static struct mutex cache_mutex;
@@ -235,11 +236,9 @@ void fat_size(IF_MV2(int volume,) unsigned long* size, unsigned long* free)
#endif
struct bpb* fat_bpb = &fat_bpbs[volume];
if (size)
- *size = (fat_bpb->dataclusters * fat_bpb->bpb_secperclus
- * fat_bpb->secmult) / 2;
+ *size = fat_bpb->dataclusters * fat_bpb->bpb_secperclus / 2;
if (free)
- *free = (fat_bpb->fsinfo.freecount * fat_bpb->bpb_secperclus
- * fat_bpb->secmult) / 2;
+ *free = fat_bpb->fsinfo.freecount * fat_bpb->bpb_secperclus / 2;
}
void fat_init(void)
@@ -273,8 +272,9 @@ int fat_mount(IF_MV2(int volume,) IF_MV2(int drive,) long startsector)
const int volume = 0;
#endif
struct bpb* fat_bpb = &fat_bpbs[volume];
- unsigned char buf[MAX_SECTOR_SIZE];
+ unsigned char buf[SECTOR_SIZE];
int rc;
+ int secmult;
long datasec;
#ifdef HAVE_FAT16SUPPORT
int rootdirsectors;
@@ -295,19 +295,20 @@ int fat_mount(IF_MV2(int volume,) IF_MV2(int drive,) long startsector)
#endif
fat_bpb->bpb_bytspersec = BYTES2INT16(buf,BPB_BYTSPERSEC);
- fat_bpb->bpb_secperclus = buf[BPB_SECPERCLUS];
- fat_bpb->bpb_rsvdseccnt = BYTES2INT16(buf,BPB_RSVDSECCNT);
+ secmult = fat_bpb->bpb_bytspersec / SECTOR_SIZE;
+ /* Sanity check is performed later */
+
+ fat_bpb->bpb_secperclus = secmult * buf[BPB_SECPERCLUS];
+ fat_bpb->bpb_rsvdseccnt = secmult * BYTES2INT16(buf,BPB_RSVDSECCNT);
fat_bpb->bpb_numfats = buf[BPB_NUMFATS];
- fat_bpb->bpb_totsec16 = BYTES2INT16(buf,BPB_TOTSEC16);
fat_bpb->bpb_media = buf[BPB_MEDIA];
- fat_bpb->bpb_fatsz16 = BYTES2INT16(buf,BPB_FATSZ16);
- fat_bpb->bpb_fatsz32 = BYTES2INT32(buf,BPB_FATSZ32);
- fat_bpb->bpb_totsec32 = BYTES2INT32(buf,BPB_TOTSEC32);
+ fat_bpb->bpb_fatsz16 = secmult * BYTES2INT16(buf,BPB_FATSZ16);
+ fat_bpb->bpb_fatsz32 = secmult * BYTES2INT32(buf,BPB_FATSZ32);
+ fat_bpb->bpb_totsec16 = secmult * BYTES2INT16(buf,BPB_TOTSEC16);
+ fat_bpb->bpb_totsec32 = secmult * BYTES2INT32(buf,BPB_TOTSEC32);
fat_bpb->last_word = BYTES2INT16(buf,BPB_LAST_WORD);
/* calculate a few commonly used values */
- fat_bpb->secmult = fat_bpb->bpb_bytspersec / PHYSICAL_SECTOR_SIZE;
-
if (fat_bpb->bpb_fatsz16 != 0)
fat_bpb->fatsize = fat_bpb->bpb_fatsz16;
else
@@ -320,8 +321,8 @@ int fat_mount(IF_MV2(int volume,) IF_MV2(int drive,) long startsector)
#ifdef HAVE_FAT16SUPPORT
fat_bpb->bpb_rootentcnt = BYTES2INT16(buf,BPB_ROOTENTCNT);
- rootdirsectors = ((fat_bpb->bpb_rootentcnt * 32)
- + (fat_bpb->bpb_bytspersec - 1)) / fat_bpb->bpb_bytspersec;
+ rootdirsectors = secmult * ((fat_bpb->bpb_rootentcnt * DIR_ENTRY_SIZE
+ + fat_bpb->bpb_bytspersec - 1) / fat_bpb->bpb_bytspersec);
#endif /* #ifdef HAVE_FAT16SUPPORT */
fat_bpb->firstdatasector = fat_bpb->bpb_rsvdseccnt
@@ -375,7 +376,7 @@ int fat_mount(IF_MV2(int volume,) IF_MV2(int drive,) long startsector)
#endif /* #ifdef HAVE_FAT16SUPPORT */
{ /* FAT32 specific part of BPB */
fat_bpb->bpb_rootclus = BYTES2INT32(buf,BPB_ROOTCLUS);
- fat_bpb->bpb_fsinfo = BYTES2INT16(buf,BPB_FSINFO);
+ fat_bpb->bpb_fsinfo = secmult * BYTES2INT16(buf,BPB_FSINFO);
fat_bpb->rootdirsector = cluster2sec(IF_MV2(fat_bpb,) fat_bpb->bpb_rootclus);
}
@@ -397,7 +398,7 @@ int fat_mount(IF_MV2(int volume,) IF_MV2(int drive,) long startsector)
{
/* Read the fsinfo sector */
rc = ata_read_sectors(IF_MV2(drive,)
- startsector + (fat_bpb->bpb_fsinfo * fat_bpb->secmult), 1, buf);
+ startsector + fat_bpb->bpb_fsinfo, 1, buf);
if (rc < 0)
{
DEBUGF( "fat_mount() - Couldn't read FSInfo (error code %d)\n", rc);
@@ -512,15 +513,12 @@ static int bpb_is_sane(IF_MV_NONVOID(struct bpb* fat_bpb))
#ifndef HAVE_MULTIVOLUME
struct bpb* fat_bpb = &fat_bpbs[0];
#endif
- if(fat_bpb->bpb_bytspersec > MAX_SECTOR_SIZE
- || fat_bpb->bpb_bytspersec < PHYSICAL_SECTOR_SIZE
- || fat_bpb->bpb_bytspersec % PHYSICAL_SECTOR_SIZE)
+ if(fat_bpb->bpb_bytspersec % SECTOR_SIZE)
{
DEBUGF( "bpb_is_sane() - Error: sector size is not sane (%d)\n",
fat_bpb->bpb_bytspersec);
return -1;
}
-
if((long)fat_bpb->bpb_secperclus * (long)fat_bpb->bpb_bytspersec > 128L*1024L)
{
DEBUGF( "bpb_is_sane() - Error: cluster size is larger than 128K "
@@ -564,20 +562,17 @@ static void flush_fat_sector(struct fat_cache_entry *fce,
{
int rc;
long secnum;
- int secmult;
/* With multivolume, use only the FAT info from the cached sector! */
#ifdef HAVE_MULTIVOLUME
- secmult = fce->fat_vol->secmult;
- secnum = (fce->secnum * secmult) + fce->fat_vol->startsector;
+ secnum = fce->secnum + fce->fat_vol->startsector;
#else
- secmult = fat_bpbs[0].secmult;
- secnum = (fce->secnum * secmult) + fat_bpbs[0].startsector;
+ secnum = fce->secnum + fat_bpbs[0].startsector;
#endif
/* Write to the first FAT */
rc = ata_write_sectors(IF_MV2(fce->fat_vol->drive,)
- secnum, secmult,
+ secnum, 1,
sectorbuf);
if(rc < 0)
{
@@ -593,12 +588,12 @@ static void flush_fat_sector(struct fat_cache_entry *fce,
{
/* Write to the second FAT */
#ifdef HAVE_MULTIVOLUME
- secnum += fce->fat_vol->fatsize * secmult;
+ secnum += fce->fat_vol->fatsize;
#else
- secnum += fat_bpbs[0].fatsize * secmult;
+ secnum += fat_bpbs[0].fatsize;
#endif
rc = ata_write_sectors(IF_MV2(fce->fat_vol->drive,)
- secnum, secmult, sectorbuf);
+ secnum, 1, sectorbuf);
if(rc < 0)
{
panicf("flush_fat_sector() - Could not write sector %ld"
@@ -644,8 +639,8 @@ static void *cache_fat_sector(IF_MV2(struct bpb* fat_bpb,)
if(!fce->inuse)
{
rc = ata_read_sectors(IF_MV2(fat_bpb->drive,)
- (secnum * fat_bpb->secmult) + fat_bpb->startsector,
- fat_bpb->secmult, sectorbuf);
+ secnum + fat_bpb->startsector,1,
+ sectorbuf);
if(rc < 0)
{
DEBUGF( "cache_fat_sector() - Could not read sector %ld"
@@ -821,10 +816,10 @@ static int update_fat_entry(IF_MV2(struct bpb* fat_bpb,) unsigned long entry, un
static long read_fat_entry(IF_MV2(struct bpb* fat_bpb,) unsigned long entry)
{
+#ifdef HAVE_FAT16SUPPORT
#ifndef HAVE_MULTIVOLUME
struct bpb* fat_bpb = &fat_bpbs[0];
#endif
-#ifdef HAVE_FAT16SUPPORT
if (fat_bpb->is_fat16)
{
int sector = entry / CLUSTERS_PER_FAT16_SECTOR;
@@ -888,7 +883,7 @@ static int update_fsinfo(IF_MV_NONVOID(struct bpb* fat_bpb))
#ifndef HAVE_MULTIVOLUME
struct bpb* fat_bpb = &fat_bpbs[0];
#endif
- unsigned char fsinfo[MAX_SECTOR_SIZE];
+ unsigned char fsinfo[SECTOR_SIZE];
unsigned long* intptr;
int rc;
@@ -899,8 +894,7 @@ static int update_fsinfo(IF_MV_NONVOID(struct bpb* fat_bpb))
/* update fsinfo */
rc = ata_read_sectors(IF_MV2(fat_bpb->drive,)
- fat_bpb->startsector +
- (fat_bpb->bpb_fsinfo * fat_bpb->secmult), 1, fsinfo);
+ fat_bpb->startsector + fat_bpb->bpb_fsinfo, 1,fsinfo);
if (rc < 0)
{
DEBUGF( "flush_fat() - Couldn't read FSInfo (error code %d)\n", rc);
@@ -913,8 +907,7 @@ static int update_fsinfo(IF_MV_NONVOID(struct bpb* fat_bpb))
*intptr = htole32(fat_bpb->fsinfo.nextfree);
rc = ata_write_sectors(IF_MV2(fat_bpb->drive,)
- fat_bpb->startsector +
- (fat_bpb->bpb_fsinfo * fat_bpb->secmult), 1, fsinfo);
+ fat_bpb->startsector + fat_bpb->bpb_fsinfo,1,fsinfo);
if (rc < 0)
{
DEBUGF( "flush_fat() - Couldn't write FSInfo (error code %d)\n", rc);
@@ -1050,12 +1043,7 @@ static int write_long_name(struct fat_file* file,
const unsigned char* shortname,
bool is_directory)
{
-#ifdef HAVE_MULTIVOLUME
- struct bpb *fat_bpb = &fat_bpbs[file->volume];
-#else
- struct bpb *fat_bpb = &fat_bpbs[0];
-#endif
- unsigned char buf[MAX_SECTOR_SIZE];
+ unsigned char buf[SECTOR_SIZE];
unsigned char* entry;
unsigned int idx = firstentry % DIR_ENTRIES_PER_SECTOR;
unsigned int sector = firstentry / DIR_ENTRIES_PER_SECTOR;
@@ -1213,7 +1201,7 @@ static int add_dir_entry(struct fat_dir* dir,
#else
struct bpb* fat_bpb = &fat_bpbs[0];
#endif
- unsigned char buf[MAX_SECTOR_SIZE];
+ unsigned char buf[SECTOR_SIZE];
unsigned char shortname[12];
int rc;
unsigned int sector;
@@ -1448,12 +1436,7 @@ static void randomize_dos_name(unsigned char *name)
static int update_short_entry( struct fat_file* file, long size, int attr )
{
-#ifdef HAVE_MULTIVOLUME
- struct bpb *fat_bpb = &fat_bpbs[file->volume];
-#else
- struct bpb *fat_bpb = &fat_bpbs[0];
-#endif
- unsigned char buf[MAX_SECTOR_SIZE];
+ unsigned char buf[SECTOR_SIZE];
int sector = file->direntry / DIR_ENTRIES_PER_SECTOR;
unsigned char* entry =
buf + DIR_ENTRY_SIZE * (file->direntry % DIR_ENTRIES_PER_SECTOR);
@@ -1618,7 +1601,7 @@ int fat_create_dir(const char* name,
#else
struct bpb* fat_bpb = &fat_bpbs[0];
#endif
- unsigned char buf[MAX_SECTOR_SIZE];
+ unsigned char buf[SECTOR_SIZE];
int i;
long sector;
int rc;
@@ -1740,10 +1723,10 @@ int fat_closewrite(struct fat_file *file, long size, int attr)
LDEBUGF("cluster %ld: %lx\n", count, next);
count++;
}
- len = count * fat_bpb->bpb_secperclus * fat_bpb->bpb_bytspersec;
+ len = count * fat_bpb->bpb_secperclus * SECTOR_SIZE;
LDEBUGF("File is %ld clusters (chainlen=%ld, size=%ld)\n",
count, len, size );
- if ( len > size + fat_bpb->bpb_secperclus * fat_bpb->bpb_bytspersec)
+ if ( len > size + fat_bpb->bpb_secperclus * SECTOR_SIZE)
panicf("Cluster chain is too long\n");
if ( len < size )
panicf("Cluster chain is too short\n");
@@ -1755,12 +1738,7 @@ int fat_closewrite(struct fat_file *file, long size, int attr)
static int free_direntries(struct fat_file* file)
{
-#ifdef HAVE_MULTIVOLUME
- struct bpb *fat_bpb = &fat_bpbs[file->volume];
-#else
- struct bpb *fat_bpb = &fat_bpbs[0];
-#endif
- unsigned char buf[MAX_SECTOR_SIZE];
+ unsigned char buf[SECTOR_SIZE];
struct fat_file dir;
int numentries = file->direntries;
unsigned int entry = file->direntry - numentries + 1;
@@ -1962,9 +1940,6 @@ static int transfer(IF_MV2(struct bpb* fat_bpb,)
struct bpb* fat_bpb = &fat_bpbs[0];
#endif
int rc;
-
- start *= fat_bpb->secmult;
- count *= fat_bpb->secmult;
LDEBUGF("transfer(s=%lx, c=%lx, %s)\n",
start+ fat_bpb->startsector, count, write?"write":"read");
@@ -1977,9 +1952,9 @@ static int transfer(IF_MV2(struct bpb* fat_bpb,)
#endif
firstallowed = fat_bpb->firstdatasector;
- if (start < (firstallowed * fat_bpb->secmult))
+ if (start < firstallowed)
panicf("Write %ld before data\n", firstallowed - start);
- if (start + count > (fat_bpb->totalsectors * fat_bpb->secmult))
+ if (start + count > fat_bpb->totalsectors)
panicf("Write %ld after data\n",
start + count - fat_bpb->totalsectors);
rc = ata_write_sectors(IF_MV2(fat_bpb->drive,)
@@ -2073,14 +2048,13 @@ long fat_readwrite( struct fat_file *file, long sectorcount,
first = sector;
if ( ((sector != first) && (sector != last+1)) || /* not sequential */
- (last-first+1 == (256 / fat_bpb->secmult)) ) {
- /* max 256 sectors per ata request */
+ (last-first+1 == 256) ) { /* max 256 sectors per ata request */
long count = last - first + 1;
rc = transfer(IF_MV2(fat_bpb,) first, count, buf, write );
if (rc < 0)
return rc * 10 - 1;
- buf = (char *)buf + count * fat_bpb->bpb_bytspersec;
+ buf = (char *)buf + count * SECTOR_SIZE;
first = sector;
}
@@ -2110,16 +2084,6 @@ long fat_readwrite( struct fat_file *file, long sectorcount,
return i;
}
-int fat_get_secsize(const struct fat_file *file)
-{
-#ifdef HAVE_MULTIVOLUME
- return fat_bpbs[file->volume].bpb_bytspersec;
-#else
- (void)file;
- return fat_bpbs[0].bpb_bytspersec;
-#endif
-}
-
int fat_seek(struct fat_file *file, unsigned long seeksector )
{
#ifdef HAVE_MULTIVOLUME
@@ -2239,11 +2203,6 @@ static int fat_copy_long_name_segment(unsigned char *utf16src,
int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
{
-#ifdef HAVE_MULTIVOLUME
- struct bpb* fat_bpb = &fat_bpbs[dir->file.volume];
-#else
- struct bpb* fat_bpb = &fat_bpbs[0];
-#endif
bool done = false;
int i;
int rc;
@@ -2277,7 +2236,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
}
for (i = dir->entry % DIR_ENTRIES_PER_SECTOR;
- i < (int)DIR_ENTRIES_PER_SECTOR; i++)
+ i < DIR_ENTRIES_PER_SECTOR; i++)
{
unsigned int entrypos = i * DIR_ENTRY_SIZE;
@@ -2331,20 +2290,20 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
unsigned char* ptr = cached_buf;
int index = longarray[j];
/* current or cached sector? */
- if ( sectoridx >= fat_bpb->bpb_bytspersec ) {
- if ( sectoridx >= fat_bpb->bpb_bytspersec*2 ) {
- if ( ( index >= fat_bpb->bpb_bytspersec ) &&
- ( index < fat_bpb->bpb_bytspersec*2 ))
+ if ( sectoridx >= SECTOR_SIZE ) {
+ if ( sectoridx >= SECTOR_SIZE*2 ) {
+ if ( ( index >= SECTOR_SIZE ) &&
+ ( index < SECTOR_SIZE*2 ))
ptr = dir->sectorcache[1];
else
ptr = dir->sectorcache[2];
}
else {
- if ( index < fat_bpb->bpb_bytspersec )
+ if ( index < SECTOR_SIZE )
ptr = dir->sectorcache[1];
}
- index &= fat_bpb->bpb_bytspersec-1;
+ index &= SECTOR_SIZE-1;
}
/* Try to append each segment of the long name. Check if we'd
@@ -2404,10 +2363,10 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry)
/* save this sector, for longname use */
if ( sectoridx )
- memcpy( dir->sectorcache[2], dir->sectorcache[0], fat_bpb->bpb_bytspersec );
+ memcpy( dir->sectorcache[2], dir->sectorcache[0], SECTOR_SIZE );
else
- memcpy( dir->sectorcache[1], dir->sectorcache[0], fat_bpb->bpb_bytspersec );
- sectoridx += fat_bpb->bpb_bytspersec;
+ memcpy( dir->sectorcache[1], dir->sectorcache[0], SECTOR_SIZE );
+ sectoridx += SECTOR_SIZE;
}
return 0;
@@ -2419,7 +2378,7 @@ unsigned int fat_get_cluster_size(IF_MV_NONVOID(int volume))
const int volume = 0;
#endif
struct bpb* fat_bpb = &fat_bpbs[volume];
- return fat_bpb->bpb_secperclus * fat_bpb->bpb_bytspersec;
+ return fat_bpb->bpb_secperclus * SECTOR_SIZE;
}
#ifdef HAVE_MULTIVOLUME
diff --git a/firmware/export/config-ipodvideo.h b/firmware/export/config-ipodvideo.h
index 0caa2f2421..b2b56158f3 100644
--- a/firmware/export/config-ipodvideo.h
+++ b/firmware/export/config-ipodvideo.h
@@ -121,6 +121,10 @@
/* Define this if you can read an absolute wheel position */
#define HAVE_WHEEL_POSITION
+/* define this if the device has larger sectors when accessed via USB */
+/* (only relevant in disk.c, fat.c now always supports large virtual sectors) */
+#define MAX_SECTOR_SIZE 2048
+
#define BOOTFILE_EXT "ipod"
#define BOOTFILE "rockbox." BOOTFILE_EXT
diff --git a/firmware/export/fat.h b/firmware/export/fat.h
index 4110f765a3..2680fdf751 100644
--- a/firmware/export/fat.h
+++ b/firmware/export/fat.h
@@ -24,14 +24,7 @@
#include "ata.h" /* for volume definitions */
#include "config.h"
-#define PHYSICAL_SECTOR_SIZE 512
-
-/* Some never players (such as iPod 5.5G) might have 2048 bytes per sector. */
-#ifdef IPOD_VIDEO
-#define MAX_SECTOR_SIZE 2048
-#else
-#define MAX_SECTOR_SIZE 512
-#endif
+#define SECTOR_SIZE 512
/* Number of bytes reserved for a file name (including the trailing \0).
Since names are stored in the entry as UTF-8, we won't be able to
@@ -86,7 +79,7 @@ struct fat_dir
unsigned int entrycount;
long sector;
struct fat_file file;
- unsigned char sectorcache[3][MAX_SECTOR_SIZE];
+ unsigned char sectorcache[3][SECTOR_SIZE];
};
@@ -109,7 +102,6 @@ extern int fat_create_file(const char* name,
extern long fat_readwrite(struct fat_file *ent, long sectorcount,
void* buf, bool write );
extern int fat_closewrite(struct fat_file *ent, long size, int attr);
-extern int fat_get_secsize(const struct fat_file *file);
extern int fat_seek(struct fat_file *ent, unsigned long sector );
extern int fat_remove(struct fat_file *ent);
extern int fat_truncate(const struct fat_file *ent);