Eric Lee / smarc-uboot | Embedian Git Server

Commit 1ad0b98a067a133c0e8a182649a76a4afd739594

Authored by Suriyan Ramasami 2014-11-18 06:39:35 +0800

Committed by Tom Rini 2014-11-23 19:49:04 +0800

Exists in v2017.01-smarct4x and in 37 other branches

fat: Prepare API change for files greater than 2GB

Change the internal FAT functions to use loff_t for offsets.

Signed-off-by: Suriyan Ramasami <suriyan.r@gmail.com>
Acked-by: Simon Glass <sjg@chromium.org>
[trini: Fix fs/fat/fat.c for min3 updates]
Signed-off-by: Tom Rini <trini@ti.com>

Showing 7 changed files with 128 additions and 100 deletions Inline Diff

board/esd/common/auto_update.c
common/cmd_fat.c
common/env_fat.c
fs/fat/fat.c
fs/fat/fat_write.c
fs/fat/file.c
include/fat.h

board/esd/common/auto_update.c

Diff comments View file @ 1ad0b98

 /*
  * (C) Copyright 2003-2004
  * Gary Jennejohn, DENX Software Engineering, garyj@denx.de.
  * Stefan Roese, esd gmbh germany, stefan.roese@esd-electronics.com
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <command.h>
 #include <image.h>
 #include <asm/byteorder.h>
 #include <fat.h>
 #include <flash.h>
 #include <part.h>
 #include "auto_update.h"
 #ifdef CONFIG_AUTO_UPDATE
 #if !defined(CONFIG_CMD_FAT)
 #error "must define CONFIG_CMD_FAT"
 #endif
 extern au_image_t au_image[];
 extern int N_AU_IMAGES;
 /* where to load files into memory */
 #define LOAD_ADDR ((unsigned char *)0x100000)
 #define MAX_LOADSZ 0x1c00000
 /* externals */
-extern int fat_register_device(block_dev_desc_t *, int);
-extern int file_fat_detectfs(void);
-extern long file_fat_read(const char *, void *, unsigned long);
 long do_fat_read (const char *filename, void *buffer,
 		  unsigned long maxsize, int dols);
 extern block_dev_desc_t ide_dev_desc[CONFIG_SYS_IDE_MAXDEVICE];
 int au_check_cksum_valid(int i, long nbytes)
 {
 	image_header_t *hdr;
 	hdr = (image_header_t *)LOAD_ADDR;
 #if defined(CONFIG_FIT)
 	if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) {
 		puts ("Non legacy image format not supported\n");
 		return -1;
 	}
 #endif
 	if ((au_image[i].type == AU_FIRMWARE) &&
 	    (au_image[i].size != image_get_data_size (hdr))) {
 		printf ("Image %s has wrong size\n", au_image[i].name);
 		return -1;
 	}
 	if (nbytes != (image_get_image_size (hdr))) {
 		printf ("Image %s bad total SIZE\n", au_image[i].name);
 		return -1;
 	}
 	/* check the data CRC */
 	if (!image_check_dcrc (hdr)) {
 		printf ("Image %s bad data checksum\n", au_image[i].name);
 		return -1;
 	}
 	return 0;
 }
 int au_check_header_valid(int i, long nbytes)
 {
 	image_header_t *hdr;
 	hdr = (image_header_t *)LOAD_ADDR;
 #if defined(CONFIG_FIT)
 	if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) {
 		puts ("Non legacy image format not supported\n");
 		return -1;
 	}
 #endif
 	/* check the easy ones first */
 	if (nbytes < image_get_header_size ()) {
 		printf ("Image %s bad header SIZE\n", au_image[i].name);
 		return -1;
 	}
 	if (!image_check_magic (hdr) || !image_check_arch (hdr, IH_ARCH_PPC)) {
 		printf ("Image %s bad MAGIC or ARCH\n", au_image[i].name);
 		return -1;
 	}
 	if (!image_check_hcrc (hdr)) {
 		printf ("Image %s bad header checksum\n", au_image[i].name);
 		return -1;
 	}
 	/* check the type - could do this all in one gigantic if() */
 	if (((au_image[i].type & AU_TYPEMASK) == AU_FIRMWARE) &&
 	    !image_check_type (hdr, IH_TYPE_FIRMWARE)) {
 		printf ("Image %s wrong type\n", au_image[i].name);
 		return -1;
 	}
 	if (((au_image[i].type & AU_TYPEMASK) == AU_SCRIPT) &&
 	    !image_check_type (hdr, IH_TYPE_SCRIPT)) {
 		printf ("Image %s wrong type\n", au_image[i].name);
 		return -1;
 	}
 	return 0;
 }
 int au_do_update(int i, long sz)
 {
 	image_header_t *hdr;
 	char *addr;
 	long start, end;
 	int off, rc;
 	uint nbytes;
 	int k;
 	hdr = (image_header_t *)LOAD_ADDR;
 #if defined(CONFIG_FIT)
 	if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) {
 		puts ("Non legacy image format not supported\n");
 		return -1;
 	}
 #endif
 	switch (au_image[i].type & AU_TYPEMASK) {
 	case AU_SCRIPT:
 		printf("Executing script %s\n", au_image[i].name);
 		/* execute a script */
 		if (image_check_type (hdr, IH_TYPE_SCRIPT)) {
 			addr = (char *)((char *)hdr + image_get_header_size ());
 			/* stick a NULL at the end of the script, otherwise */
 			/* parse_string_outer() runs off the end. */
 			addr[image_get_data_size (hdr)] = 0;
 			addr += 8;
 			/*
 			 * Replace cr/lf with ;
 			 */
 			k = 0;
 			while (addr[k] != 0) {
 				if ((addr[k] == 10) || (addr[k] == 13)) {
 					addr[k] = ';';
 				}
 				k++;
 			}
 			run_command(addr, 0);
 			return 0;
 		}
 		break;
 	case AU_FIRMWARE:
 	case AU_NOR:
 	case AU_NAND:
 		start = au_image[i].start;
 		end = au_image[i].start + au_image[i].size - 1;
 		/*
 		 * do not update firmware when image is already in flash.
 		 */
 		if (au_image[i].type == AU_FIRMWARE) {
 			char *orig = (char*)start;
 			char *new  = (char *)((char *)hdr +
 					      image_get_header_size ());
 			nbytes = image_get_data_size (hdr);
 			while (--nbytes) {
 				if (*orig++ != *new++) {
 					break;
 				}
 			}
 			if (!nbytes) {
 				printf ("Skipping firmware update - "
 					"images are identical\n");
 				break;
 			}
 		}
 		/* unprotect the address range */
 		if (((au_image[i].type & AU_FLAGMASK) == AU_PROTECT) ||
 		    (au_image[i].type == AU_FIRMWARE)) {
 			flash_sect_protect (0, start, end);
 		}
 		/*
 		 * erase the address range.
 		 */
 		if (au_image[i].type != AU_NAND) {
 			printf ("Updating NOR FLASH with image %s\n",
 				au_image[i].name);
 			debug ("flash_sect_erase(%lx, %lx);\n", start, end);
 			flash_sect_erase (start, end);
 		}
 		udelay(10000);
 		/* strip the header - except for the kernel and ramdisk */
 		if (au_image[i].type != AU_FIRMWARE) {
 			addr = (char *)hdr;
 			off = image_get_header_size ();
 			nbytes = image_get_image_size (hdr);
 		} else {
 			addr = (char *)((char *)hdr + image_get_header_size ());
 			off = 0;
 			nbytes = image_get_data_size (hdr);
 		}
 		/*
 		 * copy the data from RAM to FLASH
 		 */
 		if (au_image[i].type != AU_NAND) {
 			debug ("flash_write(%p, %lx, %x)\n",
 			       addr, start, nbytes);
 			rc = flash_write ((char *)addr, start,
 					  (nbytes + 1) & ~1);
 		} else {
 			rc = -1;
 		}
 		if (rc != 0) {
 			printf ("Flashing failed due to error %d\n", rc);
 			return -1;
 		}
 		/*
 		 * check the dcrc of the copy
 		 */
 		if (au_image[i].type != AU_NAND) {
 			rc = crc32 (0, (uchar *)(start + off),
 				    image_get_data_size (hdr));
 		}
 		if (rc != image_get_dcrc (hdr)) {
 			printf ("Image %s Bad Data Checksum After COPY\n",
 				au_image[i].name);
 			return -1;
 		}
 		/* protect the address range */
 		/* this assumes that ONLY the firmware is protected! */
 		if (((au_image[i].type & AU_FLAGMASK) == AU_PROTECT) ||
 		    (au_image[i].type == AU_FIRMWARE)) {
 			flash_sect_protect (1, start, end);
 		}
 		break;
 	default:
 		printf("Wrong image type selected!\n");
 	}
 	return 0;
 }
 static void process_macros (const char *input, char *output)
 {
 	char c, prev;
 	const char *varname_start = NULL;
 	int inputcnt  = strlen (input);
 	int outputcnt = CONFIG_SYS_CBSIZE;
 	int state = 0;	/* 0 = waiting for '$'	*/
 			/* 1 = waiting for '(' or '{' */
 			/* 2 = waiting for ')' or '}' */
 			/* 3 = waiting for '''  */
 #ifdef DEBUG_PARSER
 	char *output_start = output;
 	printf ("[PROCESS_MACROS] INPUT len %d: \"%s\"\n",
 		strlen(input), input);
 #endif
 	prev = '\0';			/* previous character */
 	while (inputcnt && outputcnt) {
 	    c = *input++;
 	    inputcnt--;
 	    if (state != 3) {
 	    /* remove one level of escape characters */
 	    if ((c == '\\') && (prev != '\\')) {
 		if (inputcnt-- == 0)
 			break;
 		prev = c;
 		c = *input++;
 	    }
 	    }
 	    switch (state) {
 	    case 0:			/* Waiting for (unescaped) $ */
 		if ((c == '\'') && (prev != '\\')) {
 			state = 3;
 			break;
 		}
 		if ((c == '$') && (prev != '\\')) {
 			state++;
 		} else {
 			*(output++) = c;
 			outputcnt--;
 		}
 		break;
 	    case 1:			/* Waiting for ( */
 		if (c == '(' || c == '{') {
 			state++;
 			varname_start = input;
 		} else {
 			state = 0;
 			*(output++) = '$';
 			outputcnt--;
 			if (outputcnt) {
 				*(output++) = c;
 				outputcnt--;
 			}
 		}
 		break;
 	    case 2:			/* Waiting for )	*/
 		if (c == ')' || c == '}') {
 			int i;
 			char envname[CONFIG_SYS_CBSIZE], *envval;
 			/* Varname # of chars */
 			int envcnt = input - varname_start - 1;
 			/* Get the varname */
 			for (i = 0; i < envcnt; i++) {
 				envname[i] = varname_start[i];
 			}
 			envname[i] = 0;
 			/* Get its value */
 			envval = getenv (envname);
 			/* Copy into the line if it exists */
 			if (envval != NULL)
 				while ((*envval) && outputcnt) {
 					*(output++) = *(envval++);
 					outputcnt--;
 				}
 			/* Look for another '$' */
 			state = 0;
 		}
 		break;
 	    case 3:			/* Waiting for '	*/
 		if ((c == '\'') && (prev != '\\')) {
 			state = 0;
 		} else {
 			*(output++) = c;
 			outputcnt--;
 		}
 		break;
 	    }
 	    prev = c;
 	}
 	if (outputcnt)
 		*output = 0;
 #ifdef DEBUG_PARSER
 	printf ("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n",
 		strlen (output_start), output_start);
 #endif
 }
 /*
  * this is called from board_init() after the hardware has been set up
  * and is usable. That seems like a good time to do this.
  * Right now the return value is ignored.
  */
 int do_auto_update(void)
 {
 	block_dev_desc_t *stor_dev = NULL;
 	long sz;
 	int i, res, old_ctrlc;
 	char buffer[32];
 	char str[80];
 	int n;
 	if  (ide_dev_desc[0].type != DEV_TYPE_UNKNOWN) {
 		stor_dev = get_dev ("ide", 0);
 		if (stor_dev == NULL) {
 			debug ("ide: unknown device\n");
 			return -1;
 		}
 	}
 	if (fat_register_device (stor_dev, 1) != 0) {
 		debug ("Unable to register ide disk 0:1\n");
 		return -1;
 	}
 	/*
 	 * Check if magic file is present
 	 */
 	if ((n = do_fat_read (AU_MAGIC_FILE, buffer,
 			      sizeof(buffer), LS_NO)) <= 0) {
 		debug ("No auto_update magic file (n=%d)\n", n);
 		return -1;
 	}
 #ifdef CONFIG_AUTO_UPDATE_SHOW
 	board_auto_update_show (1);
 #endif
 	puts("\nAutoUpdate Disk detected! Trying to update system...\n");
 	/* make sure that we see CTRL-C and save the old state */
 	old_ctrlc = disable_ctrlc (0);
 	/* just loop thru all the possible files */
 	for (i = 0; i < N_AU_IMAGES; i++) {
 		/*
 		 * Try to expand the environment var in the fname
 		 */
 		process_macros (au_image[i].name, str);
 		strcpy (au_image[i].name, str);
 		printf("Reading %s ...", au_image[i].name);
 		/* just read the header */
 		sz = do_fat_read (au_image[i].name, LOAD_ADDR,
 				  image_get_header_size (), LS_NO);
 		debug ("read %s sz %ld hdr %d\n",
 			au_image[i].name, sz, image_get_header_size ());
 		if (sz <= 0 || sz < image_get_header_size ()) {
 			puts(" not found\n");
 			continue;
 		}
 		if (au_check_header_valid (i, sz) < 0) {
 			puts(" header not valid\n");
 			continue;
 		}
 		sz = do_fat_read (au_image[i].name, LOAD_ADDR,
 				  MAX_LOADSZ, LS_NO);
 		debug ("read %s sz %ld hdr %d\n",
 			au_image[i].name, sz, image_get_header_size ());
 		if (sz <= 0 || sz <= image_get_header_size ()) {
 			puts(" not found\n");
 			continue;
 		}
 		if (au_check_cksum_valid (i, sz) < 0) {
 			puts(" checksum not valid\n");
 			continue;
 		}
 		puts(" done\n");
 		do {
 			res = au_do_update (i, sz);
 			/* let the user break out of the loop */
 			if (ctrlc() || had_ctrlc ()) {
 				clear_ctrlc ();
 				break;
 			}
 		} while (res < 0);
 	}
 	/* restore the old state */
 	disable_ctrlc (old_ctrlc);
 	puts("AutoUpdate finished\n\n");
 #ifdef CONFIG_AUTO_UPDATE_SHOW
 	board_auto_update_show (0);
 #endif
 	return 0;
 }
 int auto_update(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	do_auto_update();
 	return 0;
 }
 U_BOOT_CMD(
 	autoupd,	1,	1,	auto_update,
 	"Automatically update images",
 	""
 );
 #endif /* CONFIG_AUTO_UPDATE */

common/cmd_fat.c

Diff comments View file @ 1ad0b98

 /*
  * (C) Copyright 2002
  * Richard Jones, rjones@nexus-tech.net
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 /*
  * Boot support
  */
 #include <common.h>
 #include <command.h>
 #include <s_record.h>
 #include <net.h>
 #include <ata.h>
 #include <asm/io.h>
 #include <part.h>
 #include <fat.h>
 #include <fs.h>
 int do_fat_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	return do_size(cmdtp, flag, argc, argv, FS_TYPE_FAT);
 }
 U_BOOT_CMD(
 	fatsize,	4,	0,	do_fat_size,
 	"determine a file's size",
 	"<interface> <dev[:part]> <filename>\n"
 	"    - Find file 'filename' from 'dev' on 'interface'\n"
 	"      and determine its size."
 );
 int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	return do_load(cmdtp, flag, argc, argv, FS_TYPE_FAT);
 }
 U_BOOT_CMD(
 	fatload,	7,	0,	do_fat_fsload,
 	"load binary file from a dos filesystem",
 	"<interface> [<dev[:part]> [<addr> [<filename> [bytes [pos]]]]]\n"
 	"    - Load binary file 'filename' from 'dev' on 'interface'\n"
 	"      to address 'addr' from dos filesystem.\n"
 	"      'pos' gives the file position to start loading from.\n"
 	"      If 'pos' is omitted, 0 is used. 'pos' requires 'bytes'.\n"
 	"      'bytes' gives the size to load. If 'bytes' is 0 or omitted,\n"
 	"      the load stops on end of file.\n"
 	"      If either 'pos' or 'bytes' are not aligned to\n"
 	"      ARCH_DMA_MINALIGN then a misaligned buffer warning will\n"
 	"      be printed and performance will suffer for the load."
 );
 static int do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	return do_ls(cmdtp, flag, argc, argv, FS_TYPE_FAT);
 }
 U_BOOT_CMD(
 	fatls,	4,	1,	do_fat_ls,
 	"list files in a directory (default /)",
 	"<interface> [<dev[:part]>] [directory]\n"
 	"    - list files from 'dev' on 'interface' in a 'directory'"
 );
 static int do_fat_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
 			 char * const argv[])
 {
 	int dev, part;
 	block_dev_desc_t *dev_desc;
 	disk_partition_t info;
 	if (argc < 2) {
 		printf("usage: fatinfo <interface> [<dev[:part]>]\n");
 		return 0;
 	}
 	part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1);
 	if (part < 0)
 		return 1;
 	dev = dev_desc->dev;
 	if (fat_set_blk_dev(dev_desc, &info) != 0) {
 		printf("\n** Unable to use %s %d:%d for fatinfo **\n",
 			argv[1], dev, part);
 		return 1;
 	}
 	return file_fat_detectfs();
 }
 U_BOOT_CMD(
 	fatinfo,	3,	1,	do_fat_fsinfo,
 	"print information about filesystem",
 	"<interface> [<dev[:part]>]\n"
 	"    - print information about filesystem from 'dev' on 'interface'"
 );
 #ifdef CONFIG_FAT_WRITE
 static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	long size;
