WiiToo!

From WiiBrew
Jump to: navigation, search
WiiToo!
General
Author(s)Vquicksilver
TypeOperating system
Version29 October 2009
Links
Download
Website

Contents

News

There is a new version available and this page needs to be updated now!!! Hint: the kernel is in the /boot directory of the downloaded tarball now. It is set to NTSC and needs to be patched for the correct video mode.

Introduction

WiiToo! is a minimal precompiled stage4 made to let you run Gentoo on your Wii using MIKE and Mini. A stage4 archive is an image of the entire root partition of a Gentoo system. It provides all the basic software required to compile and install new programs on it, and some other software ready to be used. The kernel used is plain vanilla-sources & Wii-Linux patches, so expect WiFi working out of the box after just editing some configuration files.

Features

  • Ready to use, uncompress, copy, configure and run
  • Highly configurable, like Gentoo
  • USB keyboard isn't a requirement but highly recommended, you could also configure your WLAN network and use SSH
  • Can use all the hardware that Wii-Linux is able to use:
Hardware Status
Non-accelerated 2D video hardware Correct RGB framebuffer support requires a special SDL library port
Audio hardware Works
SDHC and Non-SDHC SD cards in SD mode Works via the front SD card slot
Serial interface (SI) Nintendo GameCube controllers, and WaveBird wireless controllers works
MEM2 memory as normal RAM Works, requires a module to be loaded
Internal USB Bluetooth dongle Works
Nintendo Wii Remote and related expansion accessories Works
Sensor Bar Works
USB 1.x and 2.0 devices Works, 1.x devices can have some problems
Internal wireless network card Works, can maintain rates up to 200KB
SRAM/RTC Works
Nintendo GameCube memory cards Doesn't work
Internal DVD drive Doesn't work

Requirements

For running it you will need:

  • SD Card, like any other you can use with your wii, 1GB or more is required
  • USB keyboard & TV or simply a local network connection, to be able to login in the system, input commands, etc

Installation

Download and install bootmii

For booting WiiToo! you will need bootmii. Therefore install bootmii beta3 or higher now. You can download it from here: bootmii download.

Download the HackMii installer from this page and copy the directory containing the boot.elf file to the APPS folder on your SD card. Start the Homebrew channel and select the bootmii installer. Install bootmii as IOS (recommended). Read the bootmii page for details regarding this. Choose prepare the SD card and then the HackMii installer will prepare the SD Card to boot bootmii from it. This means it makes a folder on the SD card named bootmii which contains the files "ppcboot.elf", "armboot.bin" and "bootmii.ini".

For the Windows installation procedure we will just need the files "armboot.bin" and "bootmii.ini" to prepare the boot partition. We will rename the WiiToo! kernel to ppcboot.elf to use bootmii to boot it.

NOTE: If you MUST have BootMii/boot2 (BootMii/IOS will also work but not recommended) you can call the WiiToo! kernel something else and use the BootMii SD browser to launch the kernel, or WiiToo! will start up on EVERY BOOT, which may be undesirable in some cases. (Alternatively, remove the SD card before booting the Wii.)

From a Linux PC

Making partitions on your SD card

The recommended partitioning scheme it's the whiite-linux scheme, else you will have to edit /etc/fstab and the boot parameters on the kernel image with a hexeditor.

Backup all the data on the SD card, before starting, or you will lose it.

Now put your SD card on the reader, find the corresponding device file on /dev, mine is /dev/mmcblk0, (Tip: See dmesg output if you are on linux) and umount any partition that can be mounted (Check with df). Now use fdisk to create a primary fat16 partition (this will be our boot partition), 30M should be enough for WiiToo! kernel images + bootmii, but if you are going to use another homebrew apps, or to store data from your Wii, make it bigger. Finally create the partition for the root filesystem (the bigger the better :D), exit fdisk, and unplug the SD card.

Becoming super user

$ su

an alternative is using sudo, you must put sudo at the start of the commands that start with #, the commands that start with $ can be run as a normal user.

Creating the filesystems

# /sbin/mkfs.vfat -n boot /dev/mmcblk0p1
# /sbin/mkfs.ext3 -L whiite /dev/mmcblk0p2

Creating mountpoints and mounting the filesystems

