i.MX8 - Getting Started - Loading Pre-built Images - Android SD Partitions RidgeRun Script

From RidgeRun Developer Wiki


  Index  






General Description

The following script is a modified version of the Android script for the creation of the partition on SD Cards. The original version can be found inside the packages provided by Android for i.MX8 platforms.

Objective

This script provides support for devices recognized as /dev/sdX or /dev/mmcblkX among others by the host machine.

Example Usage

You can run the script in order to write Android images on SD Cards. One usage example for writing pre-built Android images for i.MX8 platforms is present in this guide.

Script Content

You can name the script as fsl-sdcard-partition-rr.sh and put the following content inside it:

#!/bin/bash

# android-tools-fsutils should be installed as
# "sudo apt-get install android-tools-fsutils"

help() {

bn=`basename $0`
cat << EOF
usage $bn <option> device_node

options:
  -h				displays this help message
  -s				only get partition size
  -np 				not partition.
  -f soc_name			flash android image file with soc_name
  -F soc_name			determine the device_node's offset to flash bootloader and flash default android image file
					 soc     				offset(KB)
					default					   1
					imx8dv					  16
					imx8qm/imx8qxp/imx8mq			  33
  -a				only flash image to slot_a
  -b				only flash image to slot_b
  -c card_size			optional setting: 7 / 14 / 28
					If not set, use partition-table.img
					If set to 7, use partition-table-7GB.img for 7GB SD card
EOF

}

