From 384e1c514135b4188dfbe44d81940f38e0fa6167 Mon Sep 17 00:00:00 2001 From: Francis Rowe Date: Tue, 23 Dec 2014 08:07:34 -0500 Subject: ich9deblob: move x86 compatibility checks to a separate file --- (limited to 'resources') diff --git a/resources/utilities/ich9deblob/Makefile b/resources/utilities/ich9deblob/Makefile index 5ef9587..656e2a1 100644 --- a/resources/utilities/ich9deblob/Makefile +++ b/resources/utilities/ich9deblob/Makefile @@ -20,8 +20,8 @@ CC=gcc CFLAGS=-I. -ich9deblob: ich9deblob.c ich9desc.c ich9gbe.c - $(CC) $(CFLAGS) ich9deblob.c ich9desc.c ich9gbe.c -o ich9deblob +ich9deblob: ich9deblob.c ich9desc.h ich9gbe.h + $(CC) $(CFLAGS) ich9deblob.c ich9desc.h ich9gbe.h -o ich9deblob clean: rm -f ich9deblob *.o diff --git a/resources/utilities/ich9deblob/ich9deblob.c b/resources/utilities/ich9deblob/ich9deblob.c index 3630766..66b9c9b 100644 --- a/resources/utilities/ich9deblob/ich9deblob.c +++ b/resources/utilities/ich9deblob/ich9deblob.c @@ -1,5 +1,5 @@ /* - * main.c + * ich9deblob.c * This file is part of the ich9deblob utility from the libreboot project * * Purpose: disable and remove the ME from ich9m/gm45 machines in coreboot. @@ -42,30 +42,15 @@ #include #include -#include "ich9desc.c" // structs describing what's in the descriptor region -#include "ich9gbe.c" // structs describing what's in the gbe region - -#define DESCRIPTORREGIONSIZE 0x1000 // 4 KiB -#define GBEREGIONSIZE 0x2000 // 8 KiB -// 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? - -// Related to the flash descriptor -#define FLREGIONBITSHIFT 0xC // 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 +#include "ich9desc.h" // structs describing what's in the descriptor region +#include "ich9gbe.h" // structs describing what's in the gbe region +#include "x86compatibility.c" // compatibility checks. this utility is not portable yet. unsigned short gbeGetChecksumFrom4kStruct(struct GBEREGIONRECORD_4K gbeStruct4k, unsigned short desiredValue); unsigned short gbeGetChecksumFrom8kBuffer(char* buffer, unsigned short desiredValue, char isBackup); // for GBe region (checksum calculation) unsigned short gbeGetRegionWordFrom8kBuffer(int i, char* buffer); // used for getting each word needed to calculate said checksum struct DESCRIPTORREGIONRECORD deblobbedDescriptorStructFromFactory(struct DESCRIPTORREGIONRECORD factoryDescriptorStruct, unsigned int factoryRomSize); -int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct GBEREGIONRECORD_8K gbe8kDummy); -int systemIsBigEndian(); -int structBitfieldWrongOrder(); -int structMembersWrongOrder(); struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8K factoryGbeStruct8k); -int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k); int main(int argc, char *argv[]) { @@ -371,138 +356,3 @@ unsigned short gbeGetRegionWordFrom8kBuffer(int index, char* regionData) return *((unsigned short*)(regionData + (index * 2))); } -// --------------------------------------------------------------------- -// x86 compatibility checking: -// --------------------------------------------------------------------- - -// Basically, this should only return true on non-x86 machines -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); - return 1; - } - if (GBEREGIONSIZE != gbeRegion8kStructSize){ - printf("\nerror: compiler incompatibility: gbe struct length is %i bytes (should be %i)\n", gbeRegion8kStructSize, GBEREGIONSIZE); - return 1; - } - return 0; -} - -int systemIsBigEndian() { - // endianness check. big endian forced to fail - unsigned short steak = 0xBEEF; - unsigned char *grill = (unsigned char*)&steak; - if (*grill==0xBE) { - printf("\nunsigned short 0xBEEF: first byte should be EF, but it's BE. Your system is big endian, and unsupported (only little endian is tested)\n"); - return 1; - } - return 0; -} - -// fail if members are presented in the wrong order -int structMembersWrongOrder() -{ - int i; - struct DESCRIPTORREGIONRECORD descriptorDummy; - unsigned char *meVsccTablePtr = (unsigned char*)&descriptorDummy.meVsccTable; - - // These do not use bitfields. - descriptorDummy.meVsccTable.jid0 = 0x01020304; // unsigned int 32-bit - descriptorDummy.meVsccTable.vscc0 = 0x10203040; // unsigned int 32-bit - descriptorDummy.meVsccTable.jid1 = 0x11223344; // unsigned int 32-bit - descriptorDummy.meVsccTable.vscc1 = 0x05060708; // unsigned int 32-bit - descriptorDummy.meVsccTable.jid2 = 0x50607080; // unsigned int 32-bit - descriptorDummy.meVsccTable.vscc2 = 0x55667788; // unsigned int 32-bit - descriptorDummy.meVsccTable.padding[0] = 0xAA; // unsigned char 8-bit - 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. - // Then, concatenate the unsigned chars in big endian order. (in the padding array) - - // combined, these should become: - // 01020304 10203040 11223344 05060708 50607080 55667788 AA BB CC DD (ignore this. big endian. just working it out manually:) - // 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 - - 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("\n"); - - if ( - ! - ( - *meVsccTablePtr == 0x04 && *(meVsccTablePtr+1) == 0x03 && *(meVsccTablePtr+2) == 0x02 && *(meVsccTablePtr+3) == 0x01 - && *(meVsccTablePtr+4) == 0x40 && *(meVsccTablePtr+5) == 0x30 && *(meVsccTablePtr+6) == 0x20 && *(meVsccTablePtr+7) == 0x10 - && *(meVsccTablePtr+8) == 0x44 && *(meVsccTablePtr+9) == 0x33 && *(meVsccTablePtr+10) == 0x22 && *(meVsccTablePtr+11) == 0x11 - && *(meVsccTablePtr+12) == 0x08 && *(meVsccTablePtr+13) == 0x07 && *(meVsccTablePtr+14) == 0x06 && *(meVsccTablePtr+15) == 0x05 - && *(meVsccTablePtr+16) == 0x80 && *(meVsccTablePtr+17) == 0x70 && *(meVsccTablePtr+18) == 0x60 && *(meVsccTablePtr+19) == 0x50 - && *(meVsccTablePtr+20) == 0x88 && *(meVsccTablePtr+21) == 0x77 && *(meVsccTablePtr+22) == 0x66 && *(meVsccTablePtr+23) == 0x55 - && *(meVsccTablePtr+24) == 0xAA && *(meVsccTablePtr+25) == 0xBB && *(meVsccTablePtr+26) == 0xCC && *(meVsccTablePtr+27) == 0xDD - ) - ) { - printf("Incorrect order.\n"); - return 1; - } - printf("Correct order.\n"); - return 0; -} - -// fail if bit fields are presented in the wrong order -int structBitfieldWrongOrder() -{ - int i; - struct DESCRIPTORREGIONRECORD descriptorDummy; - unsigned char *flMap0Ptr = (unsigned char*)&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 - - 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("\n"); - - if (!(*flMap0Ptr == 0xA2 && *(flMap0Ptr+1) == 0xE2 && *(flMap0Ptr+2) == 0xD2 && *(flMap0Ptr+3) == 0xE5)) { - printf("Incorrect order.\n"); - return 1; - } - printf("Correct order.\n"); - return 0; -} - -// Compatibility checks. This version of ich9deblob is not yet porable. -int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k) -{ - if (structSizesIncorrect(descriptorStruct, gbeStruct8k)) return 1; - if (systemIsBigEndian()) return 1; - if (structBitfieldWrongOrder()) return 1; - if (structMembersWrongOrder()) return 1; - return 0; -} diff --git a/resources/utilities/ich9deblob/ich9desc.c b/resources/utilities/ich9deblob/ich9desc.h index 893b0fd..7463e5c 100644 --- a/resources/utilities/ich9deblob/ich9desc.c +++ b/resources/utilities/ich9deblob/ich9desc.h @@ -1,5 +1,5 @@ /* - * ich9desc.c + * ich9desc.h * This file is part of the ich9deblob utility from the libreboot project * * Copyright (C) 2014 Steve Shenton @@ -26,6 +26,15 @@ // bit fields used, corresponding to datasheet. See links to datasheets // and documentation in ich9deblob.c +#ifndef ICH9DESC_H +#define ICH9DESC_H + +#define DESCRIPTORREGIONSIZE 0x1000 // 4 KiB + +// Related to the flash descriptor +#define FLREGIONBITSHIFT 0xC // 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 + struct FLVALSIG{ unsigned int signature; }; @@ -215,3 +224,5 @@ struct DESCRIPTORREGIONRECORD { struct DESCRIPTORMAP2RECORD descriptor2Map; struct OEMSECTIONRECORD oemSection; }; + +#endif diff --git a/resources/utilities/ich9deblob/ich9gbe.c b/resources/utilities/ich9deblob/ich9gbe.h index 1740dbd..26b125b 100644 --- a/resources/utilities/ich9deblob/ich9gbe.c +++ b/resources/utilities/ich9deblob/ich9gbe.h @@ -1,5 +1,5 @@ /* - * ich9gbe.c + * ich9gbe.h * This file is part of the ich9deblob utility from the libreboot project * * Copyright (C) 2014 Francis Rowe @@ -25,6 +25,15 @@ // bit fields used, corresponding to datasheet. See links to datasheets // and documentation in ich9deblob.c +#ifndef ICH9GBE_H +#define ICH9GBE_H + +#define GBEREGIONSIZE 0x2000 // 8 KiB +// 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? + struct GBEREGIONRECORD_4K { unsigned char macAddress[6]; // 0x03 words, or 0x06 bytes unsigned char otherStuff[120]; // 0x3c words, or 0x7E bytes @@ -41,3 +50,5 @@ struct GBEREGIONRECORD_8K { // and other errors. You should do what you need on this one (if modifying // lenovobios's gbe region) and then copy to main }; + +#endif diff --git a/resources/utilities/ich9deblob/x86compatibility.c b/resources/utilities/ich9deblob/x86compatibility.c new file mode 100644 index 0000000..80aa062 --- /dev/null +++ b/resources/utilities/ich9deblob/x86compatibility.c @@ -0,0 +1,141 @@ +#include +#include + +#include "ich9desc.h" // structs describing what's in the descriptor region +#include "ich9gbe.h" // structs describing what's in the gbe region + +// --------------------------------------------------------------------- +// x86 compatibility checking: +// --------------------------------------------------------------------- + +// Basically, this should only return true on non-x86 machines +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); + return 1; + } + if (GBEREGIONSIZE != gbeRegion8kStructSize){ + printf("\nerror: compiler incompatibility: gbe struct length is %i bytes (should be %i)\n", gbeRegion8kStructSize, GBEREGIONSIZE); + return 1; + } + return 0; +} + +int systemIsBigEndian() { + // endianness check. big endian forced to fail + unsigned short steak = 0xBEEF; + unsigned char *grill = (unsigned char*)&steak; + if (*grill==0xBE) { + printf("\nunsigned short 0xBEEF: first byte should be EF, but it's BE. Your system is big endian, and unsupported (only little endian is tested)\n"); + return 1; + } + return 0; +} + +// fail if members are presented in the wrong order +int structMembersWrongOrder() +{ + int i; + struct DESCRIPTORREGIONRECORD descriptorDummy; + unsigned char *meVsccTablePtr = (unsigned char*)&descriptorDummy.meVsccTable; + + // These do not use bitfields. + descriptorDummy.meVsccTable.jid0 = 0x01020304; // unsigned int 32-bit + descriptorDummy.meVsccTable.vscc0 = 0x10203040; // unsigned int 32-bit + descriptorDummy.meVsccTable.jid1 = 0x11223344; // unsigned int 32-bit + descriptorDummy.meVsccTable.vscc1 = 0x05060708; // unsigned int 32-bit + descriptorDummy.meVsccTable.jid2 = 0x50607080; // unsigned int 32-bit + descriptorDummy.meVsccTable.vscc2 = 0x55667788; // unsigned int 32-bit + descriptorDummy.meVsccTable.padding[0] = 0xAA; // unsigned char 8-bit + 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. + // Then, concatenate the unsigned chars in big endian order. (in the padding array) + + // combined, these should become: + // 01020304 10203040 11223344 05060708 50607080 55667788 AA BB CC DD (ignore this. big endian. just working it out manually:) + // 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 + + 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("\n"); + + if ( + ! + ( + *meVsccTablePtr == 0x04 && *(meVsccTablePtr+1) == 0x03 && *(meVsccTablePtr+2) == 0x02 && *(meVsccTablePtr+3) == 0x01 + && *(meVsccTablePtr+4) == 0x40 && *(meVsccTablePtr+5) == 0x30 && *(meVsccTablePtr+6) == 0x20 && *(meVsccTablePtr+7) == 0x10 + && *(meVsccTablePtr+8) == 0x44 && *(meVsccTablePtr+9) == 0x33 && *(meVsccTablePtr+10) == 0x22 && *(meVsccTablePtr+11) == 0x11 + && *(meVsccTablePtr+12) == 0x08 && *(meVsccTablePtr+13) == 0x07 && *(meVsccTablePtr+14) == 0x06 && *(meVsccTablePtr+15) == 0x05 + && *(meVsccTablePtr+16) == 0x80 && *(meVsccTablePtr+17) == 0x70 && *(meVsccTablePtr+18) == 0x60 && *(meVsccTablePtr+19) == 0x50 + && *(meVsccTablePtr+20) == 0x88 && *(meVsccTablePtr+21) == 0x77 && *(meVsccTablePtr+22) == 0x66 && *(meVsccTablePtr+23) == 0x55 + && *(meVsccTablePtr+24) == 0xAA && *(meVsccTablePtr+25) == 0xBB && *(meVsccTablePtr+26) == 0xCC && *(meVsccTablePtr+27) == 0xDD + ) + ) { + printf("Incorrect order.\n"); + return 1; + } + printf("Correct order.\n"); + return 0; +} + +// fail if bit fields are presented in the wrong order +int structBitfieldWrongOrder() +{ + int i; + struct DESCRIPTORREGIONRECORD descriptorDummy; + unsigned char *flMap0Ptr = (unsigned char*)&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 + + 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("\n"); + + if (!(*flMap0Ptr == 0xA2 && *(flMap0Ptr+1) == 0xE2 && *(flMap0Ptr+2) == 0xD2 && *(flMap0Ptr+3) == 0xE5)) { + printf("Incorrect order.\n"); + return 1; + } + printf("Correct order.\n"); + return 0; +} + +// Compatibility checks. This version of ich9deblob is not yet porable. +int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k) +{ + if (structSizesIncorrect(descriptorStruct, gbeStruct8k)) return 1; + if (systemIsBigEndian()) return 1; + if (structBitfieldWrongOrder()) return 1; + if (structMembersWrongOrder()) return 1; + return 0; +} -- cgit v0.9.1