src/bsp/lk/app/blxboot/blxboot.c

/*
 * Copyright (c) 2018 MediaTek Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <app.h>
#include <assert.h>
#include <boot_mode.h>
#include <err.h>
#include <errno.h>
#include <fit.h>
#include <kernel/event.h>
#include <kernel/thread.h>
#include <kernel/vm.h>
#include <libfdt.h>
#include <lib/dl_commands.h>        /* [TODO] separate rpmb define from fastboot */
#include <lib/mempool.h>
#include <platform.h>
#include <rpmb/include/rpmb_mac.h> /* [TODO] #include <lib/rpmb_mac.h> */
#include <trace.h>

#include "blx_common.h"
#include "blxboot_ab.h"
#include "blxboot_plat.h"
#include "dto.h"
#include "imageinfo.h"

#define LOCAL_TRACE 0

extern void ext_boot(void);
extern struct imageinfo_t imagelist[];

static int load_all_images(struct blxboot *obj)
{
    int rc;
    int load_idx;
    struct imageinfo_t *img;
    const char *part_name[3];
    uint32_t *boot_mode = &(obj->bootcfg.boot_mode);

    img = &imagelist[0];
    while (img->type != IMGTYPE_NONE) {
        LTRACEF("image load: %s\n", img->imgdata->part_name);

        ASSERT((img->load != NULL) && (img->imgdata != NULL));

        /* setup the load retry sequence: fastboot -> normal -> recovery */
        if (*boot_mode == NORMAL_BOOT)
            load_idx = 1;
        else if (*boot_mode == RECOVERY_BOOT)
            load_idx = 0;
        else /* FASTBOOT_BOOT */
            load_idx = 2;

        part_name[2] = img->imgdata->membdev_name;
        part_name[1] = img->imgdata->part_name;
        part_name[0] = img->imgdata->recovery_part_name;

        /* for non recovery boot partition, no need to try recovery partition
         * if its name is the same with normal boot partition */
        if (*boot_mode != RECOVERY_BOOT) {
            if ((part_name[0] != NULL) && (part_name[1] != NULL) &&
                (!strcmp(part_name[0], part_name[1])))
                part_name[0] = NULL;
        }

        rc = -ENODEV;
        while (load_idx >= 0) {
            if (part_name[load_idx] != NULL) {
                rc = img->load(part_name[load_idx], img);
                if (rc == 0)
                    break;
            }

            load_idx--;
        }

        if (rc == 0) {
            if (obj->ops.notify)
                obj->ops.notify(obj, img);
        } else {
            LTRACEF("load part: %s, type=%d failed\n",
                    img->imgdata->part_name, img->type);
            if ((img->type != IMGTYPE_DTBO) && (img->type != IMGTYPE_VPD))
                return -1;

            /* dtbo/vpd image: allow partition not exist or no valid data.
             * Other cases, boot fail */
            if ((rc != -ENODEV) && (rc != -ENOTSUP))
                return -1;
        }
        img++;
    }

    return 0;
}

static void append_suffix(const char **name, const char *suffix, int suffix_len)
{
    char *new_name;
    int n, len;

    len = strlen(*name) + suffix_len + 1;
    new_name = mempool_alloc(len, MEMPOOL_ANY);
    ASSERT(new_name != NULL);

    n = snprintf(new_name, len, "%s%s", *name, suffix);
    ASSERT(!((n < 0) || (n >= len)));

    *name = new_name;
}

static void update_image_partition_name(const char *suffix)
{
    struct imageinfo_t *img;
    struct image_load_data *imgdata;
    int suffix_len;

    suffix_len = strlen(suffix);
    for (img = &imagelist[0]; img->type != IMGTYPE_NONE; img++) {
        ASSERT((img != NULL) && (img->imgdata != NULL));
        imgdata = img->imgdata;
        if (!imgdata->has_slot)
            continue;

        append_suffix(&imgdata->part_name, suffix, suffix_len);
        if (imgdata->recovery_part_name)
            append_suffix(&imgdata->recovery_part_name, suffix, suffix_len);
    }
}

