L27.INC1.5.2 Froyo ES2 Release Notes

From OMAPpedia

(Difference between revisions)
Jump to: navigation, search
(Bootargs)
m (Build Instructions)
 
(7 intermediate revisions not shown)
Line 104: Line 104:
make distclean
make distclean
make ARCH=arm omap4430sdp_config
make ARCH=arm omap4430sdp_config
 +
make ift 2>&1 |tee $MYDROID/logs/x-loader_make.out
 +
</pre>
 +
 +
For previous board revisions with OMAP4 ES1 600MHz, the configuration should be changed as described below:
 +
<pre>
 +
cd $MYDROID/bootable/bootloader/x-loader
 +
make distclean
 +
make ARCH=arm omap4430sdp_MPU_600MHz_config
make ift 2>&1 |tee $MYDROID/logs/x-loader_make.out
make ift 2>&1 |tee $MYDROID/logs/x-loader_make.out
</pre>
</pre>
'''Signing X-LOADER for EMU devices'''
'''Signing X-LOADER for EMU devices'''
-
The tool for signing x-loader is provided on TI's package
+
 
 +
The tool for signing x-loader is provided on TI's package. Please contact TI customer representative to gain access to this tool.
<pre>
<pre>
cd $YOUR_PATH/27.5.2/mshield-dk
cd $YOUR_PATH/27.5.2/mshield-dk
Line 116: Line 125:
'''Building Kernel'''
'''Building Kernel'''
 +
 +
To create kernel uImage you need to add "mkimage" directory path to your "PATH" environment variable:
<pre>
<pre>
 +
export PATH=$PATH:$MYDROID/bootable/bootloader/u-boot/tools
cd $YOUR_PATH/kernel/android-2.6.32
cd $YOUR_PATH/kernel/android-2.6.32
make ARCH=arm distclean
make ARCH=arm distclean
Line 128: Line 140:
make ARCH=arm modules 2>&1 |tee $MYDROID/logs/kernel_modules.out
make ARCH=arm modules 2>&1 |tee $MYDROID/logs/kernel_modules.out
</pre>
</pre>
 +
 +
'''Building WLAN(1283) driver'''
 +
<pre>
 +
export HOST_PLATFORM=sdc4430
 +
export KERNEL_DIR=$YOUR_PATH/kernel/android-2.6.32
 +
cd $MYDROID/hardware/ti/wlan/wl1283/platforms/os/linux
 +
make ARCH=arm
 +
</pre>
 +
'''Building Android Filesystem (AFS) with TI Codecs enabled'''
'''Building Android Filesystem (AFS) with TI Codecs enabled'''
Line 430: Line 451:
'''L27.5.2 Bootargs for SD card boot'''
'''L27.5.2 Bootargs for SD card boot'''
<pre>
<pre>
-
setenv bootargs 'console=ttyO2,115200n8 root=/dev/mmcblk0p2 rw rootdelay=2 mem 463M init=/init omapfb.vram="0:4M"'
+
setenv bootargs 'console=ttyO2,115200n8 root=/dev/mmcblk0p2 rw rootdelay=2 mem=463M init=/init omapfb.vram="0:4M"'
setenv bootcmd 'mmcinit 0;fatload mmc 0 0x80000000 uImage; bootm 0x80000000'
setenv bootcmd 'mmcinit 0;fatload mmc 0 0x80000000 uImage; bootm 0x80000000'
saveenv
saveenv

Latest revision as of 14:27, 3 September 2010

Contents

[edit] Introduction

This software release has been developed and verified in the following software and hardware environment.

OS Kernel: Linux® 2.6.32
Android: Froyo public project
Toolchain: CodeSourcery compiler version 2009q1.
Reference hardware platform: TI OMAP4 ES2 EMU Blaze
Build Host OS: Ubuntu

[edit] Tools & Dependency packages

Pre-requisite packages for build Android Filesystem (Note this is with reference to uBuntu 8.04)

