summaryrefslogtreecommitdiff
path: root/util/ich9utils/src/gbe
diff options
context:
space:
mode:
authorLeah Rowe <leah@libreboot.org>2023-04-08 03:14:48 +0100
committerLeah Rowe <leah@libreboot.org>2023-04-08 18:36:50 +0100
commiteb9d06304049ca03e4d00c81b43fb996d8424a1f (patch)
tree367193972648607d31f502a5be7b2047ae6fc5e0 /util/ich9utils/src/gbe
parent58e12063c72b7b2a7f4bb2c0c9e71b467d41d2c1 (diff)
add ich9utils back to utils
don't download it. keep it in lbmk. libreboot moved to codeberg for git hosting, and i didn't want to keep lugging around an extra git repo just for one tiny project.
Diffstat (limited to 'util/ich9utils/src/gbe')
-rw-r--r--util/ich9utils/src/gbe/gbe.c748
-rw-r--r--util/ich9utils/src/gbe/gbe.h436
2 files changed, 1184 insertions, 0 deletions
diff --git a/util/ich9utils/src/gbe/gbe.c b/util/ich9utils/src/gbe/gbe.c
new file mode 100644
index 00000000..31535f94
--- /dev/null
+++ b/util/ich9utils/src/gbe/gbe.c
@@ -0,0 +1,748 @@
+/*
+ * gbe/gbe.c
+ * This file is part of the ich9deblob utility from the libreboot project
+ *
+ * Copyright (C) 2014 Steve Shenton <sgsit@libreboot.org>
+ * 2014,2019 Leah Rowe <info@minifree.org>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Provide gbe related functions.
+ */
+
+/* structs describing the data from gbe region */
+#include "gbe.h"
+
+/*
+ * ---------------------------------------------------------------------
+ * Gbe functions:
+ * ---------------------------------------------------------------------
+ */
+
+/* gbe checksum calculation (algorithm based on datasheet) */
+uint16_t gbeGetChecksumFrom4kBuffer(uint16_t* gbeWord, uint16_t desiredValue, int gbeRegionBase)
+{
+ int wordOffset;
+ uint16_t total = 0;
+
+ for (wordOffset = 0; wordOffset < 0x3F; wordOffset++)
+ total += gbeWord[wordOffset + (gbeRegionBase>>1)];
+
+ return desiredValue - total;
+}
+
+/* checksum calculation for 4k gbe struct (algorithm based on datasheet) */
+uint16_t gbeGetChecksumFrom4kStruct(struct GBEREGIONRECORD_4K gbeStruct4k, uint16_t desiredValue)
+{
+ return gbeGetChecksumFrom4kBuffer((uint16_t*)&gbeStruct4k, desiredValue, 0);
+}
+
+/* modify the gbe region extracted from a factory.rom dump */
+struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8K gbeStruct8k)
+{
+ unsigned int i;
+
+ /*
+ * http://www.intel.co.uk/content/dam/doc/application-note/82573-nvm-map-appl-note.pdf
+ * That is a datasheet for a later chipset. Word 40H-53H seems (as per this datasheet) to be for AMT.
+ * Writing over it doesn't seem to cause any harm, since the ME/AMT is already removed in libreboot.
+ */
+ for(i = 0; i < sizeof(gbeStruct8k.backup.padding); i++) {
+ gbeStruct8k.backup.padding[i] = 0xFF; /* FF is correct. In the struct, this is a char buffer. */
+ } /* We really only need to do this for words 40h-53h, but let's just nuke the whole lot. It's all 0xFF anyway. */
+
+ /* Fix the checksum */
+ gbeStruct8k.backup.checkSum = gbeGetChecksumFrom4kStruct(gbeStruct8k.backup, GBECHECKSUMTOTAL);
+
+ /* Main Gbe region on X200 (as shipped by Lenovo) is broken. Fix it by over-writing it with the contents of the backup */
+ memcpy(&gbeStruct8k.main, &gbeStruct8k.backup, GBEREGIONSIZE_4K);
+
+ return gbeStruct8k;
+}
+
+/*
+ * ---------------------------------------------------------------------
+ * C code generator (self-writing code)
+ * ---------------------------------------------------------------------
+ */
+
+/*
+ * Generate a C (.h) header file for the C source file made by notCreatedCFileFromGbeStruct4k()
+ *
+ * Output it to a file.
+ */
+int notCreatedHFileForGbeCFile(char* outFileName, char* cFileName)
+{
+ remove(outFileName); /* Remove the old file before continuing */
+
+ /* Open the file that will be written to */
+ FILE* fp = fopen(outFileName, "w+");
+
+ /* ------------------------------ */
+
+ fprintf(fp, "/* %s: generated C code from ich9deblob */\n", outFileName);
+ fprintf(fp, "/* .h header file for the gbe-generating C code (%s) */\n\n", cFileName);
+
+ fprintf(fp, "#ifndef ICH9GEN_MKGBE_H\n");
+ fprintf(fp, "#define ICH9GEN_MKGBE_H\n\n");
+
+ fprintf(fp, "#include <stdio.h>\n");
+ fprintf(fp, "#include <string.h>\n");
+ fprintf(fp, "#include \"../gbe/gbe.h\"\n\n");
+
+ fprintf(fp, "struct GBEREGIONRECORD_4K generatedGbeStruct4k();\n");
+ fprintf(fp, "struct GBEREGIONRECORD_8K generatedGbeStruct8k();\n\n");
+
+ fprintf(fp, "#endif\n");
+
+ /* ------------------------------ */
+
+ fclose(fp); /* Always close the file when done. */
+
+ return 0;
+}
+/*
+ * Generate a C source file that initializes the same data from a given
+ * 4KiB Gbe data structure.
+ *
+ * It will simply copy the 4KiB struct at the end to make a full 8KiB struct.
+ * So just pass a working 4KiB Gbe struct here and you're good to go.
+ *
+ * Output it to a file.
+ */
+int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* outFileName, char* headerFileName)
+{
+ int i;
+ int paddingSize;
+ int paddingIdentical;
+
+ remove(outFileName); /* Remove the old file before continuing */
+
+ /* Open the file that will be written to */
+ FILE* fp = fopen(outFileName, "w+");
+
+ /* ------------------------------ */
+
+ fprintf(fp, "/* %s: generated C code from ich9deblob */\n", outFileName);
+ fprintf(fp, "/* .c source file for the gbe-generating C code */\n\n");
+
+ fprintf(fp, "#include \"%s\"\n\n", headerFileName);
+
+ fprintf(fp, "/* Generate a 4KiB Gbe struct, with default values. */\n");
+ fprintf(fp, "/* Read ../gbe/gbe.h for an explanation of the default values used here */\n\n");
+
+ fprintf(fp, "struct GBEREGIONRECORD_4K generatedGbeStruct4k()\n");
+ fprintf(fp, "{\n");
+ fprintf(fp, " int i;\n");
+ fprintf(fp, " struct GBEREGIONRECORD_4K gbeStruct4k;\n");
+ fprintf(fp, "\n");
+ /* Words 00h to 02h: MAC Address */
+ fprintf(fp, " /* MAC address (words 00h to 02h) */\n");
+ fprintf(fp, " /* see ../gbe/gbe.c */\n");
+ for (i = 0; i < 6; i++) {
+ fprintf(fp, " gbeStruct4k.macAddress[%d] = 0x%02x;\n", i, gbeStruct4k.macAddress[i]);
+ }
+ fprintf(fp, "\n");
+ /* Word 03h (Reserved) */
+ fprintf(fp, " /* Word 03h (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord03h.reserved1_0 = 0x%02x;\n", gbeStruct4k.reservedWord03h.reserved1_0);
+ fprintf(fp, " gbeStruct4k.reservedWord03h.reserved1_1 = 0x%01x;\n", gbeStruct4k.reservedWord03h.reserved1_1);
+ fprintf(fp, " gbeStruct4k.reservedWord03h.ibaLom = 0x%01x;\n", gbeStruct4k.reservedWord03h.ibaLom);
+ fprintf(fp, " gbeStruct4k.reservedWord03h.reserved2 = 0x%01x;\n", gbeStruct4k.reservedWord03h.reserved2);
+ fprintf(fp, "\n");
+ /* Word 04h (Reserved) */
+ fprintf(fp, " /* Word 04h (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord04h = 0x%04x;\n", gbeStruct4k.reservedWord04h);
+ fprintf(fp, "\n");
+ /* Word 05h (Image Version Information) */
+ fprintf(fp, " /* Word 05h (Image Version Information) */\n");
+ fprintf(fp, " gbeStruct4k.imageVersionInformation = 0x%04x;\n", gbeStruct4k.imageVersionInformation);
+ fprintf(fp, "\n");
+ /* Words 06h and 07h (Reserved) */
+ fprintf(fp, " /* Words 06h and 07h (Reserved) */\n");
+ for (i = 0; i < 2; i++) {
+ fprintf(fp, " gbeStruct4k.reservedWords06h07h[%d] = 0x%04x;\n", i, gbeStruct4k.reservedWords06h07h[i]);
+ }
+ fprintf(fp, "\n");
+ /* Words 08h and 09h (PBA Low and PBA High) */
+ fprintf(fp, " /* Word 08h and 09h (PBA Low and PBA High) */\n");
+ fprintf(fp, " gbeStruct4k.pbaLow = 0x%04x;\n", gbeStruct4k.pbaLow);
+ fprintf(fp, " gbeStruct4k.pbaHigh = 0x%04x;\n", gbeStruct4k.pbaHigh);
+ fprintf(fp, "\n");
+ /* Word 0Ah (PCI Initialization Control Word) */
+ fprintf(fp, " /* Word 0Ah (PCI Initialization Control Word) */\n");
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.loadVendorDeviceId = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.loadVendorDeviceId);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.loadSubsystemId = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.loadSubsystemId);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.reserved1 = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.reserved1);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.reserved2 = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.reserved2);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.pmEnable = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.pmEnable);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.auxPwr = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.auxPwr);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.reserved3 = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.reserved3);
+ fprintf(fp, " gbeStruct4k.pciInitializationControlWord.reserved4 = 0x%01x;\n", gbeStruct4k.pciInitializationControlWord.reserved4);
+ fprintf(fp, "\n");
+ /* Word 0Bh (Subsystem ID) */
+ fprintf(fp, " /* Word 0Bh (Subsystem ID) */\n");
+ fprintf(fp, " gbeStruct4k.subsystemId = 0x%04x;\n", gbeStruct4k.subsystemId);
+ fprintf(fp, "\n");
+ /* Word 0Ch (Subsystem Vendor ID) */
+ fprintf(fp, " /* Word 0Ch (Subsystem Vendor ID) */\n");
+ fprintf(fp, " gbeStruct4k.subsystemVendorId = 0x%04x;\n", gbeStruct4k.subsystemVendorId);
+ fprintf(fp, "\n");
+ /* Word 0Dh (Device ID) */
+ fprintf(fp, " /* Word 0Dh (Device ID) */\n");
+ fprintf(fp, " gbeStruct4k.deviceId = 0x%04x;\n", gbeStruct4k.deviceId);
+ fprintf(fp, "\n");
+ /* Word 0Eh (Vendor ID) */
+ fprintf(fp, " /* Word 0Eh (Vendor ID) */\n");
+ fprintf(fp, " gbeStruct4k.vendorId = 0x%04x;\n", gbeStruct4k.vendorId);
+ fprintf(fp, "\n");
+ /* Word 0Fh (Device Revision ID) */
+ fprintf(fp, " /* Word 0Fh (Device Revision ID) */\n");
+ fprintf(fp, " gbeStruct4k.deviceRevId = 0x%04x;\n", gbeStruct4k.deviceRevId);
+ fprintf(fp, "\n");
+ /* Word 10h (LAN Power Consumption) */
+ fprintf(fp, " /* Word 10h (LAN Power Consumption) */\n");
+ fprintf(fp, " gbeStruct4k.lanPowerConsumption.lanD3Power = 0x%02x;\n", gbeStruct4k.lanPowerConsumption.lanD3Power);
+ fprintf(fp, " gbeStruct4k.lanPowerConsumption.reserved = 0x%01x;\n", gbeStruct4k.lanPowerConsumption.reserved);
+ fprintf(fp, " gbeStruct4k.lanPowerConsumption.lanD0Power = 0x%02x;\n", gbeStruct4k.lanPowerConsumption.lanD0Power);
+ fprintf(fp, "\n");
+ /* Words 11h and 12h (Reserved) */
+ fprintf(fp, " /* Words 11h and 12h (Reserved) */\n");
+ for (i = 0; i < 2; i++) {
+ fprintf(fp, " gbeStruct4k.reservedWords11h12h[%d] = 0x%04x;\n", i, gbeStruct4k.reservedWords11h12h[i]);
+ }
+ fprintf(fp, "\n");
+ /* Word 13h (Shared Initialization Control Word) */
+ fprintf(fp, " /* Word 13h (Shared Initialization Control Word) */\n");
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.reserved1 = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.reserved1);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.forceDuplex = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.forceDuplex);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.forceSpeedEnable = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.forceSpeedEnable);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.reserved2_0 = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.reserved2_0);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.reserved2_1 = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.reserved2_1);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.phyPowerDownEnable = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.phyPowerDownEnable);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.reserved3 = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.reserved3);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.reserved4 = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.reserved4);
+ fprintf(fp, " gbeStruct4k.sharedInitializationControlWord.sign = 0x%01x;\n", gbeStruct4k.sharedInitializationControlWord.sign);
+ fprintf(fp, "\n");
+ /* Word 14h (Extended Configuration Control Word 1) */
+ fprintf(fp, " /* Word 14h (Extended Configuration Control Word 1) */\n");
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord1.extendedConfigurationPointer = 0x%03x;\n", gbeStruct4k.extendedConfigurationControlWord1.extendedConfigurationPointer);
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord1.oemWriteEnable = 0x%01x;\n", gbeStruct4k.extendedConfigurationControlWord1.oemWriteEnable);
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord1.reserved1 = 0x%01x;\n", gbeStruct4k.extendedConfigurationControlWord1.reserved1);
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord1.reserved2 = 0x%01x;\n", gbeStruct4k.extendedConfigurationControlWord1.reserved2);
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord1.reserved3 = 0x%01x;\n", gbeStruct4k.extendedConfigurationControlWord1.reserved3);
+ fprintf(fp, "\n");
+ /* Word 15h (Extended Configuration Control Word 2) */
+ fprintf(fp, " /* Word 15h (Extended Configuration Control Word 2) */\n");
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord2.reserved = 0x%02x;\n", gbeStruct4k.extendedConfigurationControlWord2.reserved);
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord2.extendedPhyLength = 0x%02x;\n", gbeStruct4k.extendedConfigurationControlWord2.extendedPhyLength);
+ fprintf(fp, "\n");
+ /* Word 16h (Extended Configuration Control Word 3) */
+ fprintf(fp, " /* Word 16h (Extended Configuration Control Word 3) */\n");
+ fprintf(fp, " gbeStruct4k.extendedConfigurationControlWord3 = 0x%04x;\n", gbeStruct4k.extendedConfigurationControlWord3);
+ fprintf(fp, "\n");
+ /* Word 17h (LED 1 Configuration and Power Management) */
+ fprintf(fp, " /* Word 17h (LED 1 Configuration and Power Management) */\n");
+ fprintf(fp, " gbeStruct4k.ledCtl1.led1Mode = 0x%01x;\n", gbeStruct4k.ledCtl1.led1Mode);
+ fprintf(fp, " gbeStruct4k.ledCtl1.reserved1 = 0x%01x;\n", gbeStruct4k.ledCtl1.reserved1);
+ fprintf(fp, " gbeStruct4k.ledCtl1.led1BlinkMode = 0x%01x;\n", gbeStruct4k.ledCtl1.led1BlinkMode);
+ fprintf(fp, " gbeStruct4k.ledCtl1.led1Invert = 0x%01x;\n", gbeStruct4k.ledCtl1.led1Invert);
+ fprintf(fp, " gbeStruct4k.ledCtl1.led1Blink = 0x%01x;\n", gbeStruct4k.ledCtl1.led1Blink);
+ fprintf(fp, " gbeStruct4k.ledCtl1.reserved2 = 0x%01x;\n", gbeStruct4k.ledCtl1.reserved2);
+ fprintf(fp, " gbeStruct4k.ledCtl1.lpluEnable = 0x%01x;\n", gbeStruct4k.ledCtl1.lpluEnable);
+ fprintf(fp, " gbeStruct4k.ledCtl1.lpluEnableNonD0a = 0x%01x;\n", gbeStruct4k.ledCtl1.lpluEnableNonD0a);
+ fprintf(fp, " gbeStruct4k.ledCtl1.gbeDisableNonD0a = 0x%01x;\n", gbeStruct4k.ledCtl1.gbeDisableNonD0a);
+ fprintf(fp, " gbeStruct4k.ledCtl1.reserved3 = 0x%01x;\n", gbeStruct4k.ledCtl1.reserved3);
+ fprintf(fp, " gbeStruct4k.ledCtl1.gbeDisable = 0x%01x;\n", gbeStruct4k.ledCtl1.gbeDisable);
+ fprintf(fp, " gbeStruct4k.ledCtl1.reserved4 = 0x%01x;\n", gbeStruct4k.ledCtl1.reserved4);
+ fprintf(fp, "\n");
+ /* Word 18h (LED 0 and 2 Configuration Defaults) */
+ fprintf(fp, " /* Word 18h (LED 0 and 2 Configuration Defaults) */\n");
+ fprintf(fp, " gbeStruct4k.ledCtl02.led0Mode = 0x%01x;\n", gbeStruct4k.ledCtl02.led0Mode);
+ fprintf(fp, " gbeStruct4k.ledCtl02.reserved1 = 0x%01x;\n", gbeStruct4k.ledCtl02.reserved1);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led0BlinkMode = 0x%01x;\n", gbeStruct4k.ledCtl02.led0BlinkMode);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led0Invert = 0x%01x;\n", gbeStruct4k.ledCtl02.led0Invert);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led0Blink = 0x%01x;\n", gbeStruct4k.ledCtl02.led0Blink);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led2Mode = 0x%01x;\n", gbeStruct4k.ledCtl02.led2Mode);
+ fprintf(fp, " gbeStruct4k.ledCtl02.reserved2 = 0x%01x;\n", gbeStruct4k.ledCtl02.reserved2);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led2BlinkMode = 0x%01x;\n", gbeStruct4k.ledCtl02.led2BlinkMode);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led2Invert = 0x%01x;\n", gbeStruct4k.ledCtl02.led2Invert);
+ fprintf(fp, " gbeStruct4k.ledCtl02.led2Blink = 0x%01x;\n", gbeStruct4k.ledCtl02.led2Blink);
+ fprintf(fp, "\n");
+ /* Word 19h (Reserved) */
+ fprintf(fp, " /* Word 19h (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord19h = 0x%04x;\n", gbeStruct4k.reservedWord19h);
+ fprintf(fp, "\n");
+ /* Word 1Ah (Reserved) */
+ fprintf(fp, " /* Word 1Ah (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord1Ah = 0x%04x;\n", gbeStruct4k.reservedWord1Ah);
+ fprintf(fp, "\n");
+ /* Word 1Bh (Reserved) */
+ fprintf(fp, " /* Word 1Bh (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord1Bh = 0x%04x;\n", gbeStruct4k.reservedWord1Bh);
+ fprintf(fp, "\n");
+ /* Word 1Ch (Reserved) */
+ fprintf(fp, " /* Word 1Ch (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord1Ch = 0x%04x;\n", gbeStruct4k.reservedWord1Ch);
+ fprintf(fp, "\n");
+ /* Word 1Dh (Reserved) */
+ fprintf(fp, " /* Word 1Dh (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord1Dh = 0x%04x;\n", gbeStruct4k.reservedWord1Dh);
+ fprintf(fp, "\n");
+ /* Word 1Eh (Device ID for Intel 82567LM gigabit ethernet controller) */
+ fprintf(fp, " /* Word 1Eh (Device ID for Intel 82567LM gigabit ethernet controller) */\n");
+ fprintf(fp, " gbeStruct4k._82567lmDeviceId = 0x%04x;\n", gbeStruct4k._82567lmDeviceId);
+ fprintf(fp, "\n");
+ /* Word 1Fh (Device ID for Intel 82567LF gigabit ethernet controller) */
+ fprintf(fp, " /* Word 1Fh (Device ID for Intel 82567LF gigabit ethernet controller) */\n");
+ fprintf(fp, " gbeStruct4k._82567lfDeviceId = 0x%04x;\n", gbeStruct4k._82567lfDeviceId);
+ fprintf(fp, "\n");
+ /* Word 20h (Reserved) */
+ fprintf(fp, " /* Word 20h (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord20h = 0x%04x;\n", gbeStruct4k.reservedWord20h);
+ fprintf(fp, "\n");
+ /* Word 21h (Device ID for Intel 82567V gigabit ethernet controller) */
+ fprintf(fp, " /* Word 21h (Device ID for Intel 82567V gigabit ethernet controller) */\n");
+ fprintf(fp, " gbeStruct4k._82567vDeviceId = 0x%04x;\n", gbeStruct4k._82567vDeviceId);
+ fprintf(fp, "\n");
+ /* Word 22h (Reserved) */
+ fprintf(fp, " /* Word 22h (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord22h = 0x%04x;\n", gbeStruct4k.reservedWord22h);
+ fprintf(fp, "\n");
+ /* Word 23h (Reserved) */
+ fprintf(fp, " /* Word 23h (Reserved) */\n");
+ fprintf(fp, " gbeStruct4k.reservedWord23h = 0x%04x;\n", gbeStruct4k.reservedWord23h);
+ fprintf(fp, "\n");
+ /* Words 24h to 2Fh (Reserved) */
+ fprintf(fp, " /* Words 24h to 2Fh (Reserved) */\n");
+ for (i = 0; i < 12; i++) {
+ fprintf(fp, " gbeStruct4k.reservedWords24to2Fh[%d] = 0x%04x;\n", i, gbeStruct4k.reservedWords24to2Fh[i]);
+ }
+ fprintf(fp, "\n");
+ /* Words 30h to 3Eh (PXE Software Region) */
+ fprintf(fp, " /* Words 30h to 3Eh (PXE Software Region) */\n");
+ fprintf(fp, " /* Boot Agent Main Setup Options (Word 30h) */\n");
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.protocolSelect = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.protocolSelect);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved1 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved1);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.defaultBootSelection = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.defaultBootSelection);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved2 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved2);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.promptTime = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.promptTime);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.displaySetupMessage = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.displaySetupMessage);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved3 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved3);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceSpeed = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceSpeed);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceFullDuplex = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceFullDuplex);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved4 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved4);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.efiPresence = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.efiPresence);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.pxePresence = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.pxePresence);
+ fprintf(fp, " /* Boot Agent Configuration Customization Options (Word 31h) */\n");
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableSetupMenu = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableSetupMenu);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableTitleMessage = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableTitleMessage);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableProtocolSelect = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableProtocolSelect);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableBootSelection = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableBootSelection);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableLegacyWakeupSupport = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableLegacyWakeupSupport);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableFlashUpdate = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableFlashUpdate);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved1 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved1);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.ibaBootOrderSetupMode = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.ibaBootOrderSetupMode);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved2 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved2);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.signature = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.signature);
+ fprintf(fp, " /* Boot Agent Configuration Customization Options (Word 32h) */\n");
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.buildNumber = 0x%02x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.buildNumber);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.minorVersionNumber = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.minorVersionNumber);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.majorVersionNumber = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.majorVersionNumber);
+ fprintf(fp, " /* IBA Capabilities (Word 33h) */\n");
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.baseCodePresent = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.baseCodePresent);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.undiCapabilityPresent = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.undiCapabilityPresent);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved1 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved1);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.efiUndiCapabilityPresent = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.efiUndiCapabilityPresent);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_0 = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_0);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_1 = 0x%02x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_1);
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.signature = 0x%01x;\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.signature);
+ fprintf(fp, " /* Padding (Words 34h to 3Eh) */\n");
+ for (i = 0; i < 11; i++) {
+ fprintf(fp, " gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[%d] = 0x%04x;\n", i, gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[i]);
+ }
+ fprintf(fp, "\n");
+ /* Word 3Fh (Checksum) */
+ fprintf(fp, " /* Word 3Fh (Checksum) */\n");
+ fprintf(fp, " gbeStruct4k.checkSum = gbeGetChecksumFrom4kStruct(gbeStruct4k, GBECHECKSUMTOTAL);\n");
+
+ fprintf(fp, "\n");
+ /* The rest of Gbe is just padding */
+ paddingSize = sizeof(gbeStruct4k.padding);
+ paddingIdentical = 1; /* Assume that it's all 0xFF, then try to disprove it */
+ for (i = 0; i < paddingSize; i++) { /* check whether contents differ */
+ if (gbeStruct4k.padding[i] != 0xFF) {
+ paddingIdentical = 0;
+ break;
+ }
+ }
+ if (!paddingIdentical) {
+ fprintf(fp, " /* The rest of Gbe (word 40h or byte 80h onwards) is just padding */\n");
+ for (i = 0; i < paddingSize; i++) { /* contents are not all 0xFF, just spit them all out one by one */
+ fprintf(fp, " gbeStruct4k.padding[%d] = 0x%02x;\n", i, gbeStruct4k.padding[i]);
+ }
+ } else { /* contents are all 0xFF. Generate a small for loop that sets them all to 0xFF */
+ fprintf(fp, " /* The rest of Gbe (word 40h or byte 80h onwards) is just padding (0xFF) */\n");
+ fprintf(fp, " for (i = 0; i < %d; i++) {\n", paddingSize);
+ fprintf(fp, " gbeStruct4k.padding[i] = 0xFF;\n");
+ fprintf(fp, " }\n");
+ }
+ fprintf(fp, "\n");
+ fprintf(fp, " return gbeStruct4k;\n");
+ fprintf(fp, "}\n\n");
+
+ fprintf(fp, "struct GBEREGIONRECORD_8K generatedGbeStruct8k()\n");
+ fprintf(fp, "{\n");
+ fprintf(fp, " struct GBEREGIONRECORD_8K gbeStruct8k;\n");
+ fprintf(fp, " gbeStruct8k.main = generatedGbeStruct4k();\n");
+ fprintf(fp, " memcpy(&gbeStruct8k.backup, &gbeStruct8k.main, GBEREGIONSIZE_4K);\n");
+ fprintf(fp, " return gbeStruct8k;\n");
+ fprintf(fp, "}\n\n");
+
+ /* ------------------------------ */
+
+ fclose(fp); /* Always close the file when done. */
+
+ return 0;
+}
+
+int showGbeData(struct GBEREGIONRECORD_4K gbeStruct4k)
+{
+ int i;
+
+ printf("GbE REGION\n");
+ printf("==========\n");
+
+ printf("A *word*, in this context, means two 8-bit bytes.\n\n");
+
+ printf("**MAC address** (words 00h to 02h) = ");
+ for (i = 0; i < 6; i++) {
+ printf("%02x", gbeStruct4k.macAddress[i]);
+ if (i!=5) printf(":");
+ }
+ printf("\n\n");
+
+ printf("Word 03h (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reserved1_0 = 0x%02x\n", gbeStruct4k.reservedWord03h.reserved1_0);
+ printf("- reserved1_1 = 0x%01x\n", gbeStruct4k.reservedWord03h.reserved1_1);
+ printf("- IBA Lom = 0x%01x\n", gbeStruct4k.reservedWord03h.ibaLom);
+ printf("- reserved2 = 0x%01x\n\n", gbeStruct4k.reservedWord03h.reserved2);
+
+ printf("Word 04h (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord04h = 0x%04x\n\n", gbeStruct4k.reservedWord04h);
+
+ /* Word 05h (Image Version Information) */
+ printf("Word 05h (Image Version Information)\n");
+ printf("------------------------------------\n\n");
+
+ printf("- Image Version Information = 0x%04x\n\n", gbeStruct4k.imageVersionInformation);
+
+ printf("Words 06h and 07h (Reserved)\n");
+ printf("----------------------------\n\n");
+
+ for (i = 0; i < 2; i++) {
+ printf("- Offset %d = 0x%04x\n", i, gbeStruct4k.reservedWords06h07h[i]);
+ }
+ printf("\n");
+
+ /* Words 08h and 09h (PBA Low and PBA High) */
+ printf("Word 08h and 09h (PBA Low and PBA High)\n");
+ printf("---------------------------------------\n\n");
+
+ printf("- pbaLow = 0x%04x\n", gbeStruct4k.pbaLow);
+ printf("- pbaHigh = 0x%04x\n\n", gbeStruct4k.pbaHigh);
+
+ printf("Word 0Ah (PCI Initialization Control Word)\n");
+ printf("------------------------------------------\n\n");
+
+ printf("- Load Vendor Device ID = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.loadVendorDeviceId);
+ printf("- Load Subsystem ID = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.loadSubsystemId);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.reserved1);
+ printf("- reserved2 = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.reserved2);
+ printf("- PM Enable = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.pmEnable);
+ printf("- Auxillary Power = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.auxPwr);
+ printf("- reserved3 = 0x%01x\n", gbeStruct4k.pciInitializationControlWord.reserved3);
+ printf("- reserved4 = 0x%01x\n\n", gbeStruct4k.pciInitializationControlWord.reserved4);
+
+ printf("Word 0Bh (Subsystem ID)\n");
+ printf("-----------------------\n\n");
+
+ printf("- Subsystem ID = 0x%04x\n\n", gbeStruct4k.subsystemId);
+
+ printf("Word 0Ch (Subsystem Vendor ID)\n");
+ printf("------------------------------\n\n");
+
+ printf("- Subsystem Vendor ID = 0x%04x\n\n", gbeStruct4k.subsystemVendorId);
+
+ printf("Word 0Dh (Device ID)\n");
+ printf("--------------------\n\n");
+
+ printf("- Device ID = 0x%04x\n\n", gbeStruct4k.deviceId);
+
+ printf("Word 0Eh (Vendor ID)\n");
+ printf("--------------------\n\n");
+
+ printf("- Vendor ID = 0x%04x\n\n", gbeStruct4k.vendorId);
+
+ printf("Word 0Fh (Device Revision ID)\n");
+ printf("-----------------------------\n\n");
+
+ printf("- Device Revision ID = 0x%04x\n\n", gbeStruct4k.deviceRevId);
+
+ printf("Word 10h (LAN Power Consumption)\n");
+ printf("--------------------------------\n\n");
+
+ printf("- LAN D3 Power = 0x%02x\n", gbeStruct4k.lanPowerConsumption.lanD3Power);
+ printf("- reserved = 0x%01x\n", gbeStruct4k.lanPowerConsumption.reserved);
+ printf("- LAN D0 Power = 0x%02x\n\n", gbeStruct4k.lanPowerConsumption.lanD0Power);
+
+ printf("Words 11h and 12h (Reserved)\n");
+ printf("----------------------------\n\n");
+
+ for (i = 0; i < 2; i++) {
+ printf("- Offset %d = 0x%04x\n", i, gbeStruct4k.reservedWords11h12h[i]);
+ }
+ printf("\n");
+
+ /* Word 13h (Shared Initialization Control Word) */
+ printf("Word 13h (Shared Initialization Control Word)\n");
+ printf("---------------------------------------------\n\n");
+
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.reserved1);
+ printf("- Force Duplex = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.forceDuplex);
+ printf("- Force Speed Enable = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.forceSpeedEnable);
+ printf("- reserved2_0 = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.reserved2_0);
+ printf("- reserved2_1 = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.reserved2_1);
+ printf("- PHY Power Down Enable = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.phyPowerDownEnable);
+ printf("- reserved3 = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.reserved3);
+ printf("- reserved4 = 0x%01x\n", gbeStruct4k.sharedInitializationControlWord.reserved4);
+ printf("- Sign = 0x%01x\n\n", gbeStruct4k.sharedInitializationControlWord.sign);
+
+ printf("Word 14h (Extended Configuration Control Word 1)\n");
+ printf("------------------------------------------------\n\n");
+
+ printf("- Extended Configuration Pointer = 0x%03x\n", gbeStruct4k.extendedConfigurationControlWord1.extendedConfigurationPointer);
+ printf("- OEM Write Enable = 0x%01x\n", gbeStruct4k.extendedConfigurationControlWord1.oemWriteEnable);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.extendedConfigurationControlWord1.reserved1);
+ printf("- reserved2 = 0x%01x\n", gbeStruct4k.extendedConfigurationControlWord1.reserved2);
+ printf("- reserved3 = 0x%01x\n\n", gbeStruct4k.extendedConfigurationControlWord1.reserved3);
+
+ printf("Word 15h (Extended Configuration Control Word 2)\n");
+ printf("------------------------------------------------\n\n");
+
+ printf("- reserved = 0x%02x\n", gbeStruct4k.extendedConfigurationControlWord2.reserved);
+ printf("- Extended PHY Length = 0x%02x\n\n", gbeStruct4k.extendedConfigurationControlWord2.extendedPhyLength);
+
+ printf("Word 16h (Extended Configuration Control Word 3)\n");
+ printf("------------------------------------------------\n\n");
+
+ printf("- Extended Configuration Control Word 3 = 0x%04x\n\n", gbeStruct4k.extendedConfigurationControlWord3);
+
+ printf("Word 17h (LED 1 Configuration and Power Management)\n");
+ printf("---------------------------------------------------\n\n");
+
+ printf("- LED1 Mode = 0x%01x\n", gbeStruct4k.ledCtl1.led1Mode);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.ledCtl1.reserved1);
+ printf("- LED1 Blink Mode = 0x%01x\n", gbeStruct4k.ledCtl1.led1BlinkMode);
+ printf("- LED1 Invert = 0x%01x\n", gbeStruct4k.ledCtl1.led1Invert);
+ printf("- LED1 Blink = 0x%01x\n", gbeStruct4k.ledCtl1.led1Blink);
+ printf("- reserved2 = 0x%01x\n", gbeStruct4k.ledCtl1.reserved2);
+ printf("- LPLU Enable = 0x%01x\n", gbeStruct4k.ledCtl1.lpluEnable);
+ printf("- LPLU Enable Non-D0a = 0x%01x\n", gbeStruct4k.ledCtl1.lpluEnableNonD0a);
+ printf("- GbE Disable Non-D0a = 0x%01x\n", gbeStruct4k.ledCtl1.gbeDisableNonD0a);
+ printf("- reserved3 = 0x%01x\n", gbeStruct4k.ledCtl1.reserved3);
+ printf("- GbE Disable = 0x%01x\n", gbeStruct4k.ledCtl1.gbeDisable);
+ printf("- reserved4 = 0x%01x\n\n", gbeStruct4k.ledCtl1.reserved4);
+
+ printf("Word 18h (LED 0 and 2 Configuration Defaults)\n");
+ printf("---------------------------------------------\n\n");
+
+ printf("- LED0 Mode = 0x%01x\n", gbeStruct4k.ledCtl02.led0Mode);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.ledCtl02.reserved1);
+ printf("- LED0 Blink Mode = 0x%01x\n", gbeStruct4k.ledCtl02.led0BlinkMode);
+ printf("- LED0 Invert = 0x%01x\n", gbeStruct4k.ledCtl02.led0Invert);
+ printf("- LED0 Blink = 0x%01x\n", gbeStruct4k.ledCtl02.led0Blink);
+ printf("- LED2 Mode = 0x%01x\n", gbeStruct4k.ledCtl02.led2Mode);
+ printf("- reserved2 = 0x%01x\n", gbeStruct4k.ledCtl02.reserved2);
+ printf("- LED2 Blink Mode = 0x%01x\n", gbeStruct4k.ledCtl02.led2BlinkMode);
+ printf("- LED2 Invert = 0x%01x\n", gbeStruct4k.ledCtl02.led2Invert);
+ printf("- LED2 Blink = 0x%01x\n\n", gbeStruct4k.ledCtl02.led2Blink);
+
+ printf("Word 19h (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord19h = 0x%04x\n\n", gbeStruct4k.reservedWord19h);
+
+ printf("Word 1Ah (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord1Ah = 0x%04x\n\n", gbeStruct4k.reservedWord1Ah);
+
+ printf("Word 1Bh (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord1Bh = 0x%04x\n\n", gbeStruct4k.reservedWord1Bh);
+
+ printf("Word 1Ch (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord1Ch = 0x%04x\n\n", gbeStruct4k.reservedWord1Ch);
+
+ printf("Word 1Dh (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord1Dh = 0x%04x\n\n", gbeStruct4k.reservedWord1Dh);
+
+ printf("Word 1Eh (Device ID for Intel 82567LM gigabit ethernet controller)\n");
+ printf("------------------------------------------------------------------\n\n");
+
+ printf("- 82567LM Device ID = 0x%04x\n\n", gbeStruct4k._82567lmDeviceId);
+
+ printf("Word 1Fh (Device ID for Intel 82567LF gigabit ethernet controller)\n");
+ printf("------------------------------------------------------------------\n\n");
+
+ printf("- 82567LF Device ID = 0x%04x\n\n", gbeStruct4k._82567lfDeviceId);
+
+ printf("Word 20h (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord20h = 0x%04x\n\n", gbeStruct4k.reservedWord20h);
+
+ printf("Word 21h (Device ID for Intel 82567V gigabit ethernet controller)\n");
+ printf("-----------------------------------------------------------------\n\n");
+
+ printf("- 82567V Device ID = 0x%04x\n\n", gbeStruct4k._82567vDeviceId);
+
+ printf("Word 22h (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord22h = 0x%04x\n\n", gbeStruct4k.reservedWord22h);
+
+ printf("Word 23h (Reserved)\n");
+ printf("-------------------\n\n");
+
+ printf("- reservedWord23h = 0x%04x\n\n", gbeStruct4k.reservedWord23h);
+
+ printf("Words 24h to 2Fh (Reserved)\n");
+ printf("---------------------------\n\n");
+
+ for (i = 0; i < 12; i++) {
+ printf("- Offset %d = 0x%04x\n", i, gbeStruct4k.reservedWords24to2Fh[i]);
+ }
+ printf("\n");
+
+ printf("Words 30h to 3Eh (PXE Software Region)\n");
+ printf("--------------------------------------\n\n");
+
+ printf("Boot Agent Main Setup Options (Word 30h):\n\n");
+
+ printf("- Protocol Select = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.protocolSelect);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved1);
+ printf("- Default Boot Selection = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.defaultBootSelection);
+ printf("- reserved2 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved2);
+ printf("- Prompt Time = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.promptTime);
+ printf("- Display Setup Message = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.displaySetupMessage);
+ printf("- reserved3 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved3);
+ printf("- Force Speed = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceSpeed);
+ printf("- Force Full Duplex = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceFullDuplex);
+ printf("- reserved4 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved4);
+ printf("- EFI Presence = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.efiPresence);
+ printf("- PXE Presence = 0x%01x\n\n", gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.pxePresence);
+
+ printf("Boot Agent Configuration Customization Options (Word 31h):\n\n");
+
+ printf("- Disable Setup Menu = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableSetupMenu);
+ printf("- Disable Title Message = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableTitleMessage);
+ printf("- Disable Protocol Select = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableProtocolSelect);
+ printf("- Disable Boot Selection = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableBootSelection);
+ printf("- Disable Legacy Wakeup Support = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableLegacyWakeupSupport);
+ printf("- Disable Flash Update = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableFlashUpdate);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved1);
+ printf("- IBA Boot Order Setup Mode = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.ibaBootOrderSetupMode);
+ printf("- reserved2 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved2);
+ printf("- Signature = 0x%01x\n\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.signature);
+
+ printf("Boot Agent Configuration Customization Options (Word 32h):\n\n");
+
+ printf("- Build Number = 0x%02x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.buildNumber);
+ printf("- Minor Version Number = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.minorVersionNumber);
+ printf("- Major Version Number = 0x%01x\n\n", gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.majorVersionNumber);
+
+ printf("IBA Capabilities (Word 33h):\n\n");
+
+ printf("- Base Code Present = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.baseCodePresent);
+ printf("- UNDI Capability Present = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.undiCapabilityPresent);
+ printf("- reserved1 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved1);
+ printf("- EFI UndiCapabilityPresent = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.efiUndiCapabilityPresent);
+ printf("- reserved2_0 = 0x%01x\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_0);
+ printf("- reserved2_1 = 0x%02x\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_1);
+ printf("- Signature = 0x%01x\n\n", gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.signature);
+
+ printf("Padding (Words 34h to 3Eh):\n\n");
+
+ for (i = 0; i < 11; i++) {
+ printf("- Offset %d = 0x%04x\n", i, gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[i]);
+ }
+ printf("\n");
+
+ printf("Word 3Fh (Checksum):\n\n");
+
+ printf("- Check Sum = 0x%04x\n\n", gbeStruct4k.checkSum);
+
+ printf("The rest of this section is irrelevant. It can all be set to 0xFF.\n\n");
+
+ return 0;
+}
+
+
+/*
+ * ---------------------------------------------------------------------
+ * Debugging functions:
+ * ---------------------------------------------------------------------
+ */
+
+/*
+ * show debugging info: show calculated (correct) gbe checksum and what
+ * is actually stored, in a 4K gbe struct. Only for a single region.
+ */
+void printGbeChecksumDataFromStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* romName, char* regionName)
+{
+ printf(
+ "%s Gbe (%s): calculated Gbe checksum: 0x%hx and actual GBe checksum: 0x%hx\n",
+ romName,
+ regionName,
+ gbeGetChecksumFrom4kStruct(gbeStruct4k, GBECHECKSUMTOTAL),
+ gbeStruct4k.checkSum
+ );
+
+ return;
+}
+
+/*
+ * show debugging info: show calculated (correct) gbe checksum and what
+ * is actually stored, in a 8K gbe struct. Do so for main and backup regions.
+ */
+void printGbeChecksumDataFromStruct8k(struct GBEREGIONRECORD_8K gbeStruct8k, char* romName)
+{
+ printGbeChecksumDataFromStruct4k(gbeStruct8k.main, romName, "main");
+ printGbeChecksumDataFromStruct4k(gbeStruct8k.backup, romName, "backup");
+
+ return;
+}
diff --git a/util/ich9utils/src/gbe/gbe.h b/util/ich9utils/src/gbe/gbe.h
new file mode 100644
index 00000000..2352f7d7
--- /dev/null
+++ b/util/ich9utils/src/gbe/gbe.h
@@ -0,0 +1,436 @@
+/*
+ * gbe/gbe.h
+ * This file is part of the ich9deblob utility from the libreboot project
+ *
+ * Copyright (C) 2014 Steve Shenton <sgsit@libreboot.org>
+ * 2014,2019 Leah Rowe <info@minifree.org>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Purpose: provide struct representing gbe region.
+ * Map actual buffers of this regions, directly to instances of these
+ * structs. This makes working with gbe really easy.
+ */
+
+/*
+ * bit fields used, corresponding to datasheet. See links to datasheets
+ * and documentation in ich9deblob.c
+ */
+
+ /*
+ * See docs/hardware/x200_remove_me.html for info plus links to datasheet (also linked below)
+ *
+ * Info about Gbe region (read whole datasheet):
+ * http://www.intel.co.uk/content/dam/doc/application-note/i-o-controller-hub-9m-82567lf-lm-v-nvm-map-appl-note.pdf
+ * https://web.archive.org/web/20150912070329/https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums
+ */
+
+#ifndef GBESTRUCT_H
+#define GBESTRUCT_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include "../descriptor/descriptor.h"
+
+/* Size of the full gbe region in bytes */
+#define GBEREGIONSIZE_8K 0x2000
+/*
+ * Size of each sub-region in gbe.
+ * gbe contains two regions which
+ * can be identical: main and backup.
+ * These are each half the size of the full region
+ */
+#define GBEREGIONSIZE_4K 0x1000
+
+/*
+ * When adding up the first 0x3F 16-bit words
+ * in a 4KiB GBE region, it should be equal
+ * to 0xBABA
+ */
+#define GBECHECKSUMTOTAL 0xBABA
+
+/*
+ * These will have a modified descriptor+gbe based on what's in the factory.rom
+ * These will be joined into a single 12KiB buffer (descriptor, then gbe) and saved to a file
+ * NOTE: The GBE region of 8K is actually 2x 4K regions in a single region; both 4K blocks can be identical (and by default, are)
+ * The 2nd one is a "backup", but we don't know when it's used. perhaps it's used when the checksum on the first one does not match?
+ */
+
+/*
+ * ---------------------------------------------------------------------
+ * Gbe struct representing the data:
+ * ---------------------------------------------------------------------
+ */
+
+struct GBE_RESERVED_WORD_03H {
+ /* least significant bits */
+ uint8_t reserved1_0 : 8; /* bits should all be set to zero */
+ uint8_t reserved1_1 : 3; /* ^ part of above. Separated so that the bitfields align */
+ uint8_t ibaLom : 1; /* set to 1 for intel boot agent to work (i.e. set it to 0) */
+ uint8_t reserved2 : 4; /* bits should all be set to zero */
+ /* most significant bits */
+};
+
+/* Word 0A */
+struct GBE_PCI_INITIALIZATION_CONTROL_WORD {
+ /* least significant bits */
+ uint8_t loadVendorDeviceId : 1; /* 1 = load from NVM. 0 = load from MAC fuses. It's 1 in my deblobbed_descriptor.bin */
+ uint8_t loadSubsystemId : 1; /* 1 = load from NVM. 0 = load from MAC fuses. It's 1 in my deblobbed_descriptor.bin */
+ uint8_t reserved1 : 1; /* Reserved. Set to 0 (according to datasheet). 0 in my deblobbed_descriptor.bin */
+ uint8_t reserved2 : 3; /* Reserved. Set them to 0 (according to datasheet). 0 in my deblobbed_descriptor.bin */
+ uint8_t pmEnable : 1; /* Power Management Enable. 1=Enable. It's 1 in my deblobbed_descriptor.bin */
+ uint8_t auxPwr : 1; /* Auxiliary Power Indication. See datasheet. it's 1 in my deblobbed_descriptor.bin */
+ uint8_t reserved3 : 4; /* Reserved. Set to 0000 (according to datasheet). */
+ uint8_t reserved4 : 4; /* Reserved. Set to 0001 (according to datasheet). */
+ /* most significant bits */
+};
+
+/* Word 10h. */
+struct GBE_LAN_POWER_CONSUMPTION {
+ /* least significant bits */
+ uint8_t lanD3Power : 5; /* It's 00001b (0x1) in deblobbed_descriptor.bin */
+ uint8_t reserved : 3; /* Reserved. These bits should all be 0. confirmed from deblobbed_descriptor.bin */
+ uint8_t lanD0Power : 8; /* default value: 0x0D (according to datasheet). confirmed from deblobbed_descriptor.bin */
+ /* most significant bits */
+};
+
+/* Word 13h */
+struct GBE_SHARED_INITIALIZATION_CONTROL_WORD {
+ /* least significant bits */
+ uint8_t reserved1 : 3; /* Reserved. These bits should be set to 101 (0x5) in binary (according to datasheet and deblobbed_descriptor.bin) */
+ uint8_t forceDuplex : 1; /* Hardware default is 0 according to datasheet and deblobbed_descriptor.bin. Presumably to set whether the chipset is to operate at full- or half-duplex */
+ uint8_t forceSpeedEnable : 1; /* Hardware default is 0. Presumably to limited speed eg 10, 10/100, 10/100/1000 */
+ uint8_t reserved2_0 : 3; /* Reserved. All bits should be set to 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t reserved2_1 : 1; /* ^ part of above. separated so that bitfields align */
+ uint8_t phyPowerDownEnable : 1; /* PHY Power Down in D3/Dr (if WoL is disabled), 1 means Enable power down. deblobbed_descriptor.bin says 1 */
+ uint8_t reserved3 : 1; /* Reserved. Should be set to 1 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t reserved4 : 3; /* Reserved. These bits should all be 0 according to datasheet and deblobbed_descriptor.bin */
+ /* ^ reserved4: indicates whether a valid NVM is present. If invalid, MAC does not read NVM and uses default values. */
+ /* 00 = invalid NVM, 01 = invalid NVM, 10 = valid NVM present, 11 = invalid NVM */
+ /* Default should be 10 (binary) according to datasheet and deblobbed_descriptor.bin */
+ uint8_t sign : 2; /* Make sure to set this to 0x2 (10 in binary) */
+ /* most significant bits */
+};
+
+/* Word 14h */
+struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_1 {
+ /* least significant bits */
+ uint16_t extendedConfigurationPointer: 12; /* dword: base address of extended configuration area in NVM. should not be zero. Default is 020h according to datasheet and deblobbed_descriptor.bin */
+ uint8_t oemWriteEnable : 1; /* 1=enable. if set, loads oem bits from phy_ctrl register to the 82567. loaded to EXTCNF_CTRL register. default is 1 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t reserved1 : 1; /* Reserved. default value 1 according to datasheet and deblobed_descriptor.bin */
+ uint8_t reserved2 : 1; /* Reserved. default value 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t reserved3 : 1; /* Reserved. default value 0 according to datasheet and deblobbed_descriptor.bin */
+ /* most significant bits */
+};
+
+/* Word 15h */
+struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_2 {
+ /* least significant bits */
+ uint8_t reserved : 8; /* Reserved. Should be 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t extendedPhyLength : 8; /* dword: size of extended phy configuration area. most be 0 if phy config area is disabled. default is 0000101 (binary) or 05 (hex) according to datasheet, but 00001010 (0A) according to deblobbed_descriptor.bin. Is 0000101 (in the datasheet) a typo that actually means 00001010? */
+ /* most significant bits */
+};
+
+/*
+ * Word 17h: LED 1 Configuration and Power Management
+ *
+ * Default values for LEDCTL register fields controlling LED1 (LINK_1000)
+ * output behaviours and OEM fields that define PHY power management
+ * parameters loaded to the PHY_CTRL register.
+ */
+struct LED_CTL_1 {
+ /* least significant bits */
+
+ /* See page 16 in the datasheet to show the different modes. deblobbed_descriptor.bin has "ACTIVITY" mode set */
+ uint8_t led1Mode : 4; /* Default value 0111 (bin) 7 (hex) says datasheet. 1011 (bin) B (hex) according to deblobbed_descriptor.bin */
+
+ uint8_t reserved1 : 1; /* Reserved. Should be 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led1BlinkMode : 1; /* 0 = slow blink, 1 = fast blink. should be identical to led0 blink mode. Default is 0 according to datasheet and deblobbed_descriptor.bin */
+ /* By setting this and led0 blink mode (see word 18h) to 1, you could enable a faster blinking on the LED's where the ethernet cable goes
+ * on the gigabit ethernet port. Not really useful. Slow blink is fine, and probably better (the LED will probably last longer) */
+
+ uint8_t led1Invert : 1; /* initial value of LED1_IVRT field. 0 = led1 has active low output, 1 is high active output. Default is 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led1Blink : 1; /* 1 = led1 blinks, 0 = it does not. default 0 according to datasheet, but it's 1 in deblobbed_descriptor.bin */
+ uint8_t reserved2 : 1; /* Reserved. should be 1 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t lpluEnable : 1; /* Low Power Link Up. Enable links at lowest supported speed by both link partners in all power states. 1=enabled(all power states), 0=disabled. Default is 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t lpluEnableNonD0a : 1; /* Low Power Link up (non-D0a states). Same as above but only for non-D0a states. default is 1 according to and deblobbed_descriptor.bin */
+ uint8_t gbeDisableNonD0a : 1; /* If set to 1, disable gigabit speeds in non-D0a power states. Must be 1 (according to datasheet) because GbE is not supported in Sx mode. It's also set to 1 in deblobbed_descriptor.bin */
+ uint8_t reserved3 : 2; /* Reserved. Datasheet says both bits should be 0 (confirmed in deblobbed_descriptor.bin) */
+ uint8_t gbeDisable : 1; /* When 1, gigabit speeds are disabled in all power states including D0a. Default is 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t reserved4 : 1; /* Reserved. Should be 1, according to datasheet and deblobbed_descriptor.bin */
+ /* most significant bits */
+};
+
+/*
+ * Word 18: LED 0 and 2 Configuration Defaults
+ *
+ * Hardware defaults for LEDCTL register fields controlling LED0 (LINK/ACTIVITY)
+ * and LED2 (LINK_100) output behaviours.
+ */
+struct LED_CTL_02 {
+ /* least significant bits */
+
+ /* see page 16 in datasheet to show the different modes. deblobbed_descriptor has "LINK-UP" mode set */
+ uint8_t led0Mode : 4; /* default value 0100 (bin) or 4 (hex) according to datasheet. It's 0010 (bin) or 2 (hex) according to deblobbed_descriptor.bin */
+
+ uint8_t reserved1 : 1; /* Reserved. Should be set to 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led0BlinkMode : 1; /* This should be the same as led1BlinkMode (see word 17h). Default is 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led0Invert : 1; /* initial value of LED0_IVRT field. 0 = led0 has active low output, 1 is high active output. Default is 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led0Blink : 1; /* LED0_BLINK field. Should be 0 according to datasheet and deblobbed_descriptor.bin */
+
+ /* see page 16 in datasheet to shew the different modes. deblobbed_descriptor has "LINK_100" mode set */
+ uint8_t led2Mode : 4; /* default value 0110 (bin) or 6 (hex) according to datasheet and deblobbed_descriptor.bin */
+
+ uint8_t reserved2 : 1; /* Reserved. Should be 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led2BlinkMode : 1; /* 0 = slow blink. 1 = fast. default 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led2Invert : 1; /* LED2_IVRT field. Should be 0 according to datasheet and deblobbed_descriptor.bin */
+ uint8_t led2Blink : 1; /* LED2_BLINK field. should be 0 according to datasheet and deblobbed_descriptor.bin */
+ /* most significant bits */
+};
+
+/* Word 30h */
+struct GBE_PXE_BOOT_AGENT_MAIN_SETUP_OPTIONS {
+ /* least significant bits */
+ uint8_t protocolSelect : 2; /* Default 00 binary (PXE) according to datasheet. 01 is reserved. 10/11 are undefined. deblobbed_descriptor.bin says 00 */
+ uint8_t reserved1 : 1; /* Reserved. deblobbed_descriptor.bin says 0 */
+ uint8_t defaultBootSelection : 2; /* deblobbed_descriptor.bin says 00 (binary). 00 is network boot, then local. 01 is local boot, then network. 10 is network boot only. 11 is local boot only */
+ uint8_t reserved2 : 1; /* Reserved. deblobbed_descriptor.bin says 0. */
+ uint8_t promptTime : 2; /* deblobbed_descriptor.bin says 00. delay for how long "press ctrl-s" setup prompt message appears. 00 = 2 secs, 01 is 3 secs, 10 is 5 secs, 11 is 0 secs. */
+ uint8_t displaySetupMessage : 1; /* default 1 says datasheet. deblobbed_descriptor.bin says 1. if 1, "ctrl-s" setup prompt message appears after the title message. */
+ uint8_t reserved3 : 1; /* Datasheet says to set 0. deblobbed_descriptor.bin says 0. */
+ uint8_t forceSpeed : 2; /* deblobbed_descriptor.bin says 00. 00 = auto-negotiate, 01 = 10Mbps, 10 = 100Mbps, 11 = "not allowed" */
+ uint8_t forceFullDuplex : 1; /* deblobbed_descriptor.bin says 0. Only relevant when bits 10/11 are set; if so, then: 0 = half duplex, 1 = full duplex */
+ uint8_t reserved4 : 1; /* Reserved. deblobbed_descriptor.bin says 0. datasheet recommends 0. */
+ uint8_t efiPresence : 1; /* 1 means that an EFI image is present (0 means not present). deblobbed_descriptor.bin says 0. if 1, eeprom word 33h (efi version) becomes valid. if pxePresent is 1, that means EFI and PXE are both present.*/
+ uint8_t pxePresence : 1; /* 0 means that a PXE image is present. 1 means to pxe present. deblobbed_descriptor.bin says 0. if 0, then word 32h (PXE version) in eeprom becomes valid */
+ /* most significant bits */
+
+ /* This whole data structure is pointless, since libreboot doesn't (read: won't)
+ * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
+};
+/* Word 31h */
+struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_31H {
+ /* least significant bits */
+ uint8_t disableSetupMenu : 1; /* 1 means invoking setup menu with ctrl-s won't work. deblobbed_descriptor.bin says 0 (as is default, per datasheet) */
+ uint8_t disableTitleMessage : 1; /* 1 means that title in boot agent screen is suppressed, as is ctrl-s message. default is 0, and deblobbed_descriptor.bin says 0 */
+ uint8_t disableProtocolSelect : 1; /* 1 means no changes to boot protocol are allowed. default is 0, and deblobbed_descriptor.bin says 0 */
+ uint8_t disableBootSelection : 1; /* 1 means no changes in boot order option menu are allowed. default is 0, and deblobbed_descriptor.bin says 0 */
+ uint8_t disableLegacyWakeupSupport : 1; /* 1 means no changes in legacy wakeup support menu is allowed. default is 0, and deblobbed_descriptor.bin says 0 */
+ uint8_t disableFlashUpdate : 1; /* 1 means no changes to flash image using PROset is allowed. default is 0, and deblobbed_descriptor.bin says 0 */
+ uint8_t reserved1 : 2; /* Reserved. Datasheet says these must be 0, and deblobbed_descriptor.bin sets them to 0. */
+
+ /*
+ * deblobbed_descriptor says 000
+ * 000 = normal behaviour
+ * see datasheet (page 21) for other modes.
+ */
+ uint8_t ibaBootOrderSetupMode : 3;
+
+ uint8_t reserved2 : 3; /* Reserved. Datasheet says these must be set to 0, and deblobbed_descriptor.bin sets them to 0. */
+ uint8_t signature : 2; /* Must be set to 01 to indicate that this whole word has been configured by the agent or other software. deblobbed_descriptor.bin says 01. */
+ /* most significant bits */
+
+ /* This whole data structure is pointless, since libreboot doesn't (read: won't)
+ * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
+};
+/* Word 32h */
+struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_32H {
+ /* least significant bits */
+ uint8_t buildNumber : 8; /* PXE boot agent build number. default is 28 (hex). deblobbed_descriptor.bin says 18 (hex) */
+ uint8_t minorVersionNumber : 4; /* PXE boot agent minor number. default is 2 (hex). deblobbed_descriptor.bin says 3 (hex) */
+ uint8_t majorVersionNumber : 4; /* PXE boot agent major number. default is F (hex). deblobbed_descriptor.bin says 1 (hex) */
+ /* most significant bits */
+
+ /* This whole data structure is pointless, since libreboot doesn't (read: won't)
+ * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
+};
+/* Word 33h */
+struct GBE_PXE_IBA_CAPABILITIES {
+ /* least significant bits */
+ uint8_t baseCodePresent : 1; /* 0 means PXE base code is indicated as being present. 1 (default) means not. deblobbed_descriptor.bin says 1 */
+ uint8_t undiCapabilityPresent : 1; /* 1 (default) means pxe/undi capability is indicated present. 0 means not present. deblobbed_descriptor.bin says 1 */
+ uint8_t reserved1 : 1; /* Reserved. Must be 1. deblobbed_descriptor.bin says 1 */
+ uint8_t efiUndiCapabilityPresent : 1; /* EFI UNDI capability present: 0 (default) means not present. 1 means present. deblobbed_descriptor.bin says 0 */
+ uint8_t reserved2_0 : 4; /* reserved. all bits must be 0. deblobbed_descriptor.bin sets them to 0. */
+ uint8_t reserved2_1 : 6; /* ^ part of reserved2_0. split this way so that the bitfields align */
+ uint8_t signature : 2; /* must be 01 to indicate that the word is configured by the agent or other software. deblobbed_descriptor.bin says 01 */
+ /* most significant bits */
+
+ /* This whole data structure is pointless, since libreboot doesn't (read: won't)
+ * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
+};
+/* Words 30h to 3Eh */
+struct GBE_PXE_SOFTWARE_REGION {
+ struct GBE_PXE_BOOT_AGENT_MAIN_SETUP_OPTIONS bootAgentMainSetupOptions; /* Word 30h */
+ struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_31H bootAgentConfigurationCustomizationOptions31h; /* Word 31h */
+ struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_32H bootAgentConfigurationCustomizationOptions32h; /* Word 32h */
+ struct GBE_PXE_IBA_CAPABILITIES ibaCapabilities; /* Word 33h */
+
+ /* Words 34h to 3Eh (padding). Set these to 0xFFFF (according to deblobbed_descriptor.bin) */
+ uint16_t paddingWords34hTo3Eh[11];
+
+ /*
+ * the pxe software region is practically useless in libreboot, since
+ * libreboot does not include the intel boot agent (it's proprietary software).
+ *
+ * Having this struct in place is simply for documentations sake. It is completely
+ * irrelevant what you put here. filling it with 0xFFFF would probably be fine.
+ */
+};
+
+struct GBEREGIONRECORD_4K {
+ uint8_t macAddress[6]; /* Word 00 to 02 */
+ struct GBE_RESERVED_WORD_03H reservedWord03h; /* Reserved word 03. */
+ uint16_t reservedWord04h; /* Reserved word 04: set it to 0xFFFF (according to datasheet and deblobbed_descriptor.bin) */
+ uint16_t imageVersionInformation; /* Reserved word 05: 83 10 (little endian) in my deblobbed_descriptor.bin. Set this to 0x1083 (in C, assuming little endian byte order). "cannot be changed" according to datasheet */
+ uint16_t reservedWords06h07h[2]; /* Reserved words 06-07: set both to 0xFFFF (according to datasheet and deblobbed_descriptor.bin) */
+
+ /*
+ * Word 08 and 09 (pba low and pba high):
+ *
+ * Both of these should be set to 0xFFFF by default, according to the datasheet.
+ * "nine digit printed board assembly (PBA) number" for intel cards to be stored
+ * in a 4 byte (read: 2 word) field.
+ *
+ * Example: if pba number is 123456-003, then word 08 should be 1234h and word 09 becomes 5603.
+ * Note: 1234 and 5603 above are big endian. In the image it would actually be 34 12 and 0356
+ *
+ * Example: in mine it was (in the image): 08 10 FF FF. That becomes 1008h and FFFFh, or
+ * basically: 1008FF-0FF. The same was observed in another.
+ *
+ * Setting it to FF FF FF FF should be fine, according to the datasheet.
+ */
+ uint16_t pbaLow; /* Word 08. Set it to 0x1008 (according to deblobbed_descriptor.bin). */
+ uint16_t pbaHigh; /* Word 09. Set it to 0xFFFF (according to deblobbed_descriptor.bin). */
+
+ /* Word 0A */
+ struct GBE_PCI_INITIALIZATION_CONTROL_WORD pciInitializationControlWord;
+
+ /*
+ * Word 0B; subsystem ID
+ *
+ * If load subsystem ID bit of word 0A (pci init control word) is
+ * set to 1 (read: it is. in my deblobbed_descriptor.bin), store
+ * the subsystem id here. Datasheet says that the default value is
+ * 0000h, but you should set this to 20EEh (little endian: EE 20)
+ */
+ uint16_t subsystemId; /* Set this to 0x20EE */
+
+ /*
+ * Word 0C; subsystem vendor ID
+ *
+ * If load subsystem vendor ID bit of word 0A (pci init control word)
+ * is set to 1 (read: it is. in my deblobbed_descriptor.bin), store
+ * the subsystem vendor id here. Datasheet says that the default
+ * value is 8086h, but you should set this to 17AAh (lendian: AA 17).
+ */
+ uint16_t subsystemVendorId; /* Set this to 0x17AA */
+
+ /*
+ * Word 0D: device ID
+ *
+ * If load vendor/device ID in word 0A (pci init control word) is 1
+ * (it is) then this word is used to init device id using word 21h,
+ * 1Eh or 1Fh. In my case, deviceId is 0x10F5. Word 21h is set to
+ * 0x10CB, word 1Eh is 0x10F5 and 1Fh is 0x10BF
+ *
+ * The datasheet says that 10F5 is for Intel 82567LM gigabit ethernet
+ * controller; 10BF is for Intel 82567LF and 10CB is for Intel 82567V.
+ *
+ * Based on this, the X200 is shown to have the Intel 82567LM ethernet
+ * controller.
+ */
+ uint16_t deviceId; /* Set this to 0x10F5. */
+ /* It is important that this is correct, for the linux kernel driver */
+
+ /*
+ * Word 0E: vendor ID
+ *
+ * If load vendor/device ID in word 0A (pci init control) is 1 (it is),
+ * then this word used read to initialize the PCI vendor ID. Default
+ * value is 8086 according to datasheets, and deblobbed_descriptor.bin.
+ *
+ * Intel is often 8086 as a PCI vendor ID. Because 8086. As in the CPU architecture.
+ */
+ uint16_t vendorId;
+
+ uint16_t deviceRevId; /* Word 0F: reserved bits. Set all bits to 0. */
+ struct GBE_LAN_POWER_CONSUMPTION lanPowerConsumption; /* Word 10: LAN Power Consumption (see struct definition) */
+ uint16_t reservedWords11h12h[2]; /* Words 11-12: Reserved. Set both of them to 0x0000 (according to datasheet). */
+
+ /* Word 13: Shared Initialization Control Word */
+ struct GBE_SHARED_INITIALIZATION_CONTROL_WORD sharedInitializationControlWord;
+
+ /* Word 14: Extended Configuration Control Word 1 */
+ struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_1 extendedConfigurationControlWord1;
+
+ /* Word 15: Extended Configuration Control Word 2 */
+ struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_2 extendedConfigurationControlWord2;
+
+ /* Word 16: Extended Configuration Control Word 3 */
+ /* All bits reserved. Datasheet and deblobbed_descriptor.bin say to set it to zero */
+ uint16_t extendedConfigurationControlWord3;
+
+ struct LED_CTL_1 ledCtl1; /* Word 17: LED 1 Configuration and Power Management */
+ struct LED_CTL_02 ledCtl02; /* Word 18: LED 0 and 2 Configuration Defaults */
+ uint16_t reservedWord19h; /* Word 19: Reserved. Default is 0x2B00 according to datasheet, but in deblobbed_descriptor.bin it is 0x2B40 */
+ uint16_t reservedWord1Ah; /* Word 1A: Reserved. Default is 0x0043 according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWord1Bh; /* Word 1B: Reserved. Should be 0x0000 according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWord1Ch; /* Word 1C: Reserved. Should be 0x10F5 according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWord1Dh; /* Word 1D: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
+ uint16_t _82567lmDeviceId; /* Word 1E: Device ID for Intel 82567LM gigabit ethernet controller (note: X200 uses this). Should be 0x10F5 according to datasheet and deblobbed_descriptor.bin*/
+ uint16_t _82567lfDeviceId; /* Word 1F: Device ID for Intel 82567LF gigabit ethernet controller. Should be 0x10BF according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWord20h; /* Word 20: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
+ uint16_t _82567vDeviceId; /* Word 21: Device ID for Intel 82567V gigabit ethernet controller. Should be 0x10CB according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWord22h; /* Word 22: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWord23h; /* Word 23: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
+ uint16_t reservedWords24to2Fh[12]; /* Words 24-2F: Reserved. These should all be 0x0000 according to datasheet and deblobbed_descriptor.bin */
+ struct GBE_PXE_SOFTWARE_REGION pxeSoftwareRegion; /* Words 30-3E: PXE Software Region */
+ uint16_t checkSum; /* when added to the sum of all words above, this should match GBECHECKSUMTOTAL */
+
+ /* set all bytes in here to 0xFF */
+ uint8_t padding[3968];
+};
+
+/* main and backup region in gbe */
+struct GBEREGIONRECORD_8K {
+ struct GBEREGIONRECORD_4K main;
+ struct GBEREGIONRECORD_4K backup;
+ /*
+ * Backup region:
+ * This is actually "main" on X200, since the real main has a bad checksum
+ * and other errors. You should do what you need on this one (if modifying
+ * lenovobios's gbe region) and then copy to main
+ */
+};
+
+/*
+ * ---------------------------------------------------------------------
+ * Function declarations (keep gcc/make happy. check them in gbe.c)
+ * ---------------------------------------------------------------------
+ */
+
+uint16_t gbeGetChecksumFrom4kBuffer(uint16_t* gbeWord, uint16_t desiredValue, int gbeRegionBase);
+uint16_t gbeGetChecksumFrom4kStruct(struct GBEREGIONRECORD_4K gbeStruct4k, uint16_t desiredValue);
+struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8K factoryGbeStruct8k);
+int notCreatedHFileForGbeCFile(char* outFileName, char* cFileName);
+int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* outFileName, char* headerFileName);
+int showGbeData(struct GBEREGIONRECORD_4K gbeStruct4k);
+void printGbeChecksumDataFromStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* romName, char* regionName);
+void printGbeChecksumDataFromStruct8k(struct GBEREGIONRECORD_8K gbeStruct8k, char* romName);
+
+#endif