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