| #!/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: |
| #* --------- |
| #* config_MemSegment.pm |
| #* |
| #* Project: |
| #* -------- |
| #* |
| #* |
| #* Description: |
| #* ------------ |
| #* This module collects the subroutines for common utility. |
| #* |
| #* |
| #* Author: |
| #* ------- |
| #* Carina Liao (mtk04017) |
| #* |
| #****************************************************************************/ |
| package memConfig; |
| use strict; |
| #use warnings; |
| BEGIN { push @INC, './pcore/tools/' } # add additional library path |
| use sysGenUtility; #pm file name without case sensitivity |
| use FileInfoParser; |
| use CommonUtility; |
| use File::Basename; |
| #**************************************************************************** |
| # Version |
| #**************************************************************************** |
| my $CONFIGMEMSEGMENT_VERNO = " m0.06"; |
| # m0.06 , 2012/09/18, Change getting flash size rule and add error checking in GetPhysicalFlashEnd() |
| # m0.05 , 2012/08/17, Support Smartphone |
| # m0.04 , 2012/08/10, Support GetBlockSize() in Get_SDS_total_size() directly |
| # m0.03 , 2012/08/07, Add Memory Parsing Rule and Verification |
| # m0.02 , 2012/07/26, Replace is_NOR() by is_NonSPNOR() and add some error handling |
| # m0.01 , 2012/07/12, Move booting type query from sysGenUtility to FileInfoParser |
| # v0.02 , 2012/05/28, Support path and filename case sensitive on Linux |
| # v0.01 , 2012/05/14, Initial revision |
| #**************************************************************************** |
| # Constants |
| #**************************************************************************** |
| #Parse File Type |
| use constant MEMORY_DEVICE => "CUSTOM_MEMORY_DEVICE"; |
| use constant FEATURE_CONFIG => "CUSTOM_FEATURE_CONFIG"; |
| use constant CUSTOM_IMG_CONFIG => "CUSTOM_IMG_CONFIG"; |
| use constant CUSTOM_EMI => "CUSTOM_EMI_RELEASE"; |
| use constant CUSTOM_FLASH => "CUSTOM_FLASH"; |
| #**************************************************************************** |
| # Global variable |
| #**************************************************************************** |
| my %g_MemConfigValues; # $MemConfigValues{Type} = href; |
| #Keyword needs to be case sensitive: |
| # ----- RAM ----- |
| # nEMI_EXTSRAM_SIZE : exported by GetPhysicalExtRAM() |
| # strEMI_EXTSRAM_SIZE : exported by GetPhysicalExtRAM() |
| # nPROCESSED_RAMSIZE : exported by GetExtRamSize() |
| |
| # ----- Flash Info ----- |
| # RegionInfoTxt : exported by GetFlashInfoLog() |
| # BlkInfoTxt : exported by GetFlashInfoLog() |
| # BankInfoTxt : exported by GetFlashInfoLog() |
| # REGION_LIST |
| # BANK_LIST |
| # BLK_LIST |
| # BLK_TABLE : exported by GetBlockTable() |
| |
| # ----- Flash Size ----- |
| # NOR_FLASH_DENSITY : exported by GetFlashInfoLog() |
| # nNOR_FLASH_DENSITY |
| # NOR_FLASH_SIZE : exported by GetFlashInfoLog() |
| # nNOR_FLASH_SIZE : exported by GetPhysicalFlashEnd() |
| # nCODESize : exported by GetROMSize() |
| |
| #**************************************************************************** |
| # oo >>> Finished |
| #**************************************************************************** |
| return 1; |
| |
| sub Parse |
| { |
| my ($strFilePath, $Source, $INSIDE_MTK, $bIsDummy) = @_; |
| return if(!defined $Source); |
| my %Results; |
| $Results{PATH} = $strFilePath; |
| $Results{path} = $strFilePath; |
| if($Source eq FEATURE_CONFIG) |
| { |
| &FileInfo::ParseDefinition($strFilePath, \%Results, 0); |
| &_PostProcessFeatureConfig(\%Results, $INSIDE_MTK, $bIsDummy); |
| } |
| elsif($Source eq CUSTOM_IMG_CONFIG) |
| { |
| &FileInfo::ParseDefinition($strFilePath, \%Results, 1); |
| &_PostProcessIMG_CONFIG(\%Results); |
| } |
| elsif($Source eq CUSTOM_EMI) |
| { |
| &FileInfo::ParseDefinition($strFilePath, \%Results, 0); |
| &_PostProcessRamSize(\%Results, $bIsDummy); |
| } |
| elsif($Source eq CUSTOM_FLASH) |
| { |
| &_ParseFlashInfo($strFilePath, \%Results); |
| &_PostProcessFlashSize(\%Results, $bIsDummy); |
| } |
| else |
| { |
| &FileInfo::ParseDefinition($strFilePath, \%Results, 0); |
| } |
| $g_MemConfigValues{$Source} = \%Results; |
| } |
| |
| sub _PostProcessFeatureConfig |
| { |
| my ($Hash_ref, $INSIDE_MTK, $bIsDummy)=@_; |
| if($INSIDE_MTK == 0) |
| { |
| delete $Hash_ref->{"PROJECT_EXPECTED_CODE_LIMIT"} if (exists $Hash_ref->{"PROJECT_EXPECTED_CODE_LIMIT"}); |
| delete $Hash_ref->{"PROJECT_EXPECTED_RAM_LIMIT"} if (exists $Hash_ref->{"PROJECT_EXPECTED_RAM_LIMIT"}); |
| delete $Hash_ref->{"PROJECT_EXPECTED_RAM_LIMIT_NFB"} if (exists $Hash_ref->{"PROJECT_EXPECTED_RAM_LIMIT_NFB"}); |
| } |
| if($bIsDummy) |
| { |
| $Hash_ref->{'CONFIG_ZIMAGE_DECOMPRESSED_SIZE'} = "0x2000000"; |
| } |
| $Hash_ref->{CONFIG_FOTA_UE_FLASH_SPACE} = "0x0" if(!defined $Hash_ref->{CONFIG_FOTA_UE_FLASH_SPACE}); |
| $Hash_ref->{CONFIG_FOTA_PACKAGE_BLOCK_NUMBER} = "4" if(!defined $Hash_ref->{CONFIG_FOTA_PACKAGE_BLOCK_NUMBER}); |
| $Hash_ref->{CONFIG_FOTA_PACKAGE_AREA_SIZE} = "0x0" if(!defined $Hash_ref->{CONFIG_FOTA_PACKAGE_AREA_SIZE}); |
| $Hash_ref->{CONFIG_FOTA_NAND_MAP_TABLE_SIZE} = "0x800" if(!defined $Hash_ref->{CONFIG_FOTA_NAND_MAP_TABLE_SIZE}); |
| } |
| sub _PostProcessIMG_CONFIG |
| { |
| my ($Hash_ref) = @_; |
| if(defined $g_MemConfigValues{FEATURE_CONFIG}) |
| { |
| $Hash_ref->{CONFIG_FOTA_UE_FLASH_SPACE} = &get("CONFIG_FOTA_UE_FLASH_SPACE", FEATURE_CONFIG); |
| $Hash_ref->{CONFIG_FOTA_PACKAGE_BLOCK_NUMBER} = &get("CONFIG_FOTA_PACKAGE_BLOCK_NUMBER", FEATURE_CONFIG); |
| $Hash_ref->{CONFIG_FOTA_PACKAGE_AREA_SIZE} = &get("CONFIG_FOTA_PACKAGE_AREA_SIZE", FEATURE_CONFIG); |
| $Hash_ref->{CONFIG_FOTA_NAND_MAP_TABLE_SIZE} = &get("CONFIG_FOTA_NAND_MAP_TABLE_SIZE", FEATURE_CONFIG); |
| } |
| } |
| sub _PostProcessRamSize |
| { |
| my ($Hash_ref, $bIsDummy) = @_; |
| $Hash_ref->{nEMI_EXTSRAM_SIZE} = eval($Hash_ref->{EMI_EXTSRAM_SIZE}); |
| $Hash_ref->{strEMI_EXTSRAM_SIZE} = &CommonUtil::Dec2Hex($Hash_ref->{nEMI_EXTSRAM_SIZE}); |
| if($bIsDummy) |
| { |
| $Hash_ref->{nPROCESSED_RAMSIZE} = 0x8000000; |
| } |
| else |
| { |
| &DieIfNotParsing(FEATURE_CONFIG, __FILE__, __LINE__); |
| if(&FileInfo::is_NonSPNOR() and &exist('PROJECT_EXPECTED_RAM_LIMIT', FEATURE_CONFIG)) |
| { |
| $Hash_ref->{nPROCESSED_RAMSIZE} = hex(&get('PROJECT_EXPECTED_RAM_LIMIT', FEATURE_CONFIG)); |
| } |
| elsif(!&FileInfo::is_NonSPNOR() and &exist('PROJECT_EXPECTED_RAM_LIMIT_NFB', FEATURE_CONFIG)) |
| { |
| $Hash_ref->{nPROCESSED_RAMSIZE} = hex(&get('PROJECT_EXPECTED_RAM_LIMIT_NFB', FEATURE_CONFIG)); |
| } |
| else |
| { |
| $Hash_ref->{nPROCESSED_RAMSIZE} = $Hash_ref->{"nEMI_EXTSRAM_SIZE"}; |
| } |
| } |
| } |
| sub _ParseFlashInfo |
| { |
| my ($strFilePath, $Hash_ref) = @_; |
| my (@REGION_LIST, @BANK_LIST, @BLK_LIST, %BLK_TABLE); |
| my $content = &CommonUtil::GetFileContent($strFilePath); |
| my @lines = split(/\n|\r/, $content); |
| &_parse_flash_size(\@lines, $Hash_ref); |
| if(&FileInfo::is_NonSPNOR()) |
| { |
| $Hash_ref->{RegionInfoTxt} = &_parse_norflash_list(\@lines, \@REGION_LIST, |
| 'FLASH_REGIONINFO_VAR_MODIFIER\s+FlashRegionInfo\s+oriRegionInfo\S+', |
| 'EndoriRegionInfo'); |
| $Hash_ref->{BlkInfoTxt} = &_parse_norflash_list(\@lines, \@BLK_LIST, |
| 'FLASH_REGIONINFO_VAR_MODIFIER\s+FlashBlockTBL\s+\S+', |
| 'EndBlockInfo'); |
| $Hash_ref->{BankInfoTxt} = &_parse_norflash_list(\@lines, \@BANK_LIST, |
| 'static\s+NORBankInfo\s+oriBankInfo\S+', |
| 'EndBankInfo'); |
| if (scalar(@BLK_LIST) > 0) |
| { |
| foreach my $item (@BLK_LIST) |
| { #{0x0, 0x10000} |
| $BLK_TABLE{hex($item->[0])} = hex($item->[1]); |
| } |
| } |
| $Hash_ref->{REGION_LIST} = \@REGION_LIST; |
| $Hash_ref->{BANK_LIST} = \@BANK_LIST; |
| $Hash_ref->{BLK_LIST} = \@BLK_LIST; |
| $Hash_ref->{BLK_TABLE} = \%BLK_TABLE; |
| } |
| } |
| sub _parse_norflash_list #called by _ProcessFlash |
| { |
| my ($lines_aref, $list_aref, $strSearch, $strEnd) = @_; |
| my $strParsedString; |
| my $bFound = undef; |
| foreach my $line (@$lines_aref) |
| { |
| if ($line =~ /^$strSearch/) |
| { |
| $bFound = 1; |
| } |
| elsif ($bFound) |
| { |
| if ($line =~ /\{\s*(\S+)\s*,\s*(\S+)\s*\}/) |
| { |
| $strParsedString .= $line . "\n"; |
| push @$list_aref, [$1,$2]; |
| } |
| last if ($line =~ /^\s*$strEnd\s*/); |
| } |
| } |
| return $strParsedString; |
| } |
| sub _parse_flash_size # called by _ProcessFlash |
| { |
| my ($lines_aref, $Hash_ref) = @_; |
| foreach my $line (@$lines_aref) |
| { |
| # NOR_FLASH_DENSITY = NOR_FLASH_SIZE but in different units |
| # NOR_FLASH_DENSITY is only generated in nor project by emiGen |
| # #define NOR_FLASH_SIZE is generated in both nand(means nand flash size) and nor project by emiGen |
| if($line =~ /^\s*\*\s+NOR_FLASH_DENSITY:\s*(\w*)/) |
| { # * NOR_FLASH_DENSITY: 0x02000000 - got from MDL's bank/block calculation |
| $Hash_ref->{NOR_FLASH_DENSITY} = $1; # in string |
| $Hash_ref->{nNOR_FLASH_DENSITY} = hex($1); # in num |
| } |
| elsif($line =~ /^\s*\#define\s+NOR_FLASH_SIZE\s+(\w+)/) |
| { # #define NOR_FLASH_SIZE 0x08000000 |
| $Hash_ref->{NOR_FLASH_SIZE} = $1; # in string |
| $Hash_ref->{nNOR_FLASH_SIZE} = hex($1); # in num |
| } |
| } |
| } |
| sub _PostProcessFlashSize |
| { |
| my ($Hash_ref, $bIsDummy) = @_; |
| &DieIfNotParsing(FEATURE_CONFIG, __FILE__, __LINE__); |
| if(&FileInfo::is_NonSPNOR()) |
| { |
| if($bIsDummy) |
| { |
| $Hash_ref->{nCODESize} = 0x8000000; |
| } |
| elsif(&exist('PROJECT_EXPECTED_CODE_LIMIT', FEATURE_CONFIG)) |
| { |
| $Hash_ref->{nCODESize} = hex(&get('PROJECT_EXPECTED_CODE_LIMIT', FEATURE_CONFIG)); |
| } |
| else |
| { |
| ($Hash_ref->{nCODESize}, my $temp) = &_GetFSInfo($Hash_ref); |
| } |
| } |
| } |
| sub _GetFSInfo |
| { |
| my ($Hash_ref) = @_; |
| &DieIfNotNonSPNOR(__FILE__, __LINE__); |
| &DieIfNotParsing(MEMORY_DEVICE, __FILE__, __LINE__); |
| my ($nFSBase, $nFSSize) = (undef, undef); |
| if(&exist("NOR_BOOTING_NOR_FS_BASE_ADDRESS", MEMORY_DEVICE) and &exist("NOR_BOOTING_NOR_FS_SIZE", MEMORY_DEVICE)) |
| { |
| $nFSBase = hex(&get("NOR_BOOTING_NOR_FS_BASE_ADDRESS", MEMORY_DEVICE)); |
| $nFSSize = hex(&get("NOR_BOOTING_NOR_FS_SIZE", MEMORY_DEVICE)); |
| } |
| elsif(&exist("NOR_BOOTING_NOR_FS_BASE_ADDRESS", MEMORY_DEVICE) and !&exist("NOR_BOOTING_NOR_FS_SIZE" , MEMORY_DEVICE)) |
| { |
| my ($nFATBase , $nFATSpace, $nSmallBlockStart) = &_GetFATInfo($Hash_ref); |
| $nFSBase = hex(&get("NOR_BOOTING_NOR_FS_BASE_ADDRESS", MEMORY_DEVICE)); |
| $nFSSize = $nSmallBlockStart - $nFSBase; |
| } |
| elsif(!&exist("NOR_BOOTING_NOR_FS_BASE_ADDRESS", MEMORY_DEVICE) and &exist("NOR_BOOTING_NOR_FS_SIZE", MEMORY_DEVICE)) |
| { |
| ($nFSBase , my $nFATSpace, my $nSmallBlockStart) = &_GetFATInfo($Hash_ref); |
| $nFSSize = hex(&get("NOR_BOOTING_NOR_FS_SIZE", MEMORY_DEVICE)); |
| } |
| else |
| { |
| ($nFSBase , $nFSSize, my $nSmallBlockStart) = &_GetFATInfo($Hash_ref); |
| } |
| ### work-around for bad small block issue |
| #To correct Toshiba(NOR Flash on 36) for some small blocks which can't be used |
| if((($nFSBase+$nFSSize) > $Hash_ref->{nNOR_FLASH_DENSITY}) and |
| (($nFSBase+$nFSSize) <= ($Hash_ref->{nNOR_FLASH_SIZE}))) |
| { |
| $nFSSize = $Hash_ref->{nNOR_FLASH_DENSITY} - $nFSBase; |
| } |
| return ($nFSBase, $nFSSize); |
| } |
| sub _GetFATInfo ### Calculate FAT size/start address |
| { |
| my ($Hash_ref) = @_; #parsed hash from custom_flash.h |
| &DieIfNotNonSPNOR(__FILE__, __LINE__); |
| &DieIfNotParsing(MEMORY_DEVICE, __FILE__, __LINE__); |
| my ($Regions_aref, $BLK_aref) = ($Hash_ref->{REGION_LIST}, $Hash_ref->{BLK_LIST}); |
| my ($nFATBase , $nFATSpace) = (0, 0); |
| my $nFlashSize = $Hash_ref->{nNOR_FLASH_DENSITY}; |
| my $sum_of_regions = 0; |
| my $nSmallBlockStart = $nFlashSize; |
| for (0..scalar(@{$Regions_aref})-1) |
| { |
| $sum_of_regions += hex($Regions_aref->[$_][0]) * $Regions_aref->[$_][1]; |
| } |
| if ((scalar(@{$Regions_aref})>0) && &is("__NOR_FDM5__", "TRUE", MEMORY_DEVICE)) |
| { |
| $nSmallBlockStart = hex($BLK_aref->[-1]->[0]);# match {0xFF0000,0x2000} |
| $nFATSpace = $sum_of_regions - ($nFlashSize - $nSmallBlockStart); #To avoid Toshiba(NOR Flash) some small blocks can't be used |
| } |
| else |
| { |
| $nFATSpace = $sum_of_regions; |
| } |
| $nFATBase = $nFlashSize - $sum_of_regions; |
| return ($nFATBase , $nFATSpace, $nSmallBlockStart); |
| } |
| sub VerifyFSInfo |
| { |
| my ($isDummy) = @_; |
| return if($isDummy or !&FileInfo::is_NonSPNOR()); |
| my $Flash_href = &GetSource(CUSTOM_FLASH); |
| my ($nFSBase, $nFSSize) = &_GetFSInfo($Flash_href); |
| |
| # 1. Ensure that FS Base and Size are correct |
| my $nPhysicalFlashSize = &GetPhysicalFlashEnd(); |
| &config_die("FAT space($nFSBase+$nFSSize) cannot exceed physical NOR flash size($nPhysicalFlashSize)!", __FILE__, __LINE__) |
| if(($nFSBase < 0) or ($nFSSize < 0) or (($nFSBase+ $nFSSize) > $nPhysicalFlashSize)); |
| |
| # 2. Ensure small block workaround |
| if(&exist("__NOR_FDM5__", MEMORY_DEVICE)) |
| { |
| my ($nFATBase , $nFATSpace, $nSmallBlockStart) = &_GetFATInfo($Flash_href); |
| &config_die("FAT space($nFSBase+$nFSSize) cannot include small blocks(SmallBlockStart:$nSmallBlockStart) in NOR FDM 5.0!", __FILE__, __LINE__) |
| if(($nFSBase+$nFSSize) > $nSmallBlockStart); |
| } |
| |
| # 3. if FS Base is defined by the customer, help to check bank/block alignment. |
| if(&exist("NOR_BOOTING_NOR_FS_BASE_ADDRESS", MEMORY_DEVICE)) |
| { |
| if(&FileInfo::is("enhanced_single_bank_nor_flash_support","TRUE")) |
| { #single-bank FAT start address needs to be block-aligned |
| my $bBlockAligned = &isBlockAligned($nFSBase); |
| my $BlkInfoTxt = &get("BlkInfoTxt", CUSTOM_FLASH); |
| &config_die("FS Base($nFSBase) needs to be block-aligned in single-bank setting!\nBlockInfo:\n$BlkInfoTxt\n", |
| __FILE__, __LINE__) if(!$bBlockAligned); |
| } |
| else |
| { #multi-bank FAT start address needs to be bank-aligned |
| my ($bBankAligned, $nSum_of_banks) = &isBankAligned($nFSBase); |
| &config_die("FS Base($nFSBase) needs to be bank-aligned (SumOfBank=$nSum_of_banks) in multi-bank setting!", |
| __FILE__, __LINE__) if(!$bBankAligned); |
| } |
| } |
| # 4. Check CODE setting validity |
| my $strROMLimit = &get("PROJECT_EXPECTED_CODE_LIMIT", FEATURE_CONFIG); |
| &config_die("Expected ROM Limit($strROMLimit) in ".&GetMappingPath(FEATURE_CONFIG). |
| " is larger than FS Base(".&CommonUtil::Dec2Hex($nFSBase).")!\n" , __FILE__, __LINE__) |
| if(defined $strROMLimit and hex($strROMLimit) > $nFSBase); |
| } |
| sub isBlockAligned |
| { |
| my ($nBase) = @_; |
| my $BLK_aref = &get("BLK_LIST", CUSTOM_FLASH); |
| my $bBlockAligned = 1; |
| foreach my $nIndex (scalar(@{$BLK_aref})-1 .. 0) |
| { |
| if($nBase >= hex($BLK_aref->[$nIndex]->[0])) |
| { |
| my $nCurrentBlockSize = hex($BLK_aref->[$nIndex]->[1]); |
| if(($nBase-hex($BLK_aref->[$nIndex]->[0])) % $nCurrentBlockSize) |
| { # block aligned should be 0 after % |
| $bBlockAligned = 0; |
| } |
| } |
| } |
| return $bBlockAligned; |
| } |
| sub isBankAligned |
| { |
| my ($nBase) = @_; |
| my $BANK_aref = &get("BANK_LIST", CUSTOM_FLASH); |
| my $bBankAligned = 1; |
| my $nSum_of_banks = 0; |
| foreach my $nIndex (0 .. scalar(@{$BANK_aref})-1) |
| { |
| foreach (0 .. $BANK_aref->[$nIndex]->[1]) |
| { |
| $nSum_of_banks += hex($BANK_aref->[$nIndex]->[0]); |
| last if($nSum_of_banks >= $nBase); |
| } |
| last if($nSum_of_banks >= $nBase); |
| } |
| $bBankAligned = ($nSum_of_banks == $nBase); |
| return ($bBankAligned, $nSum_of_banks); |
| } |
| sub VerifyRAMInfo |
| { |
| my ($isDummy) = @_; |
| return if($isDummy); |
| # Check RAM setting validity |
| my $strRamSize = &GetPhysicalExtRAMSize(1); |
| my $strRamLimit = (&FileInfo::is_NonSPNOR()) ? &get("PROJECT_EXPECTED_RAM_LIMIT", FEATURE_CONFIG) |
| : &get("PROJECT_EXPECTED_RAM_LIMIT_NFB", FEATURE_CONFIG) ; |
| &config_die("Expected Ram Limit($strRamLimit) in ".&GetMappingPath(FEATURE_CONFIG). |
| " is larger than physical Ram size($strRamSize)!\n" , __FILE__, __LINE__) |
| if(defined $strRamLimit and hex($strRamLimit) > hex($strRamSize)); |
| } |
| |
| #**************************************************************************** |
| # subroutine: Get_SDS_total_size: To get the SDS total size according to the block size |
| # input: $block_size : the block size for SDS |
| # $feature_config_ref : a hash reference to query defined values in custom_FeatureConfig.h |
| # $feature_option_ref : a hash reference to query feature options in projec.mak |
| # return: $sds_total_size |
| #**************************************************************************** |
| sub Get_SDS_total_size |
| { |
| my ($block_size, $feature_config_ref, $feature_option_ref) = @_; |
| my $sds_data_size = 0; |
| my $sds_spare_size = 0; |
| my $sds_total_size = 0; |
| $feature_config_ref = &GetSource(FEATURE_CONFIG) if(!defined $feature_config_ref); |
| if(!&FileInfo::is_NonSPNOR($feature_option_ref)) |
| { |
| $sds_data_size = (defined $feature_config_ref->{'SDS_MAX_SIZE'}) ? hex($feature_config_ref->{'SDS_MAX_SIZE'}) : 256*1024; |
| $sds_spare_size = (defined $feature_config_ref->{'SDS_RESERVED_SIZE_FOR_BBM'}) ? hex($feature_config_ref->{'SDS_RESERVED_SIZE_FOR_BBM'}) : 256*1024; |
| } |
| else |
| { |
| my $mode = $feature_option_ref->{'MODE'}; |
| if(!defined $block_size) |
| { |
| $block_size = &GetBlockSize(&GetPhysicalFlashEnd() -1, __FILE__, __LINE__); |
| } |
| my $two_blocks_size = 2 * $block_size; #the number of blocks for SDS need to be 2N |
| |
| if(defined $feature_config_ref->{'SDS_MAX_SIZE'}) |
| { |
| $sds_data_size = hex($feature_config_ref->{'SDS_MAX_SIZE'}); |
| } |
| elsif(($mode eq 'GSM') or ($mode eq 'GPRS')) |
| { |
| my $sds_temp_size = 0; |
| &config_die("Input parameter: Block Size($block_size) can't be less than 1",__FILE__, __LINE__) |
| if(!defined $block_size or $block_size <= 0); |
| while($sds_temp_size < 32*1024) |
| { |
| $sds_temp_size += $two_blocks_size; |
| } |
| $sds_data_size = ($block_size <= 12*1024) ? $sds_temp_size : $two_blocks_size; |
| } |
| else |
| { |
| my $sds_temp_size = 0; |
| &config_die("Input parameter: Block Size($block_size) can't be less than 1",__FILE__, __LINE__) |
| if(!defined $block_size or $block_size <= 0); |
| while($sds_temp_size < 128*1024) |
| { |
| $sds_temp_size += $two_blocks_size; |
| } |
| $sds_data_size = ($block_size <= 64*1024) ? $sds_temp_size : $two_blocks_size; |
| } |
| } |
| $sds_total_size = $sds_data_size + $sds_spare_size; |
| return $sds_total_size; |
| } |
| sub GetExtRamSize |
| { |
| &DieIfNotParsing(CUSTOM_EMI, __FILE__, __LINE__); |
| return &get("nPROCESSED_RAMSIZE", CUSTOM_EMI); |
| } |
| sub GetROMSize |
| { |
| &DieIfNotParsing(CUSTOM_FLASH, __FILE__, __LINE__); |
| return &get("nCODESize", CUSTOM_FLASH); |
| } |
| sub GetPhysicalExtRAMSize |
| { |
| my ($bNeedString) = @_; |
| my $ExtRamSize = &get("nEMI_EXTSRAM_SIZE", CUSTOM_EMI) ; |
| $ExtRamSize = &get("strEMI_EXTSRAM_SIZE", CUSTOM_EMI) if($bNeedString); |
| return $ExtRamSize; |
| } |
| sub GetPhysicalFlashEnd |
| { |
| &DieIfNotParsing(CUSTOM_FLASH, __FILE__, __LINE__); |
| return &get("nNOR_FLASH_SIZE", CUSTOM_FLASH); |
| } |
| |
| sub GetBlockTable |
| { |
| &DieIfNotParsing(CUSTOM_FLASH, __FILE__, __LINE__); |
| return &get("BLK_TABLE", CUSTOM_FLASH); |
| } |
| |
| sub GetFlashInfoLog |
| { |
| &DieIfNotParsing(CUSTOM_FLASH, __FILE__, __LINE__); |
| my $Blk = &get("BlkInfoTxt", CUSTOM_FLASH); |
| my $Region = &get("RegionInfoTxt", CUSTOM_FLASH); |
| my $Bank = &get("BankInfoTxt", CUSTOM_FLASH); |
| my $NOR_Density = &get("NOR_FLASH_DENSITY", CUSTOM_FLASH); |
| my $FlashSize = &get("NOR_FLASH_SIZE", CUSTOM_FLASH); |
| return ($Blk, $Region, $Bank, $NOR_Density, $FlashSize); |
| } |
| |
| #**************************************************************************** |
| # subroutine: GetNextBlockAlignedAddr : Query Next Block-aligned Addr from input Addr |
| # input: $nAddr : Address to the next destination |
| # $bReturnItselfIfAligned : 1=if $nAddr is block aligned, return itself directly. |
| # 0=return next block aligned address against $nAddr |
| # $file = __FILE__ , $line_no= __LINE__ |
| # Output: Next block-aligned addr |
| #**************************************************************************** |
| sub GetNextBlockAlignedAddr |
| { |
| my ($nAddr, $bReturnItselfIfAligned, $file, $line_no) = @_; |
| &DieIfNotNonSPNOR($file, $line_no); |
| my $nFlashSize = &GetPhysicalFlashEnd(); |
| &config_die("Query Block-aligned addr at ($nAddr) larger than FlashSize($nFlashSize)!", $file, $line_no) |
| if ($nAddr > $nFlashSize); |
| |
| my $nNextAddr = undef; |
| my $BLK_aref = &get("BLK_LIST", CUSTOM_FLASH); |
| foreach my $nIndex (scalar(@{$BLK_aref})-1 .. 0) |
| { |
| if($nAddr >= hex($BLK_aref->[$nIndex]->[0])) |
| { |
| my $nCurrentBlockSize = hex($BLK_aref->[$nIndex]->[1]); |
| my $bBlockAligned = ($nAddr - hex($BLK_aref->[$nIndex]->[0])) % $nCurrentBlockSize; |
| if($bBlockAligned) |
| { |
| $nNextAddr = $nAddr; |
| $nNextAddr += $nCurrentBlockSize if(!$bReturnItselfIfAligned); |
| last; |
| } |
| else |
| { |
| my $nBlocks = int(($nAddr - hex($BLK_aref->[$nIndex]->[0])) / $nCurrentBlockSize); |
| $nNextAddr = hex($BLK_aref->[$nIndex]->[0]) + $nBlocks*$nCurrentBlockSize; |
| last; |
| } |
| } |
| } |
| if(!defined $nNextAddr) |
| { |
| my $BlkInfoTxt = &get("BlkInfoTxt", CUSTOM_FLASH); |
| &config_die("Can't find next Block-aligned addr. Please check block table:\n$BlkInfoTxt\n", $file, $line_no); |
| } |
| &config_die("Next Block-aligned addr at $nNextAddr is larger than FlashSize($nFlashSize)!", $file, $line_no) |
| if ($nNextAddr > $nFlashSize); |
| return $nNextAddr; |
| } |
| sub GetBlockSize #by address |
| { |
| my ($nAddr, $file, $line_no) = @_; |
| &DieIfNotNonSPNOR($file, $line_no); |
| my $nFlashSize = &GetPhysicalFlashEnd(); |
| &config_die("[GetBlockSize]Current Address($nAddr) can't be larger than FlashSize($nFlashSize)!", $file, $line_no) |
| if ($nAddr > $nFlashSize); |
| |
| my $href = &GetBlockTable(); |
| my @offset = sort {$b <=> $a} keys %$href; |
| foreach my $i (@offset) |
| { |
| return $href->{$i} if ($nAddr >= $i); |
| } |
| my $BlkInfoTxt = &get("BlkInfoTxt", CUSTOM_FLASH); |
| &config_die("Block table information:\n$BlkInfoTxt\n is not enough for Current Address($nAddr)!", $file, $line_no); |
| } |
| |
| |
| sub get |
| { |
| my ($strKey, $Source) = @_; |
| my $strValue = undef; |
| if(defined $Source) |
| { |
| &DieIfNotParsing($Source, __FILE__, __LINE__); |
| if(exists $g_MemConfigValues{$Source}->{$strKey}) |
| { |
| $strValue = $g_MemConfigValues{$Source}->{$strKey}; |
| } |
| } |
| return $strValue; |
| } |
| sub GetSource |
| { |
| my ($Source) = @_; |
| &DieIfNotParsing($Source); |
| return $g_MemConfigValues{$Source}; # return href |
| } |
| sub GetMemDev #MemoryDevice |
| { |
| my ($strKey) = @_; |
| return &get($strKey, MEMORY_DEVICE); |
| } |
| sub GetFtCfg #FeatureConfig |
| { |
| my ($strKey) = @_; |
| return &get($strKey, FEATURE_CONFIG); |
| } |
| sub GetPath |
| { |
| my ($Source) = @_; |
| return &get("PATH", $Source); |
| } |
| sub GetMappingPath |
| { |
| my ($Source) = @_; |
| my $strFileName = basename(&get("PATH", $Source)); |
| my $strBoard = &FileInfo::get("BOARD_VER"); |
| my $strFlavor = &FileInfo::get("FLAVOR"); |
| my $strPath = "pcore/custom/system/$strBoard/$strFlavor/$strFileName\.conf"; |
| return $strPath; |
| } |
| sub is |
| { |
| my ($strKey, $strValue, $Source) = @_; |
| my $bIsTheSame = 0; |
| if(defined $Source) |
| { |
| &DieIfNotParsing($Source, __FILE__, __LINE__); |
| $bIsTheSame = 1 if(exists $g_MemConfigValues{$Source}->{uc($strKey)} and |
| $g_MemConfigValues{$Source}->{uc($strKey)} eq $strValue); |
| } |
| return $bIsTheSame; |
| } |
| sub exist |
| { |
| my ($strKey, $Source) = @_; |
| my $bExist = 0; |
| if(defined $Source) |
| { |
| &DieIfNotParsing($Source, __FILE__, __LINE__); |
| $bExist = 1 if(exists $g_MemConfigValues{$Source}->{uc($strKey)}); |
| } |
| return $bExist; |
| } |
| |
| sub config_die |
| { |
| my ($error_msg, $file, $line_no) = @_; |
| &sysUtil::error_handler($error_msg, $file, $line_no, '[Memory Config]'); |
| } |
| |
| sub DieIfNotParsing |
| { |
| my ($Source, $file, $line_no) = @_; |
| &config_die("Please parse $Source in advance.", $file, $line_no) if(!exists $g_MemConfigValues{$Source}); |
| } |
| |
| sub DieIfNotNonSPNOR |
| { |
| my ($file, $line_no) = @_; |
| &config_die("This function is unsupported on non NOR platform.", $file, $line_no) if(!&FileInfo::is_NonSPNOR()); |
| } |