diff --git a/arch/mips/lib/bootm.c b/arch/mips/lib/bootm.c
index 5bb09cc..6c56202 100644
--- a/arch/mips/lib/bootm.c
+++ b/arch/mips/lib/bootm.c
@@ -46,43 +46,36 @@
 static int do_bootm_elf(struct image_data *data)
 {
 	void (*entry)(int, void *);
-	struct elf_image *elf;
-	void *fdt, *buf;
+	void *fdt;
 	int ret = 0;
 
-	buf = read_file(data->os_file, NULL);
-	if (!buf)
-		return -EINVAL;
-
-	elf = elf_load_image(buf);
-	if (IS_ERR(elf))
-		return PTR_ERR(elf);
+	ret = bootm_load_os(data, data->os_address);
+	if (ret)
+		return ret;
 
 	fdt = bootm_get_devicetree(data);
 	if (IS_ERR(fdt)) {
 		ret = PTR_ERR(fdt);
-		goto bootm_elf_done;
+		goto bootm_free_fdt;
 	}
 
 	pr_info("Starting application at 0x%08lx, dts 0x%08lx...\n",
-		phys_to_virt(elf->entry), data->of_root_node);
+		phys_to_virt(data->os_address), data->of_root_node);
 
 	if (data->dryrun)
-		goto bootm_elf_done;
+		goto bootm_free_fdt;
 
 	shutdown_barebox();
 
-	entry = (void *) (unsigned long) elf->entry;
+	entry = (void *) (unsigned long) data->os_address;
 
 	entry(-2, phys_to_virt((unsigned long)fdt));
 
 	pr_err("ELF application terminated\n");
 	ret = -EINVAL;
 
-bootm_elf_done:
-	elf_release_image(elf);
+bootm_free_fdt:
 	free(fdt);
-	free(buf);
 
 	return ret;
 }
diff --git a/common/Kconfig b/common/Kconfig
index ac282d8..d75b43d 100644
--- a/common/Kconfig
+++ b/common/Kconfig
@@ -597,6 +597,14 @@
 	help
 	  Support using Android Images.
 
+config BOOTM_ELF
+	bool
+	depends on BOOTM
+	select ELF
+	prompt "elf loading support"
+	help
+	  Add support to load elf file with bootm.
+
 config BOOTM_FITIMAGE
 	bool
 	prompt "FIT image support"
diff --git a/common/bootm.c b/common/bootm.c
index 8fec1ee..4110d8d 100644
--- a/common/bootm.c
+++ b/common/bootm.c
@@ -143,6 +143,9 @@
 		return 0;
 	}
 
+	if (IS_ENABLED(CONFIG_ELF) && data->elf)
+		return elf_load(data->elf);
+
 	if (data->os_file) {
 		data->os_res = file_to_sdram(data->os_file, load_address);
 		if (!data->os_res)
@@ -470,6 +473,8 @@
 {
 	int ret;
 
+	if (data->elf)
+		return elf_get_mem_size(data->elf);
 	if (data->os)
 		return uimage_get_size(data->os, uimage_part_num(data->os_part));
 	if (data->os_fit)
@@ -517,6 +522,22 @@
 	return 0;
 }
 
+static int bootm_open_elf(struct image_data *data)
+{
+	if (!IS_ENABLED(CONFIG_ELF))
+		return -ENOSYS;
+
+	data->elf = elf_open(data->os_file);
+	if (IS_ERR(data->elf))
+		return PTR_ERR(data->elf);
+
+	printf("Entry Point:  %08llx\n", data->elf->entry);
+
+	data->os_address = data->elf->entry;
+
+	return 0;
+}
+
 static void bootm_print_info(struct image_data *data)
 {
 	if (data->os_res)
@@ -652,6 +673,16 @@
 		}
 	}
 
