=Introduction=
First of all I want to thank the people who made all this possible:

The guys from GC-Linux: http://www.gc-linux.org

Simon "Scorpei" van de Berg for his great tutorial how to build an SD-card adapter for the cube: http://ngc.scorpei.com/GUIDE-SD_adapter.html

The linuxwiki: http://linuxwiki.de

The creators of MFE: http://www.gc-linux.org/wiki/Mfe-distro

=The aim=
The aim of this Project is to create a custom Linux Kernel, which runs on a modified GameCube and has his root file system on an SD-card which is plugged into the memory-card slot.
After the system boots form the SD-card, it should start a custom program which allows the user to start programs using the GameCube-pad.

=Why?=
Normally the GC-Linux kernel will try to load his root file system from a NFS-Storage.

But I don’t like this idea, because you need a broadband-adapter for your GameCube, and you will always have to run an NFS-Share on your PC or a dedicated Server.
What I want is a stand-alone Linux on my GameCube! So why not create one by myself?

=Roadmap=
*Create & boot a Kernel with his root file system on an SD-Card [Done!]
*Create an auto executing script (init/linuxrc?) [Done!]
*Write an GameCube-pad controlled program [ToDo…]
*Enjoy your Linux-Cube!

=What you will need=
*An SD-Card (max. 2GB atm) + An GameCube-MemoryCard to SD Adapter (See [5] or Buy)

==For Compiling it==
*Little knowledge about Linux Kernel
*A running Linux Distribution
*A running gc-linux tool chain + patched kernel source (2.6.32)
**See http://www.gc-linux.org/wiki/Building_a_GameCube_Linux_Kernel
**You may just want to use my config files:
cp .config linux-2.6.32/.config
cp gamecube.dts linux-2.6.32/arch/powerpc/boot/dts/gamecube.dts

=What should happen?=
After the GameCube boots, you will start the kernel.dol from the 1st partition of your SD-Card (fat formatted). The kernel will boot and mount the 2nd partition as his root (ext2/3 Formatted). Then will the Kernel look for his init-script and execute it.
In our Case we use the /bin/init script to configure the rest of the hardware (swap, mounting, etc.) and then start our script/program.

==The boot parameter==
The boot parameters were the first thing I edited. It’s defined in the
“arch/powerpc/boot/dts/gamecube.dts”-file. I edited it as follows:

chosen {
bootargs = "root=/dev/gcnsda2 rootwait video=gcn-vifb:tv=auto";
};

The “root=” parameter tells the kernel that his root is on “/dev/gcnsda2” that means the SD-Card (sd) that is plugged into the GameCube’s (gcn) MemoryCard-Slot1 (a) on Partition 2 (2) [Because the fist is used so SD-Load to execute the kernel.dol]
“rootwait” tells him to wait for his root file system until it’s ready.
The video parameter tells him which video device to use, and how.
In our case he uses the GameCube framebuffer (gcn-vifb), on a tv.
With the “auto” parameter, he will look for himself which mode to use. (NTFS, PAL50/60Hz…)

==Creating a Root file system==
After I could see that my kernel wants to use my SD-Card, I needed a root file system. Basically you don’t need really much, it’s just the normal root-tree (/dev /bin /etc /mnt /usr…) But because I’m a pretty lazy person, I just used a mix of the ramdisk and the file system of the MFE-Distribution and it worked pretty well. I just used my own /linuxrc and /bin/init-scripts. Also you need to add the SD-Card-Devicenodes to the /dev directory.
Please do not use the description from the gc-linux wiki [1]. There they were called “/dev/sdcarda” and “/dev/sdcardb” but they are called “/dev/gcnsda” and “/dev/gcnsdb”.

So we will add some nodes:
# mknod dev/gcnsda b 61 0
# mknod dev/gcnsda1 b 61 0
# mknod dev/gcnsda2 b 61 0
# mknod dev/gcnsda3 b 61 0

# mknod dev/gcnsdb b 61 0
# mknod dev/gcnsdb1 b 61 0
# mknod dev/gcnsdb2 b 61 0
# mknod dev/gcnsdb3 b 61 0

I also added an 3rd SD-card partition, if we maybe want to use them later.

After that we need to create an fstab (/etc/fstab) to mount the cube’s Audio RAM as swap. 
All we need to include in the fstab is the following line:
/dev/aram swap swap pri=32767 0 0

Also we will add proc, root and our first SD-Card (vfat) Partition [Optional].

So as you can see - nothing special. The “/dev/aram” will be mounted as a swap. The “pri=32767” will tell the kernel to prefer this swap device before using an other swap device (f.e. NFS or SD). See [2].

I also added a mount path for the 1st SD-Card partition at /mnt/sdcarda, so we can mount it for later use.
# mkdir mnt/sdcarda

===/etc/fstab===
/dev/aram swap swap pri=32767 0 0
/dev/gcnsda2 / ext3 defaults,errors=remount-ro 0 0
/dev/gcnsda1 /mnt/sdcarda vfat defaults 0 0
proc /proc proc defaults 0 0

==The Init-Script==
So, the kernel boots, the filesystem looks great, what to do next?
We need to give our Kernel a init-script. As we didn’t gave the kernel the “init=/…” parameter, he will try to start the default script “/bin/init”.

A very important thing is that init is not allowed to die! So it has to run all the time.

But what has our system now to do?
We need:
*Format Audio-RAM as swap (mkswap)
*Mount fstab
*Activate swap
*Start our programs we need (mplayer, GUI, whatever)
*Keep init alive!

So let’s do that!
===/bin/init===
#!/bin/ash
mkswap /dev/aram
mount –a
swapon –a

#Now comes our script or whatever you want to execute
/linuxrc

#And keep init alive
while [ 1 –eq 1 ]; do
sleep 1
done

==Preparing the SD-Card==
First of all, we need to prepare our SD-Card partitions. We need a first partition formatted with fat (vfat) and a second partition for the root file system (ext2/3). 
How big they are depends on your SD-Card and for what additional use you want to use it. 
We need about 10MB For the kernel.dol plus the SDLOADER.BIN and about 20mb for the basic root file system. Since I want to extend the rootfs and maybe want to use other homebrew and kernel.dol’s I formatted it as follows (1GB SD):
*300MB vfat
*700MB ext2/3

I choose ext3 because I was first using ext2, but I had problems with destroyed libraries. So I switched to ext3 because it’s journaling. 
If you are ready to go, copy the file system onto the ext2/3 partition, and the GcImage.dol on the vfat partition.

=So what’s next?=
The next part is to include the software we need. This isn’t very problematic because we can use every binary which is compiled for a PowerPC! So what I did is that I downloaded my binaries and libraries from the Debian package-Service [3]. And used the libSDL and the mplayer binary from the mfe-distribution, since they were included in the filesystem. I just added the libraries for divx and mp3.

If you have an Broadband-Adapter in your Cube, you could even install apt-get and just download the packages directly on your cube! 
Another possibility for creating a big but good root file system would be the way from the GC-Linux wiki [4].

=Need Help? Got Ideas? Want to Help?=
Join the GC-Forever Community! :) [0]

=Links=
[0] http://gc-forever.com
[1] http://www.gc-linux.org/wiki/Memory_and_Filesystems#Creating_the_SD.2FMMC_card_device_nodes
[2] http://www.gc-linux.org/wiki/Memory_and_Filesystems#Create_the_device_node_for_the_audio_RAM_driver
[3] http://packages.debian.org
[4] http://www.gc-linux.org/wiki/Creating_a_Root_Filesystem
[5] http://ngc.scorpei.com/GUIDE-SD_adapter.html