[X]Assistant

[vvaaavv]

WwR MTK download

Version: 2.50 Beta

Last update of the program in the header:01.05.2019

!!!ATTENTION!!!
The program can be consideredservice which assumes the presence of certain knowledge in this area.
The level of complexity of the topic: difficult

Short description:
The program works with ROM files (read from the device usingSP Flash Tool ), based on MTK processors.

• Pulls Preloader.bin from the ROM dump file.
  
• You can cut a certain segment of the read memory.
  
• Cut the ROM file into parts, based on the Scatter file.
  
• Finds the PMT sections, PGPT (SGPT), on the basis of information from these sections creates a Scatter file.
  
• Calculates from the Recovery_log the name of the partitions, their starts and lengths.
  
• Works on ADB. Creates backup copies of partitions (If you have root rights).
  
• Creating a scatter file for devices with root rights on the MTK platform. Backup firmware any devices.
  
• Cuts out unnecessary sectors (Spare) from read memory dump from phones with NAND memory.
  
• View EXT4 sections in the ROM file itself, extract files (files only) from EXT4 to ROM.
  
• Creating empty sections EXT4, for a given length, the ability to convert into a sparse image.
  
• Create empty sections or files filled with zeros or random numbers.
  
• When you open the ROM file, instantly view the partition table GPT, PMT, MBR.
  
• New features will be added.

PC requirements: Windows XP or higher
Device Requirements: device on the MTK platform and ROM from the SP Flash Tool
Program interface: Р СѓСЃСЃРєРёР№ / English
Developer: [email protected]

Download:
Version: 2.50 Beta:
WwR_2.50_Rus.zip(46.75 MB)
WwR_2.50_Eng.zip(46.75 MB)

Attention! Until May 9, the topic header and instructions in it will change due to the release of the new version of the program

Screenshots:

List of changes

• Version 1.8
  
  • Improved speed performance: ROM cuts, Spare cuts, Partition Search.
    
  • In the Search section search for regions on the ball, search PMT, PGPT, MBR + EBR1.
    
  • Ability to make a scatter file from the PMT and PGPT sections.
    
  • Made a log program.
  
  
• Version 2.0
  
  • Added the ability to make a scatter file based on the information: dumchar_info or partinfo.
    
  • Also added the ability to compare files and scatter files by start and length values.
    
  • Minor bugs fixed.
    
  • Resized to fit on laptops.
    
  • Size of the program: 910С…640.
  
  
• Version 2.15
  
  • Minor bugs fixed. (Wrongly found the last FF at the ends. The fix for MT6589 is the old-fashioned scatter file)
  
  
• Version 2.20
  
  • Implemented automatically pull the Preloader from the ROM file, if it is there when it is executed:<Cut the ROM into a folder ..>.
  
  
• Version 2.30
  
  • Changed the program interface, added support for English.
    
  • Implemented autopilot. Fixed bugs and errors.
    
  • Many changes introduced !!!
  
  
• Version 2.40
  
  • Changed the program interface. Switch tabs by the old, or from the menu, or by buttons.
    
  • Implemented ADB mode. (Device information, List of sections, List of installed applications (view, install, delete), View Build.prop, ...)
    
  • In ADB mode with root rights, the creation of backup on all platforms (Dumchar_info, Partinfo, Partitions, Full_ROM) is implemented
    
  • Fixed bug in pulling Preloader, on some models.
    
  • The table of the Scatter file is improved, you can see all the fields in the Scatter file. Support for new lines is included.
    
  • In autopilot, the creation of a Scatter file from the Recovery_Log information has been improved. The program actually checks the starting values ​​of the LK, Boot, System, UserData, Cache sections and if they match, it makes a Scatter file. If it does not match, it calculates the offset. Then it rechecks again, and if the value of starts coincides, it uses them to create a Scatter file.
    
  • Fixed bug if more than 50 sections are used when creating a Scatter file.
    
  • Added. All sections that are not in the template file are marked as non-firmware. If the original, stock Scatter file is selected, the program automatically adds these values ​​to the template file.
    
  • Fixed autodetection of read sections in ROM file.
    
  • Redesigned partition search algorithm. The found Ext_4 sections have the specified image length, so there is no point in looking for other sections in them.
    
  • A new platform definition algorithm is involved, not by LK (uboot), but by Recovery_Log. If Recovery_Log is not in the ROM file, then the LK detection algorithm is used.
    
  • In autopilot when creating a scatter file, the program recognizes in fact which file system is on partitions, i.e. EXT4_IMG, UBI_IMG, NORMAL_ROM.
    
  • Many changes introduced !!!
  
  
• Version 2.50
  
  • Changed the program interface.
    
  • Automatic selection of the second file. If ROM_1 is selected (EMMC_USER), ROM_0 (EMMC_BOOT_1 or ready Preloader) is selected.
    
  • Added new tabs and features.
    
  • When you open a ROM file, the program instantly recognizes the markup (GPT, PMT, MBR), and displays its structure in a special table.
    
  • Autopilot changed the algorithm of almost all functions.
    
  • Autopilot modified platform definition.
    
  • View sections EXT4 in the ROM file. Extract files to EXT4.
    
  • Creating a clean partition EXT4, with conversion to Spasre and without.
    
  • Create empty files of any size, filled with zeros or random numbers.
    
  • Creating a scatter file of 1 megabyte GPT sections on MTK.
    
  • View build.prop for a second.
    
  • Check the ROM and scatter file.
    
  • In the mode of operation by ADB, you can connect more than one device.
    
  • In the ADB mode, the device automatically connects or reconnects, waits, adds.
    
  • Improved work on cutting ROM, the speed of reading and writing now depends on the hard disk and motherboard.
    
  • 
    
  • Implemented a lot of changes and additions !!!
  
  

Instructions. General principles of work for version 2.50

Select a file in the program (EMMC_USER)

When you press a button<Select a file>. You must select a ROM file read from the device dump.
The program itself determines what type of ROM it is and displays the corresponding message. Example:

It also displays the parameters of the GPT partition, its full volume, the start of the GPT markup, and the backup copy - SGPT.
More immediately shows markup for GPT, PMT, MBR. in the partition table.

Automatic detection of markup type when selecting the EMMC_USER ROM file

When selecting a ROM file (EMMC_USER), the program immediately determines the type of markup, this is GPT or MBR + EBR. If there is a PMT partition table in the first 26 megabytes, it will show the PMT markup.
Here on examples it looks like this:

GPT markup

MBR markup

PMT markup

If nothing appears in the table, and the program has opened a tab<Search for sections>it is worth thinking here - is everything OK with the ROM file ?!

File selection in the program (EMMC_BOOT_1)

When a file is selected, it is EMMC_BOOT_1, in which the Preloader is sewn up. The program scans this file and if this ROM is actually a file in which there is a Preloader, the program selects this file with the second file and shows it below. This opens the tab<Preloader>and happening<Preloader Analysis>, then you can pull Preloader.

Example

If the file is a finished Preloader, the program will also open it with the second file, and open the tab<Preloader>.

Preloader example

The program will warn you that you have already chosen Preloader. And a button<Pull out Preloader and save as ..>will not be active (since there is no sense in pulling out what has already been pulled out).

EMMC Parser function, when analyzing the Preloader

This is necessary for those who change memory chips that have failed. Because in Preloader there is information about the compatibility of memory chips with the device's hardware.
Here is an example:

EMMC Parser Example

In this example, the Preloader has 9 compatible memory chips, which are listed in the table. The CID of the chip and the CID name are displayed in any case, but their parameters are contained in the emmc.txt file in the program folder. Due to the fact that there are a lot of microcircuits, and new ones appear every day, and the manufacturers do not give out the parameters of the microcircuit by the CID number anywhere, so this file is filled in manually.

Automatic selection of the second file

When you select the ROM_1 file (EMMC_USER), the program itself selects EMMC_BOOT_1 (usually ROM_0) or the finished Preloader. Provided that the file is in the same directory.
When a ROM_0 file is selected (EMMC_BOOT_1), the program itself selects EMMC_USER (usually ROM_1). Provided that the file is in the same directory.
If for some reason the program did not select the second file (or the first one), select the file yourself, manually, just press again<File selection>and select the desired file.

Autopilot

1. Creating an empty scatter file:

Empty scatter file - there is no information about the sections in it, only the header of the scatter file, which indicates the type of platform and type of memory in the device and the first section with the Preloader. This is all necessary for reading a dump from the device’s memory.
This empty scatter file is needed only for reading a memory dump from the device, flashing with such a scatter file - It is impossible !!!
The type of device platform can be determined through ADB, for this you do not need root rights, or google. If you specify incorrectly, the SP Flash Tool will give you an error when connecting the device to the PC in read mode.
The memory type is used only two types: EMMC and NAND. In the case of EMMC, the block is selected at 0x20000. In the case of NAND, the block can be anythingbut be sure to choose the right one.You can use the scatter file from the stock firmware and see what is there. If there is no such scatter file, then you can read the firmware with a block size of 0x20000, then select this dump and run<Start scan>in the tab<Search for sections>. The program itself determines the dimension of the block. Then, in the empty scatter file, set the correct dimension of the block and read the dump again.

Example in the picture:

Only this option I turned out to be a worker!

2. Read the firmware from the device:

Here it is written as:WwR MTK (Post vvaaavv # 60035994)

3. Launch autopilot:

Instructions

We make a full backup of the memory of the phone or tablet based on MTK processors.

It is necessary to read all available memory from the device, the so-called ROM files:
ROM_0 is usually a memory block containing the Preloader (EMMC_BOOT_1),
and ROM_1 is a memory block containing everything else (EMMC_USER), there are many ways to do this. For example through the programSP Flash Tool.

Approximate structure of device memory

If you do not know anything about the device:

Using the SP Flash Tool, without a scatter file

With the help of the SP Flash Tool, without a scatter file.

• The instruction is suitable for all types of phones.
  
• Including, when on hands it turns out it is unclear what kind (meaning all the various fakes under known brands)

Imagine:
We have a phone on hand. It is not clear what. The name is not known, the phone does not turn on. (Only connects to the computer in firmware mode). Accordingly, the user does not know how to subtract data from the phone. In order to subtract data from the phone, you must haveScatter file and Preloader . How can I get them? can you try ...
So, for this you will need to download the program:SP Flash Tool and Wwr_mtk and of course install Drivers (VCOM) for phone.
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.

The procedure is as follows:

• 1. Find out what type of processor is used in the phone.
  
• 2. In the SP Flash Tool, subtract at least the first megabyte of data from the phone.
  
• 3. In WwR_MTK pull out the native Preloader.
  
• 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone)
  
• 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone).
  
  Now in more detail:
  
• 1. Find out what type of processor is used in the phone.
  
• 2. In the SP Flash Tool, subtract at least the first megabyte of data from the phone:
  2.1. You can randomly try to find out: in WwR_MTK there is a tab:<Blank scatter file>go to it, no matter what processor, choose any, also with memory.
  Further<Create and save as ..>, choose where and under what name to save.
  2.2. Next, in the SP Flash Tool, select the created empty scatter in the tab<Download>in field<Scatter-loading>, then go to the tab<ReadBack>Push the button<Add>. A new line will appear below. We click on it twice and select the storage location of the so-called ROM_0 block.
  Push<Save>, then a selection of values ​​appears, according to which the SP Flash Tool should read the memory from the device (phone or tablet).
  Next, select:
  
  Type - HEX
  Region: - EMMC_BOOT_1, (If there is such a choice), or EMMC_USER.
  Start Address: - choose 0x0000000000000000, that is, the very beginning.
  Lenght: - choose 0x0000000000100000, i.e. length.
  
  In details

  Usually on new platforms (MT67xx and MT6580) the Preloader is in EMMC_BOOT_1, and all other data is in EMMC_USER.
  We need a region with Preloader. It is usually located at the very beginning of the phone’s memory and does not exceed the size in megabytes (I have not seen the Preloader more than 200 Kb).

  1 Megabyte: 1048576 bytes in decimal form
  1 Megabyte: 0x100000 in hexadecimal form
  (0x parameter - indicates that the number is presented in hexadecimal)
  You can specify and:
  512 KB: 0x80000
  256 KB: 0x40000.

  You can specify more than it is, nothing terrible will happen.
  Therefore, in the SP Flash Tool, select the values:

  Where<Start Address:>- choose<0x00000000000000>, ie the very beginning
  and length:<Lenght:> - <0x0000000000100000>
  Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 200, 201).
  
  Figure 200, if the memory in the EMMC device:
  Figure 201, if the memory in the NAND device:
  2.3. If an error occurs (Figure 202), then we change in WwR_MTK the type of processor shown by the SP Flash Tool. Repeat the action from paragraph 2.1.
  
  Figure 202:
  2.4. If an error occurs (Figure 203), then we change the type of memory shown by the SP Flash Tool in WwR_MTK. Repeat the action from paragraph 2.1.
  
  Figure 203:
  2.5. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 3. In WwR_MTK, pull out the native Preloader:
  3.1. If the ROM file was considered normal, continue: In WwR_MTK, select our file at the very top of the program. Go to the tab<Preloader>, push the button<Preloader Analysis>. We look information:
  The name of the Preloader, the type of processor, the type of memory, and the ability to pull it out of the ROM file (Figure 205).
  
  Figure 205:
  
  *** Note:
  ** On the new platforms (MT67xx and MT6580), this type of processor (MT6752) is always indicated in the Preloader, you should not pay attention to it,
  ** On MT65xx platforms, shows the correct processor type.
  3.2. Push the button<Pull out Preloader and save as ..>, indicate the location of the save. -Now you have your own Preloader, which definitely does not hurt anything.
  
  
• 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone):
  4.1. Go to the SP Flash Tool tab<Download>click the mouse in the empty field below<Location>in the table where the name of the file with Preloader should be.
  And choose our native Preloader, which we just pulled out (Figure 206)
  
  Figure 206:
  4.2. Very carefully we read this item, and the more we do !!!
  Next, go to the tab<Memory Test>, remove all the checkboxes there except<Ram test> (Figure 207-1)
  
  Figure 207-1:
  Click on the start. And we connect the phone completely off to the computer.
  Must pass the memory test, which is in the phone. We look at the line:
  
  EMMC_PART_USER Size = 0x ................
  - there is the total amount of memory specified in the HEX. (Figure 207-2).
  
  Figure 207-2:
  
  If you have a platform MT6757 / MT6797 and instead<Ram test>coming out<DRAM Flip Test>(Figure 207-3).
  
  Figure 207-3:
  Then you can go on the alternate path: Read the first megabyte EMMC_USER, and specify it in WwR_MTK in the tab<Autopilot>, the program will analyze the file and provide accurate information about the size of the total memory in the device (Figure 207-4 and 207-5).
  
  Figure 207-4, 207-5:
  This example uses markup.<GPT>, It goes at the very beginning of EMMC_USER,and in the PGPT section there is information about the full amount of memory. There is no such information in the MBR markup !!!
  
  
• 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone):
  5.1. Now you need to read the full backup from the phone.
  5.2. Go to the tab<ReadBack>Push the button<Add>. Another line will appear in the table below, just click on it and indicate the location of the file to be saved. Then there is a choice of values ​​by which the SP Flash Tool should read the memory from the device. Choose:
  Type - HEX,
  Region: - EMMC_USER
  Start Address: - choose 0x0000000000000000, that is, the very beginning,
  Lenght: - choose length 0x ................, which we considered in<Ram test>
  (For example: 0x00000001d2000000, it is possible and so: 0x1d2000000, Zero in front is for beauty and clarity, the same as 05 will be 5)
  5.3. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208).
  
  Figure 208:
  5.4. The process of reading the full dump of the phone will go. The process is not fast. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  

If everything went well, then you have a full ROM of the entire device memory.

If we have an idea about the device, there is a scatter file from the stock (official) firmware, in which you are sure that this is from your device:

Using the SP Flash Tool, the scatter file is available from the stock firmware

Using the SP Flash Tool, the scatter file is already available.
To do this, you will need to download the program:SP Flash Tool and Wwr_mtk and of course install Drivers (VCOM) for phone.
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.

The procedure is as follows:

• 1. Prepare a scatter file for full reading in the SP Flash Tool.
  
• 2. In the SP Flash Tool read ROM file containing Preloader.
  
• 3. In WwR_MTK pull out the native Preloader.
  
• 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone)
  
• 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone).
  
  Now in more detail:
  
• 1. Prepare a scatter file for full reading in the SP Flash Tool:
  It is necessary to open the scatter file with a text editor, preferablyNotePad ++ and delete all lines after the first section with Preloader. Save the edited file with a different name to prevent overwriting the stock scatter file (Figure 223)
  
  Figure 223:
  
  
