mcu/tools/ckScatter.pl

#!/usr/bin/perl
#
#  Copyright Statement:
#  --------------------
#  This software is protected by Copyright and the information contained
#  herein is confidential. The software may not be copied and the information
#  contained herein may not be used or disclosed except with the written
#  permission of MediaTek Inc. (C) 2006
#
#  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
#  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
#  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
#  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
#  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
#  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
#  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
#  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
#  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
#  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
#
#  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
#  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
#  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
#  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
#  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
#
#  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
#  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
#  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
#  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
#  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
#
#*****************************************************************************
#*
#* Filename:
#* ---------
#*   ckScatter.pl
#*
#* Project:
#* --------
#*
#*
#* Description:
#* ------------
#*   This script parse scatter file and embedded checking rules for it
#*       1. Load View      --- NOR Flash
#*       2. Execution View --- RAM Device
#*       3. DSP execution region 
#*
#* Author:
#* -------
#*   JI Huang  (mtk01077)
#*
#****************************************************************************/

#****************************************************************************
# Included Modules
#****************************************************************************
use strict;
BEGIN { push @INC, "pcore/" , './pcore/tools/' }  # add additional library path
use sysGenUtility;                 #pm file name without case sensitivity
use FileInfoParser;
#****************************************************************************
# Constants
#****************************************************************************
my $CKSCATTER_VERNO     =  "m0.02";
                         #  m0.02 , Support path and filename case sensitive on Linux
                         #  m0.01 , skip nfb=SINGLE because it equals to smart phone
                         #  v0.48 , skip ckscatter2 check when ALICE_SUPPORT is turned on
                         #  v0.47 , No need to check the DSP size sould be 2^N and the alignment restriction of DSP base and DSP length
                         #  v0.45 , skip smartphone by using sysgenUtility.pm
                         #  v0.44 , skip smartphone if secure turns on
                         #  v0.43 , Fix parsing makefile 
                         #  v0.42 , Remove $$ to support Perl v5.12.*
                         #  v0.41 , Support 6255
                         #  v0.40 , skip smartphone DSP checking in ckscatter phase 1
                         #  v0.39 , Change custom_flash.c to custom_flash.h and skip smartphone in ckscatter phase 2
                         #  v0.38 , Refine EMI_EXTSRAM_SIZE pattern-matching to adapt to flexible () and spaces
                         #  v0.37 , Skip ckscatter2 check when dcm_compression is turned on because ckscatter cannot see compressed image and will misjudge 
                         #  v0.36 , Get EXTSRAM_SIZE from custom_EMI_release.h
                         #  v0.35 , Support eMMC Booting
                         #  v0.34 , Skip SECURE_RO_ME and SECURE_RO_S from load region boundary check because they will be downloaded to CBR region
                         #  v0.33 , Skip DSP alignment check for MT6276 shrinking
                         #  v0.32 , Skip ckscatter2 check when DUMMY_SCATTER_ENABLE is turned on because invalid memory range will be used in Scatter Gen
                         #  v0.31 , To support eMMC Booting
                         #  v0.30 , Skip ckscatter2 check when ZIMAGE_SUPPORT is turned on because ckscatter cannot see compressed image and will misjudge
                         #  v0.29 , Remove MT6253D
                         #  v0.28 , Rename MT6253E/MT6253L as MT6252H/MT6252
                         #  v0.27 , Check whether RAM consumption has exceeded DUMMY_END
                         #  v0.26 , Move EMI_EXTSRAM_SIZE to custom_EMI_release.h
                         #  v0.25 , Resume RAM boundary checking for MT6253E/L
                         #  v0.24 , To support MT6253E/L, move EXTSRAM_SIZE to custom_EMI_release.h
                         #  v0.23 , To support MT6253DV
                         #  v0.22 , To support MT6253E/L, remove RAM boundary check because EXTSRAM_SIZE was moved from custom_EMI.h to custom_EMI_release.h
                         #  v0.21 , To support MT6251
                         #  v0.20 , Fix sort hex issue
                         #  v0.19 , Adapt to NOR_FLASH_DENSITY unit change (Mbit to byte)
                         #  v0.18 , Adopt different FAT configuration in custom_MemoryDevice.h
                         #  v0.17 , Fix block alignment check errors
                         #  v0.16 , Add MT6268 and remove BT/MT check
                         #  v0.15 , Add file name and fline number information and unify all auto-gen error messages
                         #  v0.14 , NAND_FLASH_BOOTING makefile option is changed
                         #  v0.13 , Modify RAM boundary calculation and bypass 6516 boundary check
                         #  v0.12 , Modify ~flash_cfg_tmp.c parsing rules for flash_opt.h template change for FOTA
                         #  v0.11 , Parse ~flash_cfg_tmp.c only in Phase2 and fix load region calculation issue
                         #  v0.10 , Split ckscatter into two phases and arrange checks into each phase
                         #  v0.09 , add 2nd phase ckscatter at post-build stage
                         #  v0.08 , temporarily remove FAT and load region check due to lack of FAT information and add CODE_PATCH_CODE/DSP_TX/DSP_RX start address alignment check
                         #  v0.07 , add FAT and load region overlap check
                         #  v0.06 , add SECONDARY_EXTSRAM_DSP_TX 
                         #  v0.05 , update scatter parser
                         #  v0.04 , initial version 