# mkdir /mnt/wiiroot /mnt/wiiboot
# mount /dev/mmcblk0p1 /mnt/wiiboot
# mount /dev/mmcblk0p2 /mnt/wiiroot

Installing WiiToo! on SD card

To uncompress you need xz-utils:

$ xz -d /path/to/wiitoo.tar.xz
# tar xpf /path/to/wiitoo.tar -C /mnt/wiiroot/

Choose your kernel image

You must choose your kernel image according to your TV (PAL/NTSC/480/576), WiiToo! provides 5 kernel images that can be found on /boot/ on the root partition.

When you have the correct kernel image just copy it to your boot partition (FAT16) on the SD card. Rename the kernel image to ppcboot.elf for running it with bootmii.


From a Windows PC

Just use the whiite-linux-installer and 7zip on your Windows PC. These links point to the pages where you can download this software.

Partition and prepare a SD card to run WiiToo!

a) download the WiiToo! release archive.

b) download and install 7zip if you do not have this software already installed.

c) open the WiiToo! archive wiitoo-28oct2009.tar.xz.tar with 7zip and extract the file wiitoo-28oct2009.tar.xz from it.

d) remove the "xz" extension from this file.

e) use 7zip to compress this file wiitoo-28oct2009.tar to a wiitoo-28oct2009.tar.bz2 archive.

f) using 7zip look into the boot directory of this archive and extract the kernel image which fits your Wii. E.g. the wiitoo-2.6.31-480ipal60.elf file if the Wii is set for PAL 60.

g) rename this extracted kernel image file to ppcboot.elf.

h) make a folder called bootmii and copy this file ppcboot.elf plus the files armboot.bin and bootmii.ini into this folder. The files armboot.bin and bootmii.ini you can retrieve from the bootmii installer. Then make a folder named kernel and copy the folder bootmii together with its files into this folder.

i) use 7zip to make a tar archive from the kernel folder.

j) use 7zip to compress this kernel.tar file to a kernel.tar.bz2 archive.

k) use the programmers notepad editor or the devcpp editor to set up the following config file:

#
# wiitoo-28oct2009
#
# Includes:
# - wiitoo-linux 28oct2009
# - wiitoo kernel 2.6.31
#
#

MINIMUM_CARD_SIZE=450 # MBs

#
# Filesystem tarball settings
#
FS_MINIMUM_PART_SIZE=408 # MBs
FS_TARBALL="wiitoo-28oct2009.tar.bz2"
FS_TARBALL_FILE_COUNT=34651

#
# Kernel tarball settings
#

KERNEL_TARBALL="kernel.tar.bz2"
KERNEL_TARBALL_FILE_COUNT=6

Save this config file under the name: "whiite-linux-installer.conf". It is important that the editor terminates lines with LF as Linux does and not CR/LF as Windows does. Both editors mentioned will do that. If you CANNOT read them properly with the notepad editor they do not have CR/LF as line termination. Otherwise the installation will not work.

l) copy the following files to the root directory of a USB flash disk: "wiitoo-28oct2009.tar.bz2", "kernel.tar.bz2" and "whiite-linux-installer.conf".

m) put the USB flash disk into your Wii.

n) put a SD card into your PC and copy the whiite linux installer and its files into the APPS folder of this SD card.

o) put this SC card into the Wii now.

p) start the whiite linux installer from the homebrew channel. Answer the prompts of this installer as required.

q) this installer will partition the SD card into a FAT16 partition and a EXT3 partition for the WiiToo! files. Make the size of the FAT16 partition e.g. about 100MB if you want to copy downloaded files from the FAT16 partition to the EXT3 partition later. The installer will also install the files in the "wiitoo-28oct2009.tar.bz2" archive in the EXT3 partiton and the files in the "kernel.tar.bz2" archive in the FAT16 partition which will be used to boot WiiToo! from.

Having done all this you can boot WiiToo! as described below.

If you want to try an alternative to these instructions, you may try with cygwin, or using a GNU/Linux livecd like sysrescuecd.

Linux guides for Windows users

To familiarise yourself briefly with the available commands on the WiiToo! command line please take a lot at this documentation:

Windows/DOS commands and Linux shell commands compared: tut1 or tut2

There is also a one page linux manual

The Gentoo manual covering installation, Portage and network configuration is here.


