L27.INC1.5.3 Froyo ES2 Release Notes

= 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

=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)

=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.3_Froyo $ export MANIFEST=`pwd` $ cd 	$ export YOUR_PATH=`pwd` $ mkdir -p 27.5.3/mydroid; cd 27.5.3/mydroid $ export MYDROID=`pwd` $ repo init –u $MANIFEST $ repo sync

You need to have git 1.6.6 or higher to use these generic commands. In addition to Android source referenced by this manifest, you need to apply three patches on top of Syslink tree. Once you finish downloading Android source do:

$ cd $MYDROID/hardware/ti/syslink $ git fetch http://review.omapzoom.org/p/platform/hardware/ti/syslink refs/changes/39/6039/2 && git cherry-pick FETCH_HEAD $ git fetch http://review.omapzoom.org/p/platform/hardware/ti/syslink refs/changes/40/6040/2 && git cherry-pick FETCH_HEAD $ git fetch http://review.omapzoom.org/p/platform/hardware/ti/syslink refs/changes/64/6064/1 && git cherry-pick FETCH_HEAD

Kernel & Driver Sources

To clone kernel source from scratch do: $ cd ; export YOUR_PATH=`pwd` $ mkdir kernel $ git clone git://git.omapzoom.org/kernel/omap.git kernel/android-2.6.32 $ cd kernel/android-2.6.32 $ git checkout 34a864e74b29dbf82cc2bc6f0a9a90df50a67c83 If you already have kernel source cloned then just update it: $ cd $YOUR_PATH/kernel/android-2.6.32 $ git fetch origin $ git checkout 34a864e74b29dbf82cc2bc6f0a9a90df50a67c83 In addition to this kernel revision, you need to apply a patch on top of it: $ cd $YOUR_PATH/kernel/android-2.6.32 $ git fetch http://review.omapzoom.org/p/kernel/omap refs/changes/81/6081/1 && git cherry-pick FETCH_HEAD

=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

=Build Instructions=

Setting up build environment
From your work directory (where your 27.5.3 folder resides): export YOUR_PATH=`pwd` export PATH=$PATH:/arm-2009q1/bin export MYDROID=${YOUR_PATH}/27.5.3/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

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 get access to this tool. cd $YOUR_PATH/27.5.3/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: 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 driver
export HOST_PLATFORM=sdc4430 export KERNEL_DIR=$YOUR_PATH/kernel/android-2.6.32 cd $MYDROID/hardware/ti/wlan/w1283/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” and:
 * Uncomment “USE_CAMERA_STUB := true”
 * Comment “BOARD_USES_TI_CAMERA_HAL := true”
 * Comment "HARDWARE_OMX := true”

sed -i "s/.*USE_CAMERA_STUB.*/USE_CAMERA_STUB := true/g" $MYDROID/device/ti/blaze/BoardConfig.mk sed -i 's/BOARD_USES_TI_CAMERA_HAL := true/#BOARD_USES_TI_CAMERA_HAL := true/g' $MYDROID/device/ti/blaze/BoardConfig.mk sed -i 's/HARDWARE_OMX := true/#HARDWARE_OMX := true/g' $MYDROID/device/ti/blaze/BoardConfig.mk

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

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

This step is optional and will make Android UI look bigger echo “ro.sf.lcd_density=240” >> system/build.prop

= 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): 

(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): 

(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/ $ mkfs.ext3 -L android_fs /dev/

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 

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/ /tmp/mmc1 $ mount /dev/ /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.3/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

= 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 devices 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)) Command (m for help): a Create partition table: Command (m for help): w The partition table has been altered!
 * You have to format 1st partitions with vfat32 filesystem.

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/ /tmp/mmc1 $ mount /dev/ /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.3/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.

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

=Bootargs=

L27.5.3 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

=Resources=