How MSI's EFI BIOS should look. Flashy? yes. Too Flashy? Quite possibly.
We’ve been talking about EFI for
quite a while now and MSI has always been on
the forefront of
this technology – this is the next generation BIOS structure that moves away from the 20-year-old Assembler-based design into a new, very user friendly interface where you can even use a mouse.
When you buy an MSI P45 board (it wasn’t stated which yet), MSI has said that it will deliver a free upgrade to EFI in and around the July timeframe. The company's representatives stressed to us that you can choose whether to go back or forth if you like it or prefer the standard legacy BIOS – it won’t be a permanent switch.
One thing we had serious reservations about was the supposed “Vista x64 SP1” limitation – what happens on EFI-based board when you install or use an OS that isn’t Windows Vista x64 SP1? Do you need to streamline SP1 into a Vista x64 DVD or revert the BIOS every time?
Fortunately, no! You can use EFI and install
any operating system you want, however you can’t use any in-Windows tools to see the BIOS options (including stuff like CPU-Z, temperature monitoring or clock-gen tools) if you don’t use Windows Vista x64 SP1. You can still use and overclock that board via the new EFI BIOS though if you want to stick to XP.
This is awesome news – one of the concerns was that only Vista x64 SP1 could use and see it at all, but since that isn’t the case we can see a much, much wider take up of EFI this year which should make things far more user friendly.
Excited about EFI, or is it just flashy crap and the old school the only way to do things? Let us know
in the forums.
DO THE EVOLUTION
Maybe I'm just an old-fashioned and dull engineer, but I don't like this new thing.
my question is this, with this (nativeish) EFI will I be able to install a retail version OSX and dual boot to vista?
yes and no.
osx checks if you have apple hw, if not it wont work, of course there are workarounds for it, but apple's eula does not really promote them to say it nice.
i completly agree
there is nothing at all wrong with the current design. i dont want to see crappy graphics of robot animals telling me ive changed cpu voltage. i think this efi is a waste of time and a huge sack of shite.
as the old saying goes
if it ain't broke, dont try to fix it
if a poll was taken i truly believe only an incredibly small amount of people want efi.
There's a LOT more to EFI than just some funky little graphic changes. BIOS is a system that has not been updated in over 25 years - most of the hardware that is in our computers wasn't even dreamed of at that point.
EFI is a totally different interconnection method that allows a lot greater future extensibility. BIOS is how the computer's parts "talk" to each other - you don't think that maybe with a change in BIOS standards to something a little more flexibility, we couldn't adapt some better methodologies? Maybe more efficient communications?
I wrote about it a while back in a column, and I still stand by it...EFI is a move forward, and much like Vista is not XP with a new startbar, it's not BIOS with a pretty graphic.
Is my same doubt, with EFI i supposed will be open way to the Hackintosh PCs. Or at least, an improvement in easy OSX hacking.
I've been working for about the past two and a half years with projects based off the Tiano core. I am by no means the most experienced engineer in the industry, but I know enough at this point that I think I can field EFI questions.
The pretty graphics are just a coat of paint on EFI. From the point of view of developers working on it, it is a neat trick because text mode has been the greatest common factor for getting information out of the box to users. That is because it is what was available in the first PCs 25 years ago on IBM PCs. The graphics are basically developers starting to flex their new EFI muscle and see what can be done with the spec, but not required or even common (Intel has been shipping boards with EFI on them for a little while).
I doubt what MSI ships will have much in the way of graphics. If they are upgrading from a legacy BIOS, they are probably using a 512k flash part (though maybe they shipped the board with 1 meg parts in anticipation of this). If the part is 512k it is squeeze for an EFI project so I don't see them putting much in the way of graphics in the image. Setup will probally be a text based affair. Note that this is just the setup browser, there is a lot more to both EFI and BIOS than just the user interface everyone is familiar with (and it often mistaken to be what BIOS is).
EFI really is needed desperately, and it is a lot more than just the age of BIOS that matters. The demands of users frequently run into the limitations of BIOS, but since BIOS is a shadowy world, not many people realize it. The one issue that comes up a lot on message boards that I can point to is USB support and how widely it varies between boards and BIOS versions. There are a lot of games that need to be played behind the scenes, the details of which could easily fill one post.
It won't make a real difference for software that is not aware of EFI, but it will reduce a lot of hassle for future software and really help demonstrate what cross platform support means.
Standards are problematic in BIOS, there really isn't a formal group. It's more of a tug-of-war with big players like Intel and Microsoft driving things. And there are a lot of specs to support like the PnP spec, ACPI, BBS, El Torito, Post memory manager, option ROMs, and so on. EFI will help centralize all of this and hopefully help make unified, cross platform systems easier.
The main job of BIOS is to get the hardware programmed, then leave a footprint of 16 bit ISRs, description tables defined by various specifications, ASL code, SMM, and anything else I may have forgotten. BIOS is based entirely around providing these things and not too much else which can be a real problem if you need to do anything with a full OS.
EFI applies lesions learned from operating system design to system firmware. Consider the number of platforms Linux can run on. Now consider trying to install Linux on an arbitrary platform that doen not have BIOS. On a PC, to interface with the hardware befor the OS can load drivers, it will use the BIOS or a custom loader from the firmware. If it is a custom loader, the author needs to know about it ahead of time. But with EFI, things are unified. The platform can be anything and Linux can still load on it in the same way using the same source.
The services BIOS provides are hardware dependent and based on what the greatest common factor would be meaning 8286 compatibility.
For software that is EFI aware, it will not have to make any assumptions about the underlying hardware (like, I can only use what was available on an IBM 286). Instead, it knows that a core set of services are available to it, and all it needs is the API defined in the EFI spec. These services will help make OS boot loaders and installers lighter weight, faster, and easier to work with as they can let the system firmware share the load again.
These services can help with more than the OS though. A mainboard may look like one monolithic construct, but it's not, there are a lot of tiny pieces in there. However, BIOS is written in a monolithic fashion. Some vendors have worked hard to make the source code and build process modular, but it is still monolithic in the flash part. It's not a good match for the modular nature of modern hardware. EFI can be writen in a fashion that it has a set of binary features that can be swapped around in a very modular fashion. The services based approach will also allow add in hardware to more closely integrate with the platform. For example, it is theoretically possible for an add in card to add a menu to the BIOS setup instead of launching a separate utility.
EFI looks more like a tiny operating system than firmware. There is a core that provides a number of services. These are defined in the EFI spec under the boot services table and runtime services table. Outside of this are modules called drivers that are independent of the core, all they need are the services. Modules create interfaces called protocols to operate with each other. Besides the system services I mentioned above, the EFI spec also defines some protocols for drivers to implement and use to ensure a base level of functionality on the platform. As an example, to get input, I would look for the SIMPLE_INPUT_INTERFACE (called EFI_SIMPLE_TEXT_IN_PROTOCOL in Tiano) using the GUID 387477c1-69c7-11d2-8e39-00a0c969723b.
This protocol interfaces to a driver that can be implemented how ever the author wants. The driver this protocol interfaces to could gets its keystroke data from a USB keyboard, bluetooth keyboard, PS/2 keyboard, from a serial port, from a network interface, from a joystick, or even from a purely logical construct.
Drivers are totally modular and dynamically linked. They can be provided as binaries and inserted into a firmware image peace meal. This means they could be flashed into your mainboard without having the flash an entire image, or can come from something like an add in RAID card.
But they are intended to be small and minimal. EFI not well suited to real time tasks, does not have any naitive multi-threading, very basic memory management (flat memory model) and has no user management. Additional services can be built on it and you can get something a bit like DOS as the EFI shell will demonstrate, but it is not a substitute for a full OS.
To try and illustrate some of the modularity and platform independence of EFI, here is an example of using the core to locate a protocol and get data from a driver implementing the protocol. This is based on Tiano. Please ignore the typos, spelling errors, etc :)
#include "EfiDriverLib.h" EFI_PROTOCOL_CONSUMER(SimpleTextIn) EFI_DRIVER_ENTRY_POINT (ExampleEntryPoint) EFI_STATUS EFIAPI ExampleEntryPoint ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_SIMPLE_TEXT_IN_PROTOCOL *TextIn=NULL; EFI_STATUS Status; EFI_INPUT_KEY Key; EfiInitializeDriverLib (ImageHandle, SystemTable); Status=gBS->LocateProtocol( &gEfiSimpleTextInProtocolGuid, NULL, &TextIn); if(Status || TextIn==NULL || TextIn->ReadKeyStroke==NULL) { // there was an error locatng the protocol or something is not filled out properly. //It may not have been published on the platform, or is not ready yet, or something else is wrong. Do error handling. ErrorHandling(); } Status = TextIn->ReadKeyStroke(TextIn, &Key); if(!Status){ //we have a key, do stuff MyKeyHandler(); } return EFI_SUCCESS; }Nowhere does that code depend on a fixed memory location, IO port, or hardware in any way. As long as there is a text in protocol available and a driver behind it, then the code will work.
I figure I've created a big enough text wall for now. I hope that wasn't too disjointed, I was was trying to keep the length down (looks like I failed :( )
omg.....
great post, thats the sort of post I love.
Hopefully, they will allow users to choose between a traditional looking setup bowser and their graphical one. And while I'm hoping, maybe they will provide a utility to change the graphics too.