/*
   * (C) Copyright 2011 - 2012 Samsung Electronics
   * EXT4 filesystem implementation in Uboot by
   * Uma Shankar <uma.shankar@samsung.com>
   * Manjunatha C Achar <a.manjunatha@samsung.com>
   *
   * ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
   *		       Ext4 read optimization taken from Open-Moko
   *		       Qi bootloader
   *
   * (C) Copyright 2004
   * esd gmbh <www.esd-electronics.com>
   * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
   *
   * based on code from grub2 fs/ext2.c and fs/fshelp.c by
   * GRUB  --  GRand Unified Bootloader
   * Copyright (C) 2003, 2004  Free Software Foundation, Inc.
   *
   * ext4write : Based on generic ext4 protocol.
   *
   * SPDX-License-Identifier:	GPL-2.0+
   */
  
  #include <common.h>
  #include <ext_common.h>
  #include <ext4fs.h>
  #include "ext4_common.h"
  #include <div64.h>
  
  int ext4fs_symlinknest;
  struct ext_filesystem ext_fs;
  
  struct ext_filesystem *get_fs(void)
  {
  	return &ext_fs;
  }
  
  void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot)
  {
  	if ((node != &ext4fs_root->diropen) && (node != currroot))
  		free(node);
  }
  
  /*
   * Taken from openmoko-kernel mailing list: By Andy green
   * Optimized read file API : collects and defers contiguous sector
   * reads into one potentially more efficient larger sequential read action
   */
  int ext4fs_read_file(struct ext2fs_node *node, loff_t pos,
  		loff_t len, char *buf, loff_t *actread)
  {
  	struct ext_filesystem *fs = get_fs();
  	int i;
  	lbaint_t blockcnt;
  	int log2blksz = fs->dev_desc->log2blksz;
  	int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz;
  	int blocksize = (1 << (log2_fs_blocksize + log2blksz));
  	unsigned int filesize = __le32_to_cpu(node->inode.size);
  	lbaint_t previous_block_number = -1;
  	lbaint_t delayed_start = 0;
  	lbaint_t delayed_extent = 0;
  	lbaint_t delayed_skipfirst = 0;
  	lbaint_t delayed_next = 0;
  	char *delayed_buf = NULL;
  	short status;
  
  	/* Adjust len so it we can't read past the end of the file. */
  	if (len > filesize)
  		len = filesize;
  
  	blockcnt = lldiv(((len + pos) + blocksize - 1), blocksize);
  
  	for (i = lldiv(pos, blocksize); i < blockcnt; i++) {
  		lbaint_t blknr;
  		int blockoff = pos - (blocksize * i);
  		int blockend = blocksize;
  		int skipfirst = 0;
  		blknr = read_allocated_block(&(node->inode), i);
  		if (blknr < 0)
  			return -1;
  
  		blknr = blknr << log2_fs_blocksize;
  
  		/* Last block.  */
  		if (i == blockcnt - 1) {
  			blockend = (len + pos) - (blocksize * i);
  
  			/* The last portion is exactly blocksize. */
  			if (!blockend)
  				blockend = blocksize;
  		}
  
  		/* First block. */
  		if (i == lldiv(pos, blocksize)) {
  			skipfirst = blockoff;
  			blockend -= skipfirst;
  		}
  		if (blknr) {
  			int status;
  
  			if (previous_block_number != -1) {
  				if (delayed_next == blknr) {
  					delayed_extent += blockend;
  					delayed_next += blockend >> log2blksz;
  				} else {	/* spill */
  					status = ext4fs_devread(delayed_start,
  							delayed_skipfirst,
  							delayed_extent,
  							delayed_buf);
  					if (status == 0)
  						return -1;
  					previous_block_number = blknr;
  					delayed_start = blknr;
  					delayed_extent = blockend;
  					delayed_skipfirst = skipfirst;
  					delayed_buf = buf;
  					delayed_next = blknr +
  						(blockend >> log2blksz);
  				}
  			} else {
  				previous_block_number = blknr;
  				delayed_start = blknr;
  				delayed_extent = blockend;
  				delayed_skipfirst = skipfirst;
  				delayed_buf = buf;
  				delayed_next = blknr +
  					(blockend >> log2blksz);
  			}
  		} else {
  			if (previous_block_number != -1) {
  				/* spill */
  				status = ext4fs_devread(delayed_start,
  							delayed_skipfirst,
  							delayed_extent,
  							delayed_buf);
  				if (status == 0)
  					return -1;
  				previous_block_number = -1;
  			}
  			memset(buf, 0, blocksize - skipfirst);
  		}
  		buf += blocksize - skipfirst;
  	}
  	if (previous_block_number != -1) {
  		/* spill */
  		status = ext4fs_devread(delayed_start,
  					delayed_skipfirst, delayed_extent,
  					delayed_buf);
  		if (status == 0)
  			return -1;
  		previous_block_number = -1;
  	}
  
  	*actread  = len;
  	return 0;
  }
  
  int ext4fs_ls(const char *dirname)
  {
  	struct ext2fs_node *dirnode;
  	int status;
  
  	if (dirname == NULL)
  		return 0;
  
  	status = ext4fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,
  				  FILETYPE_DIRECTORY);
  	if (status != 1) {
  		printf("** Can not find directory. **
  ");
  		return 1;
  	}
  
  	ext4fs_iterate_dir(dirnode, NULL, NULL, NULL);
  	ext4fs_free_node(dirnode, &ext4fs_root->diropen);
  
  	return 0;
  }
  
  int ext4fs_exists(const char *filename)
  {
  	loff_t file_len;
  	int ret;
  
  	ret = ext4fs_open(filename, &file_len);
  	return ret == 0;
  }
  
  int ext4fs_size(const char *filename, loff_t *size)
  {
  	return ext4fs_open(filename, size);
  }
  
  int ext4fs_read(char *buf, loff_t len, loff_t *actread)
  {
  	if (ext4fs_root == NULL || ext4fs_file == NULL)
  		return 0;
  
  	return ext4fs_read_file(ext4fs_file, 0, len, buf, actread);
  }
  
  int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
  		 disk_partition_t *fs_partition)
  {
  	ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
  
  	if (!ext4fs_mount(fs_partition->size)) {
  		ext4fs_close();
  		return -1;
  	}
  
  	return 0;
  }
  
  int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
  		   loff_t *len_read)
  {
  	loff_t file_len;
  	int ret;
  
  	if (offset != 0) {
  		printf("** Cannot support non-zero offset **
  ");
  		return -1;
  	}
  
  	ret = ext4fs_open(filename, &file_len);
  	if (ret < 0) {
  		printf("** File not found %s **
  ", filename);
  		return -1;
  	}
  
  	if (len == 0)
  		len = file_len;
  
  	return ext4fs_read(buf, len, len_read);
  }
  
  int ext4fs_uuid(char *uuid_str)
  {
  	if (ext4fs_root == NULL)
  		return -1;
  
  #ifdef CONFIG_LIB_UUID
  	uuid_bin_to_str((unsigned char *)ext4fs_root->sblock.unique_id,
  			uuid_str, UUID_STR_FORMAT_STD);
  
  	return 0;
  #else
  	return -ENOSYS;
  #endif
  }