fs/fat: Big code cleanup.
- 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
parent
226fa9bb9e
commit
7385c28e9b
164
common/cmd_fat.c
164
common/cmd_fat.c
|
|
@ -45,9 +45,11 @@ int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|||
char *ep;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
dev = (int)simple_strtoul(argv[2], &ep, 16);
|
||||
dev_desc = get_dev(argv[1],dev);
|
||||
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);
|
||||
}
|
||||
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;
|
||||
}
|
||||
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);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
@ -105,7 +109,7 @@ int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|||
|
||||
if (argc < 3) {
|
||||
printf("usage: fatls <interface> <dev[:part]> [directory]\n");
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
dev = (int)simple_strtoul(argv[2], &ep, 16);
|
||||
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);
|
||||
}
|
||||
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;
|
||||
}
|
||||
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)
|
||||
printf("No Fat FS detected\n");
|
||||
return (ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
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) {
|
||||
printf("usage: fatinfo <interface> <dev[:part]>\n");
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
dev = (int)simple_strtoul(argv[2], &ep, 16);
|
||||
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);
|
||||
}
|
||||
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 (file_fat_detectfs ());
|
||||
return file_fat_detectfs();
|
||||
}
|
||||
|
||||
U_BOOT_CMD(
|
||||
|
|
@ -178,143 +184,3 @@ U_BOOT_CMD(
|
|||
"<interface> <dev[:part]>\n"
|
||||
" - 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
409
fs/fat/fat.c
|
|
@ -34,8 +34,7 @@
|
|||
/*
|
||||
* Convert a string to lowercase.
|
||||
*/
|
||||
static void
|
||||
downcase(char *str)
|
||||
static void downcase (char *str)
|
||||
{
|
||||
while (*str != '\0') {
|
||||
TOLOWER(*str);
|
||||
|
|
@ -44,7 +43,9 @@ downcase(char *str)
|
|||
}
|
||||
|
||||
static block_dev_desc_t *cur_dev = NULL;
|
||||
|
||||
static unsigned long part_offset = 0;
|
||||
|
||||
static int cur_part = 1;
|
||||
|
||||
#define DOS_PART_TBL_OFFSET 0x1be
|
||||
|
|
@ -52,31 +53,34 @@ static int cur_part = 1;
|
|||
#define DOS_FS_TYPE_OFFSET 0x36
|
||||
#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)
|
||||
return -1;
|
||||
|
||||
startblock += part_offset;
|
||||
|
||||
if (cur_dev->block_read) {
|
||||
return cur_dev->block_read (cur_dev->dev
|
||||
, startblock, getsize, (unsigned long *)bufptr);
|
||||
return cur_dev->block_read(cur_dev->dev, startblock, getsize,
|
||||
(unsigned long *) bufptr);
|
||||
}
|
||||
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];
|
||||
|
||||
disk_partition_t info;
|
||||
|
||||
if (!dev_desc->block_read)
|
||||
return -1;
|
||||
|
||||
cur_dev = dev_desc;
|
||||
/* 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) {
|
||||
printf ("** Can't read from device %d **\n", dev_desc->dev);
|
||||
printf("** Can't read from device %d **\n",
|
||||
dev_desc->dev);
|
||||
return -1;
|
||||
}
|
||||
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_MMC) || \
|
||||
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)) {
|
||||
part_offset = info.start;
|
||||
cur_part = part_no;
|
||||
} else if (strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3)==0 ||
|
||||
strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET],"FAT32",5)==0) {
|
||||
} else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3) == 0) ||
|
||||
(strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET], "FAT32", 5) == 0)) {
|
||||
/* ok, we assume we are on a PBR only */
|
||||
cur_part = 1;
|
||||
part_offset = 0;
|
||||
|
|
@ -126,18 +130,17 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Get the first occurence of a directory delimiter ('/' or '\') in a string.
|
||||
* Return index into string if found, -1 otherwise.
|
||||
*/
|
||||
static int
|
||||
dirdelim(char *str)
|
||||
static int dirdelim (char *str)
|
||||
{
|
||||
char *start = str;
|
||||
|
||||
while (*str != '\0') {
|
||||
if (ISDIRDELIM(*str)) return str - start;
|
||||
if (ISDIRDELIM(*str))
|
||||
return str - start;
|
||||
str++;
|
||||
}
|
||||
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.
|
||||
* On failure 0x00 is returned.
|
||||
*/
|
||||
static __u32
|
||||
get_fatent(fsdata *mydata, __u32 entry)
|
||||
static __u32 get_fatent (fsdata *mydata, __u32 entry)
|
||||
{
|
||||
__u32 bufnum;
|
||||
__u32 offset;
|
||||
__u32 off16, offset;
|
||||
__u32 ret = 0x00;
|
||||
__u16 val1, val2;
|
||||
|
||||
switch (mydata->fatsize) {
|
||||
case 32:
|
||||
|
|
@ -201,7 +204,7 @@ get_fatent(fsdata *mydata, __u32 entry)
|
|||
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);
|
||||
|
||||
/* 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 */
|
||||
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) {
|
||||
FAT_DPRINT("Error reading FAT blocks\n");
|
||||
debug("Error reading FAT blocks\n");
|
||||
return ret;
|
||||
}
|
||||
mydata->fatbufnum = bufnum;
|
||||
|
|
@ -230,9 +234,8 @@ get_fatent(fsdata *mydata, __u32 entry)
|
|||
case 16:
|
||||
ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);
|
||||
break;
|
||||
case 12: {
|
||||
__u32 off16 = (offset*3)/4;
|
||||
__u16 val1, val2;
|
||||
case 12:
|
||||
off16 = (offset * 3) / 4;
|
||||
|
||||
switch (offset & 0x3) {
|
||||
case 0:
|
||||
|
|
@ -254,48 +257,50 @@ get_fatent(fsdata *mydata, __u32 entry)
|
|||
ret = (val2 << 8) | (val1 >> 8);
|
||||
break;
|
||||
case 3:
|
||||
ret = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);;
|
||||
ret = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
|
||||
ret = (ret & 0xfff0) >> 4;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
FAT_DPRINT("FAT%d: ret: %08x, offset: %04x\n",
|
||||
debug("FAT%d: ret: %08x, offset: %04x\n",
|
||||
mydata->fatsize, ret, offset);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read at most 'size' bytes from the specified cluster into 'buffer'.
|
||||
* Return 0 on success, -1 otherwise.
|
||||
*/
|
||||
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;
|
||||
__u32 startsect;
|
||||
|
||||
if (clustnum > 0) {
|
||||
startsect = mydata->data_begin + clustnum*mydata->clust_size;
|
||||
startsect = mydata->data_begin +
|
||||
clustnum * mydata->clust_size;
|
||||
} else {
|
||||
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) {
|
||||
FAT_DPRINT("Error reading data\n");
|
||||
debug("Error reading data\n");
|
||||
return -1;
|
||||
}
|
||||
if (size % FS_BLOCK_SIZE) {
|
||||
__u8 tmpbuf[FS_BLOCK_SIZE];
|
||||
|
||||
idx = size / FS_BLOCK_SIZE;
|
||||
if (disk_read(startsect + idx, 1, tmpbuf) < 0) {
|
||||
FAT_DPRINT("Error reading data\n");
|
||||
debug("Error reading data\n");
|
||||
return -1;
|
||||
}
|
||||
buffer += idx * FS_BLOCK_SIZE;
|
||||
|
|
@ -307,7 +312,6 @@ get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read at most 'maxsize' bytes from the file associated with 'dentptr'
|
||||
* into 'buffer'.
|
||||
|
|
@ -323,14 +327,16 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
|
|||
__u32 endclust, newclust;
|
||||
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;
|
||||
endclust = curclust;
|
||||
|
||||
do {
|
||||
/* search for consecutive clusters */
|
||||
while (actsize < filesize) {
|
||||
|
|
@ -338,43 +344,47 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
|
|||
if ((newclust - 1) != endclust)
|
||||
goto getit;
|
||||
if (CHECK_CLUST(newclust, mydata->fatsize)) {
|
||||
FAT_DPRINT("curclust: 0x%x\n", newclust);
|
||||
FAT_DPRINT("Invalid FAT entry\n");
|
||||
debug("curclust: 0x%x\n", newclust);
|
||||
debug("Invalid FAT entry\n");
|
||||
return gotsize;
|
||||
}
|
||||
endclust = newclust;
|
||||
actsize += bytesperclust;
|
||||
}
|
||||
|
||||
/* actsize >= file size */
|
||||
actsize -= bytesperclust;
|
||||
|
||||
/* get remaining clusters */
|
||||
if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
|
||||
FAT_ERROR("Error reading cluster\n");
|
||||
printf("Error reading cluster\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* get remaining bytes */
|
||||
gotsize += (int)actsize;
|
||||
filesize -= actsize;
|
||||
buffer += actsize;
|
||||
actsize = filesize;
|
||||
if (get_cluster(mydata, endclust, buffer, (int)actsize) != 0) {
|
||||
FAT_ERROR("Error reading cluster\n");
|
||||
printf("Error reading cluster\n");
|
||||
return -1;
|
||||
}
|
||||
gotsize += actsize;
|
||||
return gotsize;
|
||||
getit:
|
||||
if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
|
||||
FAT_ERROR("Error reading cluster\n");
|
||||
printf("Error reading cluster\n");
|
||||
return -1;
|
||||
}
|
||||
gotsize += (int)actsize;
|
||||
filesize -= actsize;
|
||||
buffer += actsize;
|
||||
|
||||
curclust = get_fatent(mydata, endclust);
|
||||
if (CHECK_CLUST(curclust, mydata->fatsize)) {
|
||||
FAT_DPRINT("curclust: 0x%x\n", curclust);
|
||||
FAT_ERROR("Invalid FAT entry\n");
|
||||
debug("curclust: 0x%x\n", curclust);
|
||||
printf("Invalid FAT entry\n");
|
||||
return gotsize;
|
||||
}
|
||||
actsize = bytesperclust;
|
||||
|
|
@ -382,38 +392,38 @@ getit:
|
|||
} while (1);
|
||||
}
|
||||
|
||||
|
||||
#ifdef CONFIG_SUPPORT_VFAT
|
||||
/*
|
||||
* Extract the file name information from 'slotptr' into 'l_name',
|
||||
* starting at l_name[*idx].
|
||||
* Return 1 if terminator (zero byte) is found, 0 otherwise.
|
||||
*/
|
||||
static int
|
||||
slot2str(dir_slot *slotptr, char *l_name, int *idx)
|
||||
static int slot2str (dir_slot *slotptr, char *l_name, int *idx)
|
||||
{
|
||||
int j;
|
||||
|
||||
for (j = 0; j <= 8; j += 2) {
|
||||
l_name[*idx] = slotptr->name0_4[j];
|
||||
if (l_name[*idx] == 0x00) return 1;
|
||||
if (l_name[*idx] == 0x00)
|
||||
return 1;
|
||||
(*idx)++;
|
||||
}
|
||||
for (j = 0; j <= 10; j += 2) {
|
||||
l_name[*idx] = slotptr->name5_10[j];
|
||||
if (l_name[*idx] == 0x00) return 1;
|
||||
if (l_name[*idx] == 0x00)
|
||||
return 1;
|
||||
(*idx)++;
|
||||
}
|
||||
for (j = 0; j <= 2; j += 2) {
|
||||
l_name[*idx] = slotptr->name11_12[j];
|
||||
if (l_name[*idx] == 0x00) return 1;
|
||||
if (l_name[*idx] == 0x00)
|
||||
return 1;
|
||||
(*idx)++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Extract the full long filename starting at 'retdent' (which is really
|
||||
* 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))))
|
||||
__u8 get_vfatname_block[MAX_CLUSTSIZE];
|
||||
|
||||
static int
|
||||
get_vfatname (fsdata *mydata, int curclust, __u8 *cluster,
|
||||
dir_entry *retdent, char *l_name)
|
||||
|
|
@ -433,7 +444,8 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
|
|||
int idx = 0;
|
||||
|
||||
while ((__u8 *)slotptr < nextclust) {
|
||||
if (counter == 0) break;
|
||||
if (counter == 0)
|
||||
break;
|
||||
if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
|
||||
return -1;
|
||||
slotptr++;
|
||||
|
|
@ -446,19 +458,21 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
|
|||
slotptr--;
|
||||
curclust = get_fatent(mydata, curclust);
|
||||
if (CHECK_CLUST(curclust, mydata->fatsize)) {
|
||||
FAT_DPRINT("curclust: 0x%x\n", curclust);
|
||||
FAT_ERROR("Invalid FAT entry\n");
|
||||
debug("curclust: 0x%x\n", curclust);
|
||||
printf("Invalid FAT entry\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (get_cluster(mydata, curclust, get_vfatname_block,
|
||||
mydata->clust_size * SECTOR_SIZE) != 0) {
|
||||
FAT_DPRINT("Error: reading directory block\n");
|
||||
debug("Error: reading directory block\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
slotptr2 = (dir_slot *)get_vfatname_block;
|
||||
while (slotptr2->id > 0x01) {
|
||||
while (slotptr2->id > 0x01)
|
||||
slotptr2++;
|
||||
}
|
||||
|
||||
/* Save the real directory entry */
|
||||
realdent = (dir_entry *)slotptr2 + 1;
|
||||
while ((__u8 *)slotptr2 >= get_vfatname_block) {
|
||||
|
|
@ -472,12 +486,15 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
|
|||
|
||||
do {
|
||||
slotptr--;
|
||||
if (slot2str(slotptr, l_name, &idx)) break;
|
||||
if (slot2str(slotptr, l_name, &idx))
|
||||
break;
|
||||
} while (!(slotptr->id & LAST_LONG_ENTRY_MASK));
|
||||
|
||||
l_name[idx] = '\0';
|
||||
if (*l_name == DELETED_FLAG) *l_name = '\0';
|
||||
else if (*l_name == aRING) *l_name = DELETED_FLAG;
|
||||
if (*l_name == DELETED_FLAG)
|
||||
*l_name = '\0';
|
||||
else if (*l_name == aRING)
|
||||
*l_name = DELETED_FLAG;
|
||||
downcase(l_name);
|
||||
|
||||
/* Return the real directory entry */
|
||||
|
|
@ -486,12 +503,11 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Calculate short name checksum */
|
||||
static __u8
|
||||
mkcksum(const char *str)
|
||||
static __u8 mkcksum (const char *str)
|
||||
{
|
||||
int i;
|
||||
|
||||
__u8 ret = 0;
|
||||
|
||||
for (i = 0; i < 11; i++) {
|
||||
|
|
@ -500,8 +516,7 @@ mkcksum(const char *str)
|
|||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CONFIG_SUPPORT_VFAT */
|
||||
|
||||
/*
|
||||
* Get the directory entry associated with 'filename' from the directory
|
||||
|
|
@ -509,6 +524,7 @@ mkcksum(const char *str)
|
|||
*/
|
||||
__attribute__ ((__aligned__ (__alignof__ (dir_entry))))
|
||||
__u8 get_dentfromdir_block[MAX_CLUSTSIZE];
|
||||
|
||||
static dir_entry *get_dentfromdir (fsdata *mydata, int startsect,
|
||||
char *filename, dir_entry *retdent,
|
||||
int dols)
|
||||
|
|
@ -517,17 +533,21 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
|
|||
__u32 curclust = START(retdent);
|
||||
int files = 0, dirs = 0;
|
||||
|
||||
FAT_DPRINT ("get_dentfromdir: %s\n", filename);
|
||||
debug("get_dentfromdir: %s\n", filename);
|
||||
|
||||
while (1) {
|
||||
dir_entry *dentptr;
|
||||
|
||||
int i;
|
||||
|
||||
if (get_cluster(mydata, curclust, get_dentfromdir_block,
|
||||
mydata->clust_size * SECTOR_SIZE) != 0) {
|
||||
FAT_DPRINT ("Error: reading directory block\n");
|
||||
debug("Error: reading directory block\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
dentptr = (dir_entry *)get_dentfromdir_block;
|
||||
|
||||
for (i = 0; i < DIRENTSPERCLUST; i++) {
|
||||
char s_name[14], l_name[256];
|
||||
|
||||
|
|
@ -540,15 +560,17 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
|
|||
#ifdef CONFIG_SUPPORT_VFAT
|
||||
if ((dentptr->attr & ATTR_VFAT) &&
|
||||
(dentptr-> name[0] & LAST_LONG_ENTRY_MASK)) {
|
||||
prevcksum = ((dir_slot *) dentptr)
|
||||
->alias_checksum;
|
||||
get_vfatname (mydata, curclust, get_dentfromdir_block,
|
||||
prevcksum = ((dir_slot *)dentptr)->alias_checksum;
|
||||
get_vfatname(mydata, curclust,
|
||||
get_dentfromdir_block,
|
||||
dentptr, l_name);
|
||||
if (dols) {
|
||||
int isdir = (dentptr->attr & ATTR_DIR);
|
||||
int isdir;
|
||||
char dirc;
|
||||
int doit = 0;
|
||||
|
||||
isdir = (dentptr->attr & ATTR_DIR);
|
||||
|
||||
if (isdir) {
|
||||
dirs++;
|
||||
dirc = '/';
|
||||
|
|
@ -564,15 +586,18 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
|
|||
if (dirc == ' ') {
|
||||
printf(" %8ld %s%c\n",
|
||||
(long)FAT2CPU32(dentptr->size),
|
||||
l_name, dirc);
|
||||
l_name,
|
||||
dirc);
|
||||
} else {
|
||||
printf (" %s%c\n", l_name, dirc);
|
||||
printf(" %s%c\n",
|
||||
l_name,
|
||||
dirc);
|
||||
}
|
||||
}
|
||||
dentptr++;
|
||||
continue;
|
||||
}
|
||||
FAT_DPRINT ("vfatname: |%s|\n", l_name);
|
||||
debug("vfatname: |%s|\n", l_name);
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
|
|
@ -583,9 +608,10 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
|
|||
}
|
||||
if (dentptr->name[0] == 0) {
|
||||
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;
|
||||
}
|
||||
#ifdef CONFIG_SUPPORT_VFAT
|
||||
|
|
@ -611,37 +637,44 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
|
|||
doit = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (doit) {
|
||||
if (dirc == ' ') {
|
||||
printf(" %8ld %s%c\n",
|
||||
(long) FAT2CPU32 (dentptr->size), s_name,
|
||||
dirc);
|
||||
(long)FAT2CPU32(dentptr->size),
|
||||
s_name, dirc);
|
||||
} else {
|
||||
printf (" %s%c\n", s_name, dirc);
|
||||
printf(" %s%c\n",
|
||||
s_name, dirc);
|
||||
}
|
||||
}
|
||||
|
||||
dentptr++;
|
||||
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++;
|
||||
continue;
|
||||
}
|
||||
|
||||
memcpy(retdent, dentptr, sizeof(dir_entry));
|
||||
|
||||
FAT_DPRINT ("DentName: %s", s_name);
|
||||
FAT_DPRINT (", start: 0x%x", START (dentptr));
|
||||
FAT_DPRINT (", size: 0x%x %s\n",
|
||||
debug("DentName: %s", s_name);
|
||||
debug(", start: 0x%x", START(dentptr));
|
||||
debug(", size: 0x%x %s\n",
|
||||
FAT2CPU32(dentptr->size),
|
||||
(dentptr->attr & ATTR_DIR) ? "(DIR)" : "");
|
||||
|
||||
return retdent;
|
||||
}
|
||||
|
||||
curclust = get_fatent(mydata, curclust);
|
||||
if (CHECK_CLUST(curclust, mydata->fatsize)) {
|
||||
FAT_DPRINT ("curclust: 0x%x\n", curclust);
|
||||
FAT_ERROR ("Invalid FAT entry\n");
|
||||
debug("curclust: 0x%x\n", curclust);
|
||||
printf("Invalid FAT entry\n");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -649,7 +682,6 @@ static dir_entry *get_dentfromdir (fsdata * mydata, int startsect,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* 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)
|
||||
{
|
||||
__u8 block[FS_BLOCK_SIZE];
|
||||
|
||||
volume_info *vistart;
|
||||
|
||||
if (disk_read (0, 1, block) < 0) {
|
||||
FAT_DPRINT("Error: reading block\n");
|
||||
debug("Error: reading block\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -669,9 +702,6 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
|
|||
bs->fat_length = FAT2CPU16(bs->fat_length);
|
||||
bs->secs_track = FAT2CPU16(bs->secs_track);
|
||||
bs->heads = FAT2CPU16(bs->heads);
|
||||
#if 0 /* UNUSED */
|
||||
bs->hidden = FAT2CPU32(bs->hidden);
|
||||
#endif
|
||||
bs->total_sect = FAT2CPU32(bs->total_sect);
|
||||
|
||||
/* FAT32 entries */
|
||||
|
|
@ -691,9 +721,8 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
|
|||
memcpy(volinfo, vistart, sizeof(volume_info));
|
||||
|
||||
if (*fatsize == 32) {
|
||||
if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0) {
|
||||
if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0)
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) {
|
||||
*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;
|
||||
}
|
||||
|
||||
__attribute__ ((__aligned__ (__alignof__ (dir_entry))))
|
||||
__u8 do_fat_read_block[MAX_CLUSTSIZE];
|
||||
|
||||
long
|
||||
do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
||||
int dols)
|
||||
|
|
@ -732,61 +762,71 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
int j;
|
||||
|
||||
if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
|
||||
FAT_DPRINT ("Error: reading boot sector\n");
|
||||
debug("Error: reading boot sector\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
root_cluster = bs.root_cluster;
|
||||
if (mydata->fatsize == 32) {
|
||||
|
||||
if (mydata->fatsize == 32)
|
||||
mydata->fatlength = bs.fat32_length;
|
||||
} else {
|
||||
else
|
||||
mydata->fatlength = bs.fat_length;
|
||||
}
|
||||
|
||||
mydata->fat_sect = bs.reserved;
|
||||
|
||||
cursect = mydata->rootdir_sect
|
||||
= mydata->fat_sect + mydata->fatlength * bs.fats;
|
||||
|
||||
mydata->clust_size = bs.cluster_size;
|
||||
|
||||
if (mydata->fatsize == 32) {
|
||||
mydata->data_begin = mydata->rootdir_sect
|
||||
- (mydata->clust_size * 2);
|
||||
mydata->data_begin = mydata->rootdir_sect -
|
||||
(mydata->clust_size * 2);
|
||||
} else {
|
||||
int rootdir_size;
|
||||
|
||||
rootdir_size = ((bs.dir_entries[1] * (int) 256 + bs.dir_entries[0])
|
||||
* sizeof (dir_entry)) / SECTOR_SIZE;
|
||||
mydata->data_begin = mydata->rootdir_sect + rootdir_size
|
||||
- (mydata->clust_size * 2);
|
||||
rootdir_size = ((bs.dir_entries[1] * (int)256 +
|
||||
bs.dir_entries[0]) *
|
||||
sizeof(dir_entry)) /
|
||||
SECTOR_SIZE;
|
||||
mydata->data_begin = mydata->rootdir_sect +
|
||||
rootdir_size -
|
||||
(mydata->clust_size * 2);
|
||||
}
|
||||
|
||||
mydata->fatbufnum = -1;
|
||||
|
||||
#ifdef CONFIG_SUPPORT_VFAT
|
||||
FAT_DPRINT ("VFAT Support enabled\n");
|
||||
debug("VFAT Support enabled\n");
|
||||
#endif
|
||||
FAT_DPRINT ("FAT%d, fat_sect: %d, fatlength: %d\n",
|
||||
mydata->fatsize,
|
||||
mydata->fat_sect,
|
||||
mydata->fatlength);
|
||||
FAT_DPRINT ("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
|
||||
debug("FAT%d, fat_sect: %d, fatlength: %d\n",
|
||||
mydata->fatsize, mydata->fat_sect, mydata->fatlength);
|
||||
debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
|
||||
"Data begins at: %d\n",
|
||||
root_cluster,
|
||||
mydata->rootdir_sect,
|
||||
mydata->rootdir_sect * SECTOR_SIZE,
|
||||
mydata->data_begin);
|
||||
FAT_DPRINT ("Cluster size: %d\n", mydata->clust_size);
|
||||
mydata->rootdir_sect * SECTOR_SIZE, mydata->data_begin);
|
||||
debug("Cluster size: %d\n", mydata->clust_size);
|
||||
|
||||
/* "cwd" is always the root... */
|
||||
while (ISDIRDELIM(*filename))
|
||||
filename++;
|
||||
|
||||
/* Make a copy of the filename and convert it to lowercase */
|
||||
strcpy(fnamecopy, filename);
|
||||
downcase(fnamecopy);
|
||||
|
||||
if (*fnamecopy == '\0') {
|
||||
if (!dols)
|
||||
return -1;
|
||||
|
||||
dols = LS_ROOT;
|
||||
} else if ((idx = dirdelim(fnamecopy)) >= 0) {
|
||||
isdir = 1;
|
||||
fnamecopy[idx] = '\0';
|
||||
subname = fnamecopy + idx + 1;
|
||||
|
||||
/* Handle multiple delimiters */
|
||||
while (ISDIRDELIM(*subname))
|
||||
subname++;
|
||||
|
|
@ -798,13 +838,16 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
while (1) {
|
||||
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);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
dentptr = (dir_entry *) do_fat_read_block;
|
||||
|
||||
for (i = 0; i < DIRENTSPERBLOCK; i++) {
|
||||
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
|
||||
if ((dentptr->attr & ATTR_VFAT) &&
|
||||
(dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
|
||||
prevcksum = ((dir_slot *) dentptr)->alias_checksum;
|
||||
get_vfatname (mydata, 0, do_fat_read_block, dentptr, l_name);
|
||||
prevcksum =
|
||||
((dir_slot *)dentptr)->alias_checksum;
|
||||
|
||||
get_vfatname(mydata, 0,
|
||||
do_fat_read_block,
|
||||
dentptr, l_name);
|
||||
|
||||
if (dols == LS_ROOT) {
|
||||
int isdir = (dentptr->attr & ATTR_DIR);
|
||||
char dirc;
|
||||
int doit = 0;
|
||||
int isdir =
|
||||
(dentptr->attr & ATTR_DIR);
|
||||
|
||||
if (isdir) {
|
||||
dirs++;
|
||||
|
|
@ -835,15 +884,19 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
if (dirc == ' ') {
|
||||
printf(" %8ld %s%c\n",
|
||||
(long)FAT2CPU32(dentptr->size),
|
||||
l_name, dirc);
|
||||
l_name,
|
||||
dirc);
|
||||
} else {
|
||||
printf (" %s%c\n", l_name, dirc);
|
||||
printf(" %s%c\n",
|
||||
l_name,
|
||||
dirc);
|
||||
}
|
||||
}
|
||||
dentptr++;
|
||||
continue;
|
||||
}
|
||||
FAT_DPRINT ("Rootvfatname: |%s|\n", l_name);
|
||||
debug("Rootvfatname: |%s|\n",
|
||||
l_name);
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
|
|
@ -852,21 +905,23 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
continue;
|
||||
}
|
||||
} else if (dentptr->name[0] == 0) {
|
||||
FAT_DPRINT ("RootDentname == NULL - %d\n", i);
|
||||
debug("RootDentname == NULL - %d\n", i);
|
||||
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 -1;
|
||||
}
|
||||
#ifdef CONFIG_SUPPORT_VFAT
|
||||
else if (dols == LS_ROOT
|
||||
&& mkcksum (dentptr->name) == prevcksum) {
|
||||
else if (dols == LS_ROOT &&
|
||||
mkcksum(dentptr->name) == prevcksum) {
|
||||
dentptr++;
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
get_name(dentptr, s_name);
|
||||
|
||||
if (dols == LS_ROOT) {
|
||||
int isdir = (dentptr->attr & ATTR_DIR);
|
||||
char dirc;
|
||||
|
|
@ -888,31 +943,38 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
if (doit) {
|
||||
if (dirc == ' ') {
|
||||
printf(" %8ld %s%c\n",
|
||||
(long) FAT2CPU32 (dentptr->size), s_name,
|
||||
dirc);
|
||||
(long)FAT2CPU32(dentptr->size),
|
||||
s_name, dirc);
|
||||
} else {
|
||||
printf (" %s%c\n", s_name, dirc);
|
||||
printf(" %s%c\n",
|
||||
s_name, dirc);
|
||||
}
|
||||
}
|
||||
dentptr++;
|
||||
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++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (isdir && !(dentptr->attr & ATTR_DIR))
|
||||
return -1;
|
||||
|
||||
FAT_DPRINT ("RootName: %s", s_name);
|
||||
FAT_DPRINT (", start: 0x%x", START (dentptr));
|
||||
FAT_DPRINT (", size: 0x%x %s\n",
|
||||
FAT2CPU32 (dentptr->size), isdir ? "(DIR)" : "");
|
||||
debug("RootName: %s", s_name);
|
||||
debug(", start: 0x%x", START(dentptr));
|
||||
debug(", size: 0x%x %s\n",
|
||||
FAT2CPU32(dentptr->size),
|
||||
isdir ? "(DIR)" : "");
|
||||
|
||||
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
|
||||
|
|
@ -921,13 +983,18 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
*/
|
||||
if ((mydata->fatsize == 32) && (++j == mydata->clust_size)) {
|
||||
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);
|
||||
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",
|
||||
cursect, cur_clust, root_cluster, nxtsect, nxt_clust);
|
||||
|
||||
nxtsect = mydata->data_begin +
|
||||
(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;
|
||||
|
||||
cursect = nxtsect;
|
||||
|
|
@ -939,6 +1006,7 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
rootdir_done:
|
||||
|
||||
firsttime = 1;
|
||||
|
||||
while (isdir) {
|
||||
int startsect = mydata->data_begin
|
||||
+ START(dentptr) * mydata->clust_size;
|
||||
|
|
@ -949,6 +1017,7 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
dentptr = &dent;
|
||||
|
||||
idx = dirdelim(subname);
|
||||
|
||||
if (idx >= 0) {
|
||||
subname[idx] = '\0';
|
||||
nextname = subname + idx + 1;
|
||||
|
|
@ -978,15 +1047,14 @@ do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
|
|||
subname = nextname;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
file_fat_detectfs(void)
|
||||
int file_fat_detectfs (void)
|
||||
{
|
||||
boot_sector bs;
|
||||
volume_info volinfo;
|
||||
|
|
@ -997,6 +1065,7 @@ file_fat_detectfs(void)
|
|||
printf("No current device\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
#if defined(CONFIG_CMD_IDE) || \
|
||||
defined(CONFIG_CMD_MG_DISK) || \
|
||||
defined(CONFIG_CMD_SATA) || \
|
||||
|
|
@ -1005,40 +1074,56 @@ file_fat_detectfs(void)
|
|||
defined(CONFIG_MMC)
|
||||
printf("Interface: ");
|
||||
switch (cur_dev->if_type) {
|
||||
case IF_TYPE_IDE : printf("IDE"); break;
|
||||
case IF_TYPE_SATA : printf("SATA"); break;
|
||||
case IF_TYPE_SCSI : 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");
|
||||
case IF_TYPE_IDE:
|
||||
printf("IDE");
|
||||
break;
|
||||
case IF_TYPE_SATA:
|
||||
printf("SATA");
|
||||
break;
|
||||
case IF_TYPE_SCSI:
|
||||
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);
|
||||
dev_print(cur_dev);
|
||||
#endif
|
||||
|
||||
if (read_bootsectandvi(&bs, &volinfo, &fatsize)) {
|
||||
printf("\nNo valid FAT fs found\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
memcpy(vol_label, volinfo.volume_label, 11);
|
||||
vol_label[11] = '\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;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
file_fat_ls(const char *dir)
|
||||
int file_fat_ls (const char *dir)
|
||||
{
|
||||
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);
|
||||
return do_fat_read(filename, buffer, maxsize, LS_NO);
|
||||
|
|
|
|||
|
|
@ -48,12 +48,12 @@ char file_cwd[CWD_LEN+1] = "/";
|
|||
const char *
|
||||
file_getfsname(int idx)
|
||||
{
|
||||
if (idx < 0 || idx >= NUM_FILESYS) return NULL;
|
||||
if (idx < 0 || idx >= NUM_FILESYS)
|
||||
return NULL;
|
||||
|
||||
return filesystems[idx].name;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
pathcpy(char *dest, const char *src)
|
||||
{
|
||||
|
|
@ -72,15 +72,14 @@ pathcpy(char *dest, const char *src)
|
|||
return;
|
||||
}
|
||||
++dest;
|
||||
if (ISDIRDELIM(*src)) {
|
||||
|
||||
if (ISDIRDELIM(*src))
|
||||
while (ISDIRDELIM(*src)) src++;
|
||||
} else {
|
||||
else
|
||||
src++;
|
||||
}
|
||||
} while (1);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
file_cd(const char *path)
|
||||
{
|
||||
|
|
@ -141,7 +140,6 @@ file_cd(const char *path)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
file_detectfs(void)
|
||||
{
|
||||
|
|
@ -160,7 +158,6 @@ file_detectfs(void)
|
|||
return current_filesystem;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
file_ls(const char *dir)
|
||||
{
|
||||
|
|
@ -181,7 +178,6 @@ file_ls(const char *dir)
|
|||
return filesystems[current_filesystem].ls(arg);
|
||||
}
|
||||
|
||||
|
||||
long
|
||||
file_read(const char *filename, void *buffer, unsigned long maxsize)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -69,7 +69,8 @@
|
|||
#define DELETED_FLAG ((char)0xe5) /* Marks deleted files when 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
|
||||
*/
|
||||
#define LAST_LONG_ENTRY_MASK 0x40
|
||||
|
|
@ -80,13 +81,6 @@
|
|||
#define LS_DIR 1
|
||||
#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 FSTYPE_NONE (-1)
|
||||
|
|
@ -176,7 +170,8 @@ typedef struct dir_slot {
|
|||
__u8 name11_12[4]; /* Last 2 characters in name */
|
||||
} dir_slot;
|
||||
|
||||
/* Private filesystem parameters
|
||||
/*
|
||||
* Private filesystem parameters
|
||||
*
|
||||
* Note: FAT buffer has to be 32 bit aligned
|
||||
* (see FAT32 accesses)
|
||||
|
|
|
|||
Loading…
Reference in New Issue