Asus Eee PC R11CX - EMT64 Enabled

[Dane98]

Hello folks!

First of all, thanks to the user @xenon on his post:
https://www.bios-mods.com/forum/Thread-REQUEST-Asus-eeepc-1025C?page=2

Based off of that, I managed (with a lot of help from a friend) to apply the same steps on the R11CX model as well.
Esentially the same procedure was applied, and I want to give back to the community :)
I am by no means proficient in this field, but this worked for me flawlessly for several weeks now.
You will be doing this at your own risk, I am not responsible if anything goes wrong.

Simple Instructions:
1. Download the modified BIOS attached below
2. Format your USB flash drive to FAT32
3. Place the downloaded ROM file on the clean FAT32 flash drive - you should only have this file on the flash drive
4. Insert the flash drive in your laptop
5. During bootup of your Asus R11CX, hold F2 to enter BIOS menu
6. In the "Advanced" tab, select "Start Easy Flash"
7. You should be able to select the modified BIOS to be installed, install it (do NOT interrupt the installation procedure)
8. After finishing, restart the laptop and enter BIOS menu again, in "Advanced" tab -> "CPU Configuration" you should have "EMT64 Supported"
9. You can install your 64-bit OS now!

How to check the modifications I made if you are skeptical (I advise everyone to be vigilant):
1. Download Asus Eee PC R11CX BIOS version 1203 from the official Asus website
2. Compare the original .ROM file with my version, you should see that I have replaced 7 bytes in total with the hex
value 90, which is the opcode for "nop" instruction, meaning it just skips calling a function which, apparently, locked the EMT64 support
3. For more details you can check xenons post in the link above.

I'd love to hear if this helps someone out, cheers!

[Zerin]

Hey brother,
I also saw the Xenon's mods on the bios, but
I don't know how to do this in a hex editor. Could you please tell me step by step what did you edit and how did you find out what to change. I actually have a similar netbook HP-Mini 110-4100 with atom n2600 and want to unlock 64bit in it. Please help me in this case

[clark10min]

Thanks Dane98! This was awesome to find, and thank you for your share!

[TTL]

So I came here while figuring out a way how to enable 64bit on my Asus EE PC R011CX.
It took a little searching, discovering the main difference between my and the R11CX.
The R011CX has 1GB RAM soldered on board and no socket. So possibly the BIOS is different too.
Neither the R11CX nor the R011CX BIOS can be found on the ASUS website any-longer.

Moreover, the BIOS update option in the BIOS did nothing but showing a blinking cursor,
so no way to get a BIOS and no way to flash it. The only reliable way for me: De-solder the
flash with the BIOS, read it out, modify it, flash it and solder it back on.

After troubles with the reader for the flash chips, I managed to copy it out.
Based on the information in the thread linked above, I wrote a program searching for the
pattern to patch my BIOS. This worked successful. A big thanks for this information.
Soldering the flash back on the board, I could start it and at least the BIOS
read EMT64 enabled.
After this, I inserted the SSD back in. Unfortunately after this, the netbook did not start
a second time. Not by battery and no LEDs signalling a charging. Too sad.

But if it is for anyone to be useful, here is the program with which I patched the BIOS and
can reproduce the patched BIOS in the top post. Maybe it can help someone patching a similar BIOS.

Code:

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

/* SPDX-License-Identifier: BSD Zero Clause License */

/*Credits go to:
  https://www.bios-mods.com/forum/Thread-REQUEST-Asus-eeepc-1025C?page=2
  with this, the mod from
  https://www.bios-mods.com/forum/Thread-Asus-Eee-PC-R11CX-EMT64-Enabled
  can be reproduced

  Compile this program by:
  gcc filepatch.c -o filepatch -Wall -Wextra

  Disassembling a rom can be done with:
  ndisasm -b 32 file.rom > file.asm

  Version 1.0 2021-10-04

*/

