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