+	loff_t size;
+	int ret;
 	unsigned long addr;
 	unsigned long count;
 	block_dev_desc_t *dev_desc = NULL;
 	disk_partition_t info;
 	int dev = 0;
 	int part = 1;
 	void *buf;
 	if (argc < 5)
 		return cmd_usage(cmdtp);
 	part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1);
 	if (part < 0)
 		return 1;
 	dev = dev_desc->dev;
 	if (fat_set_blk_dev(dev_desc, &info) != 0) {
 		printf("\n** Unable to use %s %d:%d for fatwrite **\n",
 			argv[1], dev, part);
 		return 1;
 	}
 	addr = simple_strtoul(argv[3], NULL, 16);
 	count = simple_strtoul(argv[5], NULL, 16);
 	buf = map_sysmem(addr, count);
-	size = file_fat_write(argv[4], buf, count);
+	ret = file_fat_write(argv[4], buf, 0, count, &size);
 	unmap_sysmem(buf);
-	if (size == -1) {
+	if (ret < 0) {
 		printf("\n** Unable to write \"%s\" from %s %d:%d **\n",
 			argv[4], argv[1], dev, part);
 		return 1;
 	}
-	printf("%ld bytes written\n", size);
+	printf("%llu bytes written\n", size);
 	return 0;
 }
 U_BOOT_CMD(
 	fatwrite,	6,	0,	do_fat_fswrite,
 	"write file into a dos filesystem",
 	"<interface> <dev[:part]> <addr> <filename> <bytes>\n"
 	"    - write file 'filename' from the address 'addr' in RAM\n"
 	"      to 'dev' on 'interface'"
 );
 #endif

common/env_fat.c

Diff comments View file @ 1ad0b98

 /*
  * (c) Copyright 2011 by Tigris Elektronik GmbH
  *
  * Author:
  *  Maximilian Schwerin <mvs@tigris.de>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <command.h>
 #include <environment.h>
 #include <linux/stddef.h>
 #include <malloc.h>
 #include <search.h>
 #include <errno.h>
 #include <fat.h>
 #include <mmc.h>
 char *env_name_spec = "FAT";
 env_t *env_ptr;
 DECLARE_GLOBAL_DATA_PTR;
 int env_init(void)
 {
 	/* use default */
 	gd->env_addr = (ulong)&default_environment[0];
 	gd->env_valid = 1;
 	return 0;
 }
 #ifdef CONFIG_CMD_SAVEENV
 int saveenv(void)
 {
 	env_t	env_new;
 	block_dev_desc_t *dev_desc = NULL;
 	disk_partition_t info;
 	int dev, part;
 	int err;
+	loff_t size;
 	err = env_export(&env_new);
 	if (err)
 		return err;
 	part = get_device_and_partition(FAT_ENV_INTERFACE,
 					FAT_ENV_DEVICE_AND_PART,
 					&dev_desc, &info, 1);
 	if (part < 0)
 		return 1;
 	dev = dev_desc->dev;
 	if (fat_set_blk_dev(dev_desc, &info) != 0) {
 		printf("\n** Unable to use %s %d:%d for saveenv **\n",
 		       FAT_ENV_INTERFACE, dev, part);
 		return 1;
 	}
-	err = file_fat_write(FAT_ENV_FILE, (void *)&env_new, sizeof(env_t));
+	err = file_fat_write(FAT_ENV_FILE, (void *)&env_new, 0, sizeof(env_t),
+			     &size);
 	if (err == -1) {
 		printf("\n** Unable to write \"%s\" from %s%d:%d **\n",
 			FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part);
 		return 1;
 	}
 	puts("done\n");
 	return 0;
 }
 #endif /* CONFIG_CMD_SAVEENV */
 void env_relocate_spec(void)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
 	block_dev_desc_t *dev_desc = NULL;
 	disk_partition_t info;
 	int dev, part;
 	int err;
 	part = get_device_and_partition(FAT_ENV_INTERFACE,
 					FAT_ENV_DEVICE_AND_PART,
 					&dev_desc, &info, 1);
 	if (part < 0)
 		goto err_env_relocate;
 	dev = dev_desc->dev;
 	if (fat_set_blk_dev(dev_desc, &info) != 0) {
 		printf("\n** Unable to use %s %d:%d for loading the env **\n",
 		       FAT_ENV_INTERFACE, dev, part);
 		goto err_env_relocate;
 	}
 	err = file_fat_read(FAT_ENV_FILE, buf, CONFIG_ENV_SIZE);
 	if (err == -1) {
 		printf("\n** Unable to read \"%s\" from %s%d:%d **\n",
 			FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part);
 		goto err_env_relocate;
 	}
 	env_import(buf, 1);
 	return;
 err_env_relocate:
 	set_default_env(NULL);
 }

fs/fat/fat.c

Diff comments View file @ 1ad0b98

