WiiToo!

WiiToo!
General
Author	VQuickSilver
Type	Operating systems
Version	19dec2010
License	Mixed
Last Updated	2010/12/19
Links
Download
Website
Source
Support Author

WiiToo is a streamlined stage4 precompilation designed to run Gentoo ~ppc on Wii with MIKE and mini. It includes essential software for compiling and installing new programs, as well as a few ready-to-use applications. The kernel is based on vanilla-sources with wii-linux patches, ensuring Wi-Fi functionality right out of the box.

Features

• Ready to use: Simply uncompress, copy, configure, and boot.
• Configurable like Gentoo.
• No need for a USB keyboard - configure network and use ssh.
• Supports all hardware used by wii-linux.

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

Installation

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

Download and install bootmii

To boot WiiToo!, BootMii must be installed first. The BootMii Wii software can be downloaded from the BootMii download page. After downloading, copy the HackMii planner directory containing the boot.elf file to the APPS folder on your SD card. Launch the Homebrew channel and select the BootMii planner.

It is recommended to install BootMii as IOS. Follow the instructions on the BootMii Wii page for more details. The HackMii planner will prepare the SD card for booting BootMii by creating a folder named "bootmii" with the files "ppcboot.elf", "armboot.bin", and "bootmii.ini".

For the Windows installation, only the files "armboot.bin" and "bootmii.ini" are needed to prepare the boot partition. The WiiToo! kernel should be renamed to ppcboot.elf to use BootMii for booting.

Note: If BootMii/boot2 is required, the WiiToo! kernel can be named differently and launched using the BootMii SD browser. Alternatively, removing the SD card before booting the Wii will prevent WiiToo! from starting on every boot, which may be desirable in some cases.

Install from a Linux system

Making partitions on your SD card:

Use the white-linux partition scheme, or you'll need to edit /etc/fstab and the kernel image's boot parameters with a hex editor. Make sure to backup all data on the SD card before proceeding to avoid loss.

Place the SD card in a reader and locate its device file at /dev/ (use dmesg on Linux). Unmount any mounted partitions (check with df) and use fdisk to create a primary fat16 partition (30M is sufficient for WiiToo! kernel images and BootMii, but increase the size if using other homebrew apps or storing Wii data). Create another partition for the root filesystem, the bigger the better. 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:

Make sure the package dosfstools is installed on your system

# /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/

/mnt/wiiroot/boot is a dummy that contains a .elf file, that elf file is our linux kernel that outputs NTSC, for PAL or 480p, some patches might be necessary, copy the file to your bootmii folder

# mv /mnt/wiiroot/boot/*.elf /mnt/wiiboot/bootmii/ppcboot.elf

Install from a Windows System

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) If you don't have 7zip, download and install it.

c) Use 7zip to extract the wiitoo-19dec2010.tar.xz file from the WiiToo! archive (wiitoo-28oct2009.tar.xz.tar).

d) Remove the "xz" extension from wiitoo-19dec2010.tar.xz.

e) Compress wiitoo-28oct2009.tar to wiitoo-19dec2010.tar.bz2 with 7zip.

f) Use 7zip to extract the kernel image that fits your Wii from the archive's boot directory (e.g. wiitoo-2.6.31-480ipal60.elf for PAL 60).

g) Rename the extracted kernel image to ppcboot.elf.

h) Create a folder called "bootmii" and copy ppcboot.elf, armboot.bin, and bootmii.ini into it (get armboot.bin and bootmii.ini from the bootmii planner). Make a folder named "kernel" and copy the "bootmii" folder and its files into it.

i) Compress the "kernel" folder to a kernel.tar archive with 7zip.

j) Compress kernel.tar to kernel.tar.bz2 with 7zip.

k) Use a text editor (e.g. Programmer's Notepad or Devcpp) to set up the config file.

#
# wiitoo-19dec2010
#
# Includes:
# - wiitoo-linux 19dec2010
# - wiitoo kernel 2.6.31
#
#

MINIMUM_CARD_SIZE=450 # MBs

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

#
# Kernel tarball settings
#

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

Save the config file as "whiite-linux-installer.conf", using a text editor that terminates lines with LF (not CR/LF as used in Windows).

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

m) Insert the USB flash disk into your Wii.

n) Copy the whiite linux installer and its files to the APPS folder of an SD card.

o) Insert the SD card into your Wii.

p) Start the whiite linux planner from the homebrew channel and follow the prompts.

q) The planner will partition the SD card into a FAT16 and an EXT3 partition for WiiToo files.

q-a) The size of the FAT16 partition can be 100MB or more, if you want to copy downloaded files later.
q-b) The installer will install the files in "wiitoo-19dec2010.tar.bz2" to the EXT3 partition and the files in "kernel.tar.bz2" to the FAT16 partition, used for booting WiiToo.

Boot WiiToo as described.

Alternatives: Use Cygwin or a GNU/Linux livecd such as 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.

User guide

Booting the system

To boot WiiToo!:

• Start the Homebrew channel.
• Press the home button and select BootMii to load WiiToo.
• If the TV is on, you should see messages displayed on the screen after WiiToo! boots.

Note: If launching BootMii from the HBC doesn't work, try loading WiiToo! through postloader, then Neek/Bootmii.

To log into WiiToo!:

• Use USB keyboard and log in as root with password root for tasks requiring root privileges.
• Use predefined user Wii with password Wii.
• Change passwords for security if necessary.

Alternative option: Log in through SSH after setting up the network. Note: this option may require testing and changing configuration files on the SD card using a Linux PC, and may be tedious without a keyboard.

Configuring your system

To configure settings:

• Use Nano editor with simple user interface.
• Reference the Nano manual if needed.

Filesystem:

To fix file system issues after first boot: Type "FSCK" in the command line if complained about problems in the file system.

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

Tester's note: for some reasons WiiToo! Is lacking dhcpcd, lacking a dhcp client and making internet connectivity near impossible

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:

• 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".
• Create a mount point with: "mkdir /mnt/flashdisk"
• Mount the flash disk: "mount /dev/sda1 /mnt/flashdisk"

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

Media

Nintendo Wii com Linux 2021 (ColecaoNintendo)

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.

External links

• Official website - https://wiitoo.sourceforge.net/
• WiiBrew - https://wiibrew.org/wiki/WiiToo!