Showing changes from revision #6 to #7:
Added | Removed | Changed
The first thing to do is obviously to get a ROM image. If you want to build one yourself, view the instructions on this page. If you want to use a prebuilt ROM image, you can download one from this page.
You may also want to download the HardDisk4 zipfile archive which contains theRISC OS 5 !Boot sequence and other utilities. Note that there are two versions available – a self-extracting version and a tar/bz2 version. Only choose the tar/bz2 version if you have a workingRISC OS machine which you can use to extract the archive onto a USB device!
If Attempting you to downloaded prepare a an prebuild SD card manually can often result in failure, either due to user error or operating system quirks. The easiest way to solve this problem is to use theSDCreate utility, a copy of which is supplied with every OMAP3 ROM image from distributed this by site, then the readme file should contain a set of brief instructions on how to run the ROM ROOL . image Even using if u-boot and a boot script. It’s recommended that you try don’t following have those a instructions first, as this page hasn’t yet been updated to fully describe the recommended boot methods for all machine types.RISC OS machine on which to run SDCreate, you’ll still want a copy of the app, as it contains a description of how SD cards are prepared, and copies of the required U-Boot scripts.
If Before you’ve preparing built your own SD card, you may need to track down some extra files/software:ROM image then you can find the readme file and associated u-boot scripts in your build tree at RiscOS.Autobuild.ABRelease.Resources.OMAP3Dev.
There are two ways to run RISC OS on a beagleboard – the easy way and the hard way. If you get stuck, it may be worth reading over the official Beagleboard rev B/C validation/x-loader & u-boot upgrade instructions
The SDCreate main window is split into two sections – ‘Create image’ and ‘Write image’. Depending on which options are selected the ‘Run’ button at the bottom may or may not be greyed out.
A summary of some of the points below (also collating other information and advice) is available. See WARNINGHow to get started with a BeagleBoard
The code which writes images to SD cards hasn’t received thorough testing, and doesn’t ask for confirmation before beginning the write operation. So if you’ve selected the wrong drive you will lose all your data on that drive, and if you try interacting with the drive while the write is occuring then it will likely result in a corrupt image.
The easy way involves placing the WARNINGROM image on a FAT-formatted SD card along with a u-boot boot script.
If you want to create an image, and save it as a file:
When you want to update the RISC OS ROM image, all you need to do is replace the ROM file on the card.
If you want to create an image, and write it straight out to a card:
If you don’t have a suitable version of u-boot in NAND, you can update to a new one using the following steps. Note that these steps are suitable for both revision B & C boards.
If you want to write an existing SD image to an SD card:
There That’s are it! actually If three it hard all ways went – well, manual you booting, should booting now as have a uImage, working and SD booting card/image without for u-boot. use with your OMAP3 machine.
mmcinit;fatload mmc 0:1 0x80000000 riscos;go 0x80000000
If you’re able to use SDCreate to create an image file, but are unable to use it to actually write the image to a card, then you can use any number of Windows/Linux/Mac utilities to do the job for you:
A uImage is an operating system kernel with a u-boot header attached, containing information such as the load & execution address of the image, the operating system name and version contained within, etc. To boot RISC OS as a uImage, follow the following steps:
mkimage -A arm -O linux -T kernel -C none -a 0x81000000 -e 0x81000064 -n "RISC OS" -d riscos uImage.bin
If you’re unable or unwilling to use SDCreate to create an image for you, then you can always create one manually. See the SDCreate !Help file for information about the SD card structure and how booting works, or alternatively this archived copy of an earlier version of this page, which contains information about a variety of different boot methods.
When you want to upgrade your RISC OS ROM, you’ll obviously have to go through the mkimage step again. Technically this uImage could also be written to NAND and booted from there, but you’ll have to be careful with the NAND boot commands since the default only loads 4MB of data and the uImage will be slightly larger than that.
The OMAP3 port of RISC OS doesn’t yet contain a suitable driver to allow RISC OS to interact with the SD card slot. So your !Boot sequence must be placed on a USB drive instead. Here’s a brief guide of how to set up the drive:
Currently the only way to boot without u-boot is to get x-loader to boot your ROM image directly. However currently there is a bug in the RISC OS video driver which will prevent video output from working unless the ROM is loaded via u-boot.
If you’ve got a ‘new’ version of x-loader in your NAND which supports automatic loading of u-boot from SD cards (e.g. x-loader version 1.4.2 or above) then all you need to do is copy the RISC OS ROM image to an SD card and name it as ‘u-boot.bin’.
If you’ve got an older version of x-loader, and don’t feel like upgrading, then you’ll have to create a bootable SD card and use that:
At the moment the only way to get around this problem is to get your OMAP3 machine (running RISC OS) to set up the boot sequence itself. Unfortunately a couple of bugs and limitations in RISC OS mean that this is currently slightly trickier than it could be!
TODO – someone who owns a DevKit8000 needs to fill this section in! In general, the steps should be roughly the same as for a beagleboard, except a DevKit8000-specific version of u-boot and/or x-loader will be required, and the DevKit8000-specific boot script
This sets the board to output the video to the HDMI connector, reads the file “riscos” from the SD card into memory, then runs it.
If all goes well, you will then drop into the Supervisor prompt.
Then type
Hopefully it will then boot to the desktop !!
To update the ROM, just copy the new image to the SD card
Note that no guarantee is made of the suitability of QEMU to run the current version of OMAP3 RISC OS. At the time of writing QEMU’s OMAP3 emulation capability is rather poor, and the last time running a build under QEMU was attempted, both emulator patches and RISC OS source changes were required.
To make things easier, you can create a script that will build the NAND image for you:
#!/bin/bash
rm -f beagle-nand.bin
./bb_nandflash.sh x-load-bin.ift beagle-nand.bin x-loader
./bb_nandflash.sh riscos.rom beagle-nand.bin u-boot
./bb_nandflash_ecc beagle-nand.bin 0x0 0xe80000
The script will put the ‘riscos.rom’ ROM image into a NAND image, ‘beagle-nand.bin’, suitable for use by QEMU.