From b2321c6f7be6e0d9fe1e9ef01427f353a0eb55a7 Mon Sep 17 00:00:00 2001 From: Andrew Robbins Date: Sat, 13 Jan 2018 16:59:15 -0500 Subject: Copy ich9gen sources into projects/ich9gen/sources Sources for ich9deblob and demefactory are included alongside ich9gen and preserved for future applications. --- projects/ich9gen/sources/src/gbe/gbe.c | 454 +++++++++++++++++++++++++++++++++ projects/ich9gen/sources/src/gbe/gbe.h | 435 +++++++++++++++++++++++++++++++ 2 files changed, 889 insertions(+) create mode 100644 projects/ich9gen/sources/src/gbe/gbe.c create mode 100644 projects/ich9gen/sources/src/gbe/gbe.h (limited to 'projects/ich9gen/sources/src/gbe') diff --git a/projects/ich9gen/sources/src/gbe/gbe.c b/projects/ich9gen/sources/src/gbe/gbe.c new file mode 100644 index 00000000..d04b8f2a --- /dev/null +++ b/projects/ich9gen/sources/src/gbe/gbe.c @@ -0,0 +1,454 @@ +/* + * gbe/gbe.c + * This file is part of the ich9deblob utility from the libreboot project + * + * Copyright (C) 2014 Steve Shenton + * Leah Rowe + * + * 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 . + */ + +/* + * 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 \n"); + fprintf(fp, "#include \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 = 0x%04x;\n", gbeStruct4k.checkSum); + 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; +} + +/* + * --------------------------------------------------------------------- + * 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/projects/ich9gen/sources/src/gbe/gbe.h b/projects/ich9gen/sources/src/gbe/gbe.h new file mode 100644 index 00000000..a1350fdd --- /dev/null +++ b/projects/ich9gen/sources/src/gbe/gbe.h @@ -0,0 +1,435 @@ +/* + * gbe/gbe.h + * This file is part of the ich9deblob utility from the libreboot project + * + * Copyright (C) 2014 Steve Shenton + * Leah Rowe + * + * 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 . + */ + +/* + * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums + */ + +#ifndef GBESTRUCT_H +#define GBESTRUCT_H + +#include +#include +#include +#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); +void printGbeChecksumDataFromStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* romName, char* regionName); +void printGbeChecksumDataFromStruct8k(struct GBEREGIONRECORD_8K gbeStruct8k, char* romName); + +#endif -- cgit v1.2.3-70-g09d2 From 115fe0d7fe537a3069ba2051942c2f3333d0baa5 Mon Sep 17 00:00:00 2001 From: Andrew Robbins Date: Mon, 15 Jan 2018 21:47:32 -0500 Subject: Delete trailing whitespace from ich9gen & co. --- projects/ich9gen/sources/Makefile | 16 +-- .../ich9gen/sources/src/common/descriptor_gbe.c | 36 +++---- .../ich9gen/sources/src/common/descriptor_gbe.h | 4 +- .../ich9gen/sources/src/common/x86compatibility.c | 48 ++++----- .../ich9gen/sources/src/common/x86compatibility.h | 4 +- projects/ich9gen/sources/src/demefactory.c | 38 +++---- projects/ich9gen/sources/src/demefactory.h | 4 +- .../ich9gen/sources/src/descriptor/descriptor.c | 94 ++++++++--------- .../ich9gen/sources/src/descriptor/descriptor.h | 44 ++++---- projects/ich9gen/sources/src/gbe/gbe.c | 78 +++++++------- projects/ich9gen/sources/src/gbe/gbe.h | 116 ++++++++++----------- projects/ich9gen/sources/src/ich9deblob.c | 44 ++++---- projects/ich9gen/sources/src/ich9deblob.h | 4 +- projects/ich9gen/sources/src/ich9gen.c | 46 ++++---- projects/ich9gen/sources/src/ich9gen.h | 4 +- .../ich9gen/sources/src/ich9gen/mkdescriptor.c | 1 - projects/ich9gen/sources/src/ich9gen/mkgbe.c | 1 - 17 files changed, 290 insertions(+), 292 deletions(-) (limited to 'projects/ich9gen/sources/src/gbe') diff --git a/projects/ich9gen/sources/Makefile b/projects/ich9gen/sources/Makefile index dad57e7f..e16b63f0 100644 --- a/projects/ich9gen/sources/Makefile +++ b/projects/ich9gen/sources/Makefile @@ -1,4 +1,4 @@ -# +# # Makefile for ich9deblob utility from libreboot project # # Copyright (C) 2014, 2015 Leah Rowe @@ -26,15 +26,15 @@ all: ich9deblob ich9gen demefactory ich9deblob: obj/ich9deblob.o obj/common/descriptor_gbe.o \ obj/descriptor/descriptor.o obj/gbe/gbe.o obj/common/x86compatibility.o - + $(CC) $(CFLAGS) obj/ich9deblob.o obj/common/descriptor_gbe.o \ obj/common/x86compatibility.o obj/descriptor/descriptor.o obj/gbe/gbe.o \ -o ich9deblob - + ich9gen: obj/ich9gen.o obj/ich9gen/mkdescriptor.o obj/ich9gen/mkgbe.o \ obj/common/descriptor_gbe.o \ obj/descriptor/descriptor.o obj/gbe/gbe.o obj/common/x86compatibility.o - + $(CC) $(CFLAGS) obj/ich9gen.o obj/ich9gen/mkdescriptor.o obj/ich9gen/mkgbe.o \ obj/common/descriptor_gbe.o \ obj/common/x86compatibility.o obj/descriptor/descriptor.o obj/gbe/gbe.o \ @@ -42,7 +42,7 @@ ich9gen: obj/ich9gen.o obj/ich9gen/mkdescriptor.o obj/ich9gen/mkgbe.o \ demefactory: obj/demefactory.o obj/common/descriptor_gbe.o \ obj/descriptor/descriptor.o obj/gbe/gbe.o obj/common/x86compatibility.o - + $(CC) $(CFLAGS) obj/demefactory.o obj/common/descriptor_gbe.o \ obj/common/x86compatibility.o obj/descriptor/descriptor.o obj/gbe/gbe.o \ -o demefactory @@ -64,7 +64,7 @@ obj/ich9deblob.o: obj/ich9gen.o: $(CC) $(CFLAGS) $(NOLINKER) src/ich9gen.c -o obj/ich9gen.o - + obj/ich9gen/mkdescriptor.o: $(CC) $(CFLAGS) $(NOLINKER) src/ich9gen/mkdescriptor.c -o obj/ich9gen/mkdescriptor.o @@ -76,7 +76,7 @@ obj/ich9gen/mkgbe.o: obj/common/descriptor_gbe.o: $(CC) $(CFLAGS) $(NOLINKER) src/common/descriptor_gbe.c -o obj/common/descriptor_gbe.o - + obj/common/x86compatibility.o: $(CC) $(CFLAGS) $(NOLINKER) src/common/x86compatibility.c -o obj/common/x86compatibility.o @@ -85,7 +85,7 @@ obj/descriptor/descriptor.o: obj/gbe/gbe.o: $(CC) $(CFLAGS) $(NOLINKER) src/gbe/gbe.c -o obj/gbe/gbe.o - + # make clean # ---------------------------------------------------------------------- clean: diff --git a/projects/ich9gen/sources/src/common/descriptor_gbe.c b/projects/ich9gen/sources/src/common/descriptor_gbe.c index 1c1ad32b..bce8afc3 100644 --- a/projects/ich9gen/sources/src/common/descriptor_gbe.c +++ b/projects/ich9gen/sources/src/common/descriptor_gbe.c @@ -1,7 +1,7 @@ /* * descriptor_gbe.c * This file is part of the ich9deblob utility from the libreboot project - * + * * Purpose: common descriptor/gbe functions used by ich9deblob * * Copyright (C) 2014, 2015 Leah Rowe @@ -20,71 +20,71 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #include "descriptor_gbe.h" -/* +/* * create 12KiB file with descriptor, and then gbe immediately after. */ int notCreatedDescriptorGbeFile(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k, char* fileName) { FILE* fileStream = NULL; - + /* delete old file before continuing */ remove(fileName); - + /* open new file for writing the descriptor+gbe */ fileStream = fopen(fileName, "ab"); - + /* write the descriptor region into the first part */ if (DESCRIPTORREGIONSIZE != fwrite((uint8_t*)&descriptorStruct, 1, sizeof(descriptorStruct), fileStream)) { printf("\nerror: writing descriptor region failed\n"); return 1; } - + /* add gbe to the end of the file */ if (GBEREGIONSIZE_8K != fwrite((uint8_t*)&gbeStruct8k, 1, sizeof(gbeStruct8k), fileStream)) { printf("\nerror: writing GBe region failed\n"); return 1; } - + fclose(fileStream); - + printf("descriptor and gbe successfully written to the file: %s\n", fileName); printf("Now do: dd if=%s of=libreboot.rom bs=1 count=12k conv=notrunc\n", fileName); printf("(in other words, add the modified descriptor+gbe to your ROM image)\n\n"); - + return 0; } -/* +/* * create 4KiB file with descriptor */ int notCreated4kDescriptorFile(struct DESCRIPTORREGIONRECORD descriptorStruct, char* fileName) { FILE* fileStream = NULL; - + /* delete old file before continuing */ remove(fileName); - + /* open new file for writing the descriptor+gbe */ fileStream = fopen(fileName, "ab"); - + /* write the descriptor region into the first part */ if (DESCRIPTORREGIONSIZE != fwrite((uint8_t*)&descriptorStruct, 1, sizeof(descriptorStruct), fileStream)) { printf("\nerror: writing descriptor region failed\n"); return 1; } - - + + fclose(fileStream); - + printf("descriptor successfully written to the file: %s\n", fileName); printf("Now do: dd if=%s of=yourrom.rom bs=1 count=4k conv=notrunc\n", fileName); printf("(in other words, add the modified descriptor to your ROM image)\n\n"); - + return 0; } diff --git a/projects/ich9gen/sources/src/common/descriptor_gbe.h b/projects/ich9gen/sources/src/common/descriptor_gbe.h index b3713c80..ff685720 100644 --- a/projects/ich9gen/sources/src/common/descriptor_gbe.h +++ b/projects/ich9gen/sources/src/common/descriptor_gbe.h @@ -1,7 +1,7 @@ /* * gbe_descriptor.h * This file is part of the ich9deblob utility from the libreboot project - * + * * Purpose: header file for descriptor_gbe.c * * Copyright (C) 2014, 2015 Leah Rowe @@ -20,7 +20,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #ifndef COMMON_DESCRIPTOR_GBE_H #define COMMON_DESCRIPTOR_GBE_H diff --git a/projects/ich9gen/sources/src/common/x86compatibility.c b/projects/ich9gen/sources/src/common/x86compatibility.c index 362c634b..522f3e29 100644 --- a/projects/ich9gen/sources/src/common/x86compatibility.c +++ b/projects/ich9gen/sources/src/common/x86compatibility.c @@ -1,7 +1,7 @@ /* * x86compatibility.c * This file is part of the ich9deblob utility from the libreboot project - * + * * Purpose: compiler/cpu compatibility checks. ich9deblob is not portable, yet. * * Copyright (C) 2014 Steve Shenton @@ -30,11 +30,11 @@ */ /* fail if struct size is incorrect */ -int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct GBEREGIONRECORD_8K gbe8kDummy) +int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct GBEREGIONRECORD_8K gbe8kDummy) { unsigned int descriptorRegionStructSize = sizeof(descriptorDummy); unsigned int gbeRegion8kStructSize = sizeof(gbe8kDummy); - + /* check compiler bit-packs in a compatible way. basically, it is expected that this code will be used on x86 */ if (DESCRIPTORREGIONSIZE != descriptorRegionStructSize){ printf("\nerror: compiler incompatibility: descriptor struct length is %i bytes (should be %i)\n", descriptorRegionStructSize, DESCRIPTORREGIONSIZE); @@ -44,7 +44,7 @@ int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct G printf("\nerror: compiler incompatibility: gbe struct length is %i bytes (should be %i)\n", gbeRegion8kStructSize, GBEREGIONSIZE_8K); return 1; } - + return 0; } @@ -54,7 +54,7 @@ int structMembersWrongOrder() int i; struct DESCRIPTORREGIONRECORD descriptorDummy; uint8_t *meVsccTablePtr = (uint8_t*)&descriptorDummy.meVsccTable; - + /* These do not use bitfields. */ descriptorDummy.meVsccTable.jid0 = 0x01020304; /* unsigned int 32-bit */ descriptorDummy.meVsccTable.vscc0 = 0x10203040; /* unsigned int 32-bit */ @@ -66,10 +66,10 @@ int structMembersWrongOrder() descriptorDummy.meVsccTable.padding[1] = 0xBB; /* unsigned char 8-bit */ descriptorDummy.meVsccTable.padding[2] = 0xCC; /* unsigned char 8-bit */ descriptorDummy.meVsccTable.padding[3] = 0xDD; /* unsigned char 8-bit */ - + /* * Look from the top down, and concatenate the unsigned ints but - * with each unsigned in little endian order. + * with each unsigned in little endian order. * Then, concatenate the unsigned chars in big endian order. (in the padding array) * * combined, these should become: @@ -77,7 +77,7 @@ int structMembersWrongOrder() * 04030201 40302010 44332211 08070605 80706050 88776655 AA BB CC DD (ignore this. not byte-separated, just working it out:) * 04 03 02 01 40 30 20 10 44 33 22 11 08 07 06 05 80 70 60 50 88 77 66 55 AA BB CC DD <-- it should match this */ - + if ( ! ( @@ -90,65 +90,65 @@ int structMembersWrongOrder() && *(meVsccTablePtr+24) == 0xAA && *(meVsccTablePtr+25) == 0xBB && *(meVsccTablePtr+26) == 0xCC && *(meVsccTablePtr+27) == 0xDD ) ) { - + printf("\nStruct member order check (descriptorDummy.meVsccTable) with junk/dummy data:"); printf("\nShould be: 04 03 02 01 40 30 20 10 44 33 22 11 08 07 06 05 80 70 60 50 88 77 66 55 aa bb cc dd "); printf("\nAnd it is: "); - + for (i = 0; i < 28; i++) { - printf("%02x ", *(meVsccTablePtr + i)); + printf("%02x ", *(meVsccTablePtr + i)); } printf("\nIncorrect order.\n"); - + return 1; } - + return 0; } /* fail if bit fields are presented in the wrong order */ -int structBitfieldWrongOrder() +int structBitfieldWrongOrder() { int i; struct DESCRIPTORREGIONRECORD descriptorDummy; uint8_t *flMap0Ptr = (uint8_t*)&descriptorDummy.flMaps.flMap0; - + descriptorDummy.flMaps.flMap0.FCBA = 0xA2; /* :8 --> 10100010 */ descriptorDummy.flMaps.flMap0.NC = 0x02; /* :2 --> 10 */ descriptorDummy.flMaps.flMap0.reserved1 = 0x38; /* :6 --> 111000 */ descriptorDummy.flMaps.flMap0.FRBA = 0xD2; /* :8 --> 11010010 */ descriptorDummy.flMaps.flMap0.NR = 0x05; /* :3 --> 101 */ descriptorDummy.flMaps.flMap0.reserved2 = 0x1C; /* :5 --> 11100 */ - + /* * Look from the top bottom up, and concatenate the binary strings. * Then, convert the 8-bit groups to hex and reverse the (8-bit)byte order - * + * * combined, these should become (in memory), in binary: * 10100010 11100010 11010010 11100101 * or in hex: * A2 E2 D2 E5 */ - - if (!(*flMap0Ptr == 0xA2 && *(flMap0Ptr+1) == 0xE2 && *(flMap0Ptr+2) == 0xD2 && *(flMap0Ptr+3) == 0xE5)) + + if (!(*flMap0Ptr == 0xA2 && *(flMap0Ptr+1) == 0xE2 && *(flMap0Ptr+2) == 0xD2 && *(flMap0Ptr+3) == 0xE5)) { printf("\nBitfield order check (descriptorDummy.flMaps.flMaps0) with junk/dummy data:"); printf("\nShould be: a2 e2 d2 e5 "); printf("\nAnd it is: "); for (i = 0; i < 4; i++) { - printf("%02x ", *(flMap0Ptr + i)); + printf("%02x ", *(flMap0Ptr + i)); } printf("\nIncorrect order.\n"); - + return 1; } - + return 0; } /* Compatibility checks. This version of ich9deblob is not yet porable. */ -int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k) +int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k) { if (structSizesIncorrect(descriptorStruct, gbeStruct8k)) return 1; if (IS_BIG_ENDIAN) { @@ -156,6 +156,6 @@ int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, return 1; } if (structBitfieldWrongOrder()) return 1; - if (structMembersWrongOrder()) return 1; + if (structMembersWrongOrder()) return 1; return 0; } diff --git a/projects/ich9gen/sources/src/common/x86compatibility.h b/projects/ich9gen/sources/src/common/x86compatibility.h index 5a598adc..a4829888 100644 --- a/projects/ich9gen/sources/src/common/x86compatibility.h +++ b/projects/ich9gen/sources/src/common/x86compatibility.h @@ -1,7 +1,7 @@ /* * x86compatibility.h * This file is part of the ich9deblob utility from the libreboot project - * + * * Purpose: keep gcc/make happy. no actual code here, just function definitions. * * Copyright (C) 2014 Steve Shenton @@ -20,7 +20,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #ifndef X86COMPATIBILITY_H #define X86COMPATIBILITY_H diff --git a/projects/ich9gen/sources/src/demefactory.c b/projects/ich9gen/sources/src/demefactory.c index 596118cf..96bb0d41 100644 --- a/projects/ich9gen/sources/src/demefactory.c +++ b/projects/ich9gen/sources/src/demefactory.c @@ -1,12 +1,12 @@ /* * demefactory.c * This file is part of the demefactory utility from the libreboot project - * + * * Purpose: disable ME on GM45 factory firmware, but leave region intact * enable read-write on all regions * * Copyright (C) 2014, 2015 Leah Rowe - * Copyright (C) 2014 Steve Shenton + * Copyright (C) 2014 Steve Shenton * * 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 @@ -21,8 +21,8 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - -/* + +/* * demfactory utility - main */ @@ -32,15 +32,15 @@ int main() { struct DESCRIPTORREGIONRECORD descriptorStruct; uint8_t* descriptorBuffer = (uint8_t*)&descriptorStruct; - + struct GBEREGIONRECORD_8K gbeStruct8k; /* not needed, except for compatibility checking */ - + char* romFilename = "factory.rom"; char* descriptorFilename = "demefactory_4kdescriptor.bin"; - + unsigned int bufferLength; unsigned int romSize; - + /* * ------------------------------------------------------------------ * Compatibility checks. This version of ich9deblob is not yet portable. @@ -49,7 +49,7 @@ int main() if (systemOrCompilerIncompatible(descriptorStruct, gbeStruct8k)) return 1; /* If true, fail with error message */ - + /* * ------------------------------------------------------------------ * Extract the descriptor region from the factory.rom dump @@ -64,33 +64,33 @@ int main() return 1; } printf("\n%s opened successfully\n", romFilename); - - /* + + /* * Get the descriptor region dump from the factory.rom * (goes in factoryDescriptorBuffer variable) */ bufferLength = fread(descriptorBuffer, 1, DESCRIPTORREGIONSIZE, fp); - if (DESCRIPTORREGIONSIZE != bufferLength) // + if (DESCRIPTORREGIONSIZE != bufferLength) // { printf("\nerror: could not read descriptor from %s (%i) bytes read\n", romFilename, bufferLength); fclose(fp); return 1; } printf("\ndescriptor region read successfully\n"); - + /* ------------------------------------------------- */ fseek(fp, 0L, SEEK_END); romSize = ftell(fp); printf("\n%s size: [%i] bytes\n", romFilename, romSize); - + /* -------------------------------------------------- */ fclose(fp); - + /* Debugging (before modification) */ printDescriptorRegionLocations(descriptorStruct, "Original"); - + /* * ------------------------------------------------------------------ * Modify the descriptor region, ready to go in the modified factory.rom @@ -100,7 +100,7 @@ int main() // Disable the ME/TPM: descriptorStruct = descriptorDisableMe(descriptorStruct); descriptorStruct = descriptorDisableTpm(descriptorStruct); - + /* Host/CPU is allowed to read/write all regions. */ descriptorStruct = descriptorHostRegionsUnlocked(descriptorStruct); /* The ME is disallowed read-write access to all regions @@ -120,7 +120,7 @@ int main() if (notCreated4kDescriptorFile(descriptorStruct, descriptorFilename)) { return 1; } - + /* * ------------------------------------------------------------------ * Generate ich9gen data (C code that will recreate the deactivatedME descriptor from scratch) @@ -134,7 +134,7 @@ int main() if (notCreatedCFileFromDescriptorStruct(descriptorStruct, "mkdescriptor.c", "mkdescriptor.h")) { return 1; } - + printf("The modified descriptor region has also been dumped as src files: mkdescriptor.c, mkdescriptor.h\n\n"); return 0; diff --git a/projects/ich9gen/sources/src/demefactory.h b/projects/ich9gen/sources/src/demefactory.h index 7226886b..3478cef5 100644 --- a/projects/ich9gen/sources/src/demefactory.h +++ b/projects/ich9gen/sources/src/demefactory.h @@ -14,9 +14,9 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* Header file for demefactory.c */ - + #ifndef DEMEFACTORY_H #define DEMEFACTORY_H diff --git a/projects/ich9gen/sources/src/descriptor/descriptor.c b/projects/ich9gen/sources/src/descriptor/descriptor.c index 18e4e17a..61ced67e 100644 --- a/projects/ich9gen/sources/src/descriptor/descriptor.c +++ b/projects/ich9gen/sources/src/descriptor/descriptor.c @@ -1,9 +1,9 @@ /* * descriptor/descriptor.c * This file is part of the ich9deblob utility from the libreboot project - * + * * Copyright (C) 2014, 2015 Leah Rowe - * Copyright (C) 2014 Steve Shenton + * Copyright (C) 2014 Steve Shenton * * 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 @@ -32,7 +32,7 @@ * --------------------------------------------------------------------- */ -/* Set the Host CPU / BIOS region to have read-write access on all regions */ +/* Set the Host CPU / BIOS region to have read-write access on all regions */ struct DESCRIPTORREGIONRECORD descriptorHostRegionsUnlocked(struct DESCRIPTORREGIONRECORD descriptorStruct) { descriptorStruct.masterAccessSection.flMstr1.fdRegionReadAccess = 0x1; @@ -80,7 +80,7 @@ struct DESCRIPTORREGIONRECORD descriptorPlatformRegionRemoved(struct DESCRIPTORR { descriptorStruct.regionSection.flReg4.BASE = 0x1FFF; descriptorStruct.regionSection.flReg4.LIMIT = 0; - + return descriptorStruct; } @@ -89,7 +89,7 @@ struct DESCRIPTORREGIONRECORD descriptorDisableMe(struct DESCRIPTORREGIONRECORD { descriptorStruct.ichStraps.ichStrap0.meDisable = 1; descriptorStruct.mchStraps.mchStrap0.meDisable = 1; - + return descriptorStruct; } @@ -97,7 +97,7 @@ struct DESCRIPTORREGIONRECORD descriptorDisableMe(struct DESCRIPTORREGIONRECORD struct DESCRIPTORREGIONRECORD descriptorDisableTpm(struct DESCRIPTORREGIONRECORD descriptorStruct) { descriptorStruct.mchStraps.mchStrap0.tpmDisable = 1; - + return descriptorStruct; } @@ -106,7 +106,7 @@ struct DESCRIPTORREGIONRECORD descriptorMoveGbeToStart(struct DESCRIPTORREGIONRE { descriptorStruct.regionSection.flReg3.BASE = DESCRIPTORREGIONSIZE >> FLREGIONBITSHIFT; descriptorStruct.regionSection.flReg3.LIMIT = GBEREGIONSIZE_8K >> FLREGIONBITSHIFT; - + return descriptorStruct; } @@ -115,7 +115,7 @@ struct DESCRIPTORREGIONRECORD descriptorGbeRegionRemoved(struct DESCRIPTORREGION { descriptorStruct.regionSection.flReg3.BASE = 0x1FFF; descriptorStruct.regionSection.flReg3.LIMIT = 0; - + return descriptorStruct; } @@ -124,7 +124,7 @@ struct DESCRIPTORREGIONRECORD descriptorBiosRegionFillImageAfterGbe(struct DESCR { descriptorStruct.regionSection.flReg1.BASE = (DESCRIPTORREGIONSIZE + GBEREGIONSIZE_8K) >> FLREGIONBITSHIFT; descriptorStruct.regionSection.flReg1.LIMIT = (romSize >> FLREGIONBITSHIFT) - 1; - + return descriptorStruct; } @@ -133,7 +133,7 @@ struct DESCRIPTORREGIONRECORD descriptorBiosRegionFillImageAfterDescriptor(struc { descriptorStruct.regionSection.flReg1.BASE = DESCRIPTORREGIONSIZE >> FLREGIONBITSHIFT; descriptorStruct.regionSection.flReg1.LIMIT = (romSize >> FLREGIONBITSHIFT) - 1; - + return descriptorStruct; } @@ -150,7 +150,7 @@ struct DESCRIPTORREGIONRECORD descriptorOemString(struct DESCRIPTORREGIONRECORD descriptorStruct.oemSection.magicString[7] = 0x45; return descriptorStruct; -} +} /* Check whether a GbE region is defined by this descriptor. * Not thorough, but should work in most cases */ @@ -178,7 +178,7 @@ struct DESCRIPTORREGIONRECORD librebootSetGbeBiosDescriptorRegions(struct DESCRI { if (descriptorDefinesGbeRegion(descriptorStruct)) { - /* + /* * set number of regions from 4 -> 2 (0 based, so 4 means 5 and 2 * means 3. We want 3 regions: descriptor, gbe and bios, in that order) */ @@ -193,7 +193,7 @@ struct DESCRIPTORREGIONRECORD librebootSetGbeBiosDescriptorRegions(struct DESCRI descriptorStruct.ichStraps.ichStrap0.lanPhy = 0x1; } else { - /* + /* * set number of regions from 4 -> 2 (0 based, so 4 means 5 and 1 * means 2. We want 2 regions: descriptor and bios, in that order) */ @@ -237,12 +237,12 @@ struct DESCRIPTORREGIONRECORD librebootDescriptorStructFromFactory(struct DESCRI descriptorStruct = descriptorMeRegionRemoved(descriptorStruct); /* Disable the ME/TPM and remove the ME/Platform regions: */ descriptorStruct = descriptorPlatformRegionRemoved(descriptorStruct); - + /* Disable the ME itself, so that it doesn't try to start when this descriptor is in use */ descriptorStruct = descriptorDisableMe(descriptorStruct); /* Also disable the TPM, by default */ descriptorStruct = descriptorDisableTpm(descriptorStruct); - + return descriptorStruct; } @@ -254,64 +254,64 @@ struct DESCRIPTORREGIONRECORD librebootDescriptorStructFromFactory(struct DESCRI /* * Generate a C (.h) header file for the C source file made by notCreatedCFileFromDescriptorStruct() - * + * * Output it to a file. */ -int notCreatedHFileForDescriptorCFile(char* outFileName, char* cFileName) -{ +int notCreatedHFileForDescriptorCFile(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 descriptor-generating C code (%s) */\n\n", cFileName); - + fprintf(fp, "#ifndef ICH9GEN_MKDESCRIPTOR_H\n"); fprintf(fp, "#define ICH9GEN_MKDESCRIPTOR_H\n\n"); - + fprintf(fp, "#include \n"); fprintf(fp, "#include \n"); fprintf(fp, "#include \"../descriptor/descriptor.h\"\n\n"); - + fprintf(fp, "struct DESCRIPTORREGIONRECORD generatedDescriptorStruct(unsigned int romSize, int hasGbe);\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 Descriptor data structure. - * + * * Output it to a file. */ int notCreatedCFileFromDescriptorStruct(struct DESCRIPTORREGIONRECORD descriptorStruct, char* outFileName, char* headerFileName) { int i, j; - + 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 descriptor-generating C code */\n\n"); - + fprintf(fp, "#include \"%s\"\n\n", headerFileName); - + fprintf(fp, "/* Generate a 4KiB Descriptor struct, with default values. */\n"); fprintf(fp, "/* Read ../descriptor/descriptor.h for an explanation of the default values used here */\n\n"); - + fprintf(fp, "struct DESCRIPTORREGIONRECORD generatedDescriptorStruct(unsigned int romSize, int hasGbe)\n"); fprintf(fp, "{\n"); fprintf(fp, " int i;\n"); @@ -600,11 +600,11 @@ int notCreatedCFileFromDescriptorStruct(struct DESCRIPTORREGIONRECORD descriptor fprintf(fp, "\n"); fprintf(fp, " return descriptorStruct;\n"); fprintf(fp, "}\n\n"); - + /* ------------------------------ */ - + fclose(fp); /* Always close the file when done. */ - + return 0; } @@ -620,7 +620,7 @@ int notCreatedCFileFromDescriptorStruct(struct DESCRIPTORREGIONRECORD descriptor void printDescriptorRegionLocations(struct DESCRIPTORREGIONRECORD descriptorStruct, char* romName) { printf("\n"); - + /* Descriptor region */ printf( "%s: Descriptor start block: %08x ; Descriptor end block: %08x\n", @@ -628,23 +628,23 @@ void printDescriptorRegionLocations(struct DESCRIPTORREGIONRECORD descriptorStru descriptorStruct.regionSection.flReg0.BASE << FLREGIONBITSHIFT, descriptorStruct.regionSection.flReg0.LIMIT << FLREGIONBITSHIFT ); - + /* BIOS region */ printf( - "%s: BIOS start block: %08x ; BIOS end block: %08x\n", + "%s: BIOS start block: %08x ; BIOS end block: %08x\n", romName, - descriptorStruct.regionSection.flReg1.BASE << FLREGIONBITSHIFT, + descriptorStruct.regionSection.flReg1.BASE << FLREGIONBITSHIFT, descriptorStruct.regionSection.flReg1.LIMIT << FLREGIONBITSHIFT ); - + /* ME region */ printf( - "%s: ME start block: %08x ; ME end block: %08x\n", + "%s: ME start block: %08x ; ME end block: %08x\n", romName, - descriptorStruct.regionSection.flReg2.BASE << FLREGIONBITSHIFT, + descriptorStruct.regionSection.flReg2.BASE << FLREGIONBITSHIFT, descriptorStruct.regionSection.flReg2.LIMIT << FLREGIONBITSHIFT ); - + /* GBe region */ printf( "%s: GBe start block: %08x ; GBe end block: %08x\n", @@ -652,7 +652,7 @@ void printDescriptorRegionLocations(struct DESCRIPTORREGIONRECORD descriptorStru descriptorStruct.regionSection.flReg3.BASE << FLREGIONBITSHIFT, descriptorStruct.regionSection.flReg3.LIMIT << FLREGIONBITSHIFT ); - + /* Platform region */ printf( "%s: Platform start block: %08x ; Platform end block: %08x\n", @@ -660,6 +660,6 @@ void printDescriptorRegionLocations(struct DESCRIPTORREGIONRECORD descriptorStru descriptorStruct.regionSection.flReg4.BASE << FLREGIONBITSHIFT, descriptorStruct.regionSection.flReg4.LIMIT << FLREGIONBITSHIFT ); - + return; } diff --git a/projects/ich9gen/sources/src/descriptor/descriptor.h b/projects/ich9gen/sources/src/descriptor/descriptor.h index 7fb5c257..c81d451f 100644 --- a/projects/ich9gen/sources/src/descriptor/descriptor.h +++ b/projects/ich9gen/sources/src/descriptor/descriptor.h @@ -18,7 +18,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* * Purpose: provide struct representing descriptor region. * Map actual buffers of this regions, directly to instances of these @@ -27,10 +27,10 @@ * 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 flash descriptor (read page 845 onwards): * http://www.intel.co.uk/content/dam/doc/datasheet/io-controller-hub-9-datasheet.pdf */ @@ -54,7 +54,7 @@ #define ROMSIZE_8MB 0x800000 #define ROMSIZE_16MB 0x1000000 -/* +/* * Related to the flash descriptor * bits 12(0xC)-24(0x18) are represented for words found in the flash descriptor * To manipulate these easily in C, we shift them by FLREGIONBITSHIFT and then shift them back when done @@ -72,7 +72,7 @@ struct FLVALSIG { /* - * 4 bytes. + * 4 bytes. * descriptor mode = 0FF0A55A (hex, big endian). Note: stored in ROM in little endian order. * Anything else is considered invalid and will put the system in non-descriptor mode. */ @@ -92,7 +92,7 @@ struct FLMAP0 /* most significant bits. */ }; -struct FLMAP1 +struct FLMAP1 { /* least significant bits */ uint8_t FMBA : 8; @@ -103,7 +103,7 @@ struct FLMAP1 /* most significant bits */ }; -struct FLMAP2 +struct FLMAP2 { /* least significant bits */ uint8_t FMSBA : 8; @@ -113,7 +113,7 @@ struct FLMAP2 }; /* Flash Map Registers */ -struct FLMAPS +struct FLMAPS { struct FLMAP0 flMap0; struct FLMAP1 flMap1; @@ -121,7 +121,7 @@ struct FLMAPS }; /* Flash Components Register */ -struct FLCOMP +struct FLCOMP { /* least significant bits */ uint8_t component1Density : 3; @@ -138,7 +138,7 @@ struct FLCOMP /* most significant bits */ }; -struct COMPONENTSECTIONRECORD +struct COMPONENTSECTIONRECORD { struct FLCOMP flcomp; uint32_t flill; @@ -146,7 +146,7 @@ struct COMPONENTSECTIONRECORD uint8_t padding[36]; }; -struct FLREG +struct FLREG { /* least significant bits */ uint16_t BASE : 13; @@ -161,7 +161,7 @@ struct FLREG * Defines where all the regions begin/end. * This is very important for disabling ME/AMT */ -struct REGIONSECTIONRECORD +struct REGIONSECTIONRECORD { struct FLREG flReg0; /* Descriptor */ struct FLREG flReg1; /* BIOS */ @@ -171,7 +171,7 @@ struct REGIONSECTIONRECORD uint8_t padding[12]; }; -struct FLMSTR +struct FLMSTR { /* least significant bits */ uint16_t requesterId : 16; @@ -199,7 +199,7 @@ struct MASTERACCESSSECTIONRECORD uint8_t padding[148]; }; -struct ICHSTRAP0 +struct ICHSTRAP0 { /* least significant bits */ /* todo: add MeSmBus2Sel (boring setting) */ @@ -218,7 +218,7 @@ struct ICHSTRAP0 /* most significant bits */ }; -struct ICHSTRAP1 +struct ICHSTRAP1 { /* least significant bits */ uint8_t northMlink : 1; /* North MLink Dynamic Clock Gate Disable : Sets the default value for the South MLink Dynamic Clock Gate Enable registers. */ @@ -233,14 +233,14 @@ struct ICHSTRAP1 }; /* ICH straps */ -struct ICHSTRAPSRECORD +struct ICHSTRAPSRECORD { struct ICHSTRAP0 ichStrap0; struct ICHSTRAP1 ichStrap1; uint8_t padding[248]; }; -struct MCHSTRAP0 +struct MCHSTRAP0 { /* least significant bits */ uint8_t meDisable : 1; /* If true, ME is disabled. */ @@ -255,14 +255,14 @@ struct MCHSTRAP0 }; /* MCH straps */ -struct MCHSTRAPSRECORD +struct MCHSTRAPSRECORD { struct MCHSTRAP0 mchStrap0; uint8_t padding[3292]; }; /* ME VSCC Table */ -struct MEVSCCTABLERECORD +struct MEVSCCTABLERECORD { uint32_t jid0; uint32_t vscc0; @@ -284,14 +284,14 @@ struct DESCRIPTORMAP2RECORD }; /* OEM section */ -struct OEMSECTIONRECORD +struct OEMSECTIONRECORD { uint8_t magicString[8]; uint8_t padding[248]; }; /* 4KiB descriptor region, goes at the beginning of the ROM image */ -struct DESCRIPTORREGIONRECORD +struct DESCRIPTORREGIONRECORD { struct FLVALSIG flValSig; /* Flash Valid Signature Register */ struct FLMAPS flMaps; /* Flash Map Registers */ @@ -310,7 +310,7 @@ struct DESCRIPTORREGIONRECORD * Function declarations (keep gcc/make happy. check them in descriptor.c) * --------------------------------------------------------------------- */ - + struct DESCRIPTORREGIONRECORD descriptorHostRegionsUnlocked(struct DESCRIPTORREGIONRECORD descriptorStruct); struct DESCRIPTORREGIONRECORD descriptorMeRegionsForbidden(struct DESCRIPTORREGIONRECORD descriptorStruct); struct DESCRIPTORREGIONRECORD descriptorMeRegionRemoved(struct DESCRIPTORREGIONRECORD descriptorStruct); diff --git a/projects/ich9gen/sources/src/gbe/gbe.c b/projects/ich9gen/sources/src/gbe/gbe.c index d04b8f2a..6bd41549 100644 --- a/projects/ich9gen/sources/src/gbe/gbe.c +++ b/projects/ich9gen/sources/src/gbe/gbe.c @@ -18,7 +18,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* * Provide gbe related functions. */ @@ -40,7 +40,7 @@ uint16_t gbeGetChecksumFrom4kBuffer(uint16_t* gbeWord, uint16_t desiredValue, in for (wordOffset = 0; wordOffset < 0x3F; wordOffset++) total += gbeWord[wordOffset + (gbeRegionBase>>1)]; - + return desiredValue - total; } @@ -51,25 +51,25 @@ uint16_t gbeGetChecksumFrom4kStruct(struct GBEREGIONRECORD_4K gbeStruct4k, uint1 } /* modify the gbe region extracted from a factory.rom dump */ -struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8K gbeStruct8k) -{ +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. + * 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; } @@ -81,46 +81,46 @@ struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8 /* * 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) -{ +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 \n"); fprintf(fp, "#include \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) @@ -128,22 +128,22 @@ int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* 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"); @@ -402,7 +402,7 @@ int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* 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"); @@ -410,11 +410,11 @@ int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* 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; } @@ -431,24 +431,24 @@ int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* 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", + "%s Gbe (%s): calculated Gbe checksum: 0x%hx and actual GBe checksum: 0x%hx\n", romName, regionName, - gbeGetChecksumFrom4kStruct(gbeStruct4k, GBECHECKSUMTOTAL), + gbeGetChecksumFrom4kStruct(gbeStruct4k, GBECHECKSUMTOTAL), gbeStruct4k.checkSum ); - + return; } /* - * show debugging info: show calculated (correct) gbe checksum and what + * 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/projects/ich9gen/sources/src/gbe/gbe.h b/projects/ich9gen/sources/src/gbe/gbe.h index a1350fdd..14548e71 100644 --- a/projects/ich9gen/sources/src/gbe/gbe.h +++ b/projects/ich9gen/sources/src/gbe/gbe.h @@ -18,21 +18,21 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums @@ -49,14 +49,14 @@ /* Size of the full gbe region in bytes */ #define GBEREGIONSIZE_8K 0x2000 /* - * Size of each sub-region in gbe. + * 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 @@ -74,7 +74,7 @@ * --------------------------------------------------------------------- * Gbe struct representing the data: * --------------------------------------------------------------------- - */ + */ struct GBE_RESERVED_WORD_03H { /* least significant bits */ @@ -147,17 +147,17 @@ struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_2 { /* * 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 @@ -175,26 +175,26 @@ struct LED_CTL_1 { /* 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 */ @@ -218,7 +218,7 @@ struct GBE_PXE_BOOT_AGENT_MAIN_SETUP_OPTIONS { 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. */ }; @@ -232,18 +232,18 @@ struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_31H { 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. */ }; @@ -254,7 +254,7 @@ struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_32H { 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. */ }; @@ -269,7 +269,7 @@ struct GBE_PXE_IBA_CAPABILITIES { 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. */ }; @@ -279,14 +279,14 @@ struct GBE_PXE_SOFTWARE_REGION { 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). - * + * 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. */ @@ -301,90 +301,90 @@ struct GBEREGIONRECORD_4K { /* * 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. - * + * 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 + * 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. - * + * 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 */ @@ -401,16 +401,16 @@ struct GBEREGIONRECORD_4K { 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 */ +/* 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 @@ -423,7 +423,7 @@ struct GBEREGIONRECORD_8K { * 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); diff --git a/projects/ich9gen/sources/src/ich9deblob.c b/projects/ich9gen/sources/src/ich9deblob.c index d79a3a89..b9153ed6 100644 --- a/projects/ich9gen/sources/src/ich9deblob.c +++ b/projects/ich9gen/sources/src/ich9deblob.c @@ -1,7 +1,7 @@ /* * ich9deblob.c * This file is part of the ich9deblob utility from the libreboot project - * + * * Purpose: disable and remove the ME from ich9m/gm45 systems in coreboot. * * Copyright (C) 2014 Steve Shenton @@ -20,26 +20,26 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* Initially based on proof of concept by Steve Shenton. */ /* Original utility can be found at https://gitorious.org/ich9descriptortool */ - + /* - * Read a factory.rom dump (ich9m/gm45 systems) and + * Read a factory.rom dump (ich9m/gm45 systems) and * modify the flash descriptor to remove all regions except descriptor, * Gbe and BIOS. Set BIOS region to full size of the ROM image (after * the flash descriptor and gbe). Basically, deblob the descriptor. - * + * * This will will generate a concatenated descriptor+gbe dump suitable * for use in libreboot. Currently tested: ThinkPad X200 (coreboot/libreboot) */ - + /* * See docs/hardware/x200_remove_me.html for info plus links to datasheet (also linked below) - * + * * Info about flash descriptor (read page 845 onwards): * http://www.intel.co.uk/content/dam/doc/datasheet/io-controller-hub-9-datasheet.pdf - * + * * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums @@ -51,18 +51,18 @@ int main() { struct DESCRIPTORREGIONRECORD descriptorStruct; uint8_t* descriptorBuffer = (uint8_t*)&descriptorStruct; - + struct GBEREGIONRECORD_8K gbeStruct8k; uint8_t* gbeBuffer8k = (uint8_t*)&gbeStruct8k; uint32_t gbeRegionStart; - + char* romFilename = "factory.rom"; char* descriptorGbeFilename = "deblobbed_descriptor.bin"; char* descriptorNoGbeFilename = "deblobbed_4kdescriptor.bin"; - + unsigned int bufferLength; unsigned int romSize; - + /* * ------------------------------------------------------------------ * Compatibility checks. This version of ich9deblob is not yet portable. @@ -71,7 +71,7 @@ int main() if (systemOrCompilerIncompatible(descriptorStruct, gbeStruct8k)) return 1; /* If true, fail with error message */ - + /* * ------------------------------------------------------------------ * Extract the descriptor and gbe regions from the factory.rom dump @@ -86,20 +86,20 @@ int main() return 1; } printf("\n%s opened successfully\n", romFilename); - - /* + + /* * Get the descriptor region dump from the factory.rom * (goes in factoryDescriptorBuffer variable) */ bufferLength = fread(descriptorBuffer, 1, DESCRIPTORREGIONSIZE, fp); - if (DESCRIPTORREGIONSIZE != bufferLength) // + if (DESCRIPTORREGIONSIZE != bufferLength) // { printf("\nerror: could not read descriptor from %s (%i) bytes read\n", romFilename, bufferLength); fclose(fp); return 1; } printf("\ndescriptor region read successfully\n"); - + if (descriptorDefinesGbeRegion(descriptorStruct)) { gbeRegionStart = descriptorStruct.regionSection.flReg3.BASE << FLREGIONBITSHIFT; @@ -125,13 +125,13 @@ int main() printf("\n%s size: [%i] bytes\n", romFilename, romSize); fclose(fp); - + /* Debugging (before modification) */ printDescriptorRegionLocations(descriptorStruct, "Original"); - if (descriptorDefinesGbeRegion(descriptorStruct)) + if (descriptorDefinesGbeRegion(descriptorStruct)) printGbeChecksumDataFromStruct8k(gbeStruct8k, "Original"); else printf("NO GBE REGION\n"); - + /* * ------------------------------------------------------------------ * Modify the descriptor and gbe regions, ready to go in libreboot.rom @@ -179,7 +179,7 @@ int main() return 1; } } - + /* * ------------------------------------------------------------------ * Generate ich9gen data (C code that will recreate the deblobbed descriptor+gbe from scratch) @@ -205,7 +205,7 @@ int main() return 1; } } - + if (descriptorDefinesGbeRegion(descriptorStruct)) { printf("The modified descriptor and gbe regions have also been dumped as src files: mkdescriptor.c, mkdescriptor.h, mkgbe.c, mkgbe.h\n"); diff --git a/projects/ich9gen/sources/src/ich9deblob.h b/projects/ich9gen/sources/src/ich9deblob.h index c11ea290..e00b2c66 100644 --- a/projects/ich9gen/sources/src/ich9deblob.h +++ b/projects/ich9gen/sources/src/ich9deblob.h @@ -1,7 +1,7 @@ /* * ich9deblob.h * This file is part of the ich9deblob utility from the libreboot project - * + * * Purpose: header file for ich9deblob.c * * Copyright (C) 2014 Steve Shenton @@ -20,7 +20,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #ifndef ICH9DEBLOB_H #define ICH9DEBLOB_H diff --git a/projects/ich9gen/sources/src/ich9gen.c b/projects/ich9gen/sources/src/ich9gen.c index b3a2c9f1..4d1e767e 100644 --- a/projects/ich9gen/sources/src/ich9gen.c +++ b/projects/ich9gen/sources/src/ich9gen.c @@ -15,16 +15,16 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* Generate deblobbed descriptor and gbe 12KiB file from scratch * without relying on a factory.rom dump */ - + #include "ich9gen.h" -int main(int argc, char *argv[]) +int main(int argc, char *argv[]) { int i, j; - + struct GBEREGIONRECORD_8K gbeStruct8k = generatedGbeStruct8k(); struct DESCRIPTORREGIONRECORD descriptorStruct4M = generatedDescriptorStruct(ROMSIZE_4MB, WITHGBE); struct DESCRIPTORREGIONRECORD descriptorStruct8M = generatedDescriptorStruct(ROMSIZE_8MB, WITHGBE); @@ -32,11 +32,11 @@ int main(int argc, char *argv[]) struct DESCRIPTORREGIONRECORD descriptorStructNoGbe4M = generatedDescriptorStruct(ROMSIZE_4MB, WITHOUTGBE); struct DESCRIPTORREGIONRECORD descriptorStructNoGbe8M = generatedDescriptorStruct(ROMSIZE_8MB, WITHOUTGBE); struct DESCRIPTORREGIONRECORD descriptorStructNoGbe16M = generatedDescriptorStruct(ROMSIZE_16MB, WITHOUTGBE); - + /* Only for the compatibility checks */ struct DESCRIPTORREGIONRECORD dummyDescriptorStruct; struct GBEREGIONRECORD_8K dummyGbeStruct8k; - + /* * ------------------------------------------------------------------ * Compatibility checks. This version of ich9deblob is not yet portable. @@ -45,19 +45,19 @@ int main(int argc, char *argv[]) if (systemOrCompilerIncompatible(dummyDescriptorStruct, dummyGbeStruct8k)) return 1; /* If true, fail with error message */ - + /* * ------------------------------------------------------------------ * Arguments given on the terminal * ------------------------------------------------------------------ */ - + if(argc==3) { - + /* If user provides their own MAC address, it will be used. - * Otherwise, ich9gen will simply use the default one. - * + * Otherwise, ich9gen will simply use the default one. + * * However, if the user provides an invalid MAC address, then ich9gen * will exit. */ if(0==strcmp(argv[1],"--macaddress")) { @@ -74,7 +74,7 @@ int main(int argc, char *argv[]) } for(i=0; i<6; i++) { gbeStruct8k.main.macAddress[i] = 0; - + /* Go through each nibble of the byte */ for(j=0; j<2; j++) { if(argv[2][(i*3)+j]>='a' && argv[2][(i*3)+j]<='f') @@ -92,7 +92,7 @@ int main(int argc, char *argv[]) gbeStruct8k.main.checkSum = gbeGetChecksumFrom4kStruct(gbeStruct8k.main, GBECHECKSUMTOTAL); /* Fix the checksum */ memcpy(&gbeStruct8k.backup, &gbeStruct8k.main, GBEREGIONSIZE_4K); /* Copy to the backup */ - + /* Generate ich9gen data (C code for Gbe region): */ /* mkgbe.h */ @@ -102,29 +102,29 @@ int main(int argc, char *argv[]) if (notCreatedCFileFromGbeStruct4k(gbeStruct8k.backup, "mkgbe.c", "mkgbe.h")) { return 1; } - + printf("You selected to change the MAC address in the Gbe section. This has been done.\n\n"); - + printf("The modified gbe region has also been dumped as src files: mkgbe.c, mkgbe.h\n"); printf("To use these in ich9gen, place them in src/ich9gen/ and re-build ich9gen.\n\n"); } - + } - + /* * ------------------------------------------------------------------ * Generate the 12KiB files, ready to be used in a libreboot image * ------------------------------------------------------------------ */ - + if (notCreatedDescriptorGbeFile(descriptorStruct4M, gbeStruct8k, "ich9fdgbe_4m.bin")) { return 1; } - + if (notCreatedDescriptorGbeFile(descriptorStruct8M, gbeStruct8k, "ich9fdgbe_8m.bin")) { return 1; } - + if (notCreatedDescriptorGbeFile(descriptorStruct16M, gbeStruct8k, "ich9fdgbe_16m.bin")) { return 1; } @@ -134,15 +134,15 @@ int main(int argc, char *argv[]) * In these descriptors, the onboard Intel GbE NIC is disabled; a discrete one is used instead * ------------------------------------------------------------------ */ - + if (notCreated4kDescriptorFile(descriptorStructNoGbe4M, "ich9fdnogbe_4m.bin")) { return 1; } - + if (notCreated4kDescriptorFile(descriptorStructNoGbe8M, "ich9fdnogbe_8m.bin")) { return 1; } - + if (notCreated4kDescriptorFile(descriptorStructNoGbe16M, "ich9fdnogbe_16m.bin")) { return 1; } diff --git a/projects/ich9gen/sources/src/ich9gen.h b/projects/ich9gen/sources/src/ich9gen.h index 6b346b06..c558e04a 100644 --- a/projects/ich9gen/sources/src/ich9gen.h +++ b/projects/ich9gen/sources/src/ich9gen.h @@ -14,9 +14,9 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + /* Header file for ich9gen.c */ - + #ifndef ICH9GEN_H #define ICH9GEN_H diff --git a/projects/ich9gen/sources/src/ich9gen/mkdescriptor.c b/projects/ich9gen/sources/src/ich9gen/mkdescriptor.c index 3b97a97b..09669ccf 100644 --- a/projects/ich9gen/sources/src/ich9gen/mkdescriptor.c +++ b/projects/ich9gen/sources/src/ich9gen/mkdescriptor.c @@ -226,4 +226,3 @@ struct DESCRIPTORREGIONRECORD generatedDescriptorStruct(unsigned int romSize, in return descriptorStruct; } - diff --git a/projects/ich9gen/sources/src/ich9gen/mkgbe.c b/projects/ich9gen/sources/src/ich9gen/mkgbe.c index d6865823..099ab5b7 100644 --- a/projects/ich9gen/sources/src/ich9gen/mkgbe.c +++ b/projects/ich9gen/sources/src/ich9gen/mkgbe.c @@ -254,4 +254,3 @@ struct GBEREGIONRECORD_8K generatedGbeStruct8k() memcpy(&gbeStruct8k.backup, &gbeStruct8k.main, GBEREGIONSIZE_4K); return gbeStruct8k; } - -- cgit v1.2.3-70-g09d2 From 89961a3cb7d38575c09ef72c350b7bddadf01756 Mon Sep 17 00:00:00 2001 From: Leah Rowe Date: Wed, 13 Jun 2018 21:43:14 +0100 Subject: Fix/update/remove dead/broken links on the website and documentation Thanks go to skollrc for pointing out these dead links, on this thread: https://www.reddit.com/r/libreboot/comments/8pjjg5/some_dead_links_in_libreboot _website/ --- docs/gnulinux/configuring_parabola.md | 2 +- docs/gnulinux/encrypted_parabola.md | 4 ++-- docs/gnulinux/grub_boot_installer.md | 2 +- docs/hardware/gm45_remove_me.md | 2 +- docs/hardware/x200.md | 6 ------ docs/install/index.md | 2 +- docs/install/rpi_setup.md | 2 +- projects/ich9gen/sources/src/gbe/gbe.h | 2 +- projects/ich9gen/sources/src/ich9deblob.c | 2 +- resources/utilities/ich9deblob/src/gbe/gbe.h | 2 +- resources/utilities/ich9deblob/src/ich9deblob.c | 2 +- www/news/andrew-robbins-new-maintainer.md | 2 +- 12 files changed, 12 insertions(+), 18 deletions(-) (limited to 'projects/ich9gen/sources/src/gbe') diff --git a/docs/gnulinux/configuring_parabola.md b/docs/gnulinux/configuring_parabola.md index 1e525f59..935ff099 100644 --- a/docs/gnulinux/configuring_parabola.md +++ b/docs/gnulinux/configuring_parabola.md @@ -63,7 +63,7 @@ For more information related to `pacman`, review the following articles on the A * [Configuring pacman](https://wiki.parabolagnulinux.org/Installation_Guide#Configure_pacman) * [Using pacman](https://wiki.archlinux.org/index.php/Pacman) -* [Additional Repositories](https://wiki.parabolagnulinux.org/Official_Repositories>) +* [Additional Repositories](https://wiki.parabolagnulinux.org/Official_Repositories) ## Updating Parabola Parabola is kept up-to-date, using `pacman`. When you are updating Parabola, diff --git a/docs/gnulinux/encrypted_parabola.md b/docs/gnulinux/encrypted_parabola.md index 74c74fce..48ef5b76 100644 --- a/docs/gnulinux/encrypted_parabola.md +++ b/docs/gnulinux/encrypted_parabola.md @@ -102,7 +102,7 @@ You can either fill the header with zeroes, or with random data; again, I chose Also, if you're using an SSD, there are a two things you should keep in mind: - There are issues with TRIM; it's not enabled by default through LUKS, -and there are security issues, if you do enable it. See [this page](https://wiki.archlinux.org/index.php/Dm-cryptSpecialties#Discard.2FTRIM_support_for_solid_state_drives_.28SSD.29) for more info. +and there are security issues, if you do enable it. See [this page](https://wiki.archlinux.org/index.php/Dm-crypt#Specialties) for more info. - Make sure to read [this article](https://wiki.archlinux.org/index.php/Solid_State_Drives), for information on managing SSD's in Arch Linux (the information applies to Parabola, as well). @@ -381,7 +381,7 @@ for the LUKS passphrase, apply here as well. You will set this password with the ### Extra Security Tweaks There are some final changes that we can make to the installation, to make it -significantly more secure; these are based on the [Security](https://wiki.archlinux.org/index.php/Securit) section of the Arch wiki. +significantly more secure; these are based on the [Security](https://wiki.archlinux.org/index.php/Security) section of the Arch wiki. #### Key Strengthening We will want to open the configuration file for password settings, and increase diff --git a/docs/gnulinux/grub_boot_installer.md b/docs/gnulinux/grub_boot_installer.md index 7086b71d..7d4375e6 100644 --- a/docs/gnulinux/grub_boot_installer.md +++ b/docs/gnulinux/grub_boot_installer.md @@ -25,7 +25,7 @@ Overwrite the drive, writing your distro ISO to it with `dd`. For example, if we That's it! You should now be able to boot the installer from your USB drive (the instructions for doing so will be given later). ## Prepare the USB drive in NetBSD -[This page](https://wiki.netbsd.org/tutorials how_to_install_netbsd_from_an_usb_memory_stick/) on the NetBSD website shows how to create a NetBSD bootable USB drive, from within NetBSD itself. You should the `dd` method documented there. This will work with any GNU+Linux ISO image. +[This page](https://wiki.netbsd.org/tutorials/how_to_install_netbsd_from_an_usb_memory_stick/) on the NetBSD website shows how to create a NetBSD bootable USB drive, from within NetBSD itself. You should the `dd` method documented there. This will work with any GNU+Linux ISO image. ## Prepare the USB drive in FreeBSD [This page](https://www.freebsd.org/doc/handbook/bsdinstall-pre.html) on the FreeBSD website shows how to create a bootable USB drive for installing FreeBSD. Use the `dd` method documented. This will work with any GNU+Linux ISO image. diff --git a/docs/hardware/gm45_remove_me.md b/docs/hardware/gm45_remove_me.md index 0ac2f49b..26e5f9f6 100644 --- a/docs/hardware/gm45_remove_me.md +++ b/docs/hardware/gm45_remove_me.md @@ -418,7 +418,7 @@ region. According to the datasheet, it's supposed to add up to 0xBABA but can actually be others on the X200. - + *"One of those engineers loves classic rock music, so they selected 0xBABA"* diff --git a/docs/hardware/x200.md b/docs/hardware/x200.md index 10f5f621..fdf992d1 100644 --- a/docs/hardware/x200.md +++ b/docs/hardware/x200.md @@ -132,12 +132,6 @@ comparing it with X200 (factory BIOS) and X200 (gm45 raminit code in coreboot), to see what the differences are. Then tweak raminit code based on that. -Trouble undocking (button doesn't work) ----------------------------------------- - -This person seems to have a workaround: - - LCD compatibility list {#lcd_supported_list} ---------------------- diff --git a/docs/install/index.md b/docs/install/index.md index d4ac2f13..6cefad56 100644 --- a/docs/install/index.md +++ b/docs/install/index.md @@ -169,7 +169,7 @@ ASUS KCMA-D8? ------------- If you have the proprietary BIOS, you need to flash libreboot -externally. See [kcma-d8.md](kgpe-d8.md). +externally. See [kcma-d8.md](kcma-d8.md). If you already have coreboot or libreboot installed, without write protection on the flash chip, then you can do it in software (otherwise, diff --git a/docs/install/rpi_setup.md b/docs/install/rpi_setup.md index e46191e7..b083aac9 100644 --- a/docs/install/rpi_setup.md +++ b/docs/install/rpi_setup.md @@ -150,7 +150,7 @@ successfully. If not, just flash again. Pi](http://scruss.com/blog/2013/02/02/simple-adc-with-the-raspberry-pi/) - [Flashing coreboot on a T60 with a Raspberry Pi - the\_unconventional's - blog](https://blogs.fsfe.org/the_unconventional/2015/05/08/flashing-coreboot-on-a-t60-with-a-raspberry-pi/) + blog](https://web.archive.org/web/20150709043222/http://blogs.fsfe.org:80/the_unconventional/2015/05/08/coreboot-t60-raspberry-pi/) - *Pomona SOIC Clip flashing* - [Arch Linux Wiki - Installing Arch Linux on Chromebook](https://wiki.archlinux.org/index.php/Chromebook) diff --git a/projects/ich9gen/sources/src/gbe/gbe.h b/projects/ich9gen/sources/src/gbe/gbe.h index 14548e71..f28f4421 100644 --- a/projects/ich9gen/sources/src/gbe/gbe.h +++ b/projects/ich9gen/sources/src/gbe/gbe.h @@ -35,7 +35,7 @@ * * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums + * https://web.archive.org/web/20150912070329/https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums */ #ifndef GBESTRUCT_H diff --git a/projects/ich9gen/sources/src/ich9deblob.c b/projects/ich9gen/sources/src/ich9deblob.c index b9153ed6..d7a57c51 100644 --- a/projects/ich9gen/sources/src/ich9deblob.c +++ b/projects/ich9gen/sources/src/ich9deblob.c @@ -42,7 +42,7 @@ * * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums + * https://web.archive.org/web/20150912070329/https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums */ #include "ich9deblob.h" diff --git a/resources/utilities/ich9deblob/src/gbe/gbe.h b/resources/utilities/ich9deblob/src/gbe/gbe.h index a1350fdd..454ab2a2 100644 --- a/resources/utilities/ich9deblob/src/gbe/gbe.h +++ b/resources/utilities/ich9deblob/src/gbe/gbe.h @@ -35,7 +35,7 @@ * * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums + * https://web.archive.org/web/20150912070329/https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums */ #ifndef GBESTRUCT_H diff --git a/resources/utilities/ich9deblob/src/ich9deblob.c b/resources/utilities/ich9deblob/src/ich9deblob.c index d79a3a89..d0fc537a 100644 --- a/resources/utilities/ich9deblob/src/ich9deblob.c +++ b/resources/utilities/ich9deblob/src/ich9deblob.c @@ -42,7 +42,7 @@ * * 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://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums + * https://web.archive.org/web/20150912070329/https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums */ #include "ich9deblob.h" diff --git a/www/news/andrew-robbins-new-maintainer.md b/www/news/andrew-robbins-new-maintainer.md index 50c43d3a..65fd8a3c 100644 --- a/www/news/andrew-robbins-new-maintainer.md +++ b/www/news/andrew-robbins-new-maintainer.md @@ -9,7 +9,7 @@ voted on by the maintainers with community input. These policies formalise our democratic standards. Today, we welcome Andrew Robbins (IRC nick `and_who` and -[NotABug](https://notabug.org) user [kragle](https://notabug.org/kragle)) as +[NotABug](https://notabug.org) user [and_who](https://notabug.org/and_who)) as our first new maintainer under the new policy. Going forward, Andrew will gain push access to Libreboot in order to review patches, as well as voting rights and IRC operator status. -- cgit v1.2.3-70-g09d2