Alpha Miniloader Howto
Prev |  | Next

# 5. How To Load MILO

The most commonly supported method of loading MILO is from the Windows NT ARC firmware as most shipping systems support this. However, there are a wide variety of loading MILO. It may be loaded from:

- a failsafe boot block floppy,

- the Windows NT ARC firmware,

- Digital's SRM console,

- an Alpha Evaluation Board Debug Monitor,

- flash/ROM.

## 5.1. Loading MILO from the Windows NT ARC firmware

Most, if not all, Alpha AXP based systems include the Windows NT ARC firmware and this is the prefered method of booting MILO and thus Linux. Once the Windows NT firmware is running and you have the correct MILO image for your system, this method is completely generic.

The Windows NT ARC firmware is an environment in which programs can run and make callbacks into the firmware to perform actions. The Windows NT OSLoader is a program that does exactly this. Linload.exe is a much simpler program which does just enough to load and execute MILO. It loads the appropriate image file into memory at 0x00000000 and then makes a swap-PAL PALcall to it. MILO, like Linux, uses a different PALcode to Windows NT which is why the swap has to happen. MILO relocates itself to 0x200000 and continues on through the PALcode reset entry point as before.

Before you add a Linux boot option, you will need to copy linload.exe and the appropriate MILO that you wish to load to someplace that the Windows NT ARC firmware can read from. In the following example, I assume that you are booting from a DOS format floppy disk:

1. At the boot menu, select `"Supplementary menu..."`

2. At the `"Supplementary menu"`, select `"Set up the system..."`

3. At the `"Setup menu"`, select `"Manage boot selection menu..."`

4. In the `"Boot selections menu"`, choose `"Add a boot selection"`

5. Choose `"Floppy Disk 0"`

6. Enter `"linload.exe"` as the osloader directory and name

7. Say "yes" to the operating system being on the same partition as the osloader

8. Enter "\" as the operating system root directory

9. I usually enter `"Linux"` as the name for this boot selection

10. Say "No" you do not want to initialise the debugger at boot time

11. You should now be back in the `"Boot selections menu"`, choose the `"Change a boot selection option"` and pick the selection you just created as the one to edit

12. Use the down arrow to get `"OSLOADFILENAME"` up and then type in the name of the MILO image that you wish to use, for example `"noname.arc"` followed by return.

13. Press ESC to get back to the `"Boot Selections menu"`

14. Choose `"Setup Menu"` (or hit ESC again) and choose `"Supplementary menu, and save changes"` option

15. ESC will get you back to the `"Boot menu"` and you can attempt to boot MILO. If you do not want Linux as the first boot option, then you can alter the order of the boot options in the `"Boot selections menu"`.

At the end of all this, you should have a boot selection that looks something like:

    LOADIDENTIFIER=Linux
    SYSTEMPARTITION=multi(0)disk(0)fdisk(0)
    OSLOADER=multi(0)disk(0)fdisk(0)\linload.exe
    OSLOADPARTITION=multi(0)disk(0)fdisk(0)
    OSLOADFILENAME=\noname.arc
    OSLOADOPTIONS=

You can now boot MILO (and then Linux). You can load linload.exe and MILO directly from a file system that Windows NT understands such as NTFS or DOS on a hard disk.

The contents `OSLOADOPTIONS` are passed to MILO which interprets it as a command. So, in order to boot Linux directly from Windows NT without pausing in MILO, you could pass the following in `OSLOADOPTIONS`:

    boot sda2:vmlinux.gz root=/dev/sda2

See Section 6 for more information on the commands available.

Another (rather sneaky) way of loading of loading MILO via the WNT ARC firmware is to put MILO onto an MS-DOS floppy and call it `fwupdate.exe` and then choose the "Upgrade Firmware" option.

## 5.2. Loading MILO from the Evaluation Board Debug Monitor

Evaluation boards (and often designs cloned from them) include support for the Alpha Evaluation Board Debug Monitor. Consult your system document before considering this method of booting MILO. The following systems are known to include Debug Monitor support:

- AlphaPC64 (Section Section 5.6.2)

