June 2021 - flashrom-gerrit - mail.coreboot.org

Change in flashrom[master]: buspirate: Add psus option
by Nico Huber (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Jeremy Kerr. Nico Huber has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/54887 ) Change subject: buspirate: Add psus option ...................................................................... Patch Set 2: Code-Review+2 -- To view, visit https://review.coreboot.org/c/flashrom/+/54887 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: I8a7d4b40c0f7f04f6976f6757f05b61f2c9958f9 Gerrit-Change-Number: 54887 Gerrit-PatchSet: 2 Gerrit-Owner: Jeremy Kerr <jk(a)ozlabs.org> Gerrit-Reviewer: Nico Huber <nico.h(a)gmx.de> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Paul Menzel <paulepanter(a)mailbox.org> Gerrit-Attention: Jeremy Kerr <jk(a)ozlabs.org> Gerrit-Comment-Date: Mon, 21 Jun 2021 10:16:32 +0000 Gerrit-HasComments: No Gerrit-Has-Labels: Yes Gerrit-MessageType: comment

1 0

Change in flashrom[master]: acpi_ec: Implement basic ACPI embedded controller API
by Michał Żygowski (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Angel Pons. Michał Żygowski has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/55714 ) Change subject: acpi_ec: Implement basic ACPI embedded controller API ...................................................................... Patch Set 1: (1 comment) Commit Message: https://review.coreboot.org/c/flashrom/+/55714/comment/b890ce1c_2965033c PS1, Line 7: ACPI > What part of the code is about ACPI? Sure, the EC data/control I/O register pair is described in ACP […] Please take a look at: https://uefi.org/specs/ACPI/6.4/12_ACPI_Embedded_Controller_Interface_Speci… I dare to say it is standard ACPI EC because: - it uses status and data register layout defined in section "12.2. Embedded Controller Register Descriptions" - it uses default command set for writing and reading bytes from EC as described in the section "12.3. Embedded Controller Command Set" This is what this patch implements, the default command set. Even the Linux kernel calls it the ACPI Embedded Controller: https://github.com/torvalds/linux/blob/master/drivers/acpi/ec.c -- To view, visit https://review.coreboot.org/c/flashrom/+/55714 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: Ie3bae8d81c80ae2f286b619e974869e3f2f4545d Gerrit-Change-Number: 55714 Gerrit-PatchSet: 1 Gerrit-Owner: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Attention: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Comment-Date: Mon, 21 Jun 2021 10:12:58 +0000 Gerrit-HasComments: Yes Gerrit-Has-Labels: No Comment-In-Reply-To: Angel Pons <th3fanbus(a)gmail.com> Gerrit-MessageType: comment

1 0

Change in flashrom[master]: acpi_ec: Implement basic ACPI embedded controller API
by Angel Pons (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Michał Żygowski. Angel Pons has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/55714 ) Change subject: acpi_ec: Implement basic ACPI embedded controller API ...................................................................... Patch Set 1: (5 comments) Commit Message: https://review.coreboot.org/c/flashrom/+/55714/comment/24cdc698_9db2d472 PS1, Line 7: ACPI What part of the code is about ACPI? Sure, the EC data/control I/O register pair is described in ACPI, but the interface per se has nothing to do with ACPI, as far as I know. https://review.coreboot.org/c/flashrom/+/55714/comment/42f420a4_6c296a1e PS1, Line 11: e typo: c File acpi_ec.h: https://review.coreboot.org/c/flashrom/+/55714/comment/36a9f392_6ef81d64 PS1, Line 41: bool ec_wait_for_ibuf(uint8_t control_port); : bool ec_wait_for_obuf(uint8_t control_port, unsigned int max_checks); Any reason why only one of these has the `max_checks` parameter? File acpi_ec.c: https://review.coreboot.org/c/flashrom/+/55714/comment/a0c88db5_85de96b7 PS1, Line 84: ec_wait_for_ibuf obuf? https://review.coreboot.org/c/flashrom/+/55714/comment/2bc72922_7a12ff9e PS1, Line 72: : : bool ec_read_reg(uint8_t address, uint8_t *data) : { : if (!ec_wait_for_ibuf(EC_CONTROL)) : return false; : OUTB(EC_CMD_READ_REG, EC_CONTROL); : : if (!ec_wait_for_ibuf(EC_CONTROL)) : return false; : OUTB(address, EC_DATA); : : if (!ec_wait_for_ibuf(EC_CONTROL)) : return false; : *data = INB(EC_DATA); : : return true; : } : : bool ec_write_reg(uint8_t address, uint8_t data) : { : if (!ec_wait_for_ibuf(EC_CONTROL)) : return false; : OUTB(EC_CMD_WRITE_REG, EC_CONTROL); : : if (!ec_wait_for_ibuf(EC_CONTROL)) : return false; : OUTB(address, EC_DATA); : : if (!ec_wait_for_ibuf(EC_CONTROL)) : return false; : OUTB(data, EC_DATA); : : return true; : } Why not use the functions you defined above? bool ec_read_reg(uint8_t address, uint8_t *data) { if (!ec_write_cmd(EC_CONTROL, EC_CMD_READ_REG)) return false; if (!ec_write_byte(EC_CONTROL, EC_DATA, address)) return false; return ec_read_byte(EC_CONTROL, EC_DATA, data); } bool ec_write_reg(uint8_t address, uint8_t data) { if (!ec_write_cmd(EC_CONTROL, EC_CMD_READ_REG)) return false; if (!ec_write_byte(EC_CONTROL, EC_DATA, address)) return false; return ec_write_byte(EC_CONTROL, EC_DATA, data); } -- To view, visit https://review.coreboot.org/c/flashrom/+/55714 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: Ie3bae8d81c80ae2f286b619e974869e3f2f4545d Gerrit-Change-Number: 55714 Gerrit-PatchSet: 1 Gerrit-Owner: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Attention: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-Comment-Date: Mon, 21 Jun 2021 09:37:19 +0000 Gerrit-HasComments: Yes Gerrit-Has-Labels: No Gerrit-MessageType: comment

1 0

Change in flashrom[master]: flashrom.c: Add 64KB write granularity
by Angel Pons (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Michał Żygowski. Angel Pons has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/55713 ) Change subject: flashrom.c: Add 64KB write granularity ...................................................................... Patch Set 1: Code-Review+1 (3 comments) Commit Message: https://review.coreboot.org/c/flashrom/+/55713/comment/c66cc63a_38120c79 PS1, Line 7: KB Strictly speaking, this should be `KiB`. (64 KB = 64 * 1000 bytes, 64 KiB = 64 * 1024 bytes) File flashrom.c: https://review.coreboot.org/c/flashrom/+/55713/comment/b50b4a1a_367fcead PS1, Line 506: 1024 * 64 nit: I'd use `64 * 1024` to be in line with `64 kilobytes`. https://review.coreboot.org/c/flashrom/+/55713/comment/f5850c81_2544d0f6 PS1, Line 578: 1024 * 64 Same here -- To view, visit https://review.coreboot.org/c/flashrom/+/55713 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: I69801f581d0cb9b85f6596de7e1267ef9317673f Gerrit-Change-Number: 55713 Gerrit-PatchSet: 1 Gerrit-Owner: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-Reviewer: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Attention: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-Comment-Date: Mon, 21 Jun 2021 09:24:56 +0000 Gerrit-HasComments: Yes Gerrit-Has-Labels: Yes Gerrit-MessageType: comment

1 0

Change in flashrom[master]: tuxedo_ec: Implement support for flashing ECs on TUXEDO laptops
by Michał Żygowski (Code Review) 21 Jun '21

21 Jun '21