1	/*	1	/*
2	* fat.c	2	* fat.c
3	*	3	*
4	* R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg	4	* R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg
5	*	5	*
6	* 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6	6	* 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6
7	* 2003-03-10 - kharris@nexus-tech.net - ported to uboot	7	* 2003-03-10 - kharris@nexus-tech.net - ported to uboot
8	*	8	*
9	* SPDX-License-Identifier: GPL-2.0+	9	* SPDX-License-Identifier: GPL-2.0+
10	*/	10	*/
11		11
12	#include <common.h>	12	#include <common.h>
13	#include <config.h>	13	#include <config.h>
14	#include <exports.h>	14	#include <exports.h>
15	#include <fat.h>	15	#include <fat.h>
16	#include <asm/byteorder.h>	16	#include <asm/byteorder.h>
17	#include <part.h>	17	#include <part.h>
18	#include <malloc.h>	18	#include <malloc.h>
19	#include <linux/compiler.h>	19	#include <linux/compiler.h>
20	#include <linux/ctype.h>	20	#include <linux/ctype.h>
21		21
22	#ifdef CONFIG_SUPPORT_VFAT	22	#ifdef CONFIG_SUPPORT_VFAT
23	static const int vfat_enabled = 1;	23	static const int vfat_enabled = 1;
24	#else	24	#else
25	static const int vfat_enabled = 0;	25	static const int vfat_enabled = 0;
26	#endif	26	#endif
27		27
28	/*	28	/*
29	* Convert a string to lowercase.	29	* Convert a string to lowercase.
30	*/	30	*/
31	static void downcase(char *str)	31	static void downcase(char *str)
32	{	32	{
33	while (*str != '\0') {	33	while (*str != '\0') {
34	str = tolower(str);	34	str = tolower(str);
35	str++;	35	str++;
36	}	36	}
37	}	37	}
38		38
39	static block_dev_desc_t *cur_dev;	39	static block_dev_desc_t *cur_dev;
40	static disk_partition_t cur_part_info;	40	static disk_partition_t cur_part_info;
41		41
42	#define DOS_BOOT_MAGIC_OFFSET 0x1fe	42	#define DOS_BOOT_MAGIC_OFFSET 0x1fe
43	#define DOS_FS_TYPE_OFFSET 0x36	43	#define DOS_FS_TYPE_OFFSET 0x36
44	#define DOS_FS32_TYPE_OFFSET 0x52	44	#define DOS_FS32_TYPE_OFFSET 0x52
45		45
46	static int disk_read(__u32 block, __u32 nr_blocks, void *buf)	46	static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
47	{	47	{
48	if (!cur_dev \|\| !cur_dev->block_read)	48	if (!cur_dev \|\| !cur_dev->block_read)
49	return -1;	49	return -1;
50		50
51	return cur_dev->block_read(cur_dev->dev,	51	return cur_dev->block_read(cur_dev->dev,
52	cur_part_info.start + block, nr_blocks, buf);	52	cur_part_info.start + block, nr_blocks, buf);
53	}	53	}
54		54
55	int fat_set_blk_dev(block_dev_desc_t dev_desc, disk_partition_t info)	55	int fat_set_blk_dev(block_dev_desc_t dev_desc, disk_partition_t info)
56	{	56	{
57	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);	57	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
58		58
59	cur_dev = dev_desc;	59	cur_dev = dev_desc;
60	cur_part_info = *info;	60	cur_part_info = *info;
61		61
62	/* Make sure it has a valid FAT header */	62	/* Make sure it has a valid FAT header */
63	if (disk_read(0, 1, buffer) != 1) {	63	if (disk_read(0, 1, buffer) != 1) {
64	cur_dev = NULL;	64	cur_dev = NULL;
65	return -1;	65	return -1;
66	}	66	}
67		67
68	/* Check if it's actually a DOS volume */	68	/* Check if it's actually a DOS volume */
69	if (memcmp(buffer + DOS_BOOT_MAGIC_OFFSET, "\x55\xAA", 2)) {	69	if (memcmp(buffer + DOS_BOOT_MAGIC_OFFSET, "\x55\xAA", 2)) {
70	cur_dev = NULL;	70	cur_dev = NULL;
71	return -1;	71	return -1;
72	}	72	}
73		73
74	/* Check for FAT12/FAT16/FAT32 filesystem */	74	/* Check for FAT12/FAT16/FAT32 filesystem */
75	if (!memcmp(buffer + DOS_FS_TYPE_OFFSET, "FAT", 3))	75	if (!memcmp(buffer + DOS_FS_TYPE_OFFSET, "FAT", 3))
76	return 0;	76	return 0;
77	if (!memcmp(buffer + DOS_FS32_TYPE_OFFSET, "FAT32", 5))	77	if (!memcmp(buffer + DOS_FS32_TYPE_OFFSET, "FAT32", 5))
78	return 0;	78	return 0;
79		79
80	cur_dev = NULL;	80	cur_dev = NULL;
81	return -1;	81	return -1;
82	}	82	}
83		83
84	int fat_register_device(block_dev_desc_t *dev_desc, int part_no)	84	int fat_register_device(block_dev_desc_t *dev_desc, int part_no)
85	{	85	{
86	disk_partition_t info;	86	disk_partition_t info;
87		87
88	/* First close any currently found FAT filesystem */	88	/* First close any currently found FAT filesystem */
89	cur_dev = NULL;	89	cur_dev = NULL;
90		90
91	/* Read the partition table, if present */	91	/* Read the partition table, if present */
92	if (get_partition_info(dev_desc, part_no, &info)) {	92	if (get_partition_info(dev_desc, part_no, &info)) {
93	if (part_no != 0) {	93	if (part_no != 0) {
94	printf(" Partition %d not valid on device %d \n",	94	printf(" Partition %d not valid on device %d \n",
95	part_no, dev_desc->dev);	95	part_no, dev_desc->dev);
96	return -1;	96	return -1;
97	}	97	}
98		98
99	info.start = 0;	99	info.start = 0;
100	info.size = dev_desc->lba;	100	info.size = dev_desc->lba;
101	info.blksz = dev_desc->blksz;	101	info.blksz = dev_desc->blksz;
102	info.name[0] = 0;	102	info.name[0] = 0;
103	info.type[0] = 0;	103	info.type[0] = 0;
104	info.bootable = 0;	104	info.bootable = 0;
105	#ifdef CONFIG_PARTITION_UUIDS	105	#ifdef CONFIG_PARTITION_UUIDS
106	info.uuid[0] = 0;	106	info.uuid[0] = 0;
107	#endif	107	#endif
108	}	108	}
109		109
110	return fat_set_blk_dev(dev_desc, &info);	110	return fat_set_blk_dev(dev_desc, &info);
111	}	111	}
112		112
113	/*	113	/*
114	* Get the first occurence of a directory delimiter ('/' or '\') in a string.	114	* Get the first occurence of a directory delimiter ('/' or '\') in a string.
115	* Return index into string if found, -1 otherwise.	115	* Return index into string if found, -1 otherwise.
116	*/	116	*/
117	static int dirdelim(char *str)	117	static int dirdelim(char *str)
118	{	118	{
119	char *start = str;	119	char *start = str;
120		120
121	while (*str != '\0') {	121	while (*str != '\0') {
122	if (ISDIRDELIM(*str))	122	if (ISDIRDELIM(*str))
123	return str - start;	123	return str - start;
124	str++;	124	str++;
125	}	125	}
126	return -1;	126	return -1;
127	}	127	}
128		128
129	/*	129	/*
130	* Extract zero terminated short name from a directory entry.	130	* Extract zero terminated short name from a directory entry.
131	*/	131	*/
132	static void get_name(dir_entry dirent, char s_name)	132	static void get_name(dir_entry dirent, char s_name)
133	{	133	{
134	char *ptr;	134	char *ptr;
135		135
136	memcpy(s_name, dirent->name, 8);	136	memcpy(s_name, dirent->name, 8);
137	s_name[8] = '\0';	137	s_name[8] = '\0';
138	ptr = s_name;	138	ptr = s_name;
139	while (ptr && ptr != ' ')	139	while (ptr && ptr != ' ')
140	ptr++;	140	ptr++;
141	if (dirent->ext[0] && dirent->ext[0] != ' ') {	141	if (dirent->ext[0] && dirent->ext[0] != ' ') {
142	*ptr = '.';	142	*ptr = '.';
143	ptr++;	143	ptr++;
144	memcpy(ptr, dirent->ext, 3);	144	memcpy(ptr, dirent->ext, 3);
145	ptr[3] = '\0';	145	ptr[3] = '\0';
146	while (ptr && ptr != ' ')	146	while (ptr && ptr != ' ')
147	ptr++;	147	ptr++;
148	}	148	}
149	*ptr = '\0';	149	*ptr = '\0';
150	if (*s_name == DELETED_FLAG)	150	if (*s_name == DELETED_FLAG)
151	*s_name = '\0';	151	*s_name = '\0';
152	else if (*s_name == aRING)	152	else if (*s_name == aRING)
153	*s_name = DELETED_FLAG;	153	*s_name = DELETED_FLAG;
154	downcase(s_name);	154	downcase(s_name);
155	}	155	}
156		156
157	/*	157	/*
158	* Get the entry at index 'entry' in a FAT (12/16/32) table.	158	* Get the entry at index 'entry' in a FAT (12/16/32) table.
159	* On failure 0x00 is returned.	159	* On failure 0x00 is returned.
160	*/	160	*/
161	static __u32 get_fatent(fsdata *mydata, __u32 entry)	161	static __u32 get_fatent(fsdata *mydata, __u32 entry)
162	{	162	{
163	__u32 bufnum;	163	__u32 bufnum;
164	__u32 off16, offset;	164	__u32 off16, offset;
165	__u32 ret = 0x00;	165	__u32 ret = 0x00;
166	__u16 val1, val2;	166	__u16 val1, val2;
167		167
168	switch (mydata->fatsize) {	168	switch (mydata->fatsize) {
169	case 32:	169	case 32:
170	bufnum = entry / FAT32BUFSIZE;	170	bufnum = entry / FAT32BUFSIZE;
171	offset = entry - bufnum * FAT32BUFSIZE;	171	offset = entry - bufnum * FAT32BUFSIZE;
172	break;	172	break;
173	case 16:	173	case 16:
174	bufnum = entry / FAT16BUFSIZE;	174	bufnum = entry / FAT16BUFSIZE;
175	offset = entry - bufnum * FAT16BUFSIZE;	175	offset = entry - bufnum * FAT16BUFSIZE;
176	break;	176	break;
177	case 12:	177	case 12:
178	bufnum = entry / FAT12BUFSIZE;	178	bufnum = entry / FAT12BUFSIZE;
179	offset = entry - bufnum * FAT12BUFSIZE;	179	offset = entry - bufnum * FAT12BUFSIZE;
180	break;	180	break;
181		181
182	default:	182	default:
183	/* Unsupported FAT size */	183	/* Unsupported FAT size */
184	return ret;	184	return ret;
185	}	185	}
186		186
187	debug("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n",	187	debug("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n",
188	mydata->fatsize, entry, entry, offset, offset);	188	mydata->fatsize, entry, entry, offset, offset);
189		189
190	/* Read a new block of FAT entries into the cache. */	190	/* Read a new block of FAT entries into the cache. */
191	if (bufnum != mydata->fatbufnum) {	191	if (bufnum != mydata->fatbufnum) {
192	__u32 getsize = FATBUFBLOCKS;	192	__u32 getsize = FATBUFBLOCKS;
193	__u8 *bufptr = mydata->fatbuf;	193	__u8 *bufptr = mydata->fatbuf;
194	__u32 fatlength = mydata->fatlength;	194	__u32 fatlength = mydata->fatlength;
195	__u32 startblock = bufnum * FATBUFBLOCKS;	195	__u32 startblock = bufnum * FATBUFBLOCKS;
196		196
197	if (startblock + getsize > fatlength)	197	if (startblock + getsize > fatlength)
198	getsize = fatlength - startblock;	198	getsize = fatlength - startblock;
199		199
200	startblock += mydata->fat_sect; /* Offset from start of disk */	200	startblock += mydata->fat_sect; /* Offset from start of disk */
201		201
202	if (disk_read(startblock, getsize, bufptr) < 0) {	202	if (disk_read(startblock, getsize, bufptr) < 0) {
203	debug("Error reading FAT blocks\n");	203	debug("Error reading FAT blocks\n");
204	return ret;	204	return ret;
205	}	205	}
206	mydata->fatbufnum = bufnum;	206	mydata->fatbufnum = bufnum;
207	}	207	}
208		208
209	/* Get the actual entry from the table */	209	/* Get the actual entry from the table */
210	switch (mydata->fatsize) {	210	switch (mydata->fatsize) {
211	case 32:	211	case 32:
212	ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]);	212	ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]);
213	break;	213	break;
214	case 16:	214	case 16:
215	ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);	215	ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);
216	break;	216	break;
217	case 12:	217	case 12:
218	off16 = (offset * 3) / 4;	218	off16 = (offset * 3) / 4;
219		219
220	switch (offset & 0x3) {	220	switch (offset & 0x3) {
221	case 0:	221	case 0:
222	ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]);	222	ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]);
223	ret &= 0xfff;	223	ret &= 0xfff;
224	break;	224	break;
225	case 1:	225	case 1:
226	val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);	226	val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
227	val1 &= 0xf000;	227	val1 &= 0xf000;
228	val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);	228	val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);
229	val2 &= 0x00ff;	229	val2 &= 0x00ff;
230	ret = (val2 << 4) \| (val1 >> 12);	230	ret = (val2 << 4) \| (val1 >> 12);
231	break;	231	break;
232	case 2:	232	case 2:
233	val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);	233	val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
234	val1 &= 0xff00;	234	val1 &= 0xff00;
235	val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);	235	val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);
236	val2 &= 0x000f;	236	val2 &= 0x000f;
237	ret = (val2 << 8) \| (val1 >> 8);	237	ret = (val2 << 8) \| (val1 >> 8);
238	break;	238	break;
239	case 3:	239	case 3:
240	ret = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);	240	ret = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
241	ret = (ret & 0xfff0) >> 4;	241	ret = (ret & 0xfff0) >> 4;
242	break;	242	break;
243	default:	243	default:
244	break;	244	break;
245	}	245	}
246	break;	246	break;
247	}	247	}
248	debug("FAT%d: ret: %08x, offset: %04x\n",	248	debug("FAT%d: ret: %08x, offset: %04x\n",
249	mydata->fatsize, ret, offset);	249	mydata->fatsize, ret, offset);
250		250
251	return ret;	251	return ret;
252	}	252	}
253		253
254	/*	254	/*
255	* Read at most 'size' bytes from the specified cluster into 'buffer'.	255	* Read at most 'size' bytes from the specified cluster into 'buffer'.
256	* Return 0 on success, -1 otherwise.	256	* Return 0 on success, -1 otherwise.
257	*/	257	*/
258	static int	258	static int
259	get_cluster(fsdata mydata, __u32 clustnum, __u8 buffer, unsigned long size)	259	get_cluster(fsdata mydata, __u32 clustnum, __u8 buffer, unsigned long size)
260	{	260	{
261	__u32 idx = 0;	261	__u32 idx = 0;
262	__u32 startsect;	262	__u32 startsect;
263	int ret;	263	int ret;
264		264
265	if (clustnum > 0) {	265	if (clustnum > 0) {
266	startsect = mydata->data_begin +	266	startsect = mydata->data_begin +
267	clustnum * mydata->clust_size;	267	clustnum * mydata->clust_size;
268	} else {	268	} else {
269	startsect = mydata->rootdir_sect;	269	startsect = mydata->rootdir_sect;
270	}	270	}
271		271
272	debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect);	272	debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect);
273		273
274	if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) {	274	if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) {
275	ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);	275	ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
276		276
277	printf("FAT: Misaligned buffer address (%p)\n", buffer);	277	printf("FAT: Misaligned buffer address (%p)\n", buffer);
278		278
279	while (size >= mydata->sect_size) {	279	while (size >= mydata->sect_size) {
280	ret = disk_read(startsect++, 1, tmpbuf);	280	ret = disk_read(startsect++, 1, tmpbuf);
281	if (ret != 1) {	281	if (ret != 1) {
282	debug("Error reading data (got %d)\n", ret);	282	debug("Error reading data (got %d)\n", ret);
283	return -1;	283	return -1;
284	}	284	}
285		285
286	memcpy(buffer, tmpbuf, mydata->sect_size);	286	memcpy(buffer, tmpbuf, mydata->sect_size);
287	buffer += mydata->sect_size;	287	buffer += mydata->sect_size;
288	size -= mydata->sect_size;	288	size -= mydata->sect_size;
289	}	289	}
290	} else {	290	} else {
291	idx = size / mydata->sect_size;	291	idx = size / mydata->sect_size;
292	ret = disk_read(startsect, idx, buffer);	292	ret = disk_read(startsect, idx, buffer);
293	if (ret != idx) {	293	if (ret != idx) {
294	debug("Error reading data (got %d)\n", ret);	294	debug("Error reading data (got %d)\n", ret);
295	return -1;	295	return -1;
296	}	296	}
297	startsect += idx;	297	startsect += idx;
298	idx *= mydata->sect_size;	298	idx *= mydata->sect_size;
299	buffer += idx;	299	buffer += idx;
300	size -= idx;	300	size -= idx;
301	}	301	}
302	if (size) {	302	if (size) {
303	ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);	303	ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
304		304
305	ret = disk_read(startsect, 1, tmpbuf);	305	ret = disk_read(startsect, 1, tmpbuf);
306	if (ret != 1) {	306	if (ret != 1) {
307	debug("Error reading data (got %d)\n", ret);	307	debug("Error reading data (got %d)\n", ret);
308	return -1;	308	return -1;
309	}	309	}
310		310
311	memcpy(buffer, tmpbuf, size);	311	memcpy(buffer, tmpbuf, size);
312	}	312	}
313		313
314	return 0;	314	return 0;
315	}	315	}
316		316
317	/*	317	/*
318	* Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr'	318	* Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr'
319	* into 'buffer'.	319	* into 'buffer'.
320	* Return the number of bytes read or -1 on fatal errors.	320	* Update the number of bytes read in *gotsize or return -1 on fatal errors.
321	*/	321	*/
322	__u8 get_contents_vfatname_block[MAX_CLUSTSIZE]	322	__u8 get_contents_vfatname_block[MAX_CLUSTSIZE]
323	__aligned(ARCH_DMA_MINALIGN);	323	__aligned(ARCH_DMA_MINALIGN);
324		324
325	static long	325	static int get_contents(fsdata mydata, dir_entry dentptr, loff_t pos,
326	get_contents(fsdata mydata, dir_entry dentptr, unsigned long pos,	326	__u8 buffer, loff_t maxsize, loff_t gotsize)
327	__u8 *buffer, unsigned long maxsize)
328	{	327	{
329	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;	328	loff_t filesize = FAT2CPU32(dentptr->size);
330	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;	329	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
331	__u32 curclust = START(dentptr);	330	__u32 curclust = START(dentptr);
332	__u32 endclust, newclust;	331	__u32 endclust, newclust;
333	unsigned long actsize;	332	loff_t actsize;
334		333
335	debug("Filesize: %ld bytes\n", filesize);	334	*gotsize = 0;
		335	debug("Filesize: %llu bytes\n", filesize);
336		336
337	if (pos >= filesize) {	337	if (pos >= filesize) {
338	debug("Read position past EOF: %lu\n", pos);	338	debug("Read position past EOF: %llu\n", pos);
339	return gotsize;	339	return 0;
340	}	340	}
341		341
342	if (maxsize > 0 && filesize > pos + maxsize)	342	if (maxsize > 0 && filesize > pos + maxsize)
343	filesize = pos + maxsize;	343	filesize = pos + maxsize;
344		344
345	debug("%ld bytes\n", filesize);	345	debug("%llu bytes\n", filesize);
346		346
347	actsize = bytesperclust;	347	actsize = bytesperclust;
348		348
349	/* go to cluster at pos */	349	/* go to cluster at pos */
350	while (actsize <= pos) {	350	while (actsize <= pos) {
351	curclust = get_fatent(mydata, curclust);	351	curclust = get_fatent(mydata, curclust);
352	if (CHECK_CLUST(curclust, mydata->fatsize)) {	352	if (CHECK_CLUST(curclust, mydata->fatsize)) {
353	debug("curclust: 0x%x\n", curclust);	353	debug("curclust: 0x%x\n", curclust);
354	debug("Invalid FAT entry\n");	354	debug("Invalid FAT entry\n");
355	return gotsize;	355	return 0;
356	}	356	}
357	actsize += bytesperclust;	357	actsize += bytesperclust;
358	}	358	}
359		359
360	/* actsize > pos */	360	/* actsize > pos */
361	actsize -= bytesperclust;	361	actsize -= bytesperclust;
362	filesize -= actsize;	362	filesize -= actsize;
363	pos -= actsize;	363	pos -= actsize;
364		364
365	/* align to beginning of next cluster if any */	365	/* align to beginning of next cluster if any */
366	if (pos) {	366	if (pos) {
367	actsize = min(filesize, (unsigned long)bytesperclust);	367	actsize = min(filesize, (loff_t)bytesperclust);
368	if (get_cluster(mydata, curclust, get_contents_vfatname_block,	368	if (get_cluster(mydata, curclust, get_contents_vfatname_block,
369	(int)actsize) != 0) {	369	(int)actsize) != 0) {
370	printf("Error reading cluster\n");	370	printf("Error reading cluster\n");
371	return -1;	371	return -1;
372	}	372	}
373	filesize -= actsize;	373	filesize -= actsize;
374	actsize -= pos;	374	actsize -= pos;
375	memcpy(buffer, get_contents_vfatname_block + pos, actsize);	375	memcpy(buffer, get_contents_vfatname_block + pos, actsize);
376	gotsize += actsize;	376	*gotsize += actsize;
377	if (!filesize)	377	if (!filesize)
378	return gotsize;	378	return 0;
379	buffer += actsize;	379	buffer += actsize;
380		380
381	curclust = get_fatent(mydata, curclust);	381	curclust = get_fatent(mydata, curclust);
382	if (CHECK_CLUST(curclust, mydata->fatsize)) {	382	if (CHECK_CLUST(curclust, mydata->fatsize)) {
383	debug("curclust: 0x%x\n", curclust);	383	debug("curclust: 0x%x\n", curclust);
384	debug("Invalid FAT entry\n");	384	debug("Invalid FAT entry\n");
385	return gotsize;	385	return 0;
386	}	386	}
387	}	387	}
388		388
389	actsize = bytesperclust;	389	actsize = bytesperclust;
390	endclust = curclust;	390	endclust = curclust;
391		391
392	do {	392	do {
393	/* search for consecutive clusters */	393	/* search for consecutive clusters */
394	while (actsize < filesize) {	394	while (actsize < filesize) {
395	newclust = get_fatent(mydata, endclust);	395	newclust = get_fatent(mydata, endclust);
396	if ((newclust - 1) != endclust)	396	if ((newclust - 1) != endclust)
397	goto getit;	397	goto getit;
398	if (CHECK_CLUST(newclust, mydata->fatsize)) {	398	if (CHECK_CLUST(newclust, mydata->fatsize)) {
399	debug("curclust: 0x%x\n", newclust);	399	debug("curclust: 0x%x\n", newclust);
400	debug("Invalid FAT entry\n");	400	debug("Invalid FAT entry\n");
401	return gotsize;	401	return 0;
402	}	402	}
403	endclust = newclust;	403	endclust = newclust;
404	actsize += bytesperclust;	404	actsize += bytesperclust;
405	}	405	}
406		406
407	/* get remaining bytes */	407	/* get remaining bytes */
408	actsize = filesize;	408	actsize = filesize;
409	if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {	409	if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
410	printf("Error reading cluster\n");	410	printf("Error reading cluster\n");
411	return -1;	411	return -1;
412	}	412	}
413	gotsize += actsize;	413	*gotsize += actsize;
414	return gotsize;	414	return 0;
415	getit:	415	getit:
416	if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {	416	if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
417	printf("Error reading cluster\n");	417	printf("Error reading cluster\n");
418	return -1;	418	return -1;
419	}	419	}
420	gotsize += (int)actsize;	420	*gotsize += (int)actsize;
421	filesize -= actsize;	421	filesize -= actsize;
422	buffer += actsize;	422	buffer += actsize;
423		423
424	curclust = get_fatent(mydata, endclust);	424	curclust = get_fatent(mydata, endclust);
425	if (CHECK_CLUST(curclust, mydata->fatsize)) {	425	if (CHECK_CLUST(curclust, mydata->fatsize)) {
426	debug("curclust: 0x%x\n", curclust);	426	debug("curclust: 0x%x\n", curclust);
427	printf("Invalid FAT entry\n");	427	printf("Invalid FAT entry\n");
428	return gotsize;	428	return 0;
429	}	429	}
430	actsize = bytesperclust;	430	actsize = bytesperclust;
431	endclust = curclust;	431	endclust = curclust;
432	} while (1);	432	} while (1);
433	}	433	}
434		434
435	/*	435	/*
436	* Extract the file name information from 'slotptr' into 'l_name',	436	* Extract the file name information from 'slotptr' into 'l_name',
437	* starting at l_name[*idx].	437	* starting at l_name[*idx].
438	* Return 1 if terminator (zero byte) is found, 0 otherwise.	438	* Return 1 if terminator (zero byte) is found, 0 otherwise.
439	*/	439	*/
440	static int slot2str(dir_slot slotptr, char l_name, int *idx)	440	static int slot2str(dir_slot slotptr, char l_name, int *idx)
441	{	441	{
442	int j;	442	int j;
443		443
444	for (j = 0; j <= 8; j += 2) {	444	for (j = 0; j <= 8; j += 2) {
445	l_name[*idx] = slotptr->name0_4[j];	445	l_name[*idx] = slotptr->name0_4[j];
446	if (l_name[*idx] == 0x00)	446	if (l_name[*idx] == 0x00)
447	return 1;	447	return 1;
448	(*idx)++;	448	(*idx)++;
449	}	449	}
450	for (j = 0; j <= 10; j += 2) {	450	for (j = 0; j <= 10; j += 2) {
451	l_name[*idx] = slotptr->name5_10[j];	451	l_name[*idx] = slotptr->name5_10[j];
452	if (l_name[*idx] == 0x00)	452	if (l_name[*idx] == 0x00)
453	return 1;	453	return 1;
454	(*idx)++;	454	(*idx)++;
455	}	455	}
456	for (j = 0; j <= 2; j += 2) {	456	for (j = 0; j <= 2; j += 2) {
457	l_name[*idx] = slotptr->name11_12[j];	457	l_name[*idx] = slotptr->name11_12[j];
458	if (l_name[*idx] == 0x00)	458	if (l_name[*idx] == 0x00)
459	return 1;	459	return 1;
460	(*idx)++;	460	(*idx)++;
461	}	461	}
462		462
463	return 0;	463	return 0;
464	}	464	}
465		465
466	/*	466	/*
467	* Extract the full long filename starting at 'retdent' (which is really	467	* Extract the full long filename starting at 'retdent' (which is really
468	* a slot) into 'l_name'. If successful also copy the real directory entry	468	* a slot) into 'l_name'. If successful also copy the real directory entry
469	* into 'retdent'	469	* into 'retdent'
470	* Return 0 on success, -1 otherwise.	470	* Return 0 on success, -1 otherwise.
471	*/	471	*/
472	static int	472	static int
473	get_vfatname(fsdata mydata, int curclust, __u8 cluster,	473	get_vfatname(fsdata mydata, int curclust, __u8 cluster,
474	dir_entry retdent, char l_name)	474	dir_entry retdent, char l_name)
475	{	475	{
476	dir_entry *realdent;	476	dir_entry *realdent;
477	dir_slot slotptr = (dir_slot )retdent;	477	dir_slot slotptr = (dir_slot )retdent;
478	__u8 buflimit = cluster + mydata->sect_size ((curclust == 0) ?	478	__u8 buflimit = cluster + mydata->sect_size ((curclust == 0) ?
479	PREFETCH_BLOCKS :	479	PREFETCH_BLOCKS :
480	mydata->clust_size);	480	mydata->clust_size);
481	__u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff;	481	__u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff;
482	int idx = 0;	482	int idx = 0;
483		483
484	if (counter > VFAT_MAXSEQ) {	484	if (counter > VFAT_MAXSEQ) {
485	debug("Error: VFAT name is too long\n");	485	debug("Error: VFAT name is too long\n");
486	return -1;	486	return -1;
487	}	487	}
488		488
489	while ((__u8 *)slotptr < buflimit) {	489	while ((__u8 *)slotptr < buflimit) {
490	if (counter == 0)	490	if (counter == 0)
491	break;	491	break;
492	if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)	492	if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
493	return -1;	493	return -1;
494	slotptr++;	494	slotptr++;
495	counter--;	495	counter--;
496	}	496	}
497		497
498	if ((__u8 *)slotptr >= buflimit) {	498	if ((__u8 *)slotptr >= buflimit) {
499	dir_slot *slotptr2;	499	dir_slot *slotptr2;
500		500
501	if (curclust == 0)	501	if (curclust == 0)
502	return -1;	502	return -1;
503	curclust = get_fatent(mydata, curclust);	503	curclust = get_fatent(mydata, curclust);
504	if (CHECK_CLUST(curclust, mydata->fatsize)) {	504	if (CHECK_CLUST(curclust, mydata->fatsize)) {
505	debug("curclust: 0x%x\n", curclust);	505	debug("curclust: 0x%x\n", curclust);
506	printf("Invalid FAT entry\n");	506	printf("Invalid FAT entry\n");
507	return -1;	507	return -1;
508	}	508	}
509		509
510	if (get_cluster(mydata, curclust, get_contents_vfatname_block,	510	if (get_cluster(mydata, curclust, get_contents_vfatname_block,
511	mydata->clust_size * mydata->sect_size) != 0) {	511	mydata->clust_size * mydata->sect_size) != 0) {
512	debug("Error: reading directory block\n");	512	debug("Error: reading directory block\n");
513	return -1;	513	return -1;
514	}	514	}
515		515
516	slotptr2 = (dir_slot *)get_contents_vfatname_block;	516	slotptr2 = (dir_slot *)get_contents_vfatname_block;
517	while (counter > 0) {	517	while (counter > 0) {
518	if (((slotptr2->id & ~LAST_LONG_ENTRY_MASK)	518	if (((slotptr2->id & ~LAST_LONG_ENTRY_MASK)
519	& 0xff) != counter)	519	& 0xff) != counter)
520	return -1;	520	return -1;
521	slotptr2++;	521	slotptr2++;
522	counter--;	522	counter--;
523	}	523	}
524		524
525	/* Save the real directory entry */	525	/* Save the real directory entry */
526	realdent = (dir_entry *)slotptr2;	526	realdent = (dir_entry *)slotptr2;
527	while ((__u8 *)slotptr2 > get_contents_vfatname_block) {	527	while ((__u8 *)slotptr2 > get_contents_vfatname_block) {
528	slotptr2--;	528	slotptr2--;
529	slot2str(slotptr2, l_name, &idx);	529	slot2str(slotptr2, l_name, &idx);
530	}	530	}
531	} else {	531	} else {
532	/* Save the real directory entry */	532	/* Save the real directory entry */
533	realdent = (dir_entry *)slotptr;	533	realdent = (dir_entry *)slotptr;
534	}	534	}
535		535
536	do {	536	do {
537	slotptr--;	537	slotptr--;
538	if (slot2str(slotptr, l_name, &idx))	538	if (slot2str(slotptr, l_name, &idx))
539	break;	539	break;
540	} while (!(slotptr->id & LAST_LONG_ENTRY_MASK));	540	} while (!(slotptr->id & LAST_LONG_ENTRY_MASK));
541		541
542	l_name[idx] = '\0';	542	l_name[idx] = '\0';
543	if (*l_name == DELETED_FLAG)	543	if (*l_name == DELETED_FLAG)
544	*l_name = '\0';	544	*l_name = '\0';
545	else if (*l_name == aRING)	545	else if (*l_name == aRING)
546	*l_name = DELETED_FLAG;	546	*l_name = DELETED_FLAG;
547	downcase(l_name);	547	downcase(l_name);
548		548
549	/* Return the real directory entry */	549	/* Return the real directory entry */
550	memcpy(retdent, realdent, sizeof(dir_entry));	550	memcpy(retdent, realdent, sizeof(dir_entry));
551		551
552	return 0;	552	return 0;
553	}	553	}
554		554
555	/* Calculate short name checksum */	555	/* Calculate short name checksum */
556	static __u8 mkcksum(const char name[8], const char ext[3])	556	static __u8 mkcksum(const char name[8], const char ext[3])
557	{	557	{
558	int i;	558	int i;
559		559
560	__u8 ret = 0;	560	__u8 ret = 0;
561		561
562	for (i = 0; i < 8; i++)	562	for (i = 0; i < 8; i++)
563	ret = (((ret & 1) << 7) \| ((ret & 0xfe) >> 1)) + name[i];	563	ret = (((ret & 1) << 7) \| ((ret & 0xfe) >> 1)) + name[i];
564	for (i = 0; i < 3; i++)	564	for (i = 0; i < 3; i++)
565	ret = (((ret & 1) << 7) \| ((ret & 0xfe) >> 1)) + ext[i];	565	ret = (((ret & 1) << 7) \| ((ret & 0xfe) >> 1)) + ext[i];
566		566
567	return ret;	567	return ret;
568	}	568	}
569		569
570	/*	570	/*
571	* Get the directory entry associated with 'filename' from the directory	571	* Get the directory entry associated with 'filename' from the directory
572	* starting at 'startsect'	572	* starting at 'startsect'
573	*/	573	*/
574	__u8 get_dentfromdir_block[MAX_CLUSTSIZE]	574	__u8 get_dentfromdir_block[MAX_CLUSTSIZE]
575	__aligned(ARCH_DMA_MINALIGN);	575	__aligned(ARCH_DMA_MINALIGN);
576		576
577	static dir_entry get_dentfromdir(fsdata mydata, int startsect,	577	static dir_entry get_dentfromdir(fsdata mydata, int startsect,
578	char filename, dir_entry retdent,	578	char filename, dir_entry retdent,
579	int dols)	579	int dols)
580	{	580	{
581	__u16 prevcksum = 0xffff;	581	__u16 prevcksum = 0xffff;
582	__u32 curclust = START(retdent);	582	__u32 curclust = START(retdent);
583	int files = 0, dirs = 0;	583	int files = 0, dirs = 0;
584		584
585	debug("get_dentfromdir: %s\n", filename);	585	debug("get_dentfromdir: %s\n", filename);
586		586
587	while (1) {	587	while (1) {
588	dir_entry *dentptr;	588	dir_entry *dentptr;
589		589
590	int i;	590	int i;
591		591
592	if (get_cluster(mydata, curclust, get_dentfromdir_block,	592	if (get_cluster(mydata, curclust, get_dentfromdir_block,
593	mydata->clust_size * mydata->sect_size) != 0) {	593	mydata->clust_size * mydata->sect_size) != 0) {
594	debug("Error: reading directory block\n");	594	debug("Error: reading directory block\n");
595	return NULL;	595	return NULL;
596	}	596	}
597		597
598	dentptr = (dir_entry *)get_dentfromdir_block;	598	dentptr = (dir_entry *)get_dentfromdir_block;
599		599
600	for (i = 0; i < DIRENTSPERCLUST; i++) {	600	for (i = 0; i < DIRENTSPERCLUST; i++) {
601	char s_name[14], l_name[VFAT_MAXLEN_BYTES];	601	char s_name[14], l_name[VFAT_MAXLEN_BYTES];
602		602
603	l_name[0] = '\0';	603	l_name[0] = '\0';
604	if (dentptr->name[0] == DELETED_FLAG) {	604	if (dentptr->name[0] == DELETED_FLAG) {
605	dentptr++;	605	dentptr++;
606	continue;	606	continue;
607	}	607	}
608	if ((dentptr->attr & ATTR_VOLUME)) {	608	if ((dentptr->attr & ATTR_VOLUME)) {
609	if (vfat_enabled &&	609	if (vfat_enabled &&
610	(dentptr->attr & ATTR_VFAT) == ATTR_VFAT &&	610	(dentptr->attr & ATTR_VFAT) == ATTR_VFAT &&
611	(dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {	611	(dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
612	prevcksum = ((dir_slot *)dentptr)->alias_checksum;	612	prevcksum = ((dir_slot *)dentptr)->alias_checksum;
613	get_vfatname(mydata, curclust,	613	get_vfatname(mydata, curclust,
614	get_dentfromdir_block,	614	get_dentfromdir_block,
615	dentptr, l_name);	615	dentptr, l_name);
616	if (dols) {	616	if (dols) {
617	int isdir;	617	int isdir;
618	char dirc;	618	char dirc;
619	int doit = 0;	619	int doit = 0;
620		620
621	isdir = (dentptr->attr & ATTR_DIR);	621	isdir = (dentptr->attr & ATTR_DIR);
622		622
623	if (isdir) {	623	if (isdir) {
624	dirs++;	624	dirs++;
625	dirc = '/';	625	dirc = '/';
626	doit = 1;	626	doit = 1;
627	} else {	627	} else {
628	dirc = ' ';	628	dirc = ' ';
629	if (l_name[0] != 0) {	629	if (l_name[0] != 0) {
630	files++;	630	files++;
631	doit = 1;	631	doit = 1;
632	}	632	}
633	}	633	}
634	if (doit) {	634	if (doit) {
635	if (dirc == ' ') {	635	if (dirc == ' ') {
636	printf(" %8ld %s%c\n",	636	printf(" %8u %s%c\n",
637	(long)FAT2CPU32(dentptr->size),	637	FAT2CPU32(dentptr->size),
638	l_name,	638	l_name,
639	dirc);	639	dirc);
640	} else {	640	} else {
641	printf(" %s%c\n",	641	printf(" %s%c\n",
642	l_name,	642	l_name,
643	dirc);	643	dirc);
644	}	644	}
645	}	645	}
646	dentptr++;	646	dentptr++;
647	continue;	647	continue;
648	}	648	}
649	debug("vfatname: \|%s\|\n", l_name);	649	debug("vfatname: \|%s\|\n", l_name);
650	} else {	650	} else {
651	/* Volume label or VFAT entry */	651	/* Volume label or VFAT entry */
652	dentptr++;	652	dentptr++;
653	continue;	653	continue;
654	}	654	}
655	}	655	}
656	if (dentptr->name[0] == 0) {	656	if (dentptr->name[0] == 0) {
657	if (dols) {	657	if (dols) {
658	printf("\n%d file(s), %d dir(s)\n\n",	658	printf("\n%d file(s), %d dir(s)\n\n",
659	files, dirs);	659	files, dirs);
660	}	660	}
661	debug("Dentname == NULL - %d\n", i);	661	debug("Dentname == NULL - %d\n", i);
662	return NULL;	662	return NULL;
663	}	663	}
664	if (vfat_enabled) {	664	if (vfat_enabled) {
665	__u8 csum = mkcksum(dentptr->name, dentptr->ext);	665	__u8 csum = mkcksum(dentptr->name, dentptr->ext);
666	if (dols && csum == prevcksum) {	666	if (dols && csum == prevcksum) {
667	prevcksum = 0xffff;	667	prevcksum = 0xffff;
668	dentptr++;	668	dentptr++;
669	continue;	669	continue;
670	}	670	}
671	}	671	}
672		672
673	get_name(dentptr, s_name);	673	get_name(dentptr, s_name);
674	if (dols) {	674	if (dols) {
675	int isdir = (dentptr->attr & ATTR_DIR);	675	int isdir = (dentptr->attr & ATTR_DIR);
676	char dirc;	676	char dirc;
677	int doit = 0;	677	int doit = 0;
678		678
679	if (isdir) {	679	if (isdir) {
680	dirs++;	680	dirs++;
681	dirc = '/';	681	dirc = '/';
682	doit = 1;	682	doit = 1;
683	} else {	683	} else {
684	dirc = ' ';	684	dirc = ' ';
685	if (s_name[0] != 0) {	685	if (s_name[0] != 0) {
686	files++;	686	files++;
687	doit = 1;	687	doit = 1;
688	}	688	}
689	}	689	}
690		690
691	if (doit) {	691	if (doit) {
692	if (dirc == ' ') {	692	if (dirc == ' ') {
693	printf(" %8ld %s%c\n",	693	printf(" %8u %s%c\n",
694	(long)FAT2CPU32(dentptr->size),	694	FAT2CPU32(dentptr->size),
695	s_name, dirc);	695	s_name, dirc);
696	} else {	696	} else {
697	printf(" %s%c\n",	697	printf(" %s%c\n",
698	s_name, dirc);	698	s_name, dirc);
699	}	699	}
700	}	700	}
701		701
702	dentptr++;	702	dentptr++;
703	continue;	703	continue;
704	}	704	}
705		705
706	if (strcmp(filename, s_name)	706	if (strcmp(filename, s_name)
707	&& strcmp(filename, l_name)) {	707	&& strcmp(filename, l_name)) {
708	debug("Mismatch: \|%s\|%s\|\n", s_name, l_name);	708	debug("Mismatch: \|%s\|%s\|\n", s_name, l_name);
709	dentptr++;	709	dentptr++;
710	continue;	710	continue;
711	}	711	}
712		712
713	memcpy(retdent, dentptr, sizeof(dir_entry));	713	memcpy(retdent, dentptr, sizeof(dir_entry));
714		714
715	debug("DentName: %s", s_name);	715	debug("DentName: %s", s_name);
716	debug(", start: 0x%x", START(dentptr));	716	debug(", start: 0x%x", START(dentptr));
717	debug(", size: 0x%x %s\n",	717	debug(", size: 0x%x %s\n",
718	FAT2CPU32(dentptr->size),	718	FAT2CPU32(dentptr->size),
719	(dentptr->attr & ATTR_DIR) ? "(DIR)" : "");	719	(dentptr->attr & ATTR_DIR) ? "(DIR)" : "");
720		720
721	return retdent;	721	return retdent;
722	}	722	}
723		723
724	curclust = get_fatent(mydata, curclust);	724	curclust = get_fatent(mydata, curclust);
725	if (CHECK_CLUST(curclust, mydata->fatsize)) {	725	if (CHECK_CLUST(curclust, mydata->fatsize)) {
726	debug("curclust: 0x%x\n", curclust);	726	debug("curclust: 0x%x\n", curclust);
727	printf("Invalid FAT entry\n");	727	printf("Invalid FAT entry\n");
728	return NULL;	728	return NULL;
729	}	729	}
730	}	730	}
731		731
732	return NULL;	732	return NULL;
733	}	733	}
734		734
735	/*	735	/*
736	* Read boot sector and volume info from a FAT filesystem	736	* Read boot sector and volume info from a FAT filesystem
737	*/	737	*/
738	static int	738	static int
739	read_bootsectandvi(boot_sector bs, volume_info volinfo, int *fatsize)	739	read_bootsectandvi(boot_sector bs, volume_info volinfo, int *fatsize)
740	{	740	{
741	__u8 *block;	741	__u8 *block;
742	volume_info *vistart;	742	volume_info *vistart;
743	int ret = 0;	743	int ret = 0;
744		744
745	if (cur_dev == NULL) {	745	if (cur_dev == NULL) {
746	debug("Error: no device selected\n");	746	debug("Error: no device selected\n");
747	return -1;	747	return -1;
748	}	748	}
749		749
750	block = memalign(ARCH_DMA_MINALIGN, cur_dev->blksz);	750	block = memalign(ARCH_DMA_MINALIGN, cur_dev->blksz);
751	if (block == NULL) {	751	if (block == NULL) {
752	debug("Error: allocating block\n");	752	debug("Error: allocating block\n");
753	return -1;	753	return -1;
754	}	754	}
755		755
756	if (disk_read(0, 1, block) < 0) {	756	if (disk_read(0, 1, block) < 0) {
757	debug("Error: reading block\n");	757	debug("Error: reading block\n");
758	goto fail;	758	goto fail;
759	}	759	}
760		760
761	memcpy(bs, block, sizeof(boot_sector));	761	memcpy(bs, block, sizeof(boot_sector));
762	bs->reserved = FAT2CPU16(bs->reserved);	762	bs->reserved = FAT2CPU16(bs->reserved);
763	bs->fat_length = FAT2CPU16(bs->fat_length);	763	bs->fat_length = FAT2CPU16(bs->fat_length);
764	bs->secs_track = FAT2CPU16(bs->secs_track);	764	bs->secs_track = FAT2CPU16(bs->secs_track);
765	bs->heads = FAT2CPU16(bs->heads);	765	bs->heads = FAT2CPU16(bs->heads);
766	bs->total_sect = FAT2CPU32(bs->total_sect);	766	bs->total_sect = FAT2CPU32(bs->total_sect);
767		767
768	/* FAT32 entries */	768	/* FAT32 entries */
769	if (bs->fat_length == 0) {	769	if (bs->fat_length == 0) {
770	/* Assume FAT32 */	770	/* Assume FAT32 */
771	bs->fat32_length = FAT2CPU32(bs->fat32_length);	771	bs->fat32_length = FAT2CPU32(bs->fat32_length);
772	bs->flags = FAT2CPU16(bs->flags);	772	bs->flags = FAT2CPU16(bs->flags);
773	bs->root_cluster = FAT2CPU32(bs->root_cluster);	773	bs->root_cluster = FAT2CPU32(bs->root_cluster);
774	bs->info_sector = FAT2CPU16(bs->info_sector);	774	bs->info_sector = FAT2CPU16(bs->info_sector);
775	bs->backup_boot = FAT2CPU16(bs->backup_boot);	775	bs->backup_boot = FAT2CPU16(bs->backup_boot);
776	vistart = (volume_info *)(block + sizeof(boot_sector));	776	vistart = (volume_info *)(block + sizeof(boot_sector));
777	*fatsize = 32;	777	*fatsize = 32;
778	} else {	778	} else {
779	vistart = (volume_info *)&(bs->fat32_length);	779	vistart = (volume_info *)&(bs->fat32_length);
780	*fatsize = 0;	780	*fatsize = 0;
781	}	781	}
782	memcpy(volinfo, vistart, sizeof(volume_info));	782	memcpy(volinfo, vistart, sizeof(volume_info));
783		783
784	if (*fatsize == 32) {	784	if (*fatsize == 32) {
785	if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0)	785	if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0)
786	goto exit;	786	goto exit;
787	} else {	787	} else {
788	if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) {	788	if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) {
789	*fatsize = 12;	789	*fatsize = 12;
790	goto exit;	790	goto exit;
791	}	791	}
792	if (strncmp(FAT16_SIGN, vistart->fs_type, SIGNLEN) == 0) {	792	if (strncmp(FAT16_SIGN, vistart->fs_type, SIGNLEN) == 0) {
793	*fatsize = 16;	793	*fatsize = 16;
794	goto exit;	794	goto exit;
795	}	795	}
796	}	796	}
797		797
798	debug("Error: broken fs_type sign\n");	798	debug("Error: broken fs_type sign\n");
799	fail:	799	fail:
800	ret = -1;	800	ret = -1;
801	exit:	801	exit:
802	free(block);	802	free(block);
803	return ret;	803	return ret;
804	}	804	}
805		805
806	__u8 do_fat_read_at_block[MAX_CLUSTSIZE]	806	__u8 do_fat_read_at_block[MAX_CLUSTSIZE]
807	__aligned(ARCH_DMA_MINALIGN);	807	__aligned(ARCH_DMA_MINALIGN);
808		808
809	long	809	int do_fat_read_at(const char filename, loff_t pos, void buffer,
810	do_fat_read_at(const char filename, unsigned long pos, void buffer,	810	loff_t maxsize, int dols, int dogetsize, loff_t *size)
811	unsigned long maxsize, int dols, int dogetsize)
812	{	811	{
813	char fnamecopy[2048];	812	char fnamecopy[2048];
814	boot_sector bs;	813	boot_sector bs;
815	volume_info volinfo;	814	volume_info volinfo;
816	fsdata datablock;	815	fsdata datablock;
817	fsdata *mydata = &datablock;	816	fsdata *mydata = &datablock;
818	dir_entry *dentptr = NULL;	817	dir_entry *dentptr = NULL;
819	__u16 prevcksum = 0xffff;	818	__u16 prevcksum = 0xffff;
820	char *subname = "";	819	char *subname = "";
821	__u32 cursect;	820	__u32 cursect;
822	int idx, isdir = 0;	821	int idx, isdir = 0;
823	int files = 0, dirs = 0;	822	int files = 0, dirs = 0;
824	long ret = -1;	823	int ret = -1;
825	int firsttime;	824	int firsttime;
826	__u32 root_cluster = 0;	825	__u32 root_cluster = 0;
827	int rootdir_size = 0;	826	int rootdir_size = 0;
828	int j;	827	int j;
829		828
830	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {	829	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
831	debug("Error: reading boot sector\n");	830	debug("Error: reading boot sector\n");
832	return -1;	831	return -1;
833	}	832	}
834		833
835	if (mydata->fatsize == 32) {	834	if (mydata->fatsize == 32) {
836	root_cluster = bs.root_cluster;	835	root_cluster = bs.root_cluster;
837	mydata->fatlength = bs.fat32_length;	836	mydata->fatlength = bs.fat32_length;
838	} else {	837	} else {
839	mydata->fatlength = bs.fat_length;	838	mydata->fatlength = bs.fat_length;
840	}	839	}
841		840
842	mydata->fat_sect = bs.reserved;	841	mydata->fat_sect = bs.reserved;
843		842
844	cursect = mydata->rootdir_sect	843	cursect = mydata->rootdir_sect
845	= mydata->fat_sect + mydata->fatlength * bs.fats;	844	= mydata->fat_sect + mydata->fatlength * bs.fats;
846		845
847	mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0];	846	mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0];
848	mydata->clust_size = bs.cluster_size;	847	mydata->clust_size = bs.cluster_size;
849	if (mydata->sect_size != cur_part_info.blksz) {	848	if (mydata->sect_size != cur_part_info.blksz) {
850	printf("Error: FAT sector size mismatch (fs=%hu, dev=%lu)\n",	849	printf("Error: FAT sector size mismatch (fs=%hu, dev=%lu)\n",
851	mydata->sect_size, cur_part_info.blksz);	850	mydata->sect_size, cur_part_info.blksz);
852	return -1;	851	return -1;
853	}	852	}
854		853
855	if (mydata->fatsize == 32) {	854	if (mydata->fatsize == 32) {
856	mydata->data_begin = mydata->rootdir_sect -	855	mydata->data_begin = mydata->rootdir_sect -
857	(mydata->clust_size * 2);	856	(mydata->clust_size * 2);
858	} else {	857	} else {
859	rootdir_size = ((bs.dir_entries[1] * (int)256 +	858	rootdir_size = ((bs.dir_entries[1] * (int)256 +
860	bs.dir_entries[0]) *	859	bs.dir_entries[0]) *
861	sizeof(dir_entry)) /	860	sizeof(dir_entry)) /
862	mydata->sect_size;	861	mydata->sect_size;
863	mydata->data_begin = mydata->rootdir_sect +	862	mydata->data_begin = mydata->rootdir_sect +
864	rootdir_size -	863	rootdir_size -
865	(mydata->clust_size * 2);	864	(mydata->clust_size * 2);
866	}	865	}
867		866
868	mydata->fatbufnum = -1;	867	mydata->fatbufnum = -1;
869	mydata->fatbuf = memalign(ARCH_DMA_MINALIGN, FATBUFSIZE);	868	mydata->fatbuf = memalign(ARCH_DMA_MINALIGN, FATBUFSIZE);
870	if (mydata->fatbuf == NULL) {	869	if (mydata->fatbuf == NULL) {
871	debug("Error: allocating memory\n");	870	debug("Error: allocating memory\n");
872	return -1;	871	return -1;
873	}	872	}
874		873
875	if (vfat_enabled)	874	if (vfat_enabled)
876	debug("VFAT Support enabled\n");	875	debug("VFAT Support enabled\n");
877		876
878	debug("FAT%d, fat_sect: %d, fatlength: %d\n",	877	debug("FAT%d, fat_sect: %d, fatlength: %d\n",
879	mydata->fatsize, mydata->fat_sect, mydata->fatlength);	878	mydata->fatsize, mydata->fat_sect, mydata->fatlength);
880	debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"	879	debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
881	"Data begins at: %d\n",	880	"Data begins at: %d\n",
882	root_cluster,	881	root_cluster,
883	mydata->rootdir_sect,	882	mydata->rootdir_sect,
884	mydata->rootdir_sect * mydata->sect_size, mydata->data_begin);	883	mydata->rootdir_sect * mydata->sect_size, mydata->data_begin);
885	debug("Sector size: %d, cluster size: %d\n", mydata->sect_size,	884	debug("Sector size: %d, cluster size: %d\n", mydata->sect_size,
886	mydata->clust_size);	885	mydata->clust_size);
887		886
888	/* "cwd" is always the root... */	887	/* "cwd" is always the root... */
889	while (ISDIRDELIM(*filename))	888	while (ISDIRDELIM(*filename))
890	filename++;	889	filename++;
891		890
892	/* Make a copy of the filename and convert it to lowercase */	891	/* Make a copy of the filename and convert it to lowercase */
893	strcpy(fnamecopy, filename);	892	strcpy(fnamecopy, filename);
894	downcase(fnamecopy);	893	downcase(fnamecopy);
895		894
896	if (*fnamecopy == '\0') {	895	if (*fnamecopy == '\0') {
897	if (!dols)	896	if (!dols)
898	goto exit;	897	goto exit;
899		898
900	dols = LS_ROOT;	899	dols = LS_ROOT;
901	} else if ((idx = dirdelim(fnamecopy)) >= 0) {	900	} else if ((idx = dirdelim(fnamecopy)) >= 0) {
902	isdir = 1;	901	isdir = 1;
903	fnamecopy[idx] = '\0';	902	fnamecopy[idx] = '\0';
904	subname = fnamecopy + idx + 1;	903	subname = fnamecopy + idx + 1;
905		904
906	/* Handle multiple delimiters */	905	/* Handle multiple delimiters */
907	while (ISDIRDELIM(*subname))	906	while (ISDIRDELIM(*subname))
908	subname++;	907	subname++;
909	} else if (dols) {	908	} else if (dols) {
910	isdir = 1;	909	isdir = 1;
911	}	910	}
912		911
913	j = 0;	912	j = 0;
914	while (1) {	913	while (1) {
915	int i;	914	int i;
916		915
917	if (j == 0) {	916	if (j == 0) {
918	debug("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%zd\n",	917	debug("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%zd\n",
919	cursect, mydata->clust_size, DIRENTSPERBLOCK);	918	cursect, mydata->clust_size, DIRENTSPERBLOCK);
920		919
921	if (disk_read(cursect,	920	if (disk_read(cursect,
922	(mydata->fatsize == 32) ?	921	(mydata->fatsize == 32) ?
923	(mydata->clust_size) :	922	(mydata->clust_size) :
924	PREFETCH_BLOCKS,	923	PREFETCH_BLOCKS,
925	do_fat_read_at_block) < 0) {	924	do_fat_read_at_block) < 0) {
926	debug("Error: reading rootdir block\n");	925	debug("Error: reading rootdir block\n");
927	goto exit;	926	goto exit;
928	}	927	}
929		928
930	dentptr = (dir_entry *) do_fat_read_at_block;	929	dentptr = (dir_entry *) do_fat_read_at_block;
931	}	930	}
932		931
933	for (i = 0; i < DIRENTSPERBLOCK; i++) {	932	for (i = 0; i < DIRENTSPERBLOCK; i++) {
934	char s_name[14], l_name[VFAT_MAXLEN_BYTES];	933	char s_name[14], l_name[VFAT_MAXLEN_BYTES];
935	__u8 csum;	934	__u8 csum;
936		935
937	l_name[0] = '\0';	936	l_name[0] = '\0';
938	if (dentptr->name[0] == DELETED_FLAG) {	937	if (dentptr->name[0] == DELETED_FLAG) {
939	dentptr++;	938	dentptr++;
940	continue;	939	continue;
941	}	940	}
942		941
943	if (vfat_enabled)	942	if (vfat_enabled)
944	csum = mkcksum(dentptr->name, dentptr->ext);	943	csum = mkcksum(dentptr->name, dentptr->ext);
945		944
946	if (dentptr->attr & ATTR_VOLUME) {	945	if (dentptr->attr & ATTR_VOLUME) {
947	if (vfat_enabled &&	946	if (vfat_enabled &&
948	(dentptr->attr & ATTR_VFAT) == ATTR_VFAT &&	947	(dentptr->attr & ATTR_VFAT) == ATTR_VFAT &&
949	(dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {	948	(dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
950	prevcksum =	949	prevcksum =
951	((dir_slot *)dentptr)->alias_checksum;	950	((dir_slot *)dentptr)->alias_checksum;
952		951
953	get_vfatname(mydata,	952	get_vfatname(mydata,
954	root_cluster,	953	root_cluster,
955	do_fat_read_at_block,	954	do_fat_read_at_block,
956	dentptr, l_name);	955	dentptr, l_name);
957		956
958	if (dols == LS_ROOT) {	957	if (dols == LS_ROOT) {
959	char dirc;	958	char dirc;
960	int doit = 0;	959	int doit = 0;
961	int isdir =	960	int isdir =
962	(dentptr->attr & ATTR_DIR);	961	(dentptr->attr & ATTR_DIR);
963		962
964	if (isdir) {	963	if (isdir) {
965	dirs++;	964	dirs++;
966	dirc = '/';	965	dirc = '/';
967	doit = 1;	966	doit = 1;
968	} else {	967	} else {
969	dirc = ' ';	968	dirc = ' ';
970	if (l_name[0] != 0) {	969	if (l_name[0] != 0) {
971	files++;	970	files++;
972	doit = 1;	971	doit = 1;
973	}	972	}
974	}	973	}
975	if (doit) {	974	if (doit) {
976	if (dirc == ' ') {	975	if (dirc == ' ') {
977	printf(" %8ld %s%c\n",	976	printf(" %8u %s%c\n",
978	(long)FAT2CPU32(dentptr->size),	977	FAT2CPU32(dentptr->size),
979	l_name,	978	l_name,
980	dirc);	979	dirc);
981	} else {	980	} else {
982	printf(" %s%c\n",	981	printf(" %s%c\n",
983	l_name,	982	l_name,
984	dirc);	983	dirc);
985	}	984	}
986	}	985	}
987	dentptr++;	986	dentptr++;
988	continue;	987	continue;
989	}	988	}
990	debug("Rootvfatname: \|%s\|\n",	989	debug("Rootvfatname: \|%s\|\n",
991	l_name);	990	l_name);
992	} else {	991	} else {
993	/* Volume label or VFAT entry */	992	/* Volume label or VFAT entry */
994	dentptr++;	993	dentptr++;
995	continue;	994	continue;
996	}	995	}
997	} else if (dentptr->name[0] == 0) {	996	} else if (dentptr->name[0] == 0) {
998	debug("RootDentname == NULL - %d\n", i);	997	debug("RootDentname == NULL - %d\n", i);
999	if (dols == LS_ROOT) {	998	if (dols == LS_ROOT) {
1000	printf("\n%d file(s), %d dir(s)\n\n",	999	printf("\n%d file(s), %d dir(s)\n\n",
1001	files, dirs);	1000	files, dirs);
1002	ret = 0;	1001	ret = 0;
1003	}	1002	}
1004	goto exit;	1003	goto exit;
1005	}	1004	}
1006	else if (vfat_enabled &&	1005	else if (vfat_enabled &&
1007	dols == LS_ROOT && csum == prevcksum) {	1006	dols == LS_ROOT && csum == prevcksum) {
1008	prevcksum = 0xffff;	1007	prevcksum = 0xffff;
1009	dentptr++;	1008	dentptr++;
1010	continue;	1009	continue;
1011	}	1010	}
1012		1011
1013	get_name(dentptr, s_name);	1012	get_name(dentptr, s_name);
1014		1013
1015	if (dols == LS_ROOT) {	1014	if (dols == LS_ROOT) {
1016	int isdir = (dentptr->attr & ATTR_DIR);	1015	int isdir = (dentptr->attr & ATTR_DIR);
1017	char dirc;	1016	char dirc;
1018	int doit = 0;	1017	int doit = 0;
1019		1018
1020	if (isdir) {	1019	if (isdir) {
1021	dirc = '/';	1020	dirc = '/';
1022	if (s_name[0] != 0) {	1021	if (s_name[0] != 0) {
1023	dirs++;	1022	dirs++;
1024	doit = 1;	1023	doit = 1;
1025	}	1024	}
1026	} else {	1025	} else {
1027	dirc = ' ';	1026	dirc = ' ';
1028	if (s_name[0] != 0) {	1027	if (s_name[0] != 0) {
1029	files++;	1028	files++;
1030	doit = 1;	1029	doit = 1;
1031	}	1030	}
1032	}	1031	}
1033	if (doit) {	1032	if (doit) {
1034	if (dirc == ' ') {	1033	if (dirc == ' ') {
1035	printf(" %8ld %s%c\n",	1034	printf(" %8u %s%c\n",
1036	(long)FAT2CPU32(dentptr->size),	1035	FAT2CPU32(dentptr->size),
1037	s_name, dirc);	1036	s_name, dirc);
1038	} else {	1037	} else {
1039	printf(" %s%c\n",	1038	printf(" %s%c\n",
1040	s_name, dirc);	1039	s_name, dirc);
1041	}	1040	}
1042	}	1041	}
1043	dentptr++;	1042	dentptr++;
1044	continue;	1043	continue;
1045	}	1044	}
1046		1045
1047	if (strcmp(fnamecopy, s_name)	1046	if (strcmp(fnamecopy, s_name)
1048	&& strcmp(fnamecopy, l_name)) {	1047	&& strcmp(fnamecopy, l_name)) {
1049	debug("RootMismatch: \|%s\|%s\|\n", s_name,	1048	debug("RootMismatch: \|%s\|%s\|\n", s_name,
1050	l_name);	1049	l_name);
1051	dentptr++;	1050	dentptr++;
1052	continue;	1051	continue;
1053	}	1052	}
1054		1053
1055	if (isdir && !(dentptr->attr & ATTR_DIR))	1054	if (isdir && !(dentptr->attr & ATTR_DIR))
1056	goto exit;	1055	goto exit;
1057		1056
1058	debug("RootName: %s", s_name);	1057	debug("RootName: %s", s_name);
1059	debug(", start: 0x%x", START(dentptr));	1058	debug(", start: 0x%x", START(dentptr));
1060	debug(", size: 0x%x %s\n",	1059	debug(", size: 0x%x %s\n",
1061	FAT2CPU32(dentptr->size),	1060	FAT2CPU32(dentptr->size),
1062	isdir ? "(DIR)" : "");	1061	isdir ? "(DIR)" : "");
1063		1062
1064	goto rootdir_done; /* We got a match */	1063	goto rootdir_done; /* We got a match */
1065	}	1064	}
1066	debug("END LOOP: j=%d clust_size=%d\n", j,	1065	debug("END LOOP: j=%d clust_size=%d\n", j,
1067	mydata->clust_size);	1066	mydata->clust_size);
1068		1067
1069	/*	1068	/*
1070	* On FAT32 we must fetch the FAT entries for the next	1069	* On FAT32 we must fetch the FAT entries for the next
1071	* root directory clusters when a cluster has been	1070	* root directory clusters when a cluster has been
1072	* completely processed.	1071	* completely processed.
1073	*/	1072	*/
1074	++j;	1073	++j;
1075	int rootdir_end = 0;	1074	int rootdir_end = 0;
1076	if (mydata->fatsize == 32) {	1075	if (mydata->fatsize == 32) {
1077	if (j == mydata->clust_size) {	1076	if (j == mydata->clust_size) {
1078	int nxtsect = 0;	1077	int nxtsect = 0;
1079	int nxt_clust = 0;	1078	int nxt_clust = 0;
1080		1079
1081	nxt_clust = get_fatent(mydata, root_cluster);	1080	nxt_clust = get_fatent(mydata, root_cluster);
1082	rootdir_end = CHECK_CLUST(nxt_clust, 32);	1081	rootdir_end = CHECK_CLUST(nxt_clust, 32);
1083		1082
1084	nxtsect = mydata->data_begin +	1083	nxtsect = mydata->data_begin +
1085	(nxt_clust * mydata->clust_size);	1084	(nxt_clust * mydata->clust_size);
1086		1085
1087	root_cluster = nxt_clust;	1086	root_cluster = nxt_clust;
1088		1087
1089	cursect = nxtsect;	1088	cursect = nxtsect;
1090	j = 0;	1089	j = 0;
1091	}	1090	}
1092	} else {	1091	} else {
1093	if (j == PREFETCH_BLOCKS)	1092	if (j == PREFETCH_BLOCKS)
1094	j = 0;	1093	j = 0;
1095		1094
1096	rootdir_end = (++cursect - mydata->rootdir_sect >=	1095	rootdir_end = (++cursect - mydata->rootdir_sect >=
1097	rootdir_size);	1096	rootdir_size);
1098	}	1097	}
1099		1098
1100	/* If end of rootdir reached */	1099	/* If end of rootdir reached */
1101	if (rootdir_end) {	1100	if (rootdir_end) {
1102	if (dols == LS_ROOT) {	1101	if (dols == LS_ROOT) {
1103	printf("\n%d file(s), %d dir(s)\n\n",	1102	printf("\n%d file(s), %d dir(s)\n\n",
1104	files, dirs);	1103	files, dirs);
1105	ret = 0;	1104	*size = 0;
1106	}	1105	}
1107	goto exit;	1106	goto exit;
1108	}	1107	}
1109	}	1108	}
1110	rootdir_done:	1109	rootdir_done:
1111		1110
1112	firsttime = 1;	1111	firsttime = 1;
1113		1112
1114	while (isdir) {	1113	while (isdir) {
1115	int startsect = mydata->data_begin	1114	int startsect = mydata->data_begin
1116	+ START(dentptr) * mydata->clust_size;	1115	+ START(dentptr) * mydata->clust_size;
1117	dir_entry dent;	1116	dir_entry dent;
1118	char *nextname = NULL;	1117	char *nextname = NULL;
1119		1118
1120	dent = *dentptr;	1119	dent = *dentptr;
1121	dentptr = &dent;	1120	dentptr = &dent;
1122		1121
1123	idx = dirdelim(subname);	1122	idx = dirdelim(subname);
1124		1123
1125	if (idx >= 0) {	1124	if (idx >= 0) {
1126	subname[idx] = '\0';	1125	subname[idx] = '\0';
1127	nextname = subname + idx + 1;	1126	nextname = subname + idx + 1;
1128	/* Handle multiple delimiters */	1127	/* Handle multiple delimiters */
1129	while (ISDIRDELIM(*nextname))	1128	while (ISDIRDELIM(*nextname))
1130	nextname++;	1129	nextname++;
1131	if (dols && *nextname == '\0')	1130	if (dols && *nextname == '\0')
1132	firsttime = 0;	1131	firsttime = 0;
1133	} else {	1132	} else {
1134	if (dols && firsttime) {	1133	if (dols && firsttime) {
1135	firsttime = 0;	1134	firsttime = 0;
1136	} else {	1135	} else {
1137	isdir = 0;	1136	isdir = 0;
1138	}	1137	}
1139	}	1138	}
1140		1139
1141	if (get_dentfromdir(mydata, startsect, subname, dentptr,	1140	if (get_dentfromdir(mydata, startsect, subname, dentptr,
1142	isdir ? 0 : dols) == NULL) {	1141	isdir ? 0 : dols) == NULL) {
1143	if (dols && !isdir)	1142	if (dols && !isdir)
1144	ret = 0;	1143	*size = 0;
1145	goto exit;	1144	goto exit;
1146	}	1145	}
1147		1146
1148	if (isdir && !(dentptr->attr & ATTR_DIR))	1147	if (isdir && !(dentptr->attr & ATTR_DIR))
1149	goto exit;	1148	goto exit;
1150		1149
1151	if (idx >= 0)	1150	if (idx >= 0)
1152	subname = nextname;	1151	subname = nextname;
1153	}	1152	}
1154		1153
1155	if (dogetsize)	1154	if (dogetsize) {
1156	ret = FAT2CPU32(dentptr->size);	1155	*size = FAT2CPU32(dentptr->size);
1157	else	1156	ret = 0;
1158	ret = get_contents(mydata, dentptr, pos, buffer, maxsize);	1157	} else {
1159	debug("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), ret);	1158	ret = get_contents(mydata, dentptr, pos, buffer, maxsize, size);
		1159	}
		1160	debug("Size: %u, got: %llu\n", FAT2CPU32(dentptr->size), *size);
1160		1161
1161	exit:	1162	exit:
1162	free(mydata->fatbuf);	1163	free(mydata->fatbuf);
1163	return ret;	1164	return ret;
1164	}	1165	}
1165		1166
1166	long	1167	int do_fat_read(const char filename, void buffer, loff_t maxsize, int dols,
1167	do_fat_read(const char filename, void buffer, unsigned long maxsize, int dols)	1168	loff_t *actread)
1168	{	1169	{
1169	return do_fat_read_at(filename, 0, buffer, maxsize, dols, 0);	1170	return do_fat_read_at(filename, 0, buffer, maxsize, dols, 0, actread);
1170	}	1171	}
1171		1172
1172	int file_fat_detectfs(void)	1173	int file_fat_detectfs(void)
1173	{	1174	{
1174	boot_sector bs;	1175	boot_sector bs;
1175	volume_info volinfo;	1176	volume_info volinfo;
1176	int fatsize;	1177	int fatsize;
1177	char vol_label[12];	1178	char vol_label[12];
1178		1179
1179	if (cur_dev == NULL) {	1180	if (cur_dev == NULL) {
1180	printf("No current device\n");	1181	printf("No current device\n");
1181	return 1;	1182	return 1;
1182	}	1183	}
1183		1184
1184	#if defined(CONFIG_CMD_IDE) \|\| \	1185	#if defined(CONFIG_CMD_IDE) \|\| \
1185	defined(CONFIG_CMD_SATA) \|\| \	1186	defined(CONFIG_CMD_SATA) \|\| \
1186	defined(CONFIG_CMD_SCSI) \|\| \	1187	defined(CONFIG_CMD_SCSI) \|\| \
1187	defined(CONFIG_CMD_USB) \|\| \	1188	defined(CONFIG_CMD_USB) \|\| \
1188	defined(CONFIG_MMC)	1189	defined(CONFIG_MMC)
1189	printf("Interface: ");	1190	printf("Interface: ");
1190	switch (cur_dev->if_type) {	1191	switch (cur_dev->if_type) {
1191	case IF_TYPE_IDE:	1192	case IF_TYPE_IDE:
1192	printf("IDE");	1193	printf("IDE");
1193	break;	1194	break;
1194	case IF_TYPE_SATA:	1195	case IF_TYPE_SATA:
1195	printf("SATA");	1196	printf("SATA");
1196	break;	1197	break;
1197	case IF_TYPE_SCSI:	1198	case IF_TYPE_SCSI:
1198	printf("SCSI");	1199	printf("SCSI");
1199	break;	1200	break;
1200	case IF_TYPE_ATAPI:	1201	case IF_TYPE_ATAPI:
1201	printf("ATAPI");	1202	printf("ATAPI");
1202	break;	1203	break;
1203	case IF_TYPE_USB:	1204	case IF_TYPE_USB:
1204	printf("USB");	1205	printf("USB");
1205	break;	1206	break;
1206	case IF_TYPE_DOC:	1207	case IF_TYPE_DOC:
1207	printf("DOC");	1208	printf("DOC");
1208	break;	1209	break;
1209	case IF_TYPE_MMC:	1210	case IF_TYPE_MMC:
1210	printf("MMC");	1211	printf("MMC");
1211	break;	1212	break;
1212	default:	1213	default:
1213	printf("Unknown");	1214	printf("Unknown");
1214	}	1215	}
1215		1216
1216	printf("\n Device %d: ", cur_dev->dev);	1217	printf("\n Device %d: ", cur_dev->dev);
1217	dev_print(cur_dev);	1218	dev_print(cur_dev);
1218	#endif	1219	#endif
1219		1220
1220	if (read_bootsectandvi(&bs, &volinfo, &fatsize)) {	1221	if (read_bootsectandvi(&bs, &volinfo, &fatsize)) {
1221	printf("\nNo valid FAT fs found\n");	1222	printf("\nNo valid FAT fs found\n");
1222	return 1;	1223	return 1;
1223	}	1224	}
1224		1225
1225	memcpy(vol_label, volinfo.volume_label, 11);	1226	memcpy(vol_label, volinfo.volume_label, 11);
1226	vol_label[11] = '\0';	1227	vol_label[11] = '\0';
1227	volinfo.fs_type[5] = '\0';	1228	volinfo.fs_type[5] = '\0';
1228		1229
1229	printf("Filesystem: %s \"%s\"\n", volinfo.fs_type, vol_label);	1230	printf("Filesystem: %s \"%s\"\n", volinfo.fs_type, vol_label);
1230		1231
1231	return 0;	1232	return 0;
1232	}	1233	}
1233		1234
1234	int file_fat_ls(const char *dir)	1235	int file_fat_ls(const char *dir)
1235	{	1236	{
1236	return do_fat_read(dir, NULL, 0, LS_YES);	1237	loff_t size;
		1238
		1239	return do_fat_read(dir, NULL, 0, LS_YES, &size);
1237	}	1240	}
1238		1241
1239	int fat_exists(const char *filename)	1242	int fat_exists(const char *filename)
1240	{	1243	{
1241	int sz;	1244	int ret;
1242	sz = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1);	1245	loff_t size;
1243	return sz >= 0;	1246
		1247	ret = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1, &size);
		1248	return ret == 0;
1244	}	1249	}
1245		1250
1246	int fat_size(const char *filename)	1251	int fat_size(const char *filename)
1247	{	1252	{
1248	return do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1);	1253	loff_t size;
		1254	int ret;
		1255
		1256	ret = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1, &size);
		1257	if (ret)
		1258	return ret;
		1259	else
		1260	return size;
