Radix

  1. Radix
  2. Updating to Radix 2
  3. Making a bootable, auto-flashing SD card
    1. Get the script
    2. Insert a SD card
    3. Determine the SD card's device handle
    4. Start the script
    5. Success... or failure
  4. Manual SD card install
    1. Formatting the SD card
    2. Build the software
    3. Copy to SD
    4. Boot off SD
    5. Flashing to NAND
  5. Cloning an OSWALD to a SD card
    1. Insert a SD card
    2. Open and terminal and start the cloning process
    3. Success... or failure
  6. Releases
    1. Radix 2.0
    2. Radix 1.2

Radix is the name of the distribution that encompasses all the software found on a standard OSWALD. Currently, stable, testing, and testing 3d releases of the distribution and all the software needed for a working OSWALD can be found on the OSL mirror in their corresponding directory.

To properly install this software on the OSWALD, you can either perform the process manually or use a script that automates the process and creates a SD card that can flash its contents into the OSWALD's NAND. See the section below corresponding to either the scripted install onto a SD card or the entire manual process.

Updating to Radix 2

Follow the instructions below to update an OSWALD running Radix 1.2 or before to the latest stable Radix 2.0 release.

1. Using the instructions below, make an auto-flashing SD card containing the latest stable Radix release.

2. Insert the SD card into your device.

3. Turn on your device and tap the Options button that appears in the upper left corner of the screen.

4. Next, select the Expert Menu option.

5. Now, select the Reset Config option and then select the Save Config as Default option.

6. Finally, hit the Back option to exit the Expert Menu and select the Resume Booting option to continue booting from the SD card.

7. If everything is working properly, Tux (the Linux penguin mascot) should appear momentarily while the kernel loads. If this is the first boot-up for the SD card it will then run through some setup scripts and then begin flashing the Radix 2.0 release to the device's NAND. The flashing process can take about around ten minutes. Note that you don't have to watch your device during the process. Just make sure it's not on battery power and the flashing process should finish successfully. You can tell when the flashing process is done when the orange LED on the top of the device has stopped flashing and turns solid.

8. When the flashing process has completed, first eject the SD card and then toggle the device's power switch.

9. Now on the next device boot, assuming there are no bootable SD cards inserted, the device will load the Radix 2.0 release from NAND. Note that the first boot of a new system will take a little longer since the system runs through a bunch of configuration and initialization procedures to setup the software environment properly.

Making a bootable, auto-flashing SD card

The instructions below outline the steps needed to use a script to create a SD card that can boot an OSWALD and optionally flash the card's contents to the OSWALD. The script will only work on UNIX-based operating systems and you should have a basic knowledge of the command-line environment to use it. Also, it should be noted that you can potentially destroy your system if you use the script incorrectly, for example by using the device handle of your system's hard drive instead of the inserted SD card, so you should make sure you know what you are doing.

Get the script

Download the mkflasher script found here and make the script executable. On the command line can be done with the command 

chmod +x mkflasher

assuming that the current working directory is where you saved the script.

Insert a SD card

Make sure you have an SD card (at least 1 GB in size) inserted in a card reader attached to the system you're using.

Determine the SD card's device handle

You must determine the device handle given to the inserted SD card. This should be something like /dev/sdb or /dev/mmcblk0 and can be found in the kernel buffer using the dmesg command or can be found in /proc/mounts if the SD card was auto-mounted. Note that determining the right device handle is very important since the script will totally remove everything on the specified device.

Start the script

In your open terminal using the following command 

sudo ./mkflasher /path/to/device

where you should replace "/path/to/device" with the SD card's device handle you determined in the previous step. The script will partition and format the card correctly and finally download and extract the latest stable release of Radix onto the card.

By default, the script will create an auto-flashing card, meaning that if the card is inserted before an OSWALD is turned on, the contents of the card will be flashed to the device's NAND. If you only want to produce a bootable card with the auto-flashing feature turned off use the "-n" flag which would change the command to 

sudo ./mkflasher -n /path/to/device

In addition, you can also make SD cards with the latest testing release or the latest testing 3d release by using either the "-t" or "-b" flags, respectively. Also, note that the "-h" flag will output the script's basic usage info.

Success... or failure