Michał Żygowski has uploaded this change for review. ( https://review.coreboot.org/c/flashrom/+/55715 ) Change subject: tuxedo_ec: Implement support for flashing ECs on TUXEDO laptops ...................................................................... tuxedo_ec: Implement support for flashing ECs on TUXEDO laptops Add a new programmer supporting TUXEDO Embedded Controllers. Tested on TUXEDO InfinityBook S 14 Gen6 and 15 Gen6 with EC firmware updates from IBV. Signed-off-by: Michał Żygowski <michal.zygowski(a)3mdeb.com> Signed-off-by: Sergii Dmytruk <sergii.dmytruk(a)3mdeb.com> Change-Id: I0e42260155ffea38a6f60790871cd8da7b657031 --- M Makefile M flashrom.8.tmpl M flashrom.c M programmer.h M programmer_table.c A tuxedo_ec.c A tuxedo_ec.h 7 files changed, 1,058 insertions(+), 1 deletion(-) git pull ssh://review.coreboot.org:29418/flashrom refs/changes/15/55715/1 diff --git a/Makefile b/Makefile index be6e551..1427452 100644 --- a/Makefile +++ b/Makefile @@ -185,6 +185,11 @@ else override CONFIG_MEC1308 = no endif +ifeq ($(CONFIG_TUXEDO_EC), yes) +UNSUPPORTED_FEATURES += CONFIG_TUXEDO_EC=yes +else +override CONFIG_TUXEDO_EC = no +endif ifeq ($(CONFIG_USBBLASTER_SPI), yes) UNSUPPORTED_FEATURES += CONFIG_USBBLASTER_SPI=yes else @@ -291,6 +296,11 @@ else override CONFIG_MEC1308 = no endif +ifeq ($(CONFIG_TUXEDO_EC), yes) +UNSUPPORTED_FEATURES += CONFIG_TUXEDO_EC=yes +else +override CONFIG_TUXEDO_EC = no +endif ifeq ($(CONFIG_NICREALTEK), yes) UNSUPPORTED_FEATURES += CONFIG_NICREALTEK=yes else @@ -396,6 +406,11 @@ else override CONFIG_MEC1308 = no endif +ifeq ($(CONFIG_TUXEDO_EC), yes) +UNSUPPORTED_FEATURES += CONFIG_TUXEDO_EC=yes +else +override CONFIG_TUXEDO_EC = no +endif ifeq ($(CONFIG_USBBLASTER_SPI), yes) UNSUPPORTED_FEATURES += CONFIG_USBBLASTER_SPI=yes else @@ -532,6 +547,11 @@ else override CONFIG_MEC1308 = no endif +ifeq ($(CONFIG_TUXEDO_EC), yes) +UNSUPPORTED_FEATURES += CONFIG_TUXEDO_EC=yes +else +override CONFIG_TUXEDO_EC = no +endif endif # Disable all drivers needing raw access (memory, PCI, port I/O) on @@ -702,6 +722,9 @@ # Microchip MEC1308 Embedded Controller CONFIG_MEC1308 ?= yes +# Embedded Controller of TUXEDO laptops. +CONFIG_TUXEDO_EC ?= yes + # Always enable Altera USB-Blaster dongles for now. CONFIG_USBBLASTER_SPI ?= yes @@ -813,6 +836,7 @@ override CONFIG_IT8212 = no override CONFIG_DRKAISER = no override CONFIG_MEC1308 = no +override CONFIG_TUXEDO_EC = no override CONFIG_NICREALTEK = no override CONFIG_NICNATSEMI = no override CONFIG_NICINTEL = no @@ -874,6 +898,16 @@ FEATURE_CFLAGS += -D'CONFIG_DEFAULT_PROGRAMMER_ARGS="$(CONFIG_DEFAULT_PROGRAMMER_ARGS)"' + +ifeq ($(CONFIG_TUXEDO_EC), yes) +# Disable internal DMI decoder to be able to locate DMI tables on EFI systems and match TUXEDO laptops +override CONFIG_INTERNAL_DMI = no +FEATURE_CFLAGS += -D'CONFIG_TUXEDO_EC=1' -D'CONFIG_INTERNAL_DMI=0' +PROGRAMMER_OBJS += acpi_ec.o tuxedo_ec.o +NEED_RAW_ACCESS += CONFIG_TUXEDO_EC +NEED_LIBPCI += CONFIG_TUXEDO_EC +endif + ifeq ($(CONFIG_INTERNAL), yes) FEATURE_CFLAGS += -D'CONFIG_INTERNAL=1' PROGRAMMER_OBJS += processor_enable.o chipset_enable.o board_enable.o cbtable.o internal.o diff --git a/flashrom.8.tmpl b/flashrom.8.tmpl index 4ae7e71..e086360 100644 --- a/flashrom.8.tmpl +++ b/flashrom.8.tmpl @@ -385,6 +385,8 @@ .sp .BR "* stlinkv3_spi" " (for SPI flash ROMs attached to STMicroelectronics STLINK V3 devices)" .sp +.BR "* tuxedo_ec" " (for Embedded Controller of TUXEDO laptops)" +.sp Some programmers have optional or mandatory parameters which are described in detail in the .B PROGRAMMER-SPECIFIC INFORMATION @@ -645,7 +647,6 @@ .B " flashrom \-p internal:laptop=this_is_not_a_laptop" .sp to tell flashrom (at your own risk) that it is not running on a laptop. -.SS .BR "dummy " programmer .IP The dummy programmer operates on a buffer in memory only. It provides a safe and fast way to test various @@ -1356,6 +1357,63 @@ If the passed frequency is not supported by the adapter the nearest lower supported frequency will be used. .SS +.BR "tuxedo_ec " programmer +.IP +This module supports EC flash programming on TUXEDO laptops. +.IP +An optional +.B portpair +parameter specifies ports to use to read/write EC ROM data. +Syntax is +.sp +.B " flashrom \-p tuxedo_ec:portpair=pairnum" +.sp +where +.B pairnum +can be (data port/control port): +.BR 0 " (0x60/0x64), " 1 " (0x62/0x66), " 2 " (0x68/0x6C) or " 3 " (0x6A/0x6E)." +. The default is 1. +.sp +An optional +.B noaccheck +parameter allows operations with unplugged AC adapter, which is an error +otherwise. +Syntax is +.sp +.B " flashrom \-p tuxedo_ec:noaccheck=yes" +.sp +An optional +.B romsize +parameter specifies size of EC ROM. Syntax is +.sp +.B " flashrom \-p tuxedo_ec:romsize=size" +.sp +where +.B size +can be: +.BR 64K ", " 128K ", " 192K " or " 256K "." +The default value is queried from EC. +.sp +An optional +.B autload +parameter specifies how to treat autoloading. +Syntax is +.sp +.B " flashrom \-p tuxedo_ec:autoload=action" +.sp +where +.B action +can be: +.BR none ", " disable ", " on " or " enable "." +. The default is none. +.sp +An optional +.B ite5570 +parameter enables support of ITE5570. Syntax is +.sp +.B " flashrom \-p tuxedo_ec:ite5570=yes" +.sp +.SS .SH EXAMPLES To back up and update your BIOS, run diff --git a/flashrom.c b/flashrom.c index a1f4710..af97a7c 100644 --- a/flashrom.c +++ b/flashrom.c @@ -39,6 +39,9 @@ #include "programmer.h" #include "hwaccess.h" #include "chipdrivers.h" +#if CONFIG_TUXEDO_EC == 1 +#include "tuxedo_ec.h" +#endif const char flashrom_version[] = FLASHROM_VERSION; const char *chip_to_probe = NULL; @@ -2103,6 +2106,27 @@ msg_cinfo("done.\n"); } +#if CONFIG_TUXEDO_EC == 1 + if (programmer == &programmer_tuxedo_ec) { + int status; + status = tuxedo_ec_verify_file_project(newcontents, curcontents, + flash_size); + if (status == 1) { + ret = 1; + goto _free_ret; + } + if (status == 2) { + if (flashctx->flags.force) { + msg_pinfo("\nProceeding anyway because user forced us to.\n"); + } else { + msg_pinfo(" Skipping...\n"); + ret = 0; + goto _free_ret; + } + } + } +#endif + if (write_by_layout(flashctx, curcontents, newcontents)) { msg_cerr("Uh oh. Erase/write failed. "); ret = 2; diff --git a/programmer.h b/programmer.h index 9d1a9ad..e6e52d0 100644 --- a/programmer.h +++ b/programmer.h @@ -97,6 +97,7 @@ extern const struct programmer_entry programmer_serprog; extern const struct programmer_entry programmer_lspcon_i2c_spi; extern const struct programmer_entry programmer_realtek_mst_i2c_spi; +extern const struct programmer_entry programmer_tuxedo_ec; int programmer_init(const struct programmer_entry *prog, const char *param); int programmer_shutdown(void); diff --git a/programmer_table.c b/programmer_table.c index e7f2c98..d2167eb 100644 --- a/programmer_table.c +++ b/programmer_table.c @@ -171,6 +171,9 @@ #if CONFIG_STLINKV3_SPI == 1 &programmer_stlinkv3_spi, #endif +#if CONFIG_TUXEDO_EC == 1 + &programmer_tuxedo_ec, +#endif }; const size_t programmer_table_size = ARRAY_SIZE(programmer_table); \ No newline at end of file diff --git a/tuxedo_ec.c b/tuxedo_ec.c new file mode 100644 index 0000000..7f4cefc --- /dev/null +++ b/tuxedo_ec.c @@ -0,0 +1,912 @@ +/* + * This file is part of the flashrom project. + * + * Copyright (C) 2021, TUXEDO Computers GmbH + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +/* + * Contains programmer implementation for EC used by TUXEDO laptops. + */ + +#if defined(__i386__) || defined(__x86_64__) + +#include <inttypes.h> +#include <stdlib.h> +#include <string.h> + +#include "chipdrivers.h" +#include "acpi_ec.h" +#include "flashchips.h" +#include "hwaccess.h" +#include "programmer.h" +#include "tuxedo_ec.h" + +#define EC_CMD_ERASE_ALL 0x01 +#define EC_CMD_WRITE_BLOCK 0x02 +#define EC_CMD_READ_BLOCK 0x03 +#define EC_CMD_GET_FLASH_ID 0x04 +#define EC_CMD_ERASE_KBYTE 0x05 +#define EC_CMD_WRITE_KBYTE 0x06 +#define EC_CMD_READ_PRJ 0x92 +#define EC_CMD_READ_VER 0x93 + +#define BYTES_PER_BLOCK (64 * 1024) +#define BYTES_PER_CHUNK 256 +#define KBYTES_PER_BLOCK 64 +#define CHUNKS_PER_KBYTE 4 +#define CHUNKS_PER_BLOCK 256 + +#define INFO_BUFFER_SIZE 16 + +enum autoloadaction { + AUTOLOAD_NO_ACTION, + AUTOLOAD_DISABLE, + AUTOLOAD_SETON, + AUTOLOAD_SETOFF +}; + +/* Need to match a pattern that spans 6 bytes to find patching place */ +enum autoloadseekstate { + AUTOLOAD_NONE, + AUTOLOAD_ONE_BYTE, + AUTOLOAD_TWO_BYTES, + AUTOLOAD_THREE_BYTES, + AUTOLOAD_FOUR_BYTES, + AUTOLOAD_FIVE_BYTES, + AUTOLOAD_SIX_BYTES +}; + +typedef struct +{ + unsigned int rom_size_in_blocks; + unsigned int rom_size_in_kbytes; + + unsigned int autoload_offset; /* meaningful for AUTOLOAD_SIX_BYTES */ + enum autoloadseekstate autoload_state; + enum autoloadaction autload_action; + + uint8_t first_kbyte[CHUNKS_PER_KBYTE * BYTES_PER_CHUNK]; + bool support_ite5570; + uint8_t write_mode; + + uint8_t control_port; + uint8_t data_port; + bool ac_adapter_plugged; +} tuxedo_ec_data_t; + +static bool tuxedo_ec_write_cmd(tuxedo_ec_data_t *ctx_data, uint8_t cmd) +{ + return ec_write_cmd(ctx_data->control_port, cmd); +} + +static bool tuxedo_ec_read_byte(tuxedo_ec_data_t *ctx_data, uint8_t *data) +{ + return ec_read_byte(ctx_data->control_port, ctx_data->data_port, data); +} + +static bool tuxedo_ec_write_byte(tuxedo_ec_data_t *ctx_data, uint8_t data) +{ + return ec_write_byte(ctx_data->control_port, ctx_data->data_port, data); +} + +static int tuxedo_ec_shutdown(void *data) +{ + tuxedo_ec_data_t *ctx_data = (tuxedo_ec_data_t *)data; + int ret = 0; + + if (!tuxedo_ec_write_cmd(ctx_data, 0xfe)) { + msg_perr("Failed to shutdown tuxedo_ec\n"); + ret = 1; + } + + free(data); + + return ret; +} + +static void tuxedo_ec_read_project(tuxedo_ec_data_t *ctx_data) +{ + uint8_t ec_project[INFO_BUFFER_SIZE]; + uint8_t i; + + if (!tuxedo_ec_write_cmd(ctx_data, EC_CMD_READ_PRJ)) { + msg_perr("Failed to write cmd...\n"); + return; + } + + for (i = 0; i < INFO_BUFFER_SIZE - 1; i++) { + if (!tuxedo_ec_read_byte(ctx_data, &ec_project[i])) { + msg_perr("Failed to read EC project\n"); + return; + } + if (ec_project[i] == '$') { + ec_project[i] = '\0'; + break; + } + } + + msg_pinfo("Mainboard EC Project: %s\n", (char *)ec_project); +} + +static void tuxedo_ec_read_version(tuxedo_ec_data_t *ctx_data) +{ + uint8_t ec_version[INFO_BUFFER_SIZE]; + uint8_t i; + + if (!tuxedo_ec_write_cmd(ctx_data, EC_CMD_READ_VER)) { + msg_perr("Failed to write cmd...\n"); + return; + } + + for (i = 0; i < INFO_BUFFER_SIZE - 1; i++) { + if (!tuxedo_ec_read_byte(ctx_data, &ec_version[i])) { + msg_perr("Failed to read EC version\n"); + return; + } + if (ec_version[i] == '$') { + ec_version[i] = '\0'; + break; + } + } + + msg_pinfo("Mainboard EC Version: 1.%s\n", (char *)ec_version); +} + +static bool tuxedo_ec_init_ctx(tuxedo_ec_data_t *ctx_data) +{ + uint8_t reg_value; + + ctx_data->control_port = EC_CONTROL; + ctx_data->data_port = EC_DATA; + + if (!ec_read_reg(0xf9, &reg_value)) { + msg_perr("Failed to query flash ROM size.\n"); + return false; + } + + msg_pdbg("%s: ROM size register value %02x\n", __func__, reg_value); + + if (reg_value == 0xff) { + msg_pwarn("Querying EC ROM size returned unexpected result.\n" + "Probably the EC has just been flashed and the EC " + "RAM has been reset.\nYou may need to pass the flash" + " size via the programmer parameters or try again in" + " a while.\nIf this warning persists please email a " + "report to flashrom(a)flashrom.org\n"); + return false; + } + + switch (reg_value & 0xf0) { + case 0x40: + ctx_data->rom_size_in_blocks = 3; + break; + case 0xf0: + ctx_data->rom_size_in_blocks = 4; + break; + default: + ctx_data->rom_size_in_blocks = 2; + break; + } + + /* flush the EC registers */ + INB(EC_CONTROL); + INB(EC_DATA); + + msg_pdbg("%s: Querying AC adapter state...\n", __func__); + if (!ec_read_reg(0x10, &reg_value)) { + msg_perr("Failed to query first byte of state register.\n"); + return false; + } + if (!ec_read_reg(0x10, &reg_value)) { + msg_perr("Failed to query AC adapter state.\n"); + return false; + } + + msg_pdbg("%s: AC adapter state %02x\n", __func__, reg_value); + + ctx_data->ac_adapter_plugged = reg_value & 0x01; + + ctx_data->rom_size_in_kbytes = + ctx_data->rom_size_in_blocks * KBYTES_PER_BLOCK; + + tuxedo_ec_read_project(ctx_data); + tuxedo_ec_read_version(ctx_data); + + return true; +} + +static int tuxedo_ec_read(struct flashctx *flash, uint8_t *buf, + unsigned int start, unsigned int len) +{ + unsigned int offset, block, block_start, block_end; + uint8_t rom_byte; + tuxedo_ec_data_t *ctx_data = (tuxedo_ec_data_t *)flash->mst->opaque.data; + + /* This EC can read only a whole block. */ + if (len % BYTES_PER_BLOCK != 0 && len < BYTES_PER_BLOCK) { + msg_perr("Incorrect read length %x\n", len); + return 1; + } + + if (start % BYTES_PER_BLOCK != 0) { + msg_perr("Incorrect read region start: %x\n", len); + return 1; + } + + block_start = start / BYTES_PER_BLOCK; + block_end = (start + len) / BYTES_PER_BLOCK; + + if (block_end > ctx_data->rom_size_in_blocks) { + msg_perr("Requested to read block outside of chip boundaries\n"); + return 1; + } + + for (block = block_start; block < block_end; block++) { + if (!tuxedo_ec_write_cmd(ctx_data, EC_CMD_READ_BLOCK) || + !tuxedo_ec_write_cmd(ctx_data, block)) { + msg_perr("Failed to select block to read %d\n", block); + return 1; + } + for (offset = 0; offset < BYTES_PER_BLOCK; ++offset) { + + if (!tuxedo_ec_read_byte(ctx_data, &rom_byte)) { + msg_perr("Flash read failed @ 0x%x\n", offset); + return 1; + } + + *buf = rom_byte; + ++buf; + } + } + + return 0; +} + +static bool tuxedo_ec_write_patched(tuxedo_ec_data_t *ctx_data, unsigned int offset, + uint8_t data) +{ + const bool blocks_1_2 = ctx_data->rom_size_in_blocks == 1 || + ctx_data->rom_size_in_blocks == 2; + + + if (ctx_data->autoload_state != AUTOLOAD_SIX_BYTES) + return tuxedo_ec_write_byte(ctx_data, data); + + switch (ctx_data->autload_action) { + case AUTOLOAD_NO_ACTION: + return tuxedo_ec_write_byte(ctx_data, data); + case AUTOLOAD_DISABLE: + if (offset == ctx_data->autoload_offset + 2) { + data = (blocks_1_2 ? 0x94 : 0x85); + } else if (offset == ctx_data->autoload_offset + 8) { + data = 0x00; + } + break; + case AUTOLOAD_SETON: + if (offset == ctx_data->autoload_offset + 2) { + data = (blocks_1_2 ? 0x94 : 0x85); + } else if (offset == ctx_data->autoload_offset + 8) { + data = (blocks_1_2 ? 0x7f : 0xbe); + } + break; + case AUTOLOAD_SETOFF: + if (offset == ctx_data->autoload_offset + 2) { + data = (blocks_1_2 ? 0xa5 : 0xb5); + } else if (offset == ctx_data->autoload_offset + 8) { + data = 0xaa; + } + break; + } + + return tuxedo_ec_write_byte(ctx_data, data); +} + +static bool tuxedo_ec_write_block(tuxedo_ec_data_t *ctx_data, const uint8_t *buf, + unsigned int block) +{ + const unsigned int param = ctx_data->support_ite5570 ? 0x00 : 0x02; + unsigned int offset = block * BYTES_PER_BLOCK; + unsigned int third_param = param; + unsigned int i; + bool skip_first_kbyte = false; + + /* Required: stash first kilobyte and write it after the last block. */ + if (ctx_data->write_mode != 0 && block == 0) { + memcpy(ctx_data->first_kbyte, buf, CHUNKS_PER_KBYTE * BYTES_PER_CHUNK); + third_param = 0x04; + skip_first_kbyte = true; + } + + if (!tuxedo_ec_write_cmd(ctx_data, EC_CMD_WRITE_BLOCK) || + !tuxedo_ec_write_cmd(ctx_data, param) || + !tuxedo_ec_write_cmd(ctx_data, block) || + !tuxedo_ec_write_cmd(ctx_data, third_param) || + !tuxedo_ec_write_cmd(ctx_data, param)) { + msg_perr("Unable to send block write command.\n"); + return 1; + } + + for (i = 0; i < BYTES_PER_BLOCK; i++, ++offset) { + if (skip_first_kbyte && (i < CHUNKS_PER_KBYTE * BYTES_PER_CHUNK)) + continue; + if (!tuxedo_ec_write_patched(ctx_data, offset, buf[i])){ + msg_perr("Unable to write byte @ 0x%x\n", block * BYTES_PER_BLOCK + i); + return false; + } + } + + /* If we're done, write the first kilobyte separately. */ + if (ctx_data->write_mode != 0 && block == ctx_data->rom_size_in_blocks - 1) { + if (!tuxedo_ec_write_cmd(ctx_data, 0x06)) { + msg_perr("Unable to send kbyte write command.\n"); + return 1; + } + for (i = 0; i < CHUNKS_PER_KBYTE * BYTES_PER_CHUNK; i++) { + if (!tuxedo_ec_write_patched(ctx_data, i, + ctx_data->first_kbyte[i])) { + msg_perr("Unable to write byte @ 0x%04x\n", i); + return false; + } + } + + memset(ctx_data->first_kbyte, 0, CHUNKS_PER_KBYTE * BYTES_PER_CHUNK); + } + + return true; +} + +static void tuxedo_ec_update_autoload_state(tuxedo_ec_data_t *ctx_data, + const uint8_t *buf, + unsigned int start, unsigned int len) +{ + unsigned int i; + unsigned int offset = start; + + if (ctx_data->autload_action == AUTOLOAD_NO_ACTION || + ctx_data->autoload_state == AUTOLOAD_SIX_BYTES) + return; + + for (i = 0; i < len; ++i, ++offset) { + switch (ctx_data->autoload_state) { + case AUTOLOAD_NONE: + if (buf[i] != 0xa5) + break; + ctx_data->autoload_state = AUTOLOAD_ONE_BYTE; + ctx_data->autoload_offset = offset; + continue; + case AUTOLOAD_ONE_BYTE: + if (offset - ctx_data->autoload_offset != 1) + break; + if (buf[i] != 0xa5 && buf[i] != 0xa4) + break; + ctx_data->autoload_state = AUTOLOAD_TWO_BYTES; + continue; + case AUTOLOAD_TWO_BYTES: + if (offset - ctx_data->autoload_offset != 2) + break; + ctx_data->autoload_state = AUTOLOAD_THREE_BYTES; + continue; + case AUTOLOAD_THREE_BYTES: + if (offset - ctx_data->autoload_offset != 3) + break; + ctx_data->autoload_state = AUTOLOAD_FOUR_BYTES; + continue; + case AUTOLOAD_FOUR_BYTES: + if (offset - ctx_data->autoload_offset != 4) + break; + ctx_data->autoload_state = AUTOLOAD_FIVE_BYTES; + continue; + case AUTOLOAD_FIVE_BYTES: + if (offset - ctx_data->autoload_offset != 5) + break; + if (buf[i] != 0x5a) + break; + ctx_data->autoload_state = AUTOLOAD_SIX_BYTES; + continue; + case AUTOLOAD_SIX_BYTES: + /* Done matching. */ + return; + } + + ctx_data->autoload_state = AUTOLOAD_NONE; + } +} + +static int tuxedo_ec_write(struct flashctx *flash, const uint8_t *buf, + unsigned int start, unsigned int len) +{ + tuxedo_ec_data_t *ctx_data = (tuxedo_ec_data_t *)flash->mst->opaque.data; + unsigned int block_start; + unsigned int block_end; + unsigned int block; + + /* This EC can write only a whole block. */ + if (len % BYTES_PER_BLOCK != 0 && len < BYTES_PER_BLOCK) { + msg_perr("Incorrect write length %x\n", len); + return 1; + } + + if (start % BYTES_PER_BLOCK != 0) { + msg_perr("Incorrect write region start: %x\n", len); + return 1; + } + + block_start = start / BYTES_PER_BLOCK; + block_end = (start + len) / BYTES_PER_BLOCK; + + if (block_end > ctx_data->rom_size_in_blocks) { + msg_perr("Requested to write block outside of chip boundaries\n"); + return 1; + } + + tuxedo_ec_update_autoload_state(ctx_data, buf, start, len); + + for (block = block_start; block < block_end; block++) { + if (!tuxedo_ec_write_block(ctx_data, + buf + (BYTES_PER_BLOCK * block), + block)) { + msg_perr("Unable to write full block.\n"); + return 1; + } + } + + return 0; +} + +static int tuxedo_ec_full_erase(tuxedo_ec_data_t *ctx_data) +{ + unsigned int i; + + if (!tuxedo_ec_write_cmd(ctx_data, EC_CMD_ERASE_ALL) || + !tuxedo_ec_write_cmd(ctx_data, 0x00) || + !tuxedo_ec_write_cmd(ctx_data, 0x00) || + !tuxedo_ec_write_cmd(ctx_data, 0x00) || + !tuxedo_ec_write_cmd(ctx_data, 0x00)) + return 1; + + if (ctx_data->rom_size_in_blocks < 3) { + internal_sleep(15000 * 64); + return 0; + } + + for (i = 0; i < 4; i++) { + if (!ec_wait_for_obuf(ctx_data->control_port, + EC_MAX_STATUS_CHECKS * 3)) + return 1; + + if (INB(ctx_data->data_port) == 0xf8) + return 0; + } + + internal_sleep(100000); + + return 1; +} + +static int tuxedo_ec_chunkwise_erase(tuxedo_ec_data_t *ctx_data, + unsigned int start, unsigned int len) +{ + const unsigned int from_chunk = start / BYTES_PER_CHUNK; + const unsigned int end = start + len; + unsigned int to_chunk = end / BYTES_PER_CHUNK; + unsigned int i; + + if (end % BYTES_PER_CHUNK != 0) + ++to_chunk; + + if (to_chunk / CHUNKS_PER_BLOCK > ctx_data->rom_size_in_blocks) { + msg_perr("Requested to erase block outside of chip boundaries\n"); + return 1; + } + + for (i = from_chunk; i < to_chunk; i += CHUNKS_PER_KBYTE) { + if (!tuxedo_ec_write_cmd(ctx_data, EC_CMD_ERASE_KBYTE) || + !tuxedo_ec_write_cmd(ctx_data, i / CHUNKS_PER_BLOCK) || + !tuxedo_ec_write_cmd(ctx_data, i % CHUNKS_PER_BLOCK) || + !tuxedo_ec_write_cmd(ctx_data, 0x00)) { + msg_perr("Failed to erase chunk %d\n", i); + return 1; + } + + internal_sleep(1000); + } + + internal_sleep(100000); + return 0; +} + +static int tuxedo_ec_erase(struct flashctx *flash, unsigned int blockaddr, + unsigned int blocklen) +{ + tuxedo_ec_data_t *ctx_data = (tuxedo_ec_data_t *)flash->mst->opaque.data; + + /* This EC can erase only a whole block */ + if (blocklen % BYTES_PER_BLOCK != 0 && blocklen < BYTES_PER_BLOCK) { + msg_perr("Incorrect erase legnth %x\n", blocklen); + return 1; + } + + if (ctx_data->support_ite5570) + return tuxedo_ec_chunkwise_erase(ctx_data, blockaddr, blocklen); + + return tuxedo_ec_full_erase(ctx_data); +} + + +static int tuxedo_ec_probe(struct flashctx *flash) +{ + tuxedo_ec_data_t *ctx_data = (tuxedo_ec_data_t *)flash->mst->opaque.data; + + flash->chip->tested = TEST_OK_PREW; + flash->chip->page_size = BYTES_PER_BLOCK; + flash->chip->total_size = ctx_data->rom_size_in_kbytes; + /* This EC supports only write granularity of 64K */ + flash->chip->gran = write_gran_64kbytes; + /* + * Erase operation must be done in one sway. + * So report an eraser for the whole chip size. + */ + flash->chip->block_erasers[0].eraseblocks[0].size = + ctx_data->rom_size_in_blocks * BYTES_PER_BLOCK; + flash->chip->block_erasers[0].eraseblocks[0].count = 1; + + return 1; +} + +static struct opaque_master programmer_opaque_tuxedo_ec = { + .max_data_read = BYTES_PER_BLOCK, + .max_data_write = BYTES_PER_BLOCK, + .probe = tuxedo_ec_probe, + .read = tuxedo_ec_read, + .write = tuxedo_ec_write, + .erase = tuxedo_ec_erase, +}; + +static bool tuxedo_ec_check_params(tuxedo_ec_data_t *ctx_data) +{ + char *p; + bool ret = true; + + msg_pdbg("%s()\n", __func__); + + p = extract_programmer_param("type"); + if (p && strcmp(p, "ec")) { + msg_pdbg("%s(): tuxedo_ec only supports \"ec\" type devices\n", + __func__); + ret = false; + } + free(p); + + p = extract_programmer_param("noaccheck"); + if (p && strcmp(p, "yes") == 0) { + /* Just mark it as present. */ + ctx_data->ac_adapter_plugged = true; + } + free(p); + + p = extract_programmer_param("ite5570"); + if (p && strcmp(p, "yes") == 0) { + ctx_data->support_ite5570 = true; + } + free(p); + + p = extract_programmer_param("portpair"); + if (p) { + if (!strcmp(p, "0")) { + ctx_data->control_port = 0x64; + ctx_data->data_port = 0x60; + } else if (!strcmp(p, "1")) { + ctx_data->control_port = 0x66; + ctx_data->data_port = 0x62; + } else if (!strcmp(p, "2")) { + ctx_data->control_port = 0x6c; + ctx_data->data_port = 0x68; + } else if (!strcmp(p, "3")) { + ctx_data->control_port = 0x6e; + ctx_data->data_port = 0x6a; + } else { + msg_pdbg("%s(): incorrect portpair param value: %s\n", + __func__, p); + ret = false; + } + } + free(p); + + p = extract_programmer_param("autoload"); + if (p) { + if (!strcmp(p, "none")) { + ctx_data->autload_action = AUTOLOAD_NO_ACTION; + } else if (!strcmp(p, "disable")) { + ctx_data->autload_action = AUTOLOAD_DISABLE; + } else if (!strcmp(p, "on")) { + ctx_data->autload_action = AUTOLOAD_SETON; + } else if (!strcmp(p, "off")) { + ctx_data->autload_action = AUTOLOAD_SETOFF; + } else { + msg_pdbg("%s(): incorrect autoload param value: %s\n", + __func__, p); + ret = false; + } + } + free(p); + + p = extract_programmer_param("romsize"); + if (p) { + if (!strcmp(p, "64K")) { + ctx_data->rom_size_in_blocks = 1; + } else if (!strcmp(p, "128K")) { + ctx_data->rom_size_in_blocks = 2; + } else if (!strcmp(p, "192K")) { + ctx_data->rom_size_in_blocks = 3; + } else if (!strcmp(p, "256K")) { + ctx_data->rom_size_in_blocks = 4; + } else { + msg_pdbg("%s(): incorrect romsize param value: %s\n", + __func__, p); + ret = false; + } + + ctx_data->rom_size_in_kbytes = + ctx_data->rom_size_in_blocks * KBYTES_PER_BLOCK; + } + free(p); + + return ret; +} + +static void get_flash_part_from_id(tuxedo_ec_data_t *ctx_data, uint32_t manuf_id, + uint32_t model_id) +{ + const struct flashchip *chip; + const char *vendor = NULL; + const char *device = NULL; + for (chip = flashchips; chip && chip->name; chip++) { + if (chip->manufacture_id == manuf_id) { + vendor = chip->vendor; + if (chip->model_id == model_id) { + device = chip->name; + break; + } + } + } + + if (vendor && device) + msg_pinfo("Found %s flash chip \"%s\" (%d kB).\n", + chip->vendor, chip->name, chip->total_size); + else if (vendor) + msg_pinfo("Found unknown %s flash chip\n", vendor); +} + +static void tuxedo_ec_read_flash_id(tuxedo_ec_data_t *ctx_data) +{ + + uint8_t rom_data[4]; + unsigned int id_length, i; + uint32_t model_id; + + tuxedo_ec_write_cmd(ctx_data, EC_CMD_GET_FLASH_ID); + + id_length = 3; + if (ctx_data->rom_size_in_blocks == 3 || + ctx_data->rom_size_in_blocks == 4) + id_length = 4; + + for (i = 0; i < id_length; i++) + tuxedo_ec_read_byte (ctx_data, &rom_data[i]); + + msg_pinfo("Flash Part ID: "); + for (i = 0; i < id_length; i++) + msg_pinfo("%02x ", rom_data[i]); + + msg_pinfo("\n"); + + model_id = rom_data[1] | ((uint32_t)rom_data[2] << 8); + if (id_length == 4) + model_id |= ((uint32_t)rom_data[3] << 16); + + get_flash_part_from_id(ctx_data, rom_data[0], model_id); +} + +static int tuxedo_ec_init(void) +{ + bool read_success; + tuxedo_ec_data_t *ctx_data = NULL; + + if (rget_io_perms()) + return 1; + + dmi_init(); + + if (!dmi_match("^TUXEDO$")) { + msg_perr("Not a TUXEDO device\n"); + return 1; + } + + if (!dmi_match("^InfinityBook S 14 Gen6$") && + !dmi_match("^InfinityBook S 15 Gen6$")) { + msg_perr("TUXEDO EC programmer not yet supported on this laptop\n"); + return 1; + } + + if (!ec_write_reg(0xf9, 0x20) || + !ec_write_reg(0xfa, 0x02) || + !ec_write_reg(0xfb, 0x00) || + !ec_write_reg(0xf8, 0xb1)) { + msg_perr("Unable to initialize controller.\n"); + return 1; + } + + ctx_data = calloc(1, sizeof(tuxedo_ec_data_t)); + if (!ctx_data) { + msg_perr("Unable to allocate space for extra context data.\n"); + return 1; + } + + if (!tuxedo_ec_init_ctx(ctx_data)) + goto tuxedo_ec_init_exit; + + if (!tuxedo_ec_check_params(ctx_data)) + goto tuxedo_ec_init_exit; + + if (!tuxedo_ec_write_cmd(ctx_data, 0xde) || + !tuxedo_ec_write_cmd(ctx_data, 0xdc)) { + msg_perr("%s(): failed to prepare controller\n", __func__); + goto tuxedo_ec_init_exit; + } + + if (!tuxedo_ec_write_cmd(ctx_data, 0xf0)) { + msg_perr("Failed to write identification commands.\n"); + goto tuxedo_ec_init_exit_shutdown; + } + + read_success = tuxedo_ec_read_byte(ctx_data, &ctx_data->write_mode); + msg_pdbg("%s(): write mode %02x\n", __func__, ctx_data->write_mode); + if (read_success && ctx_data->write_mode != 0x00 && + ctx_data->write_mode != 0xff) { + msg_pdbg("%s(): selecting ITE5570 support\n", __func__); + ctx_data->support_ite5570 = true; + } else { + ctx_data->write_mode = 0; + } + + tuxedo_ec_read_flash_id(ctx_data); + + if (!ctx_data->ac_adapter_plugged) { + msg_perr("AC adapter is not plugged.\n"); + goto tuxedo_ec_init_exit_shutdown; + } + + programmer_opaque_tuxedo_ec.data = ctx_data; + + if (register_shutdown(tuxedo_ec_shutdown, ctx_data)) + goto tuxedo_ec_init_exit_shutdown; + if (register_opaque_master(&programmer_opaque_tuxedo_ec, ctx_data)) + return 1; + + msg_pdbg("%s(): successfully initialized tuxedo_ec\n", __func__); + return 0; + +tuxedo_ec_init_exit: + tuxedo_ec_shutdown(ctx_data); + return 1; + +tuxedo_ec_init_exit_shutdown: + tuxedo_ec_shutdown(ctx_data); + return 1; +} + +static void copy_version_string(uint8_t *const contents, char *buf) +{ + size_t i; + + for (i = 0; i < INFO_BUFFER_SIZE - 1; i++) { + buf[i] = contents[i]; + if (buf[i] == '$') { + buf[i] = '\0'; + break; + } + } +} + +/** + * @brief Checks the current and file's EC project and version. + * + * Retrieves the EC project and version from the file and current flash + * contents. Compares both values and returns the action to take by flashrom. + * If any of the EC project or EC version is nto found, return one (failure). + * Ifthe EC project from the flas hdump and the firmware file does not match + * return one (failure). If the current and the file's EC version is identical, + * return two (skip flashing). Otherwise return zero to tell flashrom to + * proceed with write. + * + * @param newcontents The contents of the file to be flashed. + * @param curcontents Contects dumped from the EC flash. + * @return 0 on success, 1 on failure, 2 when flashing shall be skipped + */ +int tuxedo_ec_verify_file_project(uint8_t *const newcontents, + uint8_t *const curcontents, + const size_t flash_size) +{ + char current_ec_project[INFO_BUFFER_SIZE]; + char new_ec_project[INFO_BUFFER_SIZE]; + char current_ec_version[INFO_BUFFER_SIZE]; + char new_ec_version[INFO_BUFFER_SIZE]; + size_t new_prj_offset = 0; + size_t cur_prj_offset = 0; + size_t new_ver_offset = 0; + size_t cur_ver_offset = 0; + size_t i; + + for (i = 0; i < flash_size - 4; i++) { + if (!strncmp((char *)&newcontents[i], "PRJ:", 4)) + new_prj_offset = i + 4; + if (!strncmp((char *)&curcontents[i], "PRJ:", 4)) + cur_prj_offset = i + 4; + if (!strncmp((char *)&newcontents[i], "VER:", 4)) + new_ver_offset = i + 4; + if (!strncmp((char *)&curcontents[i], "VER:", 4)) + cur_ver_offset = i + 4; + } + + if (new_prj_offset == 0) { + msg_perr("EC project not found in the file"); + return 1; + } + + if (cur_prj_offset == 0) { + msg_perr("EC project not found in the flash content"); + return 1; + } + + if (new_ver_offset == 0) { + msg_perr("EC version not found in the file"); + return 1; + } + + if (cur_ver_offset == 0) { + msg_perr("EC version not found in the flash content"); + return 1; + } + + copy_version_string(&newcontents[new_prj_offset], new_ec_project); + copy_version_string(&newcontents[new_ver_offset], new_ec_version); + copy_version_string(&curcontents[cur_prj_offset], current_ec_project); + copy_version_string(&curcontents[cur_ver_offset], current_ec_version); + + msg_pdbg("Current EC project: %s, EC version: %s\n", current_ec_project, + current_ec_version); + msg_pdbg("New EC project: %s, EC version: %s\n", new_ec_project, + new_ec_version); + + if (strcmp(current_ec_project, new_ec_project)) { + msg_perr("Wrong EC project. This file can't be used on this machine\n"); + return 1; + } + + if (!strcmp(current_ec_version, new_ec_version)) { + msg_pinfo("The EC firmware version is identical to the requested image."); + return 2; + } + + return 0; +} + +const struct programmer_entry programmer_tuxedo_ec = { + .name = "tuxedo_ec", + .type = OTHER, + .devs.note = "Embedded Controller of TUXEDO laptops.\n", + .init = tuxedo_ec_init, + .map_flash_region = fallback_map, + .unmap_flash_region = fallback_unmap, + .delay = internal_delay, +}; +#endif diff --git a/tuxedo_ec.h b/tuxedo_ec.h new file mode 100644 index 0000000..b64d726 --- /dev/null +++ b/tuxedo_ec.h @@ -0,0 +1,25 @@ +/* + * This file is part of the flashrom project. + * + * Copyright (C) 2021, TUXEDO Computers GmbH + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#if defined(__i386__) || defined(__x86_64__) + +#include <stdint.h> +#include <stddef.h> + +int tuxedo_ec_verify_file_project(uint8_t *const newcontents, + uint8_t *const curcontents, + const size_t flash_size); + +#endif -- To view, visit https://review.coreboot.org/c/flashrom/+/55715 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: I0e42260155ffea38a6f60790871cd8da7b657031 Gerrit-Change-Number: 55715 Gerrit-PatchSet: 1 Gerrit-Owner: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-MessageType: newchange

1 0

Change in flashrom[master]: acpi_ec: Implement basic ACPI embedded controller API
by Michał Żygowski (Code Review) 21 Jun '21

21 Jun '21

Michał Żygowski has uploaded this change for review. ( https://review.coreboot.org/c/flashrom/+/55714 ) Change subject: acpi_ec: Implement basic ACPI embedded controller API ...................................................................... acpi_ec: Implement basic ACPI embedded controller API Implement basic functions to read/write EC registers and send standard ACPI EC commands. Those may prove useful in possible future implementations of embedded eontrollers in flashrom and are required to support EC firmware flashing on Tuxedo laptops. Signed-off-by: Michał Żygowski <michal.zygowski(a)3mdeb.com> Signed-off-by: Sergii Dmytruk <sergii.dmytruk(a)3mdeb.com> Change-Id: Ie3bae8d81c80ae2f286b619e974869e3f2f4545d --- A acpi_ec.c A acpi_ec.h 2 files changed, 158 insertions(+), 0 deletions(-) git pull ssh://review.coreboot.org:29418/flashrom refs/changes/14/55714/1 diff --git a/acpi_ec.c b/acpi_ec.c new file mode 100644 index 0000000..f51b763 --- /dev/null +++ b/acpi_ec.c @@ -0,0 +1,106 @@ +/* + * This file is part of the flashrom project. + * + * Copyright (C) 2021, TUXEDO Computers GmbH + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include <stdbool.h> +#include <stdint.h> + +#include "acpi_ec.h" +#include "flash.h" +#include "hwaccess.h" + +bool ec_wait_for_ibuf(uint8_t control_port) +{ + unsigned int i; + + for (i = 0; (INB(control_port) & EC_STS_IBF) != 0; ++i) { + if (i == EC_MAX_STATUS_CHECKS) + return false; + } + + return true; +} + +bool ec_wait_for_obuf(uint8_t control_port, unsigned int max_checks) +{ + unsigned int i; + + for (i = 0; (INB(control_port) & EC_STS_OBF) == 0; ++i) { + if (i == max_checks) + return false; + } + + return true; +} + +bool ec_write_cmd(uint8_t control_port, uint8_t cmd) +{ + const bool success = ec_wait_for_ibuf(control_port); + if (success) + OUTB(cmd, control_port); + + return success; +} + +bool ec_read_byte(uint8_t control_port, uint8_t data_port, uint8_t *data) +{ + const bool success = ec_wait_for_obuf(control_port, EC_MAX_STATUS_CHECKS); + if (success) + *data = INB(data_port); + + return success; +} + +bool ec_write_byte(uint8_t control_port, uint8_t data_port, uint8_t data) +{ + const bool success = ec_wait_for_ibuf(control_port); + if (success) + OUTB(data, data_port); + + return success; +} + +bool ec_read_reg(uint8_t address, uint8_t *data) +{ + if (!ec_wait_for_ibuf(EC_CONTROL)) + return false; + OUTB(EC_CMD_READ_REG, EC_CONTROL); + + if (!ec_wait_for_ibuf(EC_CONTROL)) + return false; + OUTB(address, EC_DATA); + + if (!ec_wait_for_ibuf(EC_CONTROL)) + return false; + *data = INB(EC_DATA); + + return true; +} + +bool ec_write_reg(uint8_t address, uint8_t data) +{ + if (!ec_wait_for_ibuf(EC_CONTROL)) + return false; + OUTB(EC_CMD_WRITE_REG, EC_CONTROL); + + if (!ec_wait_for_ibuf(EC_CONTROL)) + return false; + OUTB(address, EC_DATA); + + if (!ec_wait_for_ibuf(EC_CONTROL)) + return false; + OUTB(data, EC_DATA); + + return true; +} diff --git a/acpi_ec.h b/acpi_ec.h new file mode 100644 index 0000000..001d407 --- /dev/null +++ b/acpi_ec.h @@ -0,0 +1,52 @@ +/* + * This file is part of the flashrom project. + * + * Copyright (C) 2021, TUXEDO Computers GmbH + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __EC_H__ +#define __EC_H__ 1 + +#include <stdbool.h> +#include <stdint.h> + +/* + * Generic IO functions for ACPI-compliant embedded controllers + */ + +/* Standard ports */ +#define EC_DATA 0x62 +#define EC_CONTROL 0x66 /* Read status, write commands */ + +/* Standard commands */ +#define EC_CMD_READ_REG 0x80 /* Read register's value */ +#define EC_CMD_WRITE_REG 0x81 /* Write register's value */ + +/* Some of the status bits */ +#define EC_STS_IBF (1 << 1) /* EC's input buffer full (host can't write) */ +#define EC_STS_OBF (1 << 0) /* EC's output buffer full (host can read) */ + +/* How many iterations to wait for input or output buffer */ +#define EC_MAX_STATUS_CHECKS 100000 + +bool ec_wait_for_ibuf(uint8_t control_port); +bool ec_wait_for_obuf(uint8_t control_port, unsigned int max_checks); + +bool ec_write_cmd(uint8_t control_port, uint8_t cmd); +bool ec_read_byte(uint8_t control_port, uint8_t data_port, uint8_t *data); +bool ec_write_byte(uint8_t control_port, uint8_t data_port, uint8_t data); + +/* These implement standard ACPI commands and thus use standard ports */ +bool ec_read_reg(uint8_t address, uint8_t *data); +bool ec_write_reg(uint8_t address, uint8_t data); + +#endif /* !__EC_H__ */ -- To view, visit https://review.coreboot.org/c/flashrom/+/55714 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: Ie3bae8d81c80ae2f286b619e974869e3f2f4545d Gerrit-Change-Number: 55714 Gerrit-PatchSet: 1 Gerrit-Owner: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-MessageType: newchange

1 0

Change in flashrom[master]: flashrom.c: Add 64KB write granularity
by Michał Żygowski (Code Review) 21 Jun '21

21 Jun '21

Michał Żygowski has uploaded this change for review. ( https://review.coreboot.org/c/flashrom/+/55713 ) Change subject: flashrom.c: Add 64KB write granularity ...................................................................... flashrom.c: Add 64KB write granularity Add 64 KB write granularity for the incoming Embedded Controller of Tuxedo laptops. These ECs can only operate on 64KB blocks and any different operations result in a failure. Signed-off-by: Michał Żygowski <michal.zygowski(a)3mdeb.com> Change-Id: I69801f581d0cb9b85f6596de7e1267ef9317673f --- M flash.h M flashrom.c 2 files changed, 7 insertions(+), 0 deletions(-) git pull ssh://review.coreboot.org:29418/flashrom refs/changes/13/55713/1 diff --git a/flash.h b/flash.h index dd8e156..5f973d0 100644 --- a/flash.h +++ b/flash.h @@ -88,6 +88,7 @@ write_gran_528bytes, /* If less than 528 bytes are written, the unwritten bytes are undefined. */ write_gran_1024bytes, /* If less than 1024 bytes are written, the unwritten bytes are undefined. */ write_gran_1056bytes, /* If less than 1056 bytes are written, the unwritten bytes are undefined. */ + write_gran_64kbytes, /* If less than 64 kbytes are written, the unwritten bytes are undefined. */ write_gran_1byte_implicit_erase, /* EEPROMs and other chips with implicit erase and 1-byte writes. */ }; diff --git a/flashrom.c b/flashrom.c index 90e1864..a1f4710 100644 --- a/flashrom.c +++ b/flashrom.c @@ -502,6 +502,9 @@ case write_gran_1056bytes: result = need_erase_gran_bytes(have, want, len, 1056, erased_value); break; + case write_gran_64kbytes: + result = need_erase_gran_bytes(have, want, len, 1024 * 64, erased_value); + break; case write_gran_1byte_implicit_erase: /* Do not erase, handle content changes from anything->0xff by writing 0xff. */ result = 0; @@ -571,6 +574,9 @@ case write_gran_1056bytes: stride = 1056; break; + case write_gran_64kbytes: + stride = 1024 * 64; + break; default: msg_cerr("%s: Unsupported granularity! Please report a bug at " "flashrom(a)flashrom.org\n", __func__); -- To view, visit https://review.coreboot.org/c/flashrom/+/55713 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: I69801f581d0cb9b85f6596de7e1267ef9317673f Gerrit-Change-Number: 55713 Gerrit-PatchSet: 1 Gerrit-Owner: Michał Żygowski <michal.zygowski(a)3mdeb.com> Gerrit-MessageType: newchange

1 0

Change in flashrom[master]: ft2232_spi.c: Implement spi_send_multicommand()
by Angel Pons (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Simon Buhrow, Nico Huber, Edward O'Callaghan, Anastasia Klimchuk, Samir Ibradžić. Angel Pons has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/40477 ) Change subject: ft2232_spi.c: Implement spi_send_multicommand() ...................................................................... Patch Set 34: Code-Review+1 (6 comments) File ft2232_spi.c: https://review.coreboot.org/c/flashrom/+/40477/comment/f4bd210b_3c545e91 PS34, Line 283: const size_t cmd_len = 3; /* same length for any ft2232 command */ > If it is always the same, maybe it can be #define above? I don't think it's necessary, as the literal value is never used outside of this function. It's implicitly used when filling in the commands: statements that assign a value to `buf[i++]` always appear in groups of three. https://review.coreboot.org/c/flashrom/+/40477/comment/c73746fa_5c8df5f1 PS34, Line 300: int i = 0, ret = 0; Shouldn't `i` be `unsigned int` or `size_t`? size_t i = 0; int ret = 0; https://review.coreboot.org/c/flashrom/+/40477/comment/2af1b50a_dbf15566 PS34, Line 307: 65536 hmmm, max_data_write is 256 https://review.coreboot.org/c/flashrom/+/40477/comment/a93a71b9_df4d9274 PS34, Line 311: Out of memory! `Out of memory!` is usually printed when a malloc() or similar function fails. To avoid confusion, I'd use a different message, e.g. `FTDI command does not fit` (suggestions welcome). https://review.coreboot.org/c/flashrom/+/40477/comment/051d8f8a_9397ab80 PS34, Line 317: nit: no space between unary operators: buf[i++] = ~0x08 & spi_data->pinlvl; /* assert CS (3rd) bit only */ https://review.coreboot.org/c/flashrom/+/40477/comment/90cf9385_3ac1509d PS34, Line 349: /* send_buf */ I'd say this comment is redundant, and would remove it -- To view, visit https://review.coreboot.org/c/flashrom/+/40477 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: Ie4a07499ec5ef0af23818593f45dc427285a9e8a Gerrit-Change-Number: 40477 Gerrit-PatchSet: 34 Gerrit-Owner: Simon Buhrow Gerrit-Reviewer: Alan Green <avg(a)google.com> Gerrit-Reviewer: Anastasia Klimchuk <aklm(a)chromium.org> Gerrit-Reviewer: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Reviewer: Edward O'Callaghan <quasisec(a)chromium.org> Gerrit-Reviewer: Nico Huber <nico.h(a)gmx.de> Gerrit-Reviewer: Samir Ibradžić <sibradzic(a)gmail.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Patrick Georgi <pgeorgi(a)google.com> Gerrit-CC: Paul Menzel <paulepanter(a)mailbox.org> Gerrit-Attention: Simon Buhrow Gerrit-Attention: Nico Huber <nico.h(a)gmx.de> Gerrit-Attention: Edward O'Callaghan <quasisec(a)chromium.org> Gerrit-Attention: Anastasia Klimchuk <aklm(a)chromium.org> Gerrit-Attention: Samir Ibradžić <sibradzic(a)gmail.com> Gerrit-Comment-Date: Mon, 21 Jun 2021 08:36:39 +0000 Gerrit-HasComments: Yes Gerrit-Has-Labels: Yes Comment-In-Reply-To: Anastasia Klimchuk <aklm(a)chromium.org> Gerrit-MessageType: comment

1 0

Change in flashrom[master]: tests: Add unit test to run init/shutdown for mec1308.c, ene_lpc.c
by Angel Pons (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Anastasia Klimchuk. Angel Pons has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/51487 ) Change subject: tests: Add unit test to run init/shutdown for mec1308.c, ene_lpc.c ...................................................................... Patch Set 19: (1 comment) File hwaccess_x86_io_unittest.h: https://review.coreboot.org/c/flashrom/+/51487/comment/edc62d96_184321ad PS19, Line 41: #include <sys/io.h> Inclusion of this header in hwaccess_x86_io.h is guarded by `defined(__linux__) || defined(__GLIBC__)`. -- To view, visit https://review.coreboot.org/c/flashrom/+/51487 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: I3af612defe1af3850dfc1626a208d873e3a3eddc Gerrit-Change-Number: 51487 Gerrit-PatchSet: 19 Gerrit-Owner: Anastasia Klimchuk <aklm(a)chromium.org> Gerrit-Reviewer: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Reviewer: Edward O'Callaghan <quasisec(a)chromium.org> Gerrit-Reviewer: Nico Huber <nico.h(a)gmx.de> Gerrit-Reviewer: Simon Glass <sjg(a)chromium.org> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Paul Menzel <paulepanter(a)mailbox.org> Gerrit-Attention: Anastasia Klimchuk <aklm(a)chromium.org> Gerrit-Comment-Date: Mon, 21 Jun 2021 08:25:34 +0000 Gerrit-HasComments: Yes Gerrit-Has-Labels: No Gerrit-MessageType: comment

1 0

Change in flashrom[master]: ft2232_spi: Normalize error paths in ft2232_shutdown()
by Anastasia Klimchuk (Code Review) 21 Jun '21

21 Jun '21

Attention is currently required from: Alan Green, Nico Huber. Anastasia Klimchuk has posted comments on this change. ( https://review.coreboot.org/c/flashrom/+/55696 ) Change subject: ft2232_spi: Normalize error paths in ft2232_shutdown() ...................................................................... Patch Set 1: Code-Review+2 -- To view, visit https://review.coreboot.org/c/flashrom/+/55696 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: flashrom Gerrit-Branch: master Gerrit-Change-Id: I5158d06127a9a8934b083e48b69d29c4d5a11831 Gerrit-Change-Number: 55696 Gerrit-PatchSet: 1 Gerrit-Owner: Nico Huber <nico.h(a)gmx.de> Gerrit-Reviewer: Alan Green <avg(a)google.com> Gerrit-Reviewer: Anastasia Klimchuk <aklm(a)chromium.org> Gerrit-Reviewer: Angel Pons <th3fanbus(a)gmail.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Attention: Alan Green <avg(a)google.com> Gerrit-Attention: Nico Huber <nico.h(a)gmx.de> Gerrit-Comment-Date: Mon, 21 Jun 2021 06:58:49 +0000 Gerrit-HasComments: No Gerrit-Has-Labels: Yes Gerrit-MessageType: comment

1 0

2024

2023

2022

2021

2020

2019

2018

2017

flashrom-gerrit June 2021