+	if (os_type == filetype_elf) {
+		ret = bootm_open_elf(data);
+		if (ret) {
+			printf("Loading ELF image failed with: %s\n",
+					strerror(-ret));
+			data->elf = NULL;
+			goto err_out;
+		}
+	}
+
 	if (bootm_data->appendroot) {
 		char *rootarg;
 
@@ -721,6 +752,8 @@
 		uimage_close(data->initrd);
 	if (data->os)
 		uimage_close(data->os);
+	if (IS_ENABLED(CONFIG_ELF) && data->elf)
+		elf_close(data->elf);
 	if (IS_ENABLED(CONFIG_FITIMAGE) && data->os_fit)
 		fit_close(data->os_fit);
 	if (data->of_root_node && data->of_root_node != of_get_root_node())
diff --git a/common/elf.c b/common/elf.c
index 4733acc..af22be3 100644
--- a/common/elf.c
+++ b/common/elf.c
@@ -5,21 +5,31 @@
 
 #include <common.h>
 #include <elf.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <libfile.h>
 #include <memory.h>
+#include <unistd.h>
+#include <linux/fs.h>
+#include <linux/list_sort.h>
 
 struct elf_section {
 	struct list_head list;
 	struct resource *r;
+	void *phdr;
 };
 
 static int elf_request_region(struct elf_image *elf, resource_size_t start,
-			      resource_size_t size)
+			      resource_size_t size, void *phdr)
 {
 	struct list_head *list = &elf->list;
 	struct resource *r_new;
 	struct elf_section *r;
 
-	r = xzalloc(sizeof(*r));
+	r = calloc(1, sizeof(*r));
+	if (!r)
+		return -ENOMEM;
+
 	r_new = request_sdram_region("elf_section", start, size);
 	if (!r_new) {
 		pr_err("Failed to request region: %pa %pa\n", &start, &size);
@@ -27,6 +37,7 @@
 	}
 
 	r->r = r_new;
+	r->phdr = phdr;
 	list_add_tail(&r->list, list);
 
 	return 0;
@@ -39,15 +50,14 @@
 
 	list_for_each_entry_safe(r, r_tmp, list, list) {
 		release_sdram_region(r->r);
+		list_del(&r->list);
 		free(r);
 	}
 }
 
-
-static int load_elf_phdr_segment(struct elf_image *elf, void *src,
-				 void *phdr)
+static int request_elf_segment(struct elf_image *elf, void *phdr)
 {
-	void *dst = (void *) elf_phdr_p_paddr(elf, phdr);
+	void *dst = (void *) (phys_addr_t) elf_phdr_p_paddr(elf, phdr);
 	int ret;
 	u64 p_filesz = elf_phdr_p_filesz(elf, phdr);
 	u64 p_memsz = elf_phdr_p_memsz(elf, phdr);
@@ -59,88 +69,237 @@
 	if (!p_filesz)
 		return 0;
 
-	pr_debug("Loading phdr to 0x%p (%llu bytes)\n", dst, p_filesz);
+	if (dst < elf->low_addr)
+		elf->low_addr = dst;
+	if (dst + p_memsz > elf->high_addr)
+		elf->high_addr = dst + p_memsz;
 
-	ret = elf_request_region(elf, (resource_size_t)dst, p_filesz);
+	pr_debug("Requesting segment 0x%p (%llu bytes)\n", dst, p_filesz);
+
+	ret = elf_request_region(elf, (resource_size_t)dst, p_filesz, phdr);
 	if (ret)
 		return ret;
 
-	memcpy(dst, src, p_filesz);
-
-	if (p_filesz < p_memsz)
-		memset(dst + p_filesz, 0x00,
-		       p_memsz - p_filesz);
-
 	return 0;
 }
 
