GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

src/driver/vpd: Update lib_vpd from upstream 

Update lib_vpd.c (only containing vpd_decode.c) to latest version from
https://chromium.googlesource.com/chromiumos/platform/vpd

The called module (vpd.c) has been also corrected for new lib_vpd
types and constants.

BUG=chromium:967209
TEST=select VPD config on kukui; make; boots on at least kukui boards.

Change-Id: I3928e9c43cb87caf93fb44ee10434ce80f0a188a
Signed-off-by: Hung-Te Lin <hungte@chromium.org>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/33016
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Joel Kitching <kitching@google.com>
This commit is contained in:
Hung-Te Lin 2019-05-27 11:02:00 +08:00 committed by Patrick Georgi
parent 6681f05373
commit c345570acc
6 changed files with 184 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/drivers/vpd/Makefile.inc
View File

@ -1,2 +1,2 @@
romstage-$(CONFIG_VPD) += lib_vpd.c romstage-$(CONFIG_VPD) += vpd_decode.c
ramstage-$(CONFIG_VPD) += vpd.c lib_vpd.c ramstage-$(CONFIG_VPD) += vpd.c vpd_decode.c

113
src/drivers/vpd/lib_vpd.c
View File

@ -1,113 +0,0 @@
/*
* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
*/
#include <assert.h>
#include "lib_vpd.h"
/* Given an encoded string, this functions decodes the length field which varies
* from 1 byte to many bytes.
*
* The in points the actual byte going to be decoded. The *length returns
* the decoded length field. The number of consumed bytes will be stroed in
* decoded_len.
*
* Returns VPD_FAIL if more bit is 1, but actually reaches the end of string.
*/
int decodeLen(const int32_t max_len,
const uint8_t *in,
int32_t *length,
int32_t *decoded_len)
{
uint8_t more;
int i = 0;
assert(length);
assert(decoded_len);
*length = 0;
do {
if (i >= max_len)
return VPD_FAIL;
more = in[i] & 0x80;
*length <<= 7;
*length |= in[i] & 0x7f;
++i;
} while (more);
*decoded_len = i;
return VPD_OK;
}
/* Given the encoded string, this function invokes callback with extracted
* (key, value). The *consumed will be plused the number of bytes consumed in
* this function.
*
* The input_buf points to the first byte of the input buffer.
*
* The *consumed starts from 0, which is actually the next byte to be decoded.
* It can be non-zero to be used in multiple calls.
*
* If one entry is successfully decoded, sends it to callback and returns the
* result.
*/
int decodeVpdString(const int32_t max_len,
const uint8_t *input_buf,
int32_t *consumed,
VpdDecodeCallback callback,
void *callback_arg)
{
int type;
int32_t key_len, value_len;
int32_t decoded_len;
const uint8_t *key, *value;
/* type */
if (*consumed >= max_len)
return VPD_FAIL;
type = input_buf[*consumed];
switch (type) {
case VPD_TYPE_INFO:
case VPD_TYPE_STRING:
(*consumed)++;
/* key */
if (VPD_OK != decodeLen(max_len - *consumed,
&input_buf[*consumed], &key_len,
&decoded_len) ||
*consumed + decoded_len >= max_len) {
return VPD_FAIL;
}
*consumed += decoded_len;
key = &input_buf[*consumed];
*consumed += key_len;
/* value */
if (VPD_OK != decodeLen(max_len - *consumed,
&input_buf[*consumed],
&value_len, &decoded_len) ||
*consumed + decoded_len > max_len) {
return VPD_FAIL;
}
*consumed += decoded_len;
value = &input_buf[*consumed];
*consumed += value_len;
if (type == VPD_TYPE_STRING)
return callback(key, key_len, value, value_len,
callback_arg);
return VPD_OK;
default:
return VPD_FAIL;
break;
}
return VPD_OK;
}

226
src/drivers/vpd/lib_vpd.h
View File