#define PATCHERS 2

typedef int (*patcher)(uint8_t * buffer, size_t remaining);

size_t fileSizeGet(FILE * f)
{
long s = 0;
long current = ftell(f);
if (fseek(f, 0, SEEK_END) == 0)
{
s = ftell(f);
if (fseek(f, current, SEEK_SET) == 0)
{
return s;
}
}
return 0;
}

int memcmpPattern(const uint8_t * buffer1, const uint8_t * buffer2, const uint8_t * pattern, size_t len)
{
for (size_t i = 0; i < len; i++)
{
if ((pattern[i]) && (buffer1[i] != buffer2[i]))
{
return 1;
}
}
return 0;
}

int patcher1(uint8_t * buffer, size_t remaining)
{
//mov, rdmsr, or, wrmsr
const uint8_t pattern[] = {0xB9, 0x22, 0x1, 0x0, 0x0, 0x0F, 0x32, 0x0C, 0x03, 0x0F, 0x30};
if (remaining >= sizeof(pattern))
{
if (memcmp(buffer, pattern, sizeof(pattern)) == 0)
{
buffer[9] = 0x90; //nop
buffer[10] = 0x90;
return 1;
}
}
return 0;
}

int patcher2(uint8_t * buffer, size_t remaining)
{
//the amount added to the stack is different between compilation, so ignore the amount
//push, push, push, push, push, call, first part of add to stack
//search for "push dword 0x122" in the disassembly if this pattern has no match
const uint8_t pattern[] =  {0x53, 0x6A, 0xFF, 0x53, 0x6A, 0x03, 0x68, 0x22, 0x01, 0x0,  0x0,  0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0xC4};
const uint8_t relevance[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF};
const size_t len = sizeof(pattern);
if (remaining >= len)
{
if ((memcmpPattern(buffer, pattern, relevance, len)) == 0)
{
buffer[11] = 0x90; //nop
buffer[12] = 0x90;
buffer[13] = 0x90;
buffer[14] = 0x90;
buffer[15] = 0x90;
return 1;
}
}
return 0;
}


int main(int argc, char ** argv)
{
const patcher p[PATCHERS] = {&patcher1, &patcher2};
const uint32_t expected[PATCHERS] = {1, 1};
if (argc != 3)
{
printf("Wrong arguments. Use <inputfile> <outputfile>\n");
return 1;
}
FILE * fi = fopen(argv[1], "rb");
FILE * fo = fopen(argv[2], "wb");
if ((fi) && (fo))
{
const uint32_t filesize = fileSizeGet(fi);
uint8_t * buffer = (uint8_t *)malloc(filesize);
if (buffer)
{
if (fread(buffer, filesize, 1, fi) == 1)
{
uint32_t matches[PATCHERS] = {0};
for (uint32_t i = 0; i < filesize; i++)
{
for (uint32_t j = 0; j < PATCHERS; j++)
{
if (p[j](buffer + i, filesize - i))
{
printf("Patched pattern %u at 0x%x\n", (unsigned int)j + 1, (unsigned int)i);
matches[j]++;
}
}
}
bool bad = false;
for (uint32_t i = 0; i < PATCHERS; i++)
{
if (matches[i] != expected[i])
{
bad = true;
}
}
if (bad == false)
{
printf("Looks promising\n");
}
else
{
printf("Not found expected number of patchable positions. Probably wont work...\n");
}
if (fwrite(buffer, filesize, 1, fo) == 1)
{
printf("Output file written\n");
}
}
else
{
printf("Error, file size mismatch\n");
}
free(buffer);
}
else
{
printf("Error, no mem\n");
}
}
if (fi)
{
fclose(fi);
}
else
{
printf("Error, could not open input file\n");
}
if (fo)
{
fclose(fo);
}
else
{
printf("Error, could not open output file\n");
}
return 0;
}

[Snowboy]

Hi can you give me the BIOS Update please?