minix/u-boot
1
0
Fork 0
mirror of https://github.com/Stichting-MINIX-Research-Foundation/u-boot.git synced 2025-09-16 07:27:09 -04:00
Code Issues Packages Projects Releases Wiki Activity

fs/fat: Big code cleanup.

Browse Source 
- reformat
- throw out macros like FAT_DPRINT and FAT_DPRINT
- remove dead code

Signed-off-by: Wolfgang Denk <wd@denx.de>
This commit is contained in:
Wolfgang Denk 2010-07-19 11:37:00 +02:00
parent 226fa9bb9e
commit 7385c28e9b
4 changed files with 694 additions and 752 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
common/cmd_fat.c
View File

@ -45,9 +45,11 @@ int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
char *ep; char *ep;
if (argc < 5) { if (argc < 5) {
printf ("usage: fatload <interface> <dev[:part]> <addr> <filename> [bytes]\n"); printf( "usage: fatload <interface> <dev[:part]> "
"<addr> <filename> [bytes]\n");
return 1; return 1;
} }
dev = (int)simple_strtoul(argv[2], &ep, 16); dev = (int)simple_strtoul(argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev); dev_desc = get_dev(argv[1],dev);
if (dev_desc == NULL) { if (dev_desc == NULL) {
@ -62,7 +64,8 @@ int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
part = (int)simple_strtoul(++ep, NULL, 16); part = (int)simple_strtoul(++ep, NULL, 16);
} }
if (fat_register_device(dev_desc,part)!=0) { if (fat_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for fatload **\n",argv[1],dev,part); printf("\n** Unable to use %s %d:%d for fatload **\n",
argv[1], dev, part);
return 1; return 1;
} }
offset = simple_strtoul(argv[3], NULL, 16); offset = simple_strtoul(argv[3], NULL, 16);
@ -73,7 +76,8 @@ int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
size = file_fat_read(argv[4], (unsigned char *)offset, count); size = file_fat_read(argv[4], (unsigned char *)offset, count);
if(size==-1) { if(size==-1) {
printf("\n** Unable to read \"%s\" from %s %d:%d **\n",argv[4],argv[1],dev,part); printf("\n** Unable to read \"%s\" from %s %d:%d **\n",
argv[4], argv[1], dev, part);
return 1; return 1;
} }
@ -105,7 +109,7 @@ int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (argc < 3) { if (argc < 3) {
printf("usage: fatls <interface> <dev[:part]> [directory]\n"); printf("usage: fatls <interface> <dev[:part]> [directory]\n");
return (0); return 0;
} }
dev = (int)simple_strtoul(argv[2], &ep, 16); dev = (int)simple_strtoul(argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev); dev_desc = get_dev(argv[1],dev);
@ -121,7 +125,8 @@ int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
part = (int)simple_strtoul(++ep, NULL, 16); part = (int)simple_strtoul(++ep, NULL, 16);
} }
if (fat_register_device(dev_desc,part)!=0) { if (fat_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for fatls **\n",argv[1],dev,part); printf("\n** Unable to use %s %d:%d for fatls **\n",
argv[1], dev, part);
return 1; return 1;
} }
if (argc == 4) if (argc == 4)
@ -131,7 +136,7 @@ int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if(ret!=0) if(ret!=0)
printf("No Fat FS detected\n"); printf("No Fat FS detected\n");
return (ret); return ret;
} }
U_BOOT_CMD( U_BOOT_CMD(
@ -150,7 +155,7 @@ int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (argc < 2) { if (argc < 2) {
printf("usage: fatinfo <interface> <dev[:part]>\n"); printf("usage: fatinfo <interface> <dev[:part]>\n");
return (0); return 0;
} }
dev = (int)simple_strtoul(argv[2], &ep, 16); dev = (int)simple_strtoul(argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev); dev_desc = get_dev(argv[1],dev);
@ -166,10 +171,11 @@ int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
part = (int)simple_strtoul(++ep, NULL, 16); part = (int)simple_strtoul(++ep, NULL, 16);
} }
if (fat_register_device(dev_desc,part)!=0) { if (fat_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for fatinfo **\n",argv[1],dev,part); printf("\n** Unable to use %s %d:%d for fatinfo **\n",
argv[1], dev, part);
return 1; return 1;
} }
return (file_fat_detectfs ()); return file_fat_detectfs();
} }
U_BOOT_CMD( U_BOOT_CMD(
@ -178,143 +184,3 @@ U_BOOT_CMD(
"<interface> <dev[:part]>\n" "<interface> <dev[:part]>\n"
" - print information about filesystem from 'dev' on 'interface'" " - print information about filesystem from 'dev' on 'interface'"
); );
#ifdef NOT_IMPLEMENTED_YET
/* find first device whose first partition is a DOS filesystem */
int find_fat_partition (void)
{
int i, j;
block_dev_desc_t *dev_desc;
unsigned char *part_table;
unsigned char buffer[ATA_BLOCKSIZE];
for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; i++) {
dev_desc = ide_get_dev (i);
if (!dev_desc) {
debug ("couldn't get ide device!\n");
return (-1);
}
if (dev_desc->part_type == PART_TYPE_DOS) {
if (dev_desc->
block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) {
debug ("can't perform block_read!\n");
return (-1);
}
part_table = &buffer[0x1be]; /* start with partition #4 */
for (j = 0; j < 4; j++) {
if ((part_table[4] == 1 || /* 12-bit FAT */
part_table[4] == 4 || /* 16-bit FAT */
part_table[4] == 6) && /* > 32Meg part */
part_table[0] == 0x80) { /* bootable? */
curr_dev = i;
part_offset = part_table[11];
part_offset <<= 8;
part_offset |= part_table[10];
part_offset <<= 8;
part_offset |= part_table[9];
part_offset <<= 8;
part_offset |= part_table[8];
debug ("found partition start at %ld\n", part_offset);
return (0);
}
part_table += 16;
}
}
}
debug ("no valid devices found!\n");
return (-1);
}
int
do_fat_dump (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char * const argv[])
{
__u8 block[1024];
int ret;
int bknum;
ret = 0;
if (argc != 2) {
printf ("needs an argument!\n");
return (0);
}
bknum = simple_strtoul (argv[1], NULL, 10);
if (disk_read (0, bknum, block) != 0) {
printf ("Error: reading block\n");
return -1;
}
printf ("FAT dump: %d\n", bknum);
hexdump (512, block);
return (ret);
}
int disk_read (__u32 startblock, __u32 getsize, __u8 *bufptr)
{
ulong tot;
block_dev_desc_t *dev_desc;
if (curr_dev < 0) {
if (find_fat_partition () != 0)
return (-1);
}
dev_desc = ide_get_dev (curr_dev);
if (!dev_desc) {
debug ("couldn't get ide device\n");
return (-1);
}
tot = dev_desc->block_read (0, startblock + part_offset,
getsize, (ulong *) bufptr);
/* should we do this here?
flush_cache ((ulong)buf, cnt*ide_dev_desc[device].blksz);
*/
if (tot == getsize)
return (0);
debug ("unable to read from device!\n");
return (-1);
}
static int isprint (unsigned char ch)
{
if (ch >= 32 && ch < 127)
return (1);
return (0);
}
void hexdump (int cnt, unsigned char *data)
{
int i;
int run;
int offset;
offset = 0;
while (cnt) {
printf ("%04X : ", offset);
if (cnt >= 16)
run = 16;
else
run = cnt;
cnt -= run;
for (i = 0; i < run; i++)
printf ("%02X ", (unsigned int) data[i]);
printf (": ");
for (i = 0; i < run; i++)
printf ("%c", isprint (data[i]) ? data[i] : '.');
printf ("\n");
data = &data[16];
offset += run;
}
}
#endif /* NOT_IMPLEMENTED_YET */