Booting the system

Start the Homebrew channel, press the home button and select bootmii to load WiiToo!. After WiiToo! has booted and sent a lot of messages to the screen, you should see something like this if you have the TV on:

WiiToo! Boot.png

Log into your WiiToo! system

You can now log into your system with your USB keyboard. Use root as your login name and password root since the changes you have to make now mostly require root priviliges. There is also a predefined user for your system called Wii with password Wii. To make your system secure - if required - change your passwords after logging in. This is described in one section below.

If you have no keyboard, you could also log into your system with SSH as described below in a separate chapter. For this you have to setup the network as described below first. Therefore this is not recommended because setting up the network may require some testing first and this is rather tedious without a keyboard. You would have to change the settings in the configuration files on the SD card with your Linux PC and then boot again and see if it works.

Configuring your system

After booting your system, you can configure some settings. For this you have to use the Nano editor which has a very simple user interface. Just in case, here is a manual for that.

Filesystem

After booting for the first time WiiToo! may complain about problems in the file system. If this is the case type FSCK to run this program from the command line to fix that.

Keymaps

Gentoo uses the file /etc/conf.d/keymaps to handle keyboard configuration. Edit it to configure your keyboard.

# nano -w /etc/conf.d/keymaps

MAC address

The previous 28oct2009 distribution comes with the wrong MAC address of the WLAN card in a configuration file. Erase the file /etc/udev/rules.d/70-persistent-net.rules. Then boot the system again and WiiToo! will write a new file with the correct MAC address. After that continue with the settings below.

You could also read the MAC address from your Wii system menu/console and enter it into the 70-persistent-net.rules file using the Nano editor.

Hostname

The default system hostname is "Wii", you can change it just doing:

# nano -w /etc/conf.d/hostname

and put an original name like "Hermenegildo" :D.

Configuring openrc

Openrc is the init system used in Gentoo, we have to setup clock and other settings.

To setup the clock create /mnt/wiiroot/etc/timezone and set the path relative to your timezone for example:

America/New_York

You can view all available timezones exploring /mnt/wiiroot/usr/share/zoneinfo.

Changing your root password

You MUST change your root password if you want a secure system, to change it just run:

# passwd root

and follow the instructions.

Changing the Wii user password or adding a new user

Just run:

$ passwd wii

if you prefer to add a new user you can do:

# userdel wii

to erase the wii default user and then:

# useradd -m -G users,wheel,audio -s /bin/bash john
# passwd john

to add a user called john.

glibc locales

With this setting you can control the language of your system, charsets etc... don't touch it if you don't know what you are doing. To edit locales you can run:

# nano -w /etc/locale.gen

and when it's done run:

# locale-gen

Configuring the network

WiiToo! includes all the software needed to make your wifi connection work without the need to install any more software, it includes the firmware necessary to make the internal wifi card work out of the box. But you have to configure the files "wpa_supplicant" and "net" to fit your network needs. This depends whether your wireless access point or router uses no security, WPA or WEP security, dhcp or not, which channel it uses etc.

To configure wpa_supplicant you have to edit the file /etc/wpa_supplicant/wpa_supplicant.conf. Here is some documentation about this: tut and man page.

This is an example wpa_supplicant.conf file which will work with an open WLAN without security:

ctrl_interface=/var/run/wpa_supplicant
ctrl_interface_group=wheel

ap_scan=1

network={
#enter the ESSID here, e.g. ssid="dlink"
   ssid="Example ESSID"
   key_mgmt=NONE
#set this to one if the access point does not broadcast the ESSID
#  scan_ssid=1
}

This is an example wpa_supplicant.conf file which will work with WEP security:

ctrl_interface=/var/run/wpa_supplicant
ctrl_interface_group=wheel

ap_scan=1

network={
   ssid="Example ESSID"
   key_mgmt=NONE
#the numbers below are hexadecimal - 0x0,0x1,0x2..
   wep_key0=0123456789
#use "0123456789" for ASCII
   wep_tx_keyidx=0
   priority=5
#add this parameter if a Shared Key is used
   auth_alg=SHARED
}

This is an example wpa_supplicant.conf file which will work with WPA-PSK security:

ctrl_interface=/var/run/wpa_supplicant
ctrl_interface_group=wheel