1249	}	1261	}
1250		1262
1251	long file_fat_read_at(const char filename, unsigned long pos, void buffer,	1263	int file_fat_read_at(const char filename, loff_t pos, void buffer,
1252	unsigned long maxsize)	1264	loff_t maxsize, loff_t *actread)
1253	{	1265	{
1254	printf("reading %s\n", filename);	1266	printf("reading %s\n", filename);
1255	return do_fat_read_at(filename, pos, buffer, maxsize, LS_NO, 0);	1267	return do_fat_read_at(filename, pos, buffer, maxsize, LS_NO, 0,
		1268	actread);
1256	}	1269	}
1257		1270
1258	long file_fat_read(const char filename, void buffer, unsigned long maxsize)	1271	int file_fat_read(const char filename, void buffer, int maxsize)
1259	{	1272	{
1260	return file_fat_read_at(filename, 0, buffer, maxsize);	1273	loff_t actread;
		1274	int ret;
		1275
		1276	ret = file_fat_read_at(filename, 0, buffer, maxsize, &actread);
		1277	if (ret)
		1278	return ret;
		1279	else
		1280	return actread;
1261	}	1281	}
1262		1282
1263	int fat_read_file(const char filename, void buf, int offset, int len)	1283	int fat_read_file(const char filename, void buf, int offset, int len)
1264	{	1284	{
1265	int len_read;	1285	int ret;
		1286	loff_t actread;
1266		1287
1267	len_read = file_fat_read_at(filename, offset, buf, len);	1288	ret = file_fat_read_at(filename, offset, buf, len, &actread);
1268	if (len_read == -1) {	1289	if (ret) {
1269	printf(" Unable to read file %s \n", filename);	1290	printf(" Unable to read file %s \n", filename);
1270	return -1;	1291	return ret;
1271	}	1292	}
1272		1293
1273	return len_read;	1294	return actread;
1274	}	1295	}
1275		1296
1276	void fat_close(void)	1297	void fat_close(void)
1277	{	1298	{

fs/fat/fat_write.c

Diff comments View file @ 1ad0b98

 /*
  * fat_write.c
  *
  * R/W (V)FAT 12/16/32 filesystem implementation by Donggeun Kim
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <command.h>
 #include <config.h>
 #include <fat.h>
 #include <asm/byteorder.h>
 #include <part.h>
 #include <linux/ctype.h>
 #include "fat.c"
 static void uppercase(char *str, int len)
 {
 	int i;
 	for (i = 0; i < len; i++) {
 		*str = toupper(*str);
 		str++;
 	}
 }
 static int total_sector;
 static int disk_write(__u32 block, __u32 nr_blocks, void *buf)
 {
 	if (!cur_dev || !cur_dev->block_write)
 		return -1;
 	if (cur_part_info.start + block + nr_blocks >
 		cur_part_info.start + total_sector) {
 		printf("error: overflow occurs\n");
 		return -1;
 	}
 	return cur_dev->block_write(cur_dev->dev,
 			cur_part_info.start + block, nr_blocks,	buf);
 }
 /*
  * Set short name in directory entry
  */
 static void set_name(dir_entry *dirent, const char *filename)
 {
 	char s_name[VFAT_MAXLEN_BYTES];
 	char *period;
 	int period_location, len, i, ext_num;
 	if (filename == NULL)
 		return;
 	len = strlen(filename);
 	if (len == 0)
 		return;
 	strcpy(s_name, filename);
 	uppercase(s_name, len);
 	period = strchr(s_name, '.');
 	if (period == NULL) {
 		period_location = len;
 		ext_num = 0;
 	} else {
 		period_location = period - s_name;
 		ext_num = len - period_location - 1;
 	}
 	/* Pad spaces when the length of file name is shorter than eight */
 	if (period_location < 8) {
 		memcpy(dirent->name, s_name, period_location);
 		for (i = period_location; i < 8; i++)
 			dirent->name[i] = ' ';
 	} else if (period_location == 8) {
 		memcpy(dirent->name, s_name, period_location);
 	} else {
 		memcpy(dirent->name, s_name, 6);
 		dirent->name[6] = '~';
 		dirent->name[7] = '1';
 	}
 	if (ext_num < 3) {
 		memcpy(dirent->ext, s_name + period_location + 1, ext_num);
 		for (i = ext_num; i < 3; i++)
 			dirent->ext[i] = ' ';
 	} else
 		memcpy(dirent->ext, s_name + period_location + 1, 3);
 	debug("name : %s\n", dirent->name);
 	debug("ext : %s\n", dirent->ext);
 }
 static __u8 num_of_fats;
 /*
  * Write fat buffer into block device
  */
 static int flush_fat_buffer(fsdata *mydata)
 {
 	int getsize = FATBUFBLOCKS;
 	__u32 fatlength = mydata->fatlength;
 	__u8 *bufptr = mydata->fatbuf;
 	__u32 startblock = mydata->fatbufnum * FATBUFBLOCKS;
 	startblock += mydata->fat_sect;
 	if (getsize > fatlength)
 		getsize = fatlength;
 	/* Write FAT buf */
 	if (disk_write(startblock, getsize, bufptr) < 0) {
 		debug("error: writing FAT blocks\n");
 		return -1;
 	}
 	if (num_of_fats == 2) {
 		/* Update corresponding second FAT blocks */
 		startblock += mydata->fatlength;
 		if (disk_write(startblock, getsize, bufptr) < 0) {
 			debug("error: writing second FAT blocks\n");
 			return -1;
 		}
 	}
 	return 0;
 }
 /*
  * Get the entry at index 'entry' in a FAT (12/16/32) table.
  * On failure 0x00 is returned.
  * When bufnum is changed, write back the previous fatbuf to the disk.
  */
 static __u32 get_fatent_value(fsdata *mydata, __u32 entry)
 {
 	__u32 bufnum;
 	__u32 off16, offset;
 	__u32 ret = 0x00;
 	__u16 val1, val2;
 	if (CHECK_CLUST(entry, mydata->fatsize)) {
 		printf("Error: Invalid FAT entry: 0x%08x\n", entry);
 		return ret;
 	}
 	switch (mydata->fatsize) {
 	case 32:
 		bufnum = entry / FAT32BUFSIZE;
 		offset = entry - bufnum * FAT32BUFSIZE;
 		break;
 	case 16:
 		bufnum = entry / FAT16BUFSIZE;
 		offset = entry - bufnum * FAT16BUFSIZE;
 		break;
 	case 12:
 		bufnum = entry / FAT12BUFSIZE;
 		offset = entry - bufnum * FAT12BUFSIZE;
 		break;
 	default:
 		/* Unsupported FAT size */
 		return ret;
 	}
 	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. */
 	if (bufnum != mydata->fatbufnum) {
 		int getsize = FATBUFBLOCKS;
 		__u8 *bufptr = mydata->fatbuf;
 		__u32 fatlength = mydata->fatlength;
 		__u32 startblock = bufnum * FATBUFBLOCKS;
 		if (getsize > fatlength)
 			getsize = fatlength;
 		fatlength *= mydata->sect_size;	/* We want it in bytes now */
 		startblock += mydata->fat_sect;	/* Offset from start of disk */
 		/* Write back the fatbuf to the disk */
 		if (mydata->fatbufnum != -1) {
 			if (flush_fat_buffer(mydata) < 0)
 				return -1;
 		}
 		if (disk_read(startblock, getsize, bufptr) < 0) {
 			debug("Error reading FAT blocks\n");
 			return ret;
 		}
 		mydata->fatbufnum = bufnum;
 	}
 	/* Get the actual entry from the table */
 	switch (mydata->fatsize) {
 	case 32:
 		ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]);
 		break;
 	case 16:
 		ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);
 		break;
 	case 12:
 		off16 = (offset * 3) / 4;
 		switch (offset & 0x3) {
 		case 0:
 			ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]);
 			ret &= 0xfff;
 			break;
 		case 1:
 			val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
 			val1 &= 0xf000;
 			val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);
 			val2 &= 0x00ff;
 			ret = (val2 << 4) | (val1 >> 12);
 			break;
 		case 2:
 			val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
 			val1 &= 0xff00;
 			val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);
 			val2 &= 0x000f;
 			ret = (val2 << 8) | (val1 >> 8);
 			break;
 		case 3:
 			ret = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
 			ret = (ret & 0xfff0) >> 4;
 			break;
 		default:
 			break;
 		}
 		break;
 	}
 	debug("FAT%d: ret: %08x, entry: %08x, offset: %04x\n",
 	       mydata->fatsize, ret, entry, offset);
 	return ret;
 }
 /*
  * Set the file name information from 'name' into 'slotptr',
  */
 static int str2slot(dir_slot *slotptr, const char *name, int *idx)
 {
 	int j, end_idx = 0;
 	for (j = 0; j <= 8; j += 2) {
 		if (name[*idx] == 0x00) {
 			slotptr->name0_4[j] = 0;
 			slotptr->name0_4[j + 1] = 0;
 			end_idx++;
 			goto name0_4;
 		}
 		slotptr->name0_4[j] = name[*idx];
 		(*idx)++;
 		end_idx++;
 	}
 	for (j = 0; j <= 10; j += 2) {
 		if (name[*idx] == 0x00) {
 			slotptr->name5_10[j] = 0;
 			slotptr->name5_10[j + 1] = 0;
 			end_idx++;
 			goto name5_10;
 		}
 		slotptr->name5_10[j] = name[*idx];
 		(*idx)++;
 		end_idx++;
 	}
 	for (j = 0; j <= 2; j += 2) {
 		if (name[*idx] == 0x00) {
 			slotptr->name11_12[j] = 0;
 			slotptr->name11_12[j + 1] = 0;
 			end_idx++;
 			goto name11_12;
 		}
 		slotptr->name11_12[j] = name[*idx];
 		(*idx)++;
 		end_idx++;
 	}
 	if (name[*idx] == 0x00)
 		return 1;
 	return 0;
 /* Not used characters are filled with 0xff 0xff */
 name0_4:
 	for (; end_idx < 5; end_idx++) {
 		slotptr->name0_4[end_idx * 2] = 0xff;
 		slotptr->name0_4[end_idx * 2 + 1] = 0xff;
 	}
 	end_idx = 5;
 name5_10:
 	end_idx -= 5;
 	for (; end_idx < 6; end_idx++) {
 		slotptr->name5_10[end_idx * 2] = 0xff;
 		slotptr->name5_10[end_idx * 2 + 1] = 0xff;
 	}
 	end_idx = 11;
 name11_12:
 	end_idx -= 11;
 	for (; end_idx < 2; end_idx++) {
 		slotptr->name11_12[end_idx * 2] = 0xff;
 		slotptr->name11_12[end_idx * 2 + 1] = 0xff;
 	}
 	return 1;
 }
 static int is_next_clust(fsdata *mydata, dir_entry *dentptr);
 static void flush_dir_table(fsdata *mydata, dir_entry **dentptr);
 /*
  * Fill dir_slot entries with appropriate name, id, and attr
  * The real directory entry is returned by 'dentptr'
  */
 static void
 fill_dir_slot(fsdata *mydata, dir_entry **dentptr, const char *l_name)
 {
 	dir_slot *slotptr = (dir_slot *)get_contents_vfatname_block;
 	__u8 counter = 0, checksum;
 	int idx = 0, ret;
 	char s_name[16];
 	/* Get short file name and checksum value */
 	strncpy(s_name, (*dentptr)->name, 16);
 	checksum = mkcksum((*dentptr)->name, (*dentptr)->ext);
 	do {
 		memset(slotptr, 0x00, sizeof(dir_slot));
 		ret = str2slot(slotptr, l_name, &idx);
 		slotptr->id = ++counter;
 		slotptr->attr = ATTR_VFAT;
 		slotptr->alias_checksum = checksum;
 		slotptr++;
 	} while (ret == 0);
 	slotptr--;
 	slotptr->id |= LAST_LONG_ENTRY_MASK;
 	while (counter >= 1) {
 		if (is_next_clust(mydata, *dentptr)) {
 			/* A new cluster is allocated for directory table */
 			flush_dir_table(mydata, dentptr);
 		}
 		memcpy(*dentptr, slotptr, sizeof(dir_slot));
 		(*dentptr)++;
 		slotptr--;
 		counter--;
 	}
 	if (is_next_clust(mydata, *dentptr)) {
 		/* A new cluster is allocated for directory table */
 		flush_dir_table(mydata, dentptr);
 	}
 }
 static __u32 dir_curclust;
 /*
  * Extract the full long filename starting at 'retdent' (which is really
  * a slot) into 'l_name'. If successful also copy the real directory entry
  * into 'retdent'
  * If additional adjacent cluster for directory entries is read into memory,
  * then 'get_contents_vfatname_block' is copied into 'get_dentfromdir_block' and
  * the location of the real directory entry is returned by 'retdent'
  * Return 0 on success, -1 otherwise.
  */
 static int
 get_long_file_name(fsdata *mydata, int curclust, __u8 *cluster,
 	      dir_entry **retdent, char *l_name)
 {
 	dir_entry *realdent;
 	dir_slot *slotptr = (dir_slot *)(*retdent);
 	dir_slot *slotptr2 = NULL;
 	__u8 *buflimit = cluster + mydata->sect_size * ((curclust == 0) ?
 							PREFETCH_BLOCKS :
 							mydata->clust_size);
 	__u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff;
 	int idx = 0, cur_position = 0;
 	if (counter > VFAT_MAXSEQ) {
 		debug("Error: VFAT name is too long\n");
 		return -1;
 	}
 	while ((__u8 *)slotptr < buflimit) {
 		if (counter == 0)
 			break;
 		if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
 			return -1;
 		slotptr++;
 		counter--;
 	}
 	if ((__u8 *)slotptr >= buflimit) {
 		if (curclust == 0)
 			return -1;
 		curclust = get_fatent_value(mydata, dir_curclust);
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			printf("Invalid FAT entry\n");
 			return -1;
 		}
 		dir_curclust = curclust;
 		if (get_cluster(mydata, curclust, get_contents_vfatname_block,
 				mydata->clust_size * mydata->sect_size) != 0) {
 			debug("Error: reading directory block\n");
 			return -1;
 		}
 		slotptr2 = (dir_slot *)get_contents_vfatname_block;
 		while (counter > 0) {
 			if (((slotptr2->id & ~LAST_LONG_ENTRY_MASK)
 			    & 0xff) != counter)
 				return -1;
 			slotptr2++;
 			counter--;
 		}
 		/* Save the real directory entry */
 		realdent = (dir_entry *)slotptr2;
 		while ((__u8 *)slotptr2 > get_contents_vfatname_block) {
 			slotptr2--;
 			slot2str(slotptr2, l_name, &idx);
 		}
 	} else {
 		/* Save the real directory entry */
 		realdent = (dir_entry *)slotptr;
 	}
 	do {
 		slotptr--;
 		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;
 	downcase(l_name);
 	/* Return the real directory entry */
 	*retdent = realdent;
 	if (slotptr2) {
 		memcpy(get_dentfromdir_block, get_contents_vfatname_block,
 			mydata->clust_size * mydata->sect_size);
 		cur_position = (__u8 *)realdent - get_contents_vfatname_block;
 		*retdent = (dir_entry *) &get_dentfromdir_block[cur_position];
 	}
 	return 0;
 }
 /*
  * Set the entry at index 'entry' in a FAT (16/32) table.
  */
 static int set_fatent_value(fsdata *mydata, __u32 entry, __u32 entry_value)
 {
 	__u32 bufnum, offset;
 	switch (mydata->fatsize) {
 	case 32:
 		bufnum = entry / FAT32BUFSIZE;
 		offset = entry - bufnum * FAT32BUFSIZE;
 		break;
 	case 16:
 		bufnum = entry / FAT16BUFSIZE;
 		offset = entry - bufnum * FAT16BUFSIZE;
 		break;
 	default:
 		/* Unsupported FAT size */
 		return -1;
 	}
 	/* Read a new block of FAT entries into the cache. */
 	if (bufnum != mydata->fatbufnum) {
 		int getsize = FATBUFBLOCKS;
 		__u8 *bufptr = mydata->fatbuf;
 		__u32 fatlength = mydata->fatlength;
 		__u32 startblock = bufnum * FATBUFBLOCKS;
 		fatlength *= mydata->sect_size;
 		startblock += mydata->fat_sect;
 		if (getsize > fatlength)
 			getsize = fatlength;
 		if (mydata->fatbufnum != -1) {
 			if (flush_fat_buffer(mydata) < 0)
 				return -1;
 		}
 		if (disk_read(startblock, getsize, bufptr) < 0) {
 			debug("Error reading FAT blocks\n");
 			return -1;
 		}
 		mydata->fatbufnum = bufnum;
 	}
 	/* Set the actual entry */
 	switch (mydata->fatsize) {
 	case 32:
 		((__u32 *) mydata->fatbuf)[offset] = cpu_to_le32(entry_value);
 		break;
 	case 16:
 		((__u16 *) mydata->fatbuf)[offset] = cpu_to_le16(entry_value);
 		break;
 	default:
 		return -1;
 	}
 	return 0;
 }
 /*
  * Determine the entry value at index 'entry' in a FAT (16/32) table
  */
 static __u32 determine_fatent(fsdata *mydata, __u32 entry)
 {
 	__u32 next_fat, next_entry = entry + 1;
 	while (1) {
 		next_fat = get_fatent_value(mydata, next_entry);
 		if (next_fat == 0) {
 			set_fatent_value(mydata, entry, next_entry);
 			break;
 		}
 		next_entry++;
 	}
 	debug("FAT%d: entry: %08x, entry_value: %04x\n",
 	       mydata->fatsize, entry, next_entry);
 	return next_entry;
 }
 /*
  * Write at most 'size' bytes from 'buffer' into the specified cluster.
  * Return 0 on success, -1 otherwise.
  */
 static int
 set_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;
 	else
 		startsect = mydata->rootdir_sect;
 	debug("clustnum: %d, startsect: %d\n", clustnum, startsect);
 	if ((size / mydata->sect_size) > 0) {
 		if (disk_write(startsect, size / mydata->sect_size, buffer) < 0) {
 			debug("Error writing data\n");
 			return -1;
 		}
 	}
 	if (size % mydata->sect_size) {
 		__u8 tmpbuf[mydata->sect_size];
 		idx = size / mydata->sect_size;
 		buffer += idx * mydata->sect_size;
 		memcpy(tmpbuf, buffer, size % mydata->sect_size);
 		if (disk_write(startsect + idx, 1, tmpbuf) < 0) {
 			debug("Error writing data\n");
 			return -1;
 		}
 		return 0;
 	}
 	return 0;
 }
 /*
  * Find the first empty cluster
  */
 static int find_empty_cluster(fsdata *mydata)
 {
 	__u32 fat_val, entry = 3;
 	while (1) {
 		fat_val = get_fatent_value(mydata, entry);
 		if (fat_val == 0)
 			break;
 		entry++;
 	}
 	return entry;
 }
 /*
  * Write directory entries in 'get_dentfromdir_block' to block device
  */
 static void flush_dir_table(fsdata *mydata, dir_entry **dentptr)
 {
 	int dir_newclust = 0;
 	if (set_cluster(mydata, dir_curclust,
 		    get_dentfromdir_block,
 		    mydata->clust_size * mydata->sect_size) != 0) {
 		printf("error: wrinting directory entry\n");
 		return;
 	}
 	dir_newclust = find_empty_cluster(mydata);
 	set_fatent_value(mydata, dir_curclust, dir_newclust);
 	if (mydata->fatsize == 32)
 		set_fatent_value(mydata, dir_newclust, 0xffffff8);
 	else if (mydata->fatsize == 16)
 		set_fatent_value(mydata, dir_newclust, 0xfff8);
 	dir_curclust = dir_newclust;
 	if (flush_fat_buffer(mydata) < 0)
 		return;
 	memset(get_dentfromdir_block, 0x00,
 		mydata->clust_size * mydata->sect_size);
 	*dentptr = (dir_entry *) get_dentfromdir_block;
 }
 /*
  * Set empty cluster from 'entry' to the end of a file
  */
 static int clear_fatent(fsdata *mydata, __u32 entry)
 {
 	__u32 fat_val;
 	while (1) {
 		fat_val = get_fatent_value(mydata, entry);
 		if (fat_val != 0)
 			set_fatent_value(mydata, entry, 0);
 		else
 			break;
 		if (fat_val == 0xfffffff || fat_val == 0xffff)
 			break;
 		entry = fat_val;
 	}
 	/* Flush fat buffer */
 	if (flush_fat_buffer(mydata) < 0)
 		return -1;
 	return 0;
 }
 /*
  * Write at most 'maxsize' bytes from 'buffer' into
  * the file associated with 'dentptr'
- * Return the number of bytes read or -1 on fatal errors.
+ * Update the number of bytes written in *gotsize and return 0
+ * or return -1 on fatal errors.
  */
 static int
 set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