#****************************************************************************
# Input Parameters and Global Variables
#****************************************************************************
my $phase            = $ARGV[0];
my $stop_build       = $ARGV[1];
my $SCATTERFILE      = $ARGV[2];
my $LIS_TEMP         = $ARGV[3];
my $FLASH_CFG_TMP    = $ARGV[4];
my $themf            = $ARGV[5];
my $BB_FOLDER        = $ARGV[6];
my $CUSTOM_EMI_H     = $ARGV[6] . '/' . "custom_EMI.h";
my $CUSTOM_EMI_RELEASE_H = $ARGV[6] . '/' . "custom_EMI_release.h";
my $CUSTOM_FLASH_H   = $ARGV[6] . '/' . "custom_flash.h";
my $DUMMY_SCATTER_ALLOW = $ARGV[7];

my %Scat_Content;
my %MAKEFILE_OPTIONS;
my %EMI_H_Value;
my %FLASH_C_Value;
my @FLASH_H_Value_BLK_LIST;
my %FLASH_INFO;
my %NORFLASH_INFO_BLOCKS_TABLE;

# load/exec regions obtained from scatter file
my %LoadView;
my %ExecView;

# load/exec regions obtained from temp lis file
my %LoadRegion;
my %ExecRegion;


#****************************************************************************
# 0 >>>  parse input parameters and decide ckscatter phase
#****************************************************************************
print "phase=$phase, stop_build=$stop_build\n";

    # 0.1 >>> parse Project Make File
    my $keyname;

    if (!-e $themf)
    {
        &error_handler($stop_build, "$themf: NOT exist!", __FILE__, __FILE__, __LINE__) if (!-e $themf);
    }
    
    if ($themf =~ /make\/\w+(BT)_\w+.mak/i or $themf =~ /make\/\w+(MT)_\w+.mak/i) {
        $MAKEFILE_OPTIONS{'type'} = uc($1);
    }

    open (FILE_HANDLE, "<$themf") or &error_handler($stop_build, "$themf: file error!", __FILE__, __LINE__);
    while (<FILE_HANDLE>) {
        if ((/^([^\#]*)\#?.*/) && ($1 =~ /^(\w+)\s*=\s*(.*\S)\s*$/)) {
            $keyname = lc($1);
            #defined($MAKEFILE_OPTIONS{$keyname}) && warn "$1 redefined in $themf!\n";
            $MAKEFILE_OPTIONS{$keyname} = uc($2);
        }
    }
    close (FILE_HANDLE);

    # 0.2 >>> parse key definition in CUSTOM_FLASH_H
    open (FLASHC_HANDLE, "<$CUSTOM_FLASH_H") or &error_handler($stop_build, "$CUSTOM_FLASH_H: file error!", __FILE__, __LINE__);
    while (<FLASHC_HANDLE>)
    {
        if (/NOR_FLASH_DENSITY:\s*(\w*)/)
        {
            $FLASH_INFO{'NOR_FLASH_DENSITY'} = $1;
        }
        elsif (/^FLASH_REGIONINFO_VAR_MODIFIER\s+FlashBlockTBL\s+\S+/)
        {
            $FLASH_C_Value{'BlockTBLFlag'} ++;
        }
        elsif (defined $FLASH_C_Value{'BlockTBLFlag'})
        {
            $FLASH_C_Value{'BlockTBLTxt'} .= $_;
            # debug purpose
            # print $_;
            if (/\{\s*(\S+)\s*,\s*(\S+)\s*\}/)
            {
                push @FLASH_H_Value_BLK_LIST, $_;
            }
            delete $FLASH_C_Value{'BlockTBLFlag'} if (/^\s+EndBlockInfo\s+/);
        }
    }
    close (FLASHC_HANDLE);
    #&dump_custom_flash_h_values();
    
    # 0.3 >>> parse key definition in CUSTOM_EMI_RELEASE_H
    open (EMIRELEASEH_HANDLE, "<$CUSTOM_EMI_RELEASE_H") or &error_handler("$CUSTOM_EMI_RELEASE_H: file error!", __FILE__, __LINE__);
    while (<EMIRELEASEH_HANDLE>) {
        if (/^#define EMI_EXTSRAM_SIZE\s+\(\s*\(*\s*\(*\s*(\S+)\)*\s*<<\s*20\s*\)*\s*>>\s*3\s*\)/)
        {
            $EMI_H_Value{'EXTSRAM_SIZE'} = $1;
        }
    }
    close (EMIRELEASEH_HANDLE);
    #&dump_custom_emi_h_values();

    # 0.4 >>> do check in each phase
    if ($phase == 1)
    {
        &ckscatter_phase1();
    }
    elsif ($phase == 2)
    {
        &ckscatter_phase2();
    }
    else
    {
        &error_handler($stop_build, "make/pcore/build.mak: Unsupported ckscatter command!", __FILE__, __LINE__);
    }
    
    exit;

#****************************************************************************
# 1 >>>  Phase 1
#****************************************************************************
sub ckscatter_phase1
{
    print "Phase1!\n";

    # 1.1 >>>  open and read scatter file, keep the important content in memory
    open (SCAT_HANDLE, "<$SCATTERFILE") or &error_handler($stop_build, "$SCATTERFILE: file error!", __FILE__, __LINE__);
    while (<SCAT_HANDLE>) {
       if (/\(.+\)/) {next;}
       if (/;/) {s/;.*//;}
       if (/{/ or /}/ or /\S+/) { $Scat_Content{$.} = $_; }
    }
    close (SCAT_HANDLE);
    #&dump_scatter_file_structure();

    # 1.2 >>> Build the LOAD View List and Execution View List
    &parse_scatter_file_structure();
    #&dump_load_view();
    #&dump_exec_view();

    # 1.3 >>> Check the DSP_TX and DSP_RX execution region
    if (($MAKEFILE_OPTIONS{'platform'} ne 'MT6276') and ($MAKEFILE_OPTIONS{'platform'} ne 'MT6575') and ($MAKEFILE_OPTIONS{'platform'} ne 'MT6573'))  # MT6276 is skipped because these regions no longer obey the alignment rule for shrinking purpose
    {
        my $rule = 0;
    
        foreach my $e ( grep { /EXTSRAM_DSP_[TR]X/ } keys %ExecView )
        {
            printf "DSP Checking: $e \n";
    
            # 1 : No Overlay
            if ( defined $ExecView{$e}->{'attr'} and $ExecView{$e}->{'attr'} eq "OVERLAY")
            {
                printf "$e violate rule , No OVERLAY\n";
                $rule++;
            }
            
            # 2 : Size >= 4KB
            if ( exists $ExecView{$e}->{'length'} and hex( $ExecView{$e}->{'length'} ) < 4 * 1024 )
            {
                my $length = $ExecView{$e}->{'length'};
                printf "$e violate rule , the Length($length) too small\n";
                $rule++;
            }
            elsif ( not exists $ExecView{$e}->{'length'} )
            {
                printf "$e violate rule , please define Length\n";
                $rule++;
                next;
            }
            # Size must be 4K align
            my $sz = hex( $ExecView{$e}->{'length'} );
            if ($sz % (4 * 1024))
            {
                printf "$e violate rule , size must be 4K align \n";
                $rule++;
                next;
            }
    
            # 3 : address need to be assigned
            if ( defined $ExecView{$e}->{'begin'} and $ExecView{$e} =~ /\+/ )
            {
                printf "$e address needs to be assigned\n";
                $rule++;
            }
            elsif ( not defined $ExecView{$e}->{'begin'} )
            {
                printf "$e address not calculated, script error , please contact MTK\n";
                $rule++;
            }
        }
        if ($rule > 0)
        {
            &error_handler($stop_build, "$SCATTERFILE: Scatter File DSP check rule fail! Please contact with Scatter File owner!", __FILE__, __LINE__);
        }
    }

    # 1.4 >>> CODE_PATCH_CODE, DSP_TX, and DSP_RX start addresses need to be 4KB-aligned
    {
        if (exists $MAKEFILE_OPTIONS{'platform'} and (&config_query_arm9($MAKEFILE_OPTIONS{'platform'}) == 1))
        {
            foreach my $e ( keys %ExecView )
            {
                if (($e =~ /EXTSRAM_DSP_[TR]X/) || ($e eq 'CODE_PATCH_CODE'))
                {
                    #printf("$e start address = %08X\n", $ExecView{$e}->{'addr'});
                    if (!defined $ExecView{$e}->{'begin'})
                    {
                        &error_handler($stop_build, "$SCATTERFILE: $e lack of start address! Please contact with Scatter File owner!", __FILE__, __LINE__);
                    }
                    if (hex($ExecView{$e}->{'addr'}) % (4*1024) != 0)
                    {
                        &error_handler($stop_build, "$SCATTERFILE: $e start address needs to be 4KB-aligned! Please contact with Scatter File owner!", __FILE__, __LINE__);
                    }
                }
            }
        }
    }
    
    # 1.5 >>> BOOTLOADER, __HIDDEN_SECURE_RO, __HIDDEN_FLASHTOOL_CFG, __HIDDEN_CUST_PARA start addresses need to be block-aligned
    my $SINGLE = ((exists $MAKEFILE_OPTIONS{'nand_flash_booting'} and $MAKEFILE_OPTIONS{'nand_flash_booting'} eq 'SINGLE') or 
                  (exists $MAKEFILE_OPTIONS{'emmc_booting'} and $MAKEFILE_OPTIONS{'emmc_booting'} eq 'SINGLE'));
    if (1 != &FileInfo::is_SmartPhone(\%MAKEFILE_OPTIONS) and 1 != $SINGLE )
    {
        &get_block_table();
        my @offset = sort {$b <=> $a} keys %NORFLASH_INFO_BLOCKS_TABLE;

        foreach ( keys %LoadView )
        {
            if (/BOODLOADER|__HIDDEN_SECURE_RO|__HIDDEN_FLASHTOOL_CFG|__HIDDEN_CUST_PARA/)
            {
                foreach my $i (@offset)
                {
                    if (hex($LoadView{$_}->{'begin'}) >= $i)
                    {
                        if (hex($LoadView{$_}->{'begin'}) == $i)
                        {
                            last;
                        }
                        my $tmp = hex($LoadView{$_}->{'begin'}) - $i;
                        while ($tmp > 0)
                        {
                            $tmp -= $NORFLASH_INFO_BLOCKS_TABLE{$i};
                        }
                        if ($tmp != 0)
                        {
                            &error_handler($stop_build, "$SCATTERFILE: $_ start address needs to be block-aligned! Please contact with Scatter File owner!", __FILE__, __LINE__);
                        }
                        else
                        {
                            last;
                        }
                    }
                }
            }
        }
    }
}

#****************************************************************************
# 2 >>>  Phase 2
#****************************************************************************
sub ckscatter_phase2
{
    print "Phase2!\n";

    # 2.10 >>>  6516 series do not have FAT information and thus is bypassed in ckscatter_phase2
    if (exists $MAKEFILE_OPTIONS{'platform'} and ($MAKEFILE_OPTIONS{'platform'} =~ /6516/ or $MAKEFILE_OPTIONS{'platform'} =~ /6573/ or $MAKEFILE_OPTIONS{'platform'} =~ /6575/))
    {
        print "bypass check on Smart Phone!\n";
        return;        
    }

    # 2.11 >>>  BT/MT projects do not contain EXTSRAM and thus is bypassed in ckscatter_phase2
    if (exists $MAKEFILE_OPTIONS{'type'} and ($MAKEFILE_OPTIONS{'type'} =~ /BT/ or $MAKEFILE_OPTIONS{'type'} =~ /MT/))
    {
        print "bypass check on BT/MT!\n";
         return;        
    }

    # 2.12 >>>  When ZIMAGE_SUPPORT or DCM Compression is turned on, ckscatter will misjudge because it cannot recognize compressed case. Besides, another tool will be used to check ZIMAGE_SUPPORT/DCM Compression memory expiration
    if (exists $MAKEFILE_OPTIONS{'zimage_support'} and ($MAKEFILE_OPTIONS{'zimage_support'} eq 'TRUE'))
    {
        print "bypass check when ZIMAGE_SUPPORT = TRUE!\n";
        return;        
    }
    if (exists $MAKEFILE_OPTIONS{'dcm_compression_support'} and ($MAKEFILE_OPTIONS{'dcm_compression_support'} eq 'TRUE'))
    {
        print "bypass check when dcm_compression_support = TRUE!\n";
        return;        
    }
    if (exists $MAKEFILE_OPTIONS{'alice_support'} and ($MAKEFILE_OPTIONS{'alice_support'} eq 'TRUE'))
    {
        print "bypass check when alice_support = TRUE!\n";
        return;        
    }    

    # 2.13 >>>  When DUMMY_SCATTER_ENABLE is turned on (only available on NOR booting), ckscatter should bypass
    if ((exists $MAKEFILE_OPTIONS{'nand_flash_booting'} and $MAKEFILE_OPTIONS{'nand_flash_booting'} eq 'NONE') and (!exists $MAKEFILE_OPTIONS{'emmc_booting'} or $MAKEFILE_OPTIONS{'emmc_booting'} eq 'NONE'))
    {
        if (exists $MAKEFILE_OPTIONS{'dummy_scatter_enable'} and ($MAKEFILE_OPTIONS{'dummy_scatter_enable'} eq 'TRUE'))
        {
            if ($DUMMY_SCATTER_ALLOW == 1)
            {
                print "bypass check when DUMMY_SCATTER_ENABLE = TRUE!\n";
                return;
            }
        }
    }

    # 2.2 >>>  open and read temp lis file, keep the important content in memory
    open (LIS_HANDLE, "<$LIS_TEMP") or &error_handler($stop_build, "$LIS_TEMP: file error!", __FILE__, __LINE__);
    my $LoadRegion_seq = 0;
    my $ExecRegion_seq = 0;
    while (<LIS_HANDLE>) {
       if (/Load\s+Region\s+(\S+)\s+\(Base:\s+(\w+),\s+Size:\s+(\w+),\s+Max:\s+(\w+)/)
       {
#           print $_ ,  "\n";
           $LoadRegion{$1}->{'Base'} = $2;
           $LoadRegion{$1}->{'Size'} = $3;
           $LoadRegion{$1}->{'Max'} = $4;
           $LoadRegion{$1}->{'Seq'} = $LoadRegion_seq;
           $LoadRegion_seq++;
       }
       elsif (/Execution\s+Region\s+(\S+)\s+\(Base:\s+(\w+),\s+Size:\s+(\w+),\s+Max:\s+(\w+)/)
       {
#           print $_ ,  "\n";
           $ExecRegion{$1}->{'Base'} = $2;
           $ExecRegion{$1}->{'Size'} = $3;
           $ExecRegion{$1}->{'Max'} = $4;
           $ExecRegion{$1}->{'Seq'} = $ExecRegion_seq;
           $ExecRegion_seq++;
       }
    }
    close (LIS_HANDLE);
    &dump_temp_lis_structure();
    &error_handler($stop_build, "$LIS_TEMP: LIS file empty! Please resolve link errors first!", __FILE__, __LINE__) if (($LoadRegion_seq == 0) && ($ExecRegion_seq == 0));

    # 2.3 >>> parse key definition in ~flash_cfg_tmp.c
    open (FLASH_TMP_HANDLE, "<$FLASH_CFG_TMP") or &error_handler($stop_build, "$FLASH_CFG_TMP: file error!", __FILE__, __LINE__);
    while (<FLASH_TMP_HANDLE>) {
       if (/int\s+flash_base_address\s*=\s*(.+);/s)
              {
           my $flash_base_address = `perl -e "printf ($1)" 2>&1`;
                                       $FLASH_INFO{'FLASH_BASE_ADDRESS'} = sprintf("%X", $flash_base_address);
       }
       elsif (/int\s+allocated_fat_space\s*=\s*(.+);/s)
       {
           my $allocated_fat_space = `perl -e "printf ($1)" 2>&1`;
                                      $FLASH_INFO{'ALLOCATED_FAT_SPACE'} = sprintf("%X", $allocated_fat_space);
       }
    }
    close (FLASH_TMP_HANDLE);
    #&dump_flash_cfg_tmp_values();

    # 2.4 >>> check size limit validation
    my $flash_size  = &comp_flash_size();
    my $load_length = &comp_load_length();
    my ($ram_size, $ram_boundary, $ram_size_dummy_end, $ram_boundary_before_dummy_end);
    if ($MAKEFILE_OPTIONS{'platform'} ne 'MT6251')
    {
        $ram_size                      = &comp_ram_size();
        $ram_boundary                  = &comp_ram_boundary();
        $ram_size_dummy_end            = &comp_ram_size_dummy_end();
        $ram_boundary_before_dummy_end = &comp_ram_boundary_before_dummy_end($ram_size_dummy_end);
    }
    
    #printf "%x, %x, %x, %x\n", $flash_size, $ram_size, $load_length, $ram_boundary;
    
    if ((exists $MAKEFILE_OPTIONS{'nand_flash_booting'} and $MAKEFILE_OPTIONS{'nand_flash_booting'} ne 'NONE') or (exists $MAKEFILE_OPTIONS{'emmc_booting'} and $MAKEFILE_OPTIONS{'emmc_booting'} ne 'NONE'))
    {
        printf "LOAD VIEW , bypass check on NAND FLASH BOOTING\n";
        printf "EXEC VIEW , Physical Device Density 0x%x , Scatter File Configuration 0x%x , Scatter File DUMMY_END 0x%x , Scatter File Usage 0x%x\n",
                         $ram_size , $ram_boundary, $ram_size_dummy_end, $ram_boundary_before_dummy_end;
        if ($ram_size < $ram_boundary)
        {
            &error_handler($stop_build, "$SCATTERFILE: RAM consumption has exceeded its upper bound! Please turn off some features or change to a larger MCP!", __FILE__, __LINE__);
        }
        if ($ram_size_dummy_end < $ram_boundary_before_dummy_end)
        {
            &error_handler($stop_build, "$SCATTERFILE: RAM consumption has exceeded its upper bound! Please turn off some features or change to a larger MCP!", __FILE__, __LINE__);
        }
        if ($ram_size > $ram_boundary and ($ram_size - $ram_boundary) >= 1024 * 1024)
        {
            print "Warnning : RAM / Exec View configure waste at least 1MB\n";
        }
    }
    else
    {
        printf "LOAD VIEW , Physical Device Density 0x%x , Scatter File Configuration 0x%x\t%s\n",
                         $flash_size, $load_length, ($flash_size >= $load_length)? "PASS" : "ERROR";
        if ($flash_size < $load_length)
        {
            &error_handler($stop_build, "$SCATTERFILE: ROM consumption has exceeded its upper bound! Please turn off some features or change to a larger MCP!", __FILE__, __LINE__);
        }
        if (($MAKEFILE_OPTIONS{'platform'} ne 'MT6251'))
        {
            printf "EXEC VIEW , Physical Device Density 0x%x , Scatter File Configuration 0x%x , Scatter File DUMMY_END 0x%x , Scatter File Usage 0x%x\n",
                   $ram_size , $ram_boundary, $ram_size_dummy_end, $ram_boundary_before_dummy_end;
            if ($ram_size < $ram_boundary)
            {
                &error_handler($stop_build, "$SCATTERFILE: RAM consumption has exceeded its upper bound! Please turn off some features or change to a larger MCP!", __FILE__, __LINE__);
            }
            if ($ram_size_dummy_end < $ram_boundary_before_dummy_end)
            {
                &error_handler($stop_build, "$SCATTERFILE: RAM consumption has exceeded its upper bound! Please turn off some features or change to a larger MCP!", __FILE__, __LINE__);
            }
        }
        if ($flash_size > $load_length and ($flash_size - $load_length) >= 1024 * 1024)
        {
            print "Warnning : NOR flash / Load View configure waste at least 1MB\n";
        }
        if ($MAKEFILE_OPTIONS{'platform'} ne 'MT6251')
        {
            if ($ram_size > $ram_boundary and ($ram_size - $ram_boundary) >= 1024 * 1024)
            {
                print "Warnning : RAM / Exec View configure waste at least 1MB\n";
            }
        }
    }
}

#****************************************************************************
# subroutine:  SCHEME Configure Routines :: Query :: ARM9 Family
# input:       BB chip
# Output:      whether this chip belongs to ARM9 Family
#****************************************************************************
sub config_query_arm9
{
    my ($bb) = @_;
    my %BBtbl_ARM9_Family =
    (        
            'MT6235'  => 1,
            'MT6235B' => 1,
            'MT6238'  => 1,
            'MT6239'  => 1,
            'MT6268'  => 1,
    );
    return $BBtbl_ARM9_Family{$bb};
}

#****************************************************************************
# subroutine:  comp_flash_size
# return:      EMI value
#****************************************************************************
sub comp_flash_size
{
    my $flash_limit;
    if ((exists $MAKEFILE_OPTIONS{'nand_flash_booting'} and $MAKEFILE_OPTIONS{'nand_flash_booting'} ne 'NONE') or (exists $MAKEFILE_OPTIONS{'emmc_booting'} and $MAKEFILE_OPTIONS{'emmc_booting'} ne 'NONE'))
    {
        $flash_limit = 0;
    }
    elsif (exists $MAKEFILE_OPTIONS{'system_drive_on_nand'} and $MAKEFILE_OPTIONS{'system_drive_on_nand'} eq "TRUE")
    {
        $flash_limit = hex($FLASH_INFO{'NOR_FLASH_DENSITY'});
    }
    else
    {
        $flash_limit = hex($FLASH_INFO{'FLASH_BASE_ADDRESS'});
    }
    return $flash_limit;
}

#****************************************************************************
# subroutine:  comp_ram_size
# return:      EMI value
#****************************************************************************
sub comp_ram_size
{
    $EMI_H_Value{'EXTSRAM_SIZE'} =~ s/\(//;
    $EMI_H_Value{'EXTSRAM_SIZE'} =~ s/\)//;

    return $EMI_H_Value{'EXTSRAM_SIZE'} * 1024 * 1024 / 8;
}

#****************************************************************************
# subroutine:  comp_ram_size_dummy_end
# return:      RAM size before DUMMY_END or DSP_TXRX
#****************************************************************************
sub comp_ram_size_dummy_end
{
    my $extsram_ram_size_before_dummy_end;
    if    (exists $ExecRegion{'CODE_PATCH_CODE'})
    {
        $extsram_ram_size_before_dummy_end = hex($ExecRegion{'CODE_PATCH_CODE'}->{'Base'});
    }
    elsif (exists $ExecRegion{'CACHED_CODE_PATCH_CODE'})
    {
        $extsram_ram_size_before_dummy_end = hex($ExecRegion{'CACHED_CODE_PATCH_CODE'}->{'Base'});
    }
    elsif (exists $ExecRegion{'DUMMY_END'})
    {
        $extsram_ram_size_before_dummy_end = hex($ExecRegion{'DUMMY_END'}->{'Base'});
    }
    elsif (exists $ExecRegion{'CACHED_DUMMY_END'})
    {
        $extsram_ram_size_before_dummy_end = hex($ExecRegion{'CACHED_DUMMY_END'}->{'Base'});
    }
    elsif (exists $ExecRegion{'EXTSRAM_DSP_TX'})
    {
        $extsram_ram_size_before_dummy_end = hex($ExecRegion{'EXTSRAM_DSP_TX'}->{'Base'});
    }
    elsif (exists $ExecRegion{'SECONDARY_EXTSRAM_DSP_TX'})
    {
        $extsram_ram_size_before_dummy_end = hex($ExecRegion{'SECONDARY_EXTSRAM_DSP_TX'}->{'Base'});
    }
    else
    {
        die "Unknown Scatter File Structure";
    }
    
    printf "RAM DUMMY END , %x\n" , $extsram_ram_size_before_dummy_end;
    
    return $extsram_ram_size_before_dummy_end;
}

#****************************************************************************
# subroutine:  comp_load_length
# return:      LoadView
#****************************************************************************
sub comp_load_length
{
    my @region_list = sort { hex($LoadRegion{$b}->{'Base'}) <=> hex($LoadRegion{$a}->{'Base'}) } keys %LoadRegion;
    my $last_load_region;
    for (0..$#region_list)
    {
        if (($region_list[$_] ne 'SECURE_RO_ME') and ($region_list[$_] ne 'SECURE_RO_S'))
        {
            $last_load_region = $region_list[$_];
            last;
        }
    }
    return ((hex($LoadRegion{$last_load_region}->{'Base'})+hex($LoadRegion{$last_load_region}->{'Size'})) & (~0xF8000000));
}

#****************************************************************************
# subroutine:  get_regions_reside_EXTSRAM
#****************************************************************************
sub get_regions_reside_EXTSRAM
{
    my @regions = (sort { hex($ExecRegion{$a}->{'Base'}) <=> hex($ExecRegion{$b}->{'Base'}) } keys %ExecRegion);
    my $EXTSRAM_Addr;

    for (my $i=0; $i <= $#regions; $i++)
    {
        if ($regions[$i] =~ /EXTSRAM/) # find the start of EXTSRAM
        {
            $EXTSRAM_Addr = $ExecRegion{$regions[$i]}->{'Base'};
        }
    }
    @regions = grep { (hex($ExecRegion{$_}->{'Base'}) & 0xF8000000) == (hex($EXTSRAM_Addr) & 0xF8000000) } keys %ExecRegion;

    return @regions;
}

#****************************************************************************
# subroutine:  comp_ram_boundary
# return:      LoadView
#****************************************************************************
sub comp_ram_boundary
{
    my @regions1  = sort { hex($ExecRegion{$a}->{'Base'}) <=> hex($ExecRegion{$b}->{'Base'}) } &get_regions_reside_EXTSRAM();

    my $extsram_baseaddr = hex($ExecRegion{ $regions1[0] }->{ 'Base' });
    #
    my $extsram_limitaddr;
    if    (exists $ExecRegion{'DUMMY_END'})
    {
        $extsram_limitaddr = hex($ExecRegion{'DUMMY_END'}->{'Base'});
    }
    elsif (exists $ExecRegion{'EXTSRAM_DSP_RX'})
    {
        $extsram_limitaddr = hex($ExecRegion{'EXTSRAM_DSP_RX'}->{'Base'}) + hex($ExecRegion{'EXTSRAM_DSP_RX'}->{'Size'});
    }
    elsif (exists $ExecRegion{'SECONDARY_EXTSRAM_DSP_RX'})
    {
        $extsram_limitaddr = hex($ExecRegion{'SECONDARY_EXTSRAM_DSP_RX'}->{'Base'}) + hex($ExecRegion{'SECONDARY_EXTSRAM_DSP_RX'}->{'Size'});
    }
    elsif (exists $ExecRegion{'CODE_PATCH_CODE'})
    {
        $extsram_limitaddr = hex($ExecRegion{'CODE_PATCH_CODE'}->{'Base'}) + hex($ExecRegion{'CODE_PATCH_CODE'}->{'Size'});
    }
    elsif (exists $ExecRegion{'CACHED_DUMMY_END'})
    {
        $extsram_limitaddr = hex($ExecRegion{'CACHED_DUMMY_END'}->{'Base'}) & (~0xf0000000);
    }
    elsif (exists $ExecRegion{'EXTSRAM'} and exists $ExecRegion{'EXTSRAM'}->{'Size'})
    {
        $extsram_limitaddr = hex($ExecRegion{'EXTSRAM'}->{'Base'}) + hex($ExecRegion{'EXTSRAM'}->{'Size'});
    }
    elsif (exists $ExecRegion{'SECONDARY_EXTSRAM'} and exists $ExecRegion{'SECONDARY_EXTSRAM'}->{'Size'})
    {
        $extsram_limitaddr = hex($ExecRegion{'SECONDARY_EXTSRAM'}->{'Base'}) + hex($ExecRegion{'SECONDARY_EXTSRAM'}->{'Size'});
    }
    else
    {
        die "Unknown Scatter File Structure";
    }
    
    #printf "RAM %x , %x\n" , $extsram_baseaddr , $extsram_limitaddr;
    
    return ($extsram_limitaddr & (~0xf8000000));
}

#****************************************************************************
# subroutine:  comp_ram_boundary_before_dummy_end
# return:      RAM boundary before DUMMY_END
#****************************************************************************
sub comp_ram_boundary_before_dummy_end
{
	   my ($ram_dummy_end) = @_;
    my @regions1  = sort { hex($ExecRegion{$b}->{'Seq'}) <=> hex($ExecRegion{$a}->{'Seq'}) } &get_regions_reside_EXTSRAM();

    #
    my $extsram_limitaddr;
    my $dummy_end_reached = 0;
    foreach my $region (@regions1)
    {
    	   if ($dummy_end_reached == 1)
    	   {
    	   	   $extsram_limitaddr = hex($ExecRegion{$region}->{'Base'}) + hex($ExecRegion{$region}->{'Size'});
    	   	   last;
    	   }
    	   if (hex($ExecRegion{$region}->{'Base'}) == $ram_dummy_end)
    	   {
    	   	   $dummy_end_reached = 1;
    	   }
    }

    printf "RAM Limit before DUMMY_END , %x\n" , $extsram_limitaddr;
 
    return $extsram_limitaddr;
}

#****************************************************************************
# subroutine:  get_block_table
# return:      block table hash
#****************************************************************************
sub get_block_table
{
    if ($#FLASH_H_Value_BLK_LIST >= 0)
    {
        my %blk_href;

        foreach(@FLASH_H_Value_BLK_LIST)
        {
            if (/\{(0x\w+),\s*(0x\w+)\}/)
            {
                $NORFLASH_INFO_BLOCKS_TABLE{hex($1)} = hex($2);
            }
        }
    }
}

#****************************************************************************
# subroutine:  dump_exec_view
# return:      all %LoadView ; key = RegionName , value = hash ref , begin , attr , length
#****************************************************************************
sub dump_exec_view
{
    print "=== EXEC VIEW ===\n";
    foreach my $region_name (sort { $ExecView{$a}->{'seq'} <=> $ExecView{$b}->{'seq'} } keys %ExecView)
    {
        print $region_name, "\t", $ExecView{$region_name}->{'begin'}, "\n";
    }
}

#****************************************************************************
# subroutine:  dump_load_view
# return:      all %LoadView ; key = RegionName , value = hash ref , begin , attr , length
#****************************************************************************
sub dump_load_view
{
    print "=== LOAD VIEW ===\n";
    foreach my $region_name (sort { $LoadView{$a}->{'seq'} <=> $LoadView{$b}->{'seq'} } keys %LoadView)
    {
        print $region_name, "\t", $LoadView{$region_name}->{'begin'}, "\n";
    }
}

#****************************************************************************
# subroutine:  parse_region_string
# input:       reference to %LoadView or %ExecView ; Region Name start address string
# return:      %LoadView ; key = RegionName , value = hash ref , begin , attr , length
#****************************************************************************
my $sequence = 0;
sub parse_region_string
{
    my ($hash_ref, $string) = @_;
    my %tmp;

    if    ($string =~ m/(\S+)\s+(\S+)\s+OVERLAY\s+(\S+)/)
    {
        #print 'PATTERN1', "\t", $1, "\t", $2, "\t", 'OVERLAY', "\t", $3 , "\n";
        $tmp{'seq'}     = ++$sequence;
        $tmp{'attr'}    = "OVERLAY";
        $tmp{'begin'}   = $2;
        $tmp{'length'}  = $3;
        $hash_ref->{$1} = \%tmp;
    }
    elsif    ($string =~ m/(\S+)\s+(\S+)\s+ABSOLUTE\s+(\S+)/)
    {
        #print 'PATTERN1', "\t", $1, "\t", $2, "\t", 'ABSOLUTE', "\t", $3 , "\n";
        $tmp{'seq'}     = ++$sequence;
        $tmp{'attr'}    = "ABSOLUTE";
        $tmp{'begin'}   = $2;
        $tmp{'length'}  = $3;
        $hash_ref->{$1} = \%tmp;
    }
    elsif ($string =~ m/(\S+)\s+(\S+)\s+FIXED\s+(\S+)/)
    {
        #print 'PATTERN1', "\t", $1, "\t", $2, "\t", 'FIXED', "\t", $3, "\n";
        $tmp{'seq'}     = ++$sequence;
        $tmp{'attr'}    = "FIXED";
        $tmp{'begin'}   = $2;
        $tmp{'length'}  = $3;
        $hash_ref->{$1} = \%tmp;
    }
    elsif ($string =~ m/(\S+)\s+(\S+)\s+(\S+)/)
    {
        #print 'PATTERN3', "\t", $1, "\t", $2, "\t", $3, "\n";
        $tmp{'seq'}     = ++$sequence;
        $tmp{'begin'}   = $2;
        $tmp{'length'}  = $3;
        $hash_ref->{$1} = \%tmp;
    }
    elsif ($string =~ m/(\S+)\s+(\S+)/)
    {
        #print 'PATTERN4', "\t", $1, "\t", $2, "\n";
        $tmp{'seq'}     = ++$sequence;
        $tmp{'begin'}   = $2;
        $hash_ref->{$1} = \%tmp;
    }
    else
    {
        warn "UNKNOWN PATTERN : $string";
    }
}

#****************************************************************************
# subroutine:  parse_scatter_file_structure
# return:      %LoadView , %ExecView
#****************************************************************************
sub parse_scatter_file_structure
{
    my $last_line_no;
    my $text_line;
    my $view=0;  #counter , 1 = load view , 2 = exec view
    foreach my $file_line_no (sort {$a <=> $b} keys %Scat_Content)
    {
        $text_line = $Scat_Content{$file_line_no};
        if    ($text_line =~ m/{/)
        {
            if ($view > 1)
            {
                &error_handler($stop_build, "$SCATTERFILE: Unrecognizable view at $file_line_no! Please contact with Scatter File owner!", __FILE__, __LINE__);
            }
            $view++;
            if (not defined $last_line_no)
            {
                &error_handler($stop_build, "$SCATTERFILE: No region name detected before $file_line_no!Please contact with Scatter File owner!", __FILE__, __LINE__);
            }
            &parse_region_string( ($view == 1) ? \%LoadView : \%ExecView , $Scat_Content{$last_line_no} );
        }
        elsif ($text_line =~ m/}/)
        { 
            $view--;
            if ($view < 0)
            {
                &error_handler($stop_build, "$SCATTERFILE: Unrecognizable view at $file_line_no!Please contact with Scatter File owner!", __FILE__, __LINE__);
            }
        }
        $last_line_no = $file_line_no;
    }
}

#****************************************************************************
# subroutine:  error_handler
# return:      none
#****************************************************************************
sub error_handler
{
    my ($todie, $error_msg, $file, $line_no) = @_;
 
#    print $todie, "\n";

    my $final_error_msg = "CKSCATTER ERROR: $error_msg at $file line $line_no\n";
    print $final_error_msg;
    die $final_error_msg if ($todie eq 'TRUE');
}

#****************************************************************************
# subroutine:  dump_scatter_file_structure
# return:      none
#****************************************************************************
sub dump_scatter_file_structure
{
    foreach my $file_line_no (sort {$a <=> $b} keys %Scat_Content)
    {
        print $file_line_no, "\t", $Scat_Content{$file_line_no};
    }
}

#****************************************************************************
# subroutine:  dump_temp_lis_structure
# return:      none
#****************************************************************************
sub dump_temp_lis_structure
{
    print "Dumping temp lis structure: \n";
    foreach my $lv (sort {hex($LoadRegion{$a}->{'Base'}) <=> hex($LoadRegion{$a}->{'Base'})} keys %LoadRegion)
    {
        print $lv, "\t", $LoadRegion{$lv}->{'Base'}, "\t", $LoadRegion{$lv}->{'Size'}, "\t", $LoadRegion{$lv}->{'Max'}, "\t", $LoadRegion{$lv}->{'Seq'}, "\n";
    }
    foreach my $ev (sort {hex($ExecRegion{$a}->{'Base'}) <=> hex($ExecRegion{$a}->{'Base'})} keys %ExecRegion)
    {
        print $ev, "\t", $ExecRegion{$ev}->{'Base'}, "\t", $ExecRegion{$ev}->{'Size'}, "\t", $ExecRegion{$ev}->{'Max'}, "\t", $ExecRegion{$ev}->{'Seq'}, "\n";
    }
}

#****************************************************************************
# subroutine:  dump_custom_emi_h_values
# return:      none
#****************************************************************************
sub dump_custom_emi_h_values
{
    foreach my $key (sort keys %EMI_H_Value)
    {
        print $key, "\t", $EMI_H_Value{$key} , "\n";
    }
}

#****************************************************************************
# subroutine:  dump_custom_flash_h_values
# return:      none
#****************************************************************************
sub dump_custom_flash_h_values
{
    foreach (@FLASH_H_Value_BLK_LIST)
    {
        print "$_\n";
    }
}

#****************************************************************************
# subroutine:  dump_flash_cfg_tmp_values
# return:      none
#****************************************************************************
sub dump_flash_cfg_tmp_values
{
    foreach my $key (sort keys %FLASH_INFO)
    {
        print $key, "\t", $FLASH_INFO{$key} , "\n";
    }
}