summaryrefslogtreecommitdiff
path: root/lib/avb/fsl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/avb/fsl')
-rw-r--r--lib/avb/fsl/Makefile5
-rw-r--r--lib/avb/fsl/debug.h35
-rw-r--r--lib/avb/fsl/fsl_avb.c414
-rw-r--r--lib/avb/fsl/fsl_avbkey.c717
-rw-r--r--lib/avb/fsl/fsl_avbkey.h44
-rw-r--r--lib/avb/fsl/fsl_bootctl.c176
-rw-r--r--lib/avb/fsl/utils.c51
-rw-r--r--lib/avb/fsl/utils.h25
8 files changed, 1467 insertions, 0 deletions
diff --git a/lib/avb/fsl/Makefile b/lib/avb/fsl/Makefile
new file mode 100644
index 0000000..6218fab
--- /dev/null
+++ b/lib/avb/fsl/Makefile
@@ -0,0 +1,5 @@
+ccflags-$(CONFIG_AVB_DEBUG) += -DAVB_DEBUG
+obj-y += fsl_avb.o
+obj-y += fsl_avbkey.o
+obj-y += fsl_bootctl.o
+obj-y += utils.o
diff --git a/lib/avb/fsl/debug.h b/lib/avb/fsl/debug.h
new file mode 100644
index 0000000..c1165ec
--- /dev/null
+++ b/lib/avb/fsl/debug.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#ifndef __AVB_DEBUG_H__
+#define __AVB_DEBUG_H__
+
+#ifdef AVB_VVDEBUG
+#define AVB_VDEBUG
+#define VVDEBUG(format, ...) printf(" %s: "format, __func__, ##__VA_ARGS__)
+#else
+#define VVDEBUG(format, ...)
+#endif
+
+#ifdef AVB_VDEBUG
+#define AVB_DEBUG
+#define VDEBUG(format, ...) printf(" %s: "format, __func__, ##__VA_ARGS__)
+#else
+#define VDEBUG(format, ...)
+#endif
+
+#ifdef AVB_DEBUG
+#define DEBUGAVB(format, ...) printf(" %s: "format, __func__, ##__VA_ARGS__)
+#else
+#define DEBUGAVB(format, ...)
+#endif
+
+#define ERR(format, ...) printf("%s: "format, __func__, ##__VA_ARGS__)
+
+#define HEXDUMP_COLS 16
+#define HEXDUMP_WIDTH 1
+
+#endif
diff --git a/lib/avb/fsl/fsl_avb.c b/lib/avb/fsl/fsl_avb.c
new file mode 100644
index 0000000..d4c4d72
--- /dev/null
+++ b/lib/avb/fsl/fsl_avb.c
@@ -0,0 +1,414 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include <common.h>
+#include <part.h>
+#include <stdlib.h>
+
+#include <fsl_fastboot.h>
+#include <fsl_caam.h>
+#include "../../../drivers/usb/gadget/fastboot_lock_unlock.h"
+
+#include <fsl_avb.h>
+#include "fsl_avbkey.h"
+#include "utils.h"
+#include "debug.h"
+
+#define FSL_AVB_DEV "mmc"
+
+
+static struct blk_desc *fs_dev_desc = NULL;
+static struct blk_desc *get_mmc_desc(void) {
+ extern int mmc_get_env_dev(void);
+ int dev_no = mmc_get_env_dev();
+ return blk_get_dev(FSL_AVB_DEV, dev_no);
+}
+
+ /* Reads |num_bytes| from offset |offset| from partition with name
+ * |partition| (NUL-terminated UTF-8 string). If |offset| is
+ * negative, its absolute value should be interpreted as the number
+ * of bytes from the end of the partition.
+ *
+ * This function returns AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION if
+ * there is no partition with the given name,
+ * AVB_IO_RESULT_ERROR_RANGE_OUTSIDE_PARTITION if the requested
+ * |offset| is outside the partition, and AVB_IO_RESULT_ERROR_IO if
+ * there was an I/O error from the underlying I/O subsystem. If the
+ * operation succeeds as requested AVB_IO_RESULT_OK is returned and
+ * the data is available in |buffer|.
+ *
+ * The only time partial I/O may occur is if reading beyond the end
+ * of the partition. In this case the value returned in
+ * |out_num_read| may be smaller than |num_bytes|.
+ */
+ AvbIOResult fsl_read_from_partition(AvbOps* ops, const char* partition,
+ int64_t offset, size_t num_bytes,
+ void* buffer, size_t* out_num_read)
+{
+ struct fastboot_ptentry *pte;
+ unsigned char *bdata;
+ unsigned char *out_buf = (unsigned char *)buffer;
+ unsigned long blksz;
+ unsigned long s, cnt;
+ size_t num_read = 0;
+ lbaint_t part_start, part_end, bs, be;
+ margin_pos_t margin;
+
+ AvbIOResult ret;
+
+ DEBUGAVB("[%s]: offset=%ld, num_bytes=%zu\n", partition, (long)offset, num_bytes);
+
+ assert(buffer != NULL && out_num_read != NULL);
+
+ if (!fs_dev_desc && (fs_dev_desc = get_mmc_desc()) == NULL) {
+ ERR("mmc device not found\n");
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+
+ pte = fastboot_flash_find_ptn(partition);
+ if (!pte) {
+ ERR("no %s partition\n", partition);
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+
+ blksz = fs_dev_desc->blksz;
+ part_start = pte->start;
+ part_end = pte->start + pte->length - 1;
+ VDEBUG("blksz: %ld, part_end: %ld, part_start: %ld:\n",
+ blksz, part_end, part_start);
+
+ if(get_margin_pos((uint64_t)part_start, (uint64_t)part_end, blksz,
+ &margin, offset, num_bytes, true))
+ return AVB_IO_RESULT_ERROR_RANGE_OUTSIDE_PARTITION;
+
+ bs = (lbaint_t)margin.blk_start;
+ be = (lbaint_t)margin.blk_end;
+ s = margin.start;
+
+ // alloc a blksz mem
+ bdata = (unsigned char *)memalign(ALIGN_BYTES, blksz);
+ if (bdata == NULL)
+ return AVB_IO_RESULT_ERROR_OOM;
+
+ // one block a time
+ while (bs <= be) {
+ memset(bdata, 0, blksz);
+ if (!fs_dev_desc->block_read(fs_dev_desc, bs, 1, bdata)) {
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+ cnt = blksz - s;
+ if (num_read + cnt > num_bytes)
+ cnt = num_bytes - num_read;
+ VDEBUG("cur: bs=%ld, start=%ld, cnt=%ld bdata=0x%08x\n",
+ bs, s, cnt, bdata);
+ memcpy(out_buf, bdata + s, cnt);
+ bs++;
+ num_read += cnt;
+ out_buf += cnt;
+ s = 0;
+ }
+ *out_num_read = num_read;
+ ret = AVB_IO_RESULT_OK;
+#ifdef AVB_VVDEBUG
+ printf("\nnum_read=%zu", num_read);
+ printf("\n----dump---\n");
+ print_buffer(0, buffer, HEXDUMP_WIDTH, num_read, 0);
+ printf("--- end ---\n");
+#endif
+
+fail:
+ free(bdata);
+ return ret;
+}
+
+/* multi block read version of read_from_partition */
+ AvbIOResult fsl_read_from_partition_multi(AvbOps* ops, const char* partition,
+ int64_t offset, size_t num_bytes,
+ void* buffer, size_t* out_num_read)
+{
+ struct fastboot_ptentry *pte;
+ unsigned char *bdata;
+ unsigned char *out_buf = (unsigned char *)buffer;
+ unsigned char *dst, *dst64 = NULL;
+ unsigned long blksz;
+ unsigned long s, cnt;
+ size_t num_read = 0;
+ lbaint_t part_start, part_end, bs, be, bm, blk_num;
+ margin_pos_t margin;
+
+ AvbIOResult ret;
+
+ DEBUGAVB("[%s]: offset=%ld, num_bytes=%zu\n", partition, (long)offset, num_bytes);
+
+ assert(buffer != NULL && out_num_read != NULL);
+
+ if (!fs_dev_desc && (fs_dev_desc = get_mmc_desc()) == NULL) {
+ ERR("mmc device not found\n");
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+
+ pte = fastboot_flash_find_ptn(partition);
+ if (!pte) {
+ ERR("no %s partition\n", partition);
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+
+ blksz = fs_dev_desc->blksz;
+ part_start = pte->start;
+ part_end = pte->start + pte->length - 1;
+ VDEBUG("blksz: %ld, part_end: %ld, part_start: %ld:\n",
+ blksz, part_end, part_start);
+
+ if(get_margin_pos((uint64_t)part_start, (uint64_t)part_end, blksz,
+ &margin, offset, num_bytes, true))
+ return AVB_IO_RESULT_ERROR_RANGE_OUTSIDE_PARTITION;
+
+ bs = (lbaint_t)margin.blk_start;
+ be = (lbaint_t)margin.blk_end;
+ s = margin.start;
+ bm = margin.multi;
+
+ // alloc a blksz mem
+ bdata = (unsigned char *)memalign(ALIGN_BYTES, blksz);
+ if (bdata == NULL)
+ return AVB_IO_RESULT_ERROR_OOM;
+
+ // support multi blk read
+ while (bs <= be) {
+ if (!s && bm > 1) {
+ dst = out_buf;
+ dst64 = PTR_ALIGN(out_buf, 64); //for mmc blk read alignment
+ VDEBUG("cur: dst=0x%08x, dst64=0x%08x\n", dst, dst64);
+ if (dst64 != dst) {
+ dst = dst64;
+ bm--;
+ }
+ blk_num = bm;
+ cnt = bm * blksz;
+ bm = 0; //no more multi blk
+ } else {
+ blk_num = 1;
+ cnt = blksz - s;
+ if (num_read + cnt > num_bytes)
+ cnt = num_bytes - num_read;
+ dst = bdata;
+ }
+ VDEBUG("cur: bs=%ld, num=%ld, start=%ld, cnt=%ld dst=0x%08x\n",
+ bs, blk_num, s, cnt, dst);
+ if (!fs_dev_desc->block_read(fs_dev_desc, bs, blk_num, dst)) {
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+
+ if (dst == bdata)
+ memcpy(out_buf, bdata + s, cnt);
+ else if (dst == dst64)
+ memcpy(out_buf, dst, cnt); //internal copy
+
+ s = 0;
+ bs += blk_num;
+ num_read += cnt;
+ out_buf += cnt;
+#ifdef AVB_VVDEBUG
+ printf("\nnum_read=%ld", cnt);
+ printf("\n----dump---\n");
+ print_buffer(0, buffer, HEXDUMP_WIDTH, cnt, 0);
+ printf("--- end ---\n");
+#endif
+ }
+ *out_num_read = num_read;
+ ret = AVB_IO_RESULT_OK;
+#ifdef AVB_VVDEBUG
+ printf("\nnum_read=%zu", num_read);
+ printf("\n----dump---\n");
+ print_buffer(0, buffer, HEXDUMP_WIDTH, num_read, 0);
+ printf("--- end ---\n");
+#endif
+
+fail:
+ free(bdata);
+ return ret;
+}
+
+ /* Writes |num_bytes| from |bffer| at offset |offset| to partition
+ * with name |partition| (NUL-terminated UTF-8 string). If |offset|
+ * is negative, its absolute value should be interpreted as the
+ * number of bytes from the end of the partition.
+ *
+ * This function returns AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION if
+ * there is no partition with the given name,
+ * AVB_IO_RESULT_ERROR_RANGE_OUTSIDE_PARTITION if the requested
+ * byterange goes outside the partition, and AVB_IO_RESULT_ERROR_IO
+ * if there was an I/O error from the underlying I/O subsystem. If
+ * the operation succeeds as requested AVB_IO_RESULT_OK is
+ * returned.
+ *
+ * This function never does any partial I/O, it either transfers all
+ * of the requested bytes or returns an error.
+ */
+ AvbIOResult fsl_write_to_partition(AvbOps* ops, const char* partition,
+ int64_t offset, size_t num_bytes,
+ const void* buffer)
+{
+ struct fastboot_ptentry *pte;
+ unsigned char *bdata;
+ unsigned char *in_buf = (unsigned char *)buffer;
+ unsigned long blksz;
+ unsigned long s, cnt;
+ size_t num_write = 0;
+ lbaint_t part_start, part_end, bs;
+ margin_pos_t margin;
+
+ AvbIOResult ret;
+
+ DEBUGAVB("[%s]: offset=%ld, num_bytes=%zu\n", partition, (long)offset, num_bytes);
+
+ assert(buffer != NULL);
+
+ if (!fs_dev_desc && (fs_dev_desc = get_mmc_desc()) == NULL) {
+ ERR("mmc device not found\n");
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+
+ pte = fastboot_flash_find_ptn(partition);
+ if (!pte) {
+ ERR("no %s partition\n", partition);
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+
+ blksz = fs_dev_desc->blksz;
+ part_start = pte->start;
+ part_end = pte->start + pte->length - 1;
+ VDEBUG("blksz: %ld, part_end: %ld, part_start: %ld:\n",
+ blksz, part_end, part_start);
+
+ if(get_margin_pos((uint64_t)part_start, (uint64_t)part_end, blksz,
+ &margin, offset, num_bytes, false))
+ return AVB_IO_RESULT_ERROR_RANGE_OUTSIDE_PARTITION;
+
+ bs = (lbaint_t)margin.blk_start;
+ s = margin.start;
+
+ // alloc a blksz mem
+ bdata = (unsigned char *)memalign(ALIGN_BYTES, blksz);
+ if (bdata == NULL)
+ return AVB_IO_RESULT_ERROR_OOM;
+
+ while (num_write < num_bytes) {
+ memset(bdata, 0, blksz);
+ cnt = blksz - s;
+ if (num_write + cnt > num_bytes)
+ cnt = num_bytes - num_write;
+ if (!s || cnt != blksz) { //read blk first
+ if (!fs_dev_desc->block_read(fs_dev_desc, bs, 1, bdata)) {
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+ }
+ memcpy(bdata + s, in_buf, cnt); //change data
+ VDEBUG("cur: bs=%ld, start=%ld, cnt=%ld bdata=0x%08x\n",
+ bs, s, cnt, bdata);
+ if (!fs_dev_desc->block_write(fs_dev_desc, bs, 1, bdata)) {
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+ bs++;
+ num_write += cnt;
+ in_buf += cnt;
+ if (s != 0)
+ s = 0;
+ }
+ ret = AVB_IO_RESULT_OK;
+
+fail:
+ free(bdata);
+ return ret;
+}
+
+/* Reads A/B metadata from persistent storage. Returned data is
+ * properly byteswapped. Returns AVB_IO_RESULT_OK on success, error
+ * code otherwise.
+ *
+ * If the data read is invalid (e.g. wrong magic or CRC checksum
+ * failure), the metadata shoule be reset using avb_ab_data_init()
+ * and then written to persistent storage.
+ *
+ * Implementations will typically want to use avb_ab_data_read()
+ * here to use the 'misc' partition for persistent storage.
+ */
+AvbIOResult fsl_read_ab_metadata(AvbABOps* ab_ops, struct AvbABData* data)
+{
+ return avb_ab_data_read(ab_ops, data);
+}
+
+/* Writes A/B metadata to persistent storage. This will byteswap and
+ * update the CRC as needed. Returns AVB_IO_RESULT_OK on success,
+ * error code otherwise.
+ *
+ * Implementations will typically want to use avb_ab_data_write()
+ * here to use the 'misc' partition for persistent storage.
+ */
+AvbIOResult fsl_write_ab_metadata(AvbABOps* ab_ops, const struct AvbABData* data)
+{
+ return avb_ab_data_write(ab_ops, data);
+}
+
+/* Gets whether the device is unlocked. The value is returned in
+ * |out_is_unlocked| (true if unlocked, false otherwise). Returns
+ * AVB_IO_RESULT_OK if the state was retrieved, otherwise an error
+ * code.
+ */
+AvbIOResult fsl_read_is_device_unlocked(AvbOps* ops, bool* out_is_unlocked) {
+
+ FbLockState status;
+
+ assert(out_is_unlocked != NULL);
+ *out_is_unlocked = false;
+
+ status = fastboot_get_lock_stat();
+ if (status != FASTBOOT_LOCK_ERROR) {
+ if (status == FASTBOOT_LOCK)
+ *out_is_unlocked = false;
+ else
+ *out_is_unlocked = true;
+ } else
+ return AVB_IO_RESULT_ERROR_IO;
+
+ DEBUGAVB("is_unlocked=%d\n", *out_is_unlocked);
+ return AVB_IO_RESULT_OK;
+}
+
+/* Gets the unique partition GUID for a partition with name in
+ * |partition| (NUL-terminated UTF-8 string). The GUID is copied as
+ * a string into |guid_buf| of size |guid_buf_size| and will be NUL
+ * terminated. The string must be lower-case and properly
+ * hyphenated. For example:
+ *
+ * 527c1c6d-6361-4593-8842-3c78fcd39219
+ *
+ * Returns AVB_IO_RESULT_OK on success, otherwise an error code.
+ */
+AvbIOResult fsl_get_unique_guid_for_partition(AvbOps* ops,
+ const char* partition,
+ char* guid_buf,
+ size_t guid_buf_size) {
+ assert(guid_buf != NULL);
+#ifdef CONFIG_PARTITION_UUIDS
+ struct fastboot_ptentry *pte;
+ pte = fastboot_flash_find_ptn(partition);
+ if (!pte) {
+ ERR("no %s partition\n", partition);
+ return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
+ }
+ strncpy(guid_buf, (const char *)pte->uuid, guid_buf_size);
+ guid_buf[guid_buf_size - 1] = '\0';
+ DEBUGAVB("[%s]: GUID=%s\n", partition, guid_buf);
+ return AVB_IO_RESULT_OK;
+#else
+ return AVB_IO_RESULT_ERROR_IO;
+#endif
+}
diff --git a/lib/avb/fsl/fsl_avbkey.c b/lib/avb/fsl/fsl_avbkey.c
new file mode 100644
index 0000000..9f2f11a
--- /dev/null
+++ b/lib/avb/fsl/fsl_avbkey.c
@@ -0,0 +1,717 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include <common.h>
+#include <stdlib.h>
+#include <fsl_caam.h>
+#include <fuse.h>
+#include <mmc.h>
+
+#include <fsl_avb.h>
+#include "fsl_avbkey.h"
+#include "utils.h"
+#include "debug.h"
+
+#define INITFLAG_FUSE_OFFSET 0
+#define INITFLAG_FUSE_MASK 0x00000001
+#define INITFLAG_FUSE 0x00000001
+
+#define RPMB_BLKSZ 256
+#define RPMBKEY_FUSE_OFFSET 1
+#define RPMBKEY_LENGTH 32
+#define RPMBKEY_FUSE_LEN ((RPMBKEY_LENGTH) + (CAAM_PAD))
+#define RPMBKEY_FUSE_LENW (RPMBKEY_FUSE_LEN / 4)
+
+static int mmc_dev_no = -1;
+
+static struct mmc *get_mmc(void) {
+ extern int mmc_get_env_devno(void);
+ struct mmc *mmc;
+ if (mmc_dev_no < 0 && (mmc_dev_no = mmc_get_env_dev()) < 0)
+ return NULL;
+ mmc = find_mmc_device(mmc_dev_no);
+ if (!mmc || mmc_init(mmc))
+ return NULL;
+ return mmc;
+}
+
+static int fsl_fuse_ops(uint32_t *buffer, uint32_t length, uint32_t offset,
+ const uint8_t read) {
+
+ unsigned short bs, ws, bksz, cnt;
+ unsigned short num_done = 0;
+ margin_pos_t margin;
+ int i;
+
+ /* read from fuse */
+ bksz = CONFIG_AVB_FUSE_BANK_SIZEW;
+ if(get_margin_pos(CONFIG_AVB_FUSE_BANK_START, CONFIG_AVB_FUSE_BANK_END, bksz,
+ &margin, offset, length, false))
+ return -1;
+ bs = (unsigned short)margin.blk_start;
+ ws = (unsigned short)margin.start;
+
+ while (num_done < length) {
+ cnt = bksz - ws;
+ if (num_done + cnt > length)
+ cnt = length - num_done;
+ for (i = 0; i < cnt; i++) {
+ VDEBUG("cur: bank=%d, word=%d\n",bs, ws);
+ if (read) {
+#ifdef CONFIG_AVB_FUSE
+ if (fuse_sense(bs, ws, buffer)) {
+#else
+ if (fuse_read(bs, ws, buffer)) {
+#endif
+ ERR("read fuse bank %d, word %d error\n", bs, ws);
+ return -1;
+ }
+ } else {
+#ifdef CONFIG_AVB_FUSE
+ if (fuse_prog(bs, ws, *buffer)) {
+#else
+ if (fuse_override(bs, ws, *buffer)) {
+#endif
+ ERR("write fuse bank %d, word %d error\n", bs, ws);
+ return -1;
+ }
+ }
+ ws++;
+ buffer++;
+ }
+ bs++;
+ num_done += cnt;
+ ws = 0;
+ }
+ return 0;
+}
+
+static int fsl_fuse_read(uint32_t *buffer, uint32_t length, uint32_t offset) {
+
+ return fsl_fuse_ops(
+ buffer,
+ length,
+ offset,
+ 1
+ );
+}
+
+static int fsl_fuse_write(const uint32_t *buffer, uint32_t length, uint32_t offset) {
+
+ return fsl_fuse_ops(
+ (uint32_t *)buffer,
+ length,
+ offset,
+ 0
+ );
+}
+
+static int rpmb_key(struct mmc *mmc) {
+
+ char original_part;
+ uint8_t blob[RPMBKEY_FUSE_LEN];
+ uint8_t plain_key[RPMBKEY_LENGTH];
+
+ int ret;
+
+ DEBUGAVB("[rpmb]: set kley\n");
+
+ /* Switch to the RPMB partition */
+ original_part = mmc->block_dev.hwpart;
+ if (mmc->block_dev.hwpart != MMC_PART_RPMB) {
+ if (mmc_switch_part(mmc, MMC_PART_RPMB) != 0)
+ return -1;
+ mmc->block_dev.hwpart = MMC_PART_RPMB;
+ }
+
+ /* use caam hwrng to generate */
+ caam_open();
+ if (caam_hwrng(plain_key, RPMBKEY_LENGTH)) {
+ ERR("ERROR - caam rng\n");
+ ret = -1;
+ goto fail;
+ }
+
+ /* generate keyblob and program to fuse */
+ if (caam_gen_blob((uint32_t)plain_key, (uint32_t)blob, RPMBKEY_LENGTH)) {
+ ERR("gen rpmb key blb error\n");
+ ret = -1;
+ goto fail;
+ }
+
+ if (fsl_fuse_write((uint32_t *)blob, RPMBKEY_FUSE_LENW, RPMBKEY_FUSE_OFFSET)){
+ ERR("write rpmb key to fuse error\n");
+ ret = -1;
+ goto fail;
+ }
+
+#ifdef CONFIG_AVB_FUSE
+ /* program key to mmc */
+ if (mmc_rpmb_set_key(mmc, plain_key)) {
+ ERR("Key already programmed ?\n");
+ ret = -1;
+ goto fail;
+ }
+#endif
+ ret = 0;
+
+#ifdef CONFIG_AVB_DEBUG
+ /* debug */
+ uint8_t ext_key[RPMBKEY_LENGTH];
+ printf(" RPMB plain kay---\n");
+ print_buffer(0, plain_key, HEXDUMP_WIDTH, RPMBKEY_LENGTH, 0);
+ if (fsl_fuse_read((uint32_t *)blob, RPMBKEY_FUSE_LENW, RPMBKEY_FUSE_OFFSET)){
+ ERR("read rpmb key to fuse error\n");
+ ret = -1;
+ goto fail;
+ }
+ printf(" RPMB blob---\n");
+ print_buffer(0, blob, HEXDUMP_WIDTH, RPMBKEY_FUSE_LEN, 0);
+ if (caam_decap_blob((uint32_t)ext_key, (uint32_t)blob, RPMBKEY_LENGTH)) {
+ ret = -1;
+ goto fail;
+ }
+ printf(" RPMB extract---\n");
+ print_buffer(0, ext_key, HEXDUMP_WIDTH, RPMBKEY_LENGTH, 0);
+ /* debug done */
+#endif
+
+fail:
+ /* Return to original partition */
+ if (mmc->block_dev.hwpart != original_part) {
+ if (mmc_switch_part(mmc, original_part) != 0)
+ return -1;
+ mmc->block_dev.hwpart = original_part;
+ }
+ return ret;
+
+}
+
+static int rpmb_read(struct mmc *mmc, uint8_t *buffer, size_t num_bytes, int64_t offset) {
+
+ unsigned char *bdata = NULL;
+ unsigned char *out_buf = (unsigned char *)buffer;
+ unsigned long s, cnt;
+ unsigned long blksz;
+ size_t num_read = 0;
+ unsigned short part_start, part_length, part_end, bs, be;
+ margin_pos_t margin;
+ char original_part;
+ uint8_t extract_key[RPMBKEY_LENGTH];
+ uint8_t blob[RPMBKEY_FUSE_LEN];
+
+ int ret;
+
+ blksz = RPMB_BLKSZ;
+ part_length = mmc->capacity_rpmb >> 8;
+ part_start = 0;
+ part_end = part_start + part_length - 1;
+
+ DEBUGAVB("[rpmb]: offset=%ld, num_bytes=%zu\n", (long)offset, num_bytes);
+
+ if(get_margin_pos(part_start, part_end, blksz,
+ &margin, offset, num_bytes, false))
+ return -1;
+
+ bs = (unsigned short)margin.blk_start;
+ be = (unsigned short)margin.blk_end;
+ s = margin.start;
+
+ /* Switch to the RPMB partition */
+ original_part = mmc->block_dev.hwpart;
+ if (mmc->block_dev.hwpart != MMC_PART_RPMB) {
+ if (mmc_switch_part(mmc, MMC_PART_RPMB) != 0)
+ return -1;
+ mmc->block_dev.hwpart = MMC_PART_RPMB;
+ }
+
+ /* get rpmb key */
+ if (fsl_fuse_read((uint32_t *)blob, RPMBKEY_FUSE_LENW, RPMBKEY_FUSE_OFFSET)){
+ ERR("read rpmb key error\n");
+ ret = -1;
+ goto fail;
+ }
+ caam_open();
+ if (caam_decap_blob((uint32_t)extract_key, (uint32_t)blob, RPMBKEY_LENGTH)) {
+ ERR("decap rpmb key error\n");
+ ret = -1;
+ goto fail;
+ }
+
+ // alloc a blksz mem
+ bdata = (unsigned char *)memalign(ALIGN_BYTES, blksz);
+ if (bdata == NULL) {
+ ret = -1;
+ goto fail;
+ }
+ // one block a time
+ while (bs <= be) {
+ memset(bdata, 0, blksz);
+ if (mmc_rpmb_read(mmc, bdata, bs, 1, extract_key) != 1) {
+ ret = -1;
+ goto fail;
+ }
+ cnt = blksz - s;
+ if (num_read + cnt > num_bytes)
+ cnt = num_bytes - num_read;
+ VDEBUG("cur: bs=%d, start=%ld, cnt=%ld bdata=0x%p\n",
+ bs, s, cnt, bdata);
+ memcpy(out_buf, bdata + s, cnt);
+ bs++;
+ num_read += cnt;
+ out_buf += cnt;
+ s = 0;
+ }
+ ret = 0;
+
+fail:
+ /* Return to original partition */
+ if (mmc->block_dev.hwpart != original_part) {
+ if (mmc_switch_part(mmc, original_part) != 0)
+ return -1;
+ mmc->block_dev.hwpart = original_part;
+ }
+ if (bdata != NULL)
+ free(bdata);
+ return ret;
+
+}
+static int rpmb_write(struct mmc *mmc, uint8_t *buffer, size_t num_bytes, int64_t offset) {
+
+ unsigned char *bdata = NULL;
+ unsigned char *in_buf = (unsigned char *)buffer;
+ unsigned long s, cnt;
+ unsigned long blksz;
+ size_t num_write = 0;
+ unsigned short part_start, part_length, part_end, bs;
+ margin_pos_t margin;
+ char original_part;
+ uint8_t extract_key[RPMBKEY_LENGTH];
+ uint8_t blob[RPMBKEY_FUSE_LEN];
+
+ int ret;
+
+ blksz = RPMB_BLKSZ;
+ part_length = mmc->capacity_rpmb >> 8;
+ part_start = 0;
+ part_end = part_start + part_length - 1;
+
+ DEBUGAVB("[rpmb]: offset=%ld, num_bytes=%zu\n", (long)offset, num_bytes);
+
+ if(get_margin_pos(part_start, part_end, blksz,
+ &margin, offset, num_bytes, false)) {
+ ERR("get_margin_pos err\n");
+ return -1;
+ }
+
+ bs = (unsigned short)margin.blk_start;
+ s = margin.start;
+
+ /* Switch to the RPMB partition */
+ original_part = mmc->block_dev.hwpart;
+ if (mmc->block_dev.hwpart != MMC_PART_RPMB) {
+ if (mmc_switch_part(mmc, MMC_PART_RPMB) != 0)
+ return -1;
+ mmc->block_dev.hwpart = MMC_PART_RPMB;
+ }
+
+ /* get rpmb key */
+ if (fsl_fuse_read((uint32_t *)blob, RPMBKEY_FUSE_LENW, RPMBKEY_FUSE_OFFSET)){
+ ERR("read rpmb key error\n");
+ ret = -1;
+ goto fail;
+ }
+ caam_open();
+ if (caam_decap_blob((uint32_t)extract_key, (uint32_t)blob, RPMBKEY_LENGTH)) {
+ ERR("decap rpmb key error\n");
+ ret = -1;
+ goto fail;
+ }
+
+ // alloc a blksz mem
+ bdata = (unsigned char *)memalign(ALIGN_BYTES, blksz);
+ if (bdata == NULL) {
+ ret = -1;
+ goto fail;
+ }
+ while (num_write < num_bytes) {
+ memset(bdata, 0, blksz);
+ cnt = blksz - s;
+ if (num_write + cnt > num_bytes)
+ cnt = num_bytes - num_write;
+ if (!s || cnt != blksz) { //read blk first
+ if (mmc_rpmb_read(mmc, bdata, bs, 1, extract_key) != 1) {
+ ERR("mmc_rpmb_read err, mmc= 0x%08x\n", (unsigned int)mmc);
+ ret = -1;
+ goto fail;
+ }
+ }
+ memcpy(bdata + s, in_buf, cnt); //change data
+ VDEBUG("cur: bs=%d, start=%ld, cnt=%ld\n", bs, s, cnt);
+ if (mmc_rpmb_write(mmc, bdata, bs, 1, extract_key) != 1) {
+ ret = -1;
+ goto fail;
+ }
+ bs++;
+ num_write += cnt;
+ in_buf += cnt;
+ if (s != 0)
+ s = 0;
+ }
+ ret = 0;
+
+fail:
+ /* Return to original partition */
+ if (mmc->block_dev.hwpart != original_part) {
+ if (mmc_switch_part(mmc, original_part) != 0)
+ return -1;
+ mmc->block_dev.hwpart = original_part;
+ }
+ if (bdata != NULL)
+ free(bdata);
+ return ret;
+
+}
+
+int rbkidx_erase(void) {
+ int i;
+ kblb_hdr_t hdr;
+ kblb_tag_t *tag;
+ struct mmc *mmc_dev;
+
+ if ((mmc_dev = get_mmc()) == NULL) {
+ ERR("err get mmc device\n");
+ return -1;
+ }
+
+ /* read the kblb header */
+ if (rpmb_read(mmc_dev, (uint8_t *)&hdr, sizeof(hdr), 0) != 0) {
+ ERR("read RPMB error\n");
+ return -1;
+ }
+ if (memcmp(hdr.magic, AVB_KBLB_MAGIC, AVB_KBLB_MAGIC_LEN) != 0) {
+ ERR("magic not match\n");
+ return -1;
+ }
+
+ /* reset rollback index */
+ uint32_t offset = AVB_RBIDX_START;
+ uint32_t rbidx_len = AVB_RBIDX_LEN;
+ uint8_t *rbidx = malloc(rbidx_len);
+ if (rbidx == NULL)
+ return -1;
+ memset(rbidx, 0, rbidx_len);
+ *(uint64_t *)rbidx = AVB_RBIDX_INITVAL;
+ for (i = 0; i < AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS; i++) {
+ tag = &hdr.rbk_tags[i];
+ tag->flag = AVB_RBIDX_FLAG;
+ tag->offset = offset;
+ tag->len = rbidx_len;
+ /* write */
+ if (rpmb_write(mmc_dev, rbidx, tag->len, tag->offset) != 0) {
+ ERR("write RBKIDX RPMB error\n");
+ free(rbidx);
+ return -1;
+ }
+ offset += AVB_RBIDX_ALIGN;
+ }
+ free(rbidx);
+ /* write back hdr */
+ if (rpmb_write(mmc_dev, (uint8_t *)&hdr, sizeof(hdr), 0) != 0) {
+ ERR("write RPMB hdr error\n");
+ return -1;
+ }
+ return 0;
+}
+
+
+int avbkey_init(uint8_t *plainkey, uint32_t keylen) {
+ int i;
+ kblb_hdr_t hdr;
+ kblb_tag_t *tag;
+ struct mmc *mmc_dev;
+ uint32_t init_flag;
+
+ /* int ret; */
+
+ assert(plainkey != NULL);
+
+ /* check overflow */
+ if (keylen > AVB_RBIDX_START - AVB_PUBKY_OFFSET) {
+ ERR("key len overflow\n");
+ return -1;
+ }
+
+ /* check init status */
+ if (fsl_fuse_read(&init_flag, 1, INITFLAG_FUSE_OFFSET)) {
+ ERR("ERROR - read fuse init flag error\n");
+ return -1;
+ }
+ if ((init_flag & INITFLAG_FUSE_MASK) == INITFLAG_FUSE) {
+ ERR("ERROR - already inited\n");
+ return -1;
+ }
+ init_flag = INITFLAG_FUSE & INITFLAG_FUSE_MASK;
+
+ /* generate and write key to mmc/fuse */
+ if ((mmc_dev = get_mmc()) == NULL) {
+ ERR("ERROR - get mmc device\n");
+ return -1;
+ }
+ if (rpmb_key(mmc_dev)) {
+ ERR("ERROR - write mmc rpmb key\n");
+ return -1;
+ }
+
+ if (fsl_fuse_write(&init_flag, 1, INITFLAG_FUSE_OFFSET)){
+ ERR("write fuse init error\n");
+ return -1;
+ }
+
+ /* init pubkey */
+ tag = &hdr.pubk_tag;
+ tag->flag = AVB_PUBKY_FLAG;
+ tag->offset = AVB_PUBKY_OFFSET;
+ tag->len = keylen;
+
+ if (rpmb_write(mmc_dev, plainkey, tag->len, tag->offset) != 0) {
+ ERR("write RPMB error\n");
+ return -1;
+ }
+
+ /* init rollback index */
+ uint32_t offset = AVB_RBIDX_START;
+ uint32_t rbidx_len = AVB_RBIDX_LEN;
+ uint8_t *rbidx = malloc(rbidx_len);
+ if (rbidx == NULL)
+ return -1;
+ memset(rbidx, 0, rbidx_len);
+ *(uint64_t *)rbidx = AVB_RBIDX_INITVAL;
+ for (i = 0; i < AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS; i++) {
+ tag = &hdr.rbk_tags[i];
+ tag->flag = AVB_RBIDX_FLAG;
+ tag->offset = offset;
+ tag->len = rbidx_len;
+ if (rpmb_write(mmc_dev, rbidx, tag->len, tag->offset) != 0) {
+ ERR("write RBKIDX RPMB error\n");
+ free(rbidx);
+ return -1;
+ }
+ offset += AVB_RBIDX_ALIGN;
+ }
+ free(rbidx);
+
+ /* init hdr */
+ memcpy(hdr.magic, AVB_KBLB_MAGIC, AVB_KBLB_MAGIC_LEN);
+ if (rpmb_write(mmc_dev, (uint8_t *)&hdr, sizeof(hdr), 0) != 0) {
+ ERR("write RPMB hdr error\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+/* Checks if the given public key used to sign the 'vbmeta'
+ * partition is trusted. Boot loaders typically compare this with
+ * embedded key material generated with 'avbtool
+ * extract_public_key'.
+ *
+ * If AVB_IO_RESULT_OK is returned then |out_is_trusted| is set -
+ * true if trusted or false if untrusted.
+ */
+AvbIOResult fsl_validate_vbmeta_public_key_rpmb(AvbOps* ops,
+ const uint8_t* public_key_data,
+ size_t public_key_length,
+ const uint8_t* public_key_metadata,
+ size_t public_key_metadata_length,
+ bool* out_is_trusted) {
+ kblb_hdr_t hdr;
+ kblb_tag_t *pubk;
+ uint8_t *extract_key = NULL;
+ struct mmc *mmc_dev;
+ AvbIOResult ret;
+
+ assert(ops != NULL && out_is_trusted != NULL);
+ *out_is_trusted = false;
+
+ if ((mmc_dev = get_mmc()) == NULL) {
+ ERR("err get mmc device\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+ /* read the kblb header */
+ if (rpmb_read(mmc_dev, (uint8_t *)&hdr, sizeof(hdr), 0) != 0) {
+ ERR("read RPMB error\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+
+ if (memcmp(hdr.magic, AVB_KBLB_MAGIC, AVB_KBLB_MAGIC_LEN) != 0) {
+ ERR("magic not match\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+
+ /* read public key */
+ pubk = &hdr.pubk_tag;
+ if (pubk->len != public_key_length){
+ ERR("avbkey len not match\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+ extract_key = malloc(pubk->len);
+ if (extract_key == NULL)
+ return AVB_IO_RESULT_ERROR_OOM;
+
+ if (rpmb_read(mmc_dev, extract_key, pubk->len, pubk->offset) != 0) {
+ ERR("read public keyblob error\n");
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+
+ /* match given public key */
+ if (memcmp(extract_key, public_key_data, public_key_length)) {
+ ret = AVB_IO_RESULT_OK;
+ goto fail;
+ }
+#ifdef AVB_VDEBUG
+ printf("\n----key dump: stored---\n");
+ print_buffer(0, extract_key, HEXDUMP_WIDTH, pubk->len, 0);
+ printf("\n----key dump: vbmeta---\n");
+ print_buffer(0, public_key_data, HEXDUMP_WIDTH, public_key_length, 0);
+ printf("--- end ---\n");
+#endif
+
+ *out_is_trusted = true;
+ ret = AVB_IO_RESULT_OK;
+fail:
+ if (extract_key != NULL)
+ free(extract_key);
+ return ret;
+}
+
+/* Gets the rollback index corresponding to the slot given by
+ * |rollback_index_slot|. The value is returned in
+ * |out_rollback_index|. Returns AVB_IO_RESULT_OK if the rollback
+ * index was retrieved, otherwise an error code.
+ *
+ * A device may have a limited amount of rollback index slots (say,
+ * one or four) so may error out if |rollback_index_slot| exceeds
+ * this number.
+ */
+AvbIOResult fsl_read_rollback_index_rpmb(AvbOps* ops, size_t rollback_index_slot,
+ uint64_t* out_rollback_index) {
+ kblb_hdr_t hdr;
+ kblb_tag_t *rbk;
+ uint64_t *extract_idx = NULL;
+ struct mmc *mmc_dev;
+ AvbIOResult ret;
+
+ assert(ops != NULL && out_rollback_index != NULL);
+ *out_rollback_index = ~0;
+
+ DEBUGAVB("[rpmb] read rollback slot: %zu\n", rollback_index_slot);
+
+ if (rollback_index_slot >= AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS)
+ return AVB_IO_RESULT_ERROR_IO;
+
+ if ((mmc_dev = get_mmc()) == NULL) {
+ ERR("err get mmc device\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+ /* read the kblb header */
+ if (rpmb_read(mmc_dev, (uint8_t *)&hdr, sizeof(hdr), 0) != 0) {
+ ERR("read RPMB error\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+
+ if (memcmp(hdr.magic, AVB_KBLB_MAGIC, AVB_KBLB_MAGIC_LEN) != 0) {
+ ERR("magic not match\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+
+ rbk = &hdr.rbk_tags[rollback_index_slot];
+ extract_idx = malloc(rbk->len);
+ if (extract_idx == NULL)
+ return AVB_IO_RESULT_ERROR_OOM;
+
+ /* read rollback_index keyblob */
+ if (rpmb_read(mmc_dev, (uint8_t *)extract_idx, rbk->len, rbk->offset) != 0) {
+ ERR("read rollback index error\n");
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+
+#ifdef AVB_VVDEBUG
+ printf("\n----idx dump: ---\n");
+ print_buffer(0, extract_idx, HEXDUMP_WIDTH, rbk->len, 0);
+ printf("--- end ---\n");
+#endif
+
+ *out_rollback_index = *extract_idx;
+ DEBUGAVB("rollback_index = %" PRIu64 "\n", *out_rollback_index);
+ ret = AVB_IO_RESULT_OK;
+fail:
+ if (extract_idx != NULL)
+ free(extract_idx);
+ return ret;
+}
+
+/* Sets the rollback index corresponding to the slot given by
+ * |rollback_index_slot| to |rollback_index|. Returns
+ * AVB_IO_RESULT_OK if the rollback index was set, otherwise an
+ * error code.
+ *
+ * A device may have a limited amount of rollback index slots (say,
+ * one or four) so may error out if |rollback_index_slot| exceeds
+ * this number.
+ */
+AvbIOResult fsl_write_rollback_index_rpmb(AvbOps* ops, size_t rollback_index_slot,
+ uint64_t rollback_index) {
+ kblb_hdr_t hdr;
+ kblb_tag_t *rbk;
+ uint64_t *plain_idx = NULL;
+ struct mmc *mmc_dev;
+ AvbIOResult ret;
+
+ DEBUGAVB("[rpmb] write to rollback slot: (%zu, %" PRIu64 ")\n",
+ rollback_index_slot, rollback_index);
+
+ assert(ops != NULL);
+
+ if (rollback_index_slot >= AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS)
+ return AVB_IO_RESULT_ERROR_IO;
+
+ if ((mmc_dev = get_mmc()) == NULL) {
+ ERR("err get mmc device\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+ /* read the kblb header */
+ if (rpmb_read(mmc_dev, (uint8_t *)&hdr, sizeof(hdr), 0) != 0) {
+ ERR("read RPMB error\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+
+ if (memcmp(hdr.magic, AVB_KBLB_MAGIC, AVB_KBLB_MAGIC_LEN) != 0) {
+ ERR("magic not match\n");
+ return AVB_IO_RESULT_ERROR_IO;
+ }
+
+ rbk = &hdr.rbk_tags[rollback_index_slot];
+ plain_idx = malloc(rbk->len);
+ if (plain_idx == NULL)
+ return AVB_IO_RESULT_ERROR_OOM;
+ memset(plain_idx, 0, rbk->len);
+ *plain_idx = rollback_index;
+
+ /* write rollback_index keyblob */
+ if (rpmb_write(mmc_dev, (uint8_t *)plain_idx, rbk->len, rbk->offset) != 0) {
+ ERR("write rollback index error\n");
+ ret = AVB_IO_RESULT_ERROR_IO;
+ goto fail;
+ }
+ ret = AVB_IO_RESULT_OK;
+fail:
+ if (plain_idx != NULL)
+ free(plain_idx);
+ return ret;
+}
diff --git a/lib/avb/fsl/fsl_avbkey.h b/lib/avb/fsl/fsl_avbkey.h
new file mode 100644
index 0000000..b671f03
--- /dev/null
+++ b/lib/avb/fsl/fsl_avbkey.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#ifndef __FSL_AVBKEY_H__
+#define __FSL_AVBKEY_H__
+
+
+#define CAAM_PAD 48
+
+#define AVB_PUBKY_FLAG 0xABAB
+#define AVB_PUBKY_OFFSET 0x1000
+
+#define AVB_RBIDX_FLAG 0xCDCD
+#define AVB_RBIDX_START 0x2000
+#define AVB_RBIDX_ALIGN 0x1000
+#define AVB_RBIDX_LEN 0x08
+#define AVB_RBIDX_INITVAL 0
+
+
+#define AVB_KBLB_MAGIC "\0KBLB!"
+#define AVB_KBLB_MAGIC_LEN 6
+
+
+struct kblb_tag {
+ uint32_t flag;
+ uint32_t offset;
+ uint32_t len;
+};
+typedef struct kblb_tag kblb_tag_t;
+
+struct kblb_hdr {
+ /* avbkey partition magic */
+ char magic[AVB_KBLB_MAGIC_LEN];
+ /* public key keyblb tag */
+ kblb_tag_t pubk_tag;
+ /* rollback index keyblb tag */
+ kblb_tag_t rbk_tags[AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS];
+};
+typedef struct kblb_hdr kblb_hdr_t;
+
+#endif
diff --git a/lib/avb/fsl/fsl_bootctl.c b/lib/avb/fsl/fsl_bootctl.c
new file mode 100644
index 0000000..26ff7da
--- /dev/null
+++ b/lib/avb/fsl/fsl_bootctl.c
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include <common.h>
+#include <stdlib.h>
+#include <linux/string.h>
+
+#include <fsl_avb.h>
+
+/* as libavb's bootctl doesn't have the get_var support
+ * we add the getvar support on our side ...*/
+#define SLOT_NUM 2
+static char *slot_suffix[SLOT_NUM] = {"_a", "_b"};
+
+static int strcmp_l1(const char *s1, const char *s2) {
+ if (!s1 || !s2)
+ return -1;
+ return strncmp(s1, s2, strlen(s1));
+}
+
+static bool slot_is_bootable(AvbABSlotData* slot) {
+ return slot->priority > 0 &&
+ (slot->successful_boot || (slot->tries_remaining > 0));
+}
+
+int slotidx_from_suffix(char *suffix) {
+ int slot = -1;
+
+ if (!strcmp(suffix, "_a") ||
+ !strcmp(suffix, "a"))
+ slot = 0;
+ else if (!strcmp(suffix, "_b") ||
+ !strcmp(suffix, "b"))
+ slot = 1;
+
+ return slot;
+}
+
+bool is_slotvar_avb(char *cmd) {
+
+ assert(cmd != NULL);
+ if (!strcmp_l1("has-slot:", cmd) ||
+ !strcmp_l1("slot-successful:", cmd) ||
+ !strcmp_l1("slot-count", cmd) ||
+ !strcmp_l1("slot-suffixes", cmd) ||
+ !strcmp_l1("current-slot", cmd) ||
+ !strcmp_l1("slot-unbootable:", cmd) ||
+ !strcmp_l1("slot-retry-count:", cmd))
+ return true;
+ return false;
+}
+
+static int get_curr_slot(AvbABData *ab_data) {
+ if (slot_is_bootable(&ab_data->slots[0]) &&
+ slot_is_bootable(&ab_data->slots[1])) {
+ if (ab_data->slots[1].priority > ab_data->slots[0].priority)
+ return 1;
+ else
+ return 0;
+ } else if (slot_is_bootable(&ab_data->slots[0]))
+ return 0;
+ else if (slot_is_bootable(&ab_data->slots[1]))
+ return 1;
+ else
+ return -1;
+}
+
+int get_slotvar_avb(AvbABOps *ab_ops, char *cmd, char *buffer, size_t size) {
+
+ AvbABData ab_data;
+ AvbABSlotData *slot_data;
+ int slot;
+
+ assert(ab_ops != NULL && cmd != NULL && buffer != NULL);
+
+ char *str = cmd;
+ if (!strcmp_l1("has-slot:", cmd)) {
+ str += strlen("has-slot:");
+ if (!strcmp(str, "system") || !strcmp(str, "boot"))
+ strlcpy(buffer, "yes", size);
+ else
+ strlcpy(buffer, "no", size);
+ return 0;
+
+ } else if (!strcmp_l1("slot-suffixes", cmd)) {
+ strlcpy(buffer, "_a,_b", size);
+ return 0 ;
+
+ } else if (!strcmp_l1("slot-count", cmd)) {
+ strlcpy(buffer, "2", size);
+ return 0 ;
+ }
+
+ /* load ab meta */
+ if (ab_ops->read_ab_metadata == NULL ||
+ ab_ops->read_ab_metadata(ab_ops, &ab_data) != AVB_IO_RESULT_OK) {
+ strlcpy(buffer, "ab data read error", size);
+ return -1 ;
+ }
+
+ if (!strcmp_l1("current-slot", cmd)) {
+ int curr = get_curr_slot(&ab_data);
+ if (curr >= 0 && curr < SLOT_NUM)
+ strlcpy(buffer, slot_suffix[curr], size);
+ else {
+ strlcpy(buffer, "no bootable slot", size);
+ return -1;
+ }
+
+ } else if (!strcmp_l1("slot-successful:", cmd)) {
+ str += strlen("slot-successful:");
+ slot = slotidx_from_suffix(str);
+ if (slot < 0) {
+ strlcpy(buffer, "no such slot", size);
+ return -1;
+ } else {
+ slot_data = &ab_data.slots[slot];
+ bool succ = (slot_data->successful_boot != 0);
+ strlcpy(buffer, succ ? "yes" : "no", size);
+ }
+
+ } else if (!strcmp_l1("slot-unbootable:", cmd)) {
+ str += strlen("slot-unbootable:");
+ slot = slotidx_from_suffix(str);
+ if (slot < 0) {
+ strlcpy(buffer, "no such slot", size);
+ return -1;
+ } else {
+ slot_data = &ab_data.slots[slot];
+ bool bootable = slot_is_bootable(slot_data);
+ strlcpy(buffer, bootable ? "no" : "yes", size);
+ }
+
+ } else if (!strcmp_l1("slot-retry-count:", cmd)) {
+ str += strlen("slot-retry-count:");
+ slot = slotidx_from_suffix(str);
+ if (slot < 0) {
+ strlcpy(buffer, "no such slot", size);
+ return -1;
+ }
+ else {
+ slot_data = &ab_data.slots[slot];
+ char var[7];
+ sprintf(var, "%d",
+ slot_data->tries_remaining);
+ strlcpy(buffer, var, size);
+ }
+
+ } else {
+ strlcpy(buffer, "no such slot command", size);
+ return -1;
+ }
+
+ return 0;
+}
+
+char *select_slot(AvbABOps *ab_ops) {
+ AvbABData ab_data;
+ int curr;
+
+ assert(ab_ops != NULL);
+
+ /* load ab meta */
+ if (ab_ops->read_ab_metadata == NULL ||
+ ab_ops->read_ab_metadata(ab_ops, &ab_data) != AVB_IO_RESULT_OK) {
+ return NULL;
+ }
+ curr = get_curr_slot(&ab_data);
+ if (curr >= 0 && curr < SLOT_NUM)
+ return slot_suffix[curr];
+ else
+ return NULL;
+}
diff --git a/lib/avb/fsl/utils.c b/lib/avb/fsl/utils.c
new file mode 100644
index 0000000..ec50c70
--- /dev/null
+++ b/lib/avb/fsl/utils.c
@@ -0,0 +1,51 @@
+
+#include <common.h>
+#include <stdlib.h>
+
+#include "debug.h"
+#include "utils.h"
+
+/* get margin_pos struct from offset [to the partition start/end] and num_bytes to read/write */
+int get_margin_pos(uint64_t part_start, uint64_t part_end, unsigned long blksz,
+ margin_pos_t *margin, int64_t offset, size_t num_bytes, bool allow_partial) {
+ long off;
+ assert(margin != NULL);
+ if (blksz == 0 || part_start > part_end)
+ return -1;
+
+ if (offset < 0) {
+ margin->blk_start = (offset + 1) / blksz + part_end;
+ margin->start = (off = offset % blksz) == 0 ? 0 : blksz + off; // offset == -1 means the last byte?, or start need -1
+ if (offset + num_bytes - 1 >= 0) {
+ if (!allow_partial)
+ return -1;
+ margin->blk_end = part_end;
+ margin->end = blksz - 1;
+ } else {
+ margin->blk_end = (num_bytes + offset) / blksz + part_end; // which blk the last byte is in
+ margin->end = (off = (num_bytes + offset - 1) % blksz) == 0 ?
+ 0 : blksz + off; // last byte
+ }
+ } else {
+ margin->blk_start = offset / blksz + part_start;
+ margin->start = offset % blksz;
+ margin->blk_end = (offset + num_bytes - 1) / blksz + part_start ;
+ margin->end = (offset + num_bytes - 1) % blksz;
+ if (margin->blk_end > part_end) {
+ if (!allow_partial)
+ return -1;
+ margin->blk_end = part_end;
+ margin->end = blksz - 1;
+ }
+ }
+ VDEBUG("bs=%ld, be=%ld, s=%ld, e=%ld\n",
+ margin->blk_start, margin->blk_end, margin->start, margin->end);
+
+ if (margin->blk_start > part_end || margin->blk_start < part_start)
+ return -1;
+ long multi = margin->blk_end - margin->blk_start - 1 +
+ (margin->start == 0) + (margin->end == blksz -1);
+ margin->multi = multi > 0 ? multi : 0;
+ VDEBUG("bm=%ld\n", margin->multi);
+ return 0;
+}
diff --git a/lib/avb/fsl/utils.h b/lib/avb/fsl/utils.h
new file mode 100644
index 0000000..6fe72f5
--- /dev/null
+++ b/lib/avb/fsl/utils.h
@@ -0,0 +1,25 @@
+#ifndef __UTILS_H__
+#define __UTILS_H__
+
+#include <common.h>
+
+#define ALIGN_BYTES 64 /*mmc block read/write need 64 bytes aligned */
+
+struct margin_pos {
+ /* which blk the read/write starts */
+ uint64_t blk_start;
+ /* which blk the read/write ends */
+ uint64_t blk_end;
+ /* start position inside the start blk */
+ unsigned long start;
+ /* end position inside the end blk */
+ unsigned long end;
+ /* how many blks can be read/write one time */
+ unsigned long multi;
+};
+typedef struct margin_pos margin_pos_t;
+
+int get_margin_pos(uint64_t part_start, uint64_t part_end, unsigned long blksz,
+ margin_pos_t *margin, int64_t offset, size_t num_bytes, bool allow_partial);
+
+#endif
generated by cgit v1.1 at 2024-07-15 08:38:37 +0000