-	      unsigned long maxsize)
+	      loff_t maxsize, loff_t *gotsize)
 {
-	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
+	loff_t filesize = FAT2CPU32(dentptr->size);
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust = 0, newclust = 0;
-	unsigned long actsize;
+	loff_t actsize;
-	debug("Filesize: %ld bytes\n", filesize);
+	*gotsize = 0;
+	debug("Filesize: %llu bytes\n", filesize);
 	if (maxsize > 0 && filesize > maxsize)
 		filesize = maxsize;
-	debug("%ld bytes\n", filesize);
+	debug("%llu bytes\n", filesize);
 	actsize = bytesperclust;
 	endclust = curclust;
 	do {
 		/* search for consecutive clusters */
 		while (actsize < filesize) {
 			newclust = determine_fatent(mydata, endclust);
 			if ((newclust - 1) != endclust)
 				goto getit;
 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
 				debug("curclust: 0x%x\n", newclust);
 				debug("Invalid FAT entry\n");
-				return gotsize;
+				return 0;
 			}
 			endclust = newclust;
 			actsize += bytesperclust;
 		}
 		/* actsize >= file size */
 		actsize -= bytesperclust;
 		/* set remaining clusters */
 		if (set_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
 			debug("error: writing cluster\n");
 			return -1;
 		}
 		/* set remaining bytes */
-		gotsize += (int)actsize;
+		*gotsize += actsize;
 		filesize -= actsize;
 		buffer += actsize;
 		actsize = filesize;
 		if (set_cluster(mydata, endclust, buffer, (int)actsize) != 0) {
 			debug("error: writing cluster\n");
 			return -1;
 		}
-		gotsize += actsize;
+		*gotsize += actsize;
 		/* Mark end of file in FAT */
 		if (mydata->fatsize == 16)
 			newclust = 0xffff;
 		else if (mydata->fatsize == 32)
 			newclust = 0xfffffff;
 		set_fatent_value(mydata, endclust, newclust);
-		return gotsize;
+		return 0;
 getit:
 		if (set_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
 			debug("error: writing cluster\n");
 			return -1;
 		}
-		gotsize += (int)actsize;
+		*gotsize += actsize;
 		filesize -= actsize;
 		buffer += actsize;
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize = bytesperclust;
 		curclust = endclust = newclust;
 	} while (1);
 }
 /*
  * Fill dir_entry
  */
 static void fill_dentry(fsdata *mydata, dir_entry *dentptr,
 	const char *filename, __u32 start_cluster, __u32 size, __u8 attr)
 {
 	if (mydata->fatsize == 32)
 		dentptr->starthi =
 			cpu_to_le16((start_cluster & 0xffff0000) >> 16);
 	dentptr->start = cpu_to_le16(start_cluster & 0xffff);
 	dentptr->size = cpu_to_le32(size);
 	dentptr->attr = attr;
 	set_name(dentptr, filename);
 }
 /*
  * Check whether adding a file makes the file system to
  * exceed the size of the block device
  * Return -1 when overflow occurs, otherwise return 0
  */