- EB64+ (Section Section 5.6.4)

- EB66+ (Section Section 5.6.3)

- EB164 (Section Section 5.6.6)

- PC164 (Section Section 5.6.7)

Before you consider this method, you should note that the early versions of the Evaluation Board Debug Monitor did not include video or keyboard drivers and so you must be prepared to connect another system via the serial port so that you can use the Debug Monitor. Its interface is very simple and typing help shows a whole heap of commands. The ones that are most interesting include the word `boot` or `load` in them.

The Evaluation Board Debug Monitor can load an image either via the network (netboot) or via a floppy (flboot). In either case, set the boot address to 0x200000 (`> bootadr 200000`) before booting the image.

If the image is on floppy (and note that only DOS formatted floppies are supported), then you will need to type the following command:

         AlphaPC64> flboot <MILO-image-name>

## 5.3. Loading MILO from a Failsafe Boot Block Floppy

Only the AxpPCI33 is known to include failsafe boot block floppy support (Section < id="noname-section" name="Noname">).

If you do not have a standard pre-built MILO .dd image, then you may need to build an SRM boot block floppy. Once you have built MILO, you need to do the following on Digital Unix box:

         fddisk -fmt /dev/rfd0a
         cat mboot bootm > /dev/rfd0a
         disklabel -rw rfd0a 'rx23' mboot bootm

Or on a Linux box:

         cat mboot bootm > /dev/fd0

If you have a standard MILO image available (say `MILO.dd`) then you would build a boot block floppy using the following command:

         dd if=MILO.dd of=/dev/fd0

## 5.4. Loading MILO from Flash

There are a number of systems where MILO can be blown into flash and booted directly (instead of via the Windows NT ARC firmware):

- AlphaPC64 (Section Section 5.6.2)

- Noname (Section Section 5.6.1)

- EB66+ (Section Section 5.6.3)

- EB164 (Section Section 5.6.6)

- PC164 (Section Section 5.6.7)

## 5.5. Loading MILO from the SRM Console

The SRM (short for System Reference Manual) Console knows nothing about filesystems or disk-partitions, it simply expects that the secondary bootstrap loader occupies a consecutive range of physical disk sectors starting from a given offset. The information describing the secondary bootstrap loader (its size and offset) is given in the first 512 byte block. To load MILO via the SRM you must generate that structure on a device which the SRM can access (such as a floppy disk). This is what `mboot` and `bootm`, `mboot` is the first block (or boot description) and `mboot` is the `MILO` image rounded up to a 512 byte boundary.

To load MILO from a boot block device, either build `mboot` and `bootm` and push them onto the boot device using the following command:

    	$ cat mboot bootm > /dev/fd0

Or, grab the appropriate `MILO.dd` from a web site and write it onto the boot device using either `RAWRITE.EXE` or `dd`.

Once you have done that you can boot the SRM console and use one of its many commands to boot MILO. For example, to boot MILO from a boot block floppy you would use the following command:

    	>>>boot dva0
    	(boot dva0.0.0.0.1 -flags 0)
    	block 0 of dva0.0.0.0.1 is a valid boot block
    	reading 621 blocks from dva0.0.0.0.1
    	bootstrap code read in
    	base = 112000, image_start = 0, image_bytes = 4da00
    	initializing HWRPB at 2000
    	initializing page table at 104000
    	initializing machine state
    	setting affinity to the primary CPU
    	jumping to bootstrap code
    	MILO Stub: V1.1
    	Unzipping MILO into position
    	Allocating memory for unzip
    	####...

The following systems are known to have SRM Console support:

- Noname (Section Section 5.6.1)

- AlphaPC64 (Section Section 5.6.2)

- EB164 (Section Section 5.6.6)

- PC164 (Section Section 5.6.7)

## 5.6. System Specific Information

### 5.6.1. AxpPCI33 (Noname)

The Noname board can load MILO from the Windows NT ARC firmware (Section Section 5.1), from the SRM Console (Section Section 5.5). and from a failsafe boot block floppy (Section Section 5.3). A flash management utility, runnable from MILO is available so that once MILO is running, it can be blown into flash (Section Section 7). However, be warned that once you have done this you will lose the previous image held there as there is only room for one image.

