CHROMIUM: rename and remove members of crossystem data blob

There are members of the blob that crossystem (user space utility) never
uses and are members that have ambiguous names. This patch removes and
renames these members, and further cleans up the code and adds static
assertions to offset of members.

BUG=chromium-os:17876
TEST=boot normal mode on Kaen
TEST=check crossystem output

Note: savedmem_{base,size} are x86-specific and crossystem is supposed
to output "(error)" on ARM boards.

----------------------------------------
arch                   = arm                            # Platform architecture
cros_debug             = 1                              # OS should allow debug features
dbg_reset              = 0                              # Debug reset mode request (writable)
dev_boot_usb           = 1                              # Enable developer mode boot from USB/SD (writable)
devsw_boot             = 0                              # Developer switch position at boot
devsw_cur              = 1                              # Developer switch current position
ecfw_act               = RO                             # Active EC firmware
fmap_base              = 0x000c0000                     # Main firmware flashmap physical address
fwb_tries              = 0                              # Try firmware B count (writable)
fwid                   = 0.14.785.2011_07_22_1415       # Active firmware ID
fwupdate_tries         = 0                              # Times to try OS firmware update (writable, inside kern_nv)
hwid                   = ARM KAEN TEST 3084             # Hardware ID
kern_nv                = 0x00000000                     # Non-volatile field for kernel use
kernkey_vfy            = sig                            # Type of verification done on kernel key block
loc_idx                = 0                              # Localization index for firmware screens (writable)
mainfw_act             = B                              # Active main firmware
mainfw_type            = normal                         # Active main firmware type
nvram_cleared          = 1                              # Have NV settings been lost?  Write 0 to clear
recovery_reason        = 0                              # Recovery mode reason for current boot
recovery_request       = 0                              # Recovery mode request (writable)
recoverysw_boot        = 0                              # Recovery switch position at boot
recoverysw_cur         = 0                              # Recovery switch current position
recoverysw_ec_boot     = 0                              # Recovery switch position at EC boot
ro_fwid                = 0.14.785.2011_07_22_1415       # Read-only firmware ID
savedmem_base          = (error)                        # RAM debug data area physical address
savedmem_size          = (error)                        # RAM debug data area size in bytes
tpm_fwver              = 0x00010001                     # Firmware version stored in TPM
tpm_kernver            = 0x00010001                     # Kernel version stored in TPM
tried_fwb              = 0                              # Tried firmware B before A this boot
vbtest_errfunc         = 0                              # Verified boot test error function (writable)
vbtest_errno           = 0                              # Verified boot test error number (writable)
vdat_flags             = 0x0000020a                     # Flags from VbSharedData
vdat_timers            = LFS=776638,778923 LF=794303,6382322 LK=8227743,12897100 # Timer values from VbSharedData
wpsw_boot              = 0                              # Firmware write protect hardware switch position at boot
wpsw_cur               = 1                              # Firmware write protect hardware switch current position
----------------------------------------

Change-Id: I5041ba3dfe51901aabe97e34583fcfdec7375f9f
Reviewed-on: http://gerrit.chromium.org/gerrit/4554
Tested-by: Che-Liang Chiou <clchiou@chromium.org>
Reviewed-by: Rong Chang <rongchang@chromium.org>

1 files changed, 88 insertions, 132 deletions

diff --git a/lib/chromeos/crossystem_data.c b/lib/chromeos/crossystem_data.c
index 60bcf6636f..d580b6a0ab 100644
--- a/lib/chromeos/crossystem_data.c
+++ b/lib/chromeos/crossystem_data.c
@@ -10,7 +10,6 @@
 
 #include <common.h>
 #include <fdt_decode.h>
-#include <gbb_header.h> /* for GoogleBinaryBlockHeader */
 #include <libfdt.h>
 #include <chromeos/common.h>
 #include <chromeos/crossystem_data.h>
@@ -23,65 +22,46 @@
 
 #define PREFIX "crossystem_data: "
 