• 2. In the SP Flash Tool, subtract at least the first megabyte of data from the phone:
  2.1. Next, in the SP Flash Tool, select the edited empty scatter in the tab<Download>in field<Scatter-loading>, then go to the tab<ReadBack>Push the button<Add>. A new line will appear below. We click on it twice and select the storage location of the so-called ROM_0 block.
  Push<Save>, then a selection of values ​​appears on which the SP Flash Tool should read the memory from the device (phone or tablet).
  Next, select:
  
  Type - HEX
  Region: - EMMC_BOOT_1, (If there is such a choice), or EMMC_USER.
  Start Address: - choose 0x0000000000000000, that is, the very beginning.
  Lenght: - choose 0x0000000000100000, i.e. length.
  
  In details

  Usually on new platforms (MT67xx and MT6580) the Preloader is in EMMC_BOOT_1, and all other data is in EMMC_USER.
  We need a region with Preloader. It is usually located at the very beginning of the phone’s memory and does not exceed the size in megabytes (I have not seen the Preloader more than 200 Kb).

  1 Megabyte: 1048576 bytes in decimal form
  1 Megabyte: 0x100000 in hexadecimal form
  (0x parameter - indicates that the number is presented in hexadecimal)
  You can specify and:
  512 KB: 0x80000
  256 KB: 0x40000.

  You can specify more than it is, nothing terrible will happen.
  Therefore, in the SP Flash Tool, select the values:

  Where<Start Address:>- choose<0x00000000000000>, ie the very beginning
  and length:<Lenght:> - <0x0000000000100000>
  Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 200, 201).
  
  Figure 200, if the memory in the EMMC device:
  Figure 201, if the memory in the NAND device:
  2.2. If an error occurs (Figure 202), then you are not using the scatter file from your device. It is best to use the instruction without the scatter file, which is located above.
  
  Figure 202:
  2.3. If an error occurs (Figure 203), it means that you are not using the scatter file from your device. It is best to use the instruction without the scatter file, which is located above.
  
  Figure 203:
  2.4. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 3. In WwR_MTK, pull out the native Preloader:
  3.1. If the ROM file was considered normal, continue: In WwR_MTK, select our file at the very top of the program. Go to the tab<Preloader>, push the button<Preloader Analysis>. We look information:
  The name of the Preloader, the type of processor, the type of memory, and the ability to pull it out of the ROM file (Figure 205).
  
  Figure 205:
  
  *** Note:
  ** On the new platforms (MT67xx and MT6580), this type of processor (MT6752) is always indicated in the Preloader, you should not pay attention to it,
  ** On MT65xx platforms, shows the correct processor type.
  3.2. Push the button<Pull out Preloader and save as ..>, indicate the location of the save. -Now you have your own Preloader, which definitely does not hurt anything.
  
  
• 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone):
  4.1. Go to the SP Flash Tool tab<Download>click the mouse in the empty field below<Location>in the table where the name of the file with Preloader should be.
  And choose our native Preloader, which we just pulled out (Figure 206)
  
  Figure 206:
  4.2. Very carefully we read this item, and the more we do !!!
  Next, go to the tab<Memory Test>, remove all the checkboxes there except<Ram test> (Figure 207-1)
  
  Figure 207-1:
  Click on the start. And we connect the phone completely off to the computer.
  Must pass the memory test, which is in the phone. We look at the line:
  
  EMMC_PART_USER Size = 0x ................
  - there is the total amount of memory specified in the HEX. (Figure 207-2).
  
  Figure 207-2:
  
  If you have a platform MT6757 / MT6797 and instead<Ram test>coming out<DRAM Flip Test>(Figure 207-3).
  
  Figure 207-3:
  Then you can go on the alternate path: Read the first megabyte EMMC_USER, and specify it in WwR_MTK in the tab<Autopilot>, the program will analyze the file and provide accurate information about the size of the total memory in the device (Figure 207-4 and 207-5).
  
  Figure 207-4, 207-5:
  This example uses markup.<GPT>, It goes at the very beginning of EMMC_USER,and in the PGPT section there is information about the full amount of memory. There is no such information in the MBR markup !!!
  
  
• 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone):
  5.1. Now you need to read the full backup from the phone.
  5.2. Go to the tab<ReadBack>Push the button<Add>. Another line will appear in the table below, just click on it and indicate the location of the file to be saved. Then there is a choice of values ​​by which the SP Flash Tool should read the memory from the device. Choose:
  Type - HEX,
  Region: - EMMC_USER
  Start Address: - choose 0x0000000000000000, that is, the very beginning,
  Lenght: - choose length 0x ................, which we considered in<Ram test>
  (For example: 0x00000001d2000000, it is possible and so: 0x1d2000000, Zero in front is for beauty and clarity, the same as 05 will be 5)
  5.3. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208).
  
  Figure 208:
  5.4. The process of reading the full dump of the phone will go. The process is not fast. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  

If everything went well, then you have a full ROM of the entire device memory.

Now you need to pull the firmware from the existing ROM files (s) and create a scatter file:

Creating a scatter file and extracting partitions from a ROM file using WwR_MTK

Autopilot program

Required:


• In the WwR_MTK program in the tab<Autopilot>click on the button<Select a file..>(in blue) and select the merged ROM (EMMC_USER). See picture 213.
  
  Figure 213:
• The program itself will search for the necessary information, and if it finds the PMT or PGPT tables, it will perform all the actions itself.
  
• If the program asks for a file, the merged memory region EMMC_BOOT_1, then it is needed, you must also choose (Figure 214)
  
  Figure 214:
• We are waiting for the completion of all processes. And delve into the written "Conclusion" of the program. Next, go to the tab<Scatter file>(Figure 215)
  
  Figure 215:
• Next, remove the checkboxes from the sections that you do not need (usually Cache, UserData (The UserData section contains your personal information - Photos, Videos, etc.)), and go back to the tab<Autopilot>(Figure 216).
  
  Figure 216:
• There we choose in paragraph<4) Collect firmware:>If you need to assemble the firmware: Cut the ROM into sections, create a Scatter file, you must click on the appropriate button. If you only need a Scatter file, respectively, a button:<Create Scatter file ..>(Figure 217). And wait for the completion of all processes.
  
  Figure 217:
  
  The program WwR_MTK in autopilot mode performs the following actions:
  
  If it finds PGPT:
  
• Analyzes the presence of a preloader, and calls the ROM file selection dialog (ROM_0 region of read EMMC_BOOT_1) containing the preloader.
  
• Performs a preloader analysis. The name of the preloader. Memory. The ability to pull it out of ROM_0.
  
• From the PGPT section, it pulls out information about the existing sections in ROM_1, the name of the sections, the starting position and the length.
  
• It performs the conversion of the received information about the sections, determines which sections are stitched and which are not (According to the template).
  
• Renders sections in the future scatter file. (By pattern).
  
• Adds sections that are not in PGPT (Preloader, PGPT, SGPT).
  
• Calculates the total memory size from the information in the PGPT section.
  
• Calculates sections RESERVED (Sections that are not sewn in any case, but should be in the scatter file). Corrects start positions and lengths for them (FFFF0084 - for example).
  
• Specifies the location of the LK partition.
  
• Finds the type of processor in the LK section.
  
• Determines how much the ROM_1 file is read, prepares the ROM_1 file for partitioning, removes checkboxes from future partitions that are not read.
  Assembles firmware:
  
• Creates a scatter file.
  
• Splits ROM_1 file into sections.
  
• Pulls out the preloader.
  
  If PMT finds:
  
• Analyzes the presence of a preloader, and calls the ROM file selection dialog (ROM_0 region of read EMMC_BOOT_1) containing the preloader.
  
• Performs a preloader analysis. The name of the preloader. Memory. The ability to pull it out of ROM_0.
  
• From the section, the PMT pulls information about the existing sections in ROM_1, the name of the sections, the starting position and the length.
  
• It performs the conversion of the received information about the sections, determines which sections are stitched and which are not (According to the template).
  
• Renders sections in the future scatter file. (By pattern).
  
• Adds sections that are not in the PMT (Preloader). If necessary.
  
• Approximately calculates the total memory size based on the length of all sections in the firmware.
  
• Specifies the location of the LK partition.
  
• Finds the type of processor in the LK section.
  
• Determines how much the ROM_1 file is read, prepares the ROM_1 file for partitioning, removes checkboxes from future partitions that are not read.
  Assembles firmware:
  
• Creates a scatter file.
  
• Splits ROM_1 file into sections.
  
• Pulls out the preloader.
  
  If it finds Recovery_Log and the necessary information about the firmware sections:
  
• It determines the necessary information about the sections of the firmware, pulls out the names of sections, their positions of length and start.
  
• Performs analysis for matching the found sections and their starts in the ROM file; if there is an offset, then it calculates this offset.
  
• Analyzes the presence of a preloader, and calls the ROM file selection dialog (ROM_0 region of read EMMC_BOOT_1) containing the preloader.
  
• Performs a preloader analysis. The name of the preloader. Memory. The ability to pull it out of ROM_0.
  
• It performs the conversion of the received information about the sections, determines which sections are stitched and which are not (According to the template).
  
• Renders sections in the future scatter file. (By pattern).
  
• Adds sections that do not exist (for example, Preloader, if necessary).
  
• Approximately calculates the total memory size based on the length of all sections in the firmware.
  
• Specifies the location of the LK partition.
  
• Finds the type of processor in the LK section.
  
• Finds the type of processor in Recovery_Log, if such information is there.
  
• Determines how much the ROM_1 file is read, prepares the ROM_1 file for partitioning, removes checkboxes from future partitions that are not read.
  Assembles firmware:
  
• Creates a scatter file.
  
• Splits ROM_1 file into sections.
  
• Pulls out the preloader.
  
  If Spare finds:
  
• Automatically fixes it (You just need to specify the folder to save the corrected ROM). Immediately selects the corrected ROM file and starts the scan again.
  
  What is Spare:

  • AT<SP Flash Tool>in the tab<Memory Test>shows that the total memory of the device is 512MB (0x20000000 in HEX). And after reading it, the file for some reason becomes more by 16MB - this is Spare, which is not needed. It must be removed. This is done in the tab:<Spare Cut>.
    
  • In order to<SP Flash Tool>read without it<Spare>, you need to specify in the read parameters:<Read Page Only>.
    
  • So in the program WwR_MTK open tab<Spare Cut>, select at the top the file read together with<Spare>Press the button<Cut and save as ..>and wait for the completion of the process (Figure 220)
    
    Figure 220:
    
    
  • This is an example<ROM>file read with<Spare>opened in the HEX editor (Figure 221)
    
    Figure 221:
    
    *** Note: The program WwR_MTK (version 2.30 and higher) for any scan determines whether this Spare is in the read firmware or not. If there is, offers to get rid of it. This read option appears when memory is used.<NAND>.
    ATTENTION: You also need to know the size of the read block, it is determined by the Scatter file (I know that there are 0x20000 and 0x40000) the size of the blocks of the UBIFS file system depends on this parameter (My tests on the difference of blocks of this parameter lead to different read ROMs, i.e. when comparing they are DIFFERENT, although read from the same device, and nothing has changed, even the device did not turn on)
    

Semi-automatic way

Required:

• In WwR_MTK, perform a ROM dump scan to find partitions (PMT, PGPT, SGPT).
  If PMT, PGPT, SGPT sections are found:
  
• Create a scatter file.
  
• Splitting a ROM file into sections.
  
• Use as directed. (Mounting partitions, extracting the data you need, and so on)
  
  Now more:
  
  
• Search sections:
  Open the program WwR_MTK, select our full backup (ROM_1 file) go to the tab<Search for sections>, there we press a button<Start scan>and wait until the program finds PGPT or PMT partitions,
  You can then stop the search with the button<Stop>or wait for the end of the process. Then double-click on the blue label:<There is!!! Found partition table ...>and the partition table will open in a clear way.
  After that, the button is activated.<Copy Values ​​to - Scatter File>, click on it. The program itself will find the section LK (UBOOT) and subtracts reliable information about the type of processor.
  And go to the tab<Scatter file>. (Figure 209) The old name for this tab is<Cut ROM>
  
  Figure 209:
  
  Now we have a list of all sections in a way understandable for perception (Figure 211).
  
  Figure 211:
  
  
• It is necessary to perform the conversion of the RESERVED sections to their starting addresses from the end, not from the beginning.
  That is, if the starting address is specified as 0xFFFF0084, then this is from the end of the ROM file. That is, FFFF is a minus type. In order to calculate the negative value, you need to know and specify the full amount of memory.
  Now it is calculated automatically, based on the PGPT section. In the PMT section, this information is not available, so you have to manually enter the full amount of memory based on the SP Flash Tool information. (ie see Figure 207).
  
• You must also rename the section names. To do this, poke the right mouse button on the table and select<Rename section titles ..>(Figure 219)
  *** Note: If this item passes with an error, then the error occurs only on new platforms MT67xx. The thing is that there is a division of memory on EMMC_BOOT_1, EMMC_BOOT_2, EMMC_RPMB, EMMC_USER. All data is stored in EMMC_USER, and Preloader is in EMMC_BOOT_1, and since the image is selected EMMC_USER, then there is no Preloader, you simply need to manually point to the Preloader that you have already pulled (i.e. double-click on the Preloader. ( Figure 219))
  
  Figure 219:
  
  
• You must perform another check on EXT4_IMG. To do this, poke the right mouse button on the table and select<Checks> -><Check for EXT4_IMG>.
  The program looks at the ROM at the start of all partitions and defines the partition on the file system: EXT4_IMG, UBI_IMG, NORMAL_ROM.
  
• Create scatter file:
  Create a scatter file:
  Open the tab:<Scatter of the first version:>, push the button<Create Scatter File>, choose the name and save.
  If the button is not active, then:
  Open the tab:<Scatter version two:>, Check if the program correctly identified the platform (if not correctly, then fix it).
  Push the button<Create Scatter File>, choose the name and save.
  
• Splitting a ROM file into sections:
  Now you need to divide the ROM file into sections, to do this, open the tab<Cut ROM>and press a button<Cut ROM to folder>, we choose the place of conservation and wait for the completion of the separation process.
  
• Use as directed. (Mounting partitions, extracting the data you need, and so on)
  At your choice, other programs. :)

If the device turns on:

If the device turns on, there is no root

If the phone turns on and there is no Root right
So for this we will need to connect the included device to the PC, install the necessarydrivers (VCOM) for phone, and download the program Wwr_mtk
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.

The procedure is as follows:

• 1. In the device, you must activate the developer mode. In developer mode, enable<USB debugging>. Confirm the PC connection to the device, on the device itself.
  
• 2. In the program WwR_MTK get information about the device.
  
• 3. Create an empty scatter file.
  
• 4. In the SP Flash Tool, read the block containing the Preloader.
  
• 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone).
  
• 6. In the program WwR_MTK create scatter file, create firmware.
  
  Attention!!! This method is applicable to devices only on the MTK platform. And having a partition table: Dumchar_info or Partinfo! Be careful. Clause 2.1. this instruction, i.e. below
  
  Now in more detail:
  
• 1. In the device, you must activate the developer mode:
  1.1. Almost everyone knows how to do it, in each device it is done differently, it all depends on the version of Android. So it would be better if you read the profile topic on your device.
  Or, for example: In order to activate the developer mode, go to: "Settings" - "About phone" - click on the build number 7 times. In the developer settings, enable USB debugging. When you connect a USB cable, select Charging Only.
  1.2. If the PC is successfully connected to the device, the device will display a request for actions from the PC;
  
• 2. In the program WwR_MTK get information about the device:
  2.1. In the program WwR_MTK open tab<Adb>push button<To plug>. If the drivers have been installed correctly, the program will see the device and display information about it.
  I repeat again:This method is applicable only to devices on the MTK platform and having a partition table Dumchar_info and Partinfo. See here if there is a partition table (Figure 224).
  
  Picture_224
  
  
• 3. Create an empty scatter file:
  3.1. Go to tab<Autopilot>or<Empty scatter file>, make sure that the platform type is selected correctly, then click on the button<Create and save as ..>(AT<Autopilot>this is the first item).
  