The way that Noname boots is controlled by a set of jumpers on the board, J29 and J28. These look like:

            	    4
            J29	2 x x x 6
            	1 x x x 5

            J28	2 x x x 6
            	1 x x x 5
            	    3

The two options that we're interested in are J28, pins 1-3 which boots the console/loader from flash and J29, pins 1-3 which boots the console/loader from a boot block floppy. The second option is the one that you need to first boot MILO on the Noname board.

Once you've selected the boot from floppy option via the jumpers, put the SRM boot block floppy containing MILO into the floppy and reboot. In a few seconds (after the floppy light goes out) you should see the screen blank to white and MILO telling you what's going on.

If you are really interested in technical stuff, the Noname loads images off of the floppy into physical address 0x104000 and images from flash into 0x100000. For this reason, MILO is built with it's PALcode starting at 0x200000. When it is first loaded, it moves itself to the correct location (see relocate.S).

### 5.6.2. AlphaPC64 (Cabriolet)

The AlphaPC64 includes the Windows NT ARC firmware (Section Section 5.1), the SRM Console (Section Section 5.5) and the Evaluation Debug Monitor (Section Section 5.2). These images are in flash and there is room to add MILO so that you can boot MILO directly from flash. A flash management utility, runnable from MILO is available so that once MILO is running, it can be blown into flash (Section Section 7). This system supports MILO environment variables.

You select between the boot options (and MILO when it is been put into flash) using a combination of jumpers and a boot option which is saved in the NVRAM of the TOY clock.

The jumper is J2, SP bits 6 and 7 have the following meanings:

- SP bit 6 should always be out. If this jumper is set then the SROM mini-debugger gets booted,

- SP bit 7 in is boot image selected by the boot option byte in the TOY clock,

- SP bit 7 out is boot first image in flash.

So, with bit 7 out, the Debug Monitor will be booted as it is `always` the first image in flash. With bit 7 in, the image selected by the boot option in the TOY clock will be selected. The Debug Monitor, the Windows NT ARC firmware and MILO all support setting this boot option byte but you must be very careful using it. In particular, you cannot set the boot option so that next time the system boots MILO when you are running the Windows NT ARC firmware, it only allows you to set Debug Monitor or Windows NT ARC as boot options.

To get MILO into flash via the Evaluation Board Debug Monitor, you will need a flashable image. The build proceedures make MILO.rom, but you can also make a rom image using the makerom tool in the Debug Monitor software that comes with the board:

> makerom -v -i7 -l200000 MILO -o mini.flash

(type makerom to find out what the arguments mean, but 7 is a flash image id used by the srom and -l200000 gives the load address for the image as 0x200000).

Load that image into memory (via the Debug Monitor commands flload, netload, and so on) at 0x200000 and then blow the image into flash:

         AlphaPC64> flash 200000 8

(200000 is where the image to be blown is in memory and 8 is the segment number where you put the image. There are 16 1024*64 byte segments in the flash and the Debug Monitor is at seg 0 and the Windows NT ARC firmware is at seg 4).

Set up the image that the srom will boot by writing the number of the image into the TOY clock.

         AlphaPC64> bootopt 131

(131 means boot the 3rd image, 129 = 1st, 130 = 2nd and so on).

Power off, put jumper 7 on and power on and you should see the MILO burst into life. If you don't then take jumper 7 back off and reboot the Debug Monitor.

### 5.6.3. EB66+

The EB66+, like all of the Alpha Evaluation Boards built by Digital contains the Evaluation Board Debug Monitor and so this is available to load MILO (Section Section 5.2). Quite often (although not always) boards whose design is derived from these include the Debug Monitor also. Usually, these boards include the Windows NT ARC firmware (Section Section 5.1). A flash management utility, runnable from MILO is available so that once MILO is running, it can be blown into flash (Section Section 7). This system supports MILO environment variables.

These systems have several boot images in flash controlled by jumpers. The two jumper banks are J18 and J16 and are located at the bottom of the board in the middle (if the Alpha chip is at the top). You select between the boot options (and MILO when it is been put into flash) using a combination of jumpers and a boot option which is saved in the NVRAM of the TOY clock.