If the script completes successfully, a confirmation message should be outputted. Otherwise, an error message should be shown telling you what needs to be changed for the script to run properly (use the oswald-user mailing list or the #oswald IRC channel if you need help). The produced SD card can be booted from and used to flash full Radix updates to a device's NAND.

Manual SD card install

The entire process found in the script described above can also be done manually (by hand on the command line). The instructions below step through the entire procedure and should produce an SD card similar to the script above. Note that you should be very comfortable with the command line environment if you choose to follow these steps.

NOTE: These instructions still need to be updated since they don't work anymore.

Formatting the SD card

The SD card must be formatted to have 2 partitions, the first is a fat partition that is bootable, the second is an ext2/3 partition that will serve as the rootfs for the initial boot.

Build the software

Follow the above guides, man pages, google, whatever you need, to build the above software.

Copy to SD

In the end you will have: x-load.bin.ift (use the signGP tool on x-load.bin), u-boot.bin, uImage, and a rootfs. Put these files onto your SD card partition 1 (the FAT parition) with the following names: mlo, u-boot.bin, uImage. Your rootfs should go onto the second (EXT) parition. Also go to the next section and grab the flashNand.scr, save this to the first parition (FAT) as boot.scr, this will flash your device when it first boots.

Boot off SD

Put your SD card in and hold the little button on the back of the CORE board (if the oswald is in its case, there is a hole on the back to press the button). The button only needs to be pressed the first time when running the nand flash script.

Flashing to NAND

To flash to nand, make sure that you have built all of the required files (x-load.bin.ift [called mlo], u-boot.bin, uImage, and the rootfs). In u-boot use the following commands to set up the NAND:

Initialize mmc: 

mmcinit

write x-loader: 

fatload mmc 0 0x80300000 MLO
nandecc hw
nand erase 0 80000
nand write.i 0x80300000 0 80000

Write u-boot: 

fatload mmc 0 0x80300000 u-boot.bin
nandecc sw
nand erase 80000 160000
nand write.i 0x80300000 80000 160000

Write the kernel: 

fatload mmc 0 0x80300000 uImage
nand erase 280000 400000
nand write.i 0x80300000 280000 400000

Clear the rest of the NAND flash to get it ready for the file system: 

nand erase 680000

Finally, save the environment variables to the NAND: 

saveenv

Now, boot linux from SD: 

run mmcargs
mmcinit
fatload mmc 0 0x80300000 uImage
bootm 0x80300000

then in Linux, flash the root file system: 

mkdir /media/nand
mount -t jffs2 /dev/mtdblock4 /media/nand
cd /media/nand
tar xvjf /media/mmcblk0p2/rootfs.tar.bz2
cd /
umount /media/nand /media/mmcblk0p1 /media/mmcblk0p2
reboot

Now you should be able to boot from nand.

Cloning an OSWALD to a SD card

The clone-oswald script found in the standard Radix file system can clone a running OSWALD's file system and other software (x-loader, u-boot, and kernel) onto a bootable SD card. This allows a user to backup their OSWALD to an SD card or transfer their settings and programs to a friend's OSWALD. Note that the script only makes a copy of the data found on the OSWALD's NAND and not on any external devices, such as USB flash drives, that are plugged into the system. To properly clone an OSWALD to an SD card, use the following instructions.

Insert a SD card

Make sure a SD card is inserted that has no data you want saved on it.

Open and terminal and start the cloning process

Open a terminal on the OSWALD and execute the following command on the command line to start the cloning process. 

clone-oswald

Note that this command won't produce a SD card that auto-flashes an OSWALD on boot up. If you want auto-flashing functionality add the -f flag after the command so the command looks like this: 

clone-oswald -f

Success... or failure

The script will take awhile to package up all the files from your OSWALD so you may want to find something else to do for ten minutes or so depending on how full our device's NAND is. If the process fails, an error message should be shown that may tell you want needs to be changed for the script to run successfully. If you need help, feel free to ask around on the oswald-user mailing list or on the #oswald IRC channel. On the other hand, if the script completes properly it should display a success message at which point the SD card may be removed.

Releases

Radix 2.0

  • Base system
    • Linux kernel 2.6.31-omap1 (with OSWALD patches)
    • glibc-2.9
    • binutils-2.19.1
    • busybox-1.14.3
    • coreutils-7.6
    • sudo-1.7.2
    • e2fsprogs-1.41.9
    • openssh-5.3p1
    • X11 (X.org 7.4) with xorg-server-1.6.5
      • xf86-video-omapfb
      • xf86-input-evdev-2.3.0
      • xf86-input-keyboard-1.4.0
      • xf86-input-mouse-1.5.0
      • xf86-input-joystick-1.4.99.2
  • Desktop related software
    • Matchbox
      • matchbox-wm-1.2
      • matchbox-panel-0.9.3
      • matchbox-keyboard-svnr2075
      • matchbox-desktop-0.9.1
    • gtk+-2.18.3

  • Development tools, libraries, and languages
    • gcc-4.4.1
    • gdb-7.0
    • python-2.6.3 and all its core modules
    • Java
      • jamvm-1.5.3
      • classpath-0.98
    • tcl and tk-8.5.7
  • CLI tools and utilities
    • rxvt-unicode-9.06
    • htop-0.8.3
  • GUI apps
    • leafpad-0.8.16
    • epdfview-0.1.7
    • gpicview-0.2.1
    • pcmanfm-0.5.1
    • xournal-0.4.2.1
  • Media
    • mplayer-svnr29770

Radix 1.2

  • Base system
    • Linux 2.6.28-omap1 (with OSWALD-related patches)
    • glibc 2.6.1
    • busybox
    • sudo
    • jfsutils
    • e2fsprogs
    • openssh
    • X11 (X.org 7.4)
      • xf86-video-omapfb
      • xf86-input-evdev
      • xf86-input-keyboard
      • xf86-input-mouse
  • Desktop related software
    • GPE
    • Matchbox Window Manager
    • GTK+
  • Development tools, libraries, and languages
    • GCC toolchain with related libraries and utilities
    • GDB
    • Python 2.6 and all its core modules
    • Java (JamVM/Classpath runtime, Jikes toolchain)
    • Tcl/Tk (with python bindings)
  • CLI tools and utilities
    • rxvt-unicode
    • screen
    • htop
  • GUI apps
    • Leafpad text editor
    • Thunar
    • xournal
  • Media
    • mplayer (package CLI, planned GUI)
  • Games
    • Emulators
      • snes9x
      • vbam
      • scummvm
      • mednafen
      • dosbox
    • SDL-based games
      • prboom
      • opentyrian
      • powermanga
  • Other interesting programs
    • octave (with graphing capabilities via gnuplot)