How to Develop a Boot Loader (Windows CE 5.0)
A boot loader manages the boot process of the target device by initializing the target device, downloading the run-time image, and booting the run-time image on the target device.
After you develop a boot loader, you can use the boot management capabilities of your boot loader to save time during the OS development process.
Without a boot loader, you must transfer a run-time image to your target device through a slow, manual process.
With a boot loader, you can quickly download a new development run-time image to your target device.
For more information about boot loaders, see Boot Loaders.
Hardware and Software Assumptions
- The boot loader described in this topic is developed for an example hardware platform containing the following hardware specifications:
- ARM V4I CPU
- 64 MB RAM
- 32 MB Intel Strataflash (28F128)
- A supported Ethernet controller, such as NE2000 or SMC9000. As a simplification for this boot loader development process, the controller is built-in and not a PCI or PCMCIA device.
The following table shows the memory map for this hardware platform.
Physical address Length Description 0000.0000 - 01FF.FFFF 32 MB Flash A000.0000 - A3FF.FFFF 64 MB RAM
The boot loader design assumes that the CPU begins fetching code at physical address 0 following a reset.
- You are developing a new boot loader, using as much from the included support libraries as possible.
Note If you have an existing boot loader and want to migrate from a previous version of Microsoft Windows CE to the current version, see How to Migrate a Board Support Package to Windows CE 5.0.
- Your reference OS is Windows CE 5.0.
- You have access and familiarity with Microsoft Platform Builder 5.0 and the build process. Platform Builder includes with all the sources and libraries needed to support boot loader development.
- You have available documentation, such as databooks or datasheets and the latest errata, on the hardware platform, CPU, peripheral chips, and other hardware on which your boot loader will run.
- This procedure used a sample boot loader with the following design simplifications:
- The boot loader resides in system flash memory and runs at every hardware reboot.
- Use Ethernet for the download transport. This is built in with no PCMCIA or PCI interface.
- Download a Windows CE .bin file, for example, Nk.bin, to RAM.
- There is no support for booting a local run-time image, although the flash memory routines are covered. Memory management unit (MMU) or caches are not used. The ROMOFFSET configuration option in the run-time image Config.bib file should reflect the fact that all addresses are physical.
When designing your own boot loader, you can implement enhancements within the framework presented in this topic. For example, you may support a removable Ethernet adapter using PCMCIA or Compact Flash memory or use USB as your download transport.
You might want to store the run-time image in NAND flash memory. For more information about memory design tradeoffs, see the article System Memory Management in Windows CE .NET at this Microsoft Web site.
For more information about the hardware platform description and design of the boot loader described in this process, see Boot Loader Design.
Although the boot loader and the OEM adaptation layer (OAL) typically share hardware platform initialization code, the steps in the following procedure focus on the boot loader. However, keep code sharing in mind when organizing the source files.
The following procedure explains the boot loader development process from the beginning. However, you can save development time by modifying an existing boot loader image for a hardware platform of similar design.
Platform Builder includes tested boot loader source code for various hardware platforms, which you can use as the basis for further development.
To track your progress in the following table, select the check box next to each step.
Note In the following steps, code examples are used to demonstrate each step. In some cases, these examples are code fragments and might be brought together from different parts of the boot loader development process. Because of this, not all code examples compile.
|1. Create a directory for your new boot loader code.
For example: %_WINCEROOT%\Platform\MyPlatform\Src\Bootloader\Eboot.
The boot loader code directory is typically in a hardware platform directory.
You must include the directory in the hardware platform dirs file to build it as part of Platform Builder.
|2. Set up a command-line build shell to create and build the boot loader.
|Setting Up a Command-Line Build Shell|
|3. Generate all static libraries required by the boot loader image.
For more information about Sysgen.bat, see Sysgen Tool.
|4. Create a file for your boot loader's StartUp function, and then establish a function framework as a starting point.||Creating a File for the Boot Loader StartUp Function|
|5. Create a sources file and makefile file in the boot loader directory.||Creating the Boot Loader Sources and Makefile Files|
|6. Build your first boot loader executable (.exe) file.||Building the Boot Loader Source Code|
|7. Implement the boot loader's StartUp function.||Implementing the Boot Loader StartUp Function|
|8. Create a boot loader main function.
This is typically using C programming language.
Starting with this step, all boot loader code should be able to operate in C instead of assembly language.
|Creating the Boot Loader Main Function|
|9. Create stub versions for a number of OEM functions, including generic hardware platform routines and flash memory operations.||Creating Stubs for the Boot Loader OEM Functions|
|10. Add the new source files, Main.c. and Flash.c, created in the previous step to the SOURCES line in the sources file.
||Editing the Boot Loader Sources File|
|11. Create the .bib file, which will be used by Romimage.exe to convert the boot loader .exe file into .bin and .nb0 files.||Creating the Boot Loader .bib File|
|12. Rebuild the boot loader.
|Rebuilding the Boot Loader|
|13. Implement the following serial debug functions in your boot loader code:
These functions are required BLCOMMON callback functions that you must implement in your boot loader code.
You can use other libraries to help implement the functions.
You can copy and possibly modify much of the code from existing hardware platforms.
You should choose a hardware platform that is as similar to your own as possible to minimize the need for changes.
|Implementing the Serial Debug Functions|
|14. Rebuild the boot loader and verify that your code works by testing it on the target device.
You should now be able to verify the following:
If you encounter problems, verify that you correctly implemented serial debug functions.
|Rebuilding the Boot Loader|
|15. Create the driver globals and boot args shared data areas.||Creating Driver Globals and Boot Args|
|16. Implement the remaining hardware platform initialization code by implementing the OEMPlatformInit function.||Implementing the OEMPlatformInit Function|
|17. Add Ethernet debug libraries that have routines referenced in OEMPlatformInit to the TARGETLIBS entry in the boot loader sources file.
|Editing the Boot Loader Sources File|
|18. Implement the following Ethernet controller-related functions:||Implementing the Ethernet Controller-Related Functions|
|19. Implement the OEMPreDownload function.||Implementing the OEMPreDownload Function|
|20. Test boot loader communications by doing the following:
|21. Create a test .bin file to download from Platform Builder.||Creating a Test .bin File for Download|
|22. Verify that the boot loader can use Platform Builder to download a .bin file.||Verifying .bin File Download|
|23. Implement the OEMLaunch function.
|Implementing the OEMLaunch Function|
|24. Implement the OEMIsFlashAddr function.||Implementing the OEMIsFlashAddr Function|
|25. Implement the OEMMapMemAddr function.||Implementing the OEMMapMemAddr Function|
|26. Implement the following flash memory erase functions:||Implementing the Flash Memory Erase Functions|
|27. Implement the OEMWriteFlash function.||Implementing the OEMWriteFlash Function|
|28. Modify the .bib file to produce a boot loader image that downloads to flash memory.
|Modifying the .bib File to Produce a Downloadable Image|
|29. To add support for download progress indication, implement the OEMShowProgress function.
You do not need to add functionality to the OEMShowProgress function, but you must leave the stub version in your boot loader code to prevent errors when the compiler compiles the code.
|Adding Support for Download Progress Indication|
|30. To verify the RAM or flash memory used by the run-time image before the run-time image is downloaded completely, add support for memory verification.||Adding Support for Memory Verification|
|31. If you are developing a multi-BIN run-time image and you would find multi-BIN run-time image notification useful, add support for multi-BIN run-time image notification.||Adding Support for Multiple-BIN Image Notification|
|32. To have your boot loader validate the run-time image before downloading or running it, add support for run-time image signatures.||Adding Support for Image Signatures|
Send Feedback on this topic to the authors