Very Computer

I note that in 2.0.36, you no longer need the append mem= trick.
In fact, I just tested this, booting the latest version of Tom's RTBT
on a 128M machine, and voila!

Now, 'twas my understanding that detection of memory beyond 64M was
chip dependent, and that in order to do it, required intimate
knowledge of and cooperation from specific chip sets.  That is,
Microsoft can do it in NT, because they are willing to "work with" (in
the MS sense of the phrase (*)) the chip manufacturers to make it
work, but that it just isn't worth it in Linux.

My question is: How did they do it, in 2.0.36?  Was there some
heretofore undiscovered BIOS call or something, or did they
essentially do the same thing as NT does?  I'm looking for an
explanation in "semi-layman's terms" - I'm not a layman, but not
exactly a kernel hacker either.  Also, is there any particular reason
why you couldn't just probe memory (write a byte, read a byte) until
it fails?

(*) One is reminded of the line from the book "The Microsoft Files" -
"Doing business with Bill Gates is like having a date with Mike Tyson
- you expect to get*d."

-I note that in 2.0.36, you no longer need the append mem= trick.
-In fact, I just tested this, booting the latest version of Tom's RTBT
-on a 128M machine, and voila!
-
-Now, 'twas my understanding that detection of memory beyond 64M was
-chip dependent, and that in order to do it, required intimate
-knowledge of and cooperation from specific chip sets.  That is,
-Microsoft can do it in NT, because they are willing to "work with" (in
-the MS sense of the phrase (*)) the chip manufacturers to make it
-work, but that it just isn't worth it in Linux.
-

Nothing really to do with chipsets. The memory detection is done in the BIOS.
Linux originally used the existing BIOS call to get the amount of memory.
That BIOS call was limited to returning 64MB.

-My question is: How did they do it, in 2.0.36?  Was there some
-heretofore undiscovered BIOS call or something, or did they
-essentially do the same thing as NT does?

Not undiscovered, but new. And NT simply incorporated that new call earlier
than Linux did.

Frankly while it was mildly annoying, this memory detection thing simply
wasn't enough of a showstopper to add new development to the 1.3 development
tree after the freeze. That's why the call to the new BIOS call didn't make it
into the 2.0 kernels. It'll be standard in 2.2, as it is in all late model 2.1
kernels now.

-  I'm looking for an
-explanation in "semi-layman's terms" - I'm not a layman, but not
-exactly a kernel hacker either.  Also, is there any particular reason
-why you couldn't just probe memory (write a byte, read a byte) until
-it fails?

Because it's unnecessary. The BIOS probes for you. The original BIOS call
was limited. That 2.0.36 kernel patch doesn't work on old BIOS BTW. Just try it
on an old 486 with 80MB of RAM.

It was a minor nuisance. It had a quick, simple, and permanent fix by
adding the "mem=" kernel parameter. The autodetection method only works with
up to date BIOSes. Take your pick.

BAJ
--
Another random extraction from the mental bit stream of...
Byron A. Jeff - PhD student operating in parallel - And Using Linux!

   There are several bios extensions that are used to get memory sizes
   >64/16mb, and all you have to do is try them.   Linux has had support
   for them since 1.2.13 (with appropriate patches, courtesy of Network
   Associates) and they've only recently found their way into the baseline
   kernel.

Quote:>My question is: How did they do it, in 2.0.36?

   int15, ax=0e801h
   ax:  memory < 1mb
   bx:  memory > 1mb, in 64k chunks.

   do the interrupt, and if it works set memsize to
   eax + (ebx*64)
   but if it doesn't work fall back to
   int15, ax=088h
   which only returns up to 64mb.

   It's not a perfect solution;  certain EISA machines (Compaqs in
   particular) will NOT return the amount of memory on the machine
   to any of the simple bios calls, and certain other machines
   (like some HP portables) won't do it either.  But most of the
   machines out there will cheerfully either return the numbers
   that you want or will just as cheerfully fail the call.

                 ____
   david parsons \bi/ Too familiar with memory detection.
                  \/