vrl4.c

Go to the documentation of this file.

/*
 * vrl4 format generator
 *
 * Copyright (C) 2010 Simon Horman
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */

/*
 * usage: vrl4 < zImage > out
 *    dd if=out of=/dev/sdx bs=512 seek=1 # Write the image to sector 1
 *
 * Reads a zImage from stdin and writes a vrl4 image to stdout.
 * In practice this means writing a padded vrl4 header to stdout followed
 * by the zImage.
 *
 * The padding places the zImage at ALIGN bytes into the output.
 * The vrl4 uses ALIGN + START_BASE as the start_address.
 * This is where the mask ROM will jump to after verifying the header.
 *
 * The header sets copy_size to min(sizeof(zImage), MAX_BOOT_PROG_LEN) + ALIGN.
 * That is, the mask ROM will load the padded header (ALIGN bytes)
 * And then MAX_BOOT_PROG_LEN bytes of the image, or the entire image,
 * whichever is smaller.
 *
 * The zImage is not modified in any way.
 */

#define _BSD_SOURCE
#include <endian.h>
#include <unistd.h>
#include <stdint.h>
#include <stdio.h>
#include <errno.h>

struct hdr {
    uint32_t magic1;
    uint32_t reserved1;
    uint32_t magic2;
    uint32_t reserved2;
    uint16_t copy_size;
    uint16_t boot_options;
    uint32_t reserved3;
    uint32_t start_address;
    uint32_t reserved4;
    uint32_t reserved5;
    char     reserved6[308];
};

#define DECLARE_HDR(h)                  \
    struct hdr (h) = {              \
        .magic1 =   htole32(0xea000000),    \
        .reserved1 =    htole32(0x56),      \
        .magic2 =   htole32(0xe59ff008),    \
        .reserved3 =    htole16(0x1) }

/* Align to 512 bytes, the MMCIF sector size */
#define ALIGN_BITS  9
#define ALIGN       (1 << ALIGN_BITS)

#define START_BASE  0xe55b0000

/*
 * With an alignment of 512 the header uses the first sector.
 * There is a 128 sector (64kbyte) limit on the data loaded by the mask ROM.
 * So there are 127 sectors left for the boot programme. But in practice
 * Only a small portion of a zImage is needed, 16 sectors should be more
 * than enough.
 *
 * Note that this sets how much of the zImage is copied by the mask ROM.
 * The entire zImage is present after the header and is loaded
 * by the code in the boot program (which is the first portion of the zImage).
 */
#define MAX_BOOT_PROG_LEN (16 * 512)

#define ROUND_UP(x) ((x + ALIGN - 1) & ~(ALIGN - 1))

ssize_t do_read(int fd, void *buf, size_t count)
{
    size_t offset = 0;
    ssize_t l;

    while (offset < count) {
        l = read(fd, buf + offset, count - offset);
        if (!l)
            break;
        if (l < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                continue;
            perror("read");
            return -1;
        }
        offset += l;
    }

    return offset;
}

ssize_t do_write(int fd, const void *buf, size_t count)
{
    size_t offset = 0;
    ssize_t l;

    while (offset < count) {
        l = write(fd, buf + offset, count - offset);
        if (l < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                continue;
            perror("write");
            return -1;
        }
        offset += l;
    }

    return offset;
}

ssize_t write_zero(int fd, size_t len)
{
    size_t i = len;

    while (i--) {
        const char x = 0;
        if (do_write(fd, &x, 1) < 0)
            return -1;
    }

    return len;
}

int main(void)
{
    DECLARE_HDR(hdr);
    char boot_program[MAX_BOOT_PROG_LEN];
    size_t aligned_hdr_len, alligned_prog_len;
    ssize_t prog_len;

    prog_len = do_read(0, boot_program, sizeof(boot_program));
    if (prog_len <= 0)
        return -1;

    aligned_hdr_len = ROUND_UP(sizeof(hdr));
    hdr.start_address = htole32(START_BASE + aligned_hdr_len);
    alligned_prog_len = ROUND_UP(prog_len);
    hdr.copy_size = htole16(aligned_hdr_len + alligned_prog_len);

    if (do_write(1, &hdr, sizeof(hdr)) < 0)
        return -1;
    if (write_zero(1, aligned_hdr_len - sizeof(hdr)) < 0)
        return -1;

    if (do_write(1, boot_program, prog_len) < 0)
        return 1;

    /* Write out the rest of the kernel */
    while (1) {
        prog_len = do_read(0, boot_program, sizeof(boot_program));
        if (prog_len < 0)
            return 1;
        if (prog_len == 0)
            break;
        if (do_write(1, boot_program, prog_len) < 0)
            return 1;
    }

    return 0;
}