# parse command line
moreoptions=1
node="na"
soc_name=""
cal_only=0
card_size=0
bootloader_offset=1
vaild_gpt_size=17
not_partition=0
not_format_fs=0
slot=""
systemimage_file="system.img"
systemimage_raw_file="system_raw.img"
vendor_file="vendor.img"
vendor_raw_file="vendor_raw.img"
partition_file="partition-table.img"
g_sizes=0
append_soc_name=0
while [ "$moreoptions" = 1 -a $# -gt 0 ]; do
	case $1 in
	    -h) help; exit ;;
	    -s) cal_only=1 ;;
	    -f) append_soc_name=1 ; soc_name=$2; shift;;
	    -F) soc_name=$2; shift;;
	    -c) card_size=$2; shift;;
	    -np) not_partition=1 ;;
	    -nf) not_format_fs=1 ;;
	    -a) slot="_a" ;;
	    -b) slot="_b" ;;
	    *)  moreoptions=0; node=$1 ;;
	esac
	[ "$moreoptions" = 0 ] && [ $# -gt 1 ] && help && exit
	[ "$moreoptions" = 1 ] && shift
done

if [ ${card_size} -ne 0 ] && [ ${card_size} -ne 7 ] && [ ${card_size} -ne 14 ] && [ ${card_size} -ne 28 ]; then
    help; exit;
fi

if [ "${soc_name}" = "imx8dv" ]; then
    bootloader_offset=16
fi


if [ "${soc_name}" = "imx8qm" -o "${soc_name}" = "imx8qxp" -o "${soc_name}" = "imx8mq" ]; then
    bootloader_offset=33
fi

echo "${soc_name} bootloader offset is: ${bootloader_offset}"

if [ "${soc_name}" != "" ] && [ "${append_soc_name}" -eq 1 ]; then
    soc_name="-${soc_name}"
else
    soc_name=""
fi

if [ ! -e ${node} ]; then
	help
	exit
fi


# dump partitions
if [ "${cal_only}" -eq "1" ]; then
gdisk -l ${node} 2>/dev/null | grep -A 20 "Number  "
exit
fi

function get_partition_size
{
    start_sector=`gdisk -l ${node} | grep -w $1 | awk '{print $2}'`
    end_sector=`gdisk -l ${node} | grep -w $1 | awk '{print $3}'`
    # 1 sector = 512 bytes. This will change unit from sector to MBytes.
    let "g_sizes=($end_sector - $start_sector + 1) / 2048"
}

function format_partition
{
    num=`gdisk -l ${node} | grep -w $1 | awk '{print $1}'`
    num_part=`fdisk -l ${node} | grep '^/dev' | cut -d' ' -f1 | grep -oP "^${node}\K.*" | awk "NR==$num"`
    if [ ${num} -gt 0 ] 2>/dev/null; then
        echo "format_partition: $1:${node}${num_part} ext4"
        mkfs.ext4 -F ${node}${num_part} -L$1
    fi
}

function erase_partition
{
    num=`gdisk -l ${node} | grep -w $1 | awk '{print $1}'`
    num_part=`fdisk -l ${node} | grep '^/dev' | cut -d' ' -f1 | grep -oP "^${node}\K.*" | awk "NR==$num"`
    if [ ${num} -gt 0 ] 2>/dev/null; then
        get_partition_size $1
        echo "erase_partition: $1 : ${node}${num_part} ${g_sizes}M"
        dd if=/dev/zero of=${node}${num_part} bs=1048576 conv=fsync count=$g_sizes
    fi
}

function flash_partition
{
    for num in `gdisk -l ${node} | grep -E -w "$1|$1_a|$1_b" | awk '{print $1}'`
    do
        num_part=`fdisk -l ${node} | grep '^/dev' | cut -d' ' -f1 | grep -oP "^${node}\K.*" | awk "NR==$num"` 
        if [ $? -eq 0 ]; then
            if [ $(echo ${1} | grep "system") != "" ] 2>/dev/null; then
                img_name=${systemimage_raw_file}
            elif [ $(echo ${1} | grep "vendor") != "" ] 2>/dev/null; then
                img_name=${vendor_raw_file}
            else
                img_name="${1%_*}${soc_name}.img"
            fi
            echo "flash_partition: ${img_name} ---> ${node}${num_part}"
            dd if=${img_name} of=${node}${num_part} bs=10M conv=fsync
        fi
    done
}

function format_android
{
    echo "formating android images"
    format_partition userdata
    format_partition cache
    erase_partition presistdata
    erase_partition fbmisc
    erase_partition misc
}

function make_partition
{
    if [ ${card_size} -gt 0 ]; then
        partition_file="partition-table-${card_size}GB.img"
    fi
    echo "make gpt partition for android: ${partition_file}"
    dd if=${partition_file} of=${node} bs=1k count=${vaild_gpt_size} conv=fsync
}

function flash_android
{
    boot_partition="boot"${slot}
    recovery_partition="recovery"${slot}
    system_partition="system"${slot}
    vendor_partition="vendor"${slot}
    vbmeta_partition="vbmeta"${slot}

    bootloader_file="u-boot${soc_name}.imx"
    flash_partition ${boot_partition}
    flash_partition ${recovery_partition}
    simg2img ${systemimage_file} ${systemimage_raw_file}
    flash_partition ${system_partition}
    rm ${systemimage_raw_file}
    simg2img ${vendor_file} ${vendor_raw_file}
    flash_partition ${vendor_partition}
    rm ${vendor_raw_file}
    flash_partition ${vbmeta_partition}
    echo "erase_partition: uboot : ${node}"
    echo "flash_partition: ${bootloader_file} ---> ${node}"
    first_partition_offset=`gdisk -l ${node} | grep ' 1 ' | awk '{print $2}'`
    # the unit of first_partition_offset is sector size which is 512 Byte.
    count_bootloader=`expr ${first_partition_offset} / 2 - ${bootloader_offset}`
    echo "the bootloader partition size: ${count_bootloader}"
    dd if=/dev/zero of=${node} bs=1k seek=${bootloader_offset} conv=fsync count=${count_bootloader}
    dd if=${bootloader_file} of=${node} bs=1k seek=${bootloader_offset} conv=fsync
}

if [ "${not_partition}" -eq "1" ] ; then
    flash_android
    exit
fi

make_partition
sleep 3
for i in `cat /proc/mounts | grep "${node}" | awk '{print $2}'`; do umount $i; done
hdparm -z ${node}

# backup the GPT table to last LBA for sd card.
echo -e 'r\ne\nY\nw\nY\nY' |  gdisk ${node}

format_android
flash_android

# For MFGTool Notes:
# MFGTool use mksdcard-android.tar store this script
# if you want change it.
# do following:
#   tar xf mksdcard-android.sh.tar
#   vi mksdcard-android.sh 
#   [ edit want you want to change ]
#   rm mksdcard-android.sh.tar; tar cf mksdcard-android.sh.tar mksdcard-android.sh


Previous: iMX8MEVK/Getting_Started/Loading_Pre-built_Images Index Next: iMX8MEVK/Getting_Started/Loading_Pre-built_Images