Linux-Installation auf dem Minix Neo X5

sudo ./build_minix_x5_sys.sh prepare
sudo ./build_minix_x5_sys.sh kernel
sudo ./build_minix_x5_sys.sh bootstrap
sudo ./build_minix_x5_sys.sh chrootfs

sudo ./build_minix_x5_sys.sh copy2usb

sudo ./rkflashtool w 0x10000 0x8000 < recovery.img

sudo ./rkflashtool r 0x0 0x2000 > parm.bin
cat param.bin | more

#!/bin/bash
SDCARDDIR=/media/linuxroot
BOOTSTRAP=qemu-debootstrap
BINFMT=binfmt-support
DEBOOTSTRAP=debootstrap
GIT=git
CROSSCOMPILER=gcc-arm-linux-gnueabihf
BESSENTIAL=build-essential
ARCH=armhf
VARIANT=minbase
DIST=precise
MIRROR=http://ports.ubuntu.com
HOMEDIR=`pwd`
BASEDIR=${HOMEDIR}/minix
ROOTFSDIR=${BASEDIR}/minix-rootfs
KERNELDIR=${BASEDIR}/minix-kernel
KERNELNAME=rk3066-kernel
MINIXHOSTNAME=minix
EXTRATOOLS="nano,openssh-server,ifupdown,netbase,net-tools,isc-dhcp-client,keyboard-configuration"

[ $UID -ne 0 ] && { 
    echo "Fehler: Das Script benötigt root-Rechte."
    echo "Aufruf mit mit sudo $0"
    exit 1
}

alles_packen() {
echo "Packe rootfs und kernel in minix.tar.bz2"
cd $HOMEDIR
tar -cvjf minix.tar.bz2 $BASEDIR
}

prepare() {
echo "Vorbereitungen"
 if [ -z $(which ${BOOTSTRAP}) ] || [ -z $(which /usr/sbin/update-binfmts) ] || [ -z $(which ${DEBOOTSTRAP}) ]
 then
 echo "Installiere qemu-user-static binfmt-support debootstrap"

 apt-get update
 apt-get -y install qemu-user-static binfmt-support debootstrap
 else
 echo "${BOOTSTRAP} ${BINFMT} und ${DEBOOTSTRAP} sind bereits installiert. OK."
 fi
 # extra build tools

 if [ -z $(which ${GIT}) ] || [ -z $(which arm-linux-gnueabihf-gcc) ] || [ ! -e /usr/share/build-essential/essential-packages-list ] || [ -z $(which uudecode) ] || [ ! -d /usr/include/libusb-1.0 ]
 then
  echo "Installiere git, gcc-arm-linux-gnueabihf, shareutils, libusb-1.0-0-dev und build-essential" 
  apt-get update  
  apt-get -y install git gcc-arm-linux-gnueabihf build-essential sharutils libusb-1.0-0-dev
 else
 echo "git gcc-arm-linux-gnueabihf, sharutils, libusb-1.0-0-dev und build-essential sind bereits installiert. OK"  
 fi

#ncurses für make menuconfig
if [ ! -e /usr/include/curses.h ]
then
echo "Installiere libncurses5-dev"
apt-get -y install libncurses5-dev
fi

 if [ ! -d $BASEDIR ] 
  then
  mkdir $BASEDIR && mkdir $KERNELDIR && mkdir $ROOTFSDIR && mkdir ${KERNELDIR}/kernel_mod
  chown -R $SUDO_USER:$SUDO_USER $BASEDIR
  echo "Arbeitsverzeichnisse erstellt"
fi

}

bootstrap() {
echo "Boootstrap"
cd $ROOTFSDIR
$BOOTSTRAP --verbose --variant=$VARIANT \
--include=$EXTRATOOLS --arch=$ARCH \
$DIST $ROOTFSDIR $MIRROR
}

install_adb() {
apt-get --no-install-recommends install openjdk-7-jre
cd $BASEDIR
wget -c http://dl.google.com/android/android-sdk_r22.3-linux.tgz
tar zxvf android-sdk_r22.3-linux.tgz
mv android-sdk-linux $BASEDIR/android
chown -R $SUDO_USER:$SUDO_USER $BASEDIR/android

if [ ! -d ${HOMEDIR}/.android ]
then
mkdir ${HOMEDIR}/.android
chown -R $SUDO_USER:$SUDO_USER ${HOMEDIR}/.android
fi 

if [ ! -e ${HOMEDIR}/.android/adb_usb.ini ]
then
cat<<EOF>${HOMEDIR}/.android/adb_usb.ini
# ANDROID 3RD PARTY USB VENDOR ID LIST -- DO NOT EDIT.
# USE 'android update adb' TO GENERATE.
# 1 USB VENDOR ID PER LINE.
0x2207
EOF
chown $SUDO_USER:$SUDO_USER ${HOMEDIR}/.android/adb_usb.ini
fi

if [ ! -e /etc/udev/rules.d/51-android.rules ]
then
cat<<EOF>/etc/udev/rules.d/51-android.rules
SUBSYSTEM=="usb", ATTR{idVendor}=="2207", MODE="0666"
EOF
chown root:root /etc/udev/rules.d/51-android.rules
chmod 644 /etc/udev/rules.d/51-android.rules
sudo service udev restart 
fi

cd ${BASEDIR}/android/tools
su $SUDO_USER ./android
}

