[Feature]add MT2731_MP2_MR2_SVN388 baseline version
Change-Id: Ief04314834b31e27effab435d3ca8ba33b499059
diff --git a/meta/meta-mediatek/recipes-support/libavb/files/libavb.patch b/meta/meta-mediatek/recipes-support/libavb/files/libavb.patch
new file mode 100644
index 0000000..92fe61f
--- /dev/null
+++ b/meta/meta-mediatek/recipes-support/libavb/files/libavb.patch
@@ -0,0 +1,680 @@
+diff --git a/libavb/avb_crc32.c b/libavb/avb_crc32.c
+index 9abed54..491fb36 100644
+--- a/libavb/avb_crc32.c
++++ b/libavb/avb_crc32.c
+@@ -42,11 +42,12 @@
+ * CRC32 code derived from work by Gary S. Brown.
+ */
+
+-#include "avb_sysdeps.h"
++//#include "avb_sysdeps.h"
++#include "avb_util.h"
+
+ /* Code taken from FreeBSD 8 */
+
+-static uint32_t crc32_tab[] = {
++static uint32_t iavb_crc32_tab[] = {
+ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+ 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+ 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+@@ -98,16 +99,16 @@ static uint32_t crc32_tab[] = {
+ * in sys/libkern.h, where it can be inlined.
+ */
+
+-static uint32_t crc32(uint32_t crc_in, const uint8_t* buf, int size) {
++static uint32_t iavb_crc32(uint32_t crc_in, const uint8_t* buf, int size) {
+ const uint8_t* p = buf;
+ uint32_t crc;
+
+ crc = crc_in ^ ~0U;
+ while (size--)
+- crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
++ crc = iavb_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
+ return crc ^ ~0U;
+ }
+
+ uint32_t avb_crc32(const uint8_t* buf, size_t size) {
+- return crc32(0, buf, size);
++ return iavb_crc32(0, buf, size);
+ }
+diff --git a/libavb/avb_util.c b/libavb/avb_util.c
+index 43662b4..4105d38 100644
+--- a/libavb/avb_util.c
++++ b/libavb/avb_util.c
+@@ -24,31 +24,7 @@
+
+ #include "avb_util.h"
+
+-#include <stdarg.h>
+-
+-uint32_t avb_be32toh(uint32_t in) {
+- uint8_t* d = (uint8_t*)∈
+- uint32_t ret;
+- ret = ((uint32_t)d[0]) << 24;
+- ret |= ((uint32_t)d[1]) << 16;
+- ret |= ((uint32_t)d[2]) << 8;
+- ret |= ((uint32_t)d[3]);
+- return ret;
+-}
+-
+-uint64_t avb_be64toh(uint64_t in) {
+- uint8_t* d = (uint8_t*)∈
+- uint64_t ret;
+- ret = ((uint64_t)d[0]) << 56;
+- ret |= ((uint64_t)d[1]) << 48;
+- ret |= ((uint64_t)d[2]) << 40;
+- ret |= ((uint64_t)d[3]) << 32;
+- ret |= ((uint64_t)d[4]) << 24;
+- ret |= ((uint64_t)d[5]) << 16;
+- ret |= ((uint64_t)d[6]) << 8;
+- ret |= ((uint64_t)d[7]);
+- return ret;
+-}
++//#include <stdarg.h>
+
+ /* Converts a 32-bit unsigned integer from host to big-endian byte order. */
+ uint32_t avb_htobe32(uint32_t in) {
+@@ -63,341 +39,3 @@ uint32_t avb_htobe32(uint32_t in) {
+ return ret.word;
+ }
+
+-/* Converts a 64-bit unsigned integer from host to big-endian byte order. */
+-uint64_t avb_htobe64(uint64_t in) {
+- union {
+- uint64_t word;
+- uint8_t bytes[8];
+- } ret;
+- ret.bytes[0] = (in >> 56) & 0xff;
+- ret.bytes[1] = (in >> 48) & 0xff;
+- ret.bytes[2] = (in >> 40) & 0xff;
+- ret.bytes[3] = (in >> 32) & 0xff;
+- ret.bytes[4] = (in >> 24) & 0xff;
+- ret.bytes[5] = (in >> 16) & 0xff;
+- ret.bytes[6] = (in >> 8) & 0xff;
+- ret.bytes[7] = in & 0xff;
+- return ret.word;
+-}
+-
+-int avb_safe_memcmp(const void* s1, const void* s2, size_t n) {
+- const unsigned char* us1 = s1;
+- const unsigned char* us2 = s2;
+- int result = 0;
+-
+- if (0 == n) {
+- return 0;
+- }
+-
+- /*
+- * Code snippet without data-dependent branch due to Nate Lawson
+- * (nate@root.org) of Root Labs.
+- */
+- while (n--) {
+- result |= *us1++ ^ *us2++;
+- }
+-
+- return result != 0;
+-}
+-
+-bool avb_safe_add_to(uint64_t* value, uint64_t value_to_add) {
+- uint64_t original_value;
+-
+- avb_assert(value != NULL);
+-
+- original_value = *value;
+-
+- *value += value_to_add;
+- if (*value < original_value) {
+- avb_error("Overflow when adding values.\n");
+- return false;
+- }
+-
+- return true;
+-}
+-
+-bool avb_safe_add(uint64_t* out_result, uint64_t a, uint64_t b) {
+- uint64_t dummy;
+- if (out_result == NULL) {
+- out_result = &dummy;
+- }
+- *out_result = a;
+- return avb_safe_add_to(out_result, b);
+-}
+-
+-bool avb_validate_utf8(const uint8_t* data, size_t num_bytes) {
+- size_t n;
+- unsigned int num_cc;
+-
+- for (n = 0, num_cc = 0; n < num_bytes; n++) {
+- uint8_t c = data[n];
+-
+- if (num_cc > 0) {
+- if ((c & (0x80 | 0x40)) == 0x80) {
+- /* 10xx xxxx */
+- } else {
+- goto fail;
+- }
+- num_cc--;
+- } else {
+- if (c < 0x80) {
+- num_cc = 0;
+- } else if ((c & (0x80 | 0x40 | 0x20)) == (0x80 | 0x40)) {
+- /* 110x xxxx */
+- num_cc = 1;
+- } else if ((c & (0x80 | 0x40 | 0x20 | 0x10)) == (0x80 | 0x40 | 0x20)) {
+- /* 1110 xxxx */
+- num_cc = 2;
+- } else if ((c & (0x80 | 0x40 | 0x20 | 0x10 | 0x08)) ==
+- (0x80 | 0x40 | 0x20 | 0x10)) {
+- /* 1111 0xxx */
+- num_cc = 3;
+- } else {
+- goto fail;
+- }
+- }
+- }
+-
+- if (num_cc != 0) {
+- goto fail;
+- }
+-
+- return true;
+-
+-fail:
+- return false;
+-}
+-
+-bool avb_str_concat(char* buf,
+- size_t buf_size,
+- const char* str1,
+- size_t str1_len,
+- const char* str2,
+- size_t str2_len) {
+- uint64_t combined_len;
+-
+- if (!avb_safe_add(&combined_len, str1_len, str2_len)) {
+- avb_error("Overflow when adding string sizes.\n");
+- return false;
+- }
+-
+- if (combined_len > buf_size - 1) {
+- avb_error("Insufficient buffer space.\n");
+- return false;
+- }
+-
+- avb_memcpy(buf, str1, str1_len);
+- avb_memcpy(buf + str1_len, str2, str2_len);
+- buf[combined_len] = '\0';
+-
+- return true;
+-}
+-
+-void* avb_malloc(size_t size) {
+- void* ret = avb_malloc_(size);
+- if (ret == NULL) {
+- avb_error("Failed to allocate memory.\n");
+- return NULL;
+- }
+- return ret;
+-}
+-
+-void* avb_calloc(size_t size) {
+- void* ret = avb_malloc(size);
+- if (ret == NULL) {
+- return NULL;
+- }
+-
+- avb_memset(ret, '\0', size);
+- return ret;
+-}
+-
+-char* avb_strdup(const char* str) {
+- size_t len = avb_strlen(str);
+- char* ret = avb_malloc(len + 1);
+- if (ret == NULL) {
+- return NULL;
+- }
+-
+- avb_memcpy(ret, str, len);
+- ret[len] = '\0';
+-
+- return ret;
+-}
+-
+-const char* avb_strstr(const char* haystack, const char* needle) {
+- size_t n, m;
+-
+- /* Look through |haystack| and check if the first character of
+- * |needle| matches. If so, check the rest of |needle|.
+- */
+- for (n = 0; haystack[n] != '\0'; n++) {
+- if (haystack[n] != needle[0]) {
+- continue;
+- }
+-
+- for (m = 1;; m++) {
+- if (needle[m] == '\0') {
+- return haystack + n;
+- }
+-
+- if (haystack[n + m] != needle[m]) {
+- break;
+- }
+- }
+- }
+-
+- return NULL;
+-}
+-
+-const char* avb_strv_find_str(const char* const* strings,
+- const char* str,
+- size_t str_size) {
+- size_t n;
+- for (n = 0; strings[n] != NULL; n++) {
+- if (avb_strlen(strings[n]) == str_size &&
+- avb_memcmp(strings[n], str, str_size) == 0) {
+- return strings[n];
+- }
+- }
+- return NULL;
+-}
+-
+-char* avb_replace(const char* str, const char* search, const char* replace) {
+- char* ret = NULL;
+- size_t ret_len = 0;
+- size_t search_len, replace_len;
+- const char* str_after_last_replace;
+-
+- search_len = avb_strlen(search);
+- replace_len = avb_strlen(replace);
+-
+- str_after_last_replace = str;
+- while (*str != '\0') {
+- const char* s;
+- size_t num_before;
+- size_t num_new;
+-
+- s = avb_strstr(str, search);
+- if (s == NULL) {
+- break;
+- }
+-
+- num_before = s - str;
+-
+- if (ret == NULL) {
+- num_new = num_before + replace_len + 1;
+- ret = avb_malloc(num_new);
+- if (ret == NULL) {
+- goto out;
+- }
+- avb_memcpy(ret, str, num_before);
+- avb_memcpy(ret + num_before, replace, replace_len);
+- ret[num_new - 1] = '\0';
+- ret_len = num_new - 1;
+- } else {
+- char* new_str;
+- num_new = ret_len + num_before + replace_len + 1;
+- new_str = avb_malloc(num_new);
+- if (ret == NULL) {
+- goto out;
+- }
+- avb_memcpy(new_str, ret, ret_len);
+- avb_memcpy(new_str + ret_len, str, num_before);
+- avb_memcpy(new_str + ret_len + num_before, replace, replace_len);
+- new_str[num_new - 1] = '\0';
+- avb_free(ret);
+- ret = new_str;
+- ret_len = num_new - 1;
+- }
+-
+- str = s + search_len;
+- str_after_last_replace = str;
+- }
+-
+- if (ret == NULL) {
+- ret = avb_strdup(str_after_last_replace);
+- if (ret == NULL) {
+- goto out;
+- }
+- } else {
+- size_t num_remaining = avb_strlen(str_after_last_replace);
+- size_t num_new = ret_len + num_remaining + 1;
+- char* new_str = avb_malloc(num_new);
+- if (ret == NULL) {
+- goto out;
+- }
+- avb_memcpy(new_str, ret, ret_len);
+- avb_memcpy(new_str + ret_len, str_after_last_replace, num_remaining);
+- new_str[num_new - 1] = '\0';
+- avb_free(ret);
+- ret = new_str;
+- ret_len = num_new - 1;
+- }
+-
+-out:
+- return ret;
+-}
+-
+-/* We only support a limited amount of strings in avb_strdupv(). */
+-#define AVB_STRDUPV_MAX_NUM_STRINGS 32
+-
+-char* avb_strdupv(const char* str, ...) {
+- va_list ap;
+- const char* strings[AVB_STRDUPV_MAX_NUM_STRINGS];
+- size_t lengths[AVB_STRDUPV_MAX_NUM_STRINGS];
+- size_t num_strings, n;
+- uint64_t total_length;
+- char *ret = NULL, *dest;
+-
+- num_strings = 0;
+- total_length = 0;
+- va_start(ap, str);
+- do {
+- size_t str_len = avb_strlen(str);
+- strings[num_strings] = str;
+- lengths[num_strings] = str_len;
+- if (!avb_safe_add_to(&total_length, str_len)) {
+- avb_fatal("Overflow while determining total length.\n");
+- break;
+- }
+- num_strings++;
+- if (num_strings == AVB_STRDUPV_MAX_NUM_STRINGS) {
+- avb_fatal("Too many strings passed.\n");
+- break;
+- }
+- str = va_arg(ap, const char*);
+- } while (str != NULL);
+- va_end(ap);
+-
+- ret = avb_malloc(total_length + 1);
+- if (ret == NULL) {
+- goto out;
+- }
+-
+- dest = ret;
+- for (n = 0; n < num_strings; n++) {
+- avb_memcpy(dest, strings[n], lengths[n]);
+- dest += lengths[n];
+- }
+- *dest = '\0';
+- avb_assert(dest == ret + total_length);
+-
+-out:
+- return ret;
+-}
+-
+-const char* avb_basename(const char* str) {
+- int64_t n;
+- size_t len;
+-
+- len = avb_strlen(str);
+- if (len >= 2) {
+- for (n = len - 2; n >= 0; n--) {
+- if (str[n] == '/') {
+- return str + n + 1;
+- }
+- }
+- }
+- return str;
+-}
+diff --git a/libavb/avb_util.h b/libavb/avb_util.h
+index 07c3258..589e64c 100644
+--- a/libavb/avb_util.h
++++ b/libavb/avb_util.h
+@@ -22,254 +22,20 @@
+ * SOFTWARE.
+ */
+
+-#if !defined(AVB_INSIDE_LIBAVB_H) && !defined(AVB_COMPILATION)
+-#error "Never include this file directly, include libavb.h instead."
+-#endif
+-
+ #ifndef AVB_UTIL_H_
+ #define AVB_UTIL_H_
+
+-#include "avb_sysdeps.h"
+-
++#include <stdint.h>
++#include <sys/types.h>
+ #ifdef __cplusplus
+ extern "C" {
+ #endif
+-
+-#define AVB_STRINGIFY(x) #x
+-#define AVB_TO_STRING(x) AVB_STRINGIFY(x)
+-
+-#ifdef AVB_ENABLE_DEBUG
+-/* Aborts the program if |expr| is false.
+- *
+- * This has no effect unless AVB_ENABLE_DEBUG is defined.
+- */
+-#define avb_assert(expr) \
+- do { \
+- if (!(expr)) { \
+- avb_fatal("assert fail: " #expr "\n"); \
+- } \
+- } while (0)
+-#else
+-#define avb_assert(expr)
+-#endif
+-
+-/* Aborts the program if reached.
+- *
+- * This has no effect unless AVB_ENABLE_DEBUG is defined.
+- */
+-#ifdef AVB_ENABLE_DEBUG
+-#define avb_assert_not_reached() \
+- do { \
+- avb_fatal("assert_not_reached()\n"); \
+- } while (0)
+-#else
+-#define avb_assert_not_reached()
+-#endif
+-
+-/* Aborts the program if |addr| is not word-aligned.
+- *
+- * This has no effect unless AVB_ENABLE_DEBUG is defined.
+- */
+-#define avb_assert_aligned(addr) \
+- avb_assert((((uintptr_t)addr) & (AVB_ALIGNMENT_SIZE - 1)) == 0)
+-
+-#ifdef AVB_ENABLE_DEBUG
+-/* Print functions, used for diagnostics.
+- *
+- * These have no effect unless AVB_ENABLE_DEBUG is defined.
+- */
+-#define avb_debug(message) \
+- do { \
+- avb_printv(avb_basename(__FILE__), \
+- ":", \
+- AVB_TO_STRING(__LINE__), \
+- ": DEBUG: ", \
+- message, \
+- NULL); \
+- } while (0)
+-#define avb_debugv(message, ...) \
+- do { \
+- avb_printv(avb_basename(__FILE__), \
+- ":", \
+- AVB_TO_STRING(__LINE__), \
+- ": DEBUG: ", \
+- message, \
+- ##__VA_ARGS__); \
+- } while (0)
+-#else
+-#define avb_debug(message)
+-#define avb_debugv(message, ...)
+-#endif
+-
+-/* Prints out a message. This is typically used if a runtime-error
+- * occurs.
+- */
+-#define avb_error(message) \
+- do { \
+- avb_printv(avb_basename(__FILE__), \
+- ":", \
+- AVB_TO_STRING(__LINE__), \
+- ": ERROR: ", \
+- message, \
+- NULL); \
+- } while (0)
+-#define avb_errorv(message, ...) \
+- do { \
+- avb_printv(avb_basename(__FILE__), \
+- ":", \
+- AVB_TO_STRING(__LINE__), \
+- ": ERROR: ", \
+- message, \
+- ##__VA_ARGS__); \
+- } while (0)
+-
+-/* Prints out a message and calls avb_abort().
+- */
+-#define avb_fatal(message) \
+- do { \
+- avb_printv(avb_basename(__FILE__), \
+- ":", \
+- AVB_TO_STRING(__LINE__), \
+- ": FATAL: ", \
+- message, \
+- NULL); \
+- avb_abort(); \
+- } while (0)
+-#define avb_fatalv(message, ...) \
+- do { \
+- avb_printv(avb_basename(__FILE__), \
+- ":", \
+- AVB_TO_STRING(__LINE__), \
+- ": FATAL: ", \
+- message, \
+- ##__VA_ARGS__); \
+- avb_abort(); \
+- } while (0)
+-
+-/* Converts a 32-bit unsigned integer from big-endian to host byte order. */
+-uint32_t avb_be32toh(uint32_t in) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Converts a 64-bit unsigned integer from big-endian to host byte order. */
+-uint64_t avb_be64toh(uint64_t in) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+ /* Converts a 32-bit unsigned integer from host to big-endian byte order. */
+-uint32_t avb_htobe32(uint32_t in) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Converts a 64-bit unsigned integer from host to big-endian byte order. */
+-uint64_t avb_htobe64(uint64_t in) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Compare |n| bytes starting at |s1| with |s2| and return 0 if they
+- * match, 1 if they don't. Returns 0 if |n|==0, since no bytes
+- * mismatched.
+- *
+- * Time taken to perform the comparison is only dependent on |n| and
+- * not on the relationship of the match between |s1| and |s2|.
+- *
+- * Note that unlike avb_memcmp(), this only indicates inequality, not
+- * whether |s1| is less than or greater than |s2|.
+- */
+-int avb_safe_memcmp(const void* s1,
+- const void* s2,
+- size_t n) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Adds |value_to_add| to |value| with overflow protection.
+- *
+- * Returns false if the addition overflows, true otherwise. In either
+- * case, |value| is always modified.
+- */
+-bool avb_safe_add_to(uint64_t* value,
+- uint64_t value_to_add) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Adds |a| and |b| with overflow protection, returning the value in
+- * |out_result|.
+- *
+- * It's permissible to pass NULL for |out_result| if you just want to
+- * check that the addition would not overflow.
+- *
+- * Returns false if the addition overflows, true otherwise.
+- */
+-bool avb_safe_add(uint64_t* out_result,
+- uint64_t a,
+- uint64_t b) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Checks if |num_bytes| data at |data| is a valid UTF-8
+- * string. Returns true if valid UTF-8, false otherwise.
+- */
+-bool avb_validate_utf8(const uint8_t* data,
+- size_t num_bytes) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Concatenates |str1| (of |str1_len| bytes) and |str2| (of |str2_len|
+- * bytes) and puts the result in |buf| which holds |buf_size|
+- * bytes. The result is also guaranteed to be NUL terminated. Fail if
+- * there is not enough room in |buf| for the resulting string plus
+- * terminating NUL byte.
+- *
+- * Returns true if the operation succeeds, false otherwise.
+- */
+-bool avb_str_concat(char* buf,
+- size_t buf_size,
+- const char* str1,
+- size_t str1_len,
+- const char* str2,
+- size_t str2_len);
+-
+-/* Like avb_malloc_() but prints a error using avb_error() if memory
+- * allocation fails.
+- */
+-void* avb_malloc(size_t size) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Like avb_malloc() but sets the memory with zeroes. */
+-void* avb_calloc(size_t size) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Duplicates a NUL-terminated string. Returns NULL on OOM. */
+-char* avb_strdup(const char* str) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Duplicates a NULL-terminated array of NUL-terminated strings by
+- * concatenating them. The returned string will be
+- * NUL-terminated. Returns NULL on OOM.
+- */
+-char* avb_strdupv(const char* str,
+- ...) AVB_ATTR_WARN_UNUSED_RESULT AVB_ATTR_SENTINEL;
+-
+-/* Finds the first occurrence of |needle| in the string |haystack|
+- * where both strings are NUL-terminated strings. The terminating NUL
+- * bytes are not compared.
+- *
+- * Returns NULL if not found, otherwise points into |haystack| for the
+- * first occurrence of |needle|.
+- */
+-const char* avb_strstr(const char* haystack,
+- const char* needle) AVB_ATTR_WARN_UNUSED_RESULT;
+-
+-/* Finds the first occurrence of |str| in the NULL-terminated string
+- * array |strings|. Each element in |strings| must be
+- * NUL-terminated. The string given by |str| need not be
+- * NUL-terminated but its size must be given in |str_size|.
+- *
+- * Returns NULL if not found, otherwise points into |strings| for the
+- * first occurrence of |str|.
+- */
+-const char* avb_strv_find_str(const char* const* strings,
+- const char* str,
+- size_t str_size);
+-
+-/* Replaces all occurrences of |search| with |replace| in |str|.
+- *
+- * Returns a newly allocated string or NULL if out of memory.
+- */
+-char* avb_replace(const char* str,
+- const char* search,
+- const char* replace) AVB_ATTR_WARN_UNUSED_RESULT;
++uint32_t avb_htobe32(uint32_t in);
+
+ /* Calculates the CRC-32 for data in |buf| of size |buf_size|. */
+ uint32_t avb_crc32(const uint8_t* buf, size_t buf_size);
+
+-/* Returns the basename of |str|. This is defined as the last path
+- * component, assuming the normal POSIX separator '/'. If there are no
+- * separators, returns |str|.
+- */
+-const char* avb_basename(const char* str);
+-
+ #ifdef __cplusplus
+ }
+ #endif