blob: c450bf6924431ba5d399ec3423fb854b2a4a64ea [file] [log] [blame]
wdenk71f95112003-06-15 22:40:42 +00001/*
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 <fat.h>
31#include <asm/byteorder.h>
wdenk7205e402003-09-10 22:30:53 +000032#include <part.h>
wdenk71f95112003-06-15 22:40:42 +000033
wdenk71f95112003-06-15 22:40:42 +000034/*
35 * Convert a string to lowercase.
36 */
Wolfgang Denk7385c282010-07-19 11:37:00 +020037static void downcase (char *str)
wdenk71f95112003-06-15 22:40:42 +000038{
39 while (*str != '\0') {
40 TOLOWER(*str);
41 str++;
42 }
43}
44
Wolfgang Denk7385c282010-07-19 11:37:00 +020045static block_dev_desc_t *cur_dev = NULL;
46
wdenk7205e402003-09-10 22:30:53 +000047static unsigned long part_offset = 0;
Wolfgang Denk7385c282010-07-19 11:37:00 +020048
wdenk7205e402003-09-10 22:30:53 +000049static int cur_part = 1;
50
51#define DOS_PART_TBL_OFFSET 0x1be
52#define DOS_PART_MAGIC_OFFSET 0x1fe
53#define DOS_FS_TYPE_OFFSET 0x36
Wolfgang Denk66c2d732010-07-19 11:36:57 +020054#define DOS_FS32_TYPE_OFFSET 0x52
wdenk71f95112003-06-15 22:40:42 +000055
Wolfgang Denk7385c282010-07-19 11:37:00 +020056static int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr)
wdenk71f95112003-06-15 22:40:42 +000057{
wdenk7205e402003-09-10 22:30:53 +000058 if (cur_dev == NULL)
59 return -1;
Wolfgang Denk7385c282010-07-19 11:37:00 +020060
61 startblock += part_offset;
62
wdenk7205e402003-09-10 22:30:53 +000063 if (cur_dev->block_read) {
Wolfgang Denk7385c282010-07-19 11:37:00 +020064 return cur_dev->block_read(cur_dev->dev, startblock, getsize,
65 (unsigned long *) bufptr);
wdenk71f95112003-06-15 22:40:42 +000066 }
67 return -1;
68}
69
Wolfgang Denk7385c282010-07-19 11:37:00 +020070int fat_register_device (block_dev_desc_t * dev_desc, int part_no)
wdenk71f95112003-06-15 22:40:42 +000071{
wdenk7205e402003-09-10 22:30:53 +000072 unsigned char buffer[SECTOR_SIZE];
Wolfgang Denk7385c282010-07-19 11:37:00 +020073
Heiko Schocher566a4942007-06-22 19:11:54 +020074 disk_partition_t info;
wdenk7205e402003-09-10 22:30:53 +000075
76 if (!dev_desc->block_read)
77 return -1;
Wolfgang Denk7385c282010-07-19 11:37:00 +020078
Heiko Schocher566a4942007-06-22 19:11:54 +020079 cur_dev = dev_desc;
wdenk7205e402003-09-10 22:30:53 +000080 /* check if we have a MBR (on floppies we have only a PBR) */
Wolfgang Denk7385c282010-07-19 11:37:00 +020081 if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)buffer) != 1) {
82 printf("** Can't read from device %d **\n",
83 dev_desc->dev);
wdenk7205e402003-09-10 22:30:53 +000084 return -1;
85 }
86 if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
Wolfgang Denk7385c282010-07-19 11:37:00 +020087 buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) {
wdenk7205e402003-09-10 22:30:53 +000088 /* no signature found */
89 return -1;
90 }
Jon Loeligerdd60d122007-07-09 17:56:50 -050091#if (defined(CONFIG_CMD_IDE) || \
unsik Kim75eb82e2009-02-25 11:31:24 +090092 defined(CONFIG_CMD_MG_DISK) || \
Sonic Zhang8c5170a2008-12-09 23:20:18 -050093 defined(CONFIG_CMD_SATA) || \
Jon Loeligerdd60d122007-07-09 17:56:50 -050094 defined(CONFIG_CMD_SCSI) || \
95 defined(CONFIG_CMD_USB) || \
Andy Fleming02df4a22008-01-09 13:51:32 -060096 defined(CONFIG_MMC) || \
97 defined(CONFIG_SYSTEMACE) )
Wolfgang Denk7385c282010-07-19 11:37:00 +020098 /* First we assume there is a MBR */
99 if (!get_partition_info(dev_desc, part_no, &info)) {
Andy Fleming02df4a22008-01-09 13:51:32 -0600100 part_offset = info.start;
101 cur_part = part_no;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200102 } else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3) == 0) ||
103 (strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET], "FAT32", 5) == 0)) {
Andy Fleming02df4a22008-01-09 13:51:32 -0600104 /* ok, we assume we are on a PBR only */
105 cur_part = 1;
106 part_offset = 0;
107 } else {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200108 printf("** Partition %d not valid on device %d **\n",
109 part_no, dev_desc->dev);
Andy Fleming02df4a22008-01-09 13:51:32 -0600110 return -1;
Wolfgang Denkbf1060e2007-08-07 16:02:13 +0200111 }
Andy Fleming02df4a22008-01-09 13:51:32 -0600112
113#else
Wolfgang Denk66c2d732010-07-19 11:36:57 +0200114 if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3) == 0) ||
115 (strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET], "FAT32", 5) == 0)) {
Andy Fleming02df4a22008-01-09 13:51:32 -0600116 /* ok, we assume we are on a PBR only */
117 cur_part = 1;
118 part_offset = 0;
119 info.start = part_offset;
120 } else {
121 /* FIXME we need to determine the start block of the
122 * partition where the DOS FS resides. This can be done
123 * by using the get_partition_info routine. For this
124 * purpose the libpart must be included.
125 */
126 part_offset = 32;
127 cur_part = 1;
128 }
129#endif
wdenk71f95112003-06-15 22:40:42 +0000130 return 0;
131}
132
wdenk71f95112003-06-15 22:40:42 +0000133/*
134 * Get the first occurence of a directory delimiter ('/' or '\') in a string.
135 * Return index into string if found, -1 otherwise.
136 */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200137static int dirdelim (char *str)
wdenk71f95112003-06-15 22:40:42 +0000138{
139 char *start = str;
140
141 while (*str != '\0') {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200142 if (ISDIRDELIM(*str))
143 return str - start;
wdenk71f95112003-06-15 22:40:42 +0000144 str++;
145 }
146 return -1;
147}
148
wdenk71f95112003-06-15 22:40:42 +0000149/*
150 * Extract zero terminated short name from a directory entry.
151 */
152static void get_name (dir_entry *dirent, char *s_name)
153{
154 char *ptr;
155
Wolfgang Denk7385c282010-07-19 11:37:00 +0200156 memcpy(s_name, dirent->name, 8);
wdenk71f95112003-06-15 22:40:42 +0000157 s_name[8] = '\0';
158 ptr = s_name;
159 while (*ptr && *ptr != ' ')
160 ptr++;
161 if (dirent->ext[0] && dirent->ext[0] != ' ') {
162 *ptr = '.';
163 ptr++;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200164 memcpy(ptr, dirent->ext, 3);
wdenk71f95112003-06-15 22:40:42 +0000165 ptr[3] = '\0';
166 while (*ptr && *ptr != ' ')
167 ptr++;
168 }
169 *ptr = '\0';
170 if (*s_name == DELETED_FLAG)
171 *s_name = '\0';
172 else if (*s_name == aRING)
Remy Bohmer3c2c2f42008-11-27 22:30:27 +0100173 *s_name = DELETED_FLAG;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200174 downcase(s_name);
wdenk71f95112003-06-15 22:40:42 +0000175}
176
177/*
178 * Get the entry at index 'entry' in a FAT (12/16/32) table.
179 * On failure 0x00 is returned.
180 */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200181static __u32 get_fatent (fsdata *mydata, __u32 entry)
wdenk71f95112003-06-15 22:40:42 +0000182{
183 __u32 bufnum;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200184 __u32 off16, offset;
wdenk71f95112003-06-15 22:40:42 +0000185 __u32 ret = 0x00;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200186 __u16 val1, val2;
wdenk71f95112003-06-15 22:40:42 +0000187
188 switch (mydata->fatsize) {
189 case 32:
190 bufnum = entry / FAT32BUFSIZE;
191 offset = entry - bufnum * FAT32BUFSIZE;
192 break;
193 case 16:
194 bufnum = entry / FAT16BUFSIZE;
195 offset = entry - bufnum * FAT16BUFSIZE;
196 break;
197 case 12:
198 bufnum = entry / FAT12BUFSIZE;
199 offset = entry - bufnum * FAT12BUFSIZE;
200 break;
201
202 default:
203 /* Unsupported FAT size */
204 return ret;
205 }
206
Wolfgang Denk7385c282010-07-19 11:37:00 +0200207 debug("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n",
208 mydata->fatsize, entry, entry, offset, offset);
Wolfgang Denk2aa98c62010-07-19 11:36:58 +0200209
wdenk71f95112003-06-15 22:40:42 +0000210 /* Read a new block of FAT entries into the cache. */
211 if (bufnum != mydata->fatbufnum) {
Erik Hansen3f270f42011-03-24 10:15:37 +0100212 __u32 getsize = FATBUFSIZE / FS_BLOCK_SIZE;
wdenk71f95112003-06-15 22:40:42 +0000213 __u8 *bufptr = mydata->fatbuf;
214 __u32 fatlength = mydata->fatlength;
215 __u32 startblock = bufnum * FATBUFBLOCKS;
216
217 fatlength *= SECTOR_SIZE; /* We want it in bytes now */
218 startblock += mydata->fat_sect; /* Offset from start of disk */
219
Wolfgang Denk7385c282010-07-19 11:37:00 +0200220 if (getsize > fatlength)
221 getsize = fatlength;
wdenk71f95112003-06-15 22:40:42 +0000222 if (disk_read(startblock, getsize, bufptr) < 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200223 debug("Error reading FAT blocks\n");
wdenk71f95112003-06-15 22:40:42 +0000224 return ret;
225 }
226 mydata->fatbufnum = bufnum;
227 }
228
229 /* Get the actual entry from the table */
230 switch (mydata->fatsize) {
231 case 32:
Wolfgang Denk7385c282010-07-19 11:37:00 +0200232 ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]);
wdenk71f95112003-06-15 22:40:42 +0000233 break;
234 case 16:
Wolfgang Denk7385c282010-07-19 11:37:00 +0200235 ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);
wdenk71f95112003-06-15 22:40:42 +0000236 break;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200237 case 12:
238 off16 = (offset * 3) / 4;
wdenk71f95112003-06-15 22:40:42 +0000239
240 switch (offset & 0x3) {
241 case 0:
Wolfgang Denk7385c282010-07-19 11:37:00 +0200242 ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]);
wdenk71f95112003-06-15 22:40:42 +0000243 ret &= 0xfff;
244 break;
245 case 1:
Wolfgang Denk7385c282010-07-19 11:37:00 +0200246 val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
wdenk71f95112003-06-15 22:40:42 +0000247 val1 &= 0xf000;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200248 val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);
wdenk71f95112003-06-15 22:40:42 +0000249 val2 &= 0x00ff;
250 ret = (val2 << 4) | (val1 >> 12);
251 break;
252 case 2:
Wolfgang Denk7385c282010-07-19 11:37:00 +0200253 val1 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
wdenk71f95112003-06-15 22:40:42 +0000254 val1 &= 0xff00;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200255 val2 = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16 + 1]);
wdenk71f95112003-06-15 22:40:42 +0000256 val2 &= 0x000f;
257 ret = (val2 << 8) | (val1 >> 8);
258 break;
259 case 3:
Wolfgang Denk7385c282010-07-19 11:37:00 +0200260 ret = FAT2CPU16(((__u16 *)mydata->fatbuf)[off16]);
wdenk71f95112003-06-15 22:40:42 +0000261 ret = (ret & 0xfff0) >> 4;
262 break;
263 default:
264 break;
265 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200266 break;
wdenk71f95112003-06-15 22:40:42 +0000267 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200268 debug("FAT%d: ret: %08x, offset: %04x\n",
269 mydata->fatsize, ret, offset);
wdenk71f95112003-06-15 22:40:42 +0000270
271 return ret;
272}
273
wdenk71f95112003-06-15 22:40:42 +0000274/*
275 * Read at most 'size' bytes from the specified cluster into 'buffer'.
276 * Return 0 on success, -1 otherwise.
277 */
278static int
Wolfgang Denk7385c282010-07-19 11:37:00 +0200279get_cluster (fsdata *mydata, __u32 clustnum, __u8 *buffer,
280 unsigned long size)
wdenk71f95112003-06-15 22:40:42 +0000281{
Erik Hansen3f270f42011-03-24 10:15:37 +0100282 __u32 idx = 0;
wdenk71f95112003-06-15 22:40:42 +0000283 __u32 startsect;
284
285 if (clustnum > 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200286 startsect = mydata->data_begin +
287 clustnum * mydata->clust_size;
wdenk71f95112003-06-15 22:40:42 +0000288 } else {
289 startsect = mydata->rootdir_sect;
290 }
291
Wolfgang Denk7385c282010-07-19 11:37:00 +0200292 debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect);
293
294 if (disk_read(startsect, size / FS_BLOCK_SIZE, buffer) < 0) {
295 debug("Error reading data\n");
wdenk7205e402003-09-10 22:30:53 +0000296 return -1;
297 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200298 if (size % FS_BLOCK_SIZE) {
wdenk7205e402003-09-10 22:30:53 +0000299 __u8 tmpbuf[FS_BLOCK_SIZE];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200300
301 idx = size / FS_BLOCK_SIZE;
wdenk7205e402003-09-10 22:30:53 +0000302 if (disk_read(startsect + idx, 1, tmpbuf) < 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200303 debug("Error reading data\n");
wdenk7205e402003-09-10 22:30:53 +0000304 return -1;
wdenk71f95112003-06-15 22:40:42 +0000305 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200306 buffer += idx * FS_BLOCK_SIZE;
wdenk7205e402003-09-10 22:30:53 +0000307
308 memcpy(buffer, tmpbuf, size % FS_BLOCK_SIZE);
309 return 0;
wdenk71f95112003-06-15 22:40:42 +0000310 }
311
312 return 0;
313}
314
wdenk71f95112003-06-15 22:40:42 +0000315/*
316 * Read at most 'maxsize' bytes from the file associated with 'dentptr'
317 * into 'buffer'.
318 * Return the number of bytes read or -1 on fatal errors.
319 */
320static long
Wolfgang Denk7385c282010-07-19 11:37:00 +0200321get_contents (fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
322 unsigned long maxsize)
wdenk71f95112003-06-15 22:40:42 +0000323{
324 unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
325 unsigned int bytesperclust = mydata->clust_size * SECTOR_SIZE;
326 __u32 curclust = START(dentptr);
wdenk7205e402003-09-10 22:30:53 +0000327 __u32 endclust, newclust;
328 unsigned long actsize;
wdenk71f95112003-06-15 22:40:42 +0000329
Wolfgang Denk7385c282010-07-19 11:37:00 +0200330 debug("Filesize: %ld bytes\n", filesize);
wdenk71f95112003-06-15 22:40:42 +0000331
Wolfgang Denk7385c282010-07-19 11:37:00 +0200332 if (maxsize > 0 && filesize > maxsize)
333 filesize = maxsize;
wdenk71f95112003-06-15 22:40:42 +0000334
Wolfgang Denk7385c282010-07-19 11:37:00 +0200335 debug("%ld bytes\n", filesize);
wdenk71f95112003-06-15 22:40:42 +0000336
Wolfgang Denk7385c282010-07-19 11:37:00 +0200337 actsize = bytesperclust;
338 endclust = curclust;
339
wdenk71f95112003-06-15 22:40:42 +0000340 do {
wdenk7205e402003-09-10 22:30:53 +0000341 /* search for consecutive clusters */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200342 while (actsize < filesize) {
wdenk7205e402003-09-10 22:30:53 +0000343 newclust = get_fatent(mydata, endclust);
Wolfgang Denk7385c282010-07-19 11:37:00 +0200344 if ((newclust - 1) != endclust)
wdenk7205e402003-09-10 22:30:53 +0000345 goto getit;
michael8ce4e5c2008-03-02 23:33:46 +0100346 if (CHECK_CLUST(newclust, mydata->fatsize)) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200347 debug("curclust: 0x%x\n", newclust);
348 debug("Invalid FAT entry\n");
wdenk7205e402003-09-10 22:30:53 +0000349 return gotsize;
350 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200351 endclust = newclust;
352 actsize += bytesperclust;
wdenk7205e402003-09-10 22:30:53 +0000353 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200354
wdenk7205e402003-09-10 22:30:53 +0000355 /* actsize >= file size */
356 actsize -= bytesperclust;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200357
wdenk7205e402003-09-10 22:30:53 +0000358 /* get remaining clusters */
359 if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200360 printf("Error reading cluster\n");
wdenk71f95112003-06-15 22:40:42 +0000361 return -1;
362 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200363
wdenk7205e402003-09-10 22:30:53 +0000364 /* get remaining bytes */
365 gotsize += (int)actsize;
366 filesize -= actsize;
367 buffer += actsize;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200368 actsize = filesize;
wdenk7205e402003-09-10 22:30:53 +0000369 if (get_cluster(mydata, endclust, buffer, (int)actsize) != 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200370 printf("Error reading cluster\n");
wdenk7205e402003-09-10 22:30:53 +0000371 return -1;
372 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200373 gotsize += actsize;
wdenk7205e402003-09-10 22:30:53 +0000374 return gotsize;
375getit:
376 if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200377 printf("Error reading cluster\n");
wdenk7205e402003-09-10 22:30:53 +0000378 return -1;
379 }
380 gotsize += (int)actsize;
381 filesize -= actsize;
382 buffer += actsize;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200383
wdenk7205e402003-09-10 22:30:53 +0000384 curclust = get_fatent(mydata, endclust);
michael8ce4e5c2008-03-02 23:33:46 +0100385 if (CHECK_CLUST(curclust, mydata->fatsize)) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200386 debug("curclust: 0x%x\n", curclust);
387 printf("Invalid FAT entry\n");
wdenk71f95112003-06-15 22:40:42 +0000388 return gotsize;
389 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200390 actsize = bytesperclust;
391 endclust = curclust;
wdenk71f95112003-06-15 22:40:42 +0000392 } while (1);
393}
394
wdenk71f95112003-06-15 22:40:42 +0000395#ifdef CONFIG_SUPPORT_VFAT
396/*
397 * Extract the file name information from 'slotptr' into 'l_name',
398 * starting at l_name[*idx].
399 * Return 1 if terminator (zero byte) is found, 0 otherwise.
400 */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200401static int slot2str (dir_slot *slotptr, char *l_name, int *idx)
wdenk71f95112003-06-15 22:40:42 +0000402{
403 int j;
404
405 for (j = 0; j <= 8; j += 2) {
406 l_name[*idx] = slotptr->name0_4[j];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200407 if (l_name[*idx] == 0x00)
408 return 1;
wdenk71f95112003-06-15 22:40:42 +0000409 (*idx)++;
410 }
411 for (j = 0; j <= 10; j += 2) {
412 l_name[*idx] = slotptr->name5_10[j];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200413 if (l_name[*idx] == 0x00)
414 return 1;
wdenk71f95112003-06-15 22:40:42 +0000415 (*idx)++;
416 }
417 for (j = 0; j <= 2; j += 2) {
418 l_name[*idx] = slotptr->name11_12[j];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200419 if (l_name[*idx] == 0x00)
420 return 1;
wdenk71f95112003-06-15 22:40:42 +0000421 (*idx)++;
422 }
423
424 return 0;
425}
426
wdenk71f95112003-06-15 22:40:42 +0000427/*
428 * Extract the full long filename starting at 'retdent' (which is really
429 * a slot) into 'l_name'. If successful also copy the real directory entry
430 * into 'retdent'
431 * Return 0 on success, -1 otherwise.
432 */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200433__attribute__ ((__aligned__ (__alignof__ (dir_entry))))
Bryan Wu7e4b9b42009-01-02 20:47:45 -0500434__u8 get_vfatname_block[MAX_CLUSTSIZE];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200435
wdenk71f95112003-06-15 22:40:42 +0000436static int
Wolfgang Denk7385c282010-07-19 11:37:00 +0200437get_vfatname (fsdata *mydata, int curclust, __u8 *cluster,
438 dir_entry *retdent, char *l_name)
wdenk71f95112003-06-15 22:40:42 +0000439{
440 dir_entry *realdent;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200441 dir_slot *slotptr = (dir_slot *)retdent;
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300442 __u8 *buflimit = cluster + ((curclust == 0) ?
443 LINEAR_PREFETCH_SIZE :
444 (mydata->clust_size * SECTOR_SIZE)
445 );
Wolfgang Denk7385c282010-07-19 11:37:00 +0200446 __u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff;
wdenk71f95112003-06-15 22:40:42 +0000447 int idx = 0;
448
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300449 if (counter > VFAT_MAXSEQ) {
450 debug("Error: VFAT name is too long\n");
451 return -1;
452 }
453
454 while ((__u8 *)slotptr < buflimit) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200455 if (counter == 0)
456 break;
wdenk2d1a5372004-02-23 19:30:57 +0000457 if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
458 return -1;
wdenk71f95112003-06-15 22:40:42 +0000459 slotptr++;
460 counter--;
461 }
462
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300463 if ((__u8 *)slotptr >= buflimit) {
wdenk71f95112003-06-15 22:40:42 +0000464 dir_slot *slotptr2;
465
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300466 if (curclust == 0)
467 return -1;
wdenk71f95112003-06-15 22:40:42 +0000468 curclust = get_fatent(mydata, curclust);
michael8ce4e5c2008-03-02 23:33:46 +0100469 if (CHECK_CLUST(curclust, mydata->fatsize)) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200470 debug("curclust: 0x%x\n", curclust);
471 printf("Invalid FAT entry\n");
wdenk71f95112003-06-15 22:40:42 +0000472 return -1;
473 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200474
wdenk5fa66df2003-10-29 23:18:55 +0000475 if (get_cluster(mydata, curclust, get_vfatname_block,
wdenk71f95112003-06-15 22:40:42 +0000476 mydata->clust_size * SECTOR_SIZE) != 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200477 debug("Error: reading directory block\n");
wdenk71f95112003-06-15 22:40:42 +0000478 return -1;
479 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200480
481 slotptr2 = (dir_slot *)get_vfatname_block;
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300482 while (counter > 0) {
483 if (((slotptr2->id & ~LAST_LONG_ENTRY_MASK)
484 & 0xff) != counter)
485 return -1;
wdenk71f95112003-06-15 22:40:42 +0000486 slotptr2++;
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300487 counter--;
488 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200489
wdenk71f95112003-06-15 22:40:42 +0000490 /* Save the real directory entry */
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300491 realdent = (dir_entry *)slotptr2;
492 while ((__u8 *)slotptr2 > get_vfatname_block) {
wdenk71f95112003-06-15 22:40:42 +0000493 slotptr2--;
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300494 slot2str(slotptr2, l_name, &idx);
wdenk71f95112003-06-15 22:40:42 +0000495 }
496 } else {
497 /* Save the real directory entry */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200498 realdent = (dir_entry *)slotptr;
wdenk71f95112003-06-15 22:40:42 +0000499 }
500
501 do {
502 slotptr--;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200503 if (slot2str(slotptr, l_name, &idx))
504 break;
wdenk2d1a5372004-02-23 19:30:57 +0000505 } while (!(slotptr->id & LAST_LONG_ENTRY_MASK));
wdenk71f95112003-06-15 22:40:42 +0000506
507 l_name[idx] = '\0';
Wolfgang Denk7385c282010-07-19 11:37:00 +0200508 if (*l_name == DELETED_FLAG)
509 *l_name = '\0';
510 else if (*l_name == aRING)
511 *l_name = DELETED_FLAG;
wdenk71f95112003-06-15 22:40:42 +0000512 downcase(l_name);
513
514 /* Return the real directory entry */
515 memcpy(retdent, realdent, sizeof(dir_entry));
516
517 return 0;
518}
519
wdenk71f95112003-06-15 22:40:42 +0000520/* Calculate short name checksum */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200521static __u8 mkcksum (const char *str)
wdenk71f95112003-06-15 22:40:42 +0000522{
523 int i;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200524
wdenk71f95112003-06-15 22:40:42 +0000525 __u8 ret = 0;
526
527 for (i = 0; i < 11; i++) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200528 ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + str[i];
wdenk71f95112003-06-15 22:40:42 +0000529 }
530
531 return ret;
532}
Wolfgang Denk7385c282010-07-19 11:37:00 +0200533#endif /* CONFIG_SUPPORT_VFAT */
wdenk71f95112003-06-15 22:40:42 +0000534
535/*
536 * Get the directory entry associated with 'filename' from the directory
537 * starting at 'startsect'
538 */
Wolfgang Denk7385c282010-07-19 11:37:00 +0200539__attribute__ ((__aligned__ (__alignof__ (dir_entry))))
wdenk5fa66df2003-10-29 23:18:55 +0000540__u8 get_dentfromdir_block[MAX_CLUSTSIZE];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200541
542static dir_entry *get_dentfromdir (fsdata *mydata, int startsect,
543 char *filename, dir_entry *retdent,
wdenk71f95112003-06-15 22:40:42 +0000544 int dols)
545{
Wolfgang Denk7385c282010-07-19 11:37:00 +0200546 __u16 prevcksum = 0xffff;
547 __u32 curclust = START(retdent);
548 int files = 0, dirs = 0;
wdenk71f95112003-06-15 22:40:42 +0000549
Wolfgang Denk7385c282010-07-19 11:37:00 +0200550 debug("get_dentfromdir: %s\n", filename);
wdenk71f95112003-06-15 22:40:42 +0000551
Wolfgang Denk7385c282010-07-19 11:37:00 +0200552 while (1) {
553 dir_entry *dentptr;
wdenk71f95112003-06-15 22:40:42 +0000554
Wolfgang Denk7385c282010-07-19 11:37:00 +0200555 int i;
wdenk71f95112003-06-15 22:40:42 +0000556
Wolfgang Denk7385c282010-07-19 11:37:00 +0200557 if (get_cluster(mydata, curclust, get_dentfromdir_block,
558 mydata->clust_size * SECTOR_SIZE) != 0) {
559 debug("Error: reading directory block\n");
560 return NULL;
561 }
562
563 dentptr = (dir_entry *)get_dentfromdir_block;
564
565 for (i = 0; i < DIRENTSPERCLUST; i++) {
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300566 char s_name[14], l_name[VFAT_MAXLEN_BYTES];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200567
568 l_name[0] = '\0';
569 if (dentptr->name[0] == DELETED_FLAG) {
570 dentptr++;
571 continue;
wdenk71f95112003-06-15 22:40:42 +0000572 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200573 if ((dentptr->attr & ATTR_VOLUME)) {
wdenk71f95112003-06-15 22:40:42 +0000574#ifdef CONFIG_SUPPORT_VFAT
Wolfgang Denk7385c282010-07-19 11:37:00 +0200575 if ((dentptr->attr & ATTR_VFAT) &&
576 (dentptr-> name[0] & LAST_LONG_ENTRY_MASK)) {
577 prevcksum = ((dir_slot *)dentptr)->alias_checksum;
578 get_vfatname(mydata, curclust,
579 get_dentfromdir_block,
580 dentptr, l_name);
581 if (dols) {
582 int isdir;
583 char dirc;
584 int doit = 0;
585
586 isdir = (dentptr->attr & ATTR_DIR);
587
588 if (isdir) {
589 dirs++;
590 dirc = '/';
591 doit = 1;
592 } else {
593 dirc = ' ';
594 if (l_name[0] != 0) {
595 files++;
596 doit = 1;
597 }
598 }
599 if (doit) {
600 if (dirc == ' ') {
601 printf(" %8ld %s%c\n",
602 (long)FAT2CPU32(dentptr->size),
603 l_name,
604 dirc);
605 } else {
606 printf(" %s%c\n",
607 l_name,
608 dirc);
609 }
610 }
611 dentptr++;
612 continue;
613 }
614 debug("vfatname: |%s|\n", l_name);
615 } else
wdenk71f95112003-06-15 22:40:42 +0000616#endif
Wolfgang Denk7385c282010-07-19 11:37:00 +0200617 {
618 /* Volume label or VFAT entry */
619 dentptr++;
620 continue;
621 }
622 }
623 if (dentptr->name[0] == 0) {
624 if (dols) {
625 printf("\n%d file(s), %d dir(s)\n\n",
626 files, dirs);
627 }
628 debug("Dentname == NULL - %d\n", i);
629 return NULL;
630 }
631#ifdef CONFIG_SUPPORT_VFAT
632 if (dols && mkcksum(dentptr->name) == prevcksum) {
633 dentptr++;
634 continue;
635 }
636#endif
637 get_name(dentptr, s_name);
638 if (dols) {
639 int isdir = (dentptr->attr & ATTR_DIR);
640 char dirc;
641 int doit = 0;
wdenk71f95112003-06-15 22:40:42 +0000642
Wolfgang Denk7385c282010-07-19 11:37:00 +0200643 if (isdir) {
644 dirs++;
645 dirc = '/';
646 doit = 1;
647 } else {
648 dirc = ' ';
649 if (s_name[0] != 0) {
650 files++;
651 doit = 1;
652 }
653 }
654
655 if (doit) {
656 if (dirc == ' ') {
657 printf(" %8ld %s%c\n",
658 (long)FAT2CPU32(dentptr->size),
659 s_name, dirc);
660 } else {
661 printf(" %s%c\n",
662 s_name, dirc);
663 }
664 }
665
666 dentptr++;
667 continue;
668 }
669
670 if (strcmp(filename, s_name)
671 && strcmp(filename, l_name)) {
672 debug("Mismatch: |%s|%s|\n", s_name, l_name);
673 dentptr++;
674 continue;
675 }
676
677 memcpy(retdent, dentptr, sizeof(dir_entry));
678
679 debug("DentName: %s", s_name);
680 debug(", start: 0x%x", START(dentptr));
681 debug(", size: 0x%x %s\n",
682 FAT2CPU32(dentptr->size),
683 (dentptr->attr & ATTR_DIR) ? "(DIR)" : "");
684
685 return retdent;
wdenk71f95112003-06-15 22:40:42 +0000686 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200687
688 curclust = get_fatent(mydata, curclust);
689 if (CHECK_CLUST(curclust, mydata->fatsize)) {
690 debug("curclust: 0x%x\n", curclust);
691 printf("Invalid FAT entry\n");
692 return NULL;
wdenk71f95112003-06-15 22:40:42 +0000693 }
wdenk71f95112003-06-15 22:40:42 +0000694 }
wdenk71f95112003-06-15 22:40:42 +0000695
Wolfgang Denk7385c282010-07-19 11:37:00 +0200696 return NULL;
wdenk71f95112003-06-15 22:40:42 +0000697}
698
wdenk71f95112003-06-15 22:40:42 +0000699/*
700 * Read boot sector and volume info from a FAT filesystem
701 */
702static int
Wolfgang Denk7385c282010-07-19 11:37:00 +0200703read_bootsectandvi (boot_sector *bs, volume_info *volinfo, int *fatsize)
wdenk71f95112003-06-15 22:40:42 +0000704{
705 __u8 block[FS_BLOCK_SIZE];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200706
wdenk71f95112003-06-15 22:40:42 +0000707 volume_info *vistart;
708
Wolfgang Denk7385c282010-07-19 11:37:00 +0200709 if (disk_read (0, 1, block) < 0) {
710 debug("Error: reading block\n");
wdenk71f95112003-06-15 22:40:42 +0000711 return -1;
712 }
713
714 memcpy(bs, block, sizeof(boot_sector));
Wolfgang Denk7385c282010-07-19 11:37:00 +0200715 bs->reserved = FAT2CPU16(bs->reserved);
716 bs->fat_length = FAT2CPU16(bs->fat_length);
717 bs->secs_track = FAT2CPU16(bs->secs_track);
718 bs->heads = FAT2CPU16(bs->heads);
719 bs->total_sect = FAT2CPU32(bs->total_sect);
wdenk71f95112003-06-15 22:40:42 +0000720
721 /* FAT32 entries */
722 if (bs->fat_length == 0) {
723 /* Assume FAT32 */
724 bs->fat32_length = FAT2CPU32(bs->fat32_length);
Wolfgang Denk7385c282010-07-19 11:37:00 +0200725 bs->flags = FAT2CPU16(bs->flags);
wdenk71f95112003-06-15 22:40:42 +0000726 bs->root_cluster = FAT2CPU32(bs->root_cluster);
Wolfgang Denk7385c282010-07-19 11:37:00 +0200727 bs->info_sector = FAT2CPU16(bs->info_sector);
728 bs->backup_boot = FAT2CPU16(bs->backup_boot);
729 vistart = (volume_info *)(block + sizeof(boot_sector));
wdenk71f95112003-06-15 22:40:42 +0000730 *fatsize = 32;
731 } else {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200732 vistart = (volume_info *)&(bs->fat32_length);
wdenk71f95112003-06-15 22:40:42 +0000733 *fatsize = 0;
734 }
735 memcpy(volinfo, vistart, sizeof(volume_info));
736
wdenk71f95112003-06-15 22:40:42 +0000737 if (*fatsize == 32) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200738 if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0)
wdenk71f95112003-06-15 22:40:42 +0000739 return 0;
wdenk71f95112003-06-15 22:40:42 +0000740 } else {
Tom Rix651351f2009-05-20 07:55:41 -0500741 if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) {
wdenk71f95112003-06-15 22:40:42 +0000742 *fatsize = 12;
743 return 0;
744 }
Tom Rix651351f2009-05-20 07:55:41 -0500745 if (strncmp(FAT16_SIGN, vistart->fs_type, SIGNLEN) == 0) {
wdenk71f95112003-06-15 22:40:42 +0000746 *fatsize = 16;
747 return 0;
748 }
749 }
750
Wolfgang Denk7385c282010-07-19 11:37:00 +0200751 debug("Error: broken fs_type sign\n");
wdenk71f95112003-06-15 22:40:42 +0000752 return -1;
753}
754
Wolfgang Denk7385c282010-07-19 11:37:00 +0200755__attribute__ ((__aligned__ (__alignof__ (dir_entry))))
Bryan Wu7e4b9b42009-01-02 20:47:45 -0500756__u8 do_fat_read_block[MAX_CLUSTSIZE];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200757
stroese20cc00d2004-12-16 17:57:26 +0000758long
wdenk71f95112003-06-15 22:40:42 +0000759do_fat_read (const char *filename, void *buffer, unsigned long maxsize,
760 int dols)
761{
Wolfgang Denk7385c282010-07-19 11:37:00 +0200762 char fnamecopy[2048];
763 boot_sector bs;
764 volume_info volinfo;
765 fsdata datablock;
766 fsdata *mydata = &datablock;
767 dir_entry *dentptr;
768 __u16 prevcksum = 0xffff;
769 char *subname = "";
Erik Hansen3f270f42011-03-24 10:15:37 +0100770 __u32 cursect;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200771 int idx, isdir = 0;
772 int files = 0, dirs = 0;
773 long ret = 0;
774 int firsttime;
Erik Hansen3f270f42011-03-24 10:15:37 +0100775 __u32 root_cluster;
776 int rootdir_size = 0;
Wolfgang Denk7385c282010-07-19 11:37:00 +0200777 int j;
wdenk71f95112003-06-15 22:40:42 +0000778
Wolfgang Denk7385c282010-07-19 11:37:00 +0200779 if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
780 debug("Error: reading boot sector\n");
781 return -1;
782 }
783
Wolfgang Denk2aa98c62010-07-19 11:36:58 +0200784 root_cluster = bs.root_cluster;
Wolfgang Denk2aa98c62010-07-19 11:36:58 +0200785
Wolfgang Denk7385c282010-07-19 11:37:00 +0200786 if (mydata->fatsize == 32)
787 mydata->fatlength = bs.fat32_length;
788 else
789 mydata->fatlength = bs.fat_length;
wdenk71f95112003-06-15 22:40:42 +0000790
Wolfgang Denk7385c282010-07-19 11:37:00 +0200791 mydata->fat_sect = bs.reserved;
wdenk71f95112003-06-15 22:40:42 +0000792
Wolfgang Denk7385c282010-07-19 11:37:00 +0200793 cursect = mydata->rootdir_sect
794 = mydata->fat_sect + mydata->fatlength * bs.fats;
wdenk71f95112003-06-15 22:40:42 +0000795
Wolfgang Denk7385c282010-07-19 11:37:00 +0200796 mydata->clust_size = bs.cluster_size;
wdenk71f95112003-06-15 22:40:42 +0000797
Wolfgang Denk7385c282010-07-19 11:37:00 +0200798 if (mydata->fatsize == 32) {
799 mydata->data_begin = mydata->rootdir_sect -
800 (mydata->clust_size * 2);
801 } else {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200802 rootdir_size = ((bs.dir_entries[1] * (int)256 +
803 bs.dir_entries[0]) *
804 sizeof(dir_entry)) /
805 SECTOR_SIZE;
806 mydata->data_begin = mydata->rootdir_sect +
807 rootdir_size -
808 (mydata->clust_size * 2);
wdenk71f95112003-06-15 22:40:42 +0000809 }
wdenk71f95112003-06-15 22:40:42 +0000810
Wolfgang Denk7385c282010-07-19 11:37:00 +0200811 mydata->fatbufnum = -1;
812
wdenk71f95112003-06-15 22:40:42 +0000813#ifdef CONFIG_SUPPORT_VFAT
Wolfgang Denk7385c282010-07-19 11:37:00 +0200814 debug("VFAT Support enabled\n");
wdenk71f95112003-06-15 22:40:42 +0000815#endif
Wolfgang Denk7385c282010-07-19 11:37:00 +0200816 debug("FAT%d, fat_sect: %d, fatlength: %d\n",
817 mydata->fatsize, mydata->fat_sect, mydata->fatlength);
818 debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
819 "Data begins at: %d\n",
820 root_cluster,
821 mydata->rootdir_sect,
822 mydata->rootdir_sect * SECTOR_SIZE, mydata->data_begin);
823 debug("Cluster size: %d\n", mydata->clust_size);
824
825 /* "cwd" is always the root... */
826 while (ISDIRDELIM(*filename))
827 filename++;
828
829 /* Make a copy of the filename and convert it to lowercase */
830 strcpy(fnamecopy, filename);
831 downcase(fnamecopy);
832
833 if (*fnamecopy == '\0') {
834 if (!dols)
835 return -1;
836
837 dols = LS_ROOT;
838 } else if ((idx = dirdelim(fnamecopy)) >= 0) {
839 isdir = 1;
840 fnamecopy[idx] = '\0';
841 subname = fnamecopy + idx + 1;
842
843 /* Handle multiple delimiters */
844 while (ISDIRDELIM(*subname))
845 subname++;
846 } else if (dols) {
847 isdir = 1;
848 }
849
850 j = 0;
851 while (1) {
852 int i;
853
854 debug("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%d\n",
855 cursect, mydata->clust_size, DIRENTSPERBLOCK);
856
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300857 if (disk_read(cursect,
858 (mydata->fatsize == 32) ?
859 (mydata->clust_size) :
Stefano Babic11c8dd32010-10-20 08:51:45 +0200860 LINEAR_PREFETCH_SIZE / SECTOR_SIZE,
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300861 do_fat_read_block) < 0) {
Wolfgang Denk7385c282010-07-19 11:37:00 +0200862 debug("Error: reading rootdir block\n");
863 return -1;
wdenk71f95112003-06-15 22:40:42 +0000864 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200865
866 dentptr = (dir_entry *) do_fat_read_block;
867
868 for (i = 0; i < DIRENTSPERBLOCK; i++) {
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300869 char s_name[14], l_name[VFAT_MAXLEN_BYTES];
Wolfgang Denk7385c282010-07-19 11:37:00 +0200870
871 l_name[0] = '\0';
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300872 if (dentptr->name[0] == DELETED_FLAG) {
873 dentptr++;
874 continue;
875 }
Wolfgang Denk7385c282010-07-19 11:37:00 +0200876 if ((dentptr->attr & ATTR_VOLUME)) {
wdenk71f95112003-06-15 22:40:42 +0000877#ifdef CONFIG_SUPPORT_VFAT
Wolfgang Denk7385c282010-07-19 11:37:00 +0200878 if ((dentptr->attr & ATTR_VFAT) &&
879 (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
880 prevcksum =
881 ((dir_slot *)dentptr)->alias_checksum;
wdenk71f95112003-06-15 22:40:42 +0000882
Mikhail Zolotaryov38315302010-09-08 17:06:03 +0300883 get_vfatname(mydata,
884 (mydata->fatsize == 32) ?
885 root_cluster :
886 0,
Wolfgang Denk7385c282010-07-19 11:37:00 +0200887 do_fat_read_block,
888 dentptr, l_name);
889
890 if (dols == LS_ROOT) {
891 char dirc;
892 int doit = 0;
893 int isdir =
894 (dentptr->attr & ATTR_DIR);
895
896 if (isdir) {
897 dirs++;
898 dirc = '/';
899 doit = 1;
900 } else {
901 dirc = ' ';
902 if (l_name[0] != 0) {
903 files++;
904 doit = 1;
905 }
906 }
907 if (doit) {
908 if (dirc == ' ') {
909 printf(" %8ld %s%c\n",
910 (long)FAT2CPU32(dentptr->size),
911 l_name,
912 dirc);
913 } else {
914 printf(" %s%c\n",
915 l_name,
916 dirc);
917 }
918 }
919 dentptr++;
920 continue;
921 }
922 debug("Rootvfatname: |%s|\n",
923 l_name);
924 } else
925#endif
926 {
927 /* Volume label or VFAT entry */
928 dentptr++;
929 continue;
930 }
931 } else if (dentptr->name[0] == 0) {
932 debug("RootDentname == NULL - %d\n", i);
933 if (dols == LS_ROOT) {
934 printf("\n%d file(s), %d dir(s)\n\n",
935 files, dirs);
936 return 0;
937 }
938 return -1;
939 }
940#ifdef CONFIG_SUPPORT_VFAT
941 else if (dols == LS_ROOT &&
942 mkcksum(dentptr->name) == prevcksum) {
943 dentptr++;
944 continue;
945 }
946#endif
947 get_name(dentptr, s_name);
948
949 if (dols == LS_ROOT) {
950 int isdir = (dentptr->attr & ATTR_DIR);
951 char dirc;
952 int doit = 0;
953
954 if (isdir) {
955 dirc = '/';
956 if (s_name[0] != 0) {
957 dirs++;
958 doit = 1;
959 }
960 } else {
961 dirc = ' ';
962 if (s_name[0] != 0) {
963 files++;
964 doit = 1;
965 }
966 }
967 if (doit) {
968 if (dirc == ' ') {
969 printf(" %8ld %s%c\n",
970 (long)FAT2CPU32(dentptr->size),
971 s_name, dirc);
972 } else {
973 printf(" %s%c\n",
974 s_name, dirc);
975 }
976 }
977 dentptr++;
978 continue;
979 }
980
981 if (strcmp(fnamecopy, s_name)
982 && strcmp(fnamecopy, l_name)) {
983 debug("RootMismatch: |%s|%s|\n", s_name,
984 l_name);
985 dentptr++;
986 continue;
987 }
988
989 if (isdir && !(dentptr->attr & ATTR_DIR))
990 return -1;
991
992 debug("RootName: %s", s_name);
993 debug(", start: 0x%x", START(dentptr));
994 debug(", size: 0x%x %s\n",
995 FAT2CPU32(dentptr->size),
996 isdir ? "(DIR)" : "");
997
998 goto rootdir_done; /* We got a match */
999 }
1000 debug("END LOOP: j=%d clust_size=%d\n", j,
1001 mydata->clust_size);
1002
1003 /*
1004 * On FAT32 we must fetch the FAT entries for the next
1005 * root directory clusters when a cluster has been
1006 * completely processed.
1007 */
Erik Hansen3f270f42011-03-24 10:15:37 +01001008 ++j;
1009 int fat32_end = 0;
1010 if ((mydata->fatsize == 32) && (j == mydata->clust_size)) {
1011 int nxtsect = 0;
1012 int nxt_clust = 0;
Wolfgang Denk7385c282010-07-19 11:37:00 +02001013
1014 nxt_clust = get_fatent(mydata, root_cluster);
Erik Hansen3f270f42011-03-24 10:15:37 +01001015 fat32_end = CHECK_CLUST(nxt_clust, 32);
Wolfgang Denk7385c282010-07-19 11:37:00 +02001016
1017 nxtsect = mydata->data_begin +
1018 (nxt_clust * mydata->clust_size);
1019
Wolfgang Denk7385c282010-07-19 11:37:00 +02001020 root_cluster = nxt_clust;
1021
1022 cursect = nxtsect;
1023 j = 0;
wdenk71f95112003-06-15 22:40:42 +00001024 } else {
Wolfgang Denk7385c282010-07-19 11:37:00 +02001025 cursect++;
wdenk71f95112003-06-15 22:40:42 +00001026 }
Erik Hansen3f270f42011-03-24 10:15:37 +01001027
1028 /* If end of rootdir reached */
1029 if ((mydata->fatsize == 32 && fat32_end) ||
1030 (mydata->fatsize != 32 && j == rootdir_size)) {
1031 if (dols == LS_ROOT) {
1032 printf("\n%d file(s), %d dir(s)\n\n",
1033 files, dirs);
1034 return 0;
1035 } else {
1036 return -1;
1037 }
1038 }
Wolfgang Denk7385c282010-07-19 11:37:00 +02001039 }
1040rootdir_done:
1041
1042 firsttime = 1;
1043
1044 while (isdir) {
1045 int startsect = mydata->data_begin
1046 + START(dentptr) * mydata->clust_size;
1047 dir_entry dent;
1048 char *nextname = NULL;
1049
1050 dent = *dentptr;
1051 dentptr = &dent;
1052
1053 idx = dirdelim(subname);
1054
1055 if (idx >= 0) {
1056 subname[idx] = '\0';
1057 nextname = subname + idx + 1;
1058 /* Handle multiple delimiters */
1059 while (ISDIRDELIM(*nextname))
1060 nextname++;
1061 if (dols && *nextname == '\0')
1062 firsttime = 0;
1063 } else {
1064 if (dols && firsttime) {
1065 firsttime = 0;
1066 } else {
1067 isdir = 0;
1068 }
wdenk71f95112003-06-15 22:40:42 +00001069 }
wdenk71f95112003-06-15 22:40:42 +00001070
Wolfgang Denk7385c282010-07-19 11:37:00 +02001071 if (get_dentfromdir(mydata, startsect, subname, dentptr,
1072 isdir ? 0 : dols) == NULL) {
1073 if (dols && !isdir)
1074 return 0;
1075 return -1;
1076 }
wdenk71f95112003-06-15 22:40:42 +00001077
Wolfgang Denk7385c282010-07-19 11:37:00 +02001078 if (idx >= 0) {
1079 if (!(dentptr->attr & ATTR_DIR))
1080 return -1;
1081 subname = nextname;
1082 }
wdenk71f95112003-06-15 22:40:42 +00001083 }
1084
Wolfgang Denk7385c282010-07-19 11:37:00 +02001085 ret = get_contents(mydata, dentptr, buffer, maxsize);
1086 debug("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), ret);
wdenk71f95112003-06-15 22:40:42 +00001087
Wolfgang Denk7385c282010-07-19 11:37:00 +02001088 return ret;
wdenk71f95112003-06-15 22:40:42 +00001089}
1090
Wolfgang Denk7385c282010-07-19 11:37:00 +02001091int file_fat_detectfs (void)
wdenk71f95112003-06-15 22:40:42 +00001092{
Wolfgang Denk7385c282010-07-19 11:37:00 +02001093 boot_sector bs;
1094 volume_info volinfo;
1095 int fatsize;
1096 char vol_label[12];
wdenk71f95112003-06-15 22:40:42 +00001097
Wolfgang Denk7385c282010-07-19 11:37:00 +02001098 if (cur_dev == NULL) {
wdenk7205e402003-09-10 22:30:53 +00001099 printf("No current device\n");
1100 return 1;
1101 }
Wolfgang Denk7385c282010-07-19 11:37:00 +02001102
Jon Loeligerdd60d122007-07-09 17:56:50 -05001103#if defined(CONFIG_CMD_IDE) || \
unsik Kim75eb82e2009-02-25 11:31:24 +09001104 defined(CONFIG_CMD_MG_DISK) || \
Sonic Zhang8c5170a2008-12-09 23:20:18 -05001105 defined(CONFIG_CMD_SATA) || \
Jon Loeligerdd60d122007-07-09 17:56:50 -05001106 defined(CONFIG_CMD_SCSI) || \
1107 defined(CONFIG_CMD_USB) || \
Andy Fleming21f6f962008-01-16 13:06:59 -06001108 defined(CONFIG_MMC)
wdenk7205e402003-09-10 22:30:53 +00001109 printf("Interface: ");
Wolfgang Denk7385c282010-07-19 11:37:00 +02001110 switch (cur_dev->if_type) {
1111 case IF_TYPE_IDE:
1112 printf("IDE");
1113 break;
1114 case IF_TYPE_SATA:
1115 printf("SATA");
1116 break;
1117 case IF_TYPE_SCSI:
1118 printf("SCSI");
1119 break;
1120 case IF_TYPE_ATAPI:
1121 printf("ATAPI");
1122 break;
1123 case IF_TYPE_USB:
1124 printf("USB");
1125 break;
1126 case IF_TYPE_DOC:
1127 printf("DOC");
1128 break;
1129 case IF_TYPE_MMC:
1130 printf("MMC");
1131 break;
1132 default:
1133 printf("Unknown");
wdenk7205e402003-09-10 22:30:53 +00001134 }
Wolfgang Denk7385c282010-07-19 11:37:00 +02001135
1136 printf("\n Device %d: ", cur_dev->dev);
wdenk7205e402003-09-10 22:30:53 +00001137 dev_print(cur_dev);
1138#endif
Wolfgang Denk7385c282010-07-19 11:37:00 +02001139
1140 if (read_bootsectandvi(&bs, &volinfo, &fatsize)) {
wdenk7205e402003-09-10 22:30:53 +00001141 printf("\nNo valid FAT fs found\n");
1142 return 1;
1143 }
Wolfgang Denk7385c282010-07-19 11:37:00 +02001144
1145 memcpy(vol_label, volinfo.volume_label, 11);
wdenk7205e402003-09-10 22:30:53 +00001146 vol_label[11] = '\0';
Wolfgang Denk7385c282010-07-19 11:37:00 +02001147 volinfo.fs_type[5] = '\0';
1148
1149 printf("Partition %d: Filesystem: %s \"%s\"\n", cur_part,
1150 volinfo.fs_type, vol_label);
1151
wdenk7205e402003-09-10 22:30:53 +00001152 return 0;
wdenk71f95112003-06-15 22:40:42 +00001153}
1154
Wolfgang Denk7385c282010-07-19 11:37:00 +02001155int file_fat_ls (const char *dir)
wdenk71f95112003-06-15 22:40:42 +00001156{
1157 return do_fat_read(dir, NULL, 0, LS_YES);
1158}
1159
Wolfgang Denk7385c282010-07-19 11:37:00 +02001160long file_fat_read (const char *filename, void *buffer, unsigned long maxsize)
wdenk71f95112003-06-15 22:40:42 +00001161{
Wolfgang Denk7385c282010-07-19 11:37:00 +02001162 printf("reading %s\n", filename);
wdenk71f95112003-06-15 22:40:42 +00001163 return do_fat_read(filename, buffer, maxsize, LS_NO);
1164}