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