-static int check_overflow(fsdata *mydata, __u32 clustnum, unsigned long size)
+static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
 {
 	__u32 startsect, sect_num;
 	if (clustnum > 0) {
 		startsect = mydata->data_begin +
 				clustnum * mydata->clust_size;
 	} else {
 		startsect = mydata->rootdir_sect;
 	}
 	sect_num = size / mydata->sect_size;
 	if (size % mydata->sect_size)
 		sect_num++;
 	if (startsect + sect_num > cur_part_info.start + total_sector)
 		return -1;
 	return 0;
 }
 /*
  * Check if adding several entries exceed one cluster boundary
  */
 static int is_next_clust(fsdata *mydata, dir_entry *dentptr)
 {
 	int cur_position;
 	cur_position = (__u8 *)dentptr - get_dentfromdir_block;
 	if (cur_position >= mydata->clust_size * mydata->sect_size)
 		return 1;
 	else
 		return 0;
 }
 static dir_entry *empty_dentptr;
 /*
  * Find a directory entry based on filename or start cluster number
  * If the directory entry is not found,
  * the new position for writing a directory entry will be returned
  */
 static dir_entry *find_directory_entry(fsdata *mydata, int startsect,
 	char *filename, dir_entry *retdent, __u32 start)
 {
 	__u32 curclust = (startsect - mydata->data_begin) / mydata->clust_size;
 	debug("get_dentfromdir: %s\n", filename);
 	while (1) {
 		dir_entry *dentptr;
 		int i;
 		if (get_cluster(mydata, curclust, get_dentfromdir_block,
 			    mydata->clust_size * mydata->sect_size) != 0) {
 			printf("Error: reading directory block\n");
 			return NULL;
 		}
 		dentptr = (dir_entry *)get_dentfromdir_block;
 		dir_curclust = curclust;
 		for (i = 0; i < DIRENTSPERCLUST; i++) {
 			char s_name[14], l_name[VFAT_MAXLEN_BYTES];
 			l_name[0] = '\0';
 			if (dentptr->name[0] == DELETED_FLAG) {
 				dentptr++;
 				if (is_next_clust(mydata, dentptr))
 					break;
 				continue;
 			}
 			if ((dentptr->attr & ATTR_VOLUME)) {
 				if (vfat_enabled &&
 				    (dentptr->attr & ATTR_VFAT) &&
 				    (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
 					get_long_file_name(mydata, curclust,
 						     get_dentfromdir_block,
 						     &dentptr, l_name);
 					debug("vfatname: |%s|\n", l_name);
 				} else {
 					/* Volume label or VFAT entry */
 					dentptr++;
 					if (is_next_clust(mydata, dentptr))
 						break;
 					continue;
 				}
 			}
 			if (dentptr->name[0] == 0) {
 				debug("Dentname == NULL - %d\n", i);
 				empty_dentptr = dentptr;
 				return NULL;
 			}
 			get_name(dentptr, s_name);
 			if (strcmp(filename, s_name)
 			    && strcmp(filename, l_name)) {
 				debug("Mismatch: |%s|%s|\n",
 					s_name, l_name);
 				dentptr++;
 				if (is_next_clust(mydata, dentptr))
 					break;
 				continue;
 			}
 			memcpy(retdent, dentptr, sizeof(dir_entry));
 			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 dentptr;
 		}
 		/*
 		 * In FAT16/12, the root dir is locate before data area, shows
 		 * in following:
 		 * -------------------------------------------------------------
 		 * | Boot | FAT1 & 2 | Root dir | Data (start from cluster #2) |
 		 * -------------------------------------------------------------
 		 *
 		 * As a result if curclust is in Root dir, it is a negative
 		 * number or 0, 1.
 		 *
 		 */
 		if (mydata->fatsize != 32 && (int)curclust <= 1) {
 			/* Current clust is in root dir, set to next clust */
 			curclust++;
 			if ((int)curclust <= 1)
 				continue;	/* continue to find */
 			/* Reach the end of root dir */
 			empty_dentptr = dentptr;
 			return NULL;
 		}
 		curclust = get_fatent_value(mydata, dir_curclust);
 		if (IS_LAST_CLUST(curclust, mydata->fatsize)) {
 			empty_dentptr = dentptr;
 			return NULL;
 		}
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
 			return NULL;
 		}
 	}
 	return NULL;
 }
