S3C6410 porting Android kernel

Main process:
. Install lunux environment
. Install compilation tools
. Download Linux kernel
. Install Android  SDK
. Get root file system
. Modify Linux kernel source code
. Configure Linux kernel
. Modify root file system
. Compile Linux kernel
. Download kernel Image

1. Install the Linux environment 
Install the Ubuntu Linux system, download the operating system installation CD image from the website, address:
http://mirror.lupaworld.com/ubuntu/releases/8.04/ 
Download ubuntu-8.04.2-desktop-i386.iso, burn it to a CD for installation, the installation can be done under the Windows system,
select a hard disk with 15G space for installation, enter the user password to start the installation
  
, this step is over, exit the CD and restart into the Ubuntu system to complete the rest of the system installation. After
the Linux installation is complete, enter the Ubuntu system, make sure the computer is connected to the Internet, and install some necessary software.
Open the terminal and enter the command box, and perform the following operations:
$ sudo apt-get install ssh
$ sudo apt-get install flex bison gperf libsdl-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl
$ sudo apt-get install valgrind
$ sudo apt-get install sun-java6-jdk
$ sudo apt-get install libncurses5-dev
The system will automatically download and install all software from the Internet. After completion, you can start the Android porting.

2. Install the compilation tool
Download:
$ wget 
http://www.codesourcery.com/public/gnu_toolchain/arm-none-linux-gnueabi/arm-2008q1-126-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 
Installation:
$ tar -xjvf arm-2008q1-126-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2

3. Download the Linux kernel 
from the following address:
http://code.google.com/p/android/downloads/list?can=1&q=&colspec=Filename+Summary+Uploaded+Size+DownloadCount 
Kernel: linux-2.6.23-android-m5-rc14.tar.gz
Unzip the file
$ tar -xf linux-2.6.23-android-m5-rc14.tar.gz

4. Install Android SDK 
Download the Linux version of Android SDK from the Internet, as follows:
http://dl.google.com/android/android-sdk_m5-rc15_linux-x86.zip 
Download and unzip to obtain the android-sdk_m5-rc15_linux-x86 file

5. Get the root file system 
⑴ Download the busybox tool from the following address:
http://benno.id.au/blog/2007/11/14/android-busybox  (download in Linux environment)
⑵ Run the emulator to get the root file system
$ cd / android-sdk_m5-rc15_linux-x86/tools
$ ./emulator&
Wait for the emulator to start, and see the Android system screen appear. Enter the menu ALL/Dev Tools/Development Settings, check the three items of Wait for debugger, Show running processes, and Show screen updates, and return to the command input terminal.
$ ./adb push /busybox /data
$ ./adb shell
# /data/busybox tar -czf system.tar.gz /system
# /data/busybox tar -czf data.tar.gz /data
# /data/busybox tar -czf etc.tar.gz /etc
# /data/busybox tar -czf sbin.tar.gz /sbin
# exit
$ ./adb pull /system.tar.gz ./
$ ./adb pull /data.tar.gz ./
$ ./adb pull /etc.tar.gz ./
$ ./adb pull /sbin.tar.gz ./
$ ./adb pull /init ./The
emulator files are obtained and packaged through the busybox tool. Now create the root file directory
$ mkdir initial_ram_disk
$ cd initial_ram_disk
$ mkdir cache
$ mkdir d
$ mkdir dev
$ mkdir proc
$ mkdir root
$ mkdir sdcard
$ mkdir sys
$ mkdir tmp
$ mkdir var
$ tar -xf /system.tar.gz ./
$ tar -xf /data.tar.gz ./
$ tar -xf /etc.tar.gz ./
$ tar -xf / sbin.tar.gz ./
$ cp /init ./
initial_ram_disk containing the Android root file system is done.

6. Modify
the kernel file downloaded from the Linux kernel source code does not support the smdk6400 development board. You must add the smdk6400 configuration file to the kernel and modify the Kconfig and Makefile files.
Modify as follows:
1> Select /arch/arm/mach-s3c2410/Makefile.boot and change it to the following content:
zreladdr-$(CONFIG_PLAT_S3C24XX) := 0x30008000
params_phys-$(CONFIG_PLAT_S3C24XX) := 0x30000100
zreladdr-$(CONFIG_PLAT_S3C64XX) := 0x50008000
params_phys-$(CONFIG_PLAT_S3C64XX) := 0x50000100

2> Copy the following files from the mature smdk6400 platform file to the kernel directory
/arch/arm/mach-s3c6400
/drivers/serial/s3c6400.c
/drivers/input/touchscreen/s3c-ts.c
/drivers/usb/gadget

3> Copy the /drivers/android/ashmem.c file to the corresponding directory from another android kernel (The Android source code for 2.6.23 does not contain this file)

4> Modify the corresponding Kconfig and Makefile files so that they can be compiled into the loaded smdk6400 file.

7. Configure Linux kernel 
After modifying the kernel, configure it and use the compiler tool in step 2.
$ cd
$ make CROSS_COMPILE=/bin/arm-none-linux-gnueabi- ARCH=arm
menuconfig
Now enter the kernel configuration screen. Note that the Initramfs source file option should be configured to specify the initial_ram_disk file.

8. Modify the root file system 
configuration Touchscreen so that it can work properly. Modify /etc/init.rc in the initial_ram_disk file and add the following content:
TSLIB_CONSOLEDEVICE none
TSLIB_FBDEVICE /dev/graphics/fb0
TSLIB_TSDEVICE /dev/input/ts0
TSLIB_CALIBFILE /etc/pointercal
TSLIB_CONFFILE /etc/ts.conf
TSLIB_PLUGINDIR /lib/ts

9. Compile Linux kernel
$ make CROSS_COMPILE=/bin/arm-none-linux-gnueabi- ARCH=arm 
The zImage
is compiled successfully. The generated zImage file is under arch/arm/boot.

10. Download the kernel image 
and enter the Windows system. The download process is completed in the Windows system.
① Open: Program Attachment Communication HyperTerminal, configure COM port, 115200, 8N1
  
② Connect the smdk6400 development board and the computer through the serial port cable, turn on the power of the development board, you can see the output information in the hyperterminal, the bootloader starts, press the space bar to enter the command input state
  
③ Connect the USB cable on the board to the computer and install the USB driver
④ Run the dnw.exe program, configure Configuration/Options, address 0x57e00000, confirm
  
⑤ Enter the corresponding command in the hyperterminal to start downloading
$ run bootup (download bootloader)
$ run kernelup (download kernel Image)
$ run rootup (download root file system)
⑥ Here we enter
$ run kernelup
    and wait for dnw to send the file. dnw displays [COM1,115200bps][USB:OK][ADDR:0x57e00000], indicating that the connection is successful. Select USB Port->Transmit, select the successfully compiled zImage file, and start downloading.
    After the download is complete, restart the development board and wait. Some Android characters will appear on the LCD. The screen will be white for a while, and then a red scroll bar will appear. The main interface will be entered and the Android transplantation will be successful.