vendorcode: Add ChromeOS VPD parser.
Copied (and unmodified) the minimal bits from ChromeOS libVPD: https://chromium.googlesource.com/chromiumos/platform/vpd Old-Change-Id: Id75d1bfd16263ac1b94c22979f9892cf7908d5e6 Signed-off-by: Hung-Te Lin <hungte@chromium.org> Reviewed-on: https://chromium-review.googlesource.com/187411 Reviewed-by: Yung-chieh Lo <yjlou@chromium.org> (cherry picked from commit a10ca23686299f3fd5b639631242cadaa2ca9e8a) vendorcode: Update ChromeOS VPD Parser. Merge recent changes in ChromeOS VPD that allows non-memory-mapped firmware to load VPD easier and faster (ref: https://chromium-review.googlesource.com/188134 ). Old-Change-Id: I3ee0b89c703f476f3d77cdde52cc7588724f7686 Reviewed-on: https://chromium-review.googlesource.com/188743 Tested-by: Hung-Te Lin <hungte@chromium.org> Reviewed-by: Yung-chieh Lo <yjlou@chromium.org> Reviewed-by: David Hendricks <dhendrix@chromium.org> Commit-Queue: Hung-Te Lin <hungte@chromium.org> (cherry picked from commit 03f4d521a7fa711b963b0e1822e92eac16a691b1) vendorcode: Access to ChromeOS VPD on default CBFS media. The new function "cros_vpd_gets(key, buf, size)" provides an easy and quick way to retrieve values in ChromeOS VPD section. Old-Change-Id: I38e50615e515707ffaecdc4c4fae65043541b687 Signed-off-by: Hung-Te Lin <hungte@chromium.org> Reviewed-on: https://chromium-review.googlesource.com/187430 Reviewed-by: Yung-chieh Lo <yjlou@chromium.org> (cherry picked from commit bcd3832c06e8ed357c50f19396da21a218dc4b39) Squashed 3 related commits for a ChromeOS VPD parser. Change-Id: I4ba8fce16ea123c78d7b543c8353ab9bc1e2aa9f Signed-off-by: Isaac Christensen <isaac.christensen@se-eng.com> Reviewed-on: http://review.coreboot.org/6959 Reviewed-by: Ronald G. Minnich <rminnich@gmail.com> Tested-by: build bot (Jenkins)
This commit is contained in:
Hung-Te Lin
Mike Loptien
parent
ffda804b52
commit
6eaaafa2c3
|
|
@ -28,6 +28,8 @@ romstage-y += fmap.c
|
|||
ramstage-y += fmap.c
|
||||
ramstage-$(CONFIG_CHROMEOS_RAMOOPS) += ramoops.c
|
||||
smm-y += fmap.c
|
||||
romstage-y += vpd_decode.c cros_vpd.c
|
||||
ramstage-y += vpd_decode.c cros_vpd.c
|
||||
|
||||
ifeq ($(MOCK_TPM),1)
|
||||
CFLAGS_common += -DMOCK_TPM=1
|
||||
|
|
|
|||
|
|
@ -0,0 +1,140 @@
|
|||
/*
|
||||
* 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 <console/console.h>
|
||||
|
||||
#include <cbfs.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "cros_vpd.h"
|
||||
#include "fmap.h"
|
||||
#include "lib_vpd.h"
|
||||
#include "vpd_tables.h"
|
||||
|
||||
/*
|
||||
* Static variables are available in ramstage (all platforms), and romstage for
|
||||
* some platforms (ex, ARM, which uses SRAM).
|
||||
*/
|
||||
#if defined(__PRE_RAM__) && CONFIG_ARCH_X86
|
||||
#define STATIC_VAR
|
||||
#else
|
||||
#define STATIC_VAR static
|
||||
#endif
|
||||
|
||||
/* Currently we only support Google VPD 2.0, which has a fixed offset. */
|
||||
enum {
|
||||
GOOGLE_VPD_2_0_OFFSET = 0x600,
|
||||
};
|
||||
|
||||
struct vpd_gets_arg {
|
||||
const uint8_t *key;
|
||||
const uint8_t *value;
|
||||
int32_t key_len, value_len;
|
||||
int matched;
|
||||
};
|
||||
|
||||
static int cros_vpd_load(uint8_t **vpd_address, int32_t *vpd_size)
|
||||
{
|
||||
STATIC_VAR int cached = 0;
|
||||
STATIC_VAR uint8_t *cached_address = NULL;
|
||||
STATIC_VAR int32_t cached_size = 0;
|
||||
STATIC_VAR int result = -1;
|
||||
struct google_vpd_info info;
|
||||
int32_t base;
|
||||
|
||||
const struct fmap_area *area;
|
||||
struct cbfs_media media;
|
||||
|
||||
if (cached) {
|
||||
*vpd_address = cached_address;
|
||||
*vpd_size = cached_size;
|
||||
return result;
|
||||
}
|
||||
|
||||
cached = 1;
|
||||
area = find_fmap_area(fmap_find(), "RO_VPD");
|
||||
if (!area) {
|
||||
printk(BIOS_ERR, "%s: No RO_VPD FMAP section.\n", __func__);
|
||||
return result;
|
||||
}
|
||||
if (area->size <= GOOGLE_VPD_2_0_OFFSET + sizeof(info)) {
|
||||
printk(BIOS_ERR, "%s: Too small (%d) for Google VPD 2.0.\n",
|
||||
__func__, area->size);
|
||||
return result;
|
||||
}
|
||||
|
||||
base = area->offset + GOOGLE_VPD_2_0_OFFSET;
|
||||
cached_size = area->size - GOOGLE_VPD_2_0_OFFSET;
|
||||
init_default_cbfs_media(&media);
|
||||
media.open(&media);
|
||||
|
||||
/* Try if we can find a google_vpd_info, otherwise read whole VPD. */
|
||||
if (media.read(&media, &info, base, sizeof(info)) == sizeof(info) &&
|
||||
memcmp(info.header.magic, VPD_INFO_MAGIC, sizeof(info.header.magic))
|
||||
== 0 && cached_size >= info.size + sizeof(info)) {
|
||||
base += sizeof(info);
|
||||
cached_size = info.size;
|
||||
}
|
||||
|
||||
cached_address = media.map(&media, base, cached_size);
|
||||
media.close(&media);
|
||||
if (cached_address) {
|
||||
*vpd_address = cached_address;
|
||||
*vpd_size = cached_size;
|
||||
printk(BIOS_DEBUG, "%s: Got VPD: %#x+%#x\n", __func__, base,
|
||||
cached_size);
|
||||
result = 0;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static int vpd_gets_callback(const uint8_t *key, int32_t key_len,
|
||||
const uint8_t *value, int32_t value_len,
|
||||
void *arg)
|
||||
{
|
||||
struct vpd_gets_arg *result = (struct vpd_gets_arg *)arg;
|
||||
if (key_len != result->key_len ||
|
||||
memcmp(key, result->key, key_len) != 0)
|
||||
/* Returns VPD_OK to continue parsing. */
|
||||
return VPD_OK;
|
||||
|
||||
result->matched = 1;
|
||||
result->value = value;
|
||||
result->value_len = value_len;
|
||||
/* Returns VPD_FAIL to stop parsing. */
|
||||
return VPD_FAIL;
|
||||
}
|
||||
|
||||
char *cros_vpd_gets(const char *key, char *buffer, int size)
|
||||
{
|
||||
uint8_t *vpd_address = NULL;
|
||||
int32_t vpd_size = 0;
|
||||
struct vpd_gets_arg arg = {0};
|
||||
int consumed = 0;
|
||||
|
||||
if (cros_vpd_load(&vpd_address, &vpd_size) != 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
arg.key = (const uint8_t *)key;
|
||||
arg.key_len = strlen(key);
|
||||
|
||||
while (VPD_OK == decodeVpdString(vpd_size, vpd_address, &consumed,
|
||||
vpd_gets_callback, &arg)) {
|
||||
/* Iterate until found or no more entries. */
|
||||
}
|
||||
|
||||
if (!arg.matched)
|
||||
return NULL;
|
||||
|
||||
if (size < arg.value_len + 1)
|
||||
size = arg.value_len + 1;
|
||||
memcpy(buffer, arg.value, size - 1);
|
||||
buffer[size - 1] = '\0';
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __CROS_VPD_H__
|
||||
#define __CROS_VPD_H__
|
||||
|
||||
/*
|
||||
* Reads VPD string value by key.
|
||||
*
|
||||
* Reads in at most one less than size characters from VPD and stores them
|
||||
* into buffer. A terminating null byte ('\0') is stored after the last
|
||||
* character in the buffer.
|
||||
*
|
||||
* Returns NULL if key is not found, otherwise buffer.
|
||||
*/
|
||||
char *cros_vpd_gets(const char *key, char *buffer, int size);
|
||||
|
||||
#endif /* __CROS_VPD_H__ */
|
||||
|
|
@ -0,0 +1,226 @@
|
|||
/*
|
||||
* 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__ */
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
/*
|
||||
* 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"
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/* Sequentially decodes type, key, and value.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
* Ported from mosys project (http://code.google.com/p/mosys/).
|
||||
*/
|
||||
|
||||
#ifndef __LIB_VPD_TABLES_H__
|
||||
#define __LIB_VPD_TABLES_H__
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#define VPD_ENTRY_MAGIC "_SM_"
|
||||
#define VPD_INFO_MAGIC \
|
||||
"\xfe" /* type: VPD header */ \
|
||||
"\x09" /* key length, 9 = 1 + 8 */ \
|
||||
"\x01" /* info version, 1 */ \
|
||||
"gVpdInfo" /* signature, 8 bytes */ \
|
||||
"\x04" /* value length */
|
||||
|
||||
/* Google specific VPD info */
|
||||
struct google_vpd_info {
|
||||
union {
|
||||
struct {
|
||||
uint8_t type;
|
||||
uint8_t key_len;
|
||||
uint8_t info_ver;
|
||||
uint8_t signature[8];
|
||||
uint8_t value_len;
|
||||
} tlv;
|
||||
uint8_t magic[12];
|
||||
} header;
|
||||
uint32_t size;
|
||||
} __attribute__((packed));
|
||||
|
||||
/* Entry */
|
||||
struct vpd_entry {
|
||||
uint8_t anchor_string[4];
|
||||
uint8_t entry_cksum;
|
||||
uint8_t entry_length;
|
||||
uint8_t major_ver;
|
||||
uint8_t minor_ver;
|
||||
uint16_t max_size;
|
||||
uint8_t entry_rev;
|
||||
uint8_t format_area[5];
|
||||
uint8_t inter_anchor_string[5];
|
||||
uint8_t inter_anchor_cksum;
|
||||
uint16_t table_length;
|
||||
uint32_t table_address;
|
||||
uint16_t table_entry_count;
|
||||
uint8_t bcd_revision;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* Header */
|
||||
struct vpd_header {
|
||||
uint8_t type;
|
||||
uint8_t length;
|
||||
uint16_t handle;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* Type 0 - firmware information */
|
||||
struct vpd_table_firmware {
|
||||
uint8_t vendor;
|
||||
uint8_t version;
|
||||
uint16_t start_address;
|
||||
uint8_t release_date;
|
||||
uint8_t rom_size_64k_blocks;
|
||||
uint32_t characteristics;
|
||||
uint8_t extension[2]; /* v2.4+ */
|
||||
uint8_t major_ver; /* v2.4+ */
|
||||
uint8_t minor_ver; /* v2.4+ */
|
||||
uint8_t ec_major_ver; /* v2.4+ */
|
||||
uint8_t ec_minor_ver; /* v2.4+ */
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* Type 1 - system information */
|
||||
struct vpd_table_system {
|
||||
uint8_t manufacturer;
|
||||
uint8_t name;
|
||||
uint8_t version;
|
||||
uint8_t serial_number;
|
||||
uint8_t uuid[16];
|
||||
uint8_t wakeup_type;
|
||||
uint8_t sku_number; /* v2.4+ */
|
||||
uint8_t family; /* v2.4+ */
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* Type 127 - end of table */
|
||||
struct vpd_table_eot {
|
||||
struct vpd_header header;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* Type 241 - binary blob pointer */
|
||||
struct vpd_table_binary_blob_pointer {
|
||||
uint8_t struct_major_version;
|
||||
uint8_t struct_minor_version;
|
||||
uint8_t vendor;
|
||||
uint8_t description;
|
||||
uint8_t major_version;
|
||||
uint8_t minor_version;
|
||||
uint8_t variant;
|
||||
uint8_t reserved[5];
|
||||
uint8_t uuid[16];
|
||||
uint32_t offset;
|
||||
uint32_t size;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* The length and number of strings defined here is not a limitation of VPD.
|
||||
* These numbers were deemed good enough during development. */
|
||||
#define VPD_MAX_STRINGS 10
|
||||
#define VPD_MAX_STRING_LENGTH 64
|
||||
|
||||
#endif /* __LIB_VPD_TABLES_H__ */
|
||||
Loading…
Reference in New Issue