static void blxboot_task(const struct app_descriptor *app, void *args)
{
    struct blxboot *blxobj;
    struct boot_param bprm = { .arg0 = 0, .arg1 = 0, .arg2 = 0, .arg3 = 0 };
    bool fastboot_on_fail;
    uint32_t *boot_mode;
    void *fdt_dtb, *dtbo, *vpd;
    int rc;

#if (defined AVB_ENABLE_ANTIROLLBACK) || (defined AVB_ENABLE_DEVICE_STATE_CHANGE)
    rpmb_init();
#endif

    if (plat_fixup_init() != NO_ERROR)
        return;

    blxobj = blxboot_create();
    if (!blxobj)
        return;

    boot_mode = &(blxobj->bootcfg.boot_mode);
    *boot_mode = get_boot_mode();
    assert(*boot_mode <= FASTBOOT_BOOT);

    if (blxobj->ops.init) {
        rc = blxobj->ops.init();
        /*
         * if init fails, and boot mode is
         *   - fastboot mode: enter fastboot mode
         *   - non fastboot mode:
         *       . AB OTA updater enabled: reboot,
         *       . non AB OTA updater: enter fastboot mode
         */
        if (rc && (*boot_mode != FASTBOOT_BOOT)) {
            if (is_enabled_ab_ota_updater())
                platform_halt(HALT_ACTION_REBOOT, HALT_REASON_SW_RESET);
            else
                *boot_mode = FASTBOOT_BOOT;
        }
    }

#if defined(AB_OTA_UPDATER)
    plat_check_update_anti_rollback_bl_ver();
#endif

    blxobj->bootcfg.ab_suffix = get_suffix();
    if (blxobj->bootcfg.ab_suffix != NULL)
        update_image_partition_name(blxobj->bootcfg.ab_suffix);

    if (is_enabled_ab_ota_updater())
        fastboot_on_fail = false;
    else
        fastboot_on_fail = true; /* enter fastboot mode if load fail */

    do {
        if (*boot_mode == FASTBOOT_BOOT) {
            ext_boot();
            fastboot_on_fail = false;
        }

        if ((rc = load_all_images(blxobj)) == 0)
            break;

        if (fastboot_on_fail)
            *boot_mode = FASTBOOT_BOOT;
    } while (fastboot_on_fail);

    if (rc != 0) {
        if (is_enabled_ab_ota_updater())
            platform_halt(HALT_ACTION_REBOOT, HALT_REASON_SW_RESET);

        return;
    }

    /* dtbo may contains kernel bootargs, do overlay_fdt before fixup_image */
    blxobj->ops.get_overlay_image(blxobj, &fdt_dtb, &dtbo, &vpd);
    if (fdt_dtb && (dtbo || vpd)) {
        rc = overlay_fdt(fdt_dtb, dtbo, vpd);
        if (rc) {
            LTRACEF_LEVEL(CRITICAL, "dtbo overlay failed\n");
            return;
        }
    }

    if (blxobj->ops.fixup_image)
        blxobj->ops.fixup_image(blxobj, fdt_dtb);

    plat_fixup_hook(*boot_mode, blxobj->bootcfg.ab_suffix,
                    fdt_dtb, MAX_DTB_SIZE);

    if (blxobj->ops.setup_boot_param) {
        blxobj->ops.setup_boot_param(blxobj, &bprm);
    }

    dprintf(ALWAYS, "LK run time: %lld (us)\n", current_time_hires());
    dprintf(ALWAYS, "jump to next ep %p, arg (0x%lx)\n",
            (void *)bprm.arg1, bprm.arg2);

    arch_chain_load((void *)blxobj->ops.exit,
                    bprm.arg0, bprm.arg1, bprm.arg2, bprm.arg3);
}

APP_START(blxboot)
.entry = blxboot_task,
 .flags = 0,
  APP_END