-static int do_fat_write(const char *filename, void *buffer,
+static int do_fat_write(const char *filename, void *buffer, loff_t size,
-	unsigned long size)
+			loff_t *actwrite)
 {
 	dir_entry *dentptr, *retdent;
 	__u32 startsect;
 	__u32 start_cluster;
 	boot_sector bs;
 	volume_info volinfo;
 	fsdata datablock;
 	fsdata *mydata = &datablock;
 	int cursect;
 	int ret = -1, name_len;
 	char l_filename[VFAT_MAXLEN_BYTES];
-	int write_size = size;
+	*actwrite = size;
 	dir_curclust = 0;
 	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
 		debug("error: reading boot sector\n");
 		return -1;
 	}
 	total_sector = bs.total_sect;
 	if (total_sector == 0)
 		total_sector = (int)cur_part_info.size; /* cast of lbaint_t */
 	if (mydata->fatsize == 32)
 		mydata->fatlength = bs.fat32_length;
 	else
 		mydata->fatlength = bs.fat_length;
 	mydata->fat_sect = bs.reserved;
 	cursect = mydata->rootdir_sect
 		= mydata->fat_sect + mydata->fatlength * bs.fats;
 	num_of_fats = bs.fats;
 	mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0];
 	mydata->clust_size = bs.cluster_size;
 	if (mydata->fatsize == 32) {
 		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)) /
 				 mydata->sect_size;
 		mydata->data_begin = mydata->rootdir_sect +
 					rootdir_size -
 					(mydata->clust_size * 2);
 	}
 	mydata->fatbufnum = -1;
 	mydata->fatbuf = memalign(ARCH_DMA_MINALIGN, FATBUFSIZE);
 	if (mydata->fatbuf == NULL) {
 		debug("Error: allocating memory\n");
 		return -1;
 	}
 	if (disk_read(cursect,
 		(mydata->fatsize == 32) ?
 		(mydata->clust_size) :
 		PREFETCH_BLOCKS, do_fat_read_at_block) < 0) {
 		debug("Error: reading rootdir block\n");
 		goto exit;
 	}
 	dentptr = (dir_entry *) do_fat_read_at_block;
 	name_len = strlen(filename);
 	if (name_len >= VFAT_MAXLEN_BYTES)
 		name_len = VFAT_MAXLEN_BYTES - 1;
 	memcpy(l_filename, filename, name_len);
 	l_filename[name_len] = 0; /* terminate the string */
 	downcase(l_filename);
 	startsect = mydata->rootdir_sect;
 	retdent = find_directory_entry(mydata, startsect,
 				l_filename, dentptr, 0);
 	if (retdent) {
 		/* Update file size and start_cluster in a directory entry */
 		retdent->size = cpu_to_le32(size);
 		start_cluster = FAT2CPU16(retdent->start);
 		if (mydata->fatsize == 32)
 			start_cluster |=
 				(FAT2CPU16(retdent->starthi) << 16);
 		ret = check_overflow(mydata, start_cluster, size);
 		if (ret) {
-			printf("Error: %ld overflow\n", size);
+			printf("Error: %llu overflow\n", size);
 			goto exit;
 		}
 		ret = clear_fatent(mydata, start_cluster);
 		if (ret) {
 			printf("Error: clearing FAT entries\n");
 			goto exit;
 		}
-		ret = set_contents(mydata, retdent, buffer, size);
+		ret = set_contents(mydata, retdent, buffer, size, actwrite);
 		if (ret < 0) {
 			printf("Error: writing contents\n");
 			goto exit;
 		}
-		write_size = ret;
+		debug("attempt to write 0x%llx bytes\n", *actwrite);
-		debug("attempt to write 0x%x bytes\n", write_size);
 		/* Flush fat buffer */
 		ret = flush_fat_buffer(mydata);
 		if (ret) {
 			printf("Error: flush fat buffer\n");
 			goto exit;
 		}
 		/* Write directory table to device */
 		ret = set_cluster(mydata, dir_curclust,
 			    get_dentfromdir_block,
 			    mydata->clust_size * mydata->sect_size);
 		if (ret) {
 			printf("Error: writing directory entry\n");
 			goto exit;
 		}
 	} else {
 		/* Set short name to set alias checksum field in dir_slot */
 		set_name(empty_dentptr, filename);
 		fill_dir_slot(mydata, &empty_dentptr, filename);
 		ret = start_cluster = find_empty_cluster(mydata);
 		if (ret < 0) {
 			printf("Error: finding empty cluster\n");
 			goto exit;
 		}
 		ret = check_overflow(mydata, start_cluster, size);
 		if (ret) {
-			printf("Error: %ld overflow\n", size);
+			printf("Error: %llu overflow\n", size);
 			goto exit;
 		}
 		/* Set attribute as archieve for regular file */
 		fill_dentry(mydata, empty_dentptr, filename,
 			start_cluster, size, 0x20);
-		ret = set_contents(mydata, empty_dentptr, buffer, size);
+		ret = set_contents(mydata, empty_dentptr, buffer, size,
+				   actwrite);
 		if (ret < 0) {
 			printf("Error: writing contents\n");
 			goto exit;
 		}
-		write_size = ret;
+		debug("attempt to write 0x%llx bytes\n", *actwrite);
-		debug("attempt to write 0x%x bytes\n", write_size);
 		/* Flush fat buffer */
 		ret = flush_fat_buffer(mydata);
 		if (ret) {
 			printf("Error: flush fat buffer\n");
 			goto exit;
 		}
 		/* Write directory table to device */
 		ret = set_cluster(mydata, dir_curclust,
 			    get_dentfromdir_block,
 			    mydata->clust_size * mydata->sect_size);
 		if (ret) {
 			printf("Error: writing directory entry\n");
 			goto exit;
 		}
 	}
 exit:
 	free(mydata->fatbuf);