The following commands will install the correct packages to your server:
$ sudo apt-get install git-core flex bison gperf libesd0-dev libwxgtk2.6-dev zlib1g-dev build-essential libstdc++5 tofrodos
$ sudo apt-get install x-dev
$ sudo apt-get install libx11-dev
$ sudo apt-get install libncurses5-dev
$ sudo apt-get install sun-java5-jdk
If you do not have sudo rights to your machine, contact your System Administrator for assistance.
Google has issued that “sun-java6-jdk” has become unsupported: “because of incompatibilities with @Override”
To uninstall “sun-java6-jdk” please type:
$ sudo apt-get remove sun-java6-jdk
“Intrepid (8.10) users may need a newer version of libreadline:
$ sudo apt-get install lib32readline5-dev”

For higher versions of U-buntu please refer to 
http://omappedia.org/wiki/Android:_Configuring_the_Host_PC#Additional_packages_required_for_building

Tool Chain for building Kernel and Drivers

The Kernel and Driver sources are built using CodeSourcery ARM Compiler version 2009q1 - 203 version.
This tool chain can be obtained from [http://www.codesourcery.com/sgpp/lite/arm/portal/release858
Select IA32 GNU/Linux TAR one (1a6e88782f08b09a0e6cef545a1712ec)

[edit] Downloading Release Software

Android Filesystem Sources

you can get the Android source for this release by doing:
	$ git clone git://git.omapzoom.org/platform/omapmanifest.git
	$ cd omapmanifest
	$ git reset --hard RLS27.5.2_Froyo
	$ export MANIFEST=`pwd`
	$ cd <your work directory>
	$ export YOUR_PATH=`pwd`
	$ mkdir -p 27.5.2/mydroid; cd 27.5.2/mydroid
	$ export MYDROID=`pwd`
	$ repo init –u $MANIFEST
	$ repo sync

Kernel & Driver Sources

$ cd <your work directory>
$ cd $YOUR_PATH; mkdir kernel
$ git clone git://git.omapzoom.org/kernel/omap.git kernel/android-2.6.32
$ cd kernel/android-2.6.32
$ git checkout a8b5446393aaf989a705385fbda9bd92f49a9b8e

If you already have kernel source cloned then just update it :
$ cd $YOUR_PATH/kernel/android-2.6.32
$ git fetch origin
$ git checkout a8b5446393aaf989a705385fbda9bd92f49a9b8e

[edit] Release Content

This release has the below content
- Kernel and Drivers tested with OMAP4 ES2 EMU Blaze platform and verified with Froyo UI
- A9 source code for accelerating Video

The release has been verified with OMAP4 SGX hardware Graphics Accelerator libraries and accelerated Video codecs
Please contact TI customer representative to gain access TI proprietary packages

[edit] Build Instructions

From your work directory (where your 27.5.2 folder resides):
Setting up build environment

export YOUR_PATH=`pwd`
export PATH=$PATH:<toolchain_parent_dir>/arm-2009q1/bin
export MYDROID=${YOUR_PATH}/27.5.2/mydroid
mkdir $MYDROID/logs
export JAVA_HOME=/usr/lib/jvm/java-1.5.0-sun
export CROSS_COMPILE=arm-none-linux-gnueabi-
export PATH=${MYDROID}/bootable/bootloader/u-boot/tools:${PATH}

Building U-BOOT

cd $MYDROID/bootable/bootloader/u-boot
make distclean
make ARCH=arm omap4430sdp_config
make 2>&1 |tee $MYDROID/logs/u-boot_make.out
export PATH=$PATH:$MYDROID/bootable/bootloader/u-boot/tools

Building X-LOADER

cd $MYDROID/bootable/bootloader/x-loader
make distclean	
make ARCH=arm omap4430sdp_config
make ift 2>&1 |tee $MYDROID/logs/x-loader_make.out

For previous board revisions with OMAP4 ES1 600MHz, the configuration should be changed as described below:

cd $MYDROID/bootable/bootloader/x-loader
make distclean	
make ARCH=arm omap4430sdp_MPU_600MHz_config
make ift 2>&1 |tee $MYDROID/logs/x-loader_make.out

Signing X-LOADER for EMU devices

The tool for signing x-loader is provided on TI's package. Please contact TI customer representative to gain access to this tool.

cd $YOUR_PATH/27.5.2/mshield-dk
cp -f $MYDROID/bootable/bootloader/x-loader/x-load.bin .
./generate_MLO x-load.bin

Building Kernel

To create kernel uImage you need to add "mkimage" directory path to your "PATH" environment variable:

export PATH=$PATH:$MYDROID/bootable/bootloader/u-boot/tools
cd $YOUR_PATH/kernel/android-2.6.32
make ARCH=arm distclean
make ARCH=arm android_4430_defconfig
make ARCH=arm uImage 2>&1 |tee $MYDROID/logs/kernel_make.out

Building Kernel modules

cd $YOUR_PATH/kernel/android-2.6.32
make ARCH=arm modules 2>&1 |tee $MYDROID/logs/kernel_modules.out

Building WLAN(1283) driver

export HOST_PLATFORM=sdc4430
export KERNEL_DIR=$YOUR_PATH/kernel/android-2.6.32
cd $MYDROID/hardware/ti/wlan/wl1283/platforms/os/linux
make ARCH=arm


Building Android Filesystem (AFS) with TI Codecs enabled

on step below use the number of cores you have available; i.e. -j4 or -j12:

cd $MYDROID
cp -Rfp device/ti/blaze/buildspec.mk.default buildspec.mk
make clean (required for rebuild only)
make -j4 2>&1 |tee $MYDROID/logs/android_make.out

Building AFS with Android Codecs

Edit: “device/ti/blaze/BoardConfig.mk”: 
Uncomment  “USE_CAMERA_STUB := true” 
Comment “BOARD_USES_TI_CAMERA_HAL := true” 
Comment "HARDWARE_OMX := true”

This release is not yet verified with Android codecs. Camera based applications need TI proprietary drivers. 
Please contact TI customer representative to get access to proprietary sources

Please follow the below instructions to modify the file system to make it work.

Preparing Android binaries

The following binaries are required by the Blaze® board. This step will prepare a directory, called myfs, containing all necessary Android files that you must include within your SD card.

cd $YOUR_PATH
mkdir myfs
cd myfs
cp -Rfp $YOUR_PATH/kernel/android-2.6.32/drivers/misc/ti-st/*.ko $MYDROID/out/target/product/blaze/root
cp -Rfp $MYDROID/out/target/product/blaze/root/* .
cp -Rfp $MYDROID/out/target/product/blaze/system/ .
cp -Rfp $MYDROID/out/target/product/blaze/data/ .
cp -Rfp $MYDROID/device/ti/blaze/init.omap4sdp.rc init.rc

Changing default display resolution on Android

edit build.prop file as below
echo “ro.sf.lcd_density=240” >> system/build.prop

[edit] Booting Kernel and Android File System from SD card

Formatting SD Card

You will need to format your SD for the Linux file system. 
Connect your SD memory card reader with memory card inserted to a USB port on your Linux Ubuntu PC. You must login as Super User.
$ su
$ fdisk -l
Match the device to the size of your memory card.  Look for the /dev/*** device which matches the memory card in the card reader.  Use the matching device’s letter prefix in the next command.  For example if the device for memory card reader card example was: /dev/sdb1, then use only /dev/sdb in the fdisk command. 

Take note of the size in bytes of your SD Card.  You will need this to calculate the number of cylinders in a future step.

$ fdisk /dev/sdb  (replace sdb with the letter prefix for your device)

(Delete all partitions on the card if they exist)
Command (m for help): d
Partition number (1-4): 1
Command (m for help): d
Selected partition 2

Command (m for help): x

(Change the number of heads, sectors and cylinders on the device)
Expert command (m for help): h
Number of heads (1-256, default 255): 255
Expert command (m for help): s
Number of sectors (1-63, default 63): 63
Expert command (m for help): c
Number of cylinders (1-1048576, default 248): <You must calculate the number of cylinders for your SD card.  To do this, use the following formula:  

new_cylinders = (Size in bytes from your fdisk –l command)/8225280
Drop any fractional values and enter the whole number in this command.
Use this number all the steps that refer to the number of cylinders>

(Now return to the main menu)
Expert command (m for help): r

(Create the first partition)
Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-248, default 1): 1
Last cylinder or +size or +sizeM or +sizeK (1-248, default 248): +64M

If you plan to use this SD card partition for storing media your can use +1024M assuming a 2+ GB SD card.

(Create the second partition)
Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (10-248, default 10): 10
Last cylinder or +size or +sizeM or +sizeK (124-248, default 248): <use the cylinder value you calculated earlier>  

(Change the first partition to at FAT32 partition)
Command (m for help): t
Partition number (1-4): 1
Hex code (type L to list codes): c
Changed system type of partition 1 to c (W95 FAT32 (LBA))

(Toggle the bootable flag for partition 1)
Command (m for help): a
Partition number (1-4): 1

(Print the partition table to confirm your settings)
Command (m for help): p

(Sample Output – your output may differ depending on your SD card’s size and brand)
Disk /dev/sdb: 2041 MB, 2041577472 bytes
255 heads, 63 sectors/track, 248 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x00000000

   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1   *           1         9        72261     c  W95 FAT32 (LBA)
/dev/sdb2              10       248     1919767+    83  Linux

(Write your changes to the SD Card)	
Command (m for help): w

(You will see the following output)
The partition table has been altered!

Calling ioctl() to re-read partition table.


WARNING: If you have created or modified any DOS 6.x partitions, please see the fdisk manual page for additional information.
Syncing disks.

Format your partitions typing the following commands (logged as root@ubuntu-box):
$ mkfs.vfat -F 32 -n boot /dev/<your device’s first partition’s name – see the print output from the previous step> 
$ mkfs.ext3 -L android_fs /dev/<your device’s second partition’s name – see the print output from the previous step> 

There is a shell script that all calculations above automatically; to get it do:
$ wget http://cgit.openembedded.org/cgit.cgi/openembedded/plain/contrib/angstrom/omap3-mkcard.sh

Add execution permission:
$ chmod +x omap3-mkcard.sh

And you are ready to use it by just typing:
$sudo ./omap3-mkcard.sh <your_device (e.g. /dev/sdb)>

Copying Binaries onto SD Card


Now type the following to mount your SD Card on your Linux box (logged as root@ubuntu-box):
$ mkdir /tmp/mmc1
$ mkdir /tmp/mmc2
$ mount /dev/<your device’s first partition’s name> /tmp/mmc1
$ mount /dev/<your device’s second partition’s name> /tmp/mmc2

Load the appropriate software to the SD Card (logged as root@ubuntu-box):
$ cp $MYDROID/bootable/bootloader/x-loader/MLO /tmp/mmc1
$ cp $MYDROID/bootable/bootloader/u-boot/u-boot.bin /tmp/mmc1
$ cp $YOUR_PATH/kernel/android-2.6.32/arch/arm/boot/uImage /tmp/mmc1
$ cp -Rfp $YOUR_PATH/27.5.2/myfs/* /tmp/mmc2
$ chmod –R 777 /tmp/mmc2/*
$ umount /tmp/mmc1
$ umount /tmp/mmc2

Booting

Insert your SD card (with u-boot, x-loader and uImage loaded in FAT partition and ) into Blaze SD/MMC card slot, then plug the Blaze mini USB port to your PC and open a serial terminal (baudrate:115200, no parity, 8 bits). Power your board up and in your terminal window you should be able to see the ‘New’ u-boot prompt: 
“OMAP44XX SDP #”
In your serial terminal define the following:
setenv bootargs console=ttyO2,115200n8 root=/dev/mmcblk0p2 rw rootdelay=2 mem=463M init=/init omapfb.vram="0:4M"

now type this:
mmcinit 0; fatload mmc 0 0x80000000 uImage; bootm 0x80000000

Right after this your Blaze should start booting using the kernel image and loading the Android filesystem from your SD

[edit] Booting Kernel and Android File System from eMMC

Formatting eMMC

If your are going to use of eMMC for the first time, you need to create the appropriate partitions and then create a filesystem (format) for each one. For this you need to boot an Android filesystem entirely from SD card as described earlier.
Once your Android filesystem is up and running, your need to enable eMMC as a device for USB mass storage:
$ echo /dev/block/mmcblk1 >/sys/devices/platform/musb_hdrc/gadget/lun0/file

Now connect the Blaze micro USB connector to your Linux box and from your PC terminal type:
$ sudo fdisk -l
And a list of available devides should appear. You should see eMMC as an un-mounted raw device of 32 GB (ES1.0):
(device name may vary on other linux-boxes)
Disk /dev/sdg: 32.0 GB, 32015122432 bytes
255 heads, 63 sectors/track, 3892 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x00000000

Important Notes:
* eMMC device data (head, cylinders and sectors) presented here may vary on other Blaze boards
* For ES2.0 eMMC size is 8GB, please do calculate cylinders value accordingly.

Now create two partitions exactly the same way as for SD card:
$ sudo fdisk /dev/sdg

(assuming you are formatting Blaze eMMC for the first time):
Command (m for help):  d
Command (m for help): x
Expert command (m for help): h
Number of heads (1-256, default 30): 255
Expert command (m for help): s
Number of sectors (1-63, default 29): 63
Warning: setting sector offset for DOS compatiblity
Expert command (m for help): c
Number of cylinders (1-1048576, default 2286): 3891

Configure eMMC partitions:
Expert command (m for help): r
Command (m for help): n
Command action
e extended
p primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-123, default 1):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-123, default 123): +1024M
NOTE: This is the vFAT size, in this case the vFAT size would be 1GB you can change this, in this partition the boot files and media content must be placed.

Command (m for help): n
Command action
e extended
p primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (10-123, default 10):
Using default value 10
Last cylinder or +size or +sizeM or +sizeK (10-123, default 123):
Using default value 123

FAT32 Partition:
Command (m for help): t
Partition number (1-4): 1
Hex code (type L to list codes): c
Changed system type of partition 1 to c (W95 FAT32 (LBA))
* You have to format 1st partitions with vfat32 filesystem.
Command (m for help): a
Create partition table:
Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.

WARNING: If you have created or modified any DOS 6.x
partitions, please see the fdisk manual page for additional
information.
Syncing disks.

Formatting partitions:
$ sudo mkfs.vfat -F 32 -n boot /dev/sdg1
$ sudo mkfs.ext3 -L rootfs /dev/sdg2

Copying Binaries onto eMMC

Now type the following to mount your eMMC partitions on your Linux box (logged as root@ubuntu-box):
$ mkdir /tmp/mmc1
$ mkdir /tmp/mmc2
$ mount /dev/<emmc’s first partition’s name> /tmp/mmc1
$ mount /dev/<emmc’s second partition’s name> /tmp/mmc2

Load the appropriate software to the SD Card (logged as root@ubuntu-box):
$ cp $YOUR_PATH/kernel/android-2.6.32/arch/arm/boot/uImage /tmp/mmc1
$ cp -Rfp $YOUR_PATH/27.5.2/myfs/* /tmp/mmc2
$ chmod –R 777 /tmp/mmc2/*
$ umount /tmp/mmc1
$ umount /tmp/mmc2

Booting

Insert your SD card (with u-boot and signed x-loader loaded in FAT partition and ) into Blaze SD/MMC card slot, then plug the Blaze mini USB port 
to your PC and open a serial terminal (baudrate:115200, no parity, 8 bits).
Power your board up and in your terminal window you should be able to see the ‘New’ u-boot prompt:
“OMAP44XX SDP #”

In your serial terminal define the following:
$setenv bootargs 'console=ttyO2,115200n8 mem=463M root=/dev/mmcblk1p2 rw rootdelay=2 init=/init omapfb.vram="0:4M"'
$setenv bootcmd 'mmcinit 1;fatload mmc 1 0x80000000 uImage;bootm 80000000'
$saveenv
$boot

Right after this your Blaze should start booting kernel image and loading the Android filesystem both from Blaze eMMC

* bootable sdcard is required to get OMAP prompt, it can be changed or removed once the kernel is loaded

[edit] Bootargs

L27.5.2 Bootargs for SD card boot

setenv bootargs 'console=ttyO2,115200n8 root=/dev/mmcblk0p2 rw rootdelay=2 mem=463M init=/init omapfb.vram="0:4M"'
setenv bootcmd 'mmcinit 0;fatload mmc 0 0x80000000 uImage; bootm 0x80000000'
saveenv
boot

Saving Bootargs for eMMC boot


$setenv bootargs 'console=ttyO2,115200n8 mem=463M root=/dev/mmcblk1p2 rw rootdelay=2 init=/init omapfb.vram="0:4M"'
$setenv bootcmd 'mmcinit 1;fatload mmc 1 0x80000000 uImage;bootm 80000000'
$saveenv
$boot

Right after this your Blaze should start booting kernel image and loading the Android filesystem both from Blaze eMMC

Note - bootable sdcard is required to get OMAP prompt, it can be changed or removed once the kernel is loaded

[edit] Resources

Personal tools
Namespaces
Variants
Actions
Navigation
Toolbox