• 4. In the SP Flash Tool, read the block containing the Preloader .:
  4.1. To do this, in the SP Flash Tool, select this empty scatter file in the tab<Download>in field<Scatter-loading>, then go to the tab<ReadBack>Push the button<Add>. A new line will appear below. We click on it twice and select the storage location of the so-called ROM_0 block.
  Push<Save>, then a selection of values ​​appears on which the SP Flash Tool should read the memory from the device (phone or tablet).
  Next, select for EMMC_BOOT_1:
  
  Type - HEX
  Region: - EMMC_BOOT_1, (If there is such a choice), or EMMC_USER.
  Start Address: - choose 0x0000000000000000, that is, the very beginning.
  Lenght: - choose 0x0000000000100000, i.e. length.
  
  In details

  Usually on new platforms (MT67xx and MT6580) the Preloader is in EMMC_BOOT_1, and all other data is in EMMC_USER.
  We need a region with Preloader. It is usually located at the very beginning of the phone’s memory and does not exceed the size in megabytes (I have not seen the Preloader more than 200 Kb).

  1 Megabyte: 1048576 bytes in decimal form
  1 Megabyte: 0x100000 in hexadecimal form
  (0x parameter - indicates that the number is presented in hexadecimal)
  You can specify and:
  512 KB: 0x80000
  256 KB: 0x40000.

  You can specify more than it is, nothing terrible will happen.
  Therefore, in the SP Flash Tool, select the values:

  Where<Start Address:>- choose<0x00000000000000>, ie the very beginning
  and length:<Lenght:> - <0x0000000000100000>
  Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 200, 201).
  
  Figure 200, if the memory in the EMMC device:
  Figure 201, if the memory in the NAND device:
  4.2. If an error occurs (Figure 202), then we change in WwR_MTK the type of processor shown by the SP Flash Tool. Repeat the action from paragraph 4.1.
  
  Figure 202:
  4.3. If an error occurs (Figure 203), then we change the type of memory shown by the SP Flash Tool in WwR_MTK. Repeat the action from paragraph 4.1.
  
  Figure 203:
  4.4. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone):
  5.1. Now you need to read the full backup from the phone.
  5.2. Preferably tab<ReadBack>remove checkbox from ROM_0.
  5.3. Go to the tab<ReadBack>Push the button<Add>. Another line will appear in the table below, just click on it and indicate the location of the file to be saved. Then there is a choice of values ​​by which the SP Flash Tool should read the memory from the device. Choose:
  Type - HEX,
  Region: - EMMC_USER
  Start Address: - choose 0x0000000000000000, that is, the very beginning,
  Lenght: - choose the length 0x ................, which we considered in WwR_MTK in the tab<Adb>In the information field:<Full ROM memory: 0x1D2000000 (7456 MB)>. See Figure 225.
  Figure 225:
  5.4. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208-1).
  
  Figure 208-1:
  5.5. The process of reading the full dump of the phone will go. The process is not fast. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 6. In the program WwR_MTK create a scatter file, create firmware:
  
• 6.1. Option 1: Select the ROM_1 file (EMMC_USER) in<Autopilot>, the instruction is above:
  
• 6.2. Option 2: If there is a partition table (Figure 226).
  Figure 226:
  You can create a scatter file, select a ROM file and create a firmware:
  • To do this in the tab<Adb>there is a tab<List of sections, assemble firmware>- we go there. Push button<List of sections (Dumchar_info)>or<List of sections (Partinfo)>.
    
  • If everything is fine, then you will be on the tab<Scatter file>If there is a need to save only certain sections, then you need to uncheck the boxes that you do not need. Then go back to the tab<Adb>.
    
  • Next, press the button<Select ROM from SPFT>and select ROM_1 (EMMC_USER), if the program requests a file with EMMC_BOOT_1, specify ROM_0 containing the Preloader. The program will perform all necessary actions.
    
  • Next, press the button<Build firmware (backup)>select a folder to save and wait for the program to end.

If everything went well, then you have a full ROM of the entire memory of the device. The assembled firmware, in it the scatter file and all other sections.

The following method is generally a separate instruction, because you can remove backup partitions from any device that has Root rights:
If the device is on your MTK platform, and not one of the instructions above did not help to assemble the firmware, or for some reason cannot work with the SP Flash Tool.
If not MTK, then you can perform a backup of the sections, why they are to you and how you will use them all the same. Everyone decides for himself. At the moment we are talking about backup.
If I have information, how can I continue to use backup from other platforms. I will supplement the instrument and possibly supplement the program.

If the device turns on, root rights are

If the phone turns on and Root rights are there
So for this we will need to connect the included device to the PC, install the necessarydrivers (VCOM) for phone, and download the program Wwr_mtk
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.
And insert the flash memory, any size will fit even 128 megabytes.

The procedure is as follows:

• 1. In the device, you must activate the developer mode. In developer mode, enable<USB debugging>. Confirm the PC connection to the device, on the device itself.
  
• 2. In the program WwR_MTK get information about the device.
  
• 3. In the program WwR_MTK run backup sections.
  
  Now in more detail:
  
• 1. In the device, you must activate the developer mode:
  1.1. Almost everyone knows how to do it, in each device it is done differently, it all depends on the version of Android. So it would be better if you read the profile topic on your device.
  Or, for example: In order to activate the developer mode, go to: "Settings" - "About phone" - click on the build number 7 times. In the developer settings, enable USB debugging. When you connect a USB cable, select Charging Only.
  1.2. If the PC is successfully connected to the device, the device will display a request for actions from the PC;
  
• 2. In the program WwR_MTK get information about the device:
  2.1. In the program WwR_MTK open tab<Adb>push button<To plug>. If the drivers have been installed correctly, the program will see the device and display information about it (Figure 224).
  
  Picture_224
  
  