-	return ret < 0 ? ret : write_size;
+	return ret;
 }
-int file_fat_write(const char *filename, void *buffer, unsigned long maxsize)
+int file_fat_write(const char *filename, void *buffer, loff_t offset,
+		   loff_t maxsize, loff_t *actwrite)
 {
+	if (offset != 0) {
+		printf("Error: non zero offset is currently not suported.\n");
+		return -1;
+	}
 	printf("writing %s\n", filename);

fs/fat/file.c

Diff comments View file @ 1ad0b98

 /*
  * file.c
  *
  * Mini "VFS" by Marcus Sundberg
  *
  * 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6
  * 2003-03-10 - kharris@nexus-tech.net - ported to uboot
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <config.h>
 #include <malloc.h>
 #include <fat.h>
 #include <linux/stat.h>
 #include <linux/time.h>
 /* Supported filesystems */
 static const struct filesystem filesystems[] = {
 	{ file_fat_detectfs,  file_fat_ls,  file_fat_read,  "FAT" },
 };
 #define NUM_FILESYS	(sizeof(filesystems)/sizeof(struct filesystem))
 /* The filesystem which was last detected */
 static int current_filesystem = FSTYPE_NONE;
 /* The current working directory */
 #define CWD_LEN		511
 char file_cwd[CWD_LEN+1] = "/";
 const char *
 file_getfsname(int idx)
 {
 	if (idx < 0 || idx >= NUM_FILESYS)
 		return NULL;
 	return filesystems[idx].name;
 }
 static void
 pathcpy(char *dest, const char *src)
 {
 	char *origdest = dest;
 	do {
 		if (dest-file_cwd >= CWD_LEN) {
 			*dest = '\0';
 			return;
 		}
 		*(dest) = *(src);
 		if (*src == '\0') {
 			if (dest-- != origdest && ISDIRDELIM(*dest)) {
 				*dest = '\0';
 			}
 			return;
 		}
 		++dest;
 		if (ISDIRDELIM(*src))
 			while (ISDIRDELIM(*src)) src++;
 		else
 			src++;
 	} while (1);
 }
 int
 file_cd(const char *path)
 {
 	if (ISDIRDELIM(*path)) {
 		while (ISDIRDELIM(*path)) path++;
 		strncpy(file_cwd+1, path, CWD_LEN-1);
 	} else {
 		const char *origpath = path;
 		char *tmpstr = file_cwd;
 		int back = 0;
 		while (*tmpstr != '\0') tmpstr++;
 		do {
 			tmpstr--;
 		} while (ISDIRDELIM(*tmpstr));
 		while (*path == '.') {
 			path++;
 			while (*path == '.') {
 				path++;
 				back++;
 			}
 			if (*path != '\0' && !ISDIRDELIM(*path)) {
 				path = origpath;
 				back = 0;
 				break;
 			}
 			while (ISDIRDELIM(*path)) path++;
 			origpath = path;
 		}
 		while (back--) {
 			/* Strip off path component */
 			while (!ISDIRDELIM(*tmpstr)) {
 				tmpstr--;
 			}
 			if (tmpstr == file_cwd) {
 				/* Incremented again right after the loop. */
 				tmpstr--;
 				break;
 			}
 			/* Skip delimiters */
 			while (ISDIRDELIM(*tmpstr)) tmpstr--;
 		}
 		tmpstr++;
 		if (*path == '\0') {
 			if (tmpstr == file_cwd) {
 				*tmpstr = '/';
 				tmpstr++;
 			}
 			*tmpstr = '\0';
 			return 0;
 		}
 		*tmpstr = '/';
 		pathcpy(tmpstr+1, path);
 	}
 	return 0;
 }
 int
 file_detectfs(void)
 {
 	int i;
 	current_filesystem = FSTYPE_NONE;
 	for (i = 0; i < NUM_FILESYS; i++) {
 		if (filesystems[i].detect() == 0) {
 			strcpy(file_cwd, "/");
 			current_filesystem = i;
 			break;
 		}
 	}
 	return current_filesystem;
 }
 int
 file_ls(const char *dir)
 {
 	char fullpath[1024];
 	const char *arg;
 	if (current_filesystem == FSTYPE_NONE) {
 		printf("Can't list files without a filesystem!\n");
 		return -1;
 	}
 	if (ISDIRDELIM(*dir)) {
 		arg = dir;
 	} else {
 		sprintf(fullpath, "%s/%s", file_cwd, dir);
 		arg = fullpath;
 	}
 	return filesystems[current_filesystem].ls(arg);
 }
-long
+int file_read(const char *filename, void *buffer, int maxsize)
-file_read(const char *filename, void *buffer, unsigned long maxsize)
 {
 	char fullpath[1024];
 	const char *arg;
 	if (current_filesystem == FSTYPE_NONE) {
 		printf("Can't load file without a filesystem!\n");
 		return -1;
 	}
 	if (ISDIRDELIM(*filename)) {
 		arg = filename;
 	} else {
 		sprintf(fullpath, "%s/%s", file_cwd, filename);
 		arg = fullpath;
 	}
 	return filesystems[current_filesystem].read(arg, buffer, maxsize);
 }

include/fat.h

Diff comments View file @ 1ad0b98

 /*
  * R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg
  *
  * 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6
  * 2003-03-10 - kharris@nexus-tech.net - ported to u-boot
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef _FAT_H_
 #define _FAT_H_
 #include <asm/byteorder.h>
 #define CONFIG_SUPPORT_VFAT
 /* Maximum Long File Name length supported here is 128 UTF-16 code units */
 #define VFAT_MAXLEN_BYTES	256 /* Maximum LFN buffer in bytes */
 #define VFAT_MAXSEQ		9   /* Up to 9 of 13 2-byte UTF-16 entries */
 #define PREFETCH_BLOCKS		2
 #ifndef CONFIG_FS_FAT_MAX_CLUSTSIZE
 #define CONFIG_FS_FAT_MAX_CLUSTSIZE 65536
 #endif
 #define MAX_CLUSTSIZE	CONFIG_FS_FAT_MAX_CLUSTSIZE
 #define DIRENTSPERBLOCK	(mydata->sect_size / sizeof(dir_entry))
 #define DIRENTSPERCLUST	((mydata->clust_size * mydata->sect_size) / \
 			 sizeof(dir_entry))
 #define FATBUFBLOCKS	6
 #define FATBUFSIZE	(mydata->sect_size * FATBUFBLOCKS)
 #define FAT12BUFSIZE	((FATBUFSIZE*2)/3)
 #define FAT16BUFSIZE	(FATBUFSIZE/2)
 #define FAT32BUFSIZE	(FATBUFSIZE/4)
 /* Filesystem identifiers */
 #define FAT12_SIGN	"FAT12   "
 #define FAT16_SIGN	"FAT16   "
 #define FAT32_SIGN	"FAT32   "
 #define SIGNLEN		8
 /* File attributes */
 #define ATTR_RO	1
 #define ATTR_HIDDEN	2
 #define ATTR_SYS	4
 #define ATTR_VOLUME	8
 #define ATTR_DIR	16
 #define ATTR_ARCH	32
 #define ATTR_VFAT	(ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME)
 #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
  * dir entries
  */
 #define LAST_LONG_ENTRY_MASK	0x40
 /* Flags telling whether we should read a file or list a directory */
 #define LS_NO		0
 #define LS_YES		1
 #define LS_DIR		1
 #define LS_ROOT		2
 #define ISDIRDELIM(c)	((c) == '/' || (c) == '\\')
 #define FSTYPE_NONE	(-1)
 #if defined(__linux__) && defined(__KERNEL__)
 #define FAT2CPU16	le16_to_cpu
 #define FAT2CPU32	le32_to_cpu
 #else
 #if __LITTLE_ENDIAN
 #define FAT2CPU16(x)	(x)
 #define FAT2CPU32(x)	(x)
 #else
 #define FAT2CPU16(x)	((((x) & 0x00ff) << 8) | (((x) & 0xff00) >> 8))
 #define FAT2CPU32(x)	((((x) & 0x000000ff) << 24)  |	\
 			 (((x) & 0x0000ff00) << 8)  |	\
 			 (((x) & 0x00ff0000) >> 8)  |	\
 			 (((x) & 0xff000000) >> 24))
 #endif
 #endif
 #define START(dent)	(FAT2CPU16((dent)->start) \
 			+ (mydata->fatsize != 32 ? 0 : \
 			  (FAT2CPU16((dent)->starthi) << 16)))
 #define IS_LAST_CLUST(x, fatsize) ((x) >= ((fatsize) != 32 ? \
 					((fatsize) != 16 ? 0xff8 : 0xfff8) : \
 					0xffffff8))
 #define CHECK_CLUST(x, fatsize) ((x) <= 1 || \
 				(x) >= ((fatsize) != 32 ? \
 					((fatsize) != 16 ? 0xff0 : 0xfff0) : \
 					0xffffff0))
 typedef struct boot_sector {
 	__u8	ignored[3];	/* Bootstrap code */
 	char	system_id[8];	/* Name of fs */
 	__u8	sector_size[2];	/* Bytes/sector */
 	__u8	cluster_size;	/* Sectors/cluster */
 	__u16	reserved;	/* Number of reserved sectors */
 	__u8	fats;		/* Number of FATs */
 	__u8	dir_entries[2];	/* Number of root directory entries */
 	__u8	sectors[2];	/* Number of sectors */
 	__u8	media;		/* Media code */
 	__u16	fat_length;	/* Sectors/FAT */
 	__u16	secs_track;	/* Sectors/track */
 	__u16	heads;		/* Number of heads */
 	__u32	hidden;		/* Number of hidden sectors */
 	__u32	total_sect;	/* Number of sectors (if sectors == 0) */
 	/* FAT32 only */
 	__u32	fat32_length;	/* Sectors/FAT */
 	__u16	flags;		/* Bit 8: fat mirroring, low 4: active fat */
 	__u8	version[2];	/* Filesystem version */
 	__u32	root_cluster;	/* First cluster in root directory */
 	__u16	info_sector;	/* Filesystem info sector */
 	__u16	backup_boot;	/* Backup boot sector */
 	__u16	reserved2[6];	/* Unused */
 } boot_sector;
 typedef struct volume_info
 {
 	__u8 drive_number;	/* BIOS drive number */
 	__u8 reserved;		/* Unused */
 	__u8 ext_boot_sign;	/* 0x29 if fields below exist (DOS 3.3+) */
 	__u8 volume_id[4];	/* Volume ID number */
 	char volume_label[11];	/* Volume label */
 	char fs_type[8];	/* Typically FAT12, FAT16, or FAT32 */
 	/* Boot code comes next, all but 2 bytes to fill up sector */
 	/* Boot sign comes last, 2 bytes */
 } volume_info;
 typedef struct dir_entry {
 	char	name[8],ext[3];	/* Name and extension */
 	__u8	attr;		/* Attribute bits */
 	__u8	lcase;		/* Case for base and extension */
 	__u8	ctime_ms;	/* Creation time, milliseconds */
 	__u16	ctime;		/* Creation time */
 	__u16	cdate;		/* Creation date */
 	__u16	adate;		/* Last access date */
 	__u16	starthi;	/* High 16 bits of cluster in FAT32 */
 	__u16	time,date,start;/* Time, date and first cluster */
 	__u32	size;		/* File size in bytes */
 } dir_entry;
 typedef struct dir_slot {
 	__u8	id;		/* Sequence number for slot */
 	__u8	name0_4[10];	/* First 5 characters in name */
 	__u8	attr;		/* Attribute byte */
 	__u8	reserved;	/* Unused */
 	__u8	alias_checksum;/* Checksum for 8.3 alias */
 	__u8	name5_10[12];	/* 6 more characters in name */
 	__u16	start;		/* Unused */
 	__u8	name11_12[4];	/* Last 2 characters in name */
 } dir_slot;
 /*
  * Private filesystem parameters
  *
  * Note: FAT buffer has to be 32 bit aligned
  * (see FAT32 accesses)
  */
 typedef struct {
 	__u8	*fatbuf;	/* Current FAT buffer */
 	int	fatsize;	/* Size of FAT in bits */
 	__u32	fatlength;	/* Length of FAT in sectors */
 	__u16	fat_sect;	/* Starting sector of the FAT */
 	__u32	rootdir_sect;	/* Start sector of root directory */
 	__u16	sect_size;	/* Size of sectors in bytes */
 	__u16	clust_size;	/* Size of clusters in sectors */
 	int	data_begin;	/* The sector of the first cluster, can be negative */
 	int	fatbufnum;	/* Used by get_fatent, init to -1 */
 } fsdata;
 typedef int	(file_detectfs_func)(void);
 typedef int	(file_ls_func)(const char *dir);
-typedef long	(file_read_func)(const char *filename, void *buffer,
+typedef int	(file_read_func)(const char *filename, void *buffer,
-				 unsigned long maxsize);
+				 int maxsize);
 struct filesystem {
 	file_detectfs_func	*detect;
 	file_ls_func		*ls;
 	file_read_func		*read;
 	const char		name[12];
 };
 /* FAT tables */
 file_detectfs_func	file_fat_detectfs;
 file_ls_func		file_fat_ls;
 file_read_func		file_fat_read;
 /* Currently this doesn't check if the dir exists or is valid... */
 int file_cd(const char *path);
 int file_fat_detectfs(void);
 int file_fat_ls(const char *dir);
 int fat_exists(const char *filename);
 int fat_size(const char *filename);
-long file_fat_read_at(const char *filename, unsigned long pos, void *buffer,
+int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
-		      unsigned long maxsize);
+		     loff_t maxsize, loff_t *actread);
-long file_fat_read(const char *filename, void *buffer, unsigned long maxsize);
+int file_fat_read(const char *filename, void *buffer, int maxsize);
 const char *file_getfsname(int idx);
 int fat_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info);
 int fat_register_device(block_dev_desc_t *dev_desc, int part_no);
-int file_fat_write(const char *filename, void *buffer, unsigned long maxsize);
+int file_fat_write(const char *filename, void *buf, loff_t offset, loff_t len,
+		   loff_t *actwrite);
 int fat_read_file(const char *filename, void *buf, int offset, int len);
 void fat_close(void);
 #endif /* _FAT_H_ */