-enum {
-	CHSW_RECOVERY_BUTTON_PRESSED	= 0x002,
-	CHSW_DEVELOPER_MODE_ENABLED	= 0x020,
-	CHSW_WRITE_PROTECT_DISABLED	= 0x200
-};
-
-int crossystem_data_init(crossystem_data_t *cdata, uint8_t *frid,
-		uint32_t fmap_data, void *gbb_data, void *nvcxt_raw,
-		cros_gpio_t *wpsw, cros_gpio_t *recsw, cros_gpio_t *devsw)
+int crossystem_data_init(crossystem_data_t *cdata,
+		cros_gpio_t *write_protect_switch,
+		cros_gpio_t *recovery_switch,
+		cros_gpio_t *developer_switch,
+		uint32_t fmap_offset,
+		uint8_t active_ec_firmware,
+		uint8_t *hardware_id,
+		uint8_t *readonly_firmware_id)
 {
-	GoogleBinaryBlockHeader *gbbh = (GoogleBinaryBlockHeader *)gbb_data;
-
 	VBDEBUG(PREFIX "crossystem data at %p\n", cdata);
 
 	memset(cdata, '\0', sizeof(*cdata));
 
 	cdata->total_size = sizeof(*cdata);
-
+	cdata->version = CROSSYSTEM_DATA_VERSION;
 	memcpy(cdata->signature, CROSSYSTEM_DATA_SIGNATURE,
 			sizeof(CROSSYSTEM_DATA_SIGNATURE));
-	cdata->version = CROSSYSTEM_DATA_VERSION;
-
-	if (recsw->value)
-		cdata->chsw |= CHSW_RECOVERY_BUTTON_PRESSED;
-	if (devsw->value)
-		cdata->chsw |= CHSW_DEVELOPER_MODE_ENABLED;
-	if (!wpsw->value)
-		cdata->chsw |= CHSW_WRITE_PROTECT_DISABLED;
-
-	memcpy(cdata->frid, frid, ID_LEN);
-	memcpy(cdata->hwid, gbb_data + gbbh->hwid_offset, gbbh->hwid_size);
 
-	/* boot reason; always 0 */
-	cdata->binf[0] = 0;
-	/* ec firmware type: 0=read-only, 1=rewritable; default to 0 */
-	cdata->binf[2] = 0;
-	/* recovery reason is default to VBNV_RECOVERY_NOT_REQUESTED */
-	cdata->binf[4] = VBNV_RECOVERY_NOT_REQUESTED;
+	cdata->nonvolatile_context_lba = CHROMEOS_VBNVCONTEXT_LBA;
+	cdata->nonvolatile_context_offset = 0;
+	cdata->nonvolatile_context_size = VBNV_BLOCK_SIZE;
 
-	cdata->gpio_port_write_protect_sw = wpsw->port;
-	cdata->gpio_port_recovery_sw = recsw->port;
-	cdata->gpio_port_developer_sw = devsw->port;
+	cdata->boot_write_protect_switch = write_protect_switch->value;
+	cdata->boot_recovery_switch = recovery_switch->value;
+	cdata->boot_developer_switch = developer_switch->value;
 
-	cdata->polarity_write_protect_sw = wpsw->polarity;
-	cdata->polarity_recovery_sw = recsw->polarity;
-	cdata->polarity_developer_sw = devsw->polarity;
+	cdata->polarity_write_protect_switch = write_protect_switch->polarity;
+	cdata->polarity_recovery_switch = recovery_switch->polarity;
+	cdata->polarity_developer_switch = developer_switch->polarity;
 
-	cdata->write_protect_sw = wpsw->value;
-	cdata->recovery_sw = recsw->value;
-	cdata->developer_sw = devsw->value;
+	cdata->gpio_port_write_protect_switch = write_protect_switch->port;
+	cdata->gpio_port_recovery_switch = recovery_switch->port;
+	cdata->gpio_port_developer_switch = developer_switch->port;
 
-	cdata->vbnv[0] = 0;
-	cdata->vbnv[1] = VBNV_BLOCK_SIZE;
+	cdata->fmap_offset = fmap_offset;
 
-	cdata->fmap_base = fmap_data;
-
-	cdata->nvcxt_lba = CHROMEOS_VBNVCONTEXT_LBA;
-
-	memcpy(cdata->nvcxt_cache, nvcxt_raw, VBNV_BLOCK_SIZE);
+	cdata->active_ec_firmware = active_ec_firmware;
+	memcpy(cdata->hardware_id, hardware_id, sizeof(cdata->hardware_id));
+	memcpy(cdata->readonly_firmware_id, readonly_firmware_id,
+			sizeof(cdata->readonly_firmware_id));
 
 	return 0;
 }
@@ -110,34 +90,12 @@ int crossystem_data_check_integrity(crossystem_data_t *cdata)
 	return 0;
 }
 