eapol_version=1
ap_scan=1
fast_reauth=1
country=ES

network={
   ssid="Example ESSID"
   proto=WPA
   key_mgmt=WPA-PSK
   psk="YouWillNeverKnowTheSecretThatIdontShow"
   pairwise=CCMP TKIP
   group=CCMP TKIP WEP104 WEP40
   priority=5
}

Select and adapt the wpa_supplicant.conf file according to your access point's settings.


The command

iwlist wlan0 scan 

will display the available wireless networks together with their ESSIDs if the router is configured to send these.


Then configure the file /etc/conf.d/net to use dhcp:

config_wlan0=( "dhcp" )

or a static ip:

config_wlan0=( "192.168.1.37 netmask 255.255.255.0 brd 192.168.1.255" )
routes_wlan0=( "default via 192.168.1.100" )
dns_servers_wlan0=( "192.168.1.1." )

Insert a blank between the bracket and the quotation sign.

This should result in a net file like this example file:

# This blank configuration will automatically use DHCP for any net.*
# scripts in /etc/init.d.  To create a more complete configuration,
# please review /usr/share/doc/openrc/net.example and save your configuration
# in /etc/conf.d/net (this file :)!).

modules_wlan0=( "wpa_supplicant" )
wpa_supplicant_wlan0=( "-Dwext" )

#dhcp
config_wlan0=( "dhcp" )

#static ip
#config_wlan0=( "192.168.1.189 netmask 255.255.255.0 broadcast 192.168.1.255" )
#routes_wlan0=( "default via 192.168.1.1" )
#dns_servers_wlan0=( "192.168.1.1" )

#you may enter your ESSID here
essid_wlan0="dlink"
mode_wlan0="managed"
#default channel is 3 though
channel_wlan0="6"
#extend timeout here
associate_timeout_wlan0="20"
#mtu_wlan0="1400"
#wait a bit when scanning wlan networks
sleep_scan_wlan0="3"


Testing the wireless connection

the following commands can be used for testing the wireless connection:

"ifconfig" doc will display the available interfaces, e.g. wlan0. If this interface has received an internet address by dhcp, ifconfig will show this address. It will take a moment till the interface wlan0 gets this address after booting, so you may retry this command.

"killall dhcpcd" doc this will stop the dhcp process which provides the dhcp client service for WiiToo!

"dhcpcd wlan0 restart" will run a script which restarts dhcpcd.

"iwconfig" doc will display information about the wireless interfaces such as wlan0 including the current ESSID used.

"/etc/init.d/net.wlan0 restart" will restart the interface wlan0. Can be used for testing after making changes to the net or wpa_supplicant files.

"/etc/init.d/net.wlan0 status" will show if the interface wlan0 has been successfully started.

"iwlist wlan0 scan" will display the available wireless networks.

"wpa_supplicant -iwlan0 -c/etc/wpa_supplicant/wpa_supplicant.conf -Dwext -d" will start the wpa_supplicant from the command line with the current configuration.

"ps -A" doc lists all running processes and shows whether dhcpcd or wpa_supplicant are running

"ping www.google.com" this should work if everything is set up correcly. Press ctrl-C to exit.

"netstat" doc will e.g. display if a connection is established using SSH.

"route -e" doc will display the current routing table.

The configuration files in question are "/etc/conf.d/net" and "/etc/wpa_supplicant/wpa_supplicant.conf".

A typical message is "WARNING: net.wlan0 has started, but is inactive". If everything is set up correctly, you will have to wait for a moment till the status changes to "started". Use ifconfig to check when the interface wlan0 gets an IP address from the dhcp server.

Logging into the system from remote

To log into the WiiToo! system on the Wii via the wireless LAN adapter you need a SSH client which is a remote login program. Enter the following command on your Linux PC:

ssh -l wii ip.address.ofyour.wii

Then log in using e.g. wii as your login name and wii again as your password.

For Windows you can use PuTTY. Just click on putty.exe and enter the internet address of the Wii. Right-click on the title bar of PuTTY for the main menu.

The SSH connection often works slow though and seems to hang for a while.

Using installed applications

rTorrent is BitTorrent client for the command line. Documentation can be found here and here.

Irssi is an IRC client. You will find a detailed description here: irssi tutorial.