@ -1,226 +0,0 @@
/*
* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
*/
#ifndef __LIB_VPD__
#define __LIB_VPD__
#include <inttypes.h>
enum {
VPD_OK = 0,
VPD_FAIL,
};
enum {
VPD_TYPE_TERMINATOR = 0,
VPD_TYPE_STRING,
VPD_TYPE_INFO = 0xfe,
VPD_TYPE_IMPLICIT_TERMINATOR = 0xff,
};
enum {
VPD_AS_LONG_AS = -1,
};
enum { /* export_type */
VPD_EXPORT_KEY_VALUE = 1,
VPD_EXPORT_VALUE,
VPD_EXPORT_AS_PARAMETER,
};
/* Callback for decodeVpdString to invoke. */
typedef int VpdDecodeCallback(const uint8_t *key, int32_t key_len,
const uint8_t *value, int32_t value_len,
void *arg);
/* Container data types */
struct StringPair {
uint8_t *key;
uint8_t *value;
int pad_len;
int filter_out; /* TRUE means not exported. */
struct StringPair *next;
};
struct PairContainer {
struct StringPair *first;
};
/***********************************************************************
* Encode and decode VPD entries
***********************************************************************/
/* Encodes the len into multiple bytes with the following format.
*
* 7 6 ............ 0
* +----+------------------+
* |More| Length | ...
* +----+------------------+
*
* The encode_buf points to the actual position we are going to store.
* encoded_len will return the exact bytes we encoded in this function.
* Returns fail if the buffer is not long enough.
*/
int encodeLen(
const int32_t len,
uint8_t *encode_buf,
const int32_t max_len,
int32_t *encoded_len);
/* Given an encoded string, this functions decodes the length field which varies
* from 1 byte to many bytes.
*
* The in points the actual byte going to be decoded. The *length returns
* the decoded length field. The number of consumed bytes will be stroed in
* decoded_len.
*
* Returns VPD_FAIL if more bit is 1, but actually reaches the end of string.
*/
int decodeLen(
const int32_t max_len,
const uint8_t *in,
int32_t *length,
int32_t *decoded_len);
/* Encodes the terminator.
* When calling, the output_buf should point to the start of buffer while
* *generated_len should contain how many bytes exist in buffer now.
* After return, *generated_len would be plused the number of bytes generated
* in this function.
*/
int encodeVpdTerminator(
const int max_buffer_len,
uint8_t *output_buf,
int *generated_len);
/* Encodes the given type/key/value pair into buffer.
*
* The pad_value_len is used to control the output value length.
* When pad_value_len > 0, the value is outputted into fixed length (pad \0
* if the value is shorter). Truncated if too long.
* pad_value_len == VPD_NO_LIMIT, output the value as long as possible.
* This is useful when we want to fix the structure layout at beginning.
*
* The encoded string will be stored in output_buf. If it is longer than
* max_buffer_len, this function returns fail. If the buffer is long enough,
* the generated_len will be updated.
*
* When calling, the output_buf should point to the start of buffer while
* *generated_len should contain how many bytes exist in buffer now.
* After return, *generated_len would be plused the number of bytes generated
* in this function.
*
* The initial value of *generated_len can be non-zero, so that this value
* can be used between multiple calls to encodeVpd2Pair().
*/
int encodeVpdString(
const uint8_t *key,
const uint8_t *value,
const int pad_value_len,
const int max_buffer_len,
uint8_t *output_buf,
int *generated_len);
/* Given the encoded string, this function invokes callback with extracted
* (key, value). The *consumed will be plused the number of bytes consumed in
* this function.
*
* The input_buf points to the first byte of the input buffer.
*
* The *consumed starts from 0, which is actually the next byte to be decoded.
* It can be non-zero to be used in multiple calls.
*
* If one entry is successfully decoded, sends it to callback and returns the
* result.
*/
int decodeVpdString(
const int32_t max_len,
const uint8_t *input_buf,
int32_t *consumed,
VpdDecodeCallback callback,
void *callback_arg);
/***********************************************************************
* Container helpers
***********************************************************************/
void initContainer(struct PairContainer *container);
struct StringPair *findString(struct PairContainer *container,
const uint8_t *key,
struct StringPair ***prev_next);
/* If key is already existed in container, its value will be replaced.
* If not existed, creates new entry in container.
*/
void setString(struct PairContainer *container,
const uint8_t *key,
const uint8_t *value,
const int pad_len);
/* merge all entries in src into dst. If key is duplicate, overwrite it.
*/
void mergeContainer(struct PairContainer *dst,
const struct PairContainer *src);
/* subtract src from dst.
*/
int subtractContainer(struct PairContainer *dst,
const struct PairContainer *src);
/* Given a container, encode its all entries into the buffer.
*/
int encodeContainer(const struct PairContainer *container,
const int max_buf_len,
uint8_t *buf,
int *generated);
/* Given a VPD blob, decode its entries and push into container.
*/
int decodeToContainer(struct PairContainer *container,
const int32_t max_len,
const uint8_t *input_buf,
int32_t *consumed);
/* Set filter for exporting functions.
* If filter is NULL, resets the filter so that everything can be exported.
*/
int setContainerFilter(struct PairContainer *container,
const uint8_t *filter);
/*
* Remove a key.
* Returns VPD_OK if deleted successfully. Otherwise, VPD_FAIL.
*/
int deleteKey(struct PairContainer *container,
const uint8_t *key);
/*
* Returns number of pairs in container.
*/
int lenOfContainer(const struct PairContainer *container);
/*
* Export the container content with human-readable text.
*
* The buf points to the first byte of buffer and *generated contains the number
* of bytes already existed in buffer.
*
* Afterward, the *generated will be plused on exact bytes this function has
* generated.
*/
int exportContainer(const int export_type,
const struct PairContainer *container,
const int max_buf_len,
uint8_t *buf,
int *generated);
void destroyContainer(struct PairContainer *container);
#endif /* __LIB_VPD__ */