-int crossystem_data_set_fwid(crossystem_data_t *cdata, uint8_t *fwid)
+int crossystem_data_set_main_firmware(crossystem_data_t *cdata,
+		uint8_t firmware_type,
+		uint8_t *firmware_id)
 {
-	memcpy(cdata->fwid, fwid, ID_LEN);
-	return 0;
-}
-
-int crossystem_data_set_active_main_firmware(crossystem_data_t *cdata,
-		int which, int type)
-{
-	cdata->binf[1] = which;
-	cdata->binf[3] = type;
-	return 0;
-}
-
-int crossystem_data_get_active_main_firmware(crossystem_data_t *cdata)
-{
-	return cdata->binf[1];
-}
-
-int crossystem_data_get_active_main_firmware_type(crossystem_data_t *cdata)
-{
-	return cdata->binf[3];
-}
-
-int crossystem_data_set_recovery_reason(crossystem_data_t *cdata,
-		uint32_t reason)
-{
-	cdata->binf[4] = reason;
+	cdata->firmware_type = firmware_type;
+	memcpy(cdata->firmware_id, firmware_id, sizeof(cdata->firmware_id));
 	return 0;
 }
 
@@ -197,59 +155,65 @@ int crossystem_data_embed_into_fdt(crossystem_data_t *cdata, void *fdt,
 	err |= set_scalar_prop("total-size", total_size);
 	err |= set_array_prop("signature", signature);
 	err |= set_scalar_prop("version", version);
-	err |= set_scalar_prop("nonvolatile-context-lba", nvcxt_lba);
-	err |= set_scalar_prop("nonvolatile-context-offset", vbnv[0]);
-	err |= set_scalar_prop("nonvolatile-context-size", vbnv[1]);
-	err |= set_array_prop("boot-nonvolatile-cache", nvcxt_cache);
-
-	err |= set_bool_prop("boot-write-protect-switch", write_protect_sw);
-	err |= set_bool_prop("boot-recovery-switch", recovery_sw);
-	err |= set_bool_prop("boot-developer-switch", developer_sw);
 
-	gpio_prop[1] = cpu_to_fdt32(cdata->gpio_port_write_protect_sw);
-	gpio_prop[2] = cpu_to_fdt32(cdata->polarity_write_protect_sw);
+	err |= set_scalar_prop("nonvolatile-context-lba",
+			nonvolatile_context_lba);
+	err |= set_scalar_prop("nonvolatile-context-offset",
+			nonvolatile_context_offset);
+	err |= set_scalar_prop("nonvolatile-context-size",
+			nonvolatile_context_size);
+
+	err |= set_bool_prop("boot-write-protect-switch",
+			boot_write_protect_switch);
+	err |= set_bool_prop("boot-recovery-switch",
+			boot_recovery_switch);
+	err |= set_bool_prop("boot-developer-switch",
+			boot_developer_switch);
+
+	gpio_prop[1] = cpu_to_fdt32(cdata->gpio_port_write_protect_switch);
+	gpio_prop[2] = cpu_to_fdt32(cdata->polarity_write_protect_switch);
 	err |= fdt_setprop(fdt, nodeoffset, "write-protect-switch",
 			   gpio_prop, sizeof(gpio_prop));
 
-	gpio_prop[1] = cpu_to_fdt32(cdata->gpio_port_recovery_sw);
-	gpio_prop[2] = cpu_to_fdt32(cdata->polarity_recovery_sw);
+	gpio_prop[1] = cpu_to_fdt32(cdata->gpio_port_recovery_switch);
+	gpio_prop[2] = cpu_to_fdt32(cdata->polarity_recovery_switch);
 	err |= fdt_setprop(fdt, nodeoffset, "recovery-switch",
 			   gpio_prop, sizeof(gpio_prop));
 
-	gpio_prop[1] = cpu_to_fdt32(cdata->gpio_port_developer_sw);
-	gpio_prop[2] = cpu_to_fdt32(cdata->polarity_developer_sw);
+	gpio_prop[1] = cpu_to_fdt32(cdata->gpio_port_developer_switch);
+	gpio_prop[2] = cpu_to_fdt32(cdata->polarity_developer_switch);
 	err |= fdt_setprop(fdt, nodeoffset, "developer-switch",
 			   gpio_prop, sizeof(gpio_prop));
 
-	err |= set_scalar_prop("boot-reason", binf[0]);
+	err |= set_scalar_prop("fmap-offset", fmap_offset);
 
-	switch (cdata->binf[2]) {
-	case 0:
+	switch (cdata->active_ec_firmware) {
+	case ACTIVE_EC_FIRMWARE_RO:
 		err |= set_conststring_prop("active-ec-firmware", "RO");
 		break;
-	case 1:
+	case ACTIVE_EC_FIRMWARE_RW:
 		err |= set_conststring_prop("active-ec-firmware", "RW");
 		break;
 	}
 
-	switch (cdata->binf[3]) {
-	case RECOVERY_TYPE:
+	switch (cdata->firmware_type) {
+	case FIRMWARE_TYPE_RECOVERY:
 		err |= set_conststring_prop("firmware-type", "recovery");
 		break;
-	case NORMAL_TYPE:
+	case FIRMWARE_TYPE_NORMAL:
 		err |= set_conststring_prop("firmware-type", "normal");
 		break;
-	case DEVELOPER_TYPE:
+	case FIRMWARE_TYPE_DEVELOPER:
 		err |= set_conststring_prop("firmware-type", "developer");
 		break;
 	}
-	err |= set_scalar_prop("recovery-reason", binf[4]);
 
-	err |= set_array_prop("hardware-id", hwid);
-	err |= set_array_prop("firmware-version", fwid);
-	err |= set_array_prop("readonly-firmware-version", frid);
-	err |= set_scalar_prop("fmap-offset", fmap_base);
-	err |= set_array_prop("vboot-shared-data", vbshared_data);
+	err |= set_array_prop("hardware-id", hardware_id);
+	err |= set_array_prop("firmware-version", firmware_id);
+	err |= set_array_prop("readonly-firmware-version",
+			readonly_firmware_id);
+
+	err |= set_array_prop("vboot-shared-data", vb_shared_data);
 
 #undef set_scalar_prop
 #undef set_array_prop
@@ -263,40 +227,32 @@ int crossystem_data_embed_into_fdt(crossystem_data_t *cdata, void *fdt,
 
 void crossystem_data_dump(crossystem_data_t *cdata)
 {
-#ifdef VBOOT_DEBUG /* decleare inside ifdef so that compiler doesn't complain */
-	int i;
-
 #define _p(format, field) \
-	VBDEBUG("crossystem_data_dump: %-20s: " format "\n", #field, cdata->field)
+	VBDEBUG("crossystem_data_dump: %-30s: " format "\n", #field, cdata->field)
 	_p("%08x",	total_size);
 	_p("\"%s\"",	signature);
 	_p("%d",	version);
-	_p("%08llx",	nvcxt_lba);
-	_p("%08x",	vbnv[0]);
-	_p("%08x",	vbnv[1]);
-	VBDEBUG("crossystem_data_dump: nvcxt_cache: ");
-	for (i = 0; i < VBNV_BLOCK_SIZE; i++)
-		VBDEBUG("%02x", cdata->nvcxt_cache[i]);
-	VBDEBUG("\n");
-	_p("%d",	write_protect_sw);
-	_p("%d",	recovery_sw);
-	_p("%d",	developer_sw);
-	_p("%d",	gpio_port_write_protect_sw);
-	_p("%d",	gpio_port_recovery_sw);
-	_p("%d",	gpio_port_developer_sw);
-	_p("%d",	polarity_write_protect_sw);
-	_p("%d",	polarity_recovery_sw);
-	_p("%d",	polarity_developer_sw);
-	_p("%08x",	binf[0]);
-	_p("%08x",	binf[1]);
-	_p("%08x",	binf[2]);
-	_p("%08x",	binf[3]);
-	_p("%08x",	binf[4]);
-	_p("%08x",	chsw);
-	_p("\"%s\"",	hwid);
-	_p("\"%s\"",	fwid);
-	_p("\"%s\"",	frid);
-	_p("%08x",	fmap_base);
+
+	_p("%08llx",	nonvolatile_context_lba);
+	_p("%08x",	nonvolatile_context_offset);
+	_p("%08x",	nonvolatile_context_size);
+
+	_p("%d",	boot_write_protect_switch);
+	_p("%d",	boot_recovery_switch);
+	_p("%d",	boot_developer_switch);
+	_p("%d",	polarity_write_protect_switch);
+	_p("%d",	polarity_recovery_switch);
+	_p("%d",	polarity_developer_switch);
+	_p("%d",	gpio_port_write_protect_switch);
+	_p("%d",	gpio_port_recovery_switch);
+	_p("%d",	gpio_port_developer_switch);
+
+	_p("%08x",	fmap_offset);
+
+	_p("%d",	active_ec_firmware);
+	_p("%d",	firmware_type);
+	_p("\"%s\"",	hardware_id);
+	_p("\"%s\"",	readonly_firmware_id);
+	_p("\"%s\"",	firmware_id);
 #undef _p
-#endif
 }