/* * Load an uImage to a dynamically allocated sdram resource. * the resource must be freed afterwards with release_sdram_region */ struct resource *uimage_load_to_sdram(struct uimage_handle *handle, int image_no, unsigned long load_address) { int ret; ssize_t size; resource_size_t start = (resource_size_t)load_address; uimage_buf = (void *)load_address; uimage_size = 0; size = uimage_get_size(handle, image_no); if (size < 0) return NULL; uimage_resource = request_sdram_region("uimage", start, size); if (!uimage_resource) { printf("unable to request SDRAM 0x%08llx-0x%08llx\n", (unsigned long long)start, (unsigned long long)start + size - 1); return NULL; } ret = uimage_load(handle, image_no, uimage_sdram_flush); if (ret) { release_sdram_region(uimage_resource); return NULL; } return uimage_resource; }
static int barebox_memory_areas_init(void) { if(barebox_boarddata) request_sdram_region("board data", (unsigned long)barebox_boarddata, barebox_boarddata_size); return 0; }
struct resource *file_to_sdram(const char *filename, unsigned long adr) { struct resource *res; size_t size = BUFSIZ; size_t ofs = 0; int fd; fd = open(filename, O_RDONLY); if (fd < 0) return NULL; while (1) { size_t now; res = request_sdram_region("image", adr, size); if (!res) { printf("unable to request SDRAM 0x%08lx-0x%08lx\n", adr, adr + size - 1); goto out; } now = read_full(fd, (void *)(res->start + ofs), BUFSIZ); if (now < 0) { release_sdram_region(res); res = NULL; goto out; } if (now < BUFSIZ) { release_sdram_region(res); res = request_sdram_region("image", adr, ofs + now); goto out; } release_sdram_region(res); ofs += BUFSIZ; size += BUFSIZ; } out: close(fd); return res; }
static int uimage_sdram_flush(void *buf, unsigned int len) { if (uimage_size + len > resource_size(uimage_resource)) { resource_size_t start = uimage_resource->start; resource_size_t size = resource_size(uimage_resource) + len; release_sdram_region(uimage_resource); uimage_resource = request_sdram_region("uimage", start, size); if (!uimage_resource) { printf("unable to request SDRAM 0x%08x-0x%08x\n", start, start + size - 1); return -ENOMEM; } } memcpy(uimage_buf + uimage_size, buf, len); uimage_size += len; return len; }
static int do_bootm_aimage(struct image_data *data) { struct resource *snd_stage_res; int fd, ret; struct android_header __header, *header; void *buf; int to_read; struct android_header_comp *cmp; unsigned long mem_free; unsigned long mem_start, mem_size; ret = sdram_start_and_size(&mem_start, &mem_size); if (ret) return ret; fd = open(data->os_file, O_RDONLY); if (fd < 0) { perror("open"); return 1; } header = &__header; ret = read(fd, header, sizeof(*header)); if (ret < sizeof(*header)) { printf("could not read %s\n", data->os_file); goto err_out; } printf("Android Image for '%s'\n", header->name); /* * As on tftp we do not support lseek and we will just have to seek * for the size of a page - 1 max just buffer instead to read to dummy * data */ buf = xmalloc(header->page_size); to_read = header->page_size - sizeof(*header); ret = read_full(fd, buf, to_read); if (ret < 0) { printf("could not read dummy %d from %s\n", to_read, data->os_file); goto err_out; } cmp = &header->kernel; data->os_res = request_sdram_region("akernel", cmp->load_addr, cmp->size); if (!data->os_res) { pr_err("Cannot request region 0x%08x - 0x%08x, using default load address\n", cmp->load_addr, cmp->size); data->os_address = mem_start + PAGE_ALIGN(cmp->size * 4); data->os_res = request_sdram_region("akernel", data->os_address, cmp->size); if (!data->os_res) { pr_err("Cannot request region 0x%08x - 0x%08x\n", cmp->load_addr, cmp->size); ret = -ENOMEM; goto err_out; } } ret = aimage_load_resource(fd, data->os_res, buf, header->page_size); if (ret < 0) { perror("could not read kernel"); goto err_out; } /* * fastboot always expect a ramdisk * in barebox we can be less restrictive */ cmp = &header->ramdisk; if (cmp->size) { data->initrd_res = request_sdram_region("ainitrd", cmp->load_addr, cmp->size); if (!data->initrd_res) { ret = -ENOMEM; goto err_out; } ret = aimage_load_resource(fd, data->initrd_res, buf, header->page_size); if (ret < 0) { perror("could not read initrd"); goto err_out; } } if (!getenv("aimage_noverwrite_bootargs")) linux_bootargs_overwrite(header->cmdline); if (!getenv("aimage_noverwrite_tags")) armlinux_set_bootparams((void*)header->tags_addr); cmp = &header->second_stage; if (cmp->size) { void (*second)(void); snd_stage_res = request_sdram_region("asecond", cmp->load_addr, cmp->size); if (!snd_stage_res) { ret = -ENOMEM; goto err_out; } ret = aimage_load_resource(fd, snd_stage_res, buf, header->page_size); if (ret < 0) { perror("could not read initrd"); goto err_out; } second = (void*)snd_stage_res->start; shutdown_barebox(); second(); restart_machine(); } close(fd); /* * Put devicetree right after initrd if present or after the kernel * if not. */ if (data->initrd_res) mem_free = PAGE_ALIGN(data->initrd_res->end); else mem_free = PAGE_ALIGN(data->os_res->end + SZ_1M); return __do_bootm_linux(data, mem_free, 0); err_out: linux_bootargs_overwrite(NULL); close(fd); return ret; }
static int do_bootz_linux(struct image_data *data) { int fd, ret, swap = 0; struct zimage_header __header, *header; void *zimage; u32 end, start; size_t image_size; unsigned long load_address = data->os_address; unsigned long mem_free; fd = open(data->os_file, O_RDONLY); if (fd < 0) { perror("open"); return 1; } header = &__header; ret = read(fd, header, sizeof(*header)); if (ret < sizeof(*header)) { printf("could not read %s\n", data->os_file); goto err_out; } switch (header->magic) { case swab32(ZIMAGE_MAGIC): swap = 1; /* fall through */ case ZIMAGE_MAGIC: break; default: printf("invalid magic 0x%08x\n", header->magic); ret = -EINVAL; goto err_out; } end = header->end; start = header->start; if (swap) { end = swab32(end); start = swab32(start); } image_size = end - start; load_address = data->os_address; ret = get_kernel_addresses(image_size, bootm_verbose(data), &load_address, &mem_free); if (ret) return ret; data->os_res = request_sdram_region("zimage", load_address, image_size); if (!data->os_res) { pr_err("bootm/zImage: failed to request memory at 0x%lx to 0x%lx (%d).\n", load_address, load_address + image_size, image_size); ret = -ENOMEM; goto err_out; } zimage = (void *)data->os_res->start; memcpy(zimage, header, sizeof(*header)); ret = read_full(fd, zimage + sizeof(*header), image_size - sizeof(*header)); if (ret < 0) goto err_out; if (ret < image_size - sizeof(*header)) { printf("premature end of image\n"); ret = -EIO; goto err_out; } if (swap) { void *ptr; for (ptr = zimage; ptr < zimage + end; ptr += 4) *(u32 *)ptr = swab32(*(u32 *)ptr); } ret = do_bootz_linux_fdt(fd, data); if (ret && ret != -ENXIO) goto err_out; close(fd); return __do_bootm_linux(data, mem_free, swap); err_out: close(fd); return ret; }
static int do_bootm_aimage(struct image_data *data) { struct resource *snd_stage_res; int fd, ret; struct android_header __header, *header; void *buf; int to_read; struct android_header_comp *cmp; fd = open(data->os_file, O_RDONLY); if (fd < 0) { perror("open"); return 1; } header = &__header; ret = read(fd, header, sizeof(*header)); if (ret < sizeof(*header)) { printf("could not read %s\n", data->os_file); goto err_out; } printf("Android Image for '%s'\n", header->name); /* * As on tftp we do not support lseek and we will just have to seek * for the size of a page - 1 max just buffer instead to read to dummy * data */ buf = xmalloc(header->page_size); to_read = header->page_size - sizeof(*header); ret = read_full(fd, buf, to_read); if (ret < 0) { printf("could not read dummy %d from %s\n", to_read, data->os_file); goto err_out; } cmp = &header->kernel; data->os_res = request_sdram_region("akernel", cmp->load_addr, cmp->size); if (!data->os_res) { ret = -ENOMEM; goto err_out; } ret = aimage_load_resource(fd, data->os_res, buf, header->page_size); if (ret < 0) { perror("could not read kernel"); goto err_out; } /* * fastboot always expect a ramdisk * in barebox we can be less restrictive */ cmp = &header->ramdisk; if (cmp->size) { data->initrd_res = request_sdram_region("ainitrd", cmp->load_addr, cmp->size); if (!data->initrd_res) { ret = -ENOMEM; goto err_out; } ret = aimage_load_resource(fd, data->initrd_res, buf, header->page_size); if (ret < 0) { perror("could not read initrd"); goto err_out; } } if (!getenv("aimage_noverwrite_bootargs")) linux_bootargs_overwrite(header->cmdline); if (!getenv("aimage_noverwrite_tags")) armlinux_set_bootparams((void*)header->tags_addr); cmp = &header->second_stage; if (cmp->size) { void (*second)(void); snd_stage_res = request_sdram_region("asecond", cmp->load_addr, cmp->size); if (!snd_stage_res) { ret = -ENOMEM; goto err_out; } ret = aimage_load_resource(fd, snd_stage_res, buf, header->page_size); if (ret < 0) { perror("could not read initrd"); goto err_out; } second = (void*)snd_stage_res->start; shutdown_barebox(); second(); reset_cpu(0); } close(fd); return __do_bootm_linux(data, 0); err_out: linux_bootargs_overwrite(NULL); close(fd); return ret; }
static int do_bootz_linux(struct image_data *data) { int fd, ret, swap = 0; struct zimage_header __header, *header; void *zimage; u32 end; unsigned long load_address = data->os_address; if (load_address == UIMAGE_INVALID_ADDRESS) { struct memory_bank *bank = list_first_entry(&memory_banks, struct memory_bank, list); data->os_address = bank->start + SZ_8M; load_address = data->os_address; if (bootm_verbose(data)) printf("no os load address, defaulting to 0x%08lx\n", load_address); } fd = open(data->os_file, O_RDONLY); if (fd < 0) { perror("open"); return 1; } header = &__header; ret = read(fd, header, sizeof(*header)); if (ret < sizeof(*header)) { printf("could not read %s\n", data->os_file); goto err_out; } switch (header->magic) { case swab32(ZIMAGE_MAGIC): swap = 1; /* fall through */ case ZIMAGE_MAGIC: break; default: printf("invalid magic 0x%08x\n", header->magic); ret = -EINVAL; goto err_out; } end = header->end; if (swap) end = swab32(end); data->os_res = request_sdram_region("zimage", load_address, end); if (!data->os_res) { pr_err("bootm/zImage: failed to request memory at 0x%lx to 0x%lx (%d).\n", load_address, load_address + end, end); ret = -ENOMEM; goto err_out; } zimage = (void *)data->os_res->start; memcpy(zimage, header, sizeof(*header)); ret = read_full(fd, zimage + sizeof(*header), end - sizeof(*header)); if (ret < 0) goto err_out; if (ret < end - sizeof(*header)) { printf("premature end of image\n"); ret = -EIO; goto err_out; } if (swap) { void *ptr; for (ptr = zimage; ptr < zimage + end; ptr += 4) *(u32 *)ptr = swab32(*(u32 *)ptr); } ret = do_bootz_linux_fdt(fd, data); if (ret && ret != -ENXIO) goto err_out; close(fd); return __do_bootm_linux(data, swap); err_out: close(fd); return ret; }
static int do_bootz_linux_fdt(int fd, struct image_data *data) { struct fdt_header __header, *header; struct resource *r = data->os_res; struct resource *of_res = data->os_res; void *oftree; int ret; u32 end; header = &__header; ret = read(fd, header, sizeof(*header)); if (ret < sizeof(*header)) return ret; if (file_detect_type(header) != filetype_oftree) return -ENXIO; end = be32_to_cpu(header->totalsize); if (IS_BUILTIN(CONFIG_OFTREE)) { oftree = malloc(end + 0x8000); if (!oftree) { perror("zImage: oftree malloc"); return -ENOMEM; } } else { of_res = request_sdram_region("oftree", r->start + resource_size(r), end); if (!of_res) { perror("zImage: oftree request_sdram_region"); return -ENOMEM; } oftree = (void*)of_res->start; } memcpy(oftree, header, sizeof(*header)); end -= sizeof(*header); ret = read_full(fd, oftree + sizeof(*header), end); if (ret < 0) return ret; if (ret < end) { printf("premature end of image\n"); return -EIO; } if (IS_BUILTIN(CONFIG_OFTREE)) { fdt_open_into(oftree, oftree, end + 0x8000); ret = of_fix_tree(oftree); if (ret) return ret; data->oftree = oftree; } pr_info("zImage: concatenated oftree detected\n"); return 0; }
static int do_bootz_linux(struct image_data *data) { int fd, ret, swap = 0; struct zimage_header __header, *header; void *zimage; u32 end, start; size_t image_size; unsigned long load_address = data->os_address; unsigned long mem_start, mem_size, mem_free; ret = sdram_start_and_size(&mem_start, &mem_size); if (ret) return ret; fd = open(data->os_file, O_RDONLY); if (fd < 0) { perror("open"); return 1; } header = &__header; ret = read(fd, header, sizeof(*header)); if (ret < sizeof(*header)) { printf("could not read %s\n", data->os_file); goto err_out; } switch (header->magic) { case swab32(ZIMAGE_MAGIC): swap = 1; /* fall through */ case ZIMAGE_MAGIC: break; default: printf("invalid magic 0x%08x\n", header->magic); ret = -EINVAL; goto err_out; } end = header->end; start = header->start; if (swap) { end = swab32(end); start = swab32(start); } image_size = end - start; if (load_address == UIMAGE_INVALID_ADDRESS) { /* * Just use a conservative default of 4 times the size of the * compressed image, to avoid the need for the kernel to * relocate itself before decompression. */ data->os_address = mem_start + PAGE_ALIGN(image_size * 4); load_address = data->os_address; if (bootm_verbose(data)) printf("no OS load address, defaulting to 0x%08lx\n", load_address); } data->os_res = request_sdram_region("zimage", load_address, image_size); if (!data->os_res) { pr_err("bootm/zImage: failed to request memory at 0x%lx to 0x%lx (%d).\n", load_address, load_address + image_size, image_size); ret = -ENOMEM; goto err_out; } zimage = (void *)data->os_res->start; memcpy(zimage, header, sizeof(*header)); ret = read_full(fd, zimage + sizeof(*header), image_size - sizeof(*header)); if (ret < 0) goto err_out; if (ret < end - sizeof(*header)) { printf("premature end of image\n"); ret = -EIO; goto err_out; } if (swap) { void *ptr; for (ptr = zimage; ptr < zimage + end; ptr += 4) *(u32 *)ptr = swab32(*(u32 *)ptr); } ret = do_bootz_linux_fdt(fd, data); if (ret && ret != -ENXIO) goto err_out; close(fd); /* * put oftree/initrd close behind compressed kernel image to avoid * placing it outside of the kernels lowmem. */ mem_free = PAGE_ALIGN(data->os_res->end + SZ_1M); return __do_bootm_linux(data, mem_free, swap); err_out: close(fd); return ret; }