From e37f477f2a860fa51f59acce705ad2b14d985a5a Mon Sep 17 00:00:00 2001 From: Rong Chang Date: Wed, 4 May 2011 22:05:33 +0800 Subject: FACTORY: temp: crossystem workaround for factory branch Change-Id: I503271a44cfd1afe93b7da3a6061e1db6756d2a7 --- host/arch/arm/lib/crossystem_arch.c | 569 ++++++++++++++++++++++++++++++++++-- 1 file changed, 544 insertions(+), 25 deletions(-) diff --git a/host/arch/arm/lib/crossystem_arch.c b/host/arch/arm/lib/crossystem_arch.c index 4304ce7c..3eb7f702 100644 --- a/host/arch/arm/lib/crossystem_arch.c +++ b/host/arch/arm/lib/crossystem_arch.c @@ -20,75 +20,561 @@ #include "vboot_struct.h" +/* ACPI constants from Chrome OS Main Processor Firmware Spec */ +/* Boot reasons from BINF.0, from early H2C firmware */ +/* Unknown */ +#define BINF0_UNKNOWN 0 +/* Normal boot to Chrome OS */ +#define BINF0_NORMAL 1 +/* Developer mode boot (developer mode warning displayed) */ +#define BINF0_DEVELOPER 2 +/* Recovery initiated by user, using recovery button */ +#define BINF0_RECOVERY_BUTTON 3 +/* Recovery initiated by user pressing a key at developer mode warning + * screen */ +#define BINF0_RECOVERY_DEV_SCREEN_KEY 4 +/* Recovery caused by BIOS failed signature check (neither rewritable + * firmware was valid) */ +#define BINF0_RECOVERY_RW_FW_BAD 5 +/* Recovery caused by no OS kernel detected */ +#define BINF0_RECOVERY_NO_OS 6 +/* Recovery caused by OS kernel failed signature check */ +#define BINF0_RECOVERY_BAD_OS 7 +/* Recovery initiated by OS */ +#define BINF0_RECOVERY_OS_INITIATED 8 +/* OS-initiated S3 diagnostic path (debug mode boot) */ +#define BINF0_S3_DIAGNOSTIC_PATH 9 +/* S3 resume failed */ +#define BINF0_S3_RESUME_FAILED 10 +/* Recovery caused by TPM error */ +#define BINF0_RECOVERY_TPM_ERROR 11 +/* Firmware types from BINF.3 */ +#define BINF3_RECOVERY 0 +#define BINF3_NORMAL 1 +#define BINF3_DEVELOPER 2 +/* CHSW bitflags */ +#define CHSW_RECOVERY_BOOT 0x00000002 +#define CHSW_RECOVERY_EC_BOOT 0x00000004 +#define CHSW_DEV_BOOT 0x00000020 +#define CHSW_WP_BOOT 0x00000200 +/* CMOS reboot field bitflags */ +#define CMOSRF_RECOVERY 0x80 +#define CMOSRF_DEBUG_RESET 0x40 +#define CMOSRF_TRY_B 0x20 +/* GPIO signal types */ +#define GPIO_SIGNAL_TYPE_RECOVERY 1 +#define GPIO_SIGNAL_TYPE_DEV 2 +#define GPIO_SIGNAL_TYPE_WP 3 + +/* Base name for ACPI files */ +#define ACPI_BASE_PATH "/sys/devices/platform/chromeos_acpi" +/* Paths for frequently used ACPI files */ +#define ACPI_BINF_PATH ACPI_BASE_PATH "/BINF" +#define ACPI_CHNV_PATH ACPI_BASE_PATH "/CHNV" +#define ACPI_CHSW_PATH ACPI_BASE_PATH "/CHSW" +#define ACPI_FMAP_PATH ACPI_BASE_PATH "/FMAP" +#define ACPI_GPIO_PATH ACPI_BASE_PATH "/GPIO" +#define ACPI_VBNV_PATH ACPI_BASE_PATH "/VBNV" +#define ACPI_VDAT_PATH ACPI_BASE_PATH "/VDAT" + +/* Base name for GPIO files */ +#define GPIO_BASE_PATH "/sys/class/gpio" +#define GPIO_EXPORT_PATH GPIO_BASE_PATH "/export" + +/* Filename for NVRAM file */ +#define NVRAM_PATH "/dev/nvram" + +/* Filename for legacy firmware update tries */ +#define NEED_FWUPDATE_PATH "/mnt/stateful_partition/.need_firmware_update" + + int VbReadNvStorage(VbNvContext* vnc) { - /* TODO: IMPLEMENT ME! */ - return -1; + FILE* f; + int offs; + + /* Get the byte offset from VBNV */ + offs = ReadFileInt(ACPI_VBNV_PATH ".0"); + if (offs == -1) + return -1; + if (VBNV_BLOCK_SIZE > ReadFileInt(ACPI_VBNV_PATH ".1")) + return -1; /* NV storage block is too small */ + + f = fopen(NVRAM_PATH, "rb"); + if (!f) + return -1; + + if (0 != fseek(f, offs, SEEK_SET) || + 1 != fread(vnc->raw, VBNV_BLOCK_SIZE, 1, f)) { + fclose(f); + return -1; + } + + fclose(f); + return 0; } int VbWriteNvStorage(VbNvContext* vnc) { - /* TODO: IMPLEMENT ME! */ - return -1; + FILE* f; + int offs; + + if (!vnc->raw_changed) + return 0; /* Nothing changed, so no need to write */ + + /* Get the byte offset from VBNV */ + offs = ReadFileInt(ACPI_VBNV_PATH ".0"); + if (offs == -1) + return -1; + if (VBNV_BLOCK_SIZE > ReadFileInt(ACPI_VBNV_PATH ".1")) + return -1; /* NV storage block is too small */ + + f = fopen(NVRAM_PATH, "w+b"); + if (!f) + return -1; + + if (0 != fseek(f, offs, SEEK_SET) || + 1 != fwrite(vnc->raw, VBNV_BLOCK_SIZE, 1, f)) { + fclose(f); + return -1; + } + + fclose(f); + return 0; +} + + +/* + * Get buffer data from ACPI. + * + * Buffer data is expected to be represented by a file which is a text dump of + * the buffer, representing each byte by two hex numbers, space and newline + * separated. + * + * On success, stores the amount of data read in bytes to *buffer_size; on + * erros, sets *buffer_size=0. + * + * Input - ACPI file name to get data from. + * + * Output: a pointer to AcpiBuffer structure containing the binary + * representation of the data. The caller is responsible for + * deallocating the pointer, this will take care of both the structure + * and the buffer. Null in case of error. + */ +static uint8_t* VbGetBuffer(const char* filename, int* buffer_size) +{ + FILE* f = NULL; + char* file_buffer = NULL; + uint8_t* output_buffer = NULL; + uint8_t* return_value = NULL; + + /* Assume error until proven otherwise */ + if (buffer_size) + *buffer_size = 0; + + do { + struct stat fs; + uint8_t* output_ptr; + int rv, i, real_size; + int parsed_size = 0; + + rv = stat(filename, &fs); + if (rv || !S_ISREG(fs.st_mode)) + break; + + f = fopen(filename, "r"); + if (!f) + break; + + file_buffer = Malloc(fs.st_size + 1); + if (!file_buffer) + break; + + real_size = fread(file_buffer, 1, fs.st_size, f); + if (!real_size) + break; + file_buffer[real_size] = '\0'; + + /* Each byte in the output will replace two characters and a space + * in the input, so the output size does not exceed input side/3 + * (a little less if account for newline characters). */ + output_buffer = Malloc(real_size/3); + if (!output_buffer) + break; + output_ptr = output_buffer; + + /* process the file contents */ + for (i = 0; i < real_size; i++) { + char* base, *end; + + base = file_buffer + i; + + if (!isxdigit(*base)) + continue; + + output_ptr[parsed_size++] = strtol(base, &end, 16) & 0xff; + + if ((end - base) != 2) + /* Input file format error */ + break; + + i += 2; /* skip the second character and the following space */ + } + + if (i == real_size) { + /* all is well */ + return_value = output_buffer; + output_buffer = NULL; /* prevent it from deallocating */ + if (buffer_size) + *buffer_size = parsed_size; + } + } while(0); + + /* wrap up */ + if (f) + fclose(f); + + if (file_buffer) + Free(file_buffer); + + if (output_buffer) + Free(output_buffer); + + return return_value; } VbSharedDataHeader* VbSharedDataRead(void) { - /* TODO: IMPLEMENT ME! */ - return NULL; + + VbSharedDataHeader* sh; + int got_size = 0; + + sh = (VbSharedDataHeader*)VbGetBuffer(ACPI_VDAT_PATH, &got_size); + if (!sh) + return NULL; + if (got_size < sizeof(VbSharedDataHeader)) { + Free(sh); + return NULL; + } + if (sh->data_size > got_size) + sh->data_size = got_size; /* Truncated read */ + + return sh; +} + + +/* Read the CMOS reboot field in NVRAM. + * + * Returns 0 if the mask is clear in the field, 1 if set, or -1 if error. */ +static int VbGetCmosRebootField(uint8_t mask) { + FILE* f; + int chnv, nvbyte; + + /* Get the byte offset from CHNV */ + chnv = ReadFileInt(ACPI_CHNV_PATH); + if (chnv == -1) + return -1; + + f = fopen(NVRAM_PATH, "rb"); + if (!f) + return -1; + + if (0 != fseek(f, chnv, SEEK_SET) || EOF == (nvbyte = fgetc(f))) { + fclose(f); + return -1; + } + + fclose(f); + return (nvbyte & mask ? 1 : 0); +} + + +/* Write the CMOS reboot field in NVRAM. + * + * Sets (value=0) or clears (value!=0) the mask in the byte. + * + * Returns 0 if success, or -1 if error. */ +static int VbSetCmosRebootField(uint8_t mask, int value) { + FILE* f; + int chnv, nvbyte; + + /* Get the byte offset from CHNV */ + chnv = ReadFileInt(ACPI_CHNV_PATH); + if (chnv == -1) + return -1; + + f = fopen(NVRAM_PATH, "w+b"); + if (!f) + return -1; + + /* Read the current value */ + if (0 != fseek(f, chnv, SEEK_SET) || EOF == (nvbyte = fgetc(f))) { + fclose(f); + return -1; + } + + /* Set/clear the mask */ + if (value) + nvbyte |= mask; + else + nvbyte &= ~mask; + + /* Write the byte back */ + if (0 != fseek(f, chnv, SEEK_SET) || EOF == (fputc(nvbyte, f))) { + fclose(f); + return -1; + } + + /* Success */ + fclose(f); + return 0; +} + + +/* Read the active main firmware type into the destination buffer. + * Passed the destination and its size. Returns the destination, or + * NULL if error. */ +static const char* VbReadMainFwType(char* dest, int size) { + + /* Try reading type from BINF.3 */ + switch(ReadFileInt(ACPI_BINF_PATH ".3")) { + case BINF3_RECOVERY: + return StrCopy(dest, "recovery", size); + case BINF3_NORMAL: + return StrCopy(dest, "normal", size); + case BINF3_DEVELOPER: + return StrCopy(dest, "developer", size); + default: + break; /* Fall through to legacy handling */ + } + + /* Fall back to BINF.0 for legacy systems like Mario. */ + switch(ReadFileInt(ACPI_BINF_PATH ".0")) { + case -1: + /* Both BINF.0 and BINF.3 are missing, so this isn't Chrome OS + * firmware. */ + return StrCopy(dest, "nonchrome", size); + case BINF0_NORMAL: + return StrCopy(dest, "normal", size); + case BINF0_DEVELOPER: + return StrCopy(dest, "developer", size); + case BINF0_RECOVERY_BUTTON: + case BINF0_RECOVERY_DEV_SCREEN_KEY: + case BINF0_RECOVERY_RW_FW_BAD: + case BINF0_RECOVERY_NO_OS: + case BINF0_RECOVERY_BAD_OS: + case BINF0_RECOVERY_OS_INITIATED: + case BINF0_RECOVERY_TPM_ERROR: + /* Assorted flavors of recovery boot reason. */ + return StrCopy(dest, "recovery", size); + default: + /* Other values don't map cleanly to firmware type. */ + return NULL; + } +} + + +/* Read the recovery reason. Returns the reason code or -1 if error. */ +static int VbGetRecoveryReason(void) { + int value; + + /* Try reading type from BINF.4 */ + value = ReadFileInt(ACPI_BINF_PATH ".4"); + if (-1 != value) + return value; + + /* Fall back to BINF.0 for legacy systems like Mario. */ + switch(ReadFileInt(ACPI_BINF_PATH ".0")) { + case BINF0_NORMAL: + case BINF0_DEVELOPER: + return VBNV_RECOVERY_NOT_REQUESTED; + case BINF0_RECOVERY_BUTTON: + return VBNV_RECOVERY_RO_MANUAL; + case BINF0_RECOVERY_DEV_SCREEN_KEY: + return VBNV_RECOVERY_RW_DEV_SCREEN; + case BINF0_RECOVERY_RW_FW_BAD: + case BINF0_RECOVERY_NO_OS: + return VBNV_RECOVERY_RW_NO_OS; + case BINF0_RECOVERY_BAD_OS: + return VBNV_RECOVERY_RW_INVALID_OS; + case BINF0_RECOVERY_OS_INITIATED: + return VBNV_RECOVERY_LEGACY; + default: + /* Other values don't map cleanly to firmware type. */ + return -1; + } +} + + +/* Read a GPIO of the specified signal type (see ACPI GPIO SignalType). + * + * Returns 1 if the signal is asserted, 0 if not asserted, or -1 if error. */ +static int ReadGpio(int signal_type) { + char name[128]; + int index = 0; + int gpio_type; + int active_high; + int controller_offset; + char controller_name[128]; + int value; + + /* Scan GPIO.* to find a matching signal type */ + for (index = 0; ; index++) { + snprintf(name, sizeof(name), "%s.%d/GPIO.0", ACPI_GPIO_PATH, index); + gpio_type = ReadFileInt(name); + if (gpio_type == signal_type) + break; + else if (gpio_type == -1) + return -1; /* Ran out of GPIOs before finding a match */ + } + + /* Read attributes and controller info for the GPIO */ + snprintf(name, sizeof(name), "%s.%d/GPIO.1", ACPI_GPIO_PATH, index); + active_high = ReadFileBit(name, 0x00000001); + snprintf(name, sizeof(name), "%s.%d/GPIO.2", ACPI_GPIO_PATH, index); + controller_offset = ReadFileInt(name); + if (active_high == -1 || controller_offset == -1) + return -1; /* Missing needed info */ + + /* We only support the NM10 for now */ + snprintf(name, sizeof(name), "%s.%d/GPIO.3", ACPI_GPIO_PATH, index); + if (!ReadFileString(controller_name, sizeof(controller_name), name)) + return -1; + if (0 != strcmp(controller_name, "NM10")) + return -1; + + /* Assume the NM10 has offset 192 */ + /* TODO: should really check gpiochipNNN/label to see if it's the + * address we expect for the NM10, and then read the offset from + * gpiochipNNN/base. */ + controller_offset += 192; + + /* Try reading the GPIO value */ + snprintf(name, sizeof(name), "%s/gpio%d/value", + GPIO_BASE_PATH, controller_offset); + value = ReadFileInt(name); + + if (value == -1) { + /* Try exporting the GPIO */ + FILE* f = fopen(GPIO_EXPORT_PATH, "wt"); + if (!f) + return -1; + fprintf(f, "%d", controller_offset); + fclose(f); + + /* Try re-reading the GPIO value */ + value = ReadFileInt(name); + } + + if (value == -1) + return -1; + + /* Compare the GPIO value with the active value and return 1 if match. */ + return (value == active_high ? 1 : 0); } int VbGetArchPropertyInt(const char* name) { + int value = -1; - /* TODO: IMPLEMENT ME! For now, return reasonable defaults for - * values where reasonable defaults exist. */ + /* Values from ACPI */ if (!strcasecmp(name,"recovery_reason")) { + value = VbGetRecoveryReason(); } else if (!strcasecmp(name,"fmap_base")) { + value = ReadFileInt(ACPI_FMAP_PATH); } /* Switch positions */ else if (!strcasecmp(name,"devsw_cur")) { - return 1; + value = ReadGpio(GPIO_SIGNAL_TYPE_DEV); } else if (!strcasecmp(name,"recoverysw_cur")) { - return 0; + value = ReadGpio(GPIO_SIGNAL_TYPE_RECOVERY); } else if (!strcasecmp(name,"wpsw_cur")) { - return 1; + value = ReadGpio(GPIO_SIGNAL_TYPE_WP); + if (-1 != value && FwidStartsWith("Mario.")) + value = 1 - value; /* Mario reports this backwards */ } else if (!strcasecmp(name,"devsw_boot")) { - return 1; + value = ReadFileBit(ACPI_CHSW_PATH, CHSW_DEV_BOOT); } else if (!strcasecmp(name,"recoverysw_boot")) { - return 0; + value = ReadFileBit(ACPI_CHSW_PATH, CHSW_RECOVERY_BOOT); } else if (!strcasecmp(name,"recoverysw_ec_boot")) { - return 0; + value = ReadFileBit(ACPI_CHSW_PATH, CHSW_RECOVERY_EC_BOOT); } else if (!strcasecmp(name,"wpsw_boot")) { - return 1; + value = ReadFileBit(ACPI_CHSW_PATH, CHSW_WP_BOOT); + if (-1 != value && FwidStartsWith("Mario.")) + value = 1 - value; /* Mario reports this backwards */ } /* Saved memory is at a fixed location for all H2C BIOS. If the CHSW * path exists in sysfs, it's a H2C BIOS. */ else if (!strcasecmp(name,"savedmem_base")) { + return (-1 == ReadFileInt(ACPI_CHSW_PATH) ? -1 : 0x00F00000); } else if (!strcasecmp(name,"savedmem_size")) { + return (-1 == ReadFileInt(ACPI_CHSW_PATH) ? -1 : 0x00100000); } + /* NV storage values. If unable to get from NV storage, fall back to the + * CMOS reboot field used by older BIOS. */ + else if (!strcasecmp(name,"recovery_request")) { + value = VbGetNvStorage(VBNV_RECOVERY_REQUEST); + if (-1 == value) + value = VbGetCmosRebootField(CMOSRF_RECOVERY); + } else if (!strcasecmp(name,"dbg_reset")) { + value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE); + if (-1 == value) + value = VbGetCmosRebootField(CMOSRF_DEBUG_RESET); + } else if (!strcasecmp(name,"fwb_tries")) { + value = VbGetNvStorage(VBNV_TRY_B_COUNT); + if (-1 == value) + value = VbGetCmosRebootField(CMOSRF_TRY_B); + } + /* Firmware update tries is now stored in the kernel field. On + * older systems where it's not, it was stored in a file in the + * stateful partition. */ + else if (!strcasecmp(name,"fwupdate_tries")) { + if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD)) + return -1; /* NvStorage supported; fail through arch-specific + * implementation to normal implementation. */ - return -1; + /* Read value from file; missing file means value=0. */ + value = ReadFileInt(NEED_FWUPDATE_PATH); + if (-1 == value) + value = 0; + } + + return value; } const char* VbGetArchPropertyString(const char* name, char* dest, int size) { - /* TODO: IMPLEMENT ME! For now, return reasonable defaults for - * values where reasonable defaults exist. */ + if (!strcasecmp(name,"arch")) { return StrCopy(dest, "arm", size); } else if (!strcasecmp(name,"hwid")) { - return StrCopy(dest, "UnknownArmHwid", size); + return ReadFileString(dest, size, ACPI_BASE_PATH "/HWID"); } else if (!strcasecmp(name,"fwid")) { - return StrCopy(dest, "UnknownArmFwid", size); + return ReadFileString(dest, size, ACPI_BASE_PATH "/FWID"); } else if (!strcasecmp(name,"ro_fwid")) { - return StrCopy(dest, "UnknownArmRoFwid", size); + return ReadFileString(dest, size, ACPI_BASE_PATH "/FRID"); } else if (!strcasecmp(name,"mainfw_act")) { - return StrCopy(dest, "A", size); + switch(ReadFileInt(ACPI_BINF_PATH ".1")) { + case 0: + return StrCopy(dest, "recovery", size); + case 1: + return StrCopy(dest, "A", size); + case 2: + return StrCopy(dest, "B", size); + default: + return NULL; + } } else if (!strcasecmp(name,"mainfw_type")) { - return StrCopy(dest, "developer", size); + return VbReadMainFwType(dest, size); } else if (!strcasecmp(name,"ecfw_act")) { - return StrCopy(dest, "RO", size); + switch(ReadFileInt(ACPI_BINF_PATH ".2")) { + case 0: + return StrCopy(dest, "RO", size); + case 1: + return StrCopy(dest, "RW", size); + default: + return NULL; + } } return NULL; @@ -96,7 +582,40 @@ const char* VbGetArchPropertyString(const char* name, char* dest, int size) { int VbSetArchPropertyInt(const char* name, int value) { - /* TODO: IMPLEMENT ME! */ + /* NV storage values. If unable to get from NV storage, fall back to the + * CMOS reboot field used by older BIOS. */ + if (!strcasecmp(name,"recovery_request")) { + if (0 == VbSetNvStorage(VBNV_RECOVERY_REQUEST, value)) + return 0; + return VbSetCmosRebootField(CMOSRF_RECOVERY, value); + } else if (!strcasecmp(name,"dbg_reset")) { + if (0 == VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value)) + return 0; + return VbSetCmosRebootField(CMOSRF_DEBUG_RESET, value); + } else if (!strcasecmp(name,"fwb_tries")) { + if (0 == VbSetNvStorage(VBNV_TRY_B_COUNT, value)) + return 0; + return VbSetCmosRebootField(CMOSRF_TRY_B, value); + } + /* Firmware update tries is now stored in the kernel field. On + * older systems where it's not, it was stored in a file in the + * stateful partition. */ + else if (!strcasecmp(name,"fwupdate_tries")) { + if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD)) + return -1; /* NvStorage supported; fail through arch-specific + * implementation to normal implementation */ + + if (value) { + char buf[32]; + snprintf(buf, sizeof(buf), "%d", value); + return WriteFile(NEED_FWUPDATE_PATH, buf, strlen(buf)); + } else { + /* No update tries, so remove file if it exists. */ + unlink(NEED_FWUPDATE_PATH); + return 0; + } + } + return -1; } -- cgit v1.2.1