NOTE: All commands mentioned below are done as root.

The text below is not original. I have copied them from, and I have just modified them for installing Slackware 14.1 on the OLinuXino A10 Lime. Among the pages I've got content from are the following:

Setup of development environment
1] Create a VirtualBox or KVM VM for Debian "Wheezy" 7.6.0 i386. I allocated 1024MB of RAM to it. As for the virtual hard drive space, I allocated 8GB. I also recommend that you disable audio support for a VirtualBox VM.
2] Download the Net Install ISO image for Debian "Wheezy" 7.6.0 i386. Boot the mentioned ISO in the VM you've created. I used the "Install" option in the installer boot menu.
3] This set of instructions will work with everything deselected under "Software selection." You may select software to your taste during installation.
4] After the installation, the guest OS will automatically get an IP Address via DHCP.
5] As root in your guest OS:
# apt-get update
# apt-get upgrade
6] Install OpenSSH client and server software as root in your guest OS if this will make file transfers and access to your development environment convenient for you:
# apt-get install openssh-client openssh-server
7] As root in your guest OS:
# apt-get install ncurses-dev uboot-mkimage build-essential git
# cd ~
# wget
# tar xjfv gcc-linaro-arm-linux-gnueabihf-4.7-2013.01-20130125_linux.tar.bz2
8] Add toolchain directory to $PATH in your guest OS(You may want to add the following line to /etc/profile . Appending it will do.):
export PATH=/root/gcc-linaro-arm-linux-gnueabihf-4.7-2013.01-20130125_linux/bin:$PATH
9] Restart your guest OS as root:
# shutdown -r now

Compiling the kernel
1] In the development environment you've made above, login as root. Then get the kernel source code:
# cd ~
# git clone
2] Note that I'm using the e37d760b363888f3a65cd6455c99a75cac70a7b8 revision (this is for the 3.4.90 kernel). So, to checkout the mentioned revision:
# cd ~/linux-sunxi/
# git checkout e37d760b363888f3a65cd6455c99a75cac70a7b8
3] Do a "make mrproper":
# cd ~/linux-sunxi
# make mrproper
4] Download a10lime_defconfig:
# cd ~/linux-sunxi/arch/arm/configs
# wget
5] Execute the following under the linux-sunxi directory in your development environment as root:
# cd ~/linux-sunxi/
# make ARCH=arm a10lime_defconfig
6] Configure the kernel in your development environment as root:
# make ARCH=arm menuconfig

HINT: If you're having problems with Logitech wireless keyboards and mice, don't build this (for Linux 3.4.90):
Device Drivers->HID Devices->Special HID drivers->< > Logitech Unifying receivers full support

HINT: To verify OTG is enabled(for Linux 3.4.90):
Under Kernel Configuration, this must be built in the kernel:
Device Drivers->USB support->[*] SUNXI USB2.0 Dual Role Controller Support
Also, this must be built in the kernel, too:
Device Drivers->USB support->SUNXI USB2.0 Dual Role Controller Support->[*] SUNXI USB2.0 Manager
And make sure of the following:
Device Drivers->USB support->SUNXI USB2.0 Dual Role Controller Support->SUNXI USB2.0 Manager->USB0 Controller support (otg support)->(X) otg support

HINT: To verify Ethernet is enabled(for Linux 3.4.90):
Under Kernel Configuration, this must be built in the kernel:
Device Drivers->Network device support->Ethernet driver support-><*> Allwinner Ethernet MAC support

8] You can now compile the kernel and its modules in your development environment as root.
# cd ~/linux-sunxi/
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j4 uImage
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j4 INSTALL_MOD_PATH=out modules
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j4 INSTALL_MOD_PATH=out modules_install
9] In your development environment, your kernel will be "~/linux-sunxi/arch/arm/boot/uImage". And your modules will be found at "~/linux-sunxi/out/lib/modules/3.x.xx" where 3.x.xx is kernel version (eg: "3.4.90+").

Compiling Uboot
1] Download the uboot sources from GitHub repository.
# cd ~
# git clone -b sunxi

After the download you should have a new directory:

# cd ~/u-boot-sunxi
2] Note that I'm using the 44b53fd3928f15c34993ec8c6b8c2efcb79769ee revision. So, to use the mentioned revision:
# cd ~/u-boot-sunxi
# git checkout 44b53fd3928f15c34993ec8c6b8c2efcb79769ee

3] Edit ~/u-boot-sunxi/include/configs/sunxi-common.h . Look for the following:

"setargs=" \
"if test -z \\\\\"$root\\\\\"; then"\
" if test \\\\\"$bootpath\\\\\" = \"/boot/\"; then"\
" root=\"/dev/mmcblk0p1 rootwait\";"\
" else" \
" root=\"/dev/mmcblk0p2 rootwait\";"\
" fi;"\
" fi;"\