##############################################
kernel() {

echo "Kernel herunterladen/bauen"
cd $KERNELDIR

#Kernel sourcen scon vorhanden? Sonst herunterladen
if [ ! -d rk3066-kernel ]
then
git clone --depth 1 https://github.com/Myria-de/rk3066-kernel-minix-neo-x5 rk3066-kernel
fi

#initramfs
if [ ! -d initramfs ]
then
echo "Hole initramfs"
git clone --depth 1 https://github.com/Galland/rk30_linux_initramfs.git initramfs
cd initramfs
gzip -dc debian-3.0.8+fkubi.cpio.gz > initramfs.cpio
fi

# kernel schon vorhanden?
BUILDKERNEL=yes
if [ -e ${KERNELDIR}/${KERNELNAME}/arch/arm/boot/zImage ]
then
  read -p "Kernel-Image vorhanden. Neu erstellen (j/N)?" choice
   case "$choice" in 
   j|J ) BUILDKERNEL=yes;;
   * ) BUILDKERNEL=no;;
   esac
fi

#kernel erstellen
if [ ${BUILDKERNEL} == yes ]
then
echo "Baue kernel"
cd ${KERNELDIR}/${KERNELNAME}
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
export INSTALL_MOD_PATH=${KERNELDIR}/kernel_mod
export KDIR=./
export LOCALVERSION=""
MAKE="make -j$(getconf _NPROCESSORS_ONLN)"
$MAKE mrproper
cp .config_minix_neo_x5_20131018 .config
#cp config.pcw .config
$MAKE
$MAKE modules_install
fi

# mkbootimge für das Erstellen von recovery.img 
if [ ! -d ${KERNELDIR}/tools ]
then
echo "Hole mkbootimge"
cd ${KERNELDIR}
git clone --depth 1 https://github.com/olegk0/tools.git 
else
echo "mkbootimge ist bereits vorhanden"
fi

#rkflashtool zum Flashen von recovery.img
cd ${KERNELDIR}
if [ ! -d ${KERNELDIR}/rkflashtool ]
then
echo "Hole rkflashtool_rk3066"
git clone --depth 1 https://github.com/Galland/rkflashtool_rk3066.git rkflashtool
cd ${KERNELDIR}/rkflashtool
make
 if [ -e ${KERNELDIR}/rkflashtool/rkflashtool ]
 then
 echo "rkflashtool erfolgreich erstellt" 
 else
 echo "Fehler konnte rkflashtool nicht erstellen" 
 fi
else
echo "rkflashtool ist vorhanden"
fi

echo "Erstelle recovery.img"
cd ${KERNELDIR}/tools
./mkbootimg --kernel ${KERNELDIR}/${KERNELNAME}/arch/arm/boot/zImage \
--ramdisk ${KERNELDIR}/initramfs/fakeramdisk.gz --base 60400000 \
--pagesize 16384 --ramdiskaddr 62000000 \
-o ${KERNELDIR}/recovery.img
cd ${KERNELDIR}
if [ -e ${KERNELDIR}/recovery.img ]
then
echo "recovery.img erfolgreich erstellt"
mv ${KERNELDIR}/recovery.img ${KERNELDIR}/rkflashtool/recovery.img
else
echo "Fehler: recovery.img wurde nicht erstellt"
fi

}