409
fs/fat/fat.c
View File

@ -34,8 +34,7 @@
/* /*
* Convert a string to lowercase. * Convert a string to lowercase.
*/ */
static void static void downcase (char *str)
downcase(char *str)
{ {
while (*str != '\0') { while (*str != '\0') {
TOLOWER(*str); TOLOWER(*str);
@ -44,7 +43,9 @@ downcase(char *str)
} }
static block_dev_desc_t *cur_dev = NULL; static block_dev_desc_t *cur_dev = NULL;
static unsigned long part_offset = 0; static unsigned long part_offset = 0;
static int cur_part = 1; static int cur_part = 1;
#define DOS_PART_TBL_OFFSET 0x1be #define DOS_PART_TBL_OFFSET 0x1be
@ -52,31 +53,34 @@ static int cur_part = 1;
#define DOS_FS_TYPE_OFFSET 0x36 #define DOS_FS_TYPE_OFFSET 0x36
#define DOS_FS32_TYPE_OFFSET 0x52 #define DOS_FS32_TYPE_OFFSET 0x52
int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr) static int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr)
{ {
startblock += part_offset;
if (cur_dev == NULL) if (cur_dev == NULL)
return -1; return -1;
startblock += part_offset;
if (cur_dev->block_read) { if (cur_dev->block_read) {
return cur_dev->block_read (cur_dev->dev return cur_dev->block_read(cur_dev->dev, startblock, getsize,
, startblock, getsize, (unsigned long *)bufptr); (unsigned long *) bufptr);
} }
return -1; return -1;
} }
int fat_register_device (block_dev_desc_t * dev_desc, int part_no)
int
fat_register_device(block_dev_desc_t *dev_desc, int part_no)
{ {
unsigned char buffer[SECTOR_SIZE]; unsigned char buffer[SECTOR_SIZE];
disk_partition_t info; disk_partition_t info;
if (!dev_desc->block_read) if (!dev_desc->block_read)
return -1; return -1;
cur_dev = dev_desc; cur_dev = dev_desc;
/* check if we have a MBR (on floppies we have only a PBR) */ /* check if we have a MBR (on floppies we have only a PBR) */
if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)buffer) != 1) { if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)buffer) != 1) {
printf ("** Can't read from device %d **\n", dev_desc->dev); printf("** Can't read from device %d **\n",
dev_desc->dev);
return -1; return -1;
} }
if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
@ -91,12 +95,12 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no)
defined(CONFIG_CMD_USB) || \ defined(CONFIG_CMD_USB) || \
defined(CONFIG_MMC) || \ defined(CONFIG_MMC) || \
defined(CONFIG_SYSTEMACE) ) defined(CONFIG_SYSTEMACE) )
/* First we assume, there is a MBR */ /* First we assume there is a MBR */
if (!get_partition_info(dev_desc, part_no, &info)) { if (!get_partition_info(dev_desc, part_no, &info)) {
part_offset = info.start; part_offset = info.start;
cur_part = part_no; cur_part = part_no;
} else if (strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3)==0 || } else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3) == 0) ||
strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET],"FAT32",5)==0) { (strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET], "FAT32", 5) == 0)) {
/* ok, we assume we are on a PBR only */ /* ok, we assume we are on a PBR only */
cur_part = 1; cur_part = 1;
part_offset = 0; part_offset = 0;
@ -126,18 +130,17 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no)
return 0; return 0;
} }
/* /*
* Get the first occurence of a directory delimiter ('/' or '\') in a string. * Get the first occurence of a directory delimiter ('/' or '\') in a string.
* Return index into string if found, -1 otherwise. * Return index into string if found, -1 otherwise.
*/ */
static int static int dirdelim (char *str)
dirdelim(char *str)
{ {
char *start = str; char *start = str;
while (*str != '\0') { while (*str != '\0') {
if (ISDIRDELIM(*str)) return str - start; if (ISDIRDELIM(*str))
return str - start;
str++; str++;
} }
return -1; return -1;
@ -175,12 +178,12 @@ static void get_name (dir_entry *dirent, char *s_name)
* Get the entry at index 'entry' in a FAT (12/16/32) table. * Get the entry at index 'entry' in a FAT (12/16/32) table.
* On failure 0x00 is returned. * On failure 0x00 is returned.
*/ */
static __u32 static __u32 get_fatent (fsdata *mydata, __u32 entry)
get_fatent(fsdata *mydata, __u32 entry)
{ {
__u32 bufnum; __u32 bufnum;
__u32 offset; __u32 off16, offset;
__u32 ret = 0x00; __u32 ret = 0x00;
__u16 val1, val2;
switch (mydata->fatsize) { switch (mydata->fatsize) {
case 32: case 32:
@ -201,7 +204,7 @@ get_fatent(fsdata *mydata, __u32 entry)
return ret; return ret;
} }
FAT_DPRINT("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n", debug("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n",
mydata->fatsize, entry, entry, offset, offset); mydata->fatsize, entry, entry, offset, offset);
/* Read a new block of FAT entries into the cache. */ /* Read a new block of FAT entries into the cache. */
@ -214,9 +217,10 @@ get_fatent(fsdata *mydata, __u32 entry)
fatlength *= SECTOR_SIZE; /* We want it in bytes now */ fatlength *= SECTOR_SIZE; /* We want it in bytes now */
startblock += mydata->fat_sect; /* Offset from start of disk */ startblock += mydata->fat_sect; /* Offset from start of disk */
if (getsize > fatlength) getsize = fatlength; if (getsize > fatlength)
getsize = fatlength;
if (disk_read(startblock, getsize, bufptr) < 0) { if (disk_read(startblock, getsize, bufptr) < 0) {
FAT_DPRINT("Error reading FAT blocks\n"); debug("Error reading FAT blocks\n");
return ret; return ret;
} }
mydata->fatbufnum = bufnum; mydata->fatbufnum = bufnum;
@ -230,9 +234,8 @@ get_fatent(fsdata *mydata, __u32 entry)
case 16: case 16:
ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]); ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);
break; break;
case 12: { case 12:
__u32 off16 = (offset*3)/4; off16 = (offset * 3) / 4;
__u16 val1, val2;
switch (offset & 0x3) { switch (offset & 0x3) {
case 0: case 0:
@ -254,48 +257,50 @@ get_fatent(fsdata *mydata, __u32 entry)
ret = (val2 << 8) | (val1 >> 8); ret = (val2 << 8) | (val1 >> 8);
break; break;
case 3: case 3:
ret = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);; ret = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
ret = (ret & 0xfff0) >> 4; ret = (ret & 0xfff0) >> 4;
break; break;
default: default:
break; break;
} }
}
break; break;
} }
FAT_DPRINT("FAT%d: ret: %08x, offset: %04x\n", debug("FAT%d: ret: %08x, offset: %04x\n",
mydata->fatsize, ret, offset); mydata->fatsize, ret, offset);
return ret; return ret;
} }
/* /*
* Read at most 'size' bytes from the specified cluster into 'buffer'. * Read at most 'size' bytes from the specified cluster into 'buffer'.
* Return 0 on success, -1 otherwise. * Return 0 on success, -1 otherwise.
*/ */
static int static int
get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size) get_cluster (fsdata *mydata, __u32 clustnum, __u8 *buffer,
unsigned long size)
{ {
int idx = 0; int idx = 0;
__u32 startsect; __u32 startsect;
if (clustnum > 0) { if (clustnum > 0) {
startsect = mydata->data_begin + clustnum*mydata->clust_size; startsect = mydata->data_begin +
clustnum * mydata->clust_size;
} else { } else {
startsect = mydata->rootdir_sect; startsect = mydata->rootdir_sect;
} }
FAT_DPRINT("gc - clustnum: %d, startsect: %d\n", clustnum, startsect); debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect);
if (disk_read(startsect, size / FS_BLOCK_SIZE, buffer) < 0) { if (disk_read(startsect, size / FS_BLOCK_SIZE, buffer) < 0) {
FAT_DPRINT("Error reading data\n"); debug("Error reading data\n");
return -1; return -1;
} }
if (size % FS_BLOCK_SIZE) { if (size % FS_BLOCK_SIZE) {
__u8 tmpbuf[FS_BLOCK_SIZE]; __u8 tmpbuf[FS_BLOCK_SIZE];
idx = size / FS_BLOCK_SIZE; idx = size / FS_BLOCK_SIZE;
if (disk_read(startsect + idx, 1, tmpbuf) < 0) { if (disk_read(startsect + idx, 1, tmpbuf) < 0) {
FAT_DPRINT("Error reading data\n"); debug("Error reading data\n");
return -1; return -1;
} }
buffer += idx * FS_BLOCK_SIZE; buffer += idx * FS_BLOCK_SIZE;
@ -307,7 +312,6 @@ get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size)
return 0; return 0;
} }
/* /*
* Read at most 'maxsize' bytes from the file associated with 'dentptr' * Read at most 'maxsize' bytes from the file associated with 'dentptr'
* into 'buffer'. * into 'buffer'.
@ -323,14 +327,16 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
__u32 endclust, newclust; __u32 endclust, newclust;
unsigned long actsize; unsigned long actsize;
FAT_DPRINT("Filesize: %ld bytes\n", filesize); debug("Filesize: %ld bytes\n", filesize);
if (maxsize > 0 && filesize > maxsize) filesize = maxsize; if (maxsize > 0 && filesize > maxsize)
filesize = maxsize;
FAT_DPRINT("%ld bytes\n", filesize); debug("%ld bytes\n", filesize);
actsize = bytesperclust; actsize = bytesperclust;
endclust = curclust; endclust = curclust;
do { do {
/* search for consecutive clusters */ /* search for consecutive clusters */
while (actsize < filesize) { while (actsize < filesize) {
@ -338,43 +344,47 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
if ((newclust - 1) != endclust) if ((newclust - 1) != endclust)
goto getit; goto getit;
if (CHECK_CLUST(newclust, mydata->fatsize)) { if (CHECK_CLUST(newclust, mydata->fatsize)) {
FAT_DPRINT("curclust: 0x%x\n", newclust); debug("curclust: 0x%x\n", newclust);
FAT_DPRINT("Invalid FAT entry\n"); debug("Invalid FAT entry\n");
return gotsize; return gotsize;
} }
endclust = newclust; endclust = newclust;
actsize += bytesperclust; actsize += bytesperclust;
} }
/* actsize >= file size */ /* actsize >= file size */
actsize -= bytesperclust; actsize -= bytesperclust;
/* get remaining clusters */ /* get remaining clusters */
if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
FAT_ERROR("Error reading cluster\n"); printf("Error reading cluster\n");
return -1; return -1;
} }
/* get remaining bytes */ /* get remaining bytes */
gotsize += (int)actsize; gotsize += (int)actsize;
filesize -= actsize; filesize -= actsize;
buffer += actsize; buffer += actsize;
actsize = filesize; actsize = filesize;
if (get_cluster(mydata, endclust, buffer, (int)actsize) != 0) { if (get_cluster(mydata, endclust, buffer, (int)actsize) != 0) {
FAT_ERROR("Error reading cluster\n"); printf("Error reading cluster\n");
return -1; return -1;
} }
gotsize += actsize; gotsize += actsize;
return gotsize; return gotsize;
getit: getit:
if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
FAT_ERROR("Error reading cluster\n"); printf("Error reading cluster\n");
return -1; return -1;
} }
gotsize += (int)actsize; gotsize += (int)actsize;
filesize -= actsize; filesize -= actsize;
buffer += actsize; buffer += actsize;
curclust = get_fatent(mydata, endclust); curclust = get_fatent(mydata, endclust);
if (CHECK_CLUST(curclust, mydata->fatsize)) { if (CHECK_CLUST(curclust, mydata->fatsize)) {
FAT_DPRINT("curclust: 0x%x\n", curclust); debug("curclust: 0x%x\n", curclust);
FAT_ERROR("Invalid FAT entry\n"); printf("Invalid FAT entry\n");
return gotsize; return gotsize;
} }
actsize = bytesperclust; actsize = bytesperclust;
@ -382,38 +392,38 @@ getit:
} while (1); } while (1);
} }
#ifdef CONFIG_SUPPORT_VFAT #ifdef CONFIG_SUPPORT_VFAT
/* /*
* Extract the file name information from 'slotptr' into 'l_name', * Extract the file name information from 'slotptr' into 'l_name',
* starting at l_name[*idx]. * starting at l_name[*idx].
* Return 1 if terminator (zero byte) is found, 0 otherwise. * Return 1 if terminator (zero byte) is found, 0 otherwise.
*/ */
static int static int slot2str (dir_slot *slotptr, char *l_name, int *idx)
slot2str(dir_slot *slotptr, char *l_name, int *idx)
{ {
int j; int j;
for (j = 0; j <= 8; j += 2) { for (j = 0; j <= 8; j += 2) {
l_name[*idx] = slotptr->name0_4[j]; l_name[*idx] = slotptr->name0_4[j];
if (l_name[*idx] == 0x00) return 1; if (l_name[*idx] == 0x00)
return 1;
(*idx)++; (*idx)++;
} }
for (j = 0; j <= 10; j += 2) { for (j = 0; j <= 10; j += 2) {
l_name[*idx] = slotptr->name5_10[j]; l_name[*idx] = slotptr->name5_10[j];
if (l_name[*idx] == 0x00) return 1; if (l_name[*idx] == 0x00)
return 1;
(*idx)++; (*idx)++;
} }
for (j = 0; j <= 2; j += 2) { for (j = 0; j <= 2; j += 2) {
l_name[*idx] = slotptr->name11_12[j]; l_name[*idx] = slotptr->name11_12[j];
if (l_name[*idx] == 0x00) return 1; if (l_name[*idx] == 0x00)
return 1;
(*idx)++; (*idx)++;
} }
return 0; return 0;
} }
/* /*
* Extract the full long filename starting at 'retdent' (which is really * Extract the full long filename starting at 'retdent' (which is really
* a slot) into 'l_name'. If successful also copy the real directory entry * a slot) into 'l_name'. If successful also copy the real directory entry
@ -422,6 +432,7 @@ slot2str(dir_slot *slotptr, char *l_name, int *idx)
*/ */
__attribute__ ((__aligned__ (__alignof__ (dir_entry)))) __attribute__ ((__aligned__ (__alignof__ (dir_entry))))
__u8 get_vfatname_block[MAX_CLUSTSIZE]; __u8 get_vfatname_block[MAX_CLUSTSIZE];
static int static int
get_vfatname (fsdata *mydata, int curclust, __u8 *cluster, get_vfatname (fsdata *mydata, int curclust, __u8 *cluster,
dir_entry *retdent, char *l_name) dir_entry *retdent, char *l_name)
@ -433,7 +444,8 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
int idx = 0; int idx = 0;
while ((__u8 *)slotptr < nextclust) { while ((__u8 *)slotptr < nextclust) {
if (counter == 0) break; if (counter == 0)
break;
if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter) if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
return -1; return -1;
slotptr++; slotptr++;
@ -446,19 +458,21 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
slotptr--; slotptr--;
curclust = get_fatent(mydata, curclust); curclust = get_fatent(mydata, curclust);
if (CHECK_CLUST(curclust, mydata->fatsize)) { if (CHECK_CLUST(curclust, mydata->fatsize)) {
FAT_DPRINT("curclust: 0x%x\n", curclust); debug("curclust: 0x%x\n", curclust);
FAT_ERROR("Invalid FAT entry\n"); printf("Invalid FAT entry\n");
return -1; return -1;
} }
if (get_cluster(mydata, curclust, get_vfatname_block, if (get_cluster(mydata, curclust, get_vfatname_block,
mydata->clust_size * SECTOR_SIZE) != 0) { mydata->clust_size * SECTOR_SIZE) != 0) {
FAT_DPRINT("Error: reading directory block\n"); debug("Error: reading directory block\n");
return -1; return -1;
} }
slotptr2 = (dir_slot *)get_vfatname_block; slotptr2 = (dir_slot *)get_vfatname_block;
while (slotptr2->id > 0x01) { while (slotptr2->id > 0x01)
slotptr2++; slotptr2++;
}
/* Save the real directory entry */ /* Save the real directory entry */
realdent = (dir_entry *)slotptr2 + 1; realdent = (dir_entry *)slotptr2 + 1;
while ((__u8 *)slotptr2 >= get_vfatname_block) { while ((__u8 *)slotptr2 >= get_vfatname_block) {
@ -472,12 +486,15 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
do { do {
slotptr--; slotptr--;
if (slot2str(slotptr, l_name, &idx)) break; if (slot2str(slotptr, l_name, &idx))
break;
} while (!(slotptr->id & LAST_LONG_ENTRY_MASK)); } while (!(slotptr->id & LAST_LONG_ENTRY_MASK));
l_name[idx] = '\0'; l_name[idx] = '\0';
if (*l_name == DELETED_FLAG) *l_name = '\0'; if (*l_name == DELETED_FLAG)
else if (*l_name == aRING) *l_name = DELETED_FLAG; *l_name = '\0';
else if (*l_name == aRING)
*l_name = DELETED_FLAG;
downcase(l_name); downcase(l_name);
/* Return the real directory entry */ /* Return the real directory entry */
@ -486,12 +503,11 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
return 0; return 0;
} }
/* Calculate short name checksum */ /* Calculate short name checksum */
static __u8 static __u8 mkcksum (const char *str)
mkcksum(const char *str)
{ {
int i; int i;
__u8 ret = 0; __u8 ret = 0;
for (i = 0; i < 11; i++) { for (i = 0; i < 11; i++) {
@ -500,8 +516,7 @@ mkcksum(const char *str)
return ret; return ret;
} }
#endif #endif /* CONFIG_SUPPORT_VFAT */
/* /*
* Get the directory entry associated with 'filename' from the directory * Get the directory entry associated with 'filename' from the directory
@ -509,6 +524,7 @@ mkcksum(const char *str)
*/ */
__attribute__ ((__aligned__ (__alignof__ (dir_entry)))) __attribute__ ((__aligned__ (__alignof__ (dir_entry))))
__u8 get_dentfromdir_block[MAX_CLUSTSIZE]; __u8 get_dentfromdir_block[MAX_CLUSTSIZE];
static dir_entry *get_dentfromdir (fsdata *mydata, int startsect, static dir_entry *get_dentfromdir (fsdata *mydata, int startsect,
char *filename, dir_entry *retdent, char *filename, dir_entry *retdent,
int dols) int dols)
@ -517,17 +533,21 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
__u32 curclust = START(retdent); __u32 curclust = START(retdent);
int files = 0, dirs = 0; int files = 0, dirs = 0;
FAT_DPRINT ("get_dentfromdir: %s\n", filename); debug("get_dentfromdir: %s\n", filename);
while (1) { while (1) {
dir_entry *dentptr; dir_entry *dentptr;
int i; int i;
if (get_cluster(mydata, curclust, get_dentfromdir_block, if (get_cluster(mydata, curclust, get_dentfromdir_block,
mydata->clust_size * SECTOR_SIZE) != 0) { mydata->clust_size * SECTOR_SIZE) != 0) {
FAT_DPRINT ("Error: reading directory block\n"); debug("Error: reading directory block\n");
return NULL; return NULL;
} }
dentptr = (dir_entry *)get_dentfromdir_block; dentptr = (dir_entry *)get_dentfromdir_block;
for (i = 0; i < DIRENTSPERCLUST; i++) { for (i = 0; i < DIRENTSPERCLUST; i++) {
char s_name[14], l_name[256]; char s_name[14], l_name[256];
@ -540,15 +560,17 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
#ifdef CONFIG_SUPPORT_VFAT #ifdef CONFIG_SUPPORT_VFAT
if ((dentptr->attr & ATTR_VFAT) && if ((dentptr->attr & ATTR_VFAT) &&
(dentptr-> name[0] & LAST_LONG_ENTRY_MASK)) { (dentptr-> name[0] & LAST_LONG_ENTRY_MASK)) {
prevcksum = ((dir_slot *) dentptr) prevcksum = ((dir_slot *)dentptr)->alias_checksum;
->alias_checksum; get_vfatname(mydata, curclust,
get_vfatname (mydata, curclust, get_dentfromdir_block, get_dentfromdir_block,
dentptr, l_name); dentptr, l_name);
if (dols) { if (dols) {
int isdir = (dentptr->attr & ATTR_DIR); int isdir;
char dirc; char dirc;
int doit = 0; int doit = 0;
isdir = (dentptr->attr & ATTR_DIR);
if (isdir) { if (isdir) {
dirs++; dirs++;
dirc = '/'; dirc = '/';
@ -564,15 +586,18 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
if (dirc == ' ') { if (dirc == ' ') {
printf(" %8ld %s%c\n", printf(" %8ld %s%c\n",
(long)FAT2CPU32(dentptr->size), (long)FAT2CPU32(dentptr->size),
l_name, dirc); l_name,
dirc);
} else { } else {
printf (" %s%c\n", l_name, dirc); printf(" %s%c\n",
l_name,
dirc);
} }
} }
dentptr++; dentptr++;
continue; continue;
} }
FAT_DPRINT ("vfatname: |%s|\n", l_name); debug("vfatname: |%s|\n", l_name);
} else } else
#endif #endif
{ {
@ -583,9 +608,10 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
} }
if (dentptr->name[0] == 0) { if (dentptr->name[0] == 0) {
if (dols) { if (dols) {
printf ("\n%d file(s), %d dir(s)\n\n", files, dirs); printf("\n%d file(s), %d dir(s)\n\n",
files, dirs);
} }
FAT_DPRINT ("Dentname == NULL - %d\n", i); debug("Dentname == NULL - %d\n", i);
return NULL; return NULL;
} }
#ifdef CONFIG_SUPPORT_VFAT #ifdef CONFIG_SUPPORT_VFAT
@ -611,37 +637,44 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
doit = 1; doit = 1;
} }
} }
if (doit) { if (doit) {
if (dirc == ' ') { if (dirc == ' ') {
printf(" %8ld %s%c\n", printf(" %8ld %s%c\n",
(long) FAT2CPU32 (dentptr->size), s_name, (long)FAT2CPU32(dentptr->size),
dirc); s_name, dirc);
} else { } else {
printf (" %s%c\n", s_name, dirc); printf(" %s%c\n",
s_name, dirc);
} }
} }
dentptr++; dentptr++;
continue; continue;
} }
if (strcmp (filename, s_name) && strcmp (filename, l_name)) {
FAT_DPRINT ("Mismatch: |%s|%s|\n", s_name, l_name); if (strcmp(filename, s_name)
&& strcmp(filename, l_name)) {
debug("Mismatch: |%s|%s|\n", s_name, l_name);
dentptr++; dentptr++;
continue; continue;
} }
memcpy(retdent, dentptr, sizeof(dir_entry)); memcpy(retdent, dentptr, sizeof(dir_entry));
FAT_DPRINT ("DentName: %s", s_name); debug("DentName: %s", s_name);
FAT_DPRINT (", start: 0x%x", START (dentptr)); debug(", start: 0x%x", START(dentptr));
FAT_DPRINT (", size: 0x%x %s\n", debug(", size: 0x%x %s\n",
FAT2CPU32(dentptr->size), FAT2CPU32(dentptr->size),
(dentptr->attr & ATTR_DIR) ? "(DIR)" : ""); (dentptr->attr & ATTR_DIR) ? "(DIR)" : "");
return retdent; return retdent;
} }
curclust = get_fatent(mydata, curclust); curclust = get_fatent(mydata, curclust);
if (CHECK_CLUST(curclust, mydata->fatsize)) { if (CHECK_CLUST(curclust, mydata->fatsize)) {
FAT_DPRINT ("curclust: 0x%x\n", curclust); debug("curclust: 0x%x\n", curclust);
FAT_ERROR ("Invalid FAT entry\n"); printf("Invalid FAT entry\n");
return NULL; return NULL;
} }
} }
@ -649,7 +682,6 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
return NULL; return NULL;
} }
/* /*
* Read boot sector and volume info from a FAT filesystem * Read boot sector and volume info from a FAT filesystem
*/ */
@ -657,10 +689,11 @@ static int
read_bootsectandvi (boot_sector *bs, volume_info *volinfo, int *fatsize) read_bootsectandvi (boot_sector *bs, volume_info *volinfo, int *fatsize)
{ {
__u8 block[FS_BLOCK_SIZE]; __u8 block[FS_BLOCK_SIZE];
volume_info *vistart; volume_info *vistart;
if (disk_read (0, 1, block) < 0) { if (disk_read (0, 1, block) < 0) {
FAT_DPRINT("Error: reading block\n"); debug("Error: reading block\n");
return -1; return -1;
} }
@ -669,9 +702,6 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
bs->fat_length = FAT2CPU16(bs->fat_length); bs->fat_length = FAT2CPU16(bs->fat_length);
bs->secs_track = FAT2CPU16(bs->secs_track); bs->secs_track = FAT2CPU16(bs->secs_track);
bs->heads = FAT2CPU16(bs->heads); bs->heads = FAT2CPU16(bs->heads);
#if 0 /* UNUSED */
bs->hidden = FAT2CPU32(bs->hidden);
#endif
bs->total_sect = FAT2CPU32(bs->total_sect); bs->total_sect = FAT2CPU32(bs->total_sect);
/* FAT32 entries */ /* FAT32 entries */
@ -691,9 +721,8 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
memcpy(volinfo, vistart, sizeof(volume_info)); memcpy(volinfo, vistart, sizeof(volume_info));
if (*fatsize == 32) { if (*fatsize == 32) {
if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0) { if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0)
return 0; return 0;
}
} else { } else {
if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) { if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) {
*fatsize = 12; *fatsize = 12;
@ -705,12 +734,13 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
} }
} }
FAT_DPRINT("Error: broken fs_type sign\n"); debug("Error: broken fs_type sign\n");
return -1; return -1;
} }
__attribute__ ((__aligned__ (__alignof__ (dir_entry)))) __attribute__ ((__aligned__ (__alignof__ (dir_entry))))
__u8 do_fat_read_block[MAX_CLUSTSIZE]; __u8 do_fat_read_block[MAX_CLUSTSIZE];
long long
do_fat_read (const char *filename, void *buffer, unsigned long maxsize, do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
int dols) int dols)
@ -732,61 +762,71 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
int j; int j;
if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) { if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
FAT_DPRINT ("Error: reading boot sector\n"); debug("Error: reading boot sector\n");
return -1; return -1;
} }
root_cluster = bs.root_cluster; root_cluster = bs.root_cluster;
if (mydata->fatsize == 32) {
if (mydata->fatsize == 32)
mydata->fatlength = bs.fat32_length; mydata->fatlength = bs.fat32_length;
} else { else
mydata->fatlength = bs.fat_length; mydata->fatlength = bs.fat_length;
}
mydata->fat_sect = bs.reserved; mydata->fat_sect = bs.reserved;
cursect = mydata->rootdir_sect cursect = mydata->rootdir_sect
= mydata->fat_sect + mydata->fatlength * bs.fats; = mydata->fat_sect + mydata->fatlength * bs.fats;
mydata->clust_size = bs.cluster_size; mydata->clust_size = bs.cluster_size;
if (mydata->fatsize == 32) { if (mydata->fatsize == 32) {
mydata->data_begin = mydata->rootdir_sect mydata->data_begin = mydata->rootdir_sect -
- (mydata->clust_size * 2); (mydata->clust_size * 2);
} else { } else {
int rootdir_size; int rootdir_size;
rootdir_size = ((bs.dir_entries[1] * (int) 256 + bs.dir_entries[0]) rootdir_size = ((bs.dir_entries[1] * (int)256 +
* sizeof (dir_entry)) / SECTOR_SIZE; bs.dir_entries[0]) *
mydata->data_begin = mydata->rootdir_sect + rootdir_size sizeof(dir_entry)) /
- (mydata->clust_size * 2); SECTOR_SIZE;
mydata->data_begin = mydata->rootdir_sect +
rootdir_size -
(mydata->clust_size * 2);
} }
mydata->fatbufnum = -1; mydata->fatbufnum = -1;
#ifdef CONFIG_SUPPORT_VFAT #ifdef CONFIG_SUPPORT_VFAT
FAT_DPRINT ("VFAT Support enabled\n"); debug("VFAT Support enabled\n");
#endif #endif
FAT_DPRINT ("FAT%d, fat_sect: %d, fatlength: %d\n", debug("FAT%d, fat_sect: %d, fatlength: %d\n",
mydata->fatsize, mydata->fatsize, mydata->fat_sect, mydata->fatlength);
mydata->fat_sect, debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
mydata->fatlength);
FAT_DPRINT ("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
"Data begins at: %d\n", "Data begins at: %d\n",
root_cluster, root_cluster,
mydata->rootdir_sect, mydata->rootdir_sect,
mydata->rootdir_sect * SECTOR_SIZE, mydata->rootdir_sect * SECTOR_SIZE, mydata->data_begin);
mydata->data_begin); debug("Cluster size: %d\n", mydata->clust_size);
FAT_DPRINT ("Cluster size: %d\n", mydata->clust_size);
/* "cwd" is always the root... */ /* "cwd" is always the root... */
while (ISDIRDELIM(*filename)) while (ISDIRDELIM(*filename))
filename++; filename++;
/* Make a copy of the filename and convert it to lowercase */ /* Make a copy of the filename and convert it to lowercase */
strcpy(fnamecopy, filename); strcpy(fnamecopy, filename);
downcase(fnamecopy); downcase(fnamecopy);
if (*fnamecopy == '\0') { if (*fnamecopy == '\0') {
if (!dols) if (!dols)
return -1; return -1;
dols = LS_ROOT; dols = LS_ROOT;
} else if ((idx = dirdelim(fnamecopy)) >= 0) { } else if ((idx = dirdelim(fnamecopy)) >= 0) {
isdir = 1; isdir = 1;
fnamecopy[idx] = '\0'; fnamecopy[idx] = '\0';
subname = fnamecopy + idx + 1; subname = fnamecopy + idx + 1;
/* Handle multiple delimiters */ /* Handle multiple delimiters */
while (ISDIRDELIM(*subname)) while (ISDIRDELIM(*subname))
subname++; subname++;
@ -798,13 +838,16 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
while (1) { while (1) {
int i; int i;
FAT_DPRINT ("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%d\n", debug("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%d\n",
cursect, mydata->clust_size, DIRENTSPERBLOCK); cursect, mydata->clust_size, DIRENTSPERBLOCK);
if (disk_read(cursect, mydata->clust_size, do_fat_read_block) < 0) { if (disk_read(cursect, mydata->clust_size, do_fat_read_block) < 0) {
FAT_DPRINT ("Error: reading rootdir block\n"); debug("Error: reading rootdir block\n");
return -1; return -1;
} }
dentptr = (dir_entry *) do_fat_read_block; dentptr = (dir_entry *) do_fat_read_block;
for (i = 0; i < DIRENTSPERBLOCK; i++) { for (i = 0; i < DIRENTSPERBLOCK; i++) {
char s_name[14], l_name[256]; char s_name[14], l_name[256];
@ -813,12 +856,18 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
#ifdef CONFIG_SUPPORT_VFAT #ifdef CONFIG_SUPPORT_VFAT
if ((dentptr->attr & ATTR_VFAT) && if ((dentptr->attr & ATTR_VFAT) &&
(dentptr->name[0] & LAST_LONG_ENTRY_MASK)) { (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
prevcksum = ((dir_slot *) dentptr)->alias_checksum; prevcksum =
get_vfatname (mydata, 0, do_fat_read_block, dentptr, l_name); ((dir_slot *)dentptr)->alias_checksum;
get_vfatname(mydata, 0,
do_fat_read_block,
dentptr, l_name);
if (dols == LS_ROOT) { if (dols == LS_ROOT) {
int isdir = (dentptr->attr & ATTR_DIR);
char dirc; char dirc;
int doit = 0; int doit = 0;
int isdir =
(dentptr->attr & ATTR_DIR);
if (isdir) { if (isdir) {
dirs++; dirs++;
@ -835,15 +884,19 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
if (dirc == ' ') { if (dirc == ' ') {
printf(" %8ld %s%c\n", printf(" %8ld %s%c\n",
(long)FAT2CPU32(dentptr->size), (long)FAT2CPU32(dentptr->size),
l_name, dirc); l_name,
dirc);
} else { } else {
printf (" %s%c\n", l_name, dirc); printf(" %s%c\n",
l_name,
dirc);
} }
} }
dentptr++; dentptr++;
continue; continue;
} }
FAT_DPRINT ("Rootvfatname: |%s|\n", l_name); debug("Rootvfatname: |%s|\n",
l_name);
} else } else
#endif #endif
{ {
@ -852,21 +905,23 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
continue; continue;
} }
} else if (dentptr->name[0] == 0) { } else if (dentptr->name[0] == 0) {
FAT_DPRINT ("RootDentname == NULL - %d\n", i); debug("RootDentname == NULL - %d\n", i);
if (dols == LS_ROOT) { if (dols == LS_ROOT) {
printf ("\n%d file(s), %d dir(s)\n\n", files, dirs); printf("\n%d file(s), %d dir(s)\n\n",
files, dirs);
return 0; return 0;
} }
return -1; return -1;
} }
#ifdef CONFIG_SUPPORT_VFAT #ifdef CONFIG_SUPPORT_VFAT
else if (dols == LS_ROOT else if (dols == LS_ROOT &&
&& mkcksum (dentptr->name) == prevcksum) { mkcksum(dentptr->name) == prevcksum) {
dentptr++; dentptr++;
continue; continue;
} }
#endif #endif
get_name(dentptr, s_name); get_name(dentptr, s_name);
if (dols == LS_ROOT) { if (dols == LS_ROOT) {
int isdir = (dentptr->attr & ATTR_DIR); int isdir = (dentptr->attr & ATTR_DIR);
char dirc; char dirc;
@ -888,31 +943,38 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
if (doit) { if (doit) {
if (dirc == ' ') { if (dirc == ' ') {
printf(" %8ld %s%c\n", printf(" %8ld %s%c\n",
(long) FAT2CPU32 (dentptr->size), s_name, (long)FAT2CPU32(dentptr->size),
dirc); s_name, dirc);
} else { } else {
printf (" %s%c\n", s_name, dirc); printf(" %s%c\n",
s_name, dirc);
} }
} }
dentptr++; dentptr++;
continue; continue;
} }
if (strcmp (fnamecopy, s_name) && strcmp (fnamecopy, l_name)) {
FAT_DPRINT ("RootMismatch: |%s|%s|\n", s_name, l_name); if (strcmp(fnamecopy, s_name)
&& strcmp(fnamecopy, l_name)) {
debug("RootMismatch: |%s|%s|\n", s_name,
l_name);
dentptr++; dentptr++;
continue; continue;
} }
if (isdir && !(dentptr->attr & ATTR_DIR)) if (isdir && !(dentptr->attr & ATTR_DIR))
return -1; return -1;
FAT_DPRINT ("RootName: %s", s_name); debug("RootName: %s", s_name);
FAT_DPRINT (", start: 0x%x", START (dentptr)); debug(", start: 0x%x", START(dentptr));
FAT_DPRINT (", size: 0x%x %s\n", debug(", size: 0x%x %s\n",
FAT2CPU32 (dentptr->size), isdir ? "(DIR)" : ""); FAT2CPU32(dentptr->size),
isdir ? "(DIR)" : "");
goto rootdir_done; /* We got a match */ goto rootdir_done; /* We got a match */
} }
FAT_DPRINT ("END LOOP: j=%d clust_size=%d\n", j, mydata->clust_size); debug("END LOOP: j=%d clust_size=%d\n", j,
mydata->clust_size);
/* /*
* On FAT32 we must fetch the FAT entries for the next * On FAT32 we must fetch the FAT entries for the next
@ -921,13 +983,18 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
*/ */
if ((mydata->fatsize == 32) && (++j == mydata->clust_size)) { if ((mydata->fatsize == 32) && (++j == mydata->clust_size)) {
int nxtsect; int nxtsect;
int cur_clust, nxt_clust; int nxt_clust;
cur_clust = (cursect - mydata->data_begin) / mydata->clust_size;
nxt_clust = get_fatent(mydata, root_cluster); nxt_clust = get_fatent(mydata, root_cluster);
nxtsect = mydata->data_begin + (nxt_clust * mydata->clust_size);
FAT_DPRINT ("END LOOP: sect=%d, clust=%d, root_clust=%d, n_sect=%d, n_clust=%d\n", nxtsect = mydata->data_begin +
cursect, cur_clust, root_cluster, nxtsect, nxt_clust); (nxt_clust * mydata->clust_size);
debug("END LOOP: sect=%d, root_clust=%d, "
"n_sect=%d, n_clust=%d\n",
cursect, root_cluster,
nxtsect, nxt_clust);
root_cluster = nxt_clust; root_cluster = nxt_clust;
cursect = nxtsect; cursect = nxtsect;
@ -939,6 +1006,7 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
rootdir_done: rootdir_done:
firsttime = 1; firsttime = 1;
while (isdir) { while (isdir) {
int startsect = mydata->data_begin int startsect = mydata->data_begin
+ START(dentptr) * mydata->clust_size; + START(dentptr) * mydata->clust_size;
@ -949,6 +1017,7 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
dentptr = &dent; dentptr = &dent;
idx = dirdelim(subname); idx = dirdelim(subname);
if (idx >= 0) { if (idx >= 0) {
subname[idx] = '\0'; subname[idx] = '\0';
nextname = subname + idx + 1; nextname = subname + idx + 1;
@ -978,15 +1047,14 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
subname = nextname; subname = nextname;
} }
} }
ret = get_contents(mydata, dentptr, buffer, maxsize); ret = get_contents(mydata, dentptr, buffer, maxsize);
FAT_DPRINT ("Size: %d, got: %ld\n", FAT2CPU32 (dentptr->size), ret); debug("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), ret);
return ret; return ret;
} }
int file_fat_detectfs (void)
int
file_fat_detectfs(void)
{ {
boot_sector bs; boot_sector bs;
volume_info volinfo; volume_info volinfo;
@ -997,6 +1065,7 @@ file_fat_detectfs(void)
printf("No current device\n"); printf("No current device\n");
return 1; return 1;
} }
#if defined(CONFIG_CMD_IDE) || \ #if defined(CONFIG_CMD_IDE) || \
defined(CONFIG_CMD_MG_DISK) || \ defined(CONFIG_CMD_MG_DISK) || \
defined(CONFIG_CMD_SATA) || \ defined(CONFIG_CMD_SATA) || \
@ -1005,40 +1074,56 @@ file_fat_detectfs(void)
defined(CONFIG_MMC) defined(CONFIG_MMC)
printf("Interface: "); printf("Interface: ");
switch (cur_dev->if_type) { switch (cur_dev->if_type) {
case IF_TYPE_IDE : printf("IDE"); break; case IF_TYPE_IDE:
case IF_TYPE_SATA : printf("SATA"); break; printf("IDE");
case IF_TYPE_SCSI : printf("SCSI"); break; break;
case IF_TYPE_ATAPI : printf("ATAPI"); break; case IF_TYPE_SATA:
case IF_TYPE_USB : printf("USB"); break; printf("SATA");
case IF_TYPE_DOC : printf("DOC"); break; break;
case IF_TYPE_MMC : printf("MMC"); break; case IF_TYPE_SCSI:
default : printf("Unknown"); printf("SCSI");
break;
case IF_TYPE_ATAPI:
printf("ATAPI");
break;
case IF_TYPE_USB:
printf("USB");
break;
case IF_TYPE_DOC:
printf("DOC");
break;
case IF_TYPE_MMC:
printf("MMC");
break;
default:
printf("Unknown");
} }
printf("\n Device %d: ", cur_dev->dev); printf("\n Device %d: ", cur_dev->dev);
dev_print(cur_dev); dev_print(cur_dev);
#endif #endif
if (read_bootsectandvi(&bs, &volinfo, &fatsize)) { if (read_bootsectandvi(&bs, &volinfo, &fatsize)) {
printf("\nNo valid FAT fs found\n"); printf("\nNo valid FAT fs found\n");
return 1; return 1;
} }
memcpy(vol_label, volinfo.volume_label, 11); memcpy(vol_label, volinfo.volume_label, 11);
vol_label[11] = '\0'; vol_label[11] = '\0';
volinfo.fs_type[5] = '\0'; volinfo.fs_type[5] = '\0';
printf("Partition %d: Filesystem: %s \"%s\"\n"
,cur_part,volinfo.fs_type,vol_label); printf("Partition %d: Filesystem: %s \"%s\"\n", cur_part,
volinfo.fs_type, vol_label);
return 0; return 0;
} }
int file_fat_ls (const char *dir)
int
file_fat_ls(const char *dir)
{ {
return do_fat_read(dir, NULL, 0, LS_YES); return do_fat_read(dir, NULL, 0, LS_YES);
} }
long file_fat_read (const char *filename, void *buffer, unsigned long maxsize)
long
file_fat_read(const char *filename, void *buffer, unsigned long maxsize)
{ {
printf("reading %s\n", filename); printf("reading %s\n", filename);
return do_fat_read(filename, buffer, maxsize, LS_NO); return do_fat_read(filename, buffer, maxsize, LS_NO);

14
fs/fat/file.c
View File

@ -48,12 +48,12 @@ char file_cwd[CWD_LEN+1] = "/";
const char * const char *
file_getfsname(int idx) file_getfsname(int idx)
{ {
if (idx < 0 || idx >= NUM_FILESYS) return NULL; if (idx < 0 || idx >= NUM_FILESYS)
return NULL;
return filesystems[idx].name; return filesystems[idx].name;
} }
static void static void
pathcpy(char *dest, const char *src) pathcpy(char *dest, const char *src)
{ {
@ -72,15 +72,14 @@ pathcpy(char *dest, const char *src)
return; return;
} }
++dest; ++dest;
if (ISDIRDELIM(*src)) {
if (ISDIRDELIM(*src))
while (ISDIRDELIM(*src)) src++; while (ISDIRDELIM(*src)) src++;
} else { else
src++; src++;
}
} while (1); } while (1);
} }
int int
file_cd(const char *path) file_cd(const char *path)
{ {
@ -141,7 +140,6 @@ file_cd(const char *path)
return 0; return 0;
} }
int int
file_detectfs(void) file_detectfs(void)
{ {
@ -160,7 +158,6 @@ file_detectfs(void)
return current_filesystem; return current_filesystem;
} }
int int
file_ls(const char *dir) file_ls(const char *dir)
{ {
@ -181,7 +178,6 @@ file_ls(const char *dir)
return filesystems[current_filesystem].ls(arg); return filesystems[current_filesystem].ls(arg);
} }
long long
file_read(const char *filename, void *buffer, unsigned long maxsize) file_read(const char *filename, void *buffer, unsigned long maxsize)
{ {

13
include/fat.h
View File

@ -69,7 +69,8 @@
#define DELETED_FLAG ((char)0xe5) /* Marks deleted files when in name[0] */ #define DELETED_FLAG ((char)0xe5) /* Marks deleted files when in name[0] */
#define aRING 0x05 /* Used as special character in name[0] */ #define aRING 0x05 /* Used as special character in name[0] */
/* Indicates that the entry is the last long entry in a set of long /*
* Indicates that the entry is the last long entry in a set of long
* dir entries * dir entries
*/ */
#define LAST_LONG_ENTRY_MASK 0x40 #define LAST_LONG_ENTRY_MASK 0x40
@ -80,13 +81,6 @@
#define LS_DIR 1 #define LS_DIR 1
#define LS_ROOT 2 #define LS_ROOT 2
#ifdef DEBUG
#define FAT_DPRINT(args...) printf(args)
#else
#define FAT_DPRINT(args...)
#endif
#define FAT_ERROR(arg) printf(arg)
#define ISDIRDELIM(c) ((c) == '/' || (c) == '\\') #define ISDIRDELIM(c) ((c) == '/' || (c) == '\\')
#define FSTYPE_NONE (-1) #define FSTYPE_NONE (-1)
@ -176,7 +170,8 @@ typedef struct dir_slot {
__u8 name11_12[4]; /* Last 2 characters in name */ __u8 name11_12[4]; /* Last 2 characters in name */
} dir_slot; } dir_slot;
/* Private filesystem parameters /*
* Private filesystem parameters
* *
* Note: FAT buffer has to be 32 bit aligned * Note: FAT buffer has to be 32 bit aligned
* (see FAT32 accesses) * (see FAT32 accesses)