static int get_kernel_addresses(size_t image_size,
int verbose, unsigned long *load_address,
unsigned long *mem_free)
{
unsigned long mem_start, mem_size;
int ret;
size_t image_decomp_size;
unsigned long spacing;
ret = sdram_start_and_size(&mem_start, &mem_size);
if (ret)
return ret;
/*
* The kernel documentation "Documentation/arm/Booting" advises
* to place the compressed image outside of the lowest 32 MiB to
* avoid relocation. We should do this if we have at least 64 MiB
* of ram. If we have less space, we assume a maximum
* compression factor of 5.
*/
image_decomp_size = PAGE_ALIGN(image_size * 5);
if (mem_size >= SZ_64M)
image_decomp_size = max_t(size_t, image_decomp_size, SZ_32M);
/*
* By default put oftree/initrd close behind compressed kernel image to
* avoid placing it outside of the kernels lowmem region.
*/
spacing = SZ_1M;
if (*load_address == UIMAGE_INVALID_ADDRESS) {
/*
* Place the kernel at an address where it does not need to
* relocate itself before decompression.
*/
*load_address = mem_start + image_decomp_size;
if (verbose)
printf("no OS load address, defaulting to 0x%08lx\n",
*load_address);
} else if (*load_address <= mem_start + image_decomp_size) {
/*
* If the user/image specified an address where the kernel needs
* to relocate itself before decompression we need to extend the
* spacing to allow this relocation to happen without
* overwriting anything placed behind the kernel.
*/
spacing += image_decomp_size;
}
*mem_free = PAGE_ALIGN(*load_address + image_size + spacing);
/*
* Place oftree/initrd outside of the first 128 MiB, if we have space
* for it. This avoids potential conflicts with the kernel decompressor.
*/
if (mem_size > SZ_256M)
*mem_free = max(*mem_free, mem_start + SZ_128M);
return 0;
}
static int do_bootm_linux(struct image_data *data)
{
unsigned long load_address, mem_start, mem_size, mem_free;
int ret;
ret = sdram_start_and_size(&mem_start, &mem_size);
if (ret)
return ret;
load_address = data->os_address;
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.
*/
load_address = mem_start + PAGE_ALIGN(
uimage_get_size(data->os, data->os_num) * 4);
if (bootm_verbose(data))
printf("no OS load address, defaulting to 0x%08lx\n",
load_address);
}
ret = bootm_load_os(data, load_address);
if (ret)
return ret;
/*
* 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, 0);
}
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_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;
}
