/*
* 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;
}
