| /* |
| * \file optimus_fat.c |
| * \brief fopen/fread/fclose for fat32 |
| * |
| * \version 1.0.0 |
| * \date 2018/11/08 |
| * \author Sam.Wu <yihui.wu@amlgic.com> |
| * |
| * Copyright (c) 2018 Amlogic. All Rights Reserved. |
| * |
| */ |
| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * fat.c |
| * |
| * R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg |
| * |
| * 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6 |
| * 2003-03-10 - kharris@nexus-tech.net - ported to uboot |
| * 2018-11-12 - yihui.wu@amlogic.com - ported for speed up fragment reading |
| */ |
| #include "../v2_burning_i.h" |
| #include "../v2_sdc_burn/optimus_sdc_burn_i.h" |
| #include <partition_table.h> |
| #include <common.h> |
| #include <blk.h> |
| #include <config.h> |
| #include <exports.h> |
| #include <fat.h> |
| #include <fs.h> |
| #include <asm/byteorder.h> |
| #include <part.h> |
| #include <malloc.h> |
| #include <memalign.h> |
| #include <linux/compiler.h> |
| #include <linux/ctype.h> |
| #undef debug |
| #define debug(fmt...) //printf("%s[%3d]", __func__, __LINE__),printf(fmt) |
| |
| /* |
| * Directory iterator, to simplify filesystem traversal |
| * |
| * Implements an iterator pattern to traverse directory tables, |
| * transparently handling directory tables split across multiple |
| * clusters, and the difference between FAT12/FAT16 root directory |
| * (contiguous) and subdirectories + FAT32 root (chained). |
| * |
| * Rough usage: |
| * |
| * for (fat_itr_root(&itr, fsdata); fat_itr_next(&itr); ) { |
| * // to traverse down to a subdirectory pointed to by |
| * // current iterator position: |
| * fat_itr_child(&itr, &itr); |
| * } |
| * |
| * For more complete example, see fat_itr_resolve() |
| */ |
| |
| typedef struct { |
| fsdata *fsdata; /* filesystem parameters */ |
| unsigned clust; /* current cluster */ |
| int last_cluster; /* set once we've read last cluster */ |
| int is_root; /* is iterator at root directory */ |
| int remaining; /* remaining dent's in current cluster */ |
| |
| /* current iterator position values: */ |
| dir_entry *dent; /* current directory entry */ |
| char l_name[VFAT_MAXLEN_BYTES]; /* long (vfat) name */ |
| char s_name[14]; /* short 8.3 name */ |
| char *name; /* l_name if there is one, else s_name */ |
| |
| /* storage for current cluster in memory: */ |
| u8 block[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN); |
| } fat_itr; |
| |
| static int fat_itr_isdir(fat_itr *itr); |
| |
| struct fopen_para { |
| fat_itr itr; |
| fsdata fsdata; |
| __u32 curclust; |
| __u32 startclust; |
| int bytesperclust; |
| int64_t fileOffset; |
| int64_t filesize; |
| }; |
| #define MAX_FILE_NUM 1 |
| static struct fopen_para* _hFile[MAX_FILE_NUM]; |
| |
| /* |
| * Convert a string to lowercase. Converts at most 'len' characters, |
| * 'len' may be larger than the length of 'str' if 'str' is NULL |
| * terminated. |
| */ |
| static void downcase(char *str, size_t len) |
| { |
| while (*str != '\0' && len--) { |
| *str = tolower(*str); |
| str++; |
| } |
| } |
| |
| static struct blk_desc *cur_dev; |
| static disk_partition_t cur_part_info; |
| |
| #define DOS_BOOT_MAGIC_OFFSET 0x1fe |
| #define DOS_FS_TYPE_OFFSET 0x36 |
| #define DOS_FS32_TYPE_OFFSET 0x52 |
| |
| static int disk_read(__u32 block, __u32 nr_blocks, void *buf) |
| { |
| ulong ret; |
| |
| if (!cur_dev) { |
| DWN_ERR("not cur_dev in disk_read\n"); |
| return -1; |
| } |
| |
| ret = blk_dread(cur_dev, cur_part_info.start + block, nr_blocks, buf); |
| |
| if (ret != nr_blocks) { |
| DWN_ERR("Want read %u blocks, but only %lu\n", nr_blocks, ret); |
| return -1; |
| } |
| |
| return ret; |
| } |
| |
| /* |
| * Extract zero terminated short name from a directory entry. |
| */ |
| static void get_name(dir_entry *dirent, char *s_name) |
| { |
| char *ptr; |
| |
| memcpy(s_name, dirent->name, 8); |
| s_name[8] = '\0'; |
| ptr = s_name; |
| while (*ptr && *ptr != ' ') |
| ptr++; |
| if (dirent->lcase & CASE_LOWER_BASE) |
| downcase(s_name, (unsigned)(ptr - s_name)); |
| if (dirent->ext[0] && dirent->ext[0] != ' ') { |
| *ptr++ = '.'; |
| memcpy(ptr, dirent->ext, 3); |
| if (dirent->lcase & CASE_LOWER_EXT) |
| downcase(ptr, 3); |
| ptr[3] = '\0'; |
| while (*ptr && *ptr != ' ') |
| ptr++; |
| } |
| *ptr = '\0'; |
| if (*s_name == DELETED_FLAG) |
| *s_name = '\0'; |
| else if (*s_name == aRING) |
| *s_name = DELETED_FLAG; |
| } |
| |
| static int flush_dirty_fat_buffer(fsdata *mydata); |
| #if !defined(CONFIG_FAT_WRITE) |
| /* Stub for read only operation */ |
| static int flush_dirty_fat_buffer(fsdata *mydata) |
| { |
| (void)(mydata); |
| return 0; |
| } |
| #endif |
| |
| /* |
| * Get the entry at index 'entry' in a FAT (12/16/32) table. |
| * On failure 0x00 is returned. |
| */ |
| static __u32 get_fatent(fsdata *mydata, __u32 entry) |
| { |
| __u32 bufnum; |
| __u32 offset, off8; |
| __u32 ret = 0x00; |
| |
| if (CHECK_CLUST(entry, mydata->fatsize)) { |
| printf("Error: Invalid FAT entry: 0x%08x\n", entry); |
| return ret; |
| } |
| |
| switch (mydata->fatsize) { |
| case 32: |
| bufnum = entry / FAT32BUFSIZE; |
| offset = entry - bufnum * FAT32BUFSIZE; |
| break; |
| case 16: |
| bufnum = entry / FAT16BUFSIZE; |
| offset = entry - bufnum * FAT16BUFSIZE; |
| break; |
| case 12: |
| bufnum = entry / FAT12BUFSIZE; |
| offset = entry - bufnum * FAT12BUFSIZE; |
| break; |
| |
| default: |
| /* Unsupported FAT size */ |
| return ret; |
| } |
| |
| debug("FAT%d: entry: 0x%08x = %d, offset: 0x%04x = %d\n", |
| mydata->fatsize, entry, entry, offset, offset); |
| |
| /* Read a new block of FAT entries into the cache. */ |
| if (bufnum != mydata->fatbufnum) { |
| __u32 getsize = FATBUFBLOCKS; |
| __u8 *bufptr = mydata->fatbuf; |
| __u32 fatlength = mydata->fatlength; |
| __u32 startblock = bufnum * FATBUFBLOCKS; |
| |
| /* Cap length if fatlength is not a multiple of FATBUFBLOCKS */ |
| if (startblock + getsize > fatlength) |
| getsize = fatlength - startblock; |
| |
| startblock += mydata->fat_sect; /* Offset from start of disk */ |
| |
| /* Write back the fatbuf to the disk */ |
| if (flush_dirty_fat_buffer(mydata) < 0) |
| return -1; |
| |
| if (disk_read(startblock, getsize, bufptr) < 0) { |
| debug("Error reading FAT blocks\n"); |
| return ret; |
| } |
| mydata->fatbufnum = bufnum; |
| } |
| |
| /* Get the actual entry from the table */ |
| switch (mydata->fatsize) { |
| case 32: |
| ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]); |
| break; |
| case 16: |
| ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]); |
| break; |
| case 12: |
| off8 = (offset * 3) / 2; |
| /* fatbut + off8 may be unaligned, read in byte granularity */ |
| ret = mydata->fatbuf[off8] + (mydata->fatbuf[off8 + 1] << 8); |
| |
| if (offset & 0x1) |
| ret >>= 4; |
| ret &= 0xfff; |
| } |
| debug("FAT%d: ret: 0x%08x, entry: 0x%08x, offset: 0x%04x\n", |
| mydata->fatsize, ret, entry, offset); |
| |
| return ret; |
| } |
| |
| /* |
| * Read at most 'size' bytes from the specified cluster into 'buffer'. |
| * Return 0 on success, -1 otherwise. |
| */ |
| static int |
| get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size) |
| { |
| __u32 idx = 0; |
| __u32 startsect; |
| int ret; |
| |
| if (clustnum > 0) { |
| startsect = clust_to_sect(mydata, clustnum); |
| } else { |
| startsect = mydata->rootdir_sect; |
| } |
| |
| debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect); |
| |
| if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) { |
| ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size); |
| |
| printf("FAT: Misaligned buffer address (%p)\n", buffer); |
| |
| while (size >= mydata->sect_size) { |
| ret = disk_read(startsect++, 1, tmpbuf); |
| if (ret != 1) { |
| DWN_ERR("Error reading data (got %d)\n", ret); |
| return -1; |
| } |
| |
| memcpy(buffer, tmpbuf, mydata->sect_size); |
| buffer += mydata->sect_size; |
| size -= mydata->sect_size; |
| } |
| } else { |
| idx = size / mydata->sect_size; |
| ret = disk_read(startsect, idx, buffer); |
| if (ret != idx) { |
| DWN_ERR("Error reading data (got %d)\n", ret); |
| return -1; |
| } |
| startsect += idx; |
| idx *= mydata->sect_size; |
| buffer += idx; |
| size -= idx; |
| } |
| if (size) { |
| ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size); |
| |
| ret = disk_read(startsect, 1, tmpbuf); |
| if (ret != 1) { |
| DWN_ERR("Error reading data (got %d)\n", ret); |
| return -1; |
| } |
| |
| memcpy(buffer, tmpbuf, size); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr' |
| * into 'buffer'. |
| * Update the number of bytes read in *gotsize or return -1 on fatal errors. |
| */ |
| extern __u8 get_contents_vfatname_block[MAX_CLUSTSIZE];//extern as large, 64k wo |
| |
| static int _get_contents(int fd, loff_t pos, |
| __u8 *buffer, loff_t maxsize, loff_t *gotsize) |
| { |
| struct fopen_para* hFile = _hFile[fd]; |
| fsdata *mydata = &(hFile->fsdata); |
| //dir_entry *dentptr = (_hFile[fd]->itr).dent; |
| loff_t filesize = hFile->filesize; |
| __u32 endclust, newclust; |
| const unsigned int bytesperclust = hFile->bytesperclust; |
| const unsigned int clusterMask = bytesperclust - 1; |
| loff_t actsize = 0;//already seeked to pos in burning mode |
| |
| *gotsize = 0; |
| debug("Filesize: %llu bytes\n", filesize); |
| |
| if (pos + maxsize > filesize) { |
| DWN_MSG("Read position %llx + sz %llx past EOF: %llu\n", pos, maxsize, filesize); |
| return 0; |
| } |
| if (do_fat_fseek(fd, pos, 0)) { |
| DWN_ERR("Fail seek to pos %llu\n", pos); |
| return -__LINE__; |
| } |
| __u32 curclust = hFile->curclust; |
| filesize -= pos; |
| |
| /* align to beginning of next cluster if any */ |
| const int firstClusterNotAlign = pos & clusterMask; |
| if (firstClusterNotAlign) { |
| const int rightPart = bytesperclust - firstClusterNotAlign; |
| actsize = min(rightPart, (int)maxsize); |
| DWN_DBG("actsize 0x%x, firstClusterNotAlign 0x%x, curclust 0x%x\n", |
| actsize, firstClusterNotAlign, curclust); |
| if (get_cluster(mydata, curclust, get_contents_vfatname_block, bytesperclust)) { |
| printf("Error reading cluster\n"); |
| return -1; |
| } |
| maxsize -= actsize; |
| memcpy(buffer, get_contents_vfatname_block + firstClusterNotAlign, actsize); |
| *gotsize = actsize; |
| |
| if (maxsize || rightPart == actsize) { |
| curclust = get_fatent(mydata, curclust); |
| if (CHECK_CLUST(curclust, mydata->fatsize)) { |
| DWN_MSG("curclust: 0x%x\n", curclust); |
| DWN_MSG("Invalid FAT entry\n"); |
| return -__LINE__; |
| } |
| } |
| |
| if (!maxsize) { |
| if (rightPart == actsize) hFile->curclust = curclust; |
| return 0; |
| } |
| } |
| |
| buffer += actsize; |
| actsize = (int)bytesperclust; |
| endclust = curclust; |
| do { |
| /* search for consecutive clusters */ while (actsize < maxsize) { |
| newclust = get_fatent(mydata, endclust); |
| if ((newclust - 1) != endclust) |
| goto getit; |
| if (CHECK_CLUST(newclust, mydata->fatsize)) { |
| DWN_MSG("curclust: 0x%x\n", newclust); |
| DWN_MSG("Invalid FAT entry\n"); |
| return -__LINE__; |
| } |
| endclust = newclust; |
| actsize += bytesperclust; |
| } |
| |
| /* get remaining bytes */ |
| actsize = maxsize;//<= bytesperclust |
| if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { |
| printf("Error reading cluster\n"); |
| return -1; |
| } |
| *gotsize += actsize; |
| if (!(actsize & clusterMask) && filesize > *gotsize) { |
| endclust = get_fatent(mydata, endclust); |
| if (CHECK_CLUST(endclust, mydata->fatsize)) { |
| DWN_MSG("curclust: 0x%x\n", endclust); |
| DWN_MSG("Invalid FAT entry\n"); |
| return -__LINE__; |
| } |
| } |
| |
| hFile->curclust = endclust;//for next reading |
| return 0;//read ok |
| getit: //dispose consecutive clusters |
| if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { |
| DWN_ERR("Error reading cluster %u\n", curclust); |
| return -1; |
| } |
| *gotsize += (int)actsize; |
| maxsize -= actsize; |
| buffer += actsize; |
| |
| curclust = get_fatent(mydata, endclust); |
| if (CHECK_CLUST(curclust, mydata->fatsize)) { |
| DWN_MSG("curclust: 0x%x\n", curclust); |
| printf("Invalid FAT entry\n"); |
| return -__LINE__; |
| } |
| actsize = bytesperclust; |
| endclust = curclust; |
| } while (1); |
| |
| return -__LINE__;//should not reach here |
| } |
| |
| /* |
| * Extract the file name information from 'slotptr' into 'l_name', |
| * starting at l_name[*idx]. |
| * Return 1 if terminator (zero byte) is found, 0 otherwise. |
| */ |
| static int slot2str(dir_slot *slotptr, char *l_name, int *idx) |
| { |
| int j; |
| |
| for (j = 0; j <= 8; j += 2) { |
| l_name[*idx] = slotptr->name0_4[j]; |
| if (l_name[*idx] == 0x00) |
| return 1; |
| (*idx)++; |
| } |
| for (j = 0; j <= 10; j += 2) { |
| l_name[*idx] = slotptr->name5_10[j]; |
| if (l_name[*idx] == 0x00) |
| return 1; |
| (*idx)++; |
| } |
| for (j = 0; j <= 2; j += 2) { |
| l_name[*idx] = slotptr->name11_12[j]; |
| if (l_name[*idx] == 0x00) |
| return 1; |
| (*idx)++; |
| } |
| |
| return 0; |
| } |
| |
| /* Calculate short name checksum */ |
| static __u8 mkcksum(const char name[8], const char ext[3]) |
| { |
| int i; |
| |
| __u8 ret = 0; |
| |
| for (i = 0; i < 8; i++) |
| ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + name[i]; |
| for (i = 0; i < 3; i++) |
| ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + ext[i]; |
| |
| return ret; |
| } |
| |
| /* |
| * Read boot sector and volume info from a FAT filesystem |
| */ |
| static int |
| read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) |
| { |
| __u8 *block; |
| volume_info *vistart; |
| int ret = 0; |
| |
| if (cur_dev == NULL) { |
| DWN_ERR("Error: no device selected\n"); |
| return -1; |
| } |
| |
| block = malloc_cache_aligned(cur_dev->blksz); |
| if (block == NULL) { |
| DWN_ERR("Error: allocating block\n"); |
| return -1; |
| } |
| |
| if (disk_read(0, 1, block) < 0) { |
| DWN_ERR("Error: reading block\n"); |
| goto fail; |
| } |
| |
| memcpy(bs, block, sizeof(boot_sector)); |
| bs->reserved = FAT2CPU16(bs->reserved); |
| bs->fat_length = FAT2CPU16(bs->fat_length); |
| bs->secs_track = FAT2CPU16(bs->secs_track); |
| bs->heads = FAT2CPU16(bs->heads); |
| bs->total_sect = FAT2CPU32(bs->total_sect); |
| |
| /* FAT32 entries */ |
| if (bs->fat_length == 0) { |
| /* Assume FAT32 */ |
| bs->fat32_length = FAT2CPU32(bs->fat32_length); |
| bs->flags = FAT2CPU16(bs->flags); |
| bs->root_cluster = FAT2CPU32(bs->root_cluster); |
| bs->info_sector = FAT2CPU16(bs->info_sector); |
| bs->backup_boot = FAT2CPU16(bs->backup_boot); |
| vistart = (volume_info *)(block + sizeof(boot_sector)); |
| *fatsize = 32; |
| } else { |
| vistart = (volume_info *)&(bs->fat32_length); |
| *fatsize = 0; |
| } |
| memcpy(volinfo, vistart, sizeof(volume_info)); |
| |
| if (*fatsize == 32) { |
| if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0) |
| goto exit; |
| } else { |
| if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) { |
| *fatsize = 12; |
| goto exit; |
| } |
| if (strncmp(FAT16_SIGN, vistart->fs_type, SIGNLEN) == 0) { |
| *fatsize = 16; |
| goto exit; |
| } |
| } |
| |
| debug("Error: broken fs_type sign\n"); |
| fail: |
| ret = -1; |
| exit: |
| free(block); |
| return ret; |
| } |
| |
| static int get_fs_info(fsdata *mydata) |
| { |
| boot_sector bs; |
| volume_info volinfo; |
| int ret; |
| |
| ret = read_bootsectandvi(&bs, &volinfo, &mydata->fatsize); |
| if (ret) { |
| debug("Error: reading boot sector\n"); |
| return ret; |
| } |
| |
| if (mydata->fatsize == 32) { |
| mydata->fatlength = bs.fat32_length; |
| } else { |
| mydata->fatlength = bs.fat_length; |
| } |
| |
| mydata->fat_sect = bs.reserved; |
| |
| mydata->rootdir_sect = mydata->fat_sect + mydata->fatlength * bs.fats; |
| |
| mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0]; |
| mydata->clust_size = bs.cluster_size; |
| if (mydata->sect_size != cur_part_info.blksz) { |
| printf("Error: FAT sector size mismatch (fs=%hu, dev=%lu)\n", |
| mydata->sect_size, cur_part_info.blksz); |
| return -1; |
| } |
| |
| if (mydata->fatsize == 32) { |
| mydata->data_begin = mydata->rootdir_sect - |
| (mydata->clust_size * 2); |
| mydata->root_cluster = bs.root_cluster; |
| } else { |
| mydata->rootdir_size = ((bs.dir_entries[1] * (int)256 + |
| bs.dir_entries[0]) * |
| sizeof(dir_entry)) / |
| mydata->sect_size; |
| mydata->data_begin = mydata->rootdir_sect + |
| mydata->rootdir_size - |
| (mydata->clust_size * 2); |
| mydata->root_cluster = |
| sect_to_clust(mydata, mydata->rootdir_sect); |
| } |
| |
| mydata->fatbufnum = -1; |
| mydata->fat_dirty = 0; |
| mydata->fatbuf = malloc_cache_aligned(FATBUFSIZE); |
| if (mydata->fatbuf == NULL) { |
| DWN_ERR("Error: allocating memory\n"); |
| return -1; |
| } |
| |
| debug("FAT%d, fat_sect: %d, fatlength: %d\n", |
| mydata->fatsize, mydata->fat_sect, mydata->fatlength); |
| debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n" |
| "Data begins at: %d\n", |
| mydata->root_cluster, |
| mydata->rootdir_sect, |
| mydata->rootdir_sect * mydata->sect_size, mydata->data_begin); |
| debug("Sector size: %d, cluster size: %d\n", mydata->sect_size, |
| mydata->clust_size); |
| |
| return 0; |
| } |
| |
| |
| /** |
| * fat_itr_root() - initialize an iterator to start at the root |
| * directory |
| * |
| * @itr: iterator to initialize |
| * @fsdata: filesystem data for the partition |
| * @return 0 on success, else -errno |
| */ |
| static int fat_itr_root(fat_itr *itr, fsdata *fsdata) |
| { |
| if (get_fs_info(fsdata)) |
| return -ENXIO; |
| |
| itr->fsdata = fsdata; |
| itr->clust = fsdata->root_cluster; |
| itr->dent = NULL; |
| itr->remaining = 0; |
| itr->last_cluster = 0; |
| itr->is_root = 1; |
| |
| return 0; |
| } |
| |
| /** |
| * fat_itr_child() - initialize an iterator to descend into a sub- |
| * directory |
| * |
| * Initializes 'itr' to iterate the contents of the directory at |
| * the current cursor position of 'parent'. It is an error to |
| * call this if the current cursor of 'parent' is pointing at a |
| * regular file. |
| * |
| * Note that 'itr' and 'parent' can be the same pointer if you do |
| * not need to preserve 'parent' after this call, which is useful |
| * for traversing directory structure to resolve a file/directory. |
| * |
| * @itr: iterator to initialize |
| * @parent: the iterator pointing at a directory entry in the |
| * parent directory of the directory to iterate |
| */ |
| static void fat_itr_child(fat_itr *itr, fat_itr *parent) |
| { |
| fsdata *mydata = parent->fsdata; /* for silly macros */ |
| unsigned clustnum = START(parent->dent); |
| |
| assert(fat_itr_isdir(parent)); |
| |
| itr->fsdata = parent->fsdata; |
| if (clustnum > 0) { |
| itr->clust = clustnum; |
| itr->is_root = 0; |
| } else { |
| itr->clust = parent->fsdata->root_cluster; |
| itr->is_root = 1; |
| } |
| itr->dent = NULL; |
| itr->remaining = 0; |
| itr->last_cluster = 0; |
| } |
| |
| static void *next_cluster(fat_itr *itr) |
| { |
| //fsdata *mydata = itr->fsdata; /* for silly macros */ |
| int ret; |
| u32 sect; |
| |
| /* have we reached the end? */ |
| if (itr->last_cluster) |
| return NULL; |
| |
| sect = clust_to_sect(itr->fsdata, itr->clust); |
| |
| debug("FAT read(sect=%d), clust_size=%d, DIRENTSPERBLOCK=%zd\n", |
| sect, itr->fsdata->clust_size, DIRENTSPERBLOCK); |
| |
| /* |
| * NOTE: do_fat_read_at() had complicated logic to deal w/ |
| * vfat names that span multiple clusters in the fat16 case, |
| * which get_dentfromdir() probably also needed (and was |
| * missing). And not entirely sure what fat32 didn't have |
| * the same issue.. We solve that by only caring about one |
| * dent at a time and iteratively constructing the vfat long |
| * name. |
| */ |
| ret = disk_read(sect, itr->fsdata->clust_size, |
| itr->block); |
| if (ret < 0) { |
| debug("Error: reading block\n"); |
| return NULL; |
| } |
| |
| if (itr->is_root && itr->fsdata->fatsize != 32) { |
| itr->clust++; |
| sect = clust_to_sect(itr->fsdata, itr->clust); |
| if (sect - itr->fsdata->rootdir_sect >= |
| itr->fsdata->rootdir_size) { |
| debug("cursect: 0x%x\n", itr->clust); |
| itr->last_cluster = 1; |
| } |
| } else { |
| itr->clust = get_fatent(itr->fsdata, itr->clust); |
| if (CHECK_CLUST(itr->clust, itr->fsdata->fatsize)) { |
| debug("cursect: 0x%x\n", itr->clust); |
| itr->last_cluster = 1; |
| } |
| } |
| |
| return itr->block; |
| } |
| |
| static dir_entry *next_dent(fat_itr *itr) |
| { |
| if (itr->remaining == 0) { |
| struct dir_entry *dent = next_cluster(itr); |
| unsigned nbytes = itr->fsdata->sect_size * |
| itr->fsdata->clust_size; |
| |
| /* have we reached the last cluster? */ |
| if (!dent) |
| return NULL; |
| |
| itr->remaining = nbytes / sizeof(dir_entry) - 1; |
| itr->dent = dent; |
| } else { |
| itr->remaining--; |
| itr->dent++; |
| } |
| |
| /* have we reached the last valid entry? */ |
| if (itr->dent->name[0] == 0) |
| return NULL; |
| |
| return itr->dent; |
| } |
| |
| static dir_entry *extract_vfat_name(fat_itr *itr) |
| { |
| struct dir_entry *dent = itr->dent; |
| int seqn = itr->dent->name[0] & ~LAST_LONG_ENTRY_MASK; |
| u8 chksum, alias_checksum = ((dir_slot *)dent)->alias_checksum; |
| int n = 0; |
| |
| while (seqn--) { |
| char buf[13]; |
| int idx = 0; |
| |
| slot2str((dir_slot *)dent, buf, &idx); |
| |
| /* shift accumulated long-name up and copy new part in: */ |
| memmove(itr->l_name + idx, itr->l_name, n); |
| memcpy(itr->l_name, buf, idx); |
| n += idx; |
| |
| dent = next_dent(itr); |
| if (!dent) |
| return NULL; |
| } |
| |
| itr->l_name[n] = '\0'; |
| |
| chksum = mkcksum(dent->name, dent->ext); |
| |
| /* checksum mismatch could mean deleted file, etc.. skip it: */ |
| if (chksum != alias_checksum) { |
| debug("** chksum=%x, alias_checksum=%x, l_name=%s, s_name=%8s.%3s\n", |
| chksum, alias_checksum, itr->l_name, dent->name, dent->ext); |
| return NULL; |
| } |
| |
| return dent; |
| } |
| |
| /** |
| * fat_itr_next() - step to the next entry in a directory |
| * |
| * Must be called once on a new iterator before the cursor is valid. |
| * |
| * @itr: the iterator to iterate |
| * @return boolean, 1 if success or 0 if no more entries in the |
| * current directory |
| */ |
| static int fat_itr_next(fat_itr *itr) |
| { |
| dir_entry *dent; |
| |
| itr->name = NULL; |
| |
| while (1) { |
| dent = next_dent(itr); |
| if (!dent) |
| return 0; |
| |
| if (dent->name[0] == DELETED_FLAG || |
| dent->name[0] == aRING) |
| continue; |
| |
| if (dent->attr & ATTR_VOLUME) { |
| if ((dent->attr & ATTR_VFAT) == ATTR_VFAT && |
| (dent->name[0] & LAST_LONG_ENTRY_MASK)) { |
| dent = extract_vfat_name(itr); |
| if (!dent) |
| continue; |
| itr->name = itr->l_name; |
| break; |
| } else { |
| /* Volume label or VFAT entry, skip */ |
| continue; |
| } |
| } |
| |
| break; |
| } |
| |
| get_name(dent, itr->s_name); |
| if (!itr->name) |
| itr->name = itr->s_name; |
| |
| return 1; |
| } |
| |
| /** |
| * fat_itr_isdir() - is current cursor position pointing to a directory |
| * |
| * @itr: the iterator |
| * @return true if cursor is at a directory |
| */ |
| static int fat_itr_isdir(fat_itr *itr) |
| { |
| return !!(itr->dent->attr & ATTR_DIR); |
| } |
| |
| /* |
| * Helpers: |
| */ |
| |
| #define TYPE_FILE 0x1 |
| #define TYPE_DIR 0x2 |
| #define TYPE_ANY (TYPE_FILE | TYPE_DIR) |
| |
| /** |
| * fat_itr_resolve() - traverse directory structure to resolve the |
| * requested path. |
| * |
| * Traverse directory structure to the requested path. If the specified |
| * path is to a directory, this will descend into the directory and |
| * leave it iterator at the start of the directory. If the path is to a |
| * file, it will leave the iterator in the parent directory with current |
| * cursor at file's entry in the directory. |
| * |
| * @itr: iterator initialized to root |
| * @path: the requested path |
| * @type: bitmask of allowable file types |
| * @return 0 on success or -errno |
| */ |
| static int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type) |
| { |
| const char *next; |
| |
| /* chomp any extra leading slashes: */ |
| while (path[0] && ISDIRDELIM(path[0])) |
| path++; |
| |
| /* are we at the end? */ |
| if (strlen(path) == 0) { |
| if (!(type & TYPE_DIR)) |
| return -ENOENT; |
| return 0; |
| } |
| |
| /* find length of next path entry: */ |
| next = path; |
| while (next[0] && !ISDIRDELIM(next[0])) |
| next++; |
| |
| while (fat_itr_next(itr)) { |
| int match = 0; |
| unsigned n = max(strlen(itr->name), (size_t)(next - path)); |
| |
| /* check both long and short name: */ |
| if (!strncasecmp(path, itr->name, n)) |
| match = 1; |
| else if (itr->name != itr->s_name && |
| !strncasecmp(path, itr->s_name, n)) |
| match = 1; |
| |
| if (!match) |
| continue; |
| |
| if (fat_itr_isdir(itr)) { |
| /* recurse into directory: */ |
| fat_itr_child(itr, itr); |
| return fat_itr_resolve(itr, next, type); |
| } else if (next[0]) { |
| /* |
| * If next is not empty then we have a case |
| * like: /path/to/realfile/nonsense |
| */ |
| debug("bad trailing path: %s\n", next); |
| return -ENOENT; |
| } else if (!(type & TYPE_FILE)) { |
| return -ENOTDIR; |
| } else { |
| return 0; |
| } |
| } |
| |
| return -ENOENT; |
| } |
| |
| static int _fat_set_blk_dev(struct blk_desc *dev_desc, disk_partition_t *info) |
| { |
| ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz); |
| |
| cur_dev = dev_desc; |
| cur_part_info = *info; |
| |
| /* Make sure it has a valid FAT header */ |
| if (disk_read(0, 1, buffer) != 1) { |
| cur_dev = NULL; |
| return -1; |
| } |
| |
| /* Check if it's actually a DOS volume */ |
| if (memcmp(buffer + DOS_BOOT_MAGIC_OFFSET, "\x55\xAA", 2)) { |
| cur_dev = NULL; |
| return -1; |
| } |
| |
| /* Check for FAT12/FAT16/FAT32 filesystem */ |
| if (!memcmp(buffer + DOS_FS_TYPE_OFFSET, "FAT", 3)) |
| return 0; |
| if (!memcmp(buffer + DOS_FS32_TYPE_OFFSET, "FAT32", 5)) |
| return 0; |
| |
| cur_dev = NULL; |
| return -1; |
| } |
| |
| int optimus_fat_register_device(const char *ifname, const char *dev_part_str) |
| { |
| int dev, part; |
| struct blk_desc *dev_desc; |
| disk_partition_t info; |
| |
| part = blk_get_device_part_str(ifname, dev_part_str, &dev_desc, &info, 1); |
| if (part < 0) { |
| DWN_ERR("fail in blk_get_device_part_str\n"); |
| return -__LINE__; |
| } |
| |
| dev = dev_desc->devnum; |
| if (_fat_set_blk_dev(dev_desc, &info) != 0) { |
| printf("\n** Unable to use %s %d:%d for fatinfo **\n", |
| ifname, dev, part); |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| int optimus_sdc_burn_switch_to_extmmc(void) |
| { |
| return 0; |
| } |
| |
| unsigned do_fat_get_bytesperclust(int fd) |
| { |
| struct fopen_para* hFile = _hFile[fd];; |
| fsdata* mydata = &(hFile->fsdata); |
| |
| unsigned int bytesperclust = mydata->clust_size * mydata->sect_size; |
| DWN_DBG("bytesperclust %x, clust_size %x, sec %x\n", bytesperclust, |
| mydata->clust_size, mydata->sect_size); |
| return bytesperclust; |
| } |
| |
| long do_fat_fopen(const char *filename) |
| { |
| fsdata* mydata; |
| fat_itr *itr; |
| int ret = -__LINE__; |
| int index = -__LINE__; |
| |
| struct fopen_para* hFile = malloc_cache_aligned(sizeof(struct fopen_para)); |
| if (!hFile) { |
| DWN_ERR("Fail alloc mem for open\n"); |
| return -__LINE__; |
| } |
| itr = &(hFile->itr); |
| mydata = &(hFile->fsdata); |
| ret = fat_itr_root(itr, mydata); |
| if (ret) { |
| DWN_ERR("Fail read fat root\n"); |
| goto _out_free; |
| } |
| |
| ret = fat_itr_resolve(itr, filename, TYPE_FILE); |
| if (ret) { |
| DWN_ERR("Fail find file[%s]\n", filename); |
| goto _out_free; |
| } |
| |
| index = 0; |
| hFile->fileOffset = 0; |
| hFile->curclust = START(itr->dent); |
| hFile->startclust = hFile->curclust; |
| hFile->filesize = FAT2CPU32(itr->dent->size); |
| //if (_hFile[index]) free(_hFile[index]); //close last opened, why crashed!! |
| _hFile[index] = hFile; |
| _hFile[index]->bytesperclust = do_fat_get_bytesperclust(index); |
| DWN_MSG("filesize 0x%llx\n", hFile->filesize); |
| DWN_MSG("startclust 0x%x\n", hFile->startclust); |
| return index; |
| |
| _out_free: |
| free(hFile); |
| return -__LINE__; |
| } |
| |
| void do_fat_fclose(int fd) |
| { |
| struct fopen_para* hFile = _hFile[fd]; |
| if (hFile) free(hFile); |
| return; |
| } |
| |
| /* wherehence: 0 to seek from start of file; 1 to seek from current position from file */ |
| int do_fat_fseek(int fd, const int64_t offset, int wherehence) |
| { |
| struct fopen_para* hFile = _hFile[fd]; |
| int64_t* filePos = &(hFile->fileOffset); |
| const int64_t oldFileOffset = *filePos; |
| int64_t pos = oldFileOffset; |
| const unsigned clusterSz = do_fat_get_bytesperclust(fd); |
| fsdata* mydata = &(hFile->fsdata); |
| unsigned curclust = hFile->curclust; |
| |
| switch (wherehence) |
| { |
| case 0://seek from begin |
| pos = offset; |
| break; |
| |
| case 1://seek from current |
| pos += offset; |
| break; |
| default: DWN_ERR("wherehence %d err\n", wherehence); |
| return -__LINE__; |
| } |
| if ( pos >= hFile->filesize ) { |
| DWN_ERR("seek %lld err from wherehence %d\n", offset, wherehence); |
| return -__LINE__; |
| } |
| const int64_t newFileOffset = pos; //////// |
| DWN_DBG("Seek 0x%llx from 0x%llx\n", pos, oldFileOffset); |
| if (newFileOffset == oldFileOffset) return 0; |
| |
| //Above already update field @.fileOffset |
| //following update @.curClusterIndex |
| unsigned newClusterIndex = newFileOffset / clusterSz; |
| unsigned curClusterIndex = oldFileOffset / clusterSz; |
| int nCluster = 0; |
| if (newClusterIndex > curClusterIndex) { |
| curclust = hFile->curclust; |
| nCluster = newClusterIndex - curClusterIndex; |
| DWN_DBG("pos 0x%llx, nCluster %u, cur %u\n", pos, nCluster, curClusterIndex); |
| while (nCluster--) { |
| curclust = get_fatent(mydata, curclust); |
| if (CHECK_CLUST(curclust, mydata->fatsize)) { |
| DWN_ERR("curclust: 0x%x\n", curclust); |
| DWN_ERR("Invalid FAT entry\n"); |
| return -__LINE__; |
| } |
| } |
| } else if (newClusterIndex < curClusterIndex) { |
| curclust = hFile->startclust; |
| nCluster = newClusterIndex; |
| DWN_DBG("pos %llx, nCluster %u, start %u\n", pos, nCluster, curClusterIndex); |
| while (nCluster--) { |
| curclust = get_fatent(mydata, curclust); |
| if (CHECK_CLUST(curclust, mydata->fatsize)) { |
| DWN_ERR("curclust: 0x%x\n", curclust); |
| DWN_ERR("Invalid FAT entry\n"); |
| return -__LINE__; |
| } |
| } |
| } |
| |
| DWN_DBG("Seek to 0x%x from 0x%x cluster\n", curclust, hFile->curclust); |
| hFile->curclust = curclust; |
| hFile->fileOffset = newFileOffset; |
| return 0; |
| } |
| |
| long do_fat_fread(int fd, __u8 *buffer, unsigned long maxsize) |
| { |
| loff_t actRead = 0; |
| int ret = -__LINE__; |
| struct fopen_para* hFile = _hFile[fd];; |
| loff_t pos = hFile->fileOffset; |
| |
| ret = _get_contents(fd, pos, buffer, maxsize, &actRead); |
| if (ret) { |
| DWN_ERR("fail read 0x%lx from pos 0x%llx.err(%d)\n", maxsize, pos, ret); |
| return -__LINE__; |
| } |
| hFile->fileOffset += actRead; |
| DWN_DBG("update fpos 0x%llx, curclust 0x%x\n", hFile->fileOffset, hFile->curclust); |
| |
| return actRead; |
| } |
| |
| s64 do_fat_get_fileSz(const char* imgItemPath) |
| { |
| char cmdBuf[256] = ""; |
| int rcode = 0; |
| const char* envFileSz = NULL; |
| const char* usb_update = getenv("usb_update"); |
| |
| if (!strcmp(usb_update,"1")) |
| { |
| //fatexist usb host 0 imgItemPath |
| sprintf(cmdBuf, "fatsize usb 0 %s", imgItemPath); |
| } |
| else |
| { |
| rcode = optimus_sdc_burn_switch_to_extmmc(); |
| sprintf(cmdBuf, "fatsize mmc 0 %s", imgItemPath); |
| } |
| /*SDC_DBG("to run cmd [%s]\n", cmdBuf);*/ |
| rcode = run_command(cmdBuf, 0); |
| if (rcode) { |
| printf("fail in cmd [%s], rcode %d\n", cmdBuf, rcode); |
| return 0;//item size is 0 |
| } |
| envFileSz = getenv("filesize"); |
| /*SDC_DBG("size of item %s is 0x%s\n", imgItemPath, envFileSz);*/ |
| |
| return simple_strtoull(envFileSz, NULL, 16); |
| } |
| |
| //<0 if failed, 0 is normal, 1 is sparse, others reserved |
| int do_fat_get_file_format(const char* imgFilePath, unsigned char* pbuf, const unsigned bufSz) |
| { |
| int readSz = 0; |
| |
| int hFile = do_fat_fopen(imgFilePath); |
| if (hFile < 0) { |
| printf("Fail to open file (%s)\n", imgFilePath); |
| return -1; |
| } |
| |
| readSz = do_fat_fread(hFile, pbuf, bufSz); |
| if (readSz <= 0) { |
| printf("Fail to read file(%s), readSz=%d\n", imgFilePath, readSz); |
| do_fat_fclose(hFile); |
| return -1; |
| } |
| |
| readSz = optimus_simg_probe(pbuf, readSz); |
| |
| do_fat_fclose(hFile); |
| |
| return readSz; |
| } |
| |