#copy files to SD card /media/linuxroot
copy_files() {
echo "Dateien auf SD-Karte kopieren"
if [ -d ${SDCARDDIR} ]
then
echo "Kopiere rootfs"
cp -av ${ROOTFSDIR}/* ${SDCARDDIR}
echo "Kopiere Kernel-Module"
cp -av ${KERNELDIR}/kernel_mod/* ${SDCARDDIR}
else
echo "Verzeichnis ${SDCARDDIR} existiert nicht. Bitte SD-Karte einhängen."
fi

}
##############################################
rootfs() {
echo "Rootfs bearbeiten"

cat<<EOF>${ROOTFSDIR}/install_tools.sh
echo "Installiere Tools im rootfs..."
export LANG=C
apt-get update
apt-get -y install apt-utils dialog locales
cat <<END > /etc/apt/apt.conf.d/71neo
APT::Install-Recommends "0";
APT::Install-Suggests "0";
END
locale-gen de_DE.UTF-8
dpkg-reconfigure locales
localedef -i de_DE -c -f UTF-8 de_DE.UTF-8 
export LANG=de_DE.UTF-8

apt-get -y install sudo udev iproute iputils-ping wget ntpdate ntp vim less most tzdata console-tools console-data console-common module-init-tools linux-firmware

echo "Bitte geben Sie die Daten für den neuen Benutzer ein."
adduser mx
adduser mx sudo
EOF

cat<<EOF>${ROOTFSDIR}/config_keyboard.sh
dpkg-reconfigure tzdata
dpkg-reconfigure console-data
dpkg-reconfigure console-common
dpkg-reconfigure keyboard-configuration
EOF

chmod 755 ${ROOTFSDIR}/install_tools.sh
chmod 755 ${ROOTFSDIR}/config_keyboard.sh

mount -t proc proc ${ROOTFSDIR}/proc
mount -t sysfs sysfs ${ROOTFSDIR}/sys
mount -o bind /dev ${ROOTFSDIR}/dev
mount -t devpts devpts ${ROOTFSDIR}/dev/pts
echo "Wechsele in ${ROOTFSDIR}"
chroot ${ROOTFSDIR}
# mountpoints wieder entfernen
umount ${ROOTFSDIR}/proc
umount ${ROOTFSDIR}/sys
umount ${ROOTFSDIR}/dev/pts
umount ${ROOTFSDIR}/dev
}
#########################################
prepare_rootfs() {
echo "Bereite rootfs vor"

# Ubuntu 12.04 Paketquellen
echo "Lege Paketquellen fest ..."
cat<<EOF>${ROOTFSDIR}/etc/apt/sources.list
deb http://ports.ubuntu.com/ubuntu-ports/ precise main restricted universe multiverse
deb-src http://ports.ubuntu.com/ubuntu-ports/ precise main restricted universe multiverse
deb http://ports.ubuntu.com/ubuntu-ports/ precise-updates main restricted universe multiverse
deb-src http://ports.ubuntu.com/ubuntu-ports/ precise-updates main restricted universe multiverse
deb http://ports.ubuntu.com/ubuntu-ports/ precise-security main restricted universe multiverse
deb-src http://ports.ubuntu.com/ubuntu-ports/ precise-security main restricted universe multiverse
EOF

#Hostname
echo ${MINIXHOSTNAME} >  ${ROOTFSDIR}/etc/hostname
echo "127.0.1.1 ${MINIXHOSTNAME}" >>  ${ROOTFSDIR}/etc/host

#fstab
cat<<EOF>${ROOTFSDIR}/etc/fstab
/dev/root / ext4 defaults,noatime 0 0
tmpfs    /var/log    tmpfs    defaults    0 0
tmpfs    /tmp        tmpfs    defaults    0 0
tmpfs    /var/tmp    tmpfs    defaults    0 0
EOF

#Netzwerk setup
cat<<EOF>${ROOTFSDIR}/etc/network/interfaces
auto lo
iface lo inet loopback
# Ethernet interface eth0 
auto eth0
iface eth0 inet dhcp

# WLAN eth1
# auto eth1
# iface eth1 inet dhcp
# wpa-ssid testminix
# wpa-psk 12345
EOF

echo "resolve.conf durch die des Hauptsystems ersetzen"
cp -d /etc/resolv.conf ${ROOTFSDIR}/etc/resolv.conf

}

hilfe() {
cat<<EOF
Aufruf: $0 prepare|bootstrap|kernel|rootfs|copy|packen|adb|mksystem|hilfe

Optionen:
prepare .... System vorbereiten, nötige Pakete installieren
bootstrap .. Dateien für rootfs herunterladen
kernel ..... Kernel herunterladen/compilieren
chrootfs ... mit chroot in das rootfs wechslen
copy2sd .... System auf SD-Karte kopieren
packen ..... Arbeitsverzeichnis für Backup in Datei minix.tar.bz2 packen
adb ........ Android-SDK installieren
mksystem ... führt prepare, kernel und bootstrap nacheinander aus
help ....... diese Hilfe anzeigen

EOF
}

case "$1" in
  prepare)
  prepare
  ;;
  bootstrap)
  prepare 
  bootstrap
  ;;
  kernel)
  prepare  
  kernel
  ;;
  copy2sd)
  copy_files
  ;;
  packen)
  alles_packen
  ;;
  adb)
  install_adb
  ;;
  chrootfs)
  prepare_rootfs
  rootfs
  ;;
  mksystem)
  prepare
  bootstrap
  prepare_rootfs
  kernel
  #alles_packen
  ;;
  hilfe)
  hilfe
  ;;
  *)
  hilfe
  ;;
esac
exit 0