Change '" root=\"/dev/mmcblk0p2 rootwait\";"\' to the following:
" root=\"/dev/mmcblk0p2 ro rootwait\";"\

4] With the following command, you can start the uboot build:

# cd ~/u-boot-sunxi/
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- distclean
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- A10-OLinuXino-Lime_config
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

5] At the end of the process, you can check if everything is OK by:

# ls u-boot-sunxi-with-spl.bin
If you got this file, well done so far.

Format and setup the SD-card
We suggest that you use a 4GB class 10 micro SD card. But you can use any micro SD card between 2GB and 16GB.

Also, please make sure you have a micro SD card that is "clean." By "clean," I mean that this card was not set yet before for an ARM computer. If your micro SD card is not clean, there is a good chance that it will not boot. To clean by erasing the partition table and labels (Substitute "/dev/mmcblkX" appropriately for your micro SD card):

# dd if=/dev/zero of=/dev/mmcblkX bs=1M count=10

First, we have to make the correct card partitions. This is done with fdisk.

1] Substitute /dev/mmcblkX with your micro SD card in the references below:

# fdisk -u=sectors /dev/mmcblkX
Then do these steps:

1a] This will list your partitions:

1b] If there are already partitions on your card, do:
d 1
If you have more than one partitition, delete them all.

1c] Create the first partition. It should start from sector 2048 and end at sector 34815:
n p 1

1d] Create the second partition:
n p 2 enter enter

1e] List the created partitions:

If you did everything correctly on a 4GB card, you should see something like:

Disk /dev/mmcblk0: 15.9 GB, 15931539456 bytes
4 heads, 16 sectors/track, 486192 cylinders, total 31116288 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x4c6979ac

Device Boot Start End Blocks Id System
/dev/mmcblk0p1 2048 34815 16384 83 Linux
/dev/mmcblk0p2 34816 31116287 15540736 83 Linux

1f] Write changes to the micro SD card.

2] Now, we have to format the file system on the card:

The first partition should be vfat as this is the FS which the Allwinner bootloader understands.

# mkfs.vfat /dev/mmcblkXp1

3] The second partition should be a normal Linux EXT4 FS:

# mkfs.ext4 /dev/mmcblkXp2

Installing the kernel, Slackware ARM 14.1 mini root filesystem, and kernel modules
1] Proceed to copy the "~/linux-sunxi/arch/arm/boot/uImage" kernel you've compiled in the development environment into the first filesystem of the micro SD card.
Mount the first partition:
# mkdir /mnt/olinuxino0
# mount /dev/mmcblkXp1 /mnt/olinuxino0 # Substitute the appropriate value for X in /dev/mmcblkXp1

Then copy the kernel uImage to the first filesystem of the micro SD card.
# cp uImage /mnt/olinuxino0 # Get the uImage file from the environment you've compiled the kernel.
2] Copy the script.bin file in /mnt/olinuxino0 :
# cd /mnt/olinuxino0
# wget

3] Unmount /mnt/olinuxino0 :
# cd ~
# umount /mnt/olinuxino0
4] Mount the second partition:
# mkdir /mnt/olinuxino1
# mount /dev/mmcblkXp2 /mnt/olinuxino1 # Substitute the appropriate value for X in /dev/mmcblkXp2
5] Extract the Slackware ARM 14.1 mini root filesystem in /mnt/olinuxino1 . Slackware mini root filesystem can be found here:
6] Delete all contents of /mnt/olinuxino1/dev/*
7] Extract this file in /mnt/olinuxino1/dev :
8] Proceed to copy the generated kernel modules ("~/linux-sunxi/out/lib/modules/3.x.xx" in the development environment where you've compiled the kernel) in the second filesystem of the micro SD card.

If the /mnt/olinuxino1/lib/modules directory does not exist, create it.
# mkdir /mnt/olinuxino1/lib/modules
# cp -rf 3.x.xx+ /mnt/olinuxino1/lib/modules # Get the modules directory from the environment you've compiled the kernel.
9] Append the following in /mnt/olinuxino1/etc/fstab:
/dev/mmcblk0p2 / ext4 errors=remount-ro 0 1
10] Unmount /mnt/olinuxino1 :
# cd ~
# umount /mnt/olinuxino1

Write Uboot

Note that you have to write u-boot-sunxi-with-spl.bin in /dev/mmcblkX (not mmcblkXp1 or mmcblkXp2).

# dd if=u-boot-sunxi-with-spl.bin of=/dev/mmcblkX bs=1024 seek=8
# sync

Proceed to put your micro SD card on your OLinuXino A10 Lime, and then boot it.

NB: It takes a minute or two for Slackware 14.1 to boot. So if you've only connected your A10 Lime to a HDMI monitor/TV, please wait for the prompt. To speed up booting, make sure your A10 Lime is connected to a network that can assign a DHCP lease. When you boot OLinuXino using the micro SD card with Slackware 14.1 for ARM, the "root" user has the password "password" by default.