-static int load_elf_image_phdr(struct elf_image *elf)
+static int elf_section_cmp(void *priv, struct list_head *a, struct list_head *b)
 {
-	void *buf = elf->buf;
+	struct elf_image *elf = priv;
+	struct elf_section *elf_a, *elf_b;
+
+	if (a == b)
+		return 0;
+
+	elf_a = list_entry(a, struct elf_section, list);
+	elf_b = list_entry(b, struct elf_section, list);
+
+	return elf_phdr_p_offset(elf, elf_a->phdr) >
+	       elf_phdr_p_offset(elf, elf_b->phdr);
+}
+
+static int load_elf_to_memory(struct elf_image *elf)
+{
+	void *dst;
+	int ret, fd;
+	u64 p_filesz, p_memsz, p_offset;
+	struct elf_section *r;
+	struct list_head *list = &elf->list;
+
+	fd = open(elf->filename, O_RDONLY);
+	if (fd < 0) {
+		pr_err("could not open: %s\n", errno_str());
+		return -errno;
+	}
+
+	list_for_each_entry(r, list, list) {
+		p_offset = elf_phdr_p_offset(elf, r->phdr);
+		p_filesz = elf_phdr_p_filesz(elf, r->phdr);
+		p_memsz = elf_phdr_p_memsz(elf, r->phdr);
+		dst = (void *) (phys_addr_t) elf_phdr_p_paddr(elf, r->phdr);
+
+		ret = lseek(fd, p_offset, SEEK_SET);
+		if (ret == -1) {
+			pr_err("lseek at offset 0x%llx failed\n", p_offset);
+			close(fd);
+			return ret;
+		}
+
+		pr_debug("Loading phdr offset 0x%llx to 0x%p (%llu bytes)\n",
+			 p_offset, dst, p_filesz);
+
+		if (read_full(fd, dst, p_filesz) < 0) {
+			pr_err("could not read elf segment: %s\n",
+			       errno_str());
+			close(fd);
+			return -errno;
+		}
+
+		if (p_filesz < p_memsz)
+			memset(dst + p_filesz, 0x00, p_memsz - p_filesz);
+	}
+
+	close(fd);
+
+	return 0;
+}
+
+static int load_elf_image_segments(struct elf_image *elf)
+{
+	void *buf = elf->hdr_buf;
 	void *phdr = (void *) (buf + elf_hdr_e_phoff(elf, buf));
 	int i, ret;
 
-	elf->entry = elf_hdr_e_entry(elf, buf);
+	/* File as already been loaded */
+	if (!list_empty(&elf->list))
+		return -EINVAL;
 
 	for (i = 0; i < elf_hdr_e_phnum(elf, buf) ; ++i) {
-		void *src = buf + elf_phdr_p_offset(elf, phdr);
-
-		ret = load_elf_phdr_segment(elf, src, phdr);
-		/* in case of error elf_load_image() caller should clean up and
-		 * call elf_release_image() */
+		ret = request_elf_segment(elf, phdr);
 		if (ret)
-			return ret;
+			goto elf_release_regions;
 
 		phdr += elf_size_of_phdr(elf);
 	}
 
+	/*
+	 * Sort the list to avoid doing backward lseek while loading the elf
+	 * segments from file to memory(some filesystems don't support it)
+	 */
+	list_sort(elf, &elf->list, elf_section_cmp);
+
+	ret = load_elf_to_memory(elf);
+	if (ret)
+		goto elf_release_regions;
+
 	return 0;
+
+elf_release_regions:
+	elf_release_regions(elf);
+
+	return ret;
 }
 