41
src/drivers/vpd/vpd.c
View File

@ -12,7 +12,7 @@
#include <timestamp.h> #include <timestamp.h>
#include "vpd.h" #include "vpd.h"
#include "lib_vpd.h" #include "vpd_decode.h"
#include "vpd_tables.h" #include "vpd_tables.h"
/* Currently we only support Google VPD 2.0, which has a fixed offset. */ /* Currently we only support Google VPD 2.0, which has a fixed offset. */
@ -160,27 +160,27 @@ static void cbmem_add_cros_vpd(int is_recovery)
} }
} }
static int vpd_gets_callback(const uint8_t *key, int32_t key_len, static int vpd_gets_callback(const uint8_t *key, uint32_t key_len,
const uint8_t *value, int32_t value_len, const uint8_t *value, uint32_t value_len,
void *arg) void *arg)
{ {
struct vpd_gets_arg *result = (struct vpd_gets_arg *)arg; struct vpd_gets_arg *result = (struct vpd_gets_arg *)arg;
if (key_len != result->key_len || if (key_len != result->key_len ||
memcmp(key, result->key, key_len) != 0) memcmp(key, result->key, key_len) != 0)
/* Returns VPD_OK to continue parsing. */ /* Returns VPD_DECODE_OK to continue parsing. */
return VPD_OK; return VPD_DECODE_OK;
result->matched = 1; result->matched = 1;
result->value = value; result->value = value;
result->value_len = value_len; result->value_len = value_len;
/* Returns VPD_FAIL to stop parsing. */ /* Returns VPD_DECODE_FAIL to stop parsing. */
return VPD_FAIL; return VPD_DECODE_FAIL;
} }
const void *vpd_find(const char *key, int *size, enum vpd_region region) const void *vpd_find(const char *key, int *size, enum vpd_region region)
{ {
struct vpd_gets_arg arg = {0}; struct vpd_gets_arg arg = {0};
int consumed = 0; uint32_t consumed = 0;
const struct vpd_cbmem *vpd; const struct vpd_cbmem *vpd;
vpd = cbmem_find(CBMEM_ID_VPD); vpd = cbmem_find(CBMEM_ID_VPD);
@ -190,18 +190,21 @@ const void *vpd_find(const char *key, int *size, enum vpd_region region)
arg.key = (const uint8_t *)key; arg.key = (const uint8_t *)key;
arg.key_len = strlen(key); arg.key_len = strlen(key);
if (region == VPD_ANY || region == VPD_RO) if (region == VPD_ANY || region == VPD_RO) {
while (VPD_OK == decodeVpdString(vpd->ro_size, vpd->blob, while (vpd_decode_string(
&consumed, vpd_gets_callback, &arg)) { vpd->ro_size, vpd->blob, &consumed,
/* Iterate until found or no more entries. */ vpd_gets_callback, &arg) == VPD_DECODE_OK) {
/* Iterate until found or no more entries. */
} }
}
if (!arg.matched && region != VPD_RO) if (!arg.matched && region != VPD_RO) {
while (VPD_OK == decodeVpdString(vpd->rw_size, while (vpd_decode_string(
vpd->blob + vpd->ro_size, &consumed, vpd->rw_size, vpd->blob + vpd->ro_size,
vpd_gets_callback, &arg)) { &consumed, vpd_gets_callback,
/* Iterate until found or no more entries. */ &arg) == VPD_DECODE_OK) {
/* Iterate until found or no more entries. */
} }
}
if (!arg.matched) if (!arg.matched)
return NULL; return NULL;

92
src/drivers/vpd/vpd_decode.c Normal file
View File

@ -0,0 +1,92 @@
/*
* Copyright 2014 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* This is a copy from upstream:
* https://chromium.googlesource.com/chromiumos/platform/vpd/+/master/lib/vpd_decode.c
*/
#include "vpd_decode.h"
int vpd_decode_len(
const u32 max_len, const u8 *in, u32 *length, u32 *decoded_len)
{
u8 more;
int i = 0;
if (!length || !decoded_len)
return VPD_DECODE_FAIL;
*length = 0;
do {
if (i >= max_len)
return VPD_DECODE_FAIL;
more = in[i] & 0x80;
*length <<= 7;
*length |= in[i] & 0x7f;
++i;
} while (more);
*decoded_len = i;
return VPD_DECODE_OK;
}
int vpd_decode_string(
const u32 max_len, const u8 *input_buf, u32 *consumed,
vpd_decode_callback callback, void *callback_arg)
{
int type;
int res;
u32 key_len;
u32 value_len;
u32 decoded_len;
const u8 *key;
const u8 *value;
/* type */
if (*consumed >= max_len)
return VPD_DECODE_FAIL;
type = input_buf[*consumed];
switch (type) {
case VPD_TYPE_INFO:
case VPD_TYPE_STRING:
(*consumed)++;
/* key */
res = vpd_decode_len(max_len - *consumed, &input_buf[*consumed],
&key_len, &decoded_len);
/* key name cannot be empty, and must be followed by value. */
if (res != VPD_DECODE_OK || key_len < 1 ||
*consumed + decoded_len + key_len >= max_len)
return VPD_DECODE_FAIL;
*consumed += decoded_len;
key = &input_buf[*consumed];
*consumed += key_len;
/* value */
res = vpd_decode_len(max_len - *consumed, &input_buf[*consumed],
&value_len, &decoded_len);
/* value can be empty (value_len = 0). */
if (res != VPD_DECODE_OK ||
*consumed + decoded_len + value_len > max_len)
return VPD_DECODE_FAIL;
*consumed += decoded_len;
value = &input_buf[*consumed];
*consumed += value_len;
if (type == VPD_TYPE_STRING)
return callback(key, key_len, value, value_len,
callback_arg);
break;
default:
return VPD_DECODE_FAIL;
}
return VPD_DECODE_OK;
}

68
src/drivers/vpd/vpd_decode.h Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright 2019 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* This is a copy from upstream:
* https://chromium.googlesource.com/chromiumos/platform/vpd/+/master/include/lib/vpd_decode.h
*/
#ifndef __VPD_DECODE_H
#define __VPD_DECODE_H
#include <stdint.h>
enum {
VPD_DECODE_OK = 0,
VPD_DECODE_FAIL = 1,
};
enum {
VPD_TYPE_TERMINATOR = 0,
VPD_TYPE_STRING,
VPD_TYPE_INFO = 0xfe,
VPD_TYPE_IMPLICIT_TERMINATOR = 0xff,
};
/* Callback for vpd_decode_string to invoke. */
typedef int vpd_decode_callback(
const u8 *key, u32 key_len, const u8 *value, u32 value_len,
void *arg);
/*
* vpd_decode_len
*
* Given an encoded string, this function extracts the length of content
* (either key or value). The *consumed will contain the number of bytes
* consumed.
*
* The input_buf points to the first byte of the input buffer.
*
* The *consumed starts from 0, which is actually the next byte to be decoded.
* It can be non-zero to be used in multiple calls.
*
* Returns VPD_DECODE_OK on success, otherwise VPD_DECODE_FAIL.
*/
int vpd_decode_len(
const u32 max_len, const u8 *in, u32 *length, u32 *decoded_len);
/*
* vpd_decode_string
*
* Given the encoded string, this function invokes callback with extracted
* (key, value). The *consumed will be plused the number of bytes consumed in
* this function.
*
* The input_buf points to the first byte of the input buffer.
*
* The *consumed starts from 0, which is actually the next byte to be decoded.
* It can be non-zero to be used in multiple calls.
*
* If one entry is successfully decoded, sends it to callback and returns the
* result.
*/
int vpd_decode_string(
const u32 max_len, const u8 *input_buf, u32 *consumed,
vpd_decode_callback callback, void *callback_arg);
#endif /* __VPD_DECODE_H */