GNU Screen is a virtual terminal multiplexer that allows a user to access multiple separate terminal sessions inside a single terminal window. It is useful for dealing with multiple programs from the command line, and for separating programs from the shell that started the program. Enter "screen" on the command line to invoke the program. Then use ctrl-a followed by "c" to open new windows and use ctrl-a followed by space bar to move between the windows. For additional information see the manual.

This and additional software is also described here at the WiiToo! site at Sourceforge.

Installing further applications

Making a swap file

If you want to compile bigger applications on your Wii you will soon run out of memory. To avoid this you can generate a swap file so WiiToo! can use that if it runs out of memory. This is how you do that:

a) Make sure you are logged in as the root user

b) Type following command to create a 128MB swap file (1024 * 128MB = block size):

# dd if=/dev/zero of=/swapfile1 bs=1024 count=131072

Depending on the size of your SD card you can also make a bigger swapfile, e.g. set count=327680 to get a 320MB file.

c) Set up the swap area:

# mkswap /swapfile1

d) Activate /swapfile1 swap space now:

# swapon /swapfile1

e) See how much memory is available:

# free -m

f) To activate /swapfile1 each time WiiToo! is booted, add a swapfile entry to the /etc/fstab file. Open /etc/fstab with Nano and append this line:

/swapfile1 swap swap defaults 0 0

Classic method

The prefered method for installing software is using the Portage package manager, however, there are files which are not available on the Gentoo servers. For example software which is developed for the Wii such as the x86f-video-cube driver.

For a test lets try to install the game ascii-invaders. Since we have no graphics installed yet, we have to stick with ASCII games.

To install this you have to download the software from this link: ASCII invaders.

Now go into the src directory: "cd ~/src". Extract the downloaded archive there with the command (provided the archive is in the root directory):

# tar -xjvf /invaders0.1b.tgz  

This will make a new subdirectory called "invaders0.1b" and put all the files from the archive into that. Then use e.g. "cd ~/src/invaders0.1b" to go into this directory.

At this stage you can compile and install the game. First enter ./configure from the command line, then make, then make install. You can do that in one line if you do not expect that anything goes wrong: "./configure && make && make install".

"Configure" is a script which e.g. checks that your system has the proper dependencies in order to compile the program or driver from source. Some of these scripts allow you to specify options to compile with or without support for certain modules. Make executes the Make program which runs the makefile in the directory. make install causes make to run the makefile again, this time with the target "install" copying the compiled files to the proper location. If every step succeeded, you can run the program now.

Using the Portage package manager

To add further applications to WiiToo!, you can use Gentoo's package manager Portage or [1] or [2]. Portage provides "ebuilds" for each software package which contain all the necessay information to compile the package on the hardware platform in use. A complete set of these ebuilds has to be available on the local PC in form of a Portage tree in the directory /usr/portage . If this is the case e.g. the command

emerge xz-utils  

will download the source for the xz compression utilities from the Gentoo servers and compile and install them on your PC.

The Portage tree usually needs over 1000 MB of disk space. Since we operate on a SD card, we will usually have not that much space available. So the latest release of WiiToo! holds this portage tree in a SQUASH file system, so it will fit on the SD card.

Lets try if this works now. As a simple emerge download and install the automake utility. For this enter the command:

emerge -v automake 

The -v option selects verbose mode.

Mounting a flash disk

If you need more disk space or want to transfer files to the WiiToo! system, you can mount a flash disk. If you leave the flash disk with a FAT32 file system you can use it mainly for transfering files. Otherwise you should use the ext3 file system. You can put that file system on the flash disk with the command "/sbin/mkfs.ext3". However, this will destroy all files currently on the flash disk.

After plugging in the flash disk you have to:

1. check if the flash disk is found by WiiToo! and read its device name: enter "dmesg". This will flood the screen with messages and at the end disclose the device name e.g. as "sda/sda1".

2. Create a mount point with: "mkdir /mnt/flashdisk"

3. Mount the flash disk: "mount /dev/sda1 /mnt/flashdisk"

Now you can see the files on the flash disk: "ls /mnt/flashdisk".

Credits

Thanks to all the people that have contributed in any way to this project, special thanks to Gentoo, Team Twiizers, and isobel without them this wouldn't be possible.

Personal tools
Resources
Community