-static int elf_check_image(struct elf_image *elf)
+static int elf_check_image(struct elf_image *elf, void *buf)
 {
-	if (strncmp(elf->buf, ELFMAG, SELFMAG)) {
+	if (strncmp(buf, ELFMAG, SELFMAG)) {
 		pr_err("ELF magic not found.\n");
 		return -EINVAL;
 	}
 
-	elf->class = ((char *) elf->buf)[EI_CLASS];
+	elf->class = ((char *) buf)[EI_CLASS];
 
-	if (elf_hdr_e_type(elf, elf->buf) != ET_EXEC) {
+	if (elf_hdr_e_type(elf, buf) != ET_EXEC) {
 		pr_err("Non EXEC ELF image.\n");
 		return -ENOEXEC;
 	}
 
+	if (!elf_hdr_e_phnum(elf, buf)) {
+		pr_err("No phdr found.\n");
+		return -ENOEXEC;
+	}
+
 	return 0;
 }
 
-struct elf_image *elf_load_image(void *buf)
+static struct elf_image *elf_check_init(const char *filename)
 {
+	int ret, fd;
+	int hdr_size;
+	struct elf64_hdr hdr;
 	struct elf_image *elf;
-	int ret;
 
-	elf = xzalloc(sizeof(*elf));
+	elf = calloc(1, sizeof(*elf));
+	if (!elf)
+		return ERR_PTR(-ENOMEM);
 
 	INIT_LIST_HEAD(&elf->list);
+	elf->low_addr = (void *) (unsigned long) -1;
+	elf->high_addr = 0;
 
-	elf->buf = buf;
-
-	ret = elf_check_image(elf);
-	if (ret)
-		return ERR_PTR(ret);
-
-	ret = load_elf_image_phdr(elf);
-	if (ret) {
-		elf_release_image(elf);
-		return ERR_PTR(ret);
+	/* First pass is to read elf header only */
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		pr_err("could not open: %s\n", errno_str());
+		ret = -errno;
+		goto err_free_elf;
 	}
 
+	if (read_full(fd, &hdr, sizeof(hdr)) < 0) {
+		pr_err("could not read elf header: %s\n", errno_str());
+		close(fd);
+		ret = -errno;
+		goto err_free_elf;
+	}
+	close(fd);
+
+	ret = elf_check_image(elf, &hdr);
+	if (ret)
+		goto err_free_elf;
+
+	hdr_size = elf_hdr_e_phoff(elf, &hdr) +
+		   elf_hdr_e_phnum(elf, &hdr) *
+		   elf_hdr_e_phentsize(elf, &hdr);
+
+	/* Second pass is to read the whole elf header and program headers */
+	elf->hdr_buf = malloc(hdr_size);
+	if (!elf->hdr_buf) {
+		ret = -ENOMEM;
+		goto err_free_elf;
+	}
+
+	/*
+	 * We must open the file again since some fs (tftp) do not support
+	 * backward lseek operations
+	 */
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		pr_err("could not open: %s\n", errno_str());
+		ret = -errno;
+		goto err_free_hdr_buf;
+	}
+
+	if (read_full(fd, elf->hdr_buf, hdr_size) < 0) {
+		pr_err("could not read elf program headers: %s\n", errno_str());
+		ret = -errno;
+		close(fd);
+		goto err_free_hdr_buf;
+	}
+	close(fd);
+
+	elf->filename = strdup(filename);
+	if (!elf->filename) {
+		ret = -ENOMEM;
+		goto err_free_hdr_buf;
+	}
+
+	elf->entry = elf_hdr_e_entry(elf, elf->hdr_buf);
+
 	return elf;
+
+err_free_hdr_buf:
+	free(elf->hdr_buf);
+err_free_elf:
+	free(elf);
+
+	return ERR_PTR(ret);
 }
 
-void elf_release_image(struct elf_image *elf)
+struct elf_image *elf_open(const char *filename)
+{
+	return elf_check_init(filename);
+}
+
+int elf_load(struct elf_image *elf)
+{
+	return load_elf_image_segments(elf);
+}
+
+void elf_close(struct elf_image *elf)
 {
 	elf_release_regions(elf);
 
+	free(elf->hdr_buf);
+	free(elf->filename);
 	free(elf);
 }
diff --git a/include/bootm.h b/include/bootm.h
index 7782de7..ef5148f 100644
--- a/include/bootm.h
+++ b/include/bootm.h
@@ -46,6 +46,9 @@
 	/* if os is an uImage this will be provided */
 	struct uimage_handle *os;
 
+	/* if os is an elf file this will be provided */
+	struct elf_image *elf;
+
 	/* if os is a FIT image this will be provided */
 	struct fit_handle *os_fit;
 
diff --git a/include/elf.h b/include/elf.h
index 113728f..7970fd2 100644
--- a/include/elf.h
+++ b/include/elf.h
@@ -403,11 +403,20 @@
 	struct list_head list;
 	u8 class;
 	u64 entry;
-	void *buf;
+	void *low_addr;
+	void *high_addr;
+	void *hdr_buf;
+	char *filename;
 };
 
-struct elf_image *elf_load_image(void *buf);
-void elf_release_image(struct elf_image *elf);
+static inline size_t elf_get_mem_size(struct elf_image *elf)
+{
+	return elf->high_addr - elf->low_addr;
+}
+
+struct elf_image *elf_open(const char *filename);
+void elf_close(struct elf_image *elf);
+int elf_load(struct elf_image *elf);
 
 #define ELF_GET_FIELD(__s, __field, __type) \
 static inline __type elf_##__s##_##__field(struct elf_image *elf, void *arg) { \
@@ -420,6 +429,7 @@
 ELF_GET_FIELD(hdr, e_entry, u64)
 ELF_GET_FIELD(hdr, e_phnum, u16)
 ELF_GET_FIELD(hdr, e_phoff, u64)
+ELF_GET_FIELD(hdr, e_phentsize, u16)
 ELF_GET_FIELD(hdr, e_type, u16)
 ELF_GET_FIELD(phdr, p_paddr, u64)
 ELF_GET_FIELD(phdr, p_filesz, u64)