• 3. In the WwR_MTK program, backup the required partitions:
  3.1. Select a tab<Backup>, we are convinced about the presence of valid root rights.
  3.2. If we do not understand, what is needed<Buffer size>and<Place save buffer>- it is better to leave as the program itself has chosen.
  
  In detail

  The buffer size is needed to read blocks from the device to the size of this buffer, that is, for example: if the System size is 800 MB and the buffer size is 16 MB, the program subtracts 50 blocks from the System section and merges it into one section.
  This is necessary so that the user does not think that the program is frozen. And so that the program itself also did not think that it hangs.
  The place to save the buffer is better to choose a flash drive, in the system it almost always goes like: / sdcard. If the flash drive was not at hand, the device’s internal memory is usually used.
  
  3.3. Choice of method: The program itself chooses a more normal method, so it is better to leave the method chosen by default.
  3.4. Push the button<Prepare and check ..>, The program will do everything automatically, then the tab should open<Scatter file>with the names of sections, their starting positions and lengths, as well as their availability for saving.
  3.5. Next, remove the check boxes from the sections that are not needed for backup.
  3.6. Go to the tab<Adb>and click on the button<Select a folder and start ..>, We choose the place to save the backup, preferably an empty folder, and wait for the completion of the preservation work.
  3.7. If the device is on the MTK platform, you must save the scatter file. Automatically this is not done. So, you need to go to the tab<Scatter file>.
  Open the tab:<Scatter of the first version:>, push the button<Create Scatter File>, choose the name and save.
  If the button is not active, then:
  Open the tab:<Scatter version two:>, Check if the program correctly identified the platform (if not correctly, then fix it).
  Push the button<Create Scatter File>, choose the name and save.
  
  Now more about backup methods:
  
  Method 1 (Dumchar_info)

  For this method, the following commands must be executed in ADB:
  

  • 1. Dumchar_info. Based on this information, the program knows from which position to start copying, the size of the sections and to which block the section belongs:
    >>adb shell cat / proc / dumchar_info
    Part_Name Size StartAddr Type MapTo
    preloader 0x0000000000600000 0x000000000000000000 2 / dev / misc-sd
    mbr 0x0000000000080000 0x000000000000000000 2 / dev / block / mmcblk0
    ebr1 0x0000000000080000 0x0000000000080000 2 / dev / block / mmcblk0p1
    pmt 0x0000000000400000 0x0000000000100000 2 / dev / block / mmcblk0
    pro_info 0x0000000000300000 0x0000000000500000 2 / dev / block / mmcblk0
    nvram 0x0000000000500000 0x0000000000800000 2 / dev / block / mmcblk0
    protect_f 0x0000000000a00000 0x0000000000d00000 2 / dev / block / mmcblk0p2
    protect_s 0x0000000000a00000 0x0000000001700000 2 / dev / block / mmcblk0p3
    seccfg 0x0000000000020000 0x0000000002100000 2 / dev / block / mmcblk0
    uboot 0x0000000000060000 0x0000000002120000 2 / dev / block / mmcblk0
    bootimg 0x0000000000600000 0x0000000002180000 2 / dev / block / mmcblk0
    recovery 0x0000000000600000 0x0000000002780000 2 / dev / block / mmcblk0
    sec_ro 0x0000000000600000 0x0000000002d80000 2 / dev / block / mmcblk0p4
    misc 0x0000000000080000 0x0000000003380000 2 / dev / block / mmcblk0
    logo 0x0000000000300000 0x0000000003400000 2 / dev / block / mmcblk0
    ebr2 0x0000000000080000 0x0000000003700000 2 / dev / block / mmcblk0
    expdb 0x0000000000a00000 0x0000000003780000 2 / dev / block / mmcblk0
    android 0x0000000028a00000 0x0000000004180000 2 / dev / block / mmcblk0p5
    cache 0x0000000007e00000 0x000000002cb80000 2 / dev / block / mmcblk0p6
    usrdata 0x0000000040000000 0x0000000034980000 2 / dev / block / mmcblk0p7
    fat 0x0000000071180000 0x0000000074980000 2 / dev / block / mmcblk0p8
    bmtpool 0x0000000001500000 0x00000000ff9f00a8 2 / dev / block / mmcblk0
    Part_Name: Partition name you should open;
    Size: size of partition
    StartAddr: Start Address of partition;
    Type: Type of partition (MTD = 1, EMMC = 2)
    MapTo: actual device you operate
    
    
  • 2. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>adb shell getprop
    [curlockscreen]: [1]
    [dalvik.vm.heapgrowthlimit]: [128m]
    [dalvik.vm.heapsize]: [256m]
    [dalvik.vm.mtk-stack-trace-file]: [/data/anr/mtk_traces.txt]
    [dalvik.vm.stack-trace-file]: [/data/anr/traces.txt]
    [debug.MB.running]: [0]
    [debug.log2sd.defaultpath]: [/ mnt / sdcard]
    [debug.mtklog.netlog.Running]: [0]
    [dev.bootcomplete]: [1]
    [dhcp.ipv6.wlan0.dns1]: [fe80 :: 1]
    [dhcp.ipv6.wlan0.dns2]: []
    [dhcp.ipv6.wlan0.ipaddress]: []
    [dhcp.ipv6.wlan0.leasetime]: []
    [dhcp.ipv6.wlan0.reason]: [INFOREQ]
    [dhcp.ipv6.wlan0.result]: [ok]
    [dhcp.wlan0.dns1]: [192.168.1.1]
    [dhcp.wlan0.dns2]: []
    [dhcp.wlan0.dns3]: []
    [dhcp.wlan0.dns4]: []
    [dhcp.wlan0.gateway]: [192.168.1.1]
    [dhcp.wlan0.ipaddress]: [192.168.1.151]
    [dhcp.wlan0.leasetime]: [86400]
    [dhcp.wlan0.mask]: [255.255.255.0]
    [dhcp.wlan0.pid]: [930]
    [dhcp.wlan0.reason]: [REBOOT]
    [dhcp.wlan0.result]: [ok]
    [dhcp.wlan0.server]: [192.168.1.1]
    [dhcp.wlan0.vendorInfo]: []
    [drm.service.enabled]: [true]
    [external_sd_path]: [/ storage / sdcard1]
    [fmradio.driver.chip]: [3]
    [fmradio.driver.enable]: [1]
    [gps.solution.combo.chip]: [1]
    [gsm.3gswitch]: [1]
    [gsm.baseband.capability2]: [3]
    [gsm.baseband.capability]: [55]
    [gsm.current.phone-type]: [1]
    [gsm.gcf.testmode]: [0]
    [gsm.network.type]: [unknown]
    [gsm.operator.alpha.2]: []
    [gsm.operator.alpha]: []
    [gsm.operator.iso-country.2]: []
    [gsm.operator.iso-country]: []
    [gsm.operator.isroaming.2]: [false]
    [gsm.operator.isroaming]: [false]
    [gsm.operator.numeric.2]: []
    [gsm.operator.numeric]: []
    [gsm.phone.created]: [true]
    [gsm.project.baseband.2]: [HEDY89_WE_JB2_MD1_HSPA_HW (DEFAULT)]
    [gsm.project.baseband]: [HEDY89_WE_JB2_MD1_HSPA_HW (DEFAULT)]
    [gsm.roaming.indicator.needed.2]: [false]
    [gsm.roaming.indicator.needed]: [false]
    [gsm.serial]: [10]
    [gsm.sim.inserted]: [0]
    [gsm.sim.ril.phbready.2]: [true]
    [gsm.sim.ril.phbready]: [false]
    [gsm.sim.state.2]: [ABSENT]
    [gsm.sim.state]: [ABSENT]
    [gsm.siminfo.ready]: [true]
    [gsm.version.baseband]: [MOLY.WR8.W1248.MD.WG.MP.V6, 2013/05/08 11:19]
    [gsm.version.ril-impl]: [mtk gemini ril 1.0]
    [init.svc.662x_launcher]: [running]
    [init.svc.DMAgent]: [running]
    [init.svc.GoogleOtaAgent]: [running]
    [init.svc.NvRAMAgent]: [running]
    [init.svc.adbd]: [running]
    [init.svc.agpsd]: [running]
    [init.svc.bootanim]: [stopped]
    [init.svc.bootlogoupdater]: [stopped]
    [init.svc.ccci2_fsd]: [stopped]
    [init.svc.ccci2_mdinit]: [stopped]
    [init.svc.ccci_fsd]: [running]
    [init.svc.ccci_mdinit]: [running]
    [init.svc.dbus]: [running]
    [init.svc.debuggerd]: [running]
    [init.svc.dhcp6cDNS_wlan0]: [running]
    [init.svc.dhcpcd_wlan0]: [running]
    [init.svc.dpfd]: [running]
    [init.svc.drm]: [running]
    [init.svc.flash_recovery]: [stopped]
    [init.svc.gsm0710muxd]: [running]
    [init.svc.hald]: [running]
    [init.svc.installd]: [running]
    [init.svc.keystore]: [running]
    [init.svc.matv]: [running]
    [init.svc.mdlogger]: [running]
    [init.svc.media]: [running]
    [init.svc.mobile_log_d]: [running]
    [init.svc.msensord]: [stopped]
    [init.svc.mtkGD]: [running]
    [init.svc.mtkbt]: [running]
    [init.svc.netd]: [running]
    [init.svc.netdiag]: [running]
    [init.svc.nvram_daemon]: [stopped]
    [init.svc.p2p_supplicant]: [running]
    [init.svc.permission_check]: [stopped]
    [init.svc.poad]: [stopped]
    [init.svc.pq]: [stopped]
    [init.svc.pvrsrvctl]: [stopped]
    [init.svc.ril-daemon]: [running]
    [init.svc.sbchk]: [stopped]
    [init.svc.servicemanager]: [running]
    [init.svc.stp_dump]: [running]
    [init.svc.surfaceflinger]: [running]
    [init.svc.thermal]: [running]
    [init.svc.thermal_manager]: [stopped]
    [init.svc.ueventd]: [running]
    [init.svc.vold]: [running]
    [init.svc.vtservice]: [running]
    [init.svc.wlanLoader]: [stopped]
    [init.svc.xlogboot]: [stopped]
    [init.svc.xlogdebug changes]: [stopped]
    [init.svc.zygote]: [running]
    [internal_sd_path]: [/ storage / sdcard0]
    [launcher2.allappsgrid]: [3d_20]
    [launcherplus.allappsgrid]: [2d]
    [mediatek.wlan.chip]: [MT6628]
    [mediatek.wlan.ctia]: [0]
    [mediatek.wlan.module.postfix]: [_mt6628]
    [mux.report.case]: [0]
    [net.bt.name]: [Android]
    [net.change]: [net.dnschange]
    [net.dns1]: [192.168.1.1]
    [net.dnschange]: [2]
    [net.hostname]: [android-c17da8d956f3a9f8]
    [net.ipv6.dns1]: [fe80 :: 928d: 78ff: fe0a: 7480]
    [net.qtaguid_enabled]: [1]
    [net.tcp.buffersize.default]: [4096,87380,110208,4096,16384,110208]
    [net.tcp.buffersize.edge]: [4093,26280,35040,4096,16384,35040]
    [net.tcp.buffersize.evdo]: [4094,87380,262144,4096,16384,262144]
    [net.tcp.buffersize.gprs]: [4092,8760,11680,4096,8760,11680]
    [net.tcp.buffersize.hsdpa]: [4094,87380,262144,4096,16384,262144]
    [net.tcp.buffersize.hspa]: [4094,87380,262144,4096,16384,262144]
    [net.tcp.buffersize.hspap]: [4094,87380,1220608,4096,16384,1220608]
    [net.tcp.buffersize.hsupa]: [4094,87380,262144,4096,16384,262144]
    [net.tcp.buffersize.lte]: [524288,1048576,2097152,262144,524288,1048576]
    [net.tcp.buffersize.umts]: [4094,87380,110208,4096,16384,110208]
    [net.tcp.buffersize.wifi]: [524288,1048576,2097152,262144,524288,1048576]
    [net.wlan0.dns1]: [49.0.0.0]
    [net.wlan0.dns2]: []
    [nvram_init]: [Ready]
    [persist.first_boot]: [0]
    [persist.mtk.aee.aed]: [on]
    [persist.mtk.wcn.combo.chipid]: [0x6628]
    [persist.radio.default_sim]: [0]
    [persist.radio.default_sim_mode]: [12]
    [persist.radio.fd.counter]: [15]
    [persist.radio.fd.off.counter]: [5]
    [persist.radio.fd.off.r8.counter]: [5]
    [persist.radio.fd.r8.counter]: [15]
    [persist.service.acm.enable]: []
    [persist.service.adb.enable]: []
    [persist.sys.country]: [RU]
    [persist.sys.first_time_boot]: [false]
    [persist.sys.language]: [ru]
    [persist.sys.launcher-reset]: [2]
    [persist.sys.localevar]: []
    [persist.sys.mute.state]: [2]
    [persist.sys.profiler_ms]: [0]
    [persist.sys.screen.size]: [800x480]
    [persist.sys.sd.defaultpath]: [/ storage / sdcard0]
    [persist.sys.timezone]: [Asia / Shanghai]
    [persist.sys.usb.config]: [mass_storage, adb]
    [ril.current.share_modem]: [2]
    [ril.external.md]: [0]
    [ril.fd.mode]: [1]
    [ril.first.md]: [1]
    [ril.flightmode.poweroffMD]: [1]
    [ril.iccid.sim1]: [N / A]
    [ril.iccid.sim2]: [N / A]
    [ril.radiooff.poweroffMD]: [0]
    [ril.ready.sim]: [false]
    [ril.specific.sm_cause]: [0]
    [ril.telephony.mode]: [1]
    [rild.libargs]: [-d / dev / ttyC0]
    [rild.libpath]: [/system/lib/mtk-ril.so]
    [ro.allow.mock.location]: [0]
    [ro.audio.silent]: [0]
    [ro.baseband]: [unknown]
    [ro.board.platform]: [exynos5]
    [ro.boot.serialno]: [0123456789ABCDEF]
    [ro.bootloader]: [unknown]
    [ro.bootmode]: [unknown]
    [ro.build.characteristics]: [default]
    [ro.build.date.utc]: [1373287134]
    [ro.build.date]: [2013 年 07 月 08 日 �期一 20:38:54 CST]
    [ro.build.description]: [ja3gzs-user 4.2.2 JDQ39 I9500ZSUAMDE release-keys]
    [ro.build.display.id]: [JDQ39.I9500ZSUAMDF]
    [ro.build.fingerprint]: [samsung / ja3gzs / ja3g: 4.2.2 / JDQ39 / I9500ZSUAMDE: user / release-keys]
    [ro.build.flavor]: []
    [ro.build.host]: [SEP-92]
    [ro.build.id]: [JDQ39]
    [ro.build.product]: [ja3gzs]
    [ro.build.tags]: [test-keys]
    [ro.build.type]: [user]
    [ro.build.user]: [se.infra]
    [ro.build.version.codename]: [REL]
    [ro.build.version.incremental]: [I9500ZSUAMDF]
    [ro.build.version.release]: [4.2.9]
    [ro.build.version.sdk]: [17]
    [ro.camera.sound.forced]: [0]
    [ro.config.alarm_alert]: [Good_Morning.ogg]
    [ro.config.notification_sound]: [S_Whistle.ogg]
    [ro.config.ringtone]: [S_Over_the_horizon.ogg]
    [ro.crypto.fs_flags]: [0x00000406]
    [ro.crypto.fs_mnt_point]: [/ data]
    [ro.crypto.fs_options]: [noauto_da_alloc, discard]
    [ro.crypto.fs_real_blkdev]: [/ emmc @ usrdata]
    [ro.crypto.fs_type]: [ext4]
    [ro.crypto.state]: [unencrypted]
    [ro.custom.build.version]: [I9868.I9868.02.02.A.A-V05.3-0708]
    [ro.debuggable]: [0]
    [ro.factorytest]: [0]
    [ro.hardware]: [universal5410]
    [ro.mediatek.chip_ver]: [S01]
    [ro.mediatek.gemini_support]: [true]
    [ro.mediatek.platform]: [MT6589]
    [ro.mediatek.version.branch]: [ALPS.JB2.MP]
    [ro.mediatek.version.release]: [ALPS.JB2.MP.V1.2]
    [ro.mediatek.wlan.p2p]: [1]
    [ro.mediatek.wlan.wsc]: [1]
    [ro.mount.fs]: [EXT4]
    [ro.mtprof.disable]: [1]
    [ro.opengles.version]: [131072]
    [ro.product.board]: [smdk4x12]
    [ro.product.brand]: [samsung]
    [ro.product.cpu.abi2]: [armeabi]
    [ro.product.cpu.abi]: [armeabi-v7a]
    [ro.product.device]: [t03g]
    [ro.product.locale.language]: [en]
    [ro.product.locale.region]: [US]
    [ro.product.manufacturer]: [samsung]
    [ro.product.model]: [GT-I9500]
    [ro.product.name]: [t03gzs]
    [ro.revision]: [0]
    [ro.runtime.firstboot]: [1522389798976]
    [ro.secure]: [1]
    [ro.serialno]: [0123456789ABCDEF]
    [ro.sf.hwrotation]: [0]
    [ro.sf.lcd_density]: [240]
    [ro.sys.usb.bicr]: [yes]
    [ro.sys.usb.charging.only]: [yes]
    [ro.sys.usb.mtp.whql.enable]: [0]
    [ro.sys.usb.storage.type]: [mtp, mass_storage]
    [ro.wifi.channels]: []
    [ro.zygote.preload.enable]: [0]
    [service.bootanim.exit]: [1]
    [supolicy.loaded]: [1]
    [sys.boot.reason]: [0]
    [sys.boot_completed]: [1]
    [sys.ipo.pwrdncap]: [2]
    [sys.ipowin.done]: [1]
    [sys.settings_system_version]: [2]
    [sys.usb.config]: [mass_storage, adb]
    [sys.usb.state]: [mass_storage, adb]
    [sys.usb.vid]: [0BB4]
    [system_init.startsurfaceflinger]: [0]
    [vold.post_fs_data_done]: [1]
    [vold_swap_state]: [0]
    [wifi.direct.interface]: [p2p0]
    [wifi.interface]: [wlan0]
    [wifi.tethering.interface]: [ap0]
    [wlan.driver.status]: [ok]
    
    
  • 3. Next, the program checks each section for accessibility:
    >>adb shell ls -l / dev / preloader
    crw-r ----- root system 234, 0 2018-03-30 14:02 preloader
    
    >>adb shell ls -l / dev / mbr
    crw ------- root root 234, 1 2018-03-30 14:02 mbr
    
    >>adb shell ls -l / dev / block / mmcblk0p1
    brw ------- root root 179, 1 2018-03-30 14:02 mmcblk0p1
    
    >>adb shell ls -l / dev / pmt
    crw ------- root root 234, 3 2018-03-30 14:02 pmt
    
    >>adb shell ls -l / dev / pro_info
    crw-rw ---- root system 234, 4 2018-03-30 14:02 pro_info
    
    >>adb shell ls -l / dev / nvram
    crw-rw ---- root system 234, 5 2018-03-30 14:02 nvram
    
    >>adb shell ls -l / dev / block / mmcblk0p2
    brw-r ----- root system 179, 2 2018-03-30 14:02 mmcblk0p2
    
    >>adb shell ls -l / dev / block / mmcblk0p3
    brw ------- root root 179, 3 2018-03-30 14:02 mmcblk0p3
    
    >>adb shell ls -l / dev / seccfg
    crw-rw ---- root system 234, 8 2018-03-30 14:02 seccfg
    
    >>adb shell ls -l / dev / uboot
    crw ------- root root 234, 9 2018-03-30 14:02 uboot
    
    >>adb shell ls -l / dev / bootimg
    crw-r ----- root system 234, 10 2018-03-30 14:02 bootimg
    
    >>adb shell ls -l / dev / recovery
    crw-r ----- root system 234, 11 2018-03-30 14:02 recovery
    
    >>adb shell ls -l / dev / block / mmcblk0p4
    brw ------- root root 179, 4 2018-03-30 14:02 mmcblk0p4
    
    >>adb shell ls -l / dev / misc
    crw-rw ---- root system 234, 13 2018-03-30 14:02 misc
    
    >>adb shell ls -l / dev / logo
    crw ------- root root 234, 14 2018-03-30 14:02 logo
    
    >>adb shell ls -l / dev / ebr2
    crw ------- root root 234, 15 2018-03-30 14:02 ebr2
    
    >>adb shell ls -l / dev / expdb
    crw ------- root root 234, 16 2018-03-30 14:02 expdb
    
    >>adb shell ls -l / dev / block / mmcblk0p5
    brw ------- root root 179, 5 2018-03-30 14:02 mmcblk0p5
    
    >>adb shell ls -l / dev / block / mmcblk0p6
    brw ------- root root 179, 6 2018-03-30 14:02 mmcblk0p6
    
    >>adb shell ls -l / dev / block / mmcblk0p7
    brw ------- root root 179, 7 2018-03-30 14:02 mmcblk0p7
    
    >>adb shell ls -l / dev / block / mmcblk0p8
    brw ------- root root 179, 8 2018-03-30 14:02 mmcblk0p8
    
    >>adb shell ls -l / dev / bmtpool
    crw ------- root root 234, 21 2018-03-30 14:02 bmtpool
    
    
  • 4. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 5. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
  Method 2 (Full_ROM)

  For this method, the presence of a block - mmcblk0:
  

  • The method is not done to the end, and it simply copies the mmcblk0 block in stages, dividing it into blocks.

  
  
  Method 3 (Partinfo, Partitions, emmc)

  For this method, the following commands must be executed in ADB:
  

  • 1. Partinfo.
    >>adb shell cat / proc / partinfo
    Name Start Size
    pgpt 0x0000000000000000 0x0000000000080000
    proinfo 0x0000000000800000 0x0000000000680000
    nvram 0x0000000000e80000 0x0000000000500500000
    protect1 0x0000000001380000 0x0000000000a00000
    protect2 0x0000000001d80000 0x0000000000a00000
    para 0x0000000002780000 0x0000000000080000
    lk 0x0000000002800000 0x0000000000800000
    logo 0x0000000003000000 0x0000000000800000
    boot 0x0000000003800000 0x0000000001000000
    recovery 0x0000000004800000 0x0000000001000000
    oemkeystore 0x0000000005800000 0x0000000000800000
    secro 0x0000000006000000 0x0000000000800000
    keystore 0x0000000006800000 0x0000000000800000
    custpack 0x0000000007000000 0x0000000038000000
    seccfg 0x000000003f000000 0x0000000000800000
    expdb 0x000000003f800000 0x0000000001000000
    mobile_info 0x0000000040800000 0x0000000000800000
    frp 0x0000000041000000 0x0000000000800000
    nvdata 0x0000000041800000 0x0000000002000000
    metadata 0x0000000043800000 0x0000000002000000
    system 0x0000000045800000 0x000000004e800000
    cache 0x0000000094000000 0x0000000007000000
    userdata 0x000000009b000000 0x0000000133480000
    otp 0x00000001ce480000 0x0000000002b00000
    flashinfo 0x00000001d0f80000 0x0000000001000000
    sgpt 0x00000001d1f80000 0x0000000000080000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    254 0 499712 zram0
    7 0 21796 loop0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 917504 mmcblk0p13
    179 14 8192 mmcblk0p14
    179 15 16384 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 8192 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 32768 mmcblk0p19
    179 20 1286144 mmcblk0p20
    179 21 114688 mmcblk0p21
    179 22 5034496 mmcblk0p22
    179 23 44032 mmcblk0p23
    179 24 16384 mmcblk0p24
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    
    
  • 3. Emmc.
    >>adb shell cat / proc / emmc
    partno: start_sect nr_sects partition_name
    emmc_p1: 00004000 00003400 "proinfo"
    emmc_p2: 00007400 00002800 "nvram"
    emmc_p3: 00009c00 00005000 "protect1"
    emmc_p4: 0000ec00 00005000 "protect2"
    emmc_p5: 00013c00 00000400 "para"
    emmc_p6: 00014000 00004000 "lk"
    emmc_p7: 00018000 00004000 "logo"
    emmc_p8: 0001c000 00008000 "boot"
    emmc_p9: 00024000 00008000 "recovery"
    emmc_p10: 0002c000 00004000 "oemkeystore"
    emmc_p11: 00030000 00004000 "secro"
    emmc_p12: 00034000 00004000 "keystore"
    emmc_p13: 00038000 001c0000 "custpack"
    emmc_p14: 001f8000 00004000 "seccfg"
    emmc_p15: 001fc000 00008000 "expdb"
    emmc_p16: 00204000 00004000 "mobile_info"
    emmc_p17: 00208000 00004000 "frp"
    emmc_p18: 0020c000 00010000 "nvdata"
    emmc_p19: 0021c000 00010000 "metadata"
    emmc_p20: 0022c000 00274000 "system"
    emmc_p21: 004a0000 00038000 "cache"
    emmc_p22: 004d8000 0099a400 "userdata"
    emmc_p23: 00e72400 00015800 "otp"
    emmc_p24: 00e87c00 00008000 "flashinfo"
    
    
  • 4. The program itself connects information from all three conclusions, checks the sizes of blocks, the names of sections.
    
  • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 6. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>adb shell getprop
    [ro.sf.hwrotation]: [0]
    [ro.sf.lcd_density]: [320]
    [ro.adb.secure]: [1]
    [ro.apn.presetapn.edit.flag]: [true]
    [ro.com.idea.SP.call]: [false]
    [ro.com.google.gmsversion]: [5.1_r2]
    [ro.com.google.clientidbase]: [android-alcatel]
    [ro.com.google.clientidbase.am]: [android-alcatel]
    [ro.com.google.clientidbase.ms]: [android-alcatel]
    [ro.com.google.clientidbase.yt]: [android-alcatel]
    [ro.com.google.clientidbase.gmm]: [android-alcatel]
    [ro.com.android.dateformat]: [MM-dd-yyyy]
    [ro.com.android.mobiledata]: [false]
    [ro.com.android.dataroaming]: [0]
    [ro.com.android.dataroaming2]: [0]
    [ro.def.mms.autolink.extra]: [0]
    [ro.def.svn.countrycode]: []
    [ro.def.show.sim.change.dialog]: [true]
    [ro.def.show.plmn]: [1]
    [ro.def.russia.num.match.rule]: [0]
    [ro.def.browser]: [0]
    [ro.def.software.svn]: [01001]
    [ro.def.software.version]: [01001]
    [ro.def.phonenumber.Telstra]: [false]
    [ro.def.TelephonyProvider.match]: [0]
    [ro.dtv.support]: [false]
    [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
    [ro.oma.cp.authen_mandatory]: [true]
    [ro.oma.cp.userpin_acceptable]: [true]
    [ro.ssv.enabled]: [false]
    [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
    [ro.ssv.config_operator]: [none]
    [ro.ssv.diag_sel_config]: [1]
    [ro.sys.usb.mtp.whql.enable]: [0]
    [ro.sys.usb.bicr]: [yes]
    [ro.sys.usb.storage.type]: [mtp, mass_storage]
    [ro.sys.usb.charging.only]: [yes]
    [ro.boot.hardware]: [mt6580]
    [ro.boot.serialno]: [65TW556D99999999 [128m]]
    
    

  
  
  Method 4 (Partinfo, Partitions, Auto)

  For this method, the following commands must be executed in ADB:
  

  • 1. Partinfo.
    >>adb shell cat / proc / partinfo
    Name Start Size
    pgpt 0x0000000000000000 0x0000000000080000
    proinfo 0x0000000000800000 0x0000000000680000
    nvram 0x0000000000e80000 0x0000000000500500000
    protect1 0x0000000001380000 0x0000000000a00000
    protect2 0x0000000001d80000 0x0000000000a00000
    para 0x0000000002780000 0x0000000000080000
    lk 0x0000000002800000 0x0000000000800000
    logo 0x0000000003000000 0x0000000000800000
    boot 0x0000000003800000 0x0000000001000000
    recovery 0x0000000004800000 0x0000000001000000
    oemkeystore 0x0000000005800000 0x0000000000800000
    secro 0x0000000006000000 0x0000000000800000
    keystore 0x0000000006800000 0x0000000000800000
    custpack 0x0000000007000000 0x0000000038000000
    seccfg 0x000000003f000000 0x0000000000800000
    expdb 0x000000003f800000 0x0000000001000000
    mobile_info 0x0000000040800000 0x0000000000800000
    frp 0x0000000041000000 0x0000000000800000
    nvdata 0x0000000041800000 0x0000000002000000
    metadata 0x0000000043800000 0x0000000002000000
    system 0x0000000045800000 0x000000004e800000
    cache 0x0000000094000000 0x0000000007000000
    userdata 0x000000009b000000 0x0000000133480000
    otp 0x00000001ce480000 0x0000000002b00000
    flashinfo 0x00000001d0f80000 0x0000000001000000
    sgpt 0x00000001d1f80000 0x0000000000080000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    254 0 499712 zram0
    7 0 21796 loop0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 917504 mmcblk0p13
    179 14 8192 mmcblk0p14
    179 15 16384 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 8192 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 32768 mmcblk0p19
    179 20 1286144 mmcblk0p20
    179 21 114688 mmcblk0p21
    179 22 5034496 mmcblk0p22
    179 23 44032 mmcblk0p23
    179 24 16384 mmcblk0p24
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    
    
  • 3. The program itself connects information from all two conclusions, checks the size of blocks, the names of sections.
    
  • 4. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 5. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 6. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>adb shell getprop
    [ro.sf.hwrotation]: [0]
    [ro.sf.lcd_density]: [320]
    [ro.adb.secure]: [1]
    [ro.apn.presetapn.edit.flag]: [true]
    [ro.com.idea.SP.call]: [false]
    [ro.com.google.gmsversion]: [5.1_r2]
    [ro.com.google.clientidbase]: [android-alcatel]
    [ro.com.google.clientidbase.am]: [android-alcatel]
    [ro.com.google.clientidbase.ms]: [android-alcatel]
    [ro.com.google.clientidbase.yt]: [android-alcatel]
    [ro.com.google.clientidbase.gmm]: [android-alcatel]
    [ro.com.android.dateformat]: [MM-dd-yyyy]
    [ro.com.android.mobiledata]: [false]
    [ro.com.android.dataroaming]: [0]
    [ro.com.android.dataroaming2]: [0]
    [ro.def.mms.autolink.extra]: [0]
    [ro.def.svn.countrycode]: []
    [ro.def.show.sim.change.dialog]: [true]
    [ro.def.show.plmn]: [1]
    [ro.def.russia.num.match.rule]: [0]
    [ro.def.browser]: [0]
    [ro.def.software.svn]: [01001]
    [ro.def.software.version]: [01001]
    [ro.def.phonenumber.Telstra]: [false]
    [ro.def.TelephonyProvider.match]: [0]
    [ro.dtv.support]: [false]
    [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
    [ro.oma.cp.authen_mandatory]: [true]
    [ro.oma.cp.userpin_acceptable]: [true]
    [ro.ssv.enabled]: [false]
    [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
    [ro.ssv.config_operator]: [none]
    [ro.ssv.diag_sel_config]: [1]
    [ro.sys.usb.mtp.whql.enable]: [0]
    [ro.sys.usb.bicr]: [yes]
    [ro.sys.usb.storage.type]: [mtp, mass_storage]
    [ro.sys.usb.charging.only]: [yes]
    [ro.boot.hardware]: [mt6580]
    [ro.boot.serialno]: [65TW556D99999999 [128m]]
  Method 5 (Partinfo, Partitions, by-name)

  For this method, the following commands must be executed in ADB:
  

  • 1. Partinfo.
    >>adb shell cat / proc / partinfo
    Name Start Size
    pgpt 0x0000000000000000 0x0000000000080000
    proinfo 0x0000000000800000 0x0000000000680000
    nvram 0x0000000000e80000 0x0000000000500500000
    protect1 0x0000000001380000 0x0000000000a00000
    protect2 0x0000000001d80000 0x0000000000a00000
    para 0x0000000002780000 0x0000000000080000
    lk 0x0000000002800000 0x0000000000800000
    logo 0x0000000003000000 0x0000000000800000
    boot 0x0000000003800000 0x0000000001000000
    recovery 0x0000000004800000 0x0000000001000000
    oemkeystore 0x0000000005800000 0x0000000000800000
    secro 0x0000000006000000 0x0000000000800000
    keystore 0x0000000006800000 0x0000000000800000
    custpack 0x0000000007000000 0x0000000038000000
    seccfg 0x000000003f000000 0x0000000000800000
    expdb 0x000000003f800000 0x0000000001000000
    mobile_info 0x0000000040800000 0x0000000000800000
    frp 0x0000000041000000 0x0000000000800000
    nvdata 0x0000000041800000 0x0000000002000000
    metadata 0x0000000043800000 0x0000000002000000
    system 0x0000000045800000 0x000000004e800000
    cache 0x0000000094000000 0x0000000007000000
    userdata 0x000000009b000000 0x0000000133480000
    otp 0x00000001ce480000 0x0000000002b00000
    flashinfo 0x00000001d0f80000 0x0000000001000000
    sgpt 0x00000001d1f80000 0x0000000000080000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    254 0 499712 zram0
    7 0 21796 loop0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 917504 mmcblk0p13
    179 14 8192 mmcblk0p14
    179 15 16384 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 8192 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 32768 mmcblk0p19
    179 20 1286144 mmcblk0p20
    179 21 114688 mmcblk0p21
    179 22 5034496 mmcblk0p22
    179 23 44032 mmcblk0p23
    179 24 16384 mmcblk0p24
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    
    
  • 3. The program is looking for a folder (directory) named<by-name>after folder (directory)</ dev / block>. It has an approximate conclusion:
    >>adb shell ls -l / dev / block
    / dev / block: Permission denied
    
    >>adb shell su -c ls -l / dev / block
    brw ------- root root 253, 0 2015-01-26 16:07 dm-0
    brw ------- root root 7, 0 2015-01-26 16:07 loop0
    brw ------- root root 7, 1 2015-01-26 16:07 loop1
    brw ------- root root 7, 2 2015-01-26 16:07 loop2
    brw ------- root root 7, 3 2015-01-26 16:07 loop3
    brw ------- root root 7, 4 2015-01-26 16:07 loop4
    brw ------- root root 7, 5 2015-01-26 16:07 loop5
    brw ------- root root 7, 6 2015-01-26 16:07 loop6
    brw ------- root root 7, 7 2015-01-26 16:07 loop7
    brw-rw ---- root system 179, 0 2015-01-26 16:07 mmcblk0
    brw-rw ---- root system 179, 32 2015-01-26 16:07 mmcblk0boot0
    brw-rw ---- root system 179, 64 2015-01-26 16:07 mmcblk0boot1
    brw-rw ---- root system 179, 1 2015-01-26 16:07 mmcblk0p1
    brw ------- root root 179, 10 2015-01-26 16:07 mmcblk0p10
    brw-r ----- root system 179, 11 2015-01-26 16:07 mmcblk0p11
    brw ------- root root 179, 12 2015-01-26 16:07 mmcblk0p12
    brw-rw ---- root system 179, 13 2015-01-26 16:07 mmcblk0p13
    brw ------- root root 179, 14 2015-01-26 16:07 mmcblk0p14
    brw ------- root root 179, 15 2015-01-26 16:07 mmcblk0p15
    brw-rw ---- root system 179, 16 2015-01-26 16:08 mmcblk0p16
    brw ------- root root 179, 17 2015-01-26 16:07 mmcblk0p17
    brw ------- root root 179, 18 2015-01-26 16:07 mmcblk0p18
    brw ------- root root 179, 19 2015-01-26 16:07 mmcblk0p19
    brw-rw ---- root system 179, 2 2015-01-26 16:07 mmcblk0p2
    brw ------- root root 179, 20 2015-01-26 16:07 mmcblk0p20
    brw ------- root root 179, 21 2015-01-26 16:07 mmcblk0p21
    brw-r ----- root system 179, 22 2015-01-26 16:07 mmcblk0p22
    brw ------- root root 179, 23 2015-01-26 16:07 mmcblk0p23
    brw ------- root root 179, 3 2015-01-26 16:07 mmcblk0p3
    brw ------- root root 179, 4 2015-01-26 16:07 mmcblk0p4
    brw-rw ---- root system 179, 5 2015-01-26 16:07 mmcblk0p5
    brw ------- root root 179, 6 2015-01-26 16:07 mmcblk0p6
    brw-r ----- root system 179, 7 2015-01-26 16:07 mmcblk0p7
    brw-r ----- root system 179, 8 2015-01-26 16:07 mmcblk0p8
    brw-r ----- root system 179, 9 2015-01-26 16:07 mmcblk0p9
    brw ------- root root 179, 96 2015-01-26 16:07 mmcblk0rpmb
    drwxr-xr-x root root 2015-01-26 16:07 platform
    drwx ------ root root 2015-01-26 16:07 vold
    brw ------- root root 254, 0 2015-01-26 16:07 zram0
    
    >>adb shell su -c ls -l / dev / block / platform
    drwxr-xr-x root root 2015-01-26 16:07 mtk-msdc.0
    
    >>adb shell su -c ls -l / dev / block / vold
    
    >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0
    drwxr-xr-x root root 2015-01-26 16:07 11120000.msdc0
    
    >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0
    drwxr-xr-x root root 2015-01-26 16:07 by-name
    drwxr-xr-x root root 2015-01-26 16:07 by-num
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0 ->/ dev / block / mmcblk0
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot0 ->/ dev / block / mmcblk0boot0
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot1 ->/ dev / block / mmcblk0boot1
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p1 ->/ dev / block / mmcblk0p1
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p10 ->/ dev / block / mmcblk0p10
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p11 ->/ dev / block / mmcblk0p11
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p12 ->/ dev / block / mmcblk0p12
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p13 ->/ dev / block / mmcblk0p13
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p14 ->/ dev / block / mmcblk0p14
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p15 ->/ dev / block / mmcblk0p15
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p16 ->/ dev / block / mmcblk0p16
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p17 ->/ dev / block / mmcblk0p17
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p18 ->/ dev / block / mmcblk0p18
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p19 ->/ dev / block / mmcblk0p19
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p2 ->/ dev / block / mmcblk0p2
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p20 ->/ dev / block / mmcblk0p20
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p21 ->/ dev / block / mmcblk0p21
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p22 ->/ dev / block / mmcblk0p22
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p23 ->/ dev / block / mmcblk0p23
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p3 ->/ dev / block / mmcblk0p3
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p4 ->/ dev / block / mmcblk0p4
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p5 ->/ dev / block / mmcblk0p5
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p6 ->/ dev / block / mmcblk0p6
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p7 ->/ dev / block / mmcblk0p7
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p8 ->/ dev / block / mmcblk0p8
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p9 ->/ dev / block / mmcblk0p9
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0rpmb ->/ dev / block / mmcblk0rpmb
    
    >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0/by-name
    lrwxrwxrwx root root 2015-01-26 16:07 boot ->/ dev / block / mmcblk0p8
    lrwxrwxrwx root root 2015-01-26 16:07 cache ->/ dev / block / mmcblk0p20
    lrwxrwxrwx root root 2015-01-26 16:07 expdb ->/ dev / block / mmcblk0p14
    lrwxrwxrwx root root 2015-01-26 16:07 flashinfo ->/ dev / block / mmcblk0p23
    lrwxrwxrwx root root 2015-01-26 16:07 frp ->/ dev / block / mmcblk0p16
    lrwxrwxrwx root root 2015-01-26 16:07 keystore ->/ dev / block / mmcblk0p12
    lrwxrwxrwx root root 2015-01-26 16:07 lk ->/ dev / block / mmcblk0p6
    lrwxrwxrwx root root 2015-01-26 16:07 logo ->/ dev / block / mmcblk0p7
    lrwxrwxrwx root root 2015-01-26 16:07 metadata ->/ dev / block / mmcblk0p18
    lrwxrwxrwx root root 2015-01-26 16:07 mobile_info ->/ dev / block / mmcblk0p15
    lrwxrwxrwx root root 2015-01-26 16:07 nvdata ->/ dev / block / mmcblk0p17
    lrwxrwxrwx root root 2015-01-26 16:07 nvram ->/ dev / block / mmcblk0p2
    lrwxrwxrwx root root 2015-01-26 16:07 oemkeystore ->/ dev / block / mmcblk0p10
    lrwxrwxrwx root root 2015-01-26 16:07 otp ->/ dev / block / mmcblk0p22
    lrwxrwxrwx root root 2015-01-26 16:07 para ->/ dev / block / mmcblk0p5
    lrwxrwxrwx root root 2015-01-26 16:07 proinfo ->/ dev / block / mmcblk0p1
    lrwxrwxrwx root root 2015-01-26 16:07 protect1 ->/ dev / block / mmcblk0p3
    lrwxrwxrwx root root 2015-01-26 16:07 protect2 ->/ dev / block / mmcblk0p4
    lrwxrwxrwx root root 2015-01-26 16:07 recovery ->/ dev / block / mmcblk0p9
    lrwxrwxrwx root root 2015-01-26 16:07 seccfg ->/ dev / block / mmcblk0p13
    lrwxrwxrwx root root 2015-01-26 16:07 secro ->/ dev / block / mmcblk0p11
    lrwxrwxrwx root root 2015-01-26 16:07 system ->/ dev / block / mmcblk0p19
    lrwxrwxrwx root root 2015-01-26 16:07 userdata ->/ dev / block / mmcblk0p21
    
    
  • 4. The program itself connects information from all three conclusions, checks the sizes of blocks, the names of sections.
    
  • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 6. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>adb shell getprop
    [ro.sf.hwrotation]: [0]
    [ro.sf.lcd_density]: [320]
    [ro.adb.secure]: [1]
    [ro.apn.presetapn.edit.flag]: [true]
    [ro.com.idea.SP.call]: [false]
    [ro.com.google.gmsversion]: [5.1_r2]
    [ro.com.google.clientidbase]: [android-alcatel]
    [ro.com.google.clientidbase.am]: [android-alcatel]
    [ro.com.google.clientidbase.ms]: [android-alcatel]
    [ro.com.google.clientidbase.yt]: [android-alcatel]
    [ro.com.google.clientidbase.gmm]: [android-alcatel]
    [ro.com.android.dateformat]: [MM-dd-yyyy]
    [ro.com.android.mobiledata]: [false]
    [ro.com.android.dataroaming]: [0]
    [ro.com.android.dataroaming2]: [0]
    [ro.def.mms.autolink.extra]: [0]
    [ro.def.svn.countrycode]: []
    [ro.def.show.sim.change.dialog]: [true]
    [ro.def.show.plmn]: [1]
    [ro.def.russia.num.match.rule]: [0]
    [ro.def.browser]: [0]
    [ro.def.software.svn]: [01001]
    [ro.def.software.version]: [01001]
    [ro.def.phonenumber.Telstra]: [false]
    [ro.def.TelephonyProvider.match]: [0]
    [ro.dtv.support]: [false]
    [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
    [ro.oma.cp.authen_mandatory]: [true]
    [ro.oma.cp.userpin_acceptable]: [true]
    [ro.ssv.enabled]: [false]
    [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
    [ro.ssv.config_operator]: [none]
    [ro.ssv.diag_sel_config]: [1]
    [ro.sys.usb.mtp.whql.enable]: [0]
    [ro.sys.usb.bicr]: [yes]
    [ro.sys.usb.storage.type]: [mtp, mass_storage]
    [ro.sys.usb.charging.only]: [yes]
    [ro.boot.hardware]: [mt6580]
    [ro.boot.serialno]: [65TW556D99999999 [128m]]
  Method 6 (GPT, Partitions, emmc)

  For this method, the following commands must be executed in ADB:
  

  • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
    >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1
    
    >>adb pull / sdcard / rom_000 C: / Rom / rom_000
    [6%] / sdcard / rom_000
    [12%] / sdcard / rom_000
    [18%] / sdcard / rom_000
    [25%] / sdcard / rom_000
    [31%] / sdcard / rom_000
    [37%] / sdcard / rom_000
    [43%] / sdcard / rom_000
    [50%] / sdcard / rom_000
    [56%] / sdcard / rom_000
    [62%] / sdcard / rom_000
    [68%] / sdcard / rom_000
    [75%] / sdcard / rom_000
    [81%] / sdcard / rom_000
    [87%] / sdcard / rom_000
    [93%] / sdcard / rom_000
    [100%] / sdcard / rom_000
    / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)
    
    >>adb shell su -c rm / sdcard / rom_000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    254 0 499712 zram0
    7 0 21796 loop0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 917504 mmcblk0p13
    179 14 8192 mmcblk0p14
    179 15 16384 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 8192 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 32768 mmcblk0p19
    179 20 1286144 mmcblk0p20
    179 21 114688 mmcblk0p21
    179 22 5034496 mmcblk0p22
    179 23 44032 mmcblk0p23
    179 24 16384 mmcblk0p24
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    
    
  • 3. Emmc.
    >>adb shell cat / proc / emmc
    partno: start_sect nr_sects partition_name
    emmc_p1: 00004000 00003400 "proinfo"
    emmc_p2: 00007400 00002800 "nvram"
    emmc_p3: 00009c00 00005000 "protect1"
    emmc_p4: 0000ec00 00005000 "protect2"
    emmc_p5: 00013c00 00000400 "para"
    emmc_p6: 00014000 00004000 "lk"
    emmc_p7: 00018000 00004000 "logo"
    emmc_p8: 0001c000 00008000 "boot"
    emmc_p9: 00024000 00008000 "recovery"
    emmc_p10: 0002c000 00004000 "oemkeystore"
    emmc_p11: 00030000 00004000 "secro"
    emmc_p12: 00034000 00004000 "keystore"
    emmc_p13: 00038000 001c0000 "custpack"
    emmc_p14: 001f8000 00004000 "seccfg"
    emmc_p15: 001fc000 00008000 "expdb"
    emmc_p16: 00204000 00004000 "mobile_info"
    emmc_p17: 00208000 00004000 "frp"
    emmc_p18: 0020c000 00010000 "nvdata"
    emmc_p19: 0021c000 00010000 "metadata"
    emmc_p20: 0022c000 00274000 "system"
    emmc_p21: 004a0000 00038000 "cache"
    emmc_p22: 004d8000 0099a400 "userdata"
    emmc_p23: 00e72400 00015800 "otp"
    emmc_p24: 00e87c00 00008000 "flashinfo"
    
    
  • 4. The program itself connects information from all three conclusions, checks the sizes of blocks, the names of sections.
    
  • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 6. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>adb shell getprop
    [ro.sf.hwrotation]: [0]
    [ro.sf.lcd_density]: [320]
    [ro.adb.secure]: [1]
    [ro.apn.presetapn.edit.flag]: [true]
    [ro.com.idea.SP.call]: [false]
    [ro.com.google.gmsversion]: [5.1_r2]
    [ro.com.google.clientidbase]: [android-alcatel]
    [ro.com.google.clientidbase.am]: [android-alcatel]
    [ro.com.google.clientidbase.ms]: [android-alcatel]
    [ro.com.google.clientidbase.yt]: [android-alcatel]
    [ro.com.google.clientidbase.gmm]: [android-alcatel]
    [ro.com.android.dateformat]: [MM-dd-yyyy]
    [ro.com.android.mobiledata]: [false]
    [ro.com.android.dataroaming]: [0]
    [ro.com.android.dataroaming2]: [0]
    [ro.def.mms.autolink.extra]: [0]
    [ro.def.svn.countrycode]: []
    [ro.def.show.sim.change.dialog]: [true]
    [ro.def.show.plmn]: [1]
    [ro.def.russia.num.match.rule]: [0]
    [ro.def.browser]: [0]
    [ro.def.software.svn]: [01001]
    [ro.def.software.version]: [01001]
    [ro.def.phonenumber.Telstra]: [false]
    [ro.def.TelephonyProvider.match]: [0]
    [ro.dtv.support]: [false]
    [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
    [ro.oma.cp.authen_mandatory]: [true]
    [ro.oma.cp.userpin_acceptable]: [true]
    [ro.ssv.enabled]: [false]
    [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
    [ro.ssv.config_operator]: [none]
    [ro.ssv.diag_sel_config]: [1]
    [ro.sys.usb.mtp.whql.enable]: [0]
    [ro.sys.usb.bicr]: [yes]
    [ro.sys.usb.storage.type]: [mtp, mass_storage]
    [ro.sys.usb.charging.only]: [yes]
    [ro.boot.hardware]: [mt6580]
    [ro.boot.serialno]: [65TW556D99999999 [128m]]
  Method 7 (GPT, Partitions, mmcblk0)

  For this method, the following commands must be executed in ADB:
  

  • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
    >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1
    
    >>adb pull / sdcard / rom_000 C: / Rom / rom_000
    [6%] / sdcard / rom_000
    [12%] / sdcard / rom_000
    [18%] / sdcard / rom_000
    [25%] / sdcard / rom_000
    [31%] / sdcard / rom_000
    [37%] / sdcard / rom_000
    [43%] / sdcard / rom_000
    [50%] / sdcard / rom_000
    [56%] / sdcard / rom_000
    [62%] / sdcard / rom_000
    [68%] / sdcard / rom_000
    [75%] / sdcard / rom_000
    [81%] / sdcard / rom_000
    [87%] / sdcard / rom_000
    [93%] / sdcard / rom_000
    [100%] / sdcard / rom_000
    / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)
    
    >>adb shell su -c rm / sdcard / rom_000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    7 0 21796 loop0
    7 1 98304 loop1
    254 0 493824 zram0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 8192 mmcblk0p13
    179 14 16384 mmcblk0p14
    179 15 8192 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 32768 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 1761280 mmcblk0p19
    179 20 262144 mmcblk0p20
    179 21 5329408 mmcblk0p21
    179 22 44032 mmcblk0p22
    179 23 16384 mmcblk0p23
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    253 0 5329408 dm-0
    
    
  • 3. Availability of mmcblk0 and mmcblk0boot0 block:
    >>adb shell ls -l / dev / block / mmcblk0
    / dev / block / mmcblk0: Permission denied (Access denied!)
    
    >>adb shell su -c ls -l / dev / block / mmcblk0
    brw-rw ---- root system 179, 0 2015-01-26 16:07 mmcblk0
    
    >>adb shell su -c ls -l / dev / block / mmcblk0boot0
    brw-rw ---- root system 179, 32 2015-01-26 16:07 mmcblk0boot0
    
    
  • 4. The program itself connects information from all two pins, copying only takes place on the mmcblk0 block, but from a different starting position and length. The starting position and length is taken from the GPT section.
    Not a very good method, but as an option goes. Sometimes an error occurs on large sections: about the impossibility of copying a block.
    
  • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 6. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>>>adb shell getprop
    [gsm.version.baseband]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
    [gsm.version.baseband1]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
    [gsm.version.ril-impl]: [mtk gemini ril 1.0]
    [mediatek.wlan.chip]: [CONSYS_MT6735]
    [mediatek.wlan.ctia]: [0]
    [mediatek.wlan.module.postfix]: [_consys_mt6735]
    [mtk.md1.starttime]: [0s Mon Jan 26 16:07:40 2015]
    [mtk.md1.status]: [ready]
    [mtk.md2.status]: [init_done]
    [[ro.boot.hardware]: [mt6580]
    [ro.boot.mode]: [normal]
    [ro.boot.name]: [android]
    [ro.boot.serialno]: [4TEAD6L7Q86SF6AA]
    [ro.bootimage.build.date]: [Wed May 18 12:26:48 CST 2016]
    [ro.bootimage.build.date.utc]: [1463545608]
    [ro.bootimage.build.fingerprint]: [TCL / 5010X / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / test-keys]
    [ro.bootloader]: [unknown]
    [ro.bootmode]: [normal]
    [ro.build.characteristics]: [default]
    [ro.build.date]: [Fri May 20 09:22:43 CST 2016]
    [ro.build.date.utc]: [1463707363]
    [ro.build.description]: [full_pixi4_5-user 6.0 MRA58K v5E2E-0 release-keys]
    [ro.build.display.id]: [Marshmallow]
    [ro.build.fingerprint]: [TCL / 5010D / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / release-keys]
    [ro.build.flavor]: [full_pixi4_5-user]
    [ro.build.host]: [persauto-81]
    [ro.build.id]: [MRA58K]
    [ro.build.product]: [Pixi4-5]
    [ro.build.version.security_patch]: [2016-05-01]
    [ro.mediatek.chip_ver]: [S01]
    [ro.mediatek.gemini_support]: [true]
    [ro.mediatek.platform]: [MT6580]
    [ro.mediatek.project.path]: [device / jrdchz / pixi4_5]
    [ro.mediatek.version.branch]: [alps-mp-m0.mp1]
    [ro.mediatek.version.release]: [alps-mp-m0.mp1-V2.34_jhz6580.we.m_P20]
    [ro.mediatek.version.sdk]: [4]
    [ro.mediatek.wlan.p2p]: [1]
    [ro.mediatek.wlan.wsc]: [1]
    [ro.mount.fs]: [EXT4]
    [ro.mtk.dex2oat_white_list]: [com.facebook: com.google.android.gms:]
    [ro.mtk_shared_sdcard]: [1]
    [ro.mtk_sim_hot_swap]: [1]
    [ro.opengles.version]: [131072]
    [ro.product.board]: []
    [ro.product.brand]: [TCL]
    [ro.product.brand1]: [Orange]
    [ro.product.cpu.abi]: [armeabi-v7a]
    [ro.product.cpu.abi2]: [armeabi]
    [ro.product.cpu.abilist]: [armeabi-v7a, armeabi]
    [ro.product.cpu.abilist32]: [armeabi-v7a, armeabi]
    [ro.product.cpu.abilist64]: []
    [ro.product.device]: [Pixi4-5]
    [ro.product.internal.id]: [Pixi4_5_3G]
    [ro.product.locale.language]: [ru]
    [ro.product.locale.region]: [RU]
    [ro.product.manufacturer]: [TCL]
    [ro.product.model]: [5010D]
    [ro.product.name]: [5010D]
    [ro.product.orangecodename]: [NA58083]
    [ro.product.usb.model]: [Alcatel Pixi 4 (5)]
  Method 8 (GPT, Partitions, Auto)

  For this method, the following commands must be executed in ADB:
  

  • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
    >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1
    
    >>adb pull / sdcard / rom_000 C: / Rom / rom_000
    [6%] / sdcard / rom_000
    [12%] / sdcard / rom_000
    [18%] / sdcard / rom_000
    [25%] / sdcard / rom_000
    [31%] / sdcard / rom_000
    [37%] / sdcard / rom_000
    [43%] / sdcard / rom_000
    [50%] / sdcard / rom_000
    [56%] / sdcard / rom_000
    [62%] / sdcard / rom_000
    [68%] / sdcard / rom_000
    [75%] / sdcard / rom_000
    [81%] / sdcard / rom_000
    [87%] / sdcard / rom_000
    [93%] / sdcard / rom_000
    [100%] / sdcard / rom_000
    / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)
    
    >>adb shell su -c rm / sdcard / rom_000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    7 0 21796 loop0
    7 1 98304 loop1
    254 0 493824 zram0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 8192 mmcblk0p13
    179 14 16384 mmcblk0p14
    179 15 8192 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 32768 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 1761280 mmcblk0p19
    179 20 262144 mmcblk0p20
    179 21 5329408 mmcblk0p21
    179 22 44032 mmcblk0p22
    179 23 16384 mmcblk0p23
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    253 0 5329408 dm-0
    
    
  • 3. The program itself connects information from all two conclusions, checks the block sizes, their name.
    
  • 4. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 5. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 6. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>>>adb shell getprop
    [gsm.version.baseband]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
    [gsm.version.baseband1]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
    [gsm.version.ril-impl]: [mtk gemini ril 1.0]
    [mediatek.wlan.chip]: [CONSYS_MT6735]
    [mediatek.wlan.ctia]: [0]
    [mediatek.wlan.module.postfix]: [_consys_mt6735]
    [mtk.md1.starttime]: [0s Mon Jan 26 16:07:40 2015]
    [mtk.md1.status]: [ready]
    [mtk.md2.status]: [init_done]
    [[ro.boot.hardware]: [mt6580]
    [ro.boot.mode]: [normal]
    [ro.boot.name]: [android]
    [ro.boot.serialno]: [4TEAD6L7Q86SF6AA]
    [ro.bootimage.build.date]: [Wed May 18 12:26:48 CST 2016]
    [ro.bootimage.build.date.utc]: [1463545608]
    [ro.bootimage.build.fingerprint]: [TCL / 5010X / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / test-keys]
    [ro.bootloader]: [unknown]
    [ro.bootmode]: [normal]
    [ro.build.characteristics]: [default]
    [ro.build.date]: [Fri May 20 09:22:43 CST 2016]
    [ro.build.date.utc]: [1463707363]
    [ro.build.description]: [full_pixi4_5-user 6.0 MRA58K v5E2E-0 release-keys]
    [ro.build.display.id]: [Marshmallow]
    [ro.build.fingerprint]: [TCL / 5010D / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / release-keys]
    [ro.build.flavor]: [full_pixi4_5-user]
    [ro.build.host]: [persauto-81]
    [ro.build.id]: [MRA58K]
    [ro.build.product]: [Pixi4-5]
    [ro.build.version.security_patch]: [2016-05-01]
    [ro.mediatek.chip_ver]: [S01]
    [ro.mediatek.gemini_support]: [true]
    [ro.mediatek.platform]: [MT6580]
    [ro.mediatek.project.path]: [device / jrdchz / pixi4_5]
    [ro.mediatek.version.branch]: [alps-mp-m0.mp1]
    [ro.mediatek.version.release]: [alps-mp-m0.mp1-V2.34_jhz6580.we.m_P20]
    [ro.mediatek.version.sdk]: [4]
    [ro.mediatek.wlan.p2p]: [1]
    [ro.mediatek.wlan.wsc]: [1]
    [ro.mount.fs]: [EXT4]
    [ro.mtk.dex2oat_white_list]: [com.facebook: com.google.android.gms:]
    [ro.mtk_shared_sdcard]: [1]
    [ro.mtk_sim_hot_swap]: [1]
    [ro.opengles.version]: [131072]
    [ro.product.board]: []
    [ro.product.brand]: [TCL]
    [ro.product.brand1]: [Orange]
    [ro.product.cpu.abi]: [armeabi-v7a]
    [ro.product.cpu.abi2]: [armeabi]
    [ro.product.cpu.abilist]: [armeabi-v7a, armeabi]
    [ro.product.cpu.abilist32]: [armeabi-v7a, armeabi]
    [ro.product.cpu.abilist64]: []
    [ro.product.device]: [Pixi4-5]
    [ro.product.internal.id]: [Pixi4_5_3G]
    [ro.product.locale.language]: [ru]
    [ro.product.locale.region]: [RU]
    [ro.product.manufacturer]: [TCL]
    [ro.product.model]: [5010D]
    [ro.product.name]: [5010D]
    [ro.product.orangecodename]: [NA58083]
    [ro.product.usb.model]: [Alcatel Pixi 4 (5)]
  Method 9 (GPT, Partitions, by-name)

  For this method, the following commands must be executed in ADB:
  

  • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
    >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1
    
    >>adb pull / sdcard / rom_000 C: / Rom / rom_000
    [6%] / sdcard / rom_000
    [12%] / sdcard / rom_000
    [18%] / sdcard / rom_000
    [25%] / sdcard / rom_000
    [31%] / sdcard / rom_000
    [37%] / sdcard / rom_000
    [43%] / sdcard / rom_000
    [50%] / sdcard / rom_000
    [56%] / sdcard / rom_000
    [62%] / sdcard / rom_000
    [68%] / sdcard / rom_000
    [75%] / sdcard / rom_000
    [81%] / sdcard / rom_000
    [87%] / sdcard / rom_000
    [93%] / sdcard / rom_000
    [100%] / sdcard / rom_000
    / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)
    
    >>adb shell su -c rm / sdcard / rom_000
    
    
  • 2. Partitions.
    >>adb shell cat / proc / partitions
    major minor #blocks name
    7 0 21796 loop0
    7 1 98304 loop1
    254 0 493824 zram0
    179 0 7634944 mmcblk0
    179 1 6656 mmcblk0p1
    179 2 5120 mmcblk0p2
    179 3 10240 mmcblk0p3
    179 4 10240 mmcblk0p4
    179 5 512 mmcblk0p5
    179 6,8192 mmcblk0p6
    179 7 8192 mmcblk0p7
    179 8 16384 mmcblk0p8
    179 9 16384 mmcblk0p9
    179 10 8192 mmcblk0p10
    179 11 8192 mmcblk0p11
    179 12,8192 mmcblk0p12
    179 13 8192 mmcblk0p13
    179 14 16384 mmcblk0p14
    179 15 8192 mmcblk0p15
    179 16 8192 mmcblk0p16
    179 17 32768 mmcblk0p17
    179 18 32768 mmcblk0p18
    179 19 1761280 mmcblk0p19
    179 20 262144 mmcblk0p20
    179 21 5329408 mmcblk0p21
    179 22 44032 mmcblk0p22
    179 23 16384 mmcblk0p23
    179 96 512 mmcblk0rpmb
    179 64 4096 mmcblk0boot1
    179 32 4096 mmcblk0boot0
    253 0 5329408 dm-0
    
    
  • 3. The program is looking for a folder (directory) named<by-name>after folder (directory)</ dev / block>. It has an approximate conclusion:
    >>adb shell ls -l / dev / block
    / dev / block: Permission denied
    
    >>adb shell su -c ls -l / dev / block
    brw ------- root root 253, 0 2015-01-26 16:07 dm-0
    brw ------- root root 7, 0 2015-01-26 16:07 loop0
    brw ------- root root 7, 1 2015-01-26 16:07 loop1
    brw ------- root root 7, 2 2015-01-26 16:07 loop2
    brw ------- root root 7, 3 2015-01-26 16:07 loop3
    brw ------- root root 7, 4 2015-01-26 16:07 loop4
    brw ------- root root 7, 5 2015-01-26 16:07 loop5
    brw ------- root root 7, 6 2015-01-26 16:07 loop6
    brw ------- root root 7, 7 2015-01-26 16:07 loop7
    brw-rw ---- root system 179, 0 2015-01-26 16:07 mmcblk0
    brw-rw ---- root system 179, 32 2015-01-26 16:07 mmcblk0boot0
    brw-rw ---- root system 179, 64 2015-01-26 16:07 mmcblk0boot1
    brw-rw ---- root system 179, 1 2015-01-26 16:07 mmcblk0p1
    brw ------- root root 179, 10 2015-01-26 16:07 mmcblk0p10
    brw-r ----- root system 179, 11 2015-01-26 16:07 mmcblk0p11
    brw ------- root root 179, 12 2015-01-26 16:07 mmcblk0p12
    brw-rw ---- root system 179, 13 2015-01-26 16:07 mmcblk0p13
    brw ------- root root 179, 14 2015-01-26 16:07 mmcblk0p14
    brw ------- root root 179, 15 2015-01-26 16:07 mmcblk0p15
    brw-rw ---- root system 179, 16 2015-01-26 16:08 mmcblk0p16
    brw ------- root root 179, 17 2015-01-26 16:07 mmcblk0p17
    brw ------- root root 179, 18 2015-01-26 16:07 mmcblk0p18
    brw ------- root root 179, 19 2015-01-26 16:07 mmcblk0p19
    brw-rw ---- root system 179, 2 2015-01-26 16:07 mmcblk0p2
    brw ------- root root 179, 20 2015-01-26 16:07 mmcblk0p20
    brw ------- root root 179, 21 2015-01-26 16:07 mmcblk0p21
    brw-r ----- root system 179, 22 2015-01-26 16:07 mmcblk0p22
    brw ------- root root 179, 23 2015-01-26 16:07 mmcblk0p23
    brw ------- root root 179, 3 2015-01-26 16:07 mmcblk0p3
    brw ------- root root 179, 4 2015-01-26 16:07 mmcblk0p4
    brw-rw ---- root system 179, 5 2015-01-26 16:07 mmcblk0p5
    brw ------- root root 179, 6 2015-01-26 16:07 mmcblk0p6
    brw-r ----- root system 179, 7 2015-01-26 16:07 mmcblk0p7
    brw-r ----- root system 179, 8 2015-01-26 16:07 mmcblk0p8
    brw-r ----- root system 179, 9 2015-01-26 16:07 mmcblk0p9
    brw ------- root root 179, 96 2015-01-26 16:07 mmcblk0rpmb
    drwxr-xr-x root root 2015-01-26 16:07 platform
    drwx ------ root root 2015-01-26 16:07 vold
    brw ------- root root 254, 0 2015-01-26 16:07 zram0
    
    >>adb shell su -c ls -l / dev / block / platform
    drwxr-xr-x root root 2015-01-26 16:07 mtk-msdc.0
    
    >>adb shell su -c ls -l / dev / block / vold
    
    >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0
    drwxr-xr-x root root 2015-01-26 16:07 11120000.msdc0
    
    >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0
    drwxr-xr-x root root 2015-01-26 16:07 by-name
    drwxr-xr-x root root 2015-01-26 16:07 by-num
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0 ->/ dev / block / mmcblk0
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot0 ->/ dev / block / mmcblk0boot0
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot1 ->/ dev / block / mmcblk0boot1
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p1 ->/ dev / block / mmcblk0p1
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p10 ->/ dev / block / mmcblk0p10
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p11 ->/ dev / block / mmcblk0p11
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p12 ->/ dev / block / mmcblk0p12
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p13 ->/ dev / block / mmcblk0p13
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p14 ->/ dev / block / mmcblk0p14
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p15 ->/ dev / block / mmcblk0p15
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p16 ->/ dev / block / mmcblk0p16
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p17 ->/ dev / block / mmcblk0p17
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p18 ->/ dev / block / mmcblk0p18
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p19 ->/ dev / block / mmcblk0p19
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p2 ->/ dev / block / mmcblk0p2
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p20 ->/ dev / block / mmcblk0p20
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p21 ->/ dev / block / mmcblk0p21
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p22 ->/ dev / block / mmcblk0p22
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p23 ->/ dev / block / mmcblk0p23
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p3 ->/ dev / block / mmcblk0p3
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p4 ->/ dev / block / mmcblk0p4
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p5 ->/ dev / block / mmcblk0p5
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p6 ->/ dev / block / mmcblk0p6
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p7 ->/ dev / block / mmcblk0p7
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p8 ->/ dev / block / mmcblk0p8
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p9 ->/ dev / block / mmcblk0p9
    lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0rpmb ->/ dev / block / mmcblk0rpmb
    
    >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0/by-name
    lrwxrwxrwx root root 2015-01-26 16:07 boot ->/ dev / block / mmcblk0p8
    lrwxrwxrwx root root 2015-01-26 16:07 cache ->/ dev / block / mmcblk0p20
    lrwxrwxrwx root root 2015-01-26 16:07 expdb ->/ dev / block / mmcblk0p14
    lrwxrwxrwx root root 2015-01-26 16:07 flashinfo ->/ dev / block / mmcblk0p23
    lrwxrwxrwx root root 2015-01-26 16:07 frp ->/ dev / block / mmcblk0p16
    lrwxrwxrwx root root 2015-01-26 16:07 keystore ->/ dev / block / mmcblk0p12
    lrwxrwxrwx root root 2015-01-26 16:07 lk ->/ dev / block / mmcblk0p6
    lrwxrwxrwx root root 2015-01-26 16:07 logo ->/ dev / block / mmcblk0p7
    lrwxrwxrwx root root 2015-01-26 16:07 metadata ->/ dev / block / mmcblk0p18
    lrwxrwxrwx root root 2015-01-26 16:07 mobile_info ->/ dev / block / mmcblk0p15
    lrwxrwxrwx root root 2015-01-26 16:07 nvdata ->/ dev / block / mmcblk0p17
    lrwxrwxrwx root root 2015-01-26 16:07 nvram ->/ dev / block / mmcblk0p2
    lrwxrwxrwx root root 2015-01-26 16:07 oemkeystore ->/ dev / block / mmcblk0p10
    lrwxrwxrwx root root 2015-01-26 16:07 otp ->/ dev / block / mmcblk0p22
    lrwxrwxrwx root root 2015-01-26 16:07 para ->/ dev / block / mmcblk0p5
    lrwxrwxrwx root root 2015-01-26 16:07 proinfo ->/ dev / block / mmcblk0p1
    lrwxrwxrwx root root 2015-01-26 16:07 protect1 ->/ dev / block / mmcblk0p3
    lrwxrwxrwx root root 2015-01-26 16:07 protect2 ->/ dev / block / mmcblk0p4
    lrwxrwxrwx root root 2015-01-26 16:07 recovery ->/ dev / block / mmcblk0p9
    lrwxrwxrwx root root 2015-01-26 16:07 seccfg ->/ dev / block / mmcblk0p13
    lrwxrwxrwx root root 2015-01-26 16:07 secro ->/ dev / block / mmcblk0p11
    lrwxrwxrwx root root 2015-01-26 16:07 system ->/ dev / block / mmcblk0p19
    lrwxrwxrwx root root 2015-01-26 16:07 userdata ->/ dev / block / mmcblk0p21
    
    
  • 4. The program itself connects information from all three conclusions, checks the block sizes, their name.
    
  • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    
  • 6. Copying occurs in stages. I.e:
    • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      
    • Then from the memory card is copied to the PC.
      
    • And removed from the memory card.
      
      
    • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
      Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      
    • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      
    • Then on the PC, merge the blocks.
      
    • And delete blocks from the memory card.
    
    
  • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
    >>>>adb shell getprop
    [gsm.version.baseband]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
    [gsm.version.baseband1]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
    [gsm.version.ril-impl]: [mtk gemini ril 1.0]
    [mediatek.wlan.chip]: [CONSYS_MT6735]
    [mediatek.wlan.ctia]: [0]
    [mediatek.wlan.module.postfix]: [_consys_mt6735]
    [mtk.md1.starttime]: [0s Mon Jan 26 16:07:40 2015]
    [mtk.md1.status]: [ready]
    [mtk.md2.status]: [init_done]
    [[ro.boot.hardware]: [mt6580]
    [ro.boot.mode]: [normal]
    [ro.boot.name]: [android]
    [ro.boot.serialno]: [4TEAD6L7Q86SF6AA]
    [ro.bootimage.build.date]: [Wed May 18 12:26:48 CST 2016]
    [ro.bootimage.build.date.utc]: [1463545608]
    [ro.bootimage.build.fingerprint]: [TCL / 5010X / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / test-keys]
    [ro.bootloader]: [unknown]
    [ro.bootmode]: [normal]
    [ro.build.characteristics]: [default]
    [ro.build.date]: [Fri May 20 09:22:43 CST 2016]
    [ro.build.date.utc]: [1463707363]
    [ro.build.description]: [full_pixi4_5-user 6.0 MRA58K v5E2E-0 release-keys]
    [ro.build.display.id]: [Marshmallow]
    [ro.build.fingerprint]: [TCL / 5010D / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / release-keys]
    [ro.build.flavor]: [full_pixi4_5-user]
    [ro.build.host]: [persauto-81]
    [ro.build.id]: [MRA58K]
    [ro.build.product]: [Pixi4-5]
    [ro.build.version.security_patch]: [2016-05-01]
    [ro.mediatek.chip_ver]: [S01]
    [ro.mediatek.gemini_support]: [true]
    [ro.mediatek.platform]: [MT6580]
    [ro.mediatek.project.path]: [device / jrdchz / pixi4_5]
    [ro.mediatek.version.branch]: [alps-mp-m0.mp1]
    [ro.mediatek.version.release]: [alps-mp-m0.mp1-V2.34_jhz6580.we.m_P20]
    [ro.mediatek.version.sdk]: [4]
    [ro.mediatek.wlan.p2p]: [1]
    [ro.mediatek.wlan.wsc]: [1]
    [ro.mount.fs]: [EXT4]
    [ro.mtk.dex2oat_white_list]: [com.facebook: com.google.android.gms:]
    [ro.mtk_shared_sdcard]: [1]
    [ro.mtk_sim_hot_swap]: [1]
    [ro.opengles.version]: [131072]
    [ro.product.board]: []
    [ro.product.brand]: [TCL]
    [ro.product.brand1]: [Orange]
    [ro.product.cpu.abi]: [armeabi-v7a]
    [ro.product.cpu.abi2]: [armeabi]
    [ro.product.cpu.abilist]: [armeabi-v7a, armeabi]
    [ro.product.cpu.abilist32]: [armeabi-v7a, armeabi]
    [ro.product.cpu.abilist64]: []
    [ro.product.device]: [Pixi4-5]
    [ro.product.internal.id]: [Pixi4_5_3G]
    [ro.product.locale.language]: [ru]
    [ro.product.locale.region]: [RU]
    [ro.product.manufacturer]: [TCL]
    [ro.product.model]: [5010D]
    [ro.product.name]: [5010D]
    [ro.product.orangecodename]: [NA58083]
    [ro.product.usb.model]: [Alcatel Pixi 4 (5)]

That's all for now. I hope the program will help you. Methods and instructions will be updated!

Video instructions

• Video 10. WwR_MTK 2.50. General principles of the program. Part 1
  
• Video 11. WwR_MTK 2.50. General principles of the program. Part 2
  
• Video 12. WwR_MTK 2.50. General principles of the program. Part 3
  
• Video 13. WwR_MTK 2.50. General principles of the program. Part 4
  
  
• Video 1. Phone Platform Type:MT65xx , but not MT6580
  
• Video 2. Phone platform type:MT65xx , but not MT6580
  
• Video 3. Phone Platform Type:MT65xx , but not MT6580
  
• Video 4
  
• Video 5. Phone Platform Type:MT67xx and MT6580
  
• Video 6. Phone Platform Type:MT67xx and MT6580
  
• Video 7. Phone Platform Type:MT67xx and MT6580
  
• Video 8. Memory Type:NAND . File system UBIFS . Present Spare
  
• Video 9. Memory Type:NAND . File system UBIFS . Present Spare

Laiki to put, thereby helping the project.

Errors noted

2.30 version

• AT<Autopilot>After scanning, searching for partitions, the function of determining read partitions does not work correctly, but can be corrected manually, that is, if the section was read inclusively by system (along with<system>), the auto selection will not enable the checkbox on it, that is, the auto selection does not include the last read section.
  Solution: After scanning in<Autopilot>when the program offers to enter<Scatter file>and remove unnecessary checkboxes on sections, you must go in and check the box on the last section you want, which was read byROMfile. If you have a fullROM, that's okay, everything will be fine.
  
  
• Sometimes wrong pulls outPreloader, nothing terrible will happen, because the SP Flash Tool will tell you about it that Preloader is not Preloader.
  The error is fixed, in the new version everything will be fine.
  Solution: Take advantage of this: SP Flash Tool - Flash driver for MTK smartphones. (Post RealYoti # 62066982)
  
  
• The program crashes if in sectionPGPTmore than 50 positions of section names. The error is fixed, in the new version everything will be fine.
  Solution: There are no solutions yet, as this can onlyWwr_mtk(Pull out information from PGPT), there may of course be solutions, it is necessary to search in themes or programs for re-marking the memory of devices.
  
  
• When the program createsScatter fileof the values ​​found, it runs the section names according to some template file<Template.ini>which indicates which sections are sewn and which are not. And if in this template file there is no necessary section, then it is automatically set as<Update>, ie to flash. In the New version it will be the other way round, all the positions of the sections will be set as non-firmware, and then they will only follow the pattern.

Past versions

• WwR_2.40_Rus.rar(32.69 MB)
  
• WwR_2.40_Eng.rar(32.69 MB)
  Download another file and put it in the folder with the program. It contains information about installed applications in the device, the file is not mine, butotido2010
  The file itself in the subject of the message:WwR MTK (Post otido2010 # 71925327)
  Modified Template.ini file with support for new platforms, here in this post: WwR MTK (Post vvaaavv # 80174563)
  
  
• WwR_MTK_v2.30.rar(20.44 MB)
  
  
• WwR_MTK_v2.20.rar(14.3 MB)
  
  
• WwR_MTK_v2.15.rar(14.3 MB)
  
  
• WwR_MTK_v2.10.rar(14.3 MB)
  
  
• WwR_MTK_v2.0b.rar(14.3 MB)
  
  
• WwR_MTK_v1.9b.rar(14.28 MB)
  
  
• WwR_MTK_v1.8b.rar(14.27 MB)
  
  
• WWR_MTK_v1.5b.rar(14.11 MB)
  
  
• WWR_MTK_v1.4.5b.rar(14.11 MB)
  
  
• WWR_MTK_v1.4b.rar(14.11 MB)
  
  
• WWR_MTK_v1.3b.rar(14.65 MB)
  

Addition to the scatter files created:
If you use the created scatter file for the device firmware, then you need to reduce the length of the UserData section in the scatter file itself to 3 GB (0xC0000000), subject:WwR MTK (Post vvaaavv # 70864827)

About crypto section UserData

Merge the firmware from one device and flash this firmware to another device

Hello. Please test. Maybe there will be some errors on different versions of the platform. All did not have time to modify.
Corrections and improvements continue almost every day.

To contact the topic, formulate your questions and wishes more clearly, competently, in detail .. thus there will be fewer questions.
If something does not work in the program, or it works but not correctly, please prepare your Backup in advance for consideration. To do this, pack it into the archive (preferably * .7z), place it somewhere on the cloud storage (Yandex disk, Cloud Mail.Ru, Google drive) and give the link to the author of the program inQMS. For your data you can not worry, nothing, never went to the people. Or you can cut the UserData section and everything after it (For your confidence).
And remember .. each backup sent improves the performance of the program!

Thank you very muchUm4 for fixing hats!

Post has been editedvvaaavv - 02.05.19, 09:45

Reason for editing: Changing the topic header and instructions in connection with the release of the new version of the program

[82ronin]

This program was good in functionality.
MTK Droid Tools (Post #abonentka # 19867456)
It is a pity that she was abandoned ...

[Sedy]

82roninThese are different in functionality of the program.

[Foxtrot_KZ]

While a question on the interface.
Is it just my prog that when I enlarge the window, does it look like this?
Does she need something? (Frameworks there and so on)

[Foxtrot_KZ]

Sedy @ 05/10/17, 2:58 pm

A piece is not clear what you have chosen and want to get a firmware from it

All right pointed 82ronin,normal logic.
When there is a lot of devices and you need to make a backup for them, but there is a firmware, then why save a full dump, the c_0_po_xxxx area is enough, which includes the main backup sections.

[email protected], 17:56

A scatter file is created only from PMT or PGPT partitions, or use the scatter that goes to your firmware.

The fact of the matter is that the vast majority of owners (kithophones) needscatter + preloaderfor further manipulations with the phone for whichThere is no firmware. That is why MTK Droid Tools has received such huge popularity. If your program learns to form a scatter automatically, success is guaranteed.
Now, someone can manually make a scatter and cut a preloader on a full dump by manually analyzing the blocks, but for 99.9999% this is “very heavy weight”

In general, we are waiting for development.

[sever20067]

Foxtrot_KZI understand you earn on the firmware. So is not it time to use the paid software. Saves a lot of time and shows that a person has seriously got down to business.

This software is excellent, thanks for the program)

[Foxtrot_KZ]

sever20067 @ 11.05.17, 11:04

I understand you earn on firmware

YouNOTyou understand correctly. I do not earn on the firmware.
(well, not a psychic, you are not a psychic)

PS: and about what you paid software?

Post has been editedFoxtrot_KZ - 11.05.17, 08:11

[vvaaavv]

Yes, you should not particularly argue on the topic of earnings.
I have been earning money on cell phone repair for 10 years already.
I also have a paid software (Boxes): infinity box chinese miracle 2, Mrt dongle, Best, Z3x Sams Pro, Z3x Lg, Setool and UFS + HWK ...
There are interesting things for example in the infinity box chinese miracle 2 (good boxing). But he doesn’t merge software from Chinese fakes for famous brands. And if it merges, does not want to sew back. :)
This is not about everything, but about most models, for some reason CM2 does not cope, basically copes with what is already available, for example Explay Fresh - any actions.

About MTK Droid Tools - A good, necessary program. But there are some disadvantages, for example:
1) Does not work with MT67xx, well, or based on x64
2) In order to merge the firmware, you need Root.
3) The phone should turn on and USB debugging should be connected.
Yes, without this it will not work, I understand that.

My program is a kind of addition to those tools (Programs) that do not have some of the functions.
For example: A broken sensor on the device, and the data is needed by the client. CM2 could not merge (well, I could not, I myself do not know why). Through MTK droid tools - you need to enable debugging, this is not how. because the sensor does not plow.
I merge SPFT and what's next .... And then dances with a tambourine. You need to pull out the UserData section for mounting, etc.
That is, I have paid software, but I can not do it.

Maybe I, of course, in what is wrong!?

[Foxtrot_KZ]

Vvaaavv @ 05/11/17, 11:38

Maybe I, of course, in what is wrong!?

I repeat, all right.
Therefore, we wait, we hope;)

[vvaaavv]

Foxtrot_KZ @ 05/11/17 06:38

While a question on the interface.
Is it just my prog that when I enlarge the window, does it look like this?

It is necessary to deal with this.
There the problem with the font is similar.
It is necessary today to change and give you a test

[vvaaavv]

Foxtrot_KZ @ 05/11/17 07:12

Now, someone can manually make a scatter and cut a preloader on a full dump by manually analyzing the blocks, but for 99.9999% this is “very heavy weight”

Well, you just can’t do a scatter file looking at a ROM file .. For example, there are empty sections, for example seccfg, and many more. What if you start to figure it out, so everything .... you can get completely confused ... For example, with some MT6795 / 97, so there are 20-28 different sections, most of them do not understand how to define in the Rom file. If anyone knows how to manually parse the Rom file (without using PMT or PGPT partitions), please give this information !!! Because even in MBR + EBR1 there is no information on all sections.

[Bodya-kolibass]

Foxtrot_KZ @ 05/11/17 07:12

by full dump

And do not need a full dump. We need the first 512 kb of the USER region (0x8000) - this is with regard to GPT. There your cherished scatter lies, of course not in the form in which we used to see it, but the data for the scatter is clearly visible there. Again, it was repeatedly said that scatters for identical stones differ only in the size of the so-called. system partitions (system, cache, userdata).

Foxtrot_KZ @ 05/11/17 07:12

but for 99.9999% this is a "heavy weight"

Well what can I say .... Android is generally a complicated thing, although if you look at it, it’s not all that difficult ...

Graysaf @ 05/11/17, 09:00

And it does not work out properly

Vvaaavv @ 11.05.17, 10:26

Well, just can not do the file scatter

Yes, everything is possible ... but only using it (pmt, pgpt - everything is there). An example of the implementation of such a possibility -here. Then of course, again, I will have to work a little with my hands, but I think that this matter can be corrected. Well, for example, to put the scatter patterns for certain stones into the utility's work and fill them with the received data ... Again, somehow (I am not a programmer) ...
P.S. I personally have always done with my hands and repeatedly told the order of actions.

[Bodya-kolibass]

vvaaavv
BUThereThe principle of finding the necessary data in pgpt / sgpt.

[vvaaavv]

Bodya-Kolibass @ 05/11/17, 10:52

but only using it (pmt, pgpt - everything is there). An example of the implementation of such a possibility - here.

Implemented in my program. You just need to select the Rom file, go to the tab<search sections>to push<Search>If the section is in the Rom file, the program will write: Yes !!! Found PGPT or PMT section. Accordingly, we poke twice on this<There is!!!>- this section opens in a clear form, then<Copy to Cut ROM>there further create a scatter

[Bodya-kolibass]

Vvaaavv @ 05/11/17, 11:12

Implemented

So what was this conversation all about?I just did not “chase” another fresh version ...
I think it is worth writing a small instruction on how to use the utility.

[vvaaavv]

Graysaf @ 05/11/17, 11:23

damn, even where I mentioned it

Well ... I need to write the instructions .. I will deal with this issue

[Foxtrot_KZ]

Bodya-Kolibass @ 05/11/17, 13:52

Again, it was repeatedly said that scatters for identical stones differ only in the size of the so-called. system partitions

Yes indeed it is said many times -BUT this is WRONG!
In fact, there is - REFERENCE, and there are firms that, for their own reasons, change the size of sections in the scatter. (In order to protect itp)

Here are two scatters,(I searched for less than a minute)

1

############################################################################################################
#
# General Setting
#
############################################################################################################
- general: MTK_PLATFORM_CFG
info:
- config_version: V1.1.1
platform: MT6582
project: slw
storage: EMMC
boot_channel: MSDC_0
block_size: 0x20000
############################################################################################################
#
# Layout Setting
#
############################################################################################################
- partition_index: SYS0
partition_name: PRELOADER
file_name: preloader_slw.bin
is_download: true
type: SV5_BL_BIN
linear_start_addr: 0x0
physical_start_addr: 0x0
partition_size: 0xc00000
region: EMMC_BOOT_1
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: BOOTLOADERS
reserve: 0x00

- partition_index: SYS1
partition_name: MBR
file_name: MBR
is_download: true
type: NORMAL_ROM
linear_start_addr: 0xc00000
physical_start_addr: 0x0
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS2
partition_name: EBR1
file_name: EBR1
is_download: true
type: NORMAL_ROM
linear_start_addr: 0xc80000
physical_start_addr: 0x80000
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS3
partition_name: PRO_INFO
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0xd00000
physical_start_addr: 0x100000
partition_size: 0x300000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: PROTECTED
reserve: 0x00

- partition_index: SYS4
partition_name: NVRAM
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x1000000
physical_start_addr: 0x400000
partition_size: 0x500000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: BINREGION
reserve: 0x00

- partition_index: SYS5
partition_name: PROTECT_F
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x1500000
physical_start_addr: 0x900000
partition_size: 0xa00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: PROTECTED
reserve: 0x00

- partition_index: SYS6
partition_name: PROTECT_S
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x1f00000
physical_start_addr: 0x1300000
partition_size: 0xa00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: PROTECTED
reserve: 0x00

- partition_index: SYS7
partition_name: SECCFG
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x2900000
physical_start_addr: 0x1d00000
partition_size: 0x20000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS8
partition_name: UBOOT
file_name: lk.bin
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x2920000
physical_start_addr: 0x1d20000
partition_size: 0x60000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS9
partition_name: BOOTIMG
file_name: boot.img
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x2980000
physical_start_addr: 0x1d80000
partition_size: 0x1000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS10
partition_name: RECOVERY
file_name: recovery.img
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x3980000
physical_start_addr: 0x2d80000
partition_size: 0x1000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS11
partition_name: SEC_RO
file_name: secro.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x4980000
physical_start_addr: 0x3d80000
partition_size: 0x600000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS12
partition_name: MISC
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x4f80000
physical_start_addr: 0x4380000
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS13
partition_name: LOGO
file_name: logo.bin
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x5000000
physical_start_addr: 0x4400000
partition_size: 0x300000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS14
partition_name: EBR2
file_name: EBR2
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x5300000
physical_start_addr: 0x4700000
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS15
partition_name: PRELOAD
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x5380000
physical_start_addr: 0x4780000
partition_size: 0x2000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS16
partition_name: EXPDB
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x7380000
physical_start_addr: 0x6780000
partition_size: 0xa00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS17
partition_name: ANDROID
file_name: system.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x7d80000
physical_start_addr: 0x7180000
partition_size: 0x89800000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS18
partition_name: CACHE
file_name: cache.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x91580000
physical_start_addr: 0x90980000
partition_size: 0x7e00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS19
partition_name: USRDATA
file_name: userdata.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x99380000
physical_start_addr: 0x98780000
partition_size: 0x39c00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS20
partition_name: BMTPOOL
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0xFFFF00a8
physical_start_addr: 0xffff00a8
partition_size: 0x1500000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: false
is_reserved: true
operation_type: RESERVED
reserve: 0x00

2

############################################################################################################
#
# General Setting
#
############################################################################################################
- general: MTK_PLATFORM_CFG
info:
- config_version: V1.1.1
platform: MT6582
project: phaeton
storage: EMMC
boot_channel: MSDC_0
block_size: 0x20000
############################################################################################################
#
# Layout Setting
#
############################################################################################################
- partition_index: SYS0
partition_name: PRELOADER
file_name: preloader_phaeton.bin
is_download: true
type: SV5_BL_BIN
linear_start_addr: 0x0
physical_start_addr: 0x0
partition_size: 0x1400000
region: EMMC_BOOT_1
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: BOOTLOADERS
reserve: 0x00

- partition_index: SYS1
partition_name: MBR
file_name: MBR
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x1400000
physical_start_addr: 0x0
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS2
partition_name: EBR1
file_name: EBR1
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x1480000
physical_start_addr: 0x80000
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS3
partition_name: PRO_INFO
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x1500000
physical_start_addr: 0x100000
partition_size: 0x300000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: PROTECTED
reserve: 0x00

- partition_index: SYS4
partition_name: NVRAM
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x1800000
physical_start_addr: 0x400000
partition_size: 0x500000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: BINREGION
reserve: 0x00

- partition_index: SYS5
partition_name: PROTECT_F
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x1d00000
physical_start_addr: 0x900000
partition_size: 0xa00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: PROTECTED
reserve: 0x00

- partition_index: SYS6
partition_name: PROTECT_S
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x2700000
physical_start_addr: 0x1300000
partition_size: 0xa00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: PROTECTED
reserve: 0x00

- partition_index: SYS7
partition_name: SECCFG
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x3100000
physical_start_addr: 0x1d00000
partition_size: 0x20000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS8
partition_name: UBOOT
file_name: lk.bin
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x3120000
physical_start_addr: 0x1d20000
partition_size: 0x60000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS9
partition_name: BOOTIMG
file_name: boot.img
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x3180000
physical_start_addr: 0x1d80000
partition_size: 0x1000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS10
partition_name: RECOVERY
file_name: recovery.img
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x4180000
physical_start_addr: 0x2d80000
partition_size: 0xc00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS11
partition_name: SEC_RO
file_name: secro.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x4d80000
physical_start_addr: 0x3980000
partition_size: 0x600000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS12
partition_name: MISC
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x5380000
physical_start_addr: 0x3f80000
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS13
partition_name: LOGO
file_name: logo.bin
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x5400000
physical_start_addr: 0x4000000
partition_size: 0x300000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS14
partition_name: EBR2
file_name: EBR2
is_download: true
type: NORMAL_ROM
linear_start_addr: 0x5700000
physical_start_addr: 0x4300000
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS15
partition_name: EXPDB
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0x5780000
physical_start_addr: 0x4380000
partition_size: 0xa00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: INVISIBLE
reserve: 0x00

- partition_index: SYS16
partition_name: PRELOAD
file_name: NONE
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x6180000
physical_start_addr: 0x4d80000
partition_size: 0x12c00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS17
partition_name: ANDROID
file_name: system.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x18d80000
physical_start_addr: 0x17980000
partition_size: 0x4b000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS18
partition_name: CACHE
file_name: cache.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x63d80000
physical_start_addr: 0x62980000
partition_size: 0x7e00000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS19
partition_name: USRDATA
file_name: userdata.img
is_download: true
type: YAFFS_IMG
linear_start_addr: 0x6bb80000
physical_start_addr: 0x6a780000
partition_size: 0x60000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: true
is_reserved: false
operation_type: UPDATE
reserve: 0x00

- partition_index: SYS20
partition_name: BMTPOOL
file_name: NONE
is_download: false
type: NONE
linear_start_addr: 0xFFFF00a8
physical_start_addr: 0xffff00a8
partition_size: 0x1500000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: false
is_reserved: true
operation_type: RESERVED
reserve: 0x00

Download to comparator and see.
But I came across scatters from the same platforms with such "stuffing" inside that the Meat Grinders wept with envy))

offtop:
But the most TINESS was on the same machine.(I have no right to call)when redistribution occurred on the ota update with !!! TRAVEL !!! nvram and system data formatting, etc.

Post has been editedFoxtrot_KZ - 11.05.17, 12:16

[Bodya-kolibass]

Foxtrot_KZ,
I talked about GPT markup (on more "fresh" stones). :) On the MBR - I completely agree (especially with LG, there is generally a "mess").
vvaaavv
Regarding the creation of the scatter ... There is one moment (I just checked on a dump of some 6735, and I think it will be the same on the others too), namely: when reading the data, the descriptions of these sections are in the scatter

- partition_index: SYS27
partition_name: flashinfo
file_name: NONE
is_download: false
type: NORMAL_ROM
linear_start_addr: 0xFFFF0084
physical_start_addr: 0xFFFF0084
partition_size: 0x1000000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: false
is_reserved: true
operation_type: RESERVED
reserve: 0x00

- partition_index: SYS28
partition_name: sgpt
file_name: NONE
is_download: false
type: NORMAL_ROM
linear_start_addr: 0xFFFF0004
physical_start_addr: 0xFFFF0004
partition_size: 0x80000
region: EMMC_USER
storage: HW_STORAGE_EMMC
boundary_check: false
is_reserved: true
operation_type: RESERVED
reserve: 0x00

must remain unchangedfor allMT67xx processors. At the moment: flashinfo - at the end of the memory (although this is normal, but ...), and sgpt is not at all in the scatter (should be).

[vvaaavv]

Bodya-Kolibass @ 05/11/17, 12:35

must remain unchanged for all MT67xx processors. At the moment: flashinfo - at the end of the memory (although this is normal, but ...), and sgpt is not at all in the scatter (should be).

Strange .. there are a lot of things missing in PGPT. I already had to invent two sections about the preloader and the PGPT itself.
Come on in more detail. and if possible, throw off this PGPT section from Rom, I'll see it in the evening

[Foxtrot_KZ]

Vvaaavv @ 11.05.17, 13:18

It is necessary to deal with this.
There the problem with the font is similar.

mb because i have
Control Panel \ All Control Panel Items \ 150% Screen
?

[Bodya-kolibass]

Foxtrot_KZ, Nope "Net" Win10 x64 - the same story.