Jumper 7-8 of J18 in means boot the image described by the boot option. Jumper 7-8 of J18 out means boot the Evaluation Board Debug Monitor.

Blowing an image into flash via the Evaluation Board Debug Monitor is exactly the same proceedure as for the AlphaPC64 (Section Section 5.6.2).

### 5.6.4. EB64+/Aspen Alpine

This system is quite like the AlphaPC64 except that it does not contain flash which MILO can be loaded from. The EB64+ has two ROMs, one of which contains the Windows NT ARC firmware (Section Section 5.1). and the other contains the Evaluation Board Debug Monitor (Section Section 5.2).

The Aspen Alpine is a little different in that it only has one ROM; this contains the Windows NT ARC firmware.

### 5.6.5. Universal Desktop Box (Multia)

This is a very compact pre-packaged 21066 based system that includes a TGA (21030) graphics device. Although you can just fit a half height PCI graphics card in the box you are better off waiting for full TGA support in XFree86. It includes the Windows NT ARC firmware and so booting from that is the prefered method (Section Section 5.1).

### 5.6.6. EB164

The EB164, like all of the Alpha Evaluation Boards built by Digital contains the Evaluation Board Debug Monitor and so this is available to load MILO (Section Section 5.2). Quite often (although not always) boards whose design is derived from these include the Debug Monitor also. Usually, these boards include the Windows NT ARC firmware (Section Section 5.1). The SRM console is also available (Section Section 5.5). A flash management utility, runnable from MILO is available so that once MILO is running, it can be blown into flash (Section Section 7). This system supports MILO environment variables.

These systems have several boot images in flash controlled by jumpers. The two jumper bank is J1 and is located at the bottom of the board on the left (if the Alpha chip is at the top). You select between the boot options (and MILO when it is been put into flash) using a combination of jumpers and a boot option which is saved in the NVRAM of the TOY clock.

Jumper SP-11 of J1 in means boot the image described by the boot option. Jumper SP-11 of J1 out means boot the Evaluation Board Debug Monitor.

Blowing an image into flash via the Evaluation Board Debug Monitor is exactly the same proceedure as for the AlphaPC64 (Section Section 5.6.2).

### 5.6.7. PC164

The PC164, like all of the Alpha Evaluation Boards built by Digital contains the Evaluation Board Debug Monitor and so this is available to load MILO (Section Section 5.2). Quite often (although not always) boards whose design is derived from these include the Debug Monitor also. Usually, these boards include the Windows NT ARC firmware (Section Section 5.1). The SRM console is also available (Section Section 5.5). A flash management utility, runnable from MILO is available so that once MILO is running, it can be blown into flash (Section Section 7). This system supports MILO environment variables.

These systems have several boot images in flash controlled by jumpers. The main jumper block, J30, contains the system configuration jumpers and jumper CF6 in means that the system will boot the Debug Monitor, the default is out.

Blowing an image into flash via the Evaluation Board Debug Monitor is exactly the same proceedure as for the AlphaPC64 (Section Section 5.6.2).

### 5.6.8. XL266

The XL266 is one of a family of systems that are known as Avanti. It has a riser card containing the Alpha chip and cache which plugs into the main board at right angles. This board can replace the equivalent Pentium board.

Some of these systems ship with the SRM console but others, notably the XL266 ship with only the Windows NT ARC firmware (Section Section 5.1).

Here is my list of compatible systems:

- AlphaStation 400 (Avanti),

- AlphaStation 250,

- AlphaStation 200 (Mustang),

- XL. There are two flavours, XL266 and XL233 with the only difference being in processor speed and cache size.

Note The system that I use to develop and test MILO is an XL266 and so this is the only one that I can guarentee will work. However, technically, all of the above systems are equivalent; they have the same support chipsets and the same interrupt handling mechanisms.

### 5.6.9. Platform2000

This is a 233Mhz 21066 based system.

Prev | Home | Next
How To Build MILO |  | MILO's User Interface