├── .gitignore
├── AUTHORS
├── ChangeLog
├── Makefile.am
├── NEWS
├── README
├── build.cmd
├── build.sh
├── config.h.in
├── configure.ac
├── emmcdl.win32.sln
├── emmcdl.win32.vcxproj
├── inc
    ├── crc.h
    ├── diskwriter.h
    ├── dload.h
    ├── emmcdl.h
    ├── ffu.h
    ├── firehose.h
    ├── list.h
    ├── partition.h
    ├── protocol.h
    ├── qcversion.h
    ├── sahara.h
    ├── serialport.h
    ├── sparse.h
    ├── sysdeps.h
    ├── targetver.h
    ├── usb.h
    └── xmlparser.h
└── src
    ├── crc.cpp
    ├── diskwriter_linux.cpp
    ├── diskwriter_windows.cpp
    ├── dload.cpp
    ├── emmcdl.cpp
    ├── ffu.cpp
    ├── firehose.cpp
    ├── partition.cpp
    ├── protocol.cpp
    ├── sahara.cpp
    ├── serialport.cpp
    ├── sparse.cpp
    ├── sysdeps_win32.cpp
    ├── usb_linux.c
    ├── usbport.cpp
    └── xmlparser.cpp


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.o
 2 | .gitignore
 3 | .deps
 4 | .dirstamp
 5 | stamp-h1
 6 | autom4te.cache
 7 | config.log
 8 | config.status
 9 | emmcdl
10 | Makefile
11 | compile
12 | COPYING
13 | INSTALL
14 | Makefile.in
15 | aclocal.m4
16 | autoscan.log
17 | bin
18 | config.h
19 | /configure
20 | /depcomp
21 | /install-sh
22 | /missing
23 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nijel8/emmcdl/3c5ac42189eb1ddc66afd58bc71e25577859f355/AUTHORS


--------------------------------------------------------------------------------
/ChangeLog:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nijel8/emmcdl/3c5ac42189eb1ddc66afd58bc71e25577859f355/ChangeLog


--------------------------------------------------------------------------------
/Makefile.am:
--------------------------------------------------------------------------------
 1 | AUTOMAKE_OPTIONS = subdir-objects
 2 | AM_CPPFLAGS =-I$(top_srcdir)/inc
 3 | AM_CXXFLAGS = -std=c++11 -fno-rtti -fno-exceptions -pthread
 4 | 
 5 | noinst_PROGRAMS = emmcdl
 6 | 
 7 | emmcdl_LDADD = -lrt
 8 | 
 9 | emmcdl_SOURCES = \
10 |                src/crc.cpp\
11 |                src/dload.cpp\
12 |                src/emmcdl.cpp\
13 |                src/firehose.cpp\
14 |                src/ffu.cpp\
15 |                src/sahara.cpp\
16 |                src/partition.cpp\
17 |                src/protocol.cpp\
18 |                src/usbport.cpp\
19 |                src/usb_linux.c\
20 |                src/sparse.cpp\
21 |                src/xmlparser.cpp
22 | 
23 | if SYSDEPS_WIN32
24 | AM_CPPFLAGS += -D_WIN32
25 | emmcdl_SOURCES += \
26 |                src/diskwriter_windows.cpp\
27 |                src/sysdeps_win32.cpp
28 | else
29 | emmcdl_SOURCES += \
30 |                src/diskwriter_linux.cpp
31 | endif
32 | 


--------------------------------------------------------------------------------
/NEWS:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nijel8/emmcdl/3c5ac42189eb1ddc66afd58bc71e25577859f355/NEWS


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | To build emmcdl with Autoconf 2.69 and Automake 1.15:
 2 | 
 3 | cd <to-source-dir>
 4 | 
 5 | $ aclocal
 6 | $ autoconf
 7 | $ automake --add-missing
 8 | 
 9 | $ ./configure
10 | 
11 | $ make
12 | 
13 | emmcdl linux binary in .(<source-dir>)
14 | 
15 | $ emmcdl
16 | Version 2.10
17 | Usage: emmcdl <option> <value>
18 |        Options:
19 |        -l                               List available mass storage devices
20 |        -info                            List HW information about device attached to COM (eg -p COM8 -info)
21 |        -MaxPayloadSizeToTargetInBytes   The max bytes in firehose mode (DDR or large IMEM use 16384, default=8192)
22 |        -SkipWrite                       Do not write actual data to disk (use this for UFS provisioning)
23 |        -SkipStorageInit                 Do not initialize storage device (use this for UFS provisioning)
24 |        -MemoryName <ufs/emmc>           Memory type default to emmc if none is specified
25 |        -SetActivePartition <num>        Set the specified partition active for booting
26 |        -disk_sector_size <int>          Dump from start sector to end sector to file
27 |        -d <start> <end>                 Dump from start sector to end sector to file
28 |        -d <PartName>                    Dump entire partition based on partition name
29 |        -d logbuf@<start> <size>         Dump size of logbuf to the console
30 |        -e <start> <num>                 Erase disk from start sector for number of sectors
31 |        -e <PartName>                    Erase the entire partition specified
32 |        -s <sectors>                     Number of sectors in disk image
33 |        -p <port or disk>                Port or disk to program to (eg COM8, for PhysicalDrive1 use 1)
34 |        -o <filename>                    Output filename
35 |        [<-x <*.xml> [-xd <imgdir>]>...] Program XML file to output type -o (output) -p (port or disk)
36 |        -f <flash programmer>            Flash programmer to load to IMEM eg MPRG8960.hex
37 |        -i <singleimage>                 Single image to load at offset 0 eg 8960_msimage.mbn
38 |        -t                               Run performance tests
39 |        -b <prtname> <binfile>           Write <binfile> to GPT <prtname>
40 |        -g GPP1 GPP2 GPP3 GPP4           Create GPP partitions with sizes in MB
41 |        -gq                              Do not prompt when creating GPP (quiet)
42 |        -r                               Reset device
43 |        -ffu <*.ffu>                     Download FFU image to device in emergency download need -o and -p
44 |        -splitffu <*.ffu> -o <xmlfile>   Split FFU into binary chunks and create rawprogram0.xml to output location
45 |        -protocol <s|f>                  Can be <s>(STREAMING),  default is <f>(FIREHOSE)
46 |        -gpt                             Dump the GPT from the connected device
47 |        -raw                             Send and receive RAW data to serial port 0x75 0x25 0x10
48 |        -wimei <imei>                    Write IMEI <imei>
49 |        -v                               Enable verbose output
50 | 
51 | 
52 | 
53 | Examples: emmcdl -p ttyUSB0 -info
54 |  emmcdl -p ttyUSB0 -gpt
55 |  emmcdl -p ttyUSB0 -SkipWrite -SkipStorageInit -MemoryName ufs -f prog_emmc_firehose_8994_lite.mbn -x memory_configure.xml
56 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -x rawprogram0.xml  -SetActivePartition 0
57 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -x rawprogram0.xml -xd imagedir  -SetActivePartition 0
58 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -ffu wp8.ffu
59 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -d 0 1000 -o dump_1_1000.bin
60 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -d SVRawDump -o svrawdump.bin
61 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -b SBL1 c:\temp\sbl1.mbn
62 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -e 0 100
63 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -e MODEM_FSG
64 |  emmcdl -p ttyUSB0 -f prog_emmc_firehose_8994_lite.mbn -raw 0x75 0x25 0x10
65 | 


--------------------------------------------------------------------------------
/build.cmd:
--------------------------------------------------------------------------------
1 | msbuild emmcdl.win32.sln /p:platform=Win32 /p:configuration=Release
2 | 


--------------------------------------------------------------------------------
/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # build it
 4 | # Autoconf 2.69
 5 | # Automake 1.15
 6 | 
 7 | aclocal
 8 | autoconf
 9 | automake --add-missing
10 | 
11 | ./configure
12 | 
13 | make # emmcdl linux binary in .
14 | 


--------------------------------------------------------------------------------
/config.h.in:
--------------------------------------------------------------------------------
 1 | /* config.h.in.  Generated from configure.ac by autoheader.  */
 2 | 
 3 | /* Define to 1 if you have the <inttypes.h> header file. */
 4 | #undef HAVE_INTTYPES_H
 5 | 
 6 | /* Define to 1 if your system has a GNU libc compatible `malloc' function, and
 7 |    to 0 otherwise. */
 8 | #undef HAVE_MALLOC
 9 | 
10 | /* Define to 1 if you have the <memory.h> header file. */
11 | #undef HAVE_MEMORY_H
12 | 
13 | /* Define to 1 if you have the `memset' function. */
14 | #undef HAVE_MEMSET
15 | 
16 | /* Define to 1 if stdbool.h conforms to C99. */
17 | #undef HAVE_STDBOOL_H
18 | 
19 | /* Define to 1 if you have the <stdint.h> header file. */
20 | #undef HAVE_STDINT_H
21 | 
22 | /* Define to 1 if you have the <stdlib.h> header file. */
23 | #undef HAVE_STDLIB_H
24 | 
25 | /* Define to 1 if you have the <strings.h> header file. */
26 | #undef HAVE_STRINGS_H
27 | 
28 | /* Define to 1 if you have the <string.h> header file. */
29 | #undef HAVE_STRING_H
30 | 
31 | /* Define to 1 if you have the `strstr' function. */
32 | #undef HAVE_STRSTR
33 | 
34 | /* Define to 1 if you have the <sys/stat.h> header file. */
35 | #undef HAVE_SYS_STAT_H
36 | 
37 | /* Define to 1 if you have the <sys/types.h> header file. */
38 | #undef HAVE_SYS_TYPES_H
39 | 
40 | /* Define to 1 if you have the <termios.h> header file. */
41 | #undef HAVE_TERMIOS_H
42 | 
43 | /* Define to 1 if you have the <unistd.h> header file. */
44 | #undef HAVE_UNISTD_H
45 | 
46 | /* Define to 1 if the system has the type `_Bool'. */
47 | #undef HAVE__BOOL
48 | 
49 | /* Name of package */
50 | #undef PACKAGE
51 | 
52 | /* Define to the address where bug reports for this package should be sent. */
53 | #undef PACKAGE_BUGREPORT
54 | 
55 | /* Define to the full name of this package. */
56 | #undef PACKAGE_NAME
57 | 
58 | /* Define to the full name and version of this package. */
59 | #undef PACKAGE_STRING
60 | 
61 | /* Define to the one symbol short name of this package. */
62 | #undef PACKAGE_TARNAME
63 | 
64 | /* Define to the home page for this package. */
65 | #undef PACKAGE_URL
66 | 
67 | /* Define to the version of this package. */
68 | #undef PACKAGE_VERSION
69 | 
70 | /* Define to 1 if you have the ANSI C header files. */
71 | #undef STDC_HEADERS
72 | 
73 | /* Version number of package */
74 | #undef VERSION
75 | 
76 | /* Define to `__inline__' or `__inline' if that's what the C compiler
77 |    calls it, or to nothing if 'inline' is not supported under any name.  */
78 | #ifndef __cplusplus
79 | #undef inline
80 | #endif
81 | 
82 | /* Define to rpl_malloc if the replacement function should be used. */
83 | #undef malloc
84 | 
85 | /* Define to `unsigned int' if <sys/types.h> does not define. */
86 | #undef size_t
87 | 


--------------------------------------------------------------------------------
/configure.ac:
--------------------------------------------------------------------------------
 1 | #                                               -*- Autoconf -*-
 2 | # Process this file with autoconf to produce a configure script.
 3 | 
 4 | AC_PREREQ(2.69)
 5 | AC_INIT(emmcdl, 1.0, cchua.cn@gmail.com)
 6 | AC_CONFIG_SRCDIR([inc/diskwriter.h])
 7 | AC_CONFIG_HEADERS(config.h)
 8 | AM_INIT_AUTOMAKE
 9 | 
10 | # Checks for programs.
11 | AC_PROG_CXX
12 | AC_PROG_CC
13 | 
14 | # Checks for libraries.
15 | 
16 | # Checks for header files.
17 | AC_CHECK_HEADERS(stdlib.h string.h termios.h)
18 | 
19 | # Checks for typedefs, structures, and compiler characteristics.
20 | AC_HEADER_STDBOOL
21 | AC_C_INLINE
22 | AC_TYPE_SIZE_T
23 | 
24 | # Checks for library functions.
25 | AC_FUNC_MALLOC
26 | AC_CHECK_FUNCS(memset strstr)
27 | AC_PROG_RANLIB
28 | 
29 | 
30 | AC_ARG_ENABLE([sysdeps],
31 | [  --enable-sysdeps Turn on debugging],
32 | [case "${enableval}" in
33 |   yes) sysdeps=true ;;
34 |   no)  sysdeps=false ;;
35 |   *) AC_MSG_ERROR([bad value ${enableval} for --enable-sysdeps]) ;;
36 | esac],[sysdeps=false])
37 | AM_CONDITIONAL([SYSDEPS_WIN32], [test x$sysdeps = xtrue])
38 | 
39 | 
40 | AC_OUTPUT(Makefile)
41 | 


--------------------------------------------------------------------------------
/emmcdl.win32.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2012
 4 | Project("{58BBC25A-B7DA-4FEA-83BF-8C33DC4F7C1F}") = "emmcdl", "emmcdl.win32.vcxproj", "{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|Win32 = Debug|Win32
 9 | 		Release|Win32 = Release|Win32
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}.Debug|Win32.ActiveCfg = Debug|Win32
13 | 		{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}.Debug|Win32.Build.0 = Debug|Win32
14 | 		{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}.Debug|Win32.Deploy.0 = Debug|Win32
15 | 		{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}.Release|Win32.ActiveCfg = Release|Win32
16 | 		{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}.Release|Win32.Build.0 = Release|Win32
17 | 		{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}.Release|Win32.Deploy.0 = Release|Win32
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | EndGlobal
23 | 


--------------------------------------------------------------------------------
/emmcdl.win32.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <!-- Set path to QC build extensions installed with WDK. -->
  4 |   <ItemGroup Label="ProjectConfigurations">
  5 |     <ProjectConfiguration Include="Debug|Win32">
  6 |       <Configuration>Debug</Configuration>
  7 |       <Platform>Win32</Platform>
  8 |     </ProjectConfiguration>
  9 |     <ProjectConfiguration Include="Release|Win32">
 10 |       <Configuration>Release</Configuration>
 11 |       <Platform>Win32</Platform>
 12 |     </ProjectConfiguration>
 13 |   </ItemGroup>
 14 |   <PropertyGroup Label="Globals">
 15 |     <ProjectGuid>{6DDC320B-E4EF-40E3-AF4E-E2C4402BAE2D}</ProjectGuid>
 16 |     <Keyword>Win32Proj</Keyword>
 17 |     <RootNamespace>emmcdl.wp63.vcxproj</RootNamespace>
 18 |     <ProjectName>emmcdl</ProjectName>
 19 |   </PropertyGroup>
 20 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 21 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 22 |     <ConfigurationType>Application</ConfigurationType>
 23 |     <UseDebugLibraries>true</UseDebugLibraries>
 24 |     <CharacterSet>Unicode</CharacterSet>
 25 |     <BuildWindowsPhone>true</BuildWindowsPhone>
 26 |     <PlatformToolset>v$(VisualStudioVersion.Replace('.',''))</PlatformToolset>
 27 |     <UseOfMfc>false</UseOfMfc>
 28 |   </PropertyGroup>
 29 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 30 |     <ConfigurationType>Application</ConfigurationType>
 31 |     <UseDebugLibraries>false</UseDebugLibraries>
 32 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 33 |     <CharacterSet>Unicode</CharacterSet>
 34 |     <BuildWindowsPhone>true</BuildWindowsPhone>
 35 |     <PlatformToolset>v$(VisualStudioVersion.Replace('.',''))</PlatformToolset>
 36 |   </PropertyGroup>
 37 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 38 |   <ImportGroup Label="ExtensionSettings">
 39 |   </ImportGroup>
 40 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 41 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 42 |   </ImportGroup>
 43 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 44 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 45 |   </ImportGroup>
 46 |   <PropertyGroup Label="UserMacros" />
 47 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 48 |     <LinkIncremental>false</LinkIncremental>
 49 |   </PropertyGroup>
 50 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 51 |     <LinkIncremental>false</LinkIncremental>
 52 |   </PropertyGroup>
 53 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 54 |     <ClCompile>
 55 |       <PrecompiledHeader>NotUsing</PrecompiledHeader>
 56 |       <Optimization>Disabled</Optimization>
 57 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 58 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
 59 |       <AdditionalIncludeDirectories>$(SolutionDir)\inc</AdditionalIncludeDirectories>
 60 |       <PrecompiledHeaderFile />
 61 |       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
 62 |       <WarningLevel>Level4</WarningLevel>
 63 |       <TreatWarningAsError>true</TreatWarningAsError>
 64 |     </ClCompile>
 65 |     <Link>
 66 |       <SubSystem>Console</SubSystem>
 67 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 68 |       <AdditionalDependencies>Advapi32.lib;setupapi.lib;uuid.lib</AdditionalDependencies>
 69 |       <AddModuleNamesToAssembly>
 70 |       </AddModuleNamesToAssembly>
 71 |       <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
 72 |     </Link>
 73 |   </ItemDefinitionGroup>
 74 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 75 |     <ClCompile>
 76 |       <PrecompiledHeader>NotUsing</PrecompiledHeader>
 77 |       <Optimization>MaxSpeed</Optimization>
 78 |       <FunctionLevelLinking>true</FunctionLevelLinking>
 79 |       <IntrinsicFunctions>true</IntrinsicFunctions>
 80 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 81 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
 82 |       <AdditionalIncludeDirectories>$(SolutionDir)\inc</AdditionalIncludeDirectories>
 83 |       <PrecompiledHeaderFile />
 84 |       <TreatWarningAsError>true</TreatWarningAsError>
 85 |       <WarningLevel>Level4</WarningLevel>
 86 |     </ClCompile>
 87 |     <Link>
 88 |       <SubSystem>Console</SubSystem>
 89 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 90 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
 91 |       <OptimizeReferences>true</OptimizeReferences>
 92 |       <AdditionalDependencies>Advapi32.lib;setupapi.lib;uuid.lib</AdditionalDependencies>
 93 |       <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
 94 |     </Link>
 95 |   </ItemDefinitionGroup>
 96 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
 97 |   <ImportGroup Label="ExtensionTargets">
 98 |   </ImportGroup>
 99 |   <ItemGroup>
100 |     <ClInclude Include="inc\crc.h" />
101 |     <ClInclude Include="inc\diskwriter.h" />
102 |     <ClInclude Include="inc\dload.h" />
103 |     <ClInclude Include="inc\emmcdl.h" />
104 |     <ClInclude Include="inc\ffu.h" />
105 |     <ClInclude Include="inc\firehose.h" />
106 |     <ClInclude Include="inc\partition.h" />
107 |     <ClInclude Include="inc\protocol.h" />
108 |     <ClInclude Include="inc\qcversion.h" />
109 |     <ClInclude Include="inc\sahara.h" />
110 |     <ClInclude Include="inc\serialport.h" />
111 |     <ClInclude Include="inc\sparse.h" />
112 |     <ClInclude Include="inc\targetver.h" />
113 |     <ClInclude Include="inc\xmlparser.h" />
114 |   </ItemGroup>
115 |   <ItemGroup>
116 |     <ClCompile Include="src\crc.cpp" />
117 |     <ClCompile Include="src\diskwriter.cpp" />
118 |     <ClCompile Include="src\dload.cpp" />
119 |     <ClCompile Include="src\emmcdl.cpp" />
120 |     <ClCompile Include="src\ffu.cpp" />
121 |     <ClCompile Include="src\firehose.cpp" />
122 |     <ClCompile Include="src\partition.cpp" />
123 |     <ClCompile Include="src\protocol.cpp" />
124 |     <ClCompile Include="src\sahara.cpp" />
125 |     <ClCompile Include="src\serialport.cpp" />
126 |     <ClCompile Include="src\sparse.cpp" />
127 |     <ClCompile Include="src\xmlparser.cpp" />
128 |   </ItemGroup>
129 | </Project>


--------------------------------------------------------------------------------
/inc/crc.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifdef _WIN32
 3 | #ifdef _WIN32
 4 | #include <Windows.h>
 5 | #endif
 6 | #endif
 7 | 
 8 | #define CRC_16_L_SEED         0xFFFF
 9 | extern const unsigned short crc_16_l_table[];
10 | 
11 | #define CRC_16_L_STEP(xx_crc,xx_c) \
12 |   (((xx_crc) >> 8) ^ crc_16_l_table[((xx_crc) ^ (xx_c)) & 0x00ff])
13 | 
14 | unsigned short CalcCRC16(unsigned char *buf, int length);


--------------------------------------------------------------------------------
/inc/diskwriter.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * diskwriter.h
  3 |  *
  4 |  * This file defines the interface for the DiskWriter class
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/diskwriter.h#7 $
 16 | $DateTime: 2015/04/29 17:06:00 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 10/10/11   pgw     Fix up spacing and add hVolume
 21 | 03/21/11   pgw     Initial version.
 22 | =============================================================================*/
 23 | #pragma once
 24 | 
 25 | #include "partition.h"
 26 | #include "protocol.h"
 27 | #include "sysdeps.h"
 28 | #include <string.h>
 29 | #include <stdlib.h>
 30 | 
 31 | #define WRITE_TIMEOUT_MS    3000
 32 | #define MAX_VOLUMES         26
 33 | #define MAX_DISKS         26
 34 | 
 35 | 
 36 | typedef struct {
 37 |   int32_t	     serialnum;
 38 |   int32_t      drivetype;
 39 |   __uint64_t volsize;
 40 |   int          disknum;
 41 |   char        fstype[MAX_PATH+1];
 42 |   char        mount[MAX_PATH+1];
 43 |   char        rootpath[MAX_PATH+1];
 44 |   char        volume[MAX_PATH+1];
 45 | } vol_entry_t;
 46 | 
 47 | typedef struct {
 48 |   __uint64_t disksize;
 49 |   int          blocksize;
 50 |   int          disknum;
 51 |   int          volnum[MAX_VOLUMES+1];
 52 |   char        diskname[MAX_PATH+1];
 53 | } disk_entry_t;
 54 | 
 55 | class DiskWriter : public Protocol {
 56 | public:
 57 |   int diskcount;
 58 |   bool bPatchDisk;
 59 | 
 60 |   DiskWriter();
 61 |   ~DiskWriter();
 62 | 
 63 |   int WriteData(unsigned char *writeBuffer, int64_t writeOffset, uint32_t writeBytes, uint32_t *bytesWritten, uint8_t partNum);
 64 |   int ReadData(unsigned char *readBuffer, int64_t readOffset, uint32_t readBytes, uint32_t *bytesRead, uint8_t partNum);
 65 | 
 66 |   int FastCopy(int hRead, int64_t sectorRead, int hWrite, int64_t sectorWrite, __uint64_t sectors, uint8_t partNum=0);
 67 |   int OpenDevice(int dn);
 68 |   int OpenDiskFile(char *oFile, __uint64_t sectors);
 69 |   void CloseDevice();
 70 |   int InitDiskList(bool verbose = false);
 71 |   int DeviceReset(void);
 72 |   int ProgramPatchEntry(PartitionEntry pe, char *key);
 73 |   int ProgramRawCommand(char *key);
 74 | 
 75 |   // Functions for testing purposes
 76 |   int CorruptionTest(__uint64_t offset);
 77 |   int DiskTest(__uint64_t offset);
 78 |   int WipeLayout();
 79 | 
 80 | protected:
 81 | 
 82 | private:
 83 |   int hVolume;
 84 |   int disk_num;
 85 |   int hFS;
 86 |   //OVERLAPPED ovl;
 87 |   disk_entry_t *disks;
 88 |   vol_entry_t *volumes;
 89 | 
 90 |   int GetVolumeInfo(vol_entry_t *vol);
 91 |   int GetDiskInfo(disk_entry_t *de);
 92 |   char *TCharToString(char *p);
 93 |   int UnmountVolume(vol_entry_t vol);
 94 |   int LockDevice();
 95 |   int UnlockDevice();
 96 |   bool IsDeviceWriteable();
 97 |   int GetRawDiskSize(__uint64_t *ds);
 98 |   int RawReadTest(__uint64_t offset);
 99 | };
100 | 


--------------------------------------------------------------------------------
/inc/dload.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * dload.h
  3 |  *
  4 |  * This file implements the streaming download protocol
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/dload.h#2 $
 16 | $DateTime: 2014/08/05 11:44:01 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 11/08/11   pgw     Initial version.
 21 | =============================================================================*/
 22 | #pragma once
 23 | 
 24 | #include "serialport.h"
 25 | #include "partition.h"
 26 | #include <stdio.h>
 27 | #include "sysdeps.h"
 28 | 
 29 | #define PACKET_TIMEOUT  1000
 30 | 
 31 | #define FEATURE_SECTOR_ADDRESSES   0x00000010
 32 | 
 33 | // Packets that are used in dload mode
 34 | #define CMD_WRITE  0x01   /* Write a block of data to memory (received)    */
 35 | #define CMD_ACK    0x02   /* Acknowledge receiving a packet  (transmitted) */
 36 | #define CMD_NAK    0x03   /* Acknowledge a bad packet        (transmitted) */
 37 | #define CMD_ERASE  0x04   /* Erase a block of memory         (received)    */
 38 | #define CMD_GO     0x05   /* Begin execution at an address   (received)    */
 39 | #define CMD_NOP    0x06   /* No operation, for debug         (received)    */
 40 | #define CMD_PREQ   0x07   /* Request implementation info     (received)    */
 41 | #define CMD_PARAMS 0x08   /* Provide implementation info     (transmitted) */
 42 | #define CMD_DUMP   0x09   /* Debug: dump a block of memory   (received)    */
 43 | #define CMD_RESET  0x0A   /* Reset the phone                 (received)    */
 44 | #define CMD_UNLOCK 0x0B   /* Unlock access to secured ops    (received)    */
 45 | #define CMD_VERREQ 0x0C   /* Request software version info   (received)    */
 46 | #define CMD_VERRSP 0x0D   /* Provide software version info   (transmitted) */
 47 | #define CMD_PWROFF 0x0E   /* Turn phone power off            (received)    */
 48 | #define CMD_WRITE_32BIT 0x0F  /* Write a block of data to 32-bit memory */
 49 | #define CMD_MEM_DEBUG_QUERY 0x10 /* Memory debug query       (received)    */
 50 | #define CMD_MEM_DEBUG_INFO  0x11 /* Memory debug info        (transmitted) */
 51 | #define CMD_MEM_READ_REQ    0x12 /* Memory read request      (received)    */
 52 | #define CMD_MEM_READ_RESP   0x13 /* Memory read response     (transmitted) */
 53 | #define CMD_MEM_UNFRAMED_READ_REQ  0x14 /* Memory unframed read request   (received)      */
 54 | #define CMD_MEM_UNFRAMED_READ_RESP 0x15 /* Memory unframed read response  (transmitted)   */
 55 | #define CMD_SERIAL_NUM_READ   0x16 /* Return Serial number from efuse read   */
 56 | #define CMD_MSM_HW_ID_READ    0x17 /* Return msm_hw_id from efuse read   */
 57 | #define CMD_OEM_HASH_KEY_READ 0x18 /* Return oem_pk_hash from efuse read   */
 58 | #define CMD_QPST_COOKIE_READ_REQ 0x19 /* QPST cookie read request      (received)    */
 59 | #define CMD_QPST_COOKIE_READ_RESP 0x1A /* QPST cookie read response     (transmitted) */      
 60 | #define CMD_DLOAD_SWITCH 0x3A
 61 | 
 62 | // Partition types
 63 | #define PRTN_PBL          1 // don't change value
 64 | #define PRTN_QCSBLDHDR    2 // don't change value
 65 | #define PRTN_QCSBL        3 // don't change value
 66 | #define PRTN_OEMSBL       4 // don't change value
 67 | #define PRTN_MODEM        5 // don't change value
 68 | #define PRTN_APPS         6 // don't change value
 69 | #define PRTN_OTPBL        7 // don't change value
 70 | #define PRTN_FOTAUI       8	// don't change value
 71 | #define PRTN_CEFS         9 // Write CEFS to the modem f/s
 72 | #define PRTN_APPSBL      10 // don't change value
 73 | #define PRTN_CEFSAPPS    11 // Write CEFS to the apps f/s
 74 | #define PRTN_WINMOBILE   12 // Microsoft WinMobile image
 75 | #define PRTN_QDSP6       13 // QDSP6 executable
 76 | #define PRTN_USER        14 // User defined partition data
 77 | #define PRTN_DBL         15 // SB 2.0 Device boot loader
 78 | #define PRTN_OSBL        16 // SB 2.0 OS boot loader
 79 | #define PRTN_FSBL        17 // SB 2.0 Failsafe boot loader
 80 | #define PRTN_QDSP6_2     18 // dsp2.mbn
 81 | #define PRTN_RAWAPPSEFS  19 // Raw (includes ECC + spare data) 
 82 | #define PRTN_ROFS1       20 // 0x14 - Symbian
 83 | #define PRTN_ROFS2       21 // 0x15 - Symbian
 84 | #define PRTN_ROFS3       22 // 0x16 - Symbian
 85 | #define PRTN_MBR         32 // mbr.bin for NOR (boot) + MoviNand (AMSS+APPS)
 86 | #define PRTN_EMMCUSER    33 // For programming eMMC chip (singleimage.mbn)
 87 | #define PRTN_EMMCBOOT0   34 // BOOT and GPP partitions
 88 | #define PRTN_EMMCBOOT1   35
 89 | #define PRTN_EMMCRPMB    36
 90 | #define PRTN_EMMCGPP1    37
 91 | #define PRTN_EMMCGPP2    38
 92 | #define PRTN_EMMCGPP3    39
 93 | #define PRTN_EMMCGPP4    40
 94 | 
 95 | // Packets that are used in emergency download mode
 96 | #define EHOST_HELLO_REQ  0x01   // Hello request
 97 | #define EHOST_HELLO_RSP  0x02   // Hello response
 98 | #define EHOST_SIMPLE_READ_REQ   0x03   // Read some number of bytes from phone memory
 99 | #define EHOST_SIMPLE_READ_RSP   0x04   // Response to simple read
100 | #define EHOST_SIMPLE_WRITE_REQ  0x05   // Write data without erase
101 | #define EHOST_SIMPLE_WRITE_RSP  0x06   // Response to simple write
102 | #define EHOST_STREAM_WRITE_REQ  0x07   // Streaming write command
103 | #define EHOST_STREAM_WRITE_RSP  0x08   // Response to stream write
104 | #define EHOST_NOP_REQ           0x09   // NOP request
105 | #define EHOST_NOP_RSP           0x0A   // NOP response
106 | #define EHOST_RESET_REQ         0x0B   // Reset target
107 | #define EHSOT_RESET_ACK         0x0C   // Response to reset
108 | #define EHOST_ERROR             0x0D   // Target Error
109 | #define EHOST_LOG               0x0E   // Target informational message
110 | #define EHOST_UNLOCK_REQ        0x0F   // Unlock Target
111 | #define EHOST_UNLOCK_RSP        0x10   // Target unlocked
112 | #define EHOST_POWER_OFF_REQ     0x11   // Power off target
113 | #define EHOST_POWER_OFF_RSP     0x12   // Power off target response
114 | #define EHOST_OPEN_REQ          0x13   // Open for writing image
115 | #define EHOST_OPEN_RSP          0x14   // Response to open for writing image
116 | #define EHOST_CLOSE_REQ         0x15   // Close and flush last partial write to Flash
117 | #define EHOST_CLOSE_RSP         0x16   // Response to close and flush last partial write to Flash
118 | #define EHOST_SECURITY_REQ      0x17   // Send Security mode to use for programming images
119 | #define EHOST_SECURITY_RSP      0x18   // Response to Send Security mode
120 | #define EHOST_PARTITION_REQ     0x19   // Send partition table to use for programming images
121 | #define EHOST_PARTITION_RSP     0x1A   // Response to send partition table
122 | #define EHOST_OPEN_MULTI_REQ    0x1B   // Open for writing image (Multi-image mode only)
123 | #define EHOST_OPEN_MULTI_RSP    0x1C   // Response to open for writing image
124 | #define EHOST_ERASE_FLASH_REQ   0x1D   // Erase entire Flash device
125 | #define EHOST_ERASE_FLASH_RSP   0x1E   // Response to erase Flash
126 | #define EHOST_GET_ECC_REQ       0x1F   // Read current ECC generation status
127 | #define EHOST_GET_ECC_RSP       0x20   // Response to Get ECC state with current status
128 | #define EHOST_SET_ECC_REQ       0x21   // Enable/disable hardware ECC generation
129 | #define EHOST_SET_ECC_RSP       0x22   // Response to set ECC
130 | #define EHOST_STREAM_DLOAD_REQ  0x23   // New streaming download request
131 | #define EHOST_STREAM_DLOAD_RSP  0x24   // New streaming download response
132 | #define EHOST_UNFRAMED_REQ      0x30   // Unframed streaming write command
133 | #define EHOST_UNFRAMED_RSP      0x31   // Unframed streaming write response
134 | 
135 | 
136 | class Dload {
137 | public:
138 |   Dload(SerialPort *port);
139 |   int ConnectToFlashProg(unsigned char ver); //ver=2 for byte addressing and ver=3 for sector addressing
140 |   int DeviceReset(void);
141 |   int LoadPartition(char *filename);
142 |   int LoadImage(char *szSingleImage);
143 |   int CreateGPP(uint32_t dwGPP1, uint32_t dwGPP2, uint32_t dwGPP3, uint32_t dwGPP4);
144 |   int SetActivePartition();
145 |   int OpenPartition(int partition);
146 |   int ClosePartition();
147 |   int FastCopySerial(int hInFile, uint32_t sector, uint32_t sectors);
148 |   int LoadFlashProg(char *szFlashPrg);
149 |   int WriteRawProgramFile(char *szXMLFile);
150 |   int GetDloadParams(unsigned char *rsp, int len);
151 |   int IsDeviceInDload(void);
152 |   int WipeDiskContents(__uint64_t start_sector, __uint64_t num_sectors);
153 | 
154 | private:
155 |   void HexToByte(const char *hex, unsigned char *bin, int len);
156 |   uint32_t HexRunAddress(char *filename);
157 |   uint32_t HexDataLength(char *filename);
158 |   __uint64_t GetNumDiskSectors();
159 |   int ProgramPartitionEntry(PartitionEntry pe);
160 | 
161 |   SerialPort *sport;
162 |   bool bSectorAddress;
163 | };
164 | 


--------------------------------------------------------------------------------
/inc/emmcdl.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 |  * emmcdl.h
 3 |  *
 4 |  * This file has all definitions for command line parameters and structures
 5 |  *
 6 |  * Copyright (c) 2007-2011
 7 |  * Qualcomm Technologies Incorporated.
 8 |  * All Rights Reserved.
 9 |  * Qualcomm Confidential and Proprietary
10 |  *
11 |  *****************************************************************************/
12 | /*=============================================================================
13 |                         Edit History
14 | 
15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/emmcdl.h#3 $
16 | $DateTime: 2014/06/11 17:27:14 $ $Author: pweber $
17 | 
18 | when       who     what, where, why
19 | -------------------------------------------------------------------------------
20 | 11/28/11   pgw     Initial version.
21 | =============================================================================*/
22 | #pragma once
23 | 
24 | #define STREAMING_PROTOCOL  1
25 | #define FIREHOSE_PROTOCOL   2
26 | 
27 | enum emmc_cmd_e {
28 |   EMMC_CMD_NONE,
29 |   EMMC_CMD_LIST,
30 |   EMMC_CMD_DUMP,
31 |   EMMC_CMD_DUMP_LOG,
32 |   EMMC_CMD_ERASE,
33 |   EMMC_CMD_WRITE,
34 |   EMMC_CMD_WIPE,
35 |   EMMC_CMD_GPP,
36 |   EMMC_CMD_TEST,
37 |   EMMC_CMD_WRITE_GPT,
38 |   EMMC_CMD_RESET,
39 |   EMMC_CMD_FFU,
40 |   EMMC_CMD_LOAD_MRPG,
41 |   EMMC_CMD_GPT,
42 |   EMMC_CMD_SPLIT_FFU,
43 |   EMMC_CMD_RAW,
44 |   EMMC_CMD_LOAD_FFU,
45 |   EMMC_CMD_INFO,
46 |   EMMC_CMD_W_IMEI
47 | };
48 | 


--------------------------------------------------------------------------------
/inc/ffu.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * ffu.h
  3 |  *
  4 |  * This file has structures and functions for FFU format
  5 |  *
  6 |  * Copyright (c) 2007-2012
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/ffu.h#7 $
 16 | $DateTime: 2015/05/07 21:41:17 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 11/04/12   pgw     Initial version.
 21 | =============================================================================*/
 22 | #pragma once
 23 | #include "partition.h"
 24 | #include "serialport.h"
 25 | #include "firehose.h"
 26 | #include "sysdeps.h"
 27 | 
 28 | // Security Header struct. The first data read in from the FFU.
 29 | typedef struct _SECURITY_HEADER
 30 | {
 31 |     uint32_t cbSize;            // size of struct, overall
 32 |     unsigned char   signature[12];     // "SignedImage "
 33 |     uint32_t dwChunkSizeInKb;   // size of a hashed chunk within the image
 34 |     uint32_t dwAlgId;           // algorithm used to hash
 35 |     uint32_t dwCatalogSize;     // size of catalog to validate
 36 |     uint32_t dwHashTableSize;   // size of hash table
 37 | } SECURITY_HEADER;
 38 | 
 39 | // Image Header struct found within Image Header region of FFU
 40 | typedef struct _IMAGE_HEADER
 41 | {
 42 |     uint32_t  cbSize;           // sizeof(ImageHeader)
 43 |     unsigned char   Signature[12];    // "ImageFlash  "
 44 |     uint32_t  ManifestLength;   // in bytes
 45 |     uint32_t  dwChunkSize;      // Used only during image generation.
 46 | } IMAGE_HEADER;
 47 | 
 48 | // Store Header struct found within Store Header region of FFU
 49 | typedef struct _STORE_HEADER
 50 | {
 51 |     uint32_t dwUpdateType; // indicates partial or full flash
 52 |     uint16_t MajorVersion, MinorVersion; // used to validate struct
 53 |     uint16_t FullFlashMajorVersion, FullFlashMinorVersion; // FFU version, i.e. the image format
 54 |     char szPlatformId[192]; // string which indicates what device this FFU is intended to be written to
 55 |     uint32_t dwBlockSizeInBytes; // size of an image block in bytes � the device�s actual sector size may differ
 56 |     uint32_t dwWriteDescriptorCount; // number of write descriptors to iterate through
 57 |     uint32_t dwWriteDescriptorLength; // total size of all the write descriptors, in bytes (included so they can be read out up front and interpreted later)
 58 |     uint32_t dwValidateDescriptorCount; // number of validation descriptors to check
 59 |     uint32_t dwValidateDescriptorLength; // total size of all the validation descriptors, in bytes
 60 |     uint32_t dwInitialTableIndex; // block index in the payload of the initial (invalid) GPT
 61 |     uint32_t dwInitialTableCount; // count of blocks for the initial GPT, i.e. the GPT spans blockArray[idx..(idx + count -1)]
 62 |     uint32_t dwFlashOnlyTableIndex; // first block index in the payload of the flash-only GPT (included so safe flashing can be accomplished)
 63 |     uint32_t dwFlashOnlyTableCount; // count of blocks in the flash-only GPT
 64 |     uint32_t dwFinalTableIndex; // index in the table of the real GPT
 65 |     uint32_t dwFinalTableCount; // number of blocks in the real GPT
 66 | } STORE_HEADER;
 67 | 
 68 | 
 69 | enum DISK_ACCESS_METHOD
 70 | {
 71 |     DISK_BEGIN  = 0,
 72 |     DISK_SEQ    = 1,
 73 |     DISK_END    = 2
 74 | };
 75 | 
 76 | // Struct used in BLOCK_DATA_ENTRY structs to define where to put data on disk
 77 | typedef struct _DISK_LOCATION
 78 | {
 79 |     uint32_t dwDiskAccessMethod;
 80 |     uint32_t dwBlockIndex;
 81 | } DISK_LOCATION; 
 82 | 
 83 | typedef struct _BLOCK_DATA_ENTRY
 84 | {
 85 |     uint32_t dwLocationCount;
 86 |     uint32_t dwBlockCount;
 87 |     DISK_LOCATION rgDiskLocations[1];
 88 | } BLOCK_DATA_ENTRY;
 89 | 
 90 | class FFUImage {
 91 | public:
 92 |   int PreLoadImage(char *szFFUPath);
 93 |   int ProgramImage(Protocol *proto, int64_t dwOffset);
 94 |   int CloseFFUFile(void);
 95 |   void SetDiskSectorSize(int size);
 96 |   int SplitFFUBin(char *szPartName, char *szOutputFile);
 97 |   int FFUToRawProgram(char *szFFUName, char *szImagePath);
 98 |   FFUImage();
 99 |   ~FFUImage();
100 | 
101 | private:
102 |   void SetOffset(void** ovlVariable, uint64_t offset);
103 |   int CreateRawProgram(char *szFFUFile, char *szFileName);
104 |   int TerminateRawProgram(char *szFileName);
105 |   int DumpRawProgram(char *szFFUFile, char *szRawProgram);
106 |   int FFUDumpDisk(Protocol *proto);
107 |   int AddEntryToRawProgram(char *szRawProgram, char *szFileName, uint64_t ui64FileOffset, int64_t i64StartSector, uint64_t ui64NumSectors);
108 |   int ReadGPT(void);
109 |   int ParseHeaders(void);
110 |   uint64_t GetNextStartingArea(uint64_t chunkSizeInBytes, uint64_t sizeOfArea);
111 | 
112 |   // Headers found within FFU image
113 |   SECURITY_HEADER FFUSecurityHeader;
114 |   IMAGE_HEADER FFUImageHeader;
115 |   STORE_HEADER FFUStoreHeader;
116 |   unsigned char* ValidationEntries;
117 |   BLOCK_DATA_ENTRY* BlockDataEntries;
118 |   uint64_t PayloadDataStart;
119 | 
120 |   int hFFU;
121 |   void* OvlRead;
122 |   void* OvlWrite;
123 | 
124 |   // GPT Stuff
125 |   unsigned char GptProtectiveMBR[512];
126 |   gpt_header_t GptHeader;
127 |   gpt_entry_t *GptEntries;
128 |   int DISK_SECTOR_SIZE;
129 | 
130 | };
131 | 
132 | 
133 | 


--------------------------------------------------------------------------------
/inc/firehose.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * firehose.h
  3 |  *
  4 |  * This file implements the streaming download protocol
  5 |  *
  6 |  * Copyright (c) 2007-2013
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/firehose.h#11 $
 16 | $DateTime: 2015/04/01 17:01:45 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 02/06/13   pgw     Initial version.
 21 | =============================================================================*/
 22 | #pragma once
 23 | 
 24 | #include "serialport.h"
 25 | #include "protocol.h"
 26 | #include "partition.h"
 27 | #include "list.h"
 28 | #include <stdio.h>
 29 | #include <stdint.h>
 30 | #include "sysdeps.h"
 31 | 
 32 | #define MAX_RETRY   50
 33 | 
 34 | typedef struct {
 35 |   unsigned char Version;
 36 |   char MemoryName[8];
 37 |   bool SkipWrite;
 38 |   bool SkipStorageInit;
 39 |   bool ZLPAwareHost;
 40 |   int ActivePartition;
 41 |   int MaxPayloadSizeToTargetInBytes;
 42 |   int AckRawDataEveryNumPackets;
 43 | } fh_configure_t;
 44 | 
 45 | typedef struct {
 46 |   struct listnode blist;
 47 |   uint32_t len;
 48 |   unsigned char data[4];
 49 | } CBuffer;
 50 | 
 51 | class Firehose;
 52 | 
 53 | typedef struct {
 54 |    Firehose *fh;
 55 |    uint64_t sectors;
 56 |    pthread_mutex_t *pmutex;
 57 |    pthread_cond_t  *pcond;
 58 |    listnode *prnode;
 59 |    listnode *pwnode;
 60 |    int hWrite;
 61 |    int DISK_SECTOR_SIZE;
 62 | }  thread_info;
 63 | class Firehose : public Protocol {
 64 | public:
 65 |   Firehose(SerialPort *port, uint32_t maxPacketSize = (1024*1024), int hLogFile = -1);
 66 |   virtual ~Firehose();
 67 |   int WriteData(unsigned char *writeBuffer, int64_t writeOffset, uint32_t writeBytes, uint32_t *bytesWritten, uint8_t partNum);
 68 |   int WriteSimlockData(unsigned char *writeBuffer, int64_t writeOffset, uint32_t writeBytes, uint32_t *bytesWritten, uint8_t partNum);
 69 |   int ReadData(unsigned char *readBuffer, int64_t readOffset, uint32_t readBytes, uint32_t *bytesRead, uint8_t partNum);
 70 | 
 71 |   int DeviceReset(void);
 72 |   int DeviceNop();
 73 |   int FastCopy(int hRead, int64_t sectorRead, int hWrite, int64_t sectorWrite, __uint64_t sectors, uint8_t partNum);
 74 |   int ProgramPatchEntry(PartitionEntry pe, char *key);
 75 |   int ProgramRawCommand(char *key);
 76 |   int PeekLogBuf(int64_t start, int64_t size);
 77 |   int WriteIMEI(char *imei);
 78 | 
 79 | 
 80 |   // Firehose specific operations
 81 |   int CreateGPP(uint32_t dwGPP1, uint32_t dwGPP2, uint32_t dwGPP3, uint32_t dwGPP4);
 82 |   int SetActivePartition(int prtn_num);
 83 |   int ConnectToFlashProg(fh_configure_t *cfg);
 84 | 
 85 | protected:
 86 | 
 87 | private:
 88 |   int ReadData(unsigned char *pOutBuf, uint32_t uiBufSize, bool bXML);
 89 |   int ReadStatus(void);
 90 | 
 91 |   SerialPort *sport;
 92 |   __uint64_t diskSectors;
 93 |   uint32_t speedWidth;
 94 |   struct timespec startTs;
 95 |   bool m_read_back_verify;
 96 |   bool m_rawmode;
 97 |   unsigned char *m_payload;
 98 |   unsigned char *m_buffer;
 99 |   unsigned char *m_buffer_ptr;
100 |   uint32_t m_buffer_len;
101 |   uint32_t dwMaxPacketSize;
102 |   int hLog;
103 |   char *program_pkt;
104 | };
105 | 


--------------------------------------------------------------------------------
/inc/list.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (C) 2008-2013 The Android Open Source Project
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef _CUTILS_LIST_H_
18 | #define _CUTILS_LIST_H_
19 | 
20 | #include <stddef.h>
21 | 
22 | #ifdef __cplusplus
23 | extern "C" {
24 | #endif /* __cplusplus */
25 | 
26 | struct listnode
27 | {
28 |     struct listnode *next;
29 |     struct listnode *prev;
30 | };
31 | 
32 | #define node_to_item(node, container, member) \
33 |     (container *) (((char*) (node)) - offsetof(container, member))
34 | 
35 | #define list_declare(name) \
36 |     struct listnode name = { \
37 |         .next = &name, \
38 |         .prev = &name, \
39 |     }
40 | 
41 | #define list_for_each(node, list) \
42 |     for (node = (list)->next; node != (list); node = node->next)
43 | 
44 | #define list_for_each_reverse(node, list) \
45 |     for (node = (list)->prev; node != (list); node = node->prev)
46 | 
47 | #define list_for_each_safe(node, n, list) \
48 |     for (node = (list)->next, n = node->next; \
49 |          node != (list); \
50 |          node = n, n = node->next)
51 | 
52 | static inline void list_init(struct listnode *node)
53 | {
54 |     node->next = node;
55 |     node->prev = node;
56 | }
57 | 
58 | static inline void list_add_tail(struct listnode *head, struct listnode *item)
59 | {
60 |     item->next = head;
61 |     item->prev = head->prev;
62 |     head->prev->next = item;
63 |     head->prev = item;
64 | }
65 | 
66 | static inline void list_add_head(struct listnode *head, struct listnode *item)
67 | {
68 |     item->next = head->next;
69 |     item->prev = head;
70 |     head->next->prev = item;
71 |     head->next = item;
72 | }
73 | 
74 | static inline void list_remove(struct listnode *item)
75 | {
76 |     item->next->prev = item->prev;
77 |     item->prev->next = item->next;
78 | }
79 | 
80 | #define list_empty(list) ((list) == (list)->next)
81 | #define list_head(list) ((list)->next)
82 | #define list_tail(list) ((list)->prev)
83 | 
84 | #ifdef __cplusplus
85 | };
86 | #endif /* __cplusplus */
87 | 
88 | #endif
89 | 


--------------------------------------------------------------------------------
/inc/partition.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * partition.h
  3 |  *
  4 |  * This file defines the interface for the Partition class
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/partition.h#5 $
 16 | $DateTime: 2015/04/01 17:01:45 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 03/21/11   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | #include "sysdeps.h"
 27 | 
 28 | #include "xmlparser.h"
 29 | #include <stdio.h>
 30 | 
 31 | #define MAX_PATH 512
 32 | #define MAX_LIST_SIZE   100
 33 | #define MAX_PATH_LEN    256
 34 | #define SECTOR_SIZE	    512
 35 | 
 36 | class Protocol;
 37 | 
 38 | enum cmdEnum {
 39 |   CMD_INVALID = 0,
 40 |   CMD_PATCH = 1,
 41 |   CMD_ZEROOUT = 2,
 42 |   CMD_PROGRAM = 3,
 43 |   CMD_OPTION = 4,
 44 |   CMD_PATH = 5,
 45 |   CMD_READ = 6,
 46 |   CMD_ERASE = 7,
 47 |   CMD_NOP = 8,
 48 |   CMD_PEEK= 9,
 49 |   CMD_SIMLOCK = 10
 50 | };
 51 | 
 52 | typedef struct {
 53 |   char    signature[8];
 54 |   int32_t revision;
 55 |   int32_t header_size;
 56 |   int32_t crc_header;
 57 |   int32_t reserved;
 58 |   __uint64_t current_lba;
 59 |   __uint64_t backup_lba;
 60 |   __uint64_t first_lba;
 61 |   __uint64_t last_lba;
 62 |   char    disk_guid[16];
 63 |   __uint64_t partition_lba;
 64 |   int32_t num_entries;
 65 |   int32_t entry_size;
 66 |   int32_t crc_partition;
 67 |   char    reserved2[420];
 68 | } gpt_header_t;
 69 | 
 70 | typedef struct {
 71 |   char    type_guid[16];
 72 |   char    unique_guid[16];
 73 |   __uint64_t first_lba;
 74 |   __uint64_t last_lba;
 75 |   __uint64_t attributes;
 76 |   char part_name[72];
 77 | } gpt_entry_t;
 78 | 
 79 | typedef struct {
 80 |   cmdEnum eCmd;
 81 |   __uint64_t start_sector;
 82 |   __uint64_t offset;
 83 |   __uint64_t num_sectors;
 84 |   uint8_t physical_partition_number;
 85 |   __uint64_t patch_value;
 86 |   __uint64_t patch_offset;
 87 |   __uint64_t patch_size;
 88 |   __uint64_t crc_start;
 89 |   __uint64_t crc_size;
 90 |   char  filename[MAX_PATH];
 91 |   char  label[MAX_PATH];
 92 | } PartitionEntry;
 93 | 
 94 | //char *StringReplace(char *inp, const char *find, const char *rep);
 95 | //char *StringSetValue(char *key, char *keyName, char *value);
 96 | 
 97 | 
 98 | class Partition:public XMLParser {
 99 | public:
100 |   int num_entries;
101 | 
102 |   Partition(__uint64_t ds=0)
103 |   {
104 | 	  num_entries = 0; cur_action = 0; d_sectors = ds;
105 |           bVerbose = false;
106 |   };
107 |   ~Partition() {};
108 |   int PreLoadImage(char * fname, const char * imgdir = NULL);
109 |   int ProgramImage(Protocol *proto);
110 |   int ProgramPartitionEntry(Protocol *proto, PartitionEntry pe, char *key);
111 |   int SimlockPartitionEntry(Protocol *proto, PartitionEntry pe, char *key);
112 | 
113 |   int CloseXML();
114 |   int GetNextXMLKey(char *keyName, char **key);
115 |   unsigned int CalcCRC32(unsigned char *buffer, int len);
116 |   int ParseXMLKey(char *key, PartitionEntry *pe);
117 |   void EnableVerbose(void);
118 | 
119 | private:
120 |   int cur_action;
121 |   __uint64_t d_sectors;
122 | 
123 |   int Reflect(int data, int len);
124 |   int ParseXMLOptions();
125 |   int ParsePathList();
126 |   //int ParseXMLString(char *line, const char *key, char *value);
127 |   int ParseXMLInt64(char *line, const char *key, __uint64_t &value, PartitionEntry *pe) const;
128 |   int ParseXMLEvaluate(char *expr, __uint64_t &value, PartitionEntry *pe) const;
129 |   bool CheckEmptyLine(char *str) const;
130 |   int Log(const char *str,...);
131 |   bool bVerbose;
132 | };
133 | 


--------------------------------------------------------------------------------
/inc/protocol.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 | * protocol.h
 3 | *
 4 | * This file implements the streaming download protocol
 5 | *
 6 | * Copyright (c) 2007-2015
 7 | * Qualcomm Technologies Incorporated.
 8 | * All Rights Reserved.
 9 | * Qualcomm Confidential and Proprietary
10 | *
11 | *****************************************************************************/
12 | /*=============================================================================
13 | Edit History
14 | 
15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/protocol.h#4 $
16 | $DateTime: 2015/05/07 21:41:17 $ $Author: pweber $
17 | 
18 | when       who     what, where, why
19 | -------------------------------------------------------------------------------
20 | 12/09/15   pgw     Initial version.
21 | =============================================================================*/
22 | #pragma once
23 | 
24 | #include "partition.h"
25 | #include "sysdeps.h"
26 | #include <stdint.h>
27 | 
28 | #define MAX_XML_LEN         4096
29 | #define MAX_TRANSFER_SIZE   0x100000
30 | 
31 | class Protocol {
32 | public:
33 |   //int ConnectToFlashProg(fh_configure_t *cfg);
34 |   //int CreateGPP(uint32_t dwGPP1, uint32_t dwGPP2, uint32_t dwGPP3, uint32_t dwGPP4);
35 |   //int SetActivePartition(int prtn_num);
36 | 
37 |   Protocol();
38 |   virtual ~Protocol();
39 | 
40 |   int DumpDiskContents(__uint64_t start_sector, __uint64_t num_sectors, char *szOutFile, uint8_t partNum, char *szPartName);
41 |   int WipeDiskContents(__uint64_t start_sector, __uint64_t num_sectors, char *szPartName);
42 | 
43 |   int ReadGPT(bool debug);
44 |   int WriteGPT(char *szPartName, char *szBinFile);
45 |   void EnableVerbose(void);
46 |   int GetDiskSectorSize(void);
47 |   void SetDiskSectorSize(int size);
48 |   __uint64_t GetNumDiskSectors(void);
49 |   int GetDiskHandle(void);
50 |   virtual int WriteSimlockData(unsigned char *writeBuffer, int64_t writeOffset, uint32_t writeBytes, uint32_t *bytesWritten, uint8_t partNum);
51 | 
52 |   virtual int DeviceReset(void) = 0;
53 |   virtual int WriteData(unsigned char *writeBuffer, int64_t writeOffset, uint32_t writeBytes, uint32_t *bytesWritten, uint8_t partNum) = 0;
54 |   virtual int ReadData(unsigned char *readBuffer, int64_t readOffset, uint32_t readBytes, uint32_t *bytesRead, uint8_t partNum) = 0;
55 |   virtual int FastCopy(int hRead, int64_t sectorRead, int hWrite, int64_t sectorWrite, __uint64_t sectors, uint8_t partNum) = 0;
56 |   virtual int ProgramRawCommand(char *key) = 0;
57 |   virtual int ProgramPatchEntry(PartitionEntry pe, char *key) = 0;
58 | 
59 | protected:
60 | 
61 |   int LoadPartitionInfo(char *szPartName, PartitionEntry *pEntry);
62 |   void Log(const char *str, ...);
63 | 
64 |   gpt_header_t gpt_hdr;
65 |   gpt_entry_t *gpt_entries;
66 |   __uint64_t disk_size;
67 |   int hDisk;
68 |   unsigned char *buffer1;
69 |   unsigned char *buffer2;
70 |   unsigned char *bufAlloc1;
71 |   unsigned char *bufAlloc2;
72 |   int DISK_SECTOR_SIZE;
73 | 
74 | private:
75 | 
76 |   bool bVerbose;
77 | 
78 | };
79 | 


--------------------------------------------------------------------------------
/inc/qcversion.h:
--------------------------------------------------------------------------------
1 | #define FILEVER 333,039,0,0
2 | #define STRFILEVER "333.039.0.0"
3 | #define STRORIGINALFILENAME "emmcdl.exe"
4 | #define STRCOMPANYNAME "QUALCOMM Incorporated"
5 | #define STRLEGALCOPYRIGHT "Copyright (C) 2012 QUALCOMM Incorporated. All rights reserved."
6 | #define STRPRODUCTNAME "QUALCOMM Windows on Snapdragon"
7 | 


--------------------------------------------------------------------------------
/inc/sahara.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * sahara.h
  3 |  *
  4 |  * This file implements the streaming download protocol
  5 |  *
  6 |  * Copyright (c) 2007-2012
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/sahara.h#5 $
 16 | $DateTime: 2015/04/29 17:06:00 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 10/30/12   pgw     Initial version.
 21 | =============================================================================*/
 22 | #pragma once
 23 | 
 24 | #include "serialport.h"
 25 | #include "sysdeps.h"
 26 | 
 27 | #define SAHARA_VERSION 2
 28 | #define SAHARA_VERSION_SUPPORTED 2
 29 | 
 30 | #define SAHARA_HELLO_REQ      0x1
 31 | #define SAHARA_HELLO_RSP      0x2
 32 | #define SAHARA_READ_DATA      0x3
 33 | #define SAHARA_END_TRANSFER   0x4
 34 | #define SAHARA_DONE_REQ       0x5
 35 | #define SAHARA_DONE_RSP       0x6
 36 | #define SAHARA_RESET_REQ      0x7
 37 | #define SAHARA_RESET_RSP      0x8
 38 | #define SAHARA_MEMORY_DEBUG   0x9
 39 | #define SAHARA_MEMORY_READ    0xA
 40 | #define SAHARA_CMD_READY      0xB
 41 | #define SAHARA_SWITCH_MODE    0xC
 42 | #define SAHARA_EXECUTE_REQ    0xD
 43 | #define SAHARA_EXECUTE_RSP    0xE
 44 | #define SAHARA_EXECUTE_DATA   0xF
 45 | #define SAHARA_64BIT_MEMORY_DEBUG		0x10
 46 | #define SAHARA_64BIT_MEMORY_READ		0x11
 47 | #define SAHARA_64BIT_MEMORY_READ_DATA	0x12
 48 | 
 49 | #define SAHARA_ERROR_SUCCESS  0x0
 50 | 
 51 | #define SAHARA_MODE_IMAGE_TX_PENDING  0x0
 52 | #define SAHARA_MODE_IMAGE_TX_COMPLETE 0x1
 53 | #define SAHARA_MODE_MEMORY_DEBUG      0x2
 54 | #define SAHARA_MODE_COMMAND           0x3
 55 | 
 56 | /* Status codes for Sahara */
 57 | enum boot_sahara_status
 58 | {
 59 |   /* Success */
 60 |   SAHARA_STATUS_SUCCESS =                     0x00,
 61 | 
 62 |   /* Invalid command received in current state */
 63 |   SAHARA_NAK_INVALID_CMD =                    0x01,
 64 | 
 65 |   /* Protocol mismatch between host and target */
 66 |   SAHARA_NAK_PROTOCOL_MISMATCH =              0x02,
 67 | 
 68 |   /* Invalid target protocol version */
 69 |   SAHARA_NAK_INVALID_TARGET_PROTOCOL =        0x03,
 70 | 
 71 |   /* Invalid host protocol version */
 72 |   SAHARA_NAK_INVALID_HOST_PROTOCOL =          0x04,
 73 | 
 74 |   /* Invalid packet size received */
 75 |   SAHARA_NAK_INVALID_PACKET_SIZE =            0x05,
 76 | 
 77 |   /* Unexpected image ID received */
 78 |   SAHARA_NAK_UNEXPECTED_IMAGE_ID =            0x06,
 79 | 
 80 |   /* Invalid image header size received */
 81 |   SAHARA_NAK_INVALID_HEADER_SIZE =            0x07,
 82 | 
 83 |   /* Invalid image data size received */
 84 |   SAHARA_NAK_INVALID_DATA_SIZE =              0x08,
 85 | 
 86 |   /* Invalid image type received */
 87 |   SAHARA_NAK_INVALID_IMAGE_TYPE =             0x09,
 88 | 
 89 |   /* Invalid tranmission length */
 90 |   SAHARA_NAK_INVALID_TX_LENGTH =              0x0A,
 91 | 
 92 |   /* Invalid reception length */
 93 |   SAHARA_NAK_INVALID_RX_LENGTH =              0x0B,
 94 | 
 95 |   /* General transmission or reception error */
 96 |   SAHARA_NAK_GENERAL_TX_RX_ERROR =            0x0C,
 97 | 
 98 |   /* Error while transmitting READ_DATA packet */
 99 |   SAHARA_NAK_READ_DATA_ERROR =                0x0D,
100 | 
101 |   /* Cannot receive specified number of program headers */
102 |   SAHARA_NAK_UNSUPPORTED_NUM_PHDRS =          0x0E,
103 | 
104 |   /* Invalid data length received for program headers */
105 |   SAHARA_NAK_INVALID_PDHR_SIZE =              0x0F,
106 | 
107 |   /* Multiple shared segments found in ELF image */
108 |   SAHARA_NAK_MULTIPLE_SHARED_SEG =            0x10,
109 | 
110 |   /* Uninitialized program header location */
111 |   SAHARA_NAK_UNINIT_PHDR_LOC =                0x11,
112 | 
113 |   /* Invalid destination address */
114 |   SAHARA_NAK_INVALID_DEST_ADDR =              0x12,
115 | 
116 |   /* Invalid data size receieved in image header */
117 |   SAHARA_NAK_INVALID_IMG_HDR_DATA_SIZE =      0x13,
118 | 
119 |   /* Invalid ELF header received */
120 |   SAHARA_NAK_INVALID_ELF_HDR =                0x14,
121 | 
122 |   /* Unknown host error received in HELLO_RESP */
123 |   SAHARA_NAK_UNKNOWN_HOST_ERROR =             0x15,
124 | 
125 |   /* Timeout while receiving data */
126 |   SAHARA_NAK_TIMEOUT_RX =                     0x16,
127 | 
128 |   /* Timeout while transmitting data */
129 |   SAHARA_NAK_TIMEOUT_TX =                     0x17,
130 | 
131 |   /* Invalid mode received from host */
132 |   SAHARA_NAK_INVALID_HOST_MODE =              0x18,
133 | 
134 |   /* Invalid memory read access */
135 |   SAHARA_NAK_INVALID_MEMORY_READ =            0x19,
136 | 
137 |   /* Host cannot handle read data size requested */
138 |   SAHARA_NAK_INVALID_DATA_SIZE_REQUEST =      0x1A,
139 | 
140 |   /* Memory debug not supported */
141 |   SAHARA_NAK_MEMORY_DEBUG_NOT_SUPPORTED =     0x1B,
142 | 
143 |   /* Invalid mode switch */
144 |   SAHARA_NAK_INVALID_MODE_SWITCH =            0x1C,
145 | 
146 |   /* Failed to execute command */
147 |   SAHARA_NAK_CMD_EXEC_FAILURE =               0x1D,
148 | 
149 |   /* Invalid parameter passed to command execution */
150 |   SAHARA_NAK_EXEC_CMD_INVALID_PARAM =         0x1E,
151 | 
152 |   /* Unsupported client command received */
153 |   SAHARA_NAK_EXEC_CMD_UNSUPPORTED =           0x1F,
154 | 
155 |   /* Invalid client command received for data response */
156 |   SAHARA_NAK_EXEC_DATA_INVALID_CLIENT_CMD =   0x20,
157 | 
158 |   /* Failed to authenticate hash table */
159 |   SAHARA_NAK_HASH_TABLE_AUTH_FAILURE =        0x21,
160 | 
161 |   /* Failed to verify hash for a given segment of ELF image */
162 |   SAHARA_NAK_HASH_VERIFICATION_FAILURE =      0x22,
163 | 
164 |   /* Failed to find hash table in ELF image */
165 |   SAHARA_NAK_HASH_TABLE_NOT_FOUND =           0x23,
166 | 
167 |   /* Target failed to initialize */
168 |   SAHARA_NAK_TARGET_INIT_FAILURE =            0x24,
169 | 
170 |   /* Failed to authenticate generic image */
171 |   SAHARA_NAK_IMAGE_AUTH_FAILURE  =            0x25,
172 | 
173 |   /* Invalid ELF hash table size.  Too bit or small. */
174 |   SAHARA_NAK_INVALID_IMG_HASH_TABLE_SIZE =    0x26,
175 | 
176 |   /* Place all new error codes above this */
177 |   SAHARA_NAK_LAST_CODE,
178 | 
179 |   SAHARA_NAK_MAX_CODE = 0x7FFFFFFF /* To ensure 32-bits wide */
180 | };
181 | 
182 | enum boot_sahara_exec_cmd_id
183 | {
184 |   SAHARA_EXEC_CMD_NOP = 0x00,
185 |   SAHARA_EXEC_CMD_SERIAL_NUM_READ = 0x01,
186 |   SAHARA_EXEC_CMD_MSM_HW_ID_READ = 0x02,
187 |   SAHARA_EXEC_CMD_OEM_PK_HASH_READ = 0x03,
188 |   SAHARA_EXEC_CMD_SWITCH_TO_DMSS_DLOAD = 0x04,
189 |   SAHARA_EXEC_CMD_SWITCH_TO_STREAM_DLOAD = 0x05,
190 |   SAHARA_EXEC_CMD_READ_DEBUG_DATA = 0x06,
191 |   SAHARA_EXEC_CMD_GET_SOFTWARE_VERSION_SBL = 0x07,
192 | 
193 |   /* place all new commands above this */
194 |   SAHARA_EXEC_CMD_LAST,
195 |   SAHARA_EXEC_CMD_MAX = 0x7FFFFFFF
196 | };
197 | 
198 | typedef struct {
199 | 	uint32_t cmd;
200 | 	uint32_t len;
201 | 	uint32_t version;
202 | 	uint32_t version_min;
203 | 	uint32_t max_cmd_len;
204 | 	uint32_t mode;
205 | 	uint32_t res1;	uint32_t res2;	uint32_t res3;	uint32_t res4;	uint32_t res5;	uint32_t res6;
206 | } hello_req_t;
207 | 
208 | typedef struct {
209 | 	uint32_t cmd;
210 | 	uint32_t len;
211 | } cmd_hdr_t;
212 | 
213 | typedef struct {
214 | 	uint32_t id;
215 | 	uint32_t data_offset;
216 | 	uint32_t data_len;
217 | } read_data_t;
218 | 
219 | typedef struct {
220 | 	uint64_t id;
221 | 	uint64_t data_offset;
222 | 	uint64_t data_len;
223 | } read_data_64_t;
224 | 
225 | typedef struct {
226 |   uint32_t cmd;
227 |   uint32_t len;
228 |   uint32_t client_cmd;
229 | } execute_cmd_t;
230 | 
231 | typedef struct {
232 |   uint32_t cmd;
233 |   uint32_t len;
234 |   uint32_t client_cmd;
235 |   uint32_t data_len;
236 | } execute_rsp_t;
237 | 
238 | typedef struct {
239 | 	uint32_t id;
240 | 	uint32_t status;
241 | } image_end_t;
242 | 
243 | typedef struct {
244 |   uint32_t cmd;
245 |   uint32_t len;
246 |   uint32_t status;
247 | } done_t;
248 | 
249 | typedef struct {
250 |   uint32_t serial;
251 |   uint32_t msm_id;
252 |   unsigned char pk_hash[32];
253 |   uint32_t pbl_sw;
254 | } pbl_info_t;
255 | 
256 | class Sahara {
257 | public:
258 |   Sahara(SerialPort *port,int hLogFile = 0);
259 |   int DeviceReset(void);
260 |   int LoadFlashProg(char *szFlashPrg);
261 |   int ConnectToDevice(bool bReadHello, int mode);
262 |   int DumpDeviceInfo(pbl_info_t *pbl_info);
263 |   int CheckDevice(void);
264 | 
265 | private:
266 |   int ModeSwitch(int mode, bool rsp = true);
267 |   void HexToByte(const char *hex, unsigned char *bin, int len);
268 |   void Log(const char *str,...);
269 | 
270 |   uint32_t HexRunAddress(char *filename);
271 |   uint32_t HexDataLength(char *filename);
272 |   int ReadData(int cmd, unsigned char *buf, int len);
273 |   int PblHack(void);
274 | 
275 |   SerialPort *sport;
276 |   int hLog;
277 | };
278 | 


--------------------------------------------------------------------------------
/inc/serialport.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 |  * serialport.h
 3 |  *
 4 |  * This file implements HDLC encoding and serial port interface
 5 |  *
 6 |  * Copyright (c) 2007-2011
 7 |  * Qualcomm Technologies Incorporated.
 8 |  * All Rights Reserved.
 9 |  * Qualcomm Confidential and Proprietary
10 |  *
11 |  *****************************************************************************/
12 | /*=============================================================================
13 |                         Edit History
14 | 
15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/serialport.h#3 $
16 | $DateTime: 2014/08/05 11:44:01 $ $Author: pweber $
17 | 
18 | when       who     what, where, why
19 | -------------------------------------------------------------------------------
20 | 11/08/11   pgw     Initial version.
21 | =============================================================================*/
22 | #pragma once
23 | 
24 | #include <stdio.h>
25 | #include "sysdeps.h"
26 | #include "crc.h"
27 | #include "usb.h"
28 | 
29 | #define  ASYNC_HDLC_FLAG      0x7e
30 | #define  ASYNC_HDLC_ESC       0x7d
31 | #define  ASYNC_HDLC_ESC_MASK  0x20
32 | #define  MAX_PACKET_SIZE      0x20000
33 | 
34 | class SerialPort {
35 | public:
36 |   SerialPort();
37 |   ~SerialPort();
38 |   int Open(int port);
39 |   int EnableBinaryLog(char *szFileName);
40 |   int Close();
41 |   int Write(unsigned char *data, uint32_t length);
42 |   int Read(unsigned char *data, uint32_t *length);
43 |   int Flush();
44 |   int SendSync(unsigned char *out_buf, int out_length, unsigned char *in_buf, int *in_length);
45 |   int SetTimeout(int ms);
46 |   int64_t OutputBufferCount();
47 |   int64_t InputBufferCount();
48 | private:
49 |   int HDLCEncodePacket(unsigned char *in_buf, int in_length, unsigned char *out_buf, int *out_length);
50 |   int HDLCDecodePacket(unsigned char *in_buf, int in_length, unsigned char *out_buf, int *out_length);
51 |   
52 |   usb_handle* hPort;
53 |   unsigned char *HDLCBuf;
54 |   int to_ms;
55 | 
56 | };
57 | 


--------------------------------------------------------------------------------
/inc/sparse.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 | * sparse.h
 3 | *
 4 | * This file has structures and functions for sparse format
 5 | *
 6 | * Copyright (c) 2007-2015
 7 | * Qualcomm Technologies Incorporated.
 8 | * All Rights Reserved.
 9 | * Qualcomm Confidential and Proprietary
10 | *
11 | *****************************************************************************/
12 | /*=============================================================================
13 | Edit History
14 | 
15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/sparse.h#1 $
16 | $DateTime: 2015/02/10 11:56:41 $ $Author: pweber $
17 | 
18 | when       who     what, where, why
19 | -------------------------------------------------------------------------------
20 | 02/05/15   pgw     Initial version.
21 | =============================================================================*/
22 | #pragma once
23 | #include "protocol.h"
24 | #include "sysdeps.h"
25 | 
26 | #define SPARSE_MAGIC      0xED26FF3A
27 | #define SPARSE_RAW_CHUNK  0xCAC1
28 | #define SPARSE_FILL_CHUNK 0xCAC2
29 | #define SPARSE_DONT_CARE  0xCAC3
30 | 
31 | // Security Header struct. The first data read in from the FFU.
32 | typedef struct _SPARSE_HEADER
33 | {
34 |   uint32_t dwMagic;           // 0xed26ff3a
35 |   uint16_t wVerMajor;         // 0x1 Major version, reject version with higher major version
36 |   uint16_t wVerMinor;         // 0x0 Minor version, accept version with higher minor version
37 |   uint16_t wSparseHeaderSize; // 28 bytes for first revision of the file format
38 |   uint16_t wChunkHeaderSize;  // 12 bytes for first revision of the file format
39 |   uint32_t dwBlockSize;       // 4096 block size in bytes must be multiple of 4
40 |   uint32_t dwTotalBlocks;     // Total blocks in the non-sparse output file
41 |   uint32_t dwTotalChunks;     // Total chunks in the sparse input image
42 |   uint32_t dwImageChecksum;   // CRC32 checksum of the original data counting do not care 802.3 polynomial
43 | } SPARSE_HEADER;
44 | 
45 | typedef struct _CHUNK_HEADER
46 | {
47 |   uint16_t wChunkType;        // 0xCAC1 -> raw; 0xCAC2 -> fill; 0xCAC3 -> don't care
48 |   uint16_t wReserved;         // Reserved should be all 0
49 |   uint32_t dwChunkSize;       // Number of blocks this chunk takes in output image
50 |   uint32_t dwTotalSize;       // Number of bytes in input file including chunk header round up to next block size
51 | } CHUNK_HEADER;
52 | 
53 | class SparseImage {
54 | public:
55 |   int PreLoadImage(char *szSparseFile);
56 |   int ProgramImage(Protocol *pProtocol, int64_t dwOffset);
57 | 
58 |   SparseImage();
59 |   ~SparseImage();
60 | 
61 | private:
62 |   SPARSE_HEADER SparseHeader;
63 |   int hSparseImage;
64 |   bool bSparseImage;
65 | 
66 | };
67 | 


--------------------------------------------------------------------------------
/inc/sysdeps.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (C) 2007 The Android Open Source Project
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /* this file contains system-dependent definitions used by EMMCDL
 18 |  * they're related to threads, sockets and file descriptors
 19 |  */
 20 | #ifndef _EMMCDL_SYSDEPS_H
 21 | #define _EMMCDL_SYSDEPS_H
 22 | 
 23 | #ifdef __CYGWIN__
 24 | #  undef _WIN32
 25 | #endif
 26 | 
 27 | /*
 28 |  * TEMP_FAILURE_RETRY is defined by some, but not all, versions of
 29 |  * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's
 30 |  * not already defined, then define it here.
 31 |  */
 32 | #ifndef TEMP_FAILURE_RETRY
 33 | /* Used to retry syscalls that can return EINTR. */
 34 | #define TEMP_FAILURE_RETRY(exp) ({         \
 35 |     typeof (exp) _rc;                      \
 36 |     do {                                   \
 37 |         _rc = (exp);                       \
 38 |     } while (_rc == -1 && errno == EINTR); \
 39 |     _rc; })
 40 | #endif
 41 | 
 42 | #ifdef _WIN32
 43 | 
 44 | #include <ctype.h>
 45 | #include <direct.h>
 46 | #include <errno.h>
 47 | #include <fcntl.h>
 48 | #include <io.h>
 49 | #include <process.h>
 50 | #include <sys/stat.h>
 51 | #include <winsock2.h>
 52 | #include <windows.h>
 53 | #include <ws2tcpip.h>
 54 | 
 55 | #include "fdevent.h"
 56 | 
 57 | #define OS_PATH_SEPARATOR '\\'
 58 | #define OS_PATH_SEPARATOR_STR "\\"
 59 | #define ENV_PATH_SEPARATOR_STR ";"
 60 | 
 61 | typedef CRITICAL_SECTION          emmcdl_mutex_t;
 62 | 
 63 | #define  EMMCDL_MUTEX_DEFINE(x)     emmcdl_mutex_t   x
 64 | 
 65 | /* declare all mutexes */
 66 | /* For win32, emmcdl_sysdeps_init() will do the mutex runtime initialization. */
 67 | #define  EMMCDL_MUTEX(x)   extern emmcdl_mutex_t  x;
 68 | #include "mutex_list.h"
 69 | 
 70 | extern void  emmcdl_sysdeps_init(void);
 71 | 
 72 | static __inline__ void emmcdl_mutex_lock( emmcdl_mutex_t*  lock )
 73 | {
 74 |     EnterCriticalSection( lock );
 75 | }
 76 | 
 77 | static __inline__ void  emmcdl_mutex_unlock( emmcdl_mutex_t*  lock )
 78 | {
 79 |     LeaveCriticalSection( lock );
 80 | }
 81 | 
 82 | typedef  void*  (*emmcdl_thread_func_t)(void*  arg);
 83 | 
 84 | typedef  void (*win_thread_func_t)(void*  arg);
 85 | 
 86 | static __inline__ bool emmcdl_thread_create(emmcdl_thread_func_t func, void* arg) {
 87 |     uintptr_t tid = _beginthread((win_thread_func_t)func, 0, arg);
 88 |     return (tid != static_cast<uintptr_t>(-1L));
 89 | }
 90 | 
 91 | static __inline__  unsigned long emmcdl_thread_id()
 92 | {
 93 |     return GetCurrentThreadId();
 94 | }
 95 | 
 96 | static __inline__ void  close_on_exec(int  fd)
 97 | {
 98 |     /* nothing really */
 99 | }
100 | 
101 | #define  lstat    stat   /* no symlinks on Win32 */
102 | 
103 | #define  S_ISLNK(m)   0   /* no symlinks on Win32 */
104 | 
105 | static __inline__  int    emmcdl_unlink(const char*  path)
106 | {
107 |     int  rc = unlink(path);
108 | 
109 |     if (rc == -1 && errno == EACCES) {
110 |         /* unlink returns EACCES when the file is read-only, so we first */
111 |         /* try to make it writable, then unlink again...                  */
112 |         rc = chmod(path, _S_IREAD|_S_IWRITE );
113 |         if (rc == 0)
114 |             rc = unlink(path);
115 |     }
116 |     return rc;
117 | }
118 | #undef  unlink
119 | #define unlink  ___xxx_unlink
120 | 
121 | static __inline__ int  emmcdl_mkdir(const char*  path, int mode)
122 | {
123 | 	return _mkdir(path);
124 | }
125 | #undef   mkdir
126 | #define  mkdir  ___xxx_mkdir
127 | 
128 | extern int  emmcdl_open(const char*  path, int  options);
129 | extern int  emmcdl_creat(const char*  path, int  mode);
130 | extern int  emmcdl_read(int  fd, void* buf, int len);
131 | extern int  emmcdl_write(int  fd, const void*  buf, int  len);
132 | extern int  emmcdl_lseek(int  fd, int  pos, int  where);
133 | extern int  emmcdl_shutdown(int  fd);
134 | extern int  emmcdl_close(int  fd);
135 | 
136 | static __inline__ int  unix_close(int fd)
137 | {
138 |     return close(fd);
139 | }
140 | #undef   close
141 | #define  close   ____xxx_close
142 | 
143 | extern int  unix_read(int  fd, void*  buf, size_t  len);
144 | 
145 | #undef   read
146 | #define  read  ___xxx_read
147 | 
148 | static __inline__  int  unix_write(int  fd, const void*  buf, size_t  len)
149 | {
150 |     return write(fd, buf, len);
151 | }
152 | #undef   write
153 | #define  write  ___xxx_write
154 | 
155 | static __inline__ int  emmcdl_open_mode(const char* path, int options, int mode)
156 | {
157 |     return emmcdl_open(path, options);
158 | }
159 | 
160 | static __inline__ int  unix_open(const char*  path, int options,...)
161 | {
162 |     if ((options & O_CREAT) == 0)
163 |     {
164 |         return  open(path, options);
165 |     }
166 |     else
167 |     {
168 |         int      mode;
169 |         va_list  args;
170 |         va_start( args, options );
171 |         mode = va_arg( args, int );
172 |         va_end( args );
173 |         return open(path, options, mode);
174 |     }
175 | }
176 | #define  open    ___xxx_unix_open
177 | 
178 | 
179 | /* normally provided by <cutils/misc.h> */
180 | extern void*  load_file(const char*  pathname, unsigned*  psize);
181 | 
182 | /* normally provided by <cutils/sockets.h> */
183 | extern int socket_loopback_client(int port, int type);
184 | extern int socket_network_client(const char *host, int port, int type);
185 | extern int socket_network_client_timeout(const char *host, int port, int type,
186 |                                          int timeout);
187 | extern int socket_loopback_server(int port, int type);
188 | extern int socket_inaddr_any_server(int port, int type);
189 | 
190 | /* normally provided by "fdevent.h" */
191 | 
192 | #define FDE_READ              0x0001
193 | #define FDE_WRITE             0x0002
194 | #define FDE_ERROR             0x0004
195 | #define FDE_DONT_CLOSE        0x0080
196 | 
197 | typedef void (*fd_func)(int fd, unsigned events, void *userdata);
198 | 
199 | fdevent *fdevent_create(int fd, fd_func func, void *arg);
200 | void     fdevent_destroy(fdevent *fde);
201 | void     fdevent_install(fdevent *fde, int fd, fd_func func, void *arg);
202 | void     fdevent_remove(fdevent *item);
203 | void     fdevent_set(fdevent *fde, unsigned events);
204 | void     fdevent_add(fdevent *fde, unsigned events);
205 | void     fdevent_del(fdevent *fde, unsigned events);
206 | void     fdevent_loop();
207 | 
208 | static __inline__ void  emmcdl_sleep_ms( int  mseconds )
209 | {
210 |     Sleep( mseconds );
211 | }
212 | 
213 | extern int  emmcdl_socket_accept(int  serverfd, struct sockaddr*  addr, socklen_t  *addrlen);
214 | 
215 | #undef   accept
216 | #define  accept  ___xxx_accept
217 | 
218 | extern int  emmcdl_setsockopt(int  fd, int  level, int  optname, const void*  optval, socklen_t  optlen);
219 | 
220 | #undef   setsockopt
221 | #define  setsockopt  ___xxx_setsockopt
222 | 
223 | static __inline__  int  emmcdl_socket_setbufsize( int   fd, int  bufsize )
224 | {
225 |     int opt = bufsize;
226 |     return emmcdl_setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (const void*)&opt, sizeof(opt));
227 | }
228 | 
229 | static __inline__ void  disable_tcp_nagle( int  fd )
230 | {
231 |     int  on = 1;
232 |     emmcdl_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const void*)&on, sizeof(on));
233 | }
234 | 
235 | extern int  emmcdl_socketpair( int  sv[2] );
236 | 
237 | static __inline__  char*  emmcdl_dirstart( const char*  path )
238 | {
239 |     char*  p  = strchr(path, '/');
240 |     char*  p2 = strchr(path, '\\');
241 | 
242 |     if ( !p )
243 |         p = p2;
244 |     else if ( p2 && p2 > p )
245 |         p = p2;
246 | 
247 |     return p;
248 | }
249 | 
250 | static __inline__  char*  emmcdl_dirstop( const char*  path )
251 | {
252 |     char*  p  = strrchr(path, '/');
253 |     char*  p2 = strrchr(path, '\\');
254 | 
255 |     if ( !p )
256 |         p = p2;
257 |     else if ( p2 && p2 > p )
258 |         p = p2;
259 | 
260 |     return p;
261 | }
262 | 
263 | static __inline__  int  emmcdl_is_absolute_host_path( const char*  path )
264 | {
265 |     return isalpha(path[0]) && path[1] == ':' && path[2] == '\\';
266 | }
267 | 
268 | #else /* !_WIN32 a.k.a. Unix */
269 | 
270 | #ifdef ANDROID
271 | #include "fdevent.h"
272 | #include <cutils/sockets.h>
273 | #include <cutils/misc.h>
274 | #endif
275 | #include <errno.h>
276 | #include <signal.h>
277 | #include <sys/wait.h>
278 | #include <sys/stat.h>
279 | #include <fcntl.h>
280 | 
281 | #include <pthread.h>
282 | #include <unistd.h>
283 | #include <fcntl.h>
284 | #include <stdarg.h>
285 | #include <netinet/in.h>
286 | #include <netinet/tcp.h>
287 | #include <string.h>
288 | #include <unistd.h>
289 | 
290 | #define OS_PATH_SEPARATOR '/'
291 | #define OS_PATH_SEPARATOR_STR "/"
292 | #define ENV_PATH_SEPARATOR_STR ":"
293 | 
294 | typedef  pthread_mutex_t          emmcdl_mutex_t;
295 | 
296 | #define  EMMCDL_MUTEX_INITIALIZER    PTHREAD_MUTEX_INITIALIZER
297 | #define  emmcdl_mutex_init           pthread_mutex_init
298 | #define  emmcdl_mutex_lock           pthread_mutex_lock
299 | #define  emmcdl_mutex_unlock         pthread_mutex_unlock
300 | #define  emmcdl_mutex_destroy        pthread_mutex_destroy
301 | 
302 | #define  EMMCDL_MUTEX_DEFINE(m)      emmcdl_mutex_t   m = PTHREAD_MUTEX_INITIALIZER
303 | 
304 | #define  emmcdl_cond_t               pthread_cond_t
305 | #define  emmcdl_cond_init            pthread_cond_init
306 | #define  emmcdl_cond_wait            pthread_cond_wait
307 | #define  emmcdl_cond_broadcast       pthread_cond_broadcast
308 | #define  emmcdl_cond_signal          pthread_cond_signal
309 | #define  emmcdl_cond_destroy         pthread_cond_destroy
310 | 
311 | /* declare all mutexes */
312 | #define  EMMCDL_MUTEX(x)   extern emmcdl_mutex_t  x;
313 | #ifdef ANDROID
314 | #include "mutex_list.h"
315 | #endif
316 | 
317 | static __inline__ void  close_on_exec(int  fd)
318 | {
319 |     fcntl( fd, F_SETFD, FD_CLOEXEC );
320 | }
321 | 
322 | static __inline__ int  unix_open(const char*  path, int options,...)
323 | {
324 |     if ((options & O_CREAT) == 0)
325 |     {
326 |         return  TEMP_FAILURE_RETRY( open(path, options) );
327 |     }
328 |     else
329 |     {
330 |         int      mode;
331 |         va_list  args;
332 |         va_start( args, options );
333 |         mode = va_arg( args, int );
334 |         va_end( args );
335 |         return TEMP_FAILURE_RETRY( open( path, options, mode ) );
336 |     }
337 | }
338 | 
339 | static __inline__ int  emmcdl_open_mode( const char*  pathname, int  options, int  mode )
340 | {
341 |     return TEMP_FAILURE_RETRY( open( pathname, options, mode ) );
342 | }
343 | 
344 | 
345 | static __inline__ int  emmcdl_open( const char*  pathname, int  options )
346 | {
347 |     int  fd = TEMP_FAILURE_RETRY( open( pathname, options ) );
348 |     if (fd < 0)
349 |         return -1;
350 |     close_on_exec( fd );
351 |     return fd;
352 | }
353 | #undef   open
354 | #define  open    ___xxx_open
355 | 
356 | static __inline__ int  emmcdl_shutdown(int fd)
357 | {
358 |     return shutdown(fd, SHUT_RDWR);
359 | }
360 | #undef   shutdown
361 | #define  shutdown   ____xxx_shutdown
362 | 
363 | static __inline__ int  emmcdl_close(int fd)
364 | {
365 |     return close(fd);
366 | }
367 | #undef   close
368 | #define  close   ____xxx_close
369 | 
370 | 
371 | static __inline__  int  emmcdl_read(int  fd, void*  buf, size_t  len)
372 | {
373 |     return TEMP_FAILURE_RETRY( read( fd, buf, len ) );
374 | }
375 | 
376 | #undef   read
377 | #define  read  ___xxx_read
378 | 
379 | static __inline__  int  emmcdl_write(int  fd, const void*  buf, size_t  len)
380 | {
381 |     return TEMP_FAILURE_RETRY( write( fd, buf, len ) );
382 | }
383 | #undef   write
384 | #define  write  ___xxx_write
385 | 
386 | static __inline__ int   emmcdl_lseek(int  fd, int  pos, int  where)
387 | {
388 |     return lseek(fd, pos, where);
389 | }
390 | #undef   lseek
391 | #define  lseek   ___xxx_lseek
392 | 
393 | static __inline__  int    emmcdl_unlink(const char*  path)
394 | {
395 |     return  unlink(path);
396 | }
397 | #undef  unlink
398 | #define unlink  ___xxx_unlink
399 | 
400 | static __inline__  int  emmcdl_creat(const char*  path, int  mode)
401 | {
402 |     int  fd = TEMP_FAILURE_RETRY( creat( path, mode ) );
403 | 
404 |     if ( fd < 0 )
405 |         return -1;
406 | 
407 |     close_on_exec(fd);
408 |     return fd;
409 | }
410 | #undef   creat
411 | #define  creat  ___xxx_creat
412 | 
413 | static __inline__ int  emmcdl_socket_accept(int  serverfd, struct sockaddr*  addr, socklen_t  *addrlen)
414 | {
415 |     int fd;
416 | 
417 |     fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) );
418 |     if (fd >= 0)
419 |         close_on_exec(fd);
420 | 
421 |     return fd;
422 | }
423 | 
424 | #undef   accept
425 | #define  accept  ___xxx_accept
426 | 
427 | #define  unix_read   emmcdl_read
428 | #define  unix_write  emmcdl_write
429 | #define  unix_close  emmcdl_close
430 | 
431 | typedef void*  (*emmcdl_thread_func_t)( void*  arg );
432 | 
433 | static __inline__ bool emmcdl_thread_create(emmcdl_thread_func_t start, void* arg) {
434 |     pthread_attr_t attr;
435 |     pthread_attr_init(&attr);
436 |     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
437 | 
438 |     pthread_t thread;
439 |     errno = pthread_create(&thread, &attr, start, arg);
440 |     return (errno == 0);
441 | }
442 | 
443 | static __inline__  int  emmcdl_socket_setbufsize( int   fd, int  bufsize )
444 | {
445 |     int opt = bufsize;
446 |     return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt));
447 | }
448 | 
449 | static __inline__ void  disable_tcp_nagle(int fd)
450 | {
451 |     int  on = 1;
452 |     setsockopt( fd, IPPROTO_TCP, TCP_NODELAY, (void*)&on, sizeof(on) );
453 | }
454 | 
455 | static __inline__ int  emmcdl_setsockopt( int  fd, int  level, int  optname, const void*  optval, socklen_t  optlen )
456 | {
457 |     return setsockopt( fd, level, optname, optval, optlen );
458 | }
459 | 
460 | #undef   setsockopt
461 | #define  setsockopt  ___xxx_setsockopt
462 | 
463 | static __inline__ int  unix_socketpair( int  d, int  type, int  protocol, int sv[2] )
464 | {
465 |     return socketpair( d, type, protocol, sv );
466 | }
467 | 
468 | static __inline__ int  emmcdl_socketpair( int  sv[2] )
469 | {
470 |     int  rc;
471 | 
472 |     rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv );
473 |     if (rc < 0)
474 |         return -1;
475 | 
476 |     close_on_exec( sv[0] );
477 |     close_on_exec( sv[1] );
478 |     return 0;
479 | }
480 | 
481 | #undef   socketpair
482 | #define  socketpair   ___xxx_socketpair
483 | 
484 | static __inline__ void  emmcdl_sleep_ms( int  mseconds )
485 | {
486 |     usleep( mseconds*1000 );
487 | }
488 | 
489 | static __inline__ int  emmcdl_mkdir(const char*  path, int mode)
490 | {
491 |     return mkdir(path, mode);
492 | }
493 | #undef   mkdir
494 | #define  mkdir  ___xxx_mkdir
495 | 
496 | static __inline__ void  emmcdl_sysdeps_init(void)
497 | {
498 | }
499 | 
500 | static __inline__ char*  emmcdl_dirstart(const char*  path)
501 | {
502 |     return strchr((char*)path, '/');
503 | }
504 | 
505 | static __inline__ char*  emmcdl_dirstop(const char*  path)
506 | {
507 |     return strrchr((char*)path, '/');
508 | }
509 | 
510 | static __inline__  int  emmcdl_is_absolute_host_path( const char*  path )
511 | {
512 |     return path[0] == '/';
513 | }
514 | 
515 | static __inline__ unsigned long emmcdl_thread_id()
516 | {
517 |     return (unsigned long)pthread_self();
518 | }
519 | 
520 | #endif /* !_WIN32 */
521 | 
522 | #endif /* _EMMCDL_SYSDEPS_H */
523 | 


--------------------------------------------------------------------------------
/inc/targetver.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // Including SDKDDKVer.h defines the highest available Windows platform.
 4 | 
 5 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
 6 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
 7 | //#include <SDKDDKVer.h>
 8 | #define VERSION_MAJOR   2
 9 | #define VERSION_MINOR   10
10 | 


--------------------------------------------------------------------------------
/inc/usb.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (C) 2008 The Android Open Source Project
 3 |  * All rights reserved.
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without
 6 |  * modification, are permitted provided that the following conditions
 7 |  * are met:
 8 |  *  * Redistributions of source code must retain the above copyright
 9 |  *    notice, this list of conditions and the following disclaimer.
10 |  *  * Redistributions in binary form must reproduce the above copyright
11 |  *    notice, this list of conditions and the following disclaimer in
12 |  *    the documentation and/or other materials provided with the
13 |  *    distribution.
14 |  *
15 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 |  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 |  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 |  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 |  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 |  * SUCH DAMAGE.
27 |  */
28 | 
29 | #ifndef _USB_H_
30 | #define _USB_H_
31 | 
32 | #if defined(__cplusplus)
33 | extern "C" {
34 | #endif
35 | 
36 | typedef struct usb_handle usb_handle;
37 | 
38 | typedef struct usb_ifc_info usb_ifc_info;
39 | 
40 | struct usb_ifc_info
41 | {
42 |         /* from device descriptor */
43 |     unsigned short dev_vendor;
44 |     unsigned short dev_product;
45 | 
46 |     unsigned char dev_class;
47 |     unsigned char dev_subclass;
48 |     unsigned char dev_protocol;
49 | 
50 |     unsigned char ifc_class;
51 |     unsigned char ifc_subclass;
52 |     unsigned char ifc_protocol;
53 | 
54 |     unsigned char has_bulk_in;
55 |     unsigned char has_bulk_out;
56 | 
57 |     unsigned char writable;
58 | 
59 |     char serial_number[256];
60 |     char device_path[256];
61 | };
62 | 
63 | typedef int (*ifc_match_func)(usb_ifc_info *ifc);
64 | 
65 | usb_handle *usb_open(ifc_match_func callback);
66 | int usb_close(usb_handle *h);
67 | int usb_read(usb_handle *h, void *_data, int len);
68 | int usb_write(usb_handle *h, const void *_data, int len);
69 | int usb_wait_for_disconnect(usb_handle *h);
70 | 
71 | #if defined(__cplusplus)
72 | }
73 | #endif
74 | 
75 | #endif
76 | 


--------------------------------------------------------------------------------
/inc/xmlparser.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 |  * xmlparser.h
 3 |  *
 4 |  * This file is used to parse xml files and contents
 5 |  *
 6 |  * Copyright (c) 2007-2013
 7 |  * Qualcomm Technologies Incorporated.
 8 |  * All Rights Reserved.
 9 |  * Qualcomm Confidential and Proprietary
10 |  *
11 |  *****************************************************************************/
12 | /*=============================================================================
13 |                         Edit History
14 | 
15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/inc/xmlparser.h#2 $
16 | $DateTime: 2014/08/05 11:44:01 $ $Author: pweber $
17 | 
18 | when       who     what, where, why
19 | -------------------------------------------------------------------------------
20 | 05/13/13   pgw     Initial version.
21 | =============================================================================*/
22 | 
23 | #pragma once
24 | 
25 | 
26 | #include "sysdeps.h"
27 | #include <stdio.h>
28 | 
29 | #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
30 | #define MAX_STRING_LEN   512
31 | #define ERROR_INVALID_DATA  -10
32 | 
33 | class XMLParser {
34 | public:
35 |   XMLParser();
36 |   ~XMLParser();
37 |   int LoadXML(char * fname, const char *imgdir = NULL);
38 |   int ParseXMLString(char *line, const char *key, char *value) const;
39 |   int ParseXMLInteger(char *line, const char *key, __uint64_t *value) const;
40 |   char *StringReplace(char *inp, const char *find, const char *rep) const;
41 |   char *StringSetValue(char *key, const char *keyName, char *value) const;
42 | 
43 | protected:
44 |   char *xmlStart;
45 |   char *xmlEnd;
46 |   char *keyStart;
47 |   char *keyEnd;
48 |   const char *xmlFilename;
49 |   const char *imgDir;
50 | 
51 | 
52 |   int ParseXMLEvaluate(char *expr, __uint64_t &value) const;
53 | 
54 | };
55 | 


--------------------------------------------------------------------------------
/src/crc.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include "crc.h"
 3 | 
 4 | /* CRC table for 16 bit CRC, with generator polynomial 0x8408,
 5 | ** calculated 8 bits at a time, LSB first.  This table is used
 6 | ** from a macro in sio.c.
 7 | */
 8 | const unsigned short crc_16_l_table[] = {
 9 |   0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
10 |   0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
11 |   0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
12 |   0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
13 |   0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
14 |   0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
15 |   0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
16 |   0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
17 |   0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
18 |   0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
19 |   0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
20 |   0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
21 |   0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
22 |   0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
23 |   0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
24 |   0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
25 |   0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
26 |   0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
27 |   0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
28 |   0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
29 |   0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
30 |   0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
31 |   0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
32 |   0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
33 |   0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
34 |   0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
35 |   0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
36 |   0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
37 |   0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
38 |   0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
39 |   0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
40 |   0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
41 | };
42 | 
43 | unsigned short CalcCRC16(unsigned char *buf, int length)
44 | {
45 |   unsigned short crc = CRC_16_L_SEED;
46 |   for (int i=0; i < length; i++) {
47 |     crc = CRC_16_L_STEP(crc, *buf++);
48 |   }
49 |   crc ^= CRC_16_L_SEED;
50 |   return crc;
51 | }


--------------------------------------------------------------------------------
/src/dload.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * partition.cpp
  3 |  *
  4 |  * This class can perform emergency flashing given the transport layer
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/dload.cpp#5 $
 16 | $DateTime: 2015/04/29 17:06:00 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 11/08/11   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #include "dload.h"
 24 | #include "partition.h"
 25 | #include "diskwriter.h"
 26 | #define ERROR_WRITE_FAULT -19
 27 | //using namespace std;
 28 | 
 29 | void Dload::HexToByte(const char *hex, unsigned char *bin, int len)
 30 | {
 31 |   for(int i=0; i < len; i++) {
 32 |    unsigned char val1 = hex[i*2] - '0';
 33 |    unsigned char val2 = hex[i*2+1] - '0';
 34 |    if( val1 > 9 ) val1 = val1 - 7;
 35 |    if( val2 > 9 ) val2 = val2 - 7;
 36 |    bin[i] = (val1 << 4) + val2;
 37 |   }
 38 | }
 39 | 
 40 | Dload::Dload(SerialPort *port)
 41 | {
 42 |   // Initialize the serial port
 43 |   bSectorAddress = false;
 44 |   sport = port;
 45 | }
 46 | 
 47 | int Dload::ConnectToFlashProg(unsigned char ver)
 48 | {
 49 |   unsigned char hello[] = {EHOST_HELLO_REQ,'Q','C','O','M',' ','f','a','s','t',' ','d','o','w','n','l','o','a','d',' ','p','r','o','t','o','c','o','l',' ','h','o','s','t',ver,2,1};
 50 |   unsigned char security[] = {EHOST_SECURITY_REQ,0};
 51 |   unsigned char rsp[1060];
 52 |   int rspSize = sizeof(rsp);
 53 |   int status = 0;
 54 |   int i=0;
 55 | 
 56 |   if( ver > 2 ) {
 57 |     hello[35] |= FEATURE_SECTOR_ADDRESSES;
 58 |     bSectorAddress = true;
 59 |   }
 60 | 
 61 |   // For hello and security packets send 10 times each with 500ms delay
 62 |   // When device reconnects initially connection may take a while and be flakey
 63 |   for(; i < 10; i++) {
 64 |     rspSize = sizeof(rsp);
 65 |     status = sport->SendSync(hello,sizeof(hello),rsp,&rspSize);
 66 |     if( (status == 0) && (rspSize > 0) && (rsp[0] == EHOST_HELLO_RSP)) {
 67 |       break;
 68 |     }
 69 |     sport->Flush();
 70 |     emmcdl_sleep_ms(500);
 71 |   }
 72 | 
 73 |   // Clear out any stale data so we start on a new buffer
 74 |   sport->Flush();
 75 |   if( i == 10 ) {
 76 |     return EINVAL;
 77 |   }
 78 | 
 79 | 
 80 |   printf("Got hello response\n");
 81 |   for(; i < 10; i++) { 
 82 |     rspSize = sizeof(rsp);
 83 |     sport->SendSync(security,sizeof(security),rsp,&rspSize);
 84 |     if( (rspSize > 0) && (rsp[0] == EHOST_SECURITY_RSP)) {
 85 |       return 0;
 86 |     }
 87 |     sport->Flush();
 88 |     emmcdl_sleep_ms(500);
 89 |   }
 90 | 
 91 |   return EINVAL;
 92 | }
 93 | 
 94 | int Dload::DeviceReset()
 95 | {
 96 |   unsigned char reset[] = {EHOST_RESET_REQ};
 97 |   unsigned char rsp[32];
 98 |   int rspSize;
 99 | 
100 |   rspSize = sizeof(rsp);
101 |   sport->SendSync(reset,sizeof(reset),rsp,&rspSize);
102 |   if( (rspSize == 0) || (rsp[0] != EHSOT_RESET_ACK)) {
103 |     return EINVAL;
104 |   }
105 | 
106 |   return 0;
107 | }
108 | 
109 | int Dload::LoadPartition(char *szPrtnFile)
110 | {
111 |   int hFile;
112 |   int status = 0;
113 |   unsigned char rsp[32];
114 |   uint32_t bytesRead=0;
115 |   int rspSize;
116 |   unsigned char partition[1040] = {EHOST_PARTITION_REQ,0};
117 |   
118 |   hFile = emmcdl_creat(szPrtnFile,O_RDWR);
119 |   if( hFile == -1 ) return EINVAL;
120 | 
121 |   // Download the partition table as one large chunk
122 |   if((bytesRead = emmcdl_read(hFile,&partition[2],1024)) < 0 ) {
123 |     status = errno;
124 |   }
125 | 
126 |   if( bytesRead > 0 ) {
127 |     rspSize = sizeof(rsp);
128 |     sport->SendSync(partition,bytesRead+2,rsp,&rspSize);
129 |     if( (rspSize == 0) || (rsp[0] != EHOST_PARTITION_RSP) ) {
130 |       status = ERROR_WRITE_FAULT;
131 |     }
132 |   }
133 |   emmcdl_close(hFile);
134 | 
135 |   return status;
136 | }
137 | 
138 | int Dload::OpenPartition(int partition)
139 | {
140 |   unsigned char openmulti[] = {EHOST_OPEN_MULTI_REQ,(unsigned char)partition};
141 |   unsigned char rsp[32];
142 |   int rspSize;
143 | 
144 |   // Flush out any previous transactions
145 |   sport->Flush();
146 |   
147 |   // Open the partition
148 |   rspSize = sizeof(rsp);
149 |   sport->SendSync(openmulti,sizeof(openmulti),rsp,&rspSize);
150 |   if( (rspSize == 0) || (rsp[0] != EHOST_OPEN_MULTI_RSP)) {
151 |     printf("Could not open partition\n");
152 |     return EINVAL;
153 |   }
154 | 
155 |   return 0;
156 | }
157 | 
158 | int Dload::ClosePartition()
159 | {
160 |   unsigned char close[] = {EHOST_CLOSE_REQ};
161 |   unsigned char rsp[32];
162 |   int rspSize;
163 |   
164 |   // Close the partition we were writing to
165 |   rspSize = sizeof(rsp);
166 |   sport->SendSync(close,sizeof(close),rsp,&rspSize);
167 |   if( (rspSize == 0) || (rsp[0] != EHOST_CLOSE_RSP)) {
168 |     return EINVAL;
169 |   }
170 |   return 0;
171 | }
172 | 
173 | int Dload::FastCopySerial(int hInFile, uint32_t offset, uint32_t sectors)
174 | {
175 |   int status = 0;
176 |   unsigned char rsp[32];
177 |   uint32_t bytesRead=0;
178 |   uint32_t count = 0;
179 |   uint32_t readSize = 1024;
180 |   int rspSize;
181 |   unsigned char streamwrite[1050] = {EHOST_STREAM_WRITE_REQ,0};
182 | 
183 |   // For now don't worry about sliding window do a write and wait for response
184 |   while( (status == 0) && (count < sectors)) {
185 |     if( (count + 2) > sectors) {
186 |       readSize = 512;
187 |     }
188 |     // If int value is invalid then just write 0's
189 |     if( hInFile != -1 ) {
190 |       if((bytesRead = emmcdl_read(hInFile,&streamwrite[5],readSize)) < 0 ) {
191 |         status = errno;
192 |       }
193 |     } else {
194 |       memset(&streamwrite[5],0,readSize);
195 | 	  bytesRead = readSize;
196 |     }
197 | 
198 |     count += (bytesRead/512);
199 |     if( bytesRead > 0 ) {
200 |       // Write out the bytes we read to destination
201 |       streamwrite[1] = offset & 0xff;
202 |       streamwrite[2] = (offset >> 8) & 0xff;
203 |       streamwrite[3] = (offset >> 16) & 0xff;
204 |       streamwrite[4] = (offset >> 24) & 0xff;
205 |       rspSize = sizeof(rsp);
206 | 
207 |       sport->SendSync(streamwrite,bytesRead+5,rsp,&rspSize);
208 |       if( (rspSize == 0) || (rsp[0] != EHOST_STREAM_WRITE_RSP) ) {
209 |         printf("Device returned error: %i\n",rsp[0]);
210 |         if( rsp[0] == EHOST_LOG && rspSize >= 2) {
211 |           rsp[rspSize-2] = 0;
212 |           printf("%s", &rsp[1]);
213 |         }
214 |         status = ERROR_WRITE_FAULT;
215 |       }
216 |       if( bSectorAddress ) {
217 |         offset += bytesRead/SECTOR_SIZE;
218 |         printf("Destination sector: %i\r",(int)offset);
219 |       } else {
220 |         offset += bytesRead;
221 |         printf("Destination offset: %i\r",(int)offset);
222 |       }
223 |     } else {
224 |       // If we didn't read anything then break
225 |       break;
226 |     }
227 |   }
228 | 
229 |   printf("\n");
230 | 
231 |   // If we hit end of file that means we sent it all
232 |   return status;
233 | }
234 | 
235 | int Dload::LoadImage(char *szSingleImage)
236 | {
237 |   int hFile;
238 |   int status = 0;
239 | 
240 |   hFile = emmcdl_creat(szSingleImage, O_RDWR);
241 |   if( hFile == -1 ) {
242 |     printf("Filename not found %s\n",szSingleImage);
243 |     return EINVAL;
244 |   }
245 | 
246 |   status = FastCopySerial(hFile,0,(uint32_t)-1);
247 |   emmcdl_close(hFile);
248 | 
249 |   return status;
250 | }
251 | 
252 | int Dload::LoadFlashProg(char *szFlashPrg)
253 | {
254 |   unsigned char write32[280] = {CMD_WRITE_32BIT, 0};
255 |   unsigned char *writePtr;
256 |   unsigned char rsp[32];
257 |   int rspSize;
258 |   uint32_t goAddr = 0;
259 |   uint32_t targetAddr=0;
260 |   uint32_t newAddr=0;
261 |   uint32_t bytesRead;
262 |   uint32_t status = 0;
263 | 
264 |   char hexline[128];
265 |   FILE *fMprgFile = fopen(szFlashPrg,"rb");
266 | 
267 |   if( fMprgFile == NULL ) {
268 |     return EBADF;
269 |   }
270 | 
271 |   while( !feof(fMprgFile) ) {
272 |     unsigned char id=0;
273 |     bool bFirst = true;
274 |     writePtr = &write32[7];
275 |     // Read in data till we collect 256 bytes or hit end of file
276 |     for(bytesRead=0; bytesRead < 256;) {
277 |       unsigned char len;
278 |       char* unused = fgets(hexline,sizeof(hexline),fMprgFile);
279 |       if( strlen(hexline) > 9 ) {
280 |         HexToByte(&hexline[1],&len,1);
281 |         HexToByte(&hexline[3],rsp,2);
282 |         HexToByte(&hexline[7],&id,1);
283 |             
284 |         // Only read in data chunks
285 |         if( id == 0) {
286 |           HexToByte(&hexline[9],writePtr,len);
287 |           if( bFirst ) {
288 |             bFirst = false;
289 |             targetAddr = (targetAddr & 0xffff0000) + (rsp[0] << 8) + rsp[1];
290 |           }
291 |           writePtr += len;
292 |           bytesRead += len;
293 |         } else if( id == 1) {
294 |           // End of file marker
295 |           break;
296 |         } else if( id == 5) {
297 |           // File execute address
298 |           HexToByte(&hexline[9],rsp,4);
299 |           goAddr = (rsp[0] << 24) + (rsp[1] << 16) + (rsp[2] << 8) + rsp[3];
300 |         } else if( id == 4) {
301 |           // update the upper address bytes and write out chunk of last data
302 |           HexToByte(&hexline[9],rsp,2);
303 |           newAddr = (rsp[0] << 24) + (rsp[1] << 16);
304 |           break;
305 |         }
306 |       }
307 | 
308 |       // If we got new address then break;
309 |       if( id == 4 ) {
310 |         break;
311 |       }
312 |     }
313 | 
314 | 
315 |     if( bytesRead > 0 ) {
316 |       // Collected 256 bytes program it
317 |       write32[1] = (targetAddr >> 24) & 0xff;
318 |       write32[2] = (targetAddr >> 16) & 0xff;
319 |       write32[3] = (targetAddr >> 8) & 0xff;
320 |       write32[4] = targetAddr & 0xff;
321 |       write32[5] = (bytesRead >> 8) & 0xff;
322 |       write32[6] = bytesRead & 0xff;
323 |       rspSize = sizeof(rsp);
324 |       printf("Program at: 0x%x length %i\n",targetAddr,bytesRead);
325 |       sport->SendSync(write32,bytesRead+7,rsp,&rspSize);
326 |       if( (rspSize == 0) || (rsp[0] != CMD_ACK) ) {
327 |         status = ERROR_WRITE_FAULT;
328 |         break;
329 |       }
330 |     }
331 | 
332 |     targetAddr = newAddr;
333 |   }
334 |   fclose(fMprgFile);
335 |   
336 | 
337 |   if( status == 0 ) {
338 |     unsigned char gocmd[5] = {CMD_GO,0};
339 |     printf("sending go command 0x%x\n", (uint32_t)goAddr);
340 |     gocmd[1] = (goAddr >> 24) & 0xff;
341 |     gocmd[2] = (goAddr >> 16) & 0xff;
342 |     gocmd[3] = (goAddr >> 8) & 0xff;
343 |     gocmd[4] = goAddr & 0xff;
344 |   
345 |     // Send GO command if we successfully uploaded to end of file
346 |     rspSize = sizeof(rsp);
347 |     sport->SendSync(gocmd,sizeof(gocmd),rsp,&rspSize);
348 |     if( (rspSize > 0) && (rsp[0] == CMD_ACK)) {
349 |       status = 0;
350 |     } else {
351 |       status = ERROR_WRITE_FAULT;
352 |     }
353 |   }
354 |   
355 |   return status;
356 | }
357 | 
358 | int Dload::GetDloadParams(unsigned char *rsp, int len)
359 | {
360 |   unsigned char params[] = {CMD_PREQ};
361 |   int bytesRead = len;
362 |   // For params response we need at least 256 bytes
363 |   if( len < 16 ) {
364 |     return -1;
365 |   }
366 |   sport->SendSync(params,sizeof(params),rsp,&bytesRead);
367 |   if( (bytesRead > 0) && (rsp[0] == CMD_PARAMS) ) {
368 |     return 0;
369 |   }
370 |   return -2;
371 | }
372 | 
373 | int Dload::IsDeviceInDload(void)
374 | {
375 |   unsigned char nop[] = {CMD_NOP};
376 |   unsigned char rsp[32] = {0};
377 |   int bytesRead = 32;
378 | 
379 |   sport->SendSync(nop,sizeof(nop),rsp,&bytesRead);
380 |   for (int i=0;i < 32;i++)
381 |       printf("%x: ",rsp[i]);
382 |   printf("\n");
383 |   if( rsp[0] == CMD_ACK ) {
384 |     return 0;
385 |   }
386 |   
387 |   return EINVAL;
388 | }
389 | 
390 | int Dload::SetActivePartition()
391 | {
392 |   // Set currently open partition to active
393 |   unsigned char active_prtn[38] = {EHOST_STREAM_DLOAD_REQ,0x2};
394 |   unsigned char rsp[128] = {0};
395 |   int status = 0;
396 |   int bytesRead = sizeof(rsp);
397 |   unsigned short crc;
398 |   active_prtn[34] = 0xAD;
399 |   active_prtn[35] = 0xDE;
400 |   crc = CalcCRC16(&active_prtn[1],35);
401 |   active_prtn[36] = crc & 0xff;
402 |   active_prtn[37] = crc >> 8;
403 |   status = sport->SendSync(active_prtn,sizeof(active_prtn),rsp,&bytesRead);
404 |   if( (status == 0) && (rsp[0] == EHOST_STREAM_DLOAD_RSP) ) {
405 |     return 0;
406 |   }
407 | 
408 |   return status;
409 | }
410 | 
411 | int Dload::CreateGPP(uint32_t dwGPP1, uint32_t dwGPP2, uint32_t dwGPP3, uint32_t dwGPP4)
412 | {
413 |   unsigned char stream_dload[38] = {EHOST_STREAM_DLOAD_REQ,0x1};
414 |   unsigned char rsp[128] = {0};
415 |   int bytesRead = sizeof(rsp);
416 |   int status = 0;
417 |   unsigned short crc;
418 |   stream_dload[2] = dwGPP1 & 0xff;
419 |   stream_dload[3] = (dwGPP1 >> 8) & 0xff;
420 |   stream_dload[4] = (dwGPP1 >> 16) & 0xff;
421 |   stream_dload[5] = (dwGPP1 >> 24) & 0xff;
422 |   stream_dload[6] = dwGPP2 & 0xff;
423 |   stream_dload[7] = (dwGPP2 >> 8) & 0xff;
424 |   stream_dload[8] = (dwGPP2 >> 16) & 0xff;
425 |   stream_dload[9] = (dwGPP2 >> 24) & 0xff;
426 |   stream_dload[10] = dwGPP3 & 0xff;
427 |   stream_dload[11] = (dwGPP3 >> 8) & 0xff;
428 |   stream_dload[12] = (dwGPP3 >> 16) & 0xff;
429 |   stream_dload[13] = (dwGPP3 >> 24) & 0xff;
430 |   stream_dload[14] = dwGPP4 & 0xff;
431 |   stream_dload[15] = (dwGPP4 >> 8) & 0xff;
432 |   stream_dload[16] = (dwGPP4 >> 16) & 0xff;
433 |   stream_dload[17] = (dwGPP4 >> 24) & 0xff;
434 |   stream_dload[34] = 0xAD;
435 |   stream_dload[35] = 0xDE;
436 |   crc = CalcCRC16(&stream_dload[1],35);
437 |   stream_dload[36] = crc & 0xff;
438 |   stream_dload[37] = crc >> 8;
439 |   status = sport->SendSync(stream_dload,sizeof(stream_dload),rsp,&bytesRead);
440 |   if( (status == 0) && (rsp[0] == EHOST_STREAM_DLOAD_RSP) ) {
441 |     // Return actual size of the card
442 |     return 0;
443 |   }
444 |   return status;
445 | }
446 | 
447 | 
448 | __uint64_t Dload::GetNumDiskSectors()
449 | {
450 |   unsigned char stream_dload[38] = {EHOST_STREAM_DLOAD_REQ,0x0};
451 |   unsigned char rsp[128] = {0};
452 |   int bytesRead = sizeof(rsp);
453 |   int status = 0;
454 |   unsigned short crc;
455 |   stream_dload[34] = 0xAD;
456 |   stream_dload[35] = 0xDE;
457 |   crc = CalcCRC16(&stream_dload[1],35);
458 |   stream_dload[36] = crc & 0xff;
459 |   stream_dload[37] = crc >> 8;
460 |   status = sport->SendSync(stream_dload,sizeof(stream_dload),rsp,&bytesRead);
461 |   if( (status == 0) && (rsp[0] == EHOST_STREAM_DLOAD_RSP) ) {
462 |     // Return actual size of the card
463 |     return (rsp[5] | rsp[6] << 8 | rsp[7] << 16 | rsp[8] << 24);
464 |   }
465 |   return status;
466 | }
467 | 
468 | int Dload::ProgramPartitionEntry(PartitionEntry pe)
469 | {
470 |   int status = 0;
471 |   int hInFile = -1;
472 | 
473 |   if( strcmp(pe.filename,"ZERO") == 0 ) {
474 |     printf("Zeroing out area\n");
475 |   } else {
476 |     // Open the file that we are supposed to dump
477 |     hInFile = emmcdl_creat( pe.filename, O_RDWR);
478 | 
479 |     if( hInFile == -1 ) {
480 |       status = errno;
481 |     } else {
482 |       status = emmcdl_lseek(hInFile, pe.offset, SEEK_SET);
483 |     }
484 |   }
485 |   
486 |   if( status == 0 ) {
487 |     // Fast copy from input file to Serial port
488 |     printf("\nIn offset: %lu out offset: %lu sectors: %lu\n",pe.offset, pe.start_sector,pe.num_sectors);
489 |     status = FastCopySerial(hInFile,(uint32_t)pe.start_sector,(uint32_t)pe.num_sectors);
490 |   }
491 |   
492 |   if( hInFile != -1 ) emmcdl_close(hInFile);
493 |   return status;
494 | }
495 | 
496 | int Dload::WipeDiskContents(__uint64_t start_sector, __uint64_t num_sectors)
497 | {
498 |   PartitionEntry pe;
499 |   memset(&pe,0,sizeof(pe));
500 |   strcpy(pe.filename,"ZERO");
501 |   pe.start_sector = start_sector;
502 |   pe.num_sectors = num_sectors;
503 |   return ProgramPartitionEntry(pe);
504 | }
505 | 
506 |  int Dload::WriteRawProgramFile(char *szXMLFile)
507 |  {
508 |   int status = 0;
509 |   Partition *p;
510 |   p = new Partition(GetNumDiskSectors());
511 | 
512 |   printf("Parsing partition table: %s\n", szXMLFile);
513 |   status = p->PreLoadImage(szXMLFile);
514 |   if( status != 0 ) {
515 | 	printf("Partition table failed to load\n");
516 |     delete p;
517 |     return status;
518 |   }
519 | 
520 |   PartitionEntry pe;
521 |   char keyName[MAX_STRING_LEN];
522 |   char *key;
523 |   while( p->GetNextXMLKey(keyName,&key) == 0 ) {
524 | 	  memset(&pe, 0, sizeof(pe));
525 |     // parse the XML key if we don't understand it then continue
526 |     if( p->ParseXMLKey(key,&pe) != 0 ) continue;
527 |     // If there is a CRC then calculate this value before we write it out
528 |     if( pe.eCmd == CMD_PROGRAM ) {
529 |       status = ProgramPartitionEntry(pe);
530 |     } else if( pe.eCmd == CMD_PATCH ) {
531 |       // Use the diskwriter to patch the actual file on disk
532 |       Partition *part = new Partition(0);
533 |       part->ProgramPartitionEntry(NULL, pe, NULL);
534 |       delete part;
535 |     } else if( pe.eCmd == CMD_ZEROOUT ) {
536 |       status = WipeDiskContents(pe.start_sector,pe.num_sectors);
537 |     }
538 | 
539 |     if( status != 0 ) {
540 |       break;
541 |     }
542 |   }
543 | 
544 |   delete p;
545 |   return status;
546 |  }
547 | 


--------------------------------------------------------------------------------
/src/ffu.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 | * ffu.cpp
  3 | *
  4 | * This class implements FFU image support
  5 | *
  6 | * Copyright (c) 2007-2011
  7 | * Qualcomm Technologies Incorporated.
  8 | * All Rights Reserved.
  9 | * Qualcomm Confidential and Proprietary
 10 | *
 11 | *****************************************************************************/
 12 | /*=============================================================================
 13 | Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/ffu.cpp#20 $
 16 | $DateTime: 2015/05/07 21:41:17 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 11/04/12   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #include "stdio.h"
 24 | #include "stdlib.h"
 25 | #include "ffu.h"
 26 | #include "sysdeps.h"
 27 | #include "string.h"
 28 | 
 29 | // Constructor
 30 | FFUImage::FFUImage()
 31 | {
 32 |   hFFU = -1;
 33 |   ValidationEntries = NULL;
 34 |   BlockDataEntries = NULL;
 35 |   GptEntries = NULL;
 36 | 
 37 |   // Default sector size can be overridden
 38 |   DISK_SECTOR_SIZE = 512;
 39 | }
 40 | 
 41 | FFUImage::~FFUImage()
 42 | {
 43 |   if(GptEntries) free(GptEntries);
 44 |   if(BlockDataEntries) free(BlockDataEntries);
 45 |   if(ValidationEntries) free(ValidationEntries);
 46 |   ValidationEntries=NULL;
 47 |   BlockDataEntries = NULL;
 48 |   GptEntries = NULL;
 49 | }
 50 | 
 51 | // Set the disk sector size normally 512 for eMMC or 4096 for UFS
 52 | void FFUImage::SetDiskSectorSize(int size)
 53 | {
 54 |   DISK_SECTOR_SIZE = size;
 55 | }
 56 | 
 57 | // Given a 64 bit memory address, set the Offset and OffsetHigh of an OVERLAPPED variable 
 58 | void FFUImage::SetOffset(void** ovlVariable, uint64_t offset)
 59 | {
 60 | /*  ResetEvent(ovlVariable->hEvent);
 61 |   ovlVariable->Offset = offset & 0xffffffff;
 62 |   ovlVariable->OffsetHigh = (offset & 0xffffffff00000000) >> 32;*/
 63 | }
 64 | 
 65 | // Compute the size of the padding at the end of each section of the FFU, and return
 66 | // the offset into the file of the next starting area.
 67 | uint64_t FFUImage::GetNextStartingArea(uint64_t chunkSizeInBytes, uint64_t sizeOfArea)
 68 | {
 69 |   uint64_t extraSpacePastBoundary = sizeOfArea % chunkSizeInBytes;
 70 |   // If the area does not end on a chunk boundary (i.e. there is a padding), compute next boundary.
 71 |   if (extraSpacePastBoundary != 0) {
 72 |     return sizeOfArea + (chunkSizeInBytes - extraSpacePastBoundary);
 73 |   } else {
 74 |     return  sizeOfArea;
 75 |   }
 76 | 
 77 | }
 78 | 
 79 | int FFUImage::AddEntryToRawProgram(char *szRawProgram, char *szFileName, uint64_t ui64FileOffset, int64_t i64StartSector, uint64_t ui64NumSectors)
 80 | {
 81 | /*  HANDLE hRawPrg;
 82 |   char szXMLString[MAX_STRING_LEN * 2];
 83 |   char szFile[MAX_STRING_LEN];
 84 |   uint32_t dwBytesWrite;
 85 |   size_t sBytesConvert;
 86 |   int status = ERROR_SUCCESS;
 87 |   hRawPrg = CreateFile(szRawProgram,
 88 |     GENERIC_WRITE | GENERIC_READ,
 89 |     0,    // We want exclusive access to this disk
 90 |     NULL,
 91 |     OPEN_EXISTING,
 92 |     FILE_ATTRIBUTE_NORMAL,
 93 |     NULL);
 94 |   if (hRawPrg == -1) {
 95 |     status = GetLastError();
 96 |   }
 97 |   else {
 98 |     SetFilePointer(hRawPrg, 0, 0, FILE_END);
 99 |     wcstombs_s(&sBytesConvert, szFile, sizeof(szFile), szFileName, sizeof(szFile));
100 |     if (i64StartSector < 0) {
101 |       sprintf_s(szXMLString, sizeof(szXMLString), "<program SECTOR_SIZE_IN_BYTES=\"%i\" file_sector_offset=\"%I64d\" filename=\"%s\" label=\"ffu_image_%I64d\" num_partition_sectors=\"%I64d\" physical_partition_number=\"0\" size_in_KB=\"%I64d\" sparse=\"false\" start_byte_hex=\"0x%I64x\" start_sector=\"NUM_DISK_SECTORS%I64d\"/>\n",
102 |         DISK_SECTOR_SIZE,ui64FileOffset, szFile, i64StartSector, ui64NumSectors, ui64NumSectors / 2, i64StartSector * 512, i64StartSector);
103 |     }
104 |     else {
105 |       sprintf_s(szXMLString, sizeof(szXMLString), "<program SECTOR_SIZE_IN_BYTES=\"%i\" file_sector_offset=\"%I64d\" filename=\"%s\" label=\"ffu_image_%I64d\" num_partition_sectors=\"%I64d\" physical_partition_number=\"0\" size_in_KB=\"%I64d\" sparse=\"false\" start_byte_hex=\"0x%I64x\" start_sector=\"%I64d\"/>\n",
106 |         DISK_SECTOR_SIZE, ui64FileOffset, szFile, i64StartSector, ui64NumSectors, ui64NumSectors / 2, i64StartSector * 512, i64StartSector);
107 |     }
108 |     WriteFile(hRawPrg, szXMLString, strlen(szXMLString), &dwBytesWrite, NULL);
109 |     CloseHandle(hRawPrg);
110 |   }
111 | 
112 |   return status;*/
113 | 	return 0;
114 | }
115 | 
116 | int FFUImage::TerminateRawProgram(char *szFileName)
117 | {
118 | /*  HANDLE hRawPrg;
119 |   uint32_t dwBytesOut;
120 |   char szXMLString[] = "</data>\n";
121 |   hRawPrg = CreateFile( szFileName,
122 |     GENERIC_WRITE | GENERIC_READ,
123 |     0,    // We want exclusive access to this disk
124 |     NULL,
125 |     OPEN_EXISTING,
126 |     FILE_ATTRIBUTE_NORMAL,
127 |     NULL);
128 |   
129 |   if( hRawPrg == -1 ) {
130 |     return GetLastError();
131 |   }
132 | 
133 |   SetFilePointer(hRawPrg,0,0,FILE_END);
134 | 
135 |   // write out all the entries for gpt_main0.bin
136 |   WriteFile(hRawPrg,szXMLString,sizeof(szXMLString)-1,&dwBytesOut,NULL);
137 | 
138 |   CloseHandle(hRawPrg);
139 |   return ERROR_SUCCESS;*/
140 |   return 0;
141 | }
142 | 
143 | int FFUImage::CreateRawProgram(char *szFFUFile, char *szFileName)
144 | {
145 |   /*HANDLE hRawPrg;
146 |   uint32_t dwBytesOut;
147 |   char szPath[256] = { 0 };
148 |   char szOut[256] = { 0 };
149 |   char szXMLString[256] = { 0 };
150 |   sprintf_s(szXMLString, sizeof(szXMLString), "<?xml version=\"1.0\" ?>\n<data>\n");
151 |   hRawPrg = CreateFile(szFileName,
152 |     GENERIC_WRITE | GENERIC_READ,
153 |     0,    // We want exclusive access to this disk
154 |     NULL,
155 |     CREATE_ALWAYS,
156 |     FILE_ATTRIBUTE_NORMAL,
157 |     NULL);
158 |   if (hRawPrg == -1) {
159 |     return GetLastError();
160 |   }
161 | 
162 |   // write out all the entries for gpt_main0.bin
163 |   WriteFile(hRawPrg, szXMLString, strlen(szXMLString), &dwBytesOut, NULL);
164 | 
165 |   wcstombs_s((size_t *)&dwBytesOut, szPath, sizeof(szPath), szFFUFile, wcslen(szFFUFile));
166 |   wcstombs_s((size_t *)&dwBytesOut, szOut, sizeof(szOut), szFileName, wcslen(szFileName));
167 |   sprintf_s(szXMLString, sizeof(szXMLString), "<!-- emmcdl.exe -splitffu %s -o %s -->\n", szPath, szOut);
168 |   WriteFile(hRawPrg, szXMLString, strlen(szXMLString), &dwBytesOut, NULL);
169 | 
170 |   CloseHandle(hRawPrg);
171 |   return ERROR_SUCCESS;*/
172 | 	return 0;
173 | }
174 | 
175 | int FFUImage::ReadGPT(void)
176 | {
177 |  /* // Read in the data chunk for GPT
178 |   if (hFFU == -1 ) return ERROR_INVALID_HANDLE;
179 |   uint32_t bytesRead = 0;
180 |   uint64_t readOffset = PayloadDataStart + FFUStoreHeader.dwFinalTableIndex*FFUStoreHeader.dwBlockSizeInBytes;
181 | 
182 |   GptEntries = (gpt_entry_t*)malloc(sizeof(gpt_entry_t)*128);
183 |   SetOffset(&OvlRead, readOffset);
184 | 
185 |   // Read contents directly from FFU into the partition table
186 |   if (!ReadFile(hFFU, &GptProtectiveMBR, sizeof(GptProtectiveMBR), &bytesRead, &OvlRead)){
187 |     return GetLastError();
188 |   }
189 |   readOffset += sizeof(GptProtectiveMBR);
190 |   SetOffset(&OvlRead, readOffset);
191 |   if (!ReadFile(hFFU, &GptHeader, sizeof(GptHeader), &bytesRead, &OvlRead)){
192 |     return GetLastError();
193 |   }
194 | 
195 |   readOffset += sizeof(GptHeader);
196 |   SetOffset(&OvlRead, readOffset);
197 |   if (!ReadFile(hFFU, GptEntries, sizeof(gpt_entry_t)* 128, &bytesRead, &OvlRead)){
198 |     return GetLastError();
199 |   }
200 | 
201 |   return ERROR_SUCCESS;*/
202 | 	return 0;
203 | }
204 | 
205 | 
206 | int FFUImage::ParseHeaders(void)
207 | {
208 |  /* int hashedChunkSizeInBytes;
209 |   int hashedChunkSizeInKB;
210 |   uint64_t currentAreaEndSpot = 0;
211 |   uint64_t nextAreaStartSpot = 0;
212 |   uint32_t bytesRead = 0;
213 | 
214 |   if( hFFU == -1 ) return ERROR_INVALID_HANDLE;
215 | 
216 |    Read the Security Header
217 |   SetOffset(&OvlRead, 0);
218 |   if( !ReadFile(hFFU, &FFUSecurityHeader, sizeof(FFUSecurityHeader), &bytesRead, &OvlRead) ) {
219 |     return ERROR_READ_FAULT;
220 |   }
221 | 
222 |   hashedChunkSizeInKB = FFUSecurityHeader.dwChunkSizeInKb;
223 |   hashedChunkSizeInBytes = hashedChunkSizeInKB * 1024;
224 | 
225 |    Read the Image Header
226 | 
227 |   // Get the location in the file of the ImageHeader
228 |   currentAreaEndSpot = sizeof(FFUSecurityHeader) + FFUSecurityHeader.dwCatalogSize + FFUSecurityHeader.dwHashTableSize;
229 |   nextAreaStartSpot = GetNextStartingArea(hashedChunkSizeInBytes, currentAreaEndSpot);
230 | 
231 |   // Read memory
232 |   SetOffset(&OvlRead, nextAreaStartSpot);
233 |   if (!ReadFile(hFFU, &FFUImageHeader, sizeof(FFUImageHeader), &bytesRead, &OvlRead)) 
234 |     return GetLastError();
235 | 
236 |    Read the StoreHeader
237 | 
238 |   // Get the location in the file of the StoreHeader
239 |   currentAreaEndSpot = nextAreaStartSpot + sizeof(FFUImageHeader) + FFUImageHeader.ManifestLength;
240 |   nextAreaStartSpot = GetNextStartingArea(hashedChunkSizeInBytes, currentAreaEndSpot);
241 | 
242 |   // Read memory
243 |   SetOffset(&OvlRead, nextAreaStartSpot);
244 |   if (!ReadFile(hFFU, &FFUStoreHeader, sizeof(FFUStoreHeader), &bytesRead, &OvlRead)) {
245 |     return GetLastError();
246 |   }
247 | 
248 |   nextAreaStartSpot += sizeof(STORE_HEADER);
249 |   nextAreaStartSpot = GetNextStartingArea(sizeof(BLOCK_DATA_ENTRY), nextAreaStartSpot);
250 | 
251 |   // Verify the values read in are sane
252 |   if( (FFUStoreHeader.dwValidateDescriptorLength < 1000000 ) && 
253 |       (FFUStoreHeader.dwWriteDescriptorLength < 1000000) && 
254 |       (FFUStoreHeader.dwWriteDescriptorCount < 0x10000000) ) {
255 | 
256 |     ValidationEntries = (unsigned char *)malloc(FFUStoreHeader.dwValidateDescriptorLength);
257 |     BlockDataEntries = (BLOCK_DATA_ENTRY*)malloc(FFUStoreHeader.dwWriteDescriptorLength);
258 | 
259 |     if(ValidationEntries == NULL || BlockDataEntries == NULL ) {
260 |       wprintf(L"Failed to allocated memory for headers\n");
261 |       return ERROR_OUTOFMEMORY;
262 |     }
263 | 
264 |     // Get the location in the file of the Validation Entries, read from file
265 |     if (FFUStoreHeader.dwValidateDescriptorLength > 0){
266 |       SetOffset(&OvlRead, nextAreaStartSpot);
267 |       if (!ReadFile(hFFU, ValidationEntries, FFUStoreHeader.dwValidateDescriptorLength, &bytesRead, &OvlRead)) 
268 |         return GetLastError();
269 |       nextAreaStartSpot += FFUStoreHeader.dwValidateDescriptorLength;
270 |     }
271 | 
272 |     // Get location of start of block data entries they are aligned to the size of a BLOCK_DATA_ENTRY
273 |     if (FFUStoreHeader.dwWriteDescriptorLength > 0){
274 |       SetOffset(&OvlRead, nextAreaStartSpot);
275 |       if (!ReadFile(hFFU, BlockDataEntries, FFUStoreHeader.dwWriteDescriptorLength, &bytesRead, &OvlRead))
276 |         return GetLastError();
277 |       nextAreaStartSpot += FFUStoreHeader.dwWriteDescriptorLength;
278 |     }
279 | 
280 |     // Get the location of the payload data
281 |     nextAreaStartSpot = GetNextStartingArea(hashedChunkSizeInBytes, nextAreaStartSpot);
282 |     PayloadDataStart = nextAreaStartSpot;
283 |   }
284 |   return ERROR_SUCCESS;*/
285 | 	return 0;
286 | }
287 | 
288 | int FFUImage::DumpRawProgram(char *szFFUFile, char *szRawProgram)
289 | {
290 |   /*BOOL  bPendingData = FALSE;
291 |   uint32_t dwNextBlockIndex = 0;
292 |   uint32_t dwBlockOffset = 0;
293 |   uint32_t dwStartBlock = 0;
294 |   BLOCK_DATA_ENTRY* BlockDataEntriesPtr = BlockDataEntries;
295 |   int status = ERROR_SUCCESS;
296 |   int64_t diskOffset = 0;
297 | 
298 |   for (UINT32 i = 0; i < FFUStoreHeader.dwWriteDescriptorCount; i++) {
299 |     for (UINT32 j = 0; j < BlockDataEntriesPtr->dwLocationCount; j++){
300 |       if (BlockDataEntriesPtr->rgDiskLocations[j].dwDiskAccessMethod == DISK_BEGIN) {
301 |         // If this block does not follow the previous block create a new chunk 
302 |         if (BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex != dwNextBlockIndex) {
303 |           // Add this entry to the rawprogram0.xml
304 |           if (bPendingData) {
305 |             AddEntryToRawProgram(szRawProgram, szFFUFile, (PayloadDataStart + dwStartBlock*FFUStoreHeader.dwBlockSizeInBytes) / 512,
306 |               (diskOffset / 512), (dwBlockOffset - dwStartBlock) * 128 * 2);
307 |           }
308 |           diskOffset = (uint64_t)BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex*(uint64_t)FFUStoreHeader.dwBlockSizeInBytes;
309 |           dwStartBlock = dwBlockOffset;
310 |           bPendingData = TRUE;
311 |         }
312 | 
313 |         dwNextBlockIndex = BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex + 1;
314 | 
315 |       }
316 |       else if (BlockDataEntriesPtr->rgDiskLocations[j].dwDiskAccessMethod == DISK_END) {
317 |         // Add this entry to the rawprogram0.xml
318 |         if (bPendingData) {
319 |           AddEntryToRawProgram(szRawProgram, szFFUFile, (PayloadDataStart + dwStartBlock*FFUStoreHeader.dwBlockSizeInBytes) / 512,
320 |             (diskOffset / 512), (i - dwStartBlock) * 128 * 2);
321 |         }
322 | 
323 |         diskOffset = (int64_t)-1 * (int64_t)FFUStoreHeader.dwBlockSizeInBytes;  // End of disk is -1
324 | 
325 |         // Add this entry to the rawprogram0.xml special case this should be last chunk in the disk
326 |         AddEntryToRawProgram(szRawProgram, szFFUFile, (PayloadDataStart + dwBlockOffset*FFUStoreHeader.dwBlockSizeInBytes) / 512,
327 |           (diskOffset / 512), FFUStoreHeader.dwBlockSizeInBytes / 512);
328 |         bPendingData = FALSE;
329 |       }
330 | 
331 |     }
332 | 
333 |     // Increment our offset by number of blocks
334 |     if (BlockDataEntriesPtr->dwLocationCount > 0) {
335 |       BlockDataEntriesPtr = (BLOCK_DATA_ENTRY *)((uint32_t)BlockDataEntriesPtr + (sizeof(BLOCK_DATA_ENTRY)+(BlockDataEntriesPtr->dwLocationCount - 1)*sizeof(DISK_LOCATION)));
336 |     }
337 |     else {
338 |       BlockDataEntriesPtr = (BLOCK_DATA_ENTRY *)((uint32_t)BlockDataEntriesPtr + sizeof(BLOCK_DATA_ENTRY));
339 |     }
340 |     dwBlockOffset++;
341 |   }
342 | 
343 |   if (bPendingData) {
344 |     // Add this entry to the rawprogram0.xml
345 |     AddEntryToRawProgram(szRawProgram, szFFUFile, (PayloadDataStart + dwStartBlock*FFUStoreHeader.dwBlockSizeInBytes) / 512,
346 |       (diskOffset / 512), (dwBlockOffset - dwStartBlock) * 128 * 2);
347 |   }
348 | 
349 |   return status;*/
350 | }
351 | 
352 | int FFUImage::FFUToRawProgram(char *szFFUName, char *szImageFile)
353 | {
354 |  /* char *szFFUFile = wcsrchr(szFFUName, L'\\');
355 |   int status = PreLoadImage(szFFUName);
356 |   if (status != ERROR_SUCCESS) goto FFUToRawProgramExit;
357 |   status = CreateRawProgram(szFFUName, szImageFile);
358 |   if (status != ERROR_SUCCESS) goto FFUToRawProgramExit;
359 |   // Only put the filename in the output 
360 |   if (szFFUFile != NULL) szFFUFile++;
361 |   else szFFUFile = szFFUName;
362 |   status = DumpRawProgram(szFFUFile, szImageFile);
363 |   if (status != ERROR_SUCCESS) goto FFUToRawProgramExit;
364 |   status = TerminateRawProgram(szImageFile);
365 | 
366 | FFUToRawProgramExit:
367 |   CloseFFUFile();
368 |   return status;*/
369 | }
370 | 
371 | int FFUImage::FFUDumpDisk(Protocol *proto)
372 | {
373 |   /*int status = ERROR_SUCCESS;
374 |   uint32_t bytesRead = 0;
375 |   uint32_t dwTotalBytes = 0;
376 |   uint32_t dwBlockCount = 0;
377 |   uint32_t lastLBA = 0;
378 |   int64_t diskStart = 0;
379 |   int64_t diskOffset = 0;
380 |   BLOCK_DATA_ENTRY* BlockDataEntriesPtr = BlockDataEntries;
381 | 
382 |    Copy the data to disk
383 |   unsigned char *dataBlock = (unsigned char*)malloc(FFUStoreHeader.dwBlockSizeInBytes*64); // Create storage for 64*128 KB block
384 |   if( dataBlock == NULL ) return ERROR_OUTOFMEMORY;
385 |   for (UINT32 i = 0; i < FFUStoreHeader.dwWriteDescriptorCount; i++) {
386 |     for (UINT32 j = 0; j < BlockDataEntriesPtr->dwLocationCount; j++){
387 |       if (BlockDataEntriesPtr->rgDiskLocations[j].dwDiskAccessMethod == DISK_BEGIN) {
388 |         // If our new block is not at the location of the last block + 1 then write out pending old data and update lastLBA 
389 |         if (BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex != lastLBA + 1 || (dwTotalBytes > FFUStoreHeader.dwBlockSizeInBytes * 60))
390 |         {
391 |           if (dwTotalBytes > 0) {
392 |             printf("dwBlockIndex: %i\n", BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex);
393 |             printf("dwBlockSizeInBytes: %i\n", FFUStoreHeader.dwBlockSizeInBytes);
394 |             status = proto->WriteData(dataBlock, diskStart, dwTotalBytes, &bytesRead,0);
395 |             if (status != ERROR_SUCCESS) goto FFUDumpDiskCleanUp;
396 |           }
397 |           // reset the disk start address and total bytes read
398 |           diskStart = (int64_t)BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex*(int64_t)FFUStoreHeader.dwBlockSizeInBytes;
399 |           dwTotalBytes = 0;
400 |         }
401 | 
402 |         lastLBA = BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex;
403 | 
404 |         // Create new file to dump this chunk
405 |         SetOffset(&OvlRead, PayloadDataStart + dwBlockCount*FFUStoreHeader.dwBlockSizeInBytes);
406 |         if (!ReadFile(hFFU, dataBlock + dwTotalBytes, FFUStoreHeader.dwBlockSizeInBytes, &bytesRead, &OvlRead)) {
407 |           status = GetLastError();
408 | 		  goto FFUDumpDiskCleanUp;
409 | 		}
410 |         dwTotalBytes += bytesRead;
411 |       }
412 |       else if (BlockDataEntriesPtr->rgDiskLocations[j].dwDiskAccessMethod == DISK_END) {
413 |         // If there is any pending data from DISK_START write it out before reading in this data for disk end
414 |         if (dwTotalBytes > 0) {
415 |           status = proto->WriteData(dataBlock, diskStart, dwTotalBytes, &bytesRead,0);
416 |           dwTotalBytes = 0;
417 |         }
418 |         diskOffset = -1 * (int64_t)(BlockDataEntriesPtr->rgDiskLocations[j].dwBlockIndex + 1)*(int64_t)FFUStoreHeader.dwBlockSizeInBytes;  // End of disk is -1
419 |         // Create new file to dump this chunk
420 |         SetOffset(&OvlRead, PayloadDataStart + dwBlockCount*FFUStoreHeader.dwBlockSizeInBytes);
421 |         if (!ReadFile(hFFU, dataBlock, FFUStoreHeader.dwBlockSizeInBytes, &bytesRead, &OvlRead)) {
422 |           status = GetLastError();
423 |           goto FFUDumpDiskCleanUp;
424 |         }
425 | 
426 |         // Write the data into a file
427 |         status = proto->WriteData(dataBlock, diskOffset, bytesRead, &bytesRead,0);
428 |       }
429 | 
430 |     }
431 | 	// Increment our offset by number of blocks
432 | 	if (BlockDataEntriesPtr->dwLocationCount > 0) {
433 | 		BlockDataEntriesPtr = (BLOCK_DATA_ENTRY *)((uint32_t)BlockDataEntriesPtr + (sizeof(BLOCK_DATA_ENTRY)+(BlockDataEntriesPtr->dwLocationCount - 1)*sizeof(DISK_LOCATION)));
434 | 	}
435 | 	else {
436 | 		BlockDataEntriesPtr = (BLOCK_DATA_ENTRY *)((uint32_t)BlockDataEntriesPtr + sizeof(BLOCK_DATA_ENTRY));
437 | 	}
438 | 	dwBlockCount++;
439 |   }
440 | 
441 |   // Only write out the data 
442 |   if (dwTotalBytes > 0)
443 |   {
444 |     status = proto->WriteData(dataBlock, diskStart, dwTotalBytes, &bytesRead,0);
445 |   }
446 |   // If we programmed successfully reset the device
447 |   proto->DeviceReset();
448 | 
449 | FFUDumpDiskCleanUp:
450 |   free(dataBlock);
451 |   return status;*/
452 | 
453 | }
454 | 
455 | int FFUImage::ProgramImage(Protocol *proto, int64_t dwOffset)
456 | {
457 |  /* UNREFERENCED_PARAMETER(dwOffset); // This value is embedded in the FFU
458 |   int status = ERROR_SUCCESS;
459 | 
460 |   // Make sure parameters passed in are valid
461 |   if( proto == NULL ) {
462 |     return ERROR_INVALID_PARAMETER;
463 |   }
464 | 
465 |   status = FFUDumpDisk(proto);
466 |   return status;*/
467 | }
468 | 
469 | int FFUImage::PreLoadImage(char *szFFUPath)
470 | {
471 |  /* int status = ERROR_SUCCESS;
472 |   OvlRead.hEvent = CreateEvent(NULL, FALSE, NULL, NULL);
473 |   OvlWrite.hEvent = CreateEvent(NULL, FALSE, NULL, NULL);
474 |   if( (OvlRead.hEvent == NULL) || (OvlWrite.hEvent == NULL)) {
475 |     return ERROR_OUTOFMEMORY;
476 |   }
477 |   ResetEvent(OvlRead.hEvent);
478 |   ResetEvent(OvlWrite.hEvent);
479 | 
480 |   hFFU = CreateFile( szFFUPath,
481 |     GENERIC_READ,
482 |     FILE_SHARE_READ, // Open file for read and let others access it as well
483 |     NULL,
484 |     4,
485 |     FILE_ATTRIBUTE_NORMAL,
486 |     NULL);
487 |   if (hFFU == -1) return GetLastError();
488 | 
489 |   status = ParseHeaders();
490 |   if( status != ERROR_SUCCESS ) return status;
491 |   status = ReadGPT();
492 | 
493 |   return status;*/
494 | }
495 | 
496 | int FFUImage::SplitFFUBin( char *szPartName, char *szOutputFile)
497 | {
498 |   /*uint32_t bytesRead = 0;
499 |   uint32_t start_sector = 0;
500 |   uint32_t end_sector = 0;
501 |   int status = ERROR_SUCCESS;
502 |   HANDLE hImage = -1;
503 |   uint32_tLONG diskOffset = 0;
504 |   UINT32 i=0;
505 |   char szNewFile[256];
506 | 
507 |   for(i=0; i < 128; i++) {
508 |     // If all is selected then dump all partitions
509 |     if( wcscmp(szPartName,_T("all")) == 0  ) {
510 |       // Ignore partitions without name
511 |       if(wcscmp(GptEntries[i].part_name,_T("")) == 0)
512 |       {
513 |         continue;
514 |       }
515 |       SplitFFUBin(GptEntries[i].part_name,szOutputFile);
516 |     } else if( wcscmp(GptEntries[i].part_name,szPartName) == 0 ) {
517 |       start_sector = (uint32_t)GptEntries[i].first_lba;
518 |       end_sector = (uint32_t)GptEntries[i].last_lba;
519 |       break;
520 |     }
521 |   }
522 | 
523 |   // If no partition was found or crashdump partition return
524 |   if( (i == 128) || (wcscmp(GptEntries[i].part_name,L"CrashDump") == 0) ) return ERROR_SUCCESS;
525 | 
526 |   swprintf_s(szNewFile,_T("%s\\%s.bin"),szOutputFile,GptEntries[i].part_name);
527 | 
528 |   for (i = 0; i < FFUStoreHeader.dwWriteDescriptorCount; i++) {
529 |     if(BlockDataEntries[i].dwBlockCount == 0)
530 |     {
531 |       // No blocks attached to this entry
532 |       continue;
533 |     }
534 | 
535 |     diskOffset = BlockDataEntries[i].rgDiskLocations[0].dwBlockIndex;
536 |     diskOffset *= FFUStoreHeader.dwBlockSizeInBytes;
537 | 
538 |     if( ((diskOffset/512) >= start_sector) &&  ((diskOffset/512) <= end_sector)) {
539 |       unsigned char *dataBlock = (unsigned char*)malloc(FFUStoreHeader.dwBlockSizeInBytes); // Create storage for 128 KB block
540 |       if(dataBlock == NULL ) return ERROR_OUTOFMEMORY;
541 | 
542 |       SetOffset(&OvlRead, PayloadDataStart+(i)*FFUStoreHeader.dwBlockSizeInBytes );
543 |       if (!ReadFile(hFFU, dataBlock, FFUStoreHeader.dwBlockSizeInBytes, &bytesRead, &OvlRead)) {
544 |         status = GetLastError();
545 |         break;
546 |       }
547 | 
548 |       // Only create the file if there is data to write to it
549 |       if( hImage == -1 ) {
550 |         wprintf(_T("Exporting file: %s\n"),szNewFile);
551 |         hImage = CreateFile( szNewFile,
552 |           GENERIC_WRITE | GENERIC_READ,
553 |           0,    // We want exclusive access to this disk
554 |           NULL,
555 |           CREATE_ALWAYS,
556 |           FILE_ATTRIBUTE_NORMAL,
557 |           NULL);
558 |         if( hImage == -1 ) return GetLastError();
559 |       }
560 | 
561 |       uint32_tLONG tmp = start_sector; // Needed to force 64bit calc
562 |       tmp = tmp * 512;
563 |       diskOffset -= tmp;
564 | 
565 |       SetOffset(&OvlWrite, diskOffset);
566 |       WriteFile(hImage, dataBlock, FFUStoreHeader.dwBlockSizeInBytes, &bytesRead, &OvlWrite);
567 |       free(dataBlock);
568 |     }
569 |   }
570 |   //}
571 | 
572 |   if(hImage != -1 ) CloseHandle(hImage);
573 |   return status;*/
574 | }
575 | 
576 | int FFUImage::CloseFFUFile(void)
577 | {
578 | /*  CloseHandle(OvlRead.hEvent);
579 |   CloseHandle(OvlWrite.hEvent);
580 |   CloseHandle(hFFU);
581 |   hFFU = -1;
582 |   return ERROR_SUCCESS;*/
583 | }
584 | 


--------------------------------------------------------------------------------
/src/partition.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * partition.cpp
  3 |  *
  4 |  * This file parses XML and decodes information about raw partition entry
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/partition.cpp#9 $
 16 | $DateTime: 2015/04/30 15:10:13 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 10/10/11   pgw     Fix up compiler warning
 21 | 05/18/11   pgw     Added support for CRC calculations for GPT tweaked partition parsing
 22 | 03/21/11   pgw     Initial version.
 23 | =============================================================================*/
 24 | 
 25 | #include "stdio.h"
 26 | 
 27 | #include "partition.h"
 28 | #include "protocol.h"
 29 | #include "sparse.h"
 30 | 
 31 | #include "sysdeps.h"
 32 | #include <stdlib.h>
 33 | #include <ctype.h>
 34 | #if 0
 35 | // Note currently just replace in place and fill in spaces
 36 | char *StringSetValue(char *key, char *keyName, char *value)
 37 | {
 38 |   char *sptr = strstr(key, keyName);
 39 |   if( sptr == NULL) return key;
 40 | 
 41 |   sptr = strstr(sptr,"\"");
 42 |   if( sptr == NULL) return key;
 43 | 
 44 |   // Loop through and replace with actual size;
 45 |   for(sptr++;;) {
 46 |     char tmp = *value++;
 47 |     if( *sptr == '"') break;
 48 |     if( tmp == 0 ) {
 49 |       *sptr++ = '"';
 50 |       for(;*sptr!='"';sptr++) {
 51 |         *sptr = ' ';
 52 |       }
 53 |       *sptr = ' ';
 54 |       break;
 55 |     }
 56 |     *sptr++ = tmp;
 57 |   }
 58 |   return key;
 59 | }
 60 | 
 61 | char *StringReplace(char *inp, const char *find, const char *rep)
 62 | {
 63 |   char tmpstr[MAX_STRING_LEN];
 64 |   int max_len = MAX_STRING_LEN;
 65 |   char *tptr = tmpstr;
 66 |   char *sptr = strstr(inp, find);
 67 | 
 68 |   if( sptr != NULL ) {
 69 |     // Copy part of string before the value to replace
 70 |     strncpy(tptr,inp,(sptr-inp));
 71 |     max_len -= (sptr-inp);
 72 |     tptr += (sptr-inp);
 73 |     sptr += strlen(find);
 74 |     // Copy the replace value
 75 |     strncpy(tptr,rep,strlen(rep));
 76 |     max_len -= strlen(rep);
 77 |     tptr += strlen(rep);
 78 | 
 79 |     // Copy the rest of the string
 80 |     strncpy(tptr,sptr,strlen(sptr)+1);
 81 | 
 82 |     // Copy new temp string back into original
 83 |     strcpy(inp,tmpstr);
 84 |   }
 85 | 
 86 |   return inp;
 87 | }
 88 | #endif
 89 | int Partition::Log(const char *str,...)
 90 | {
 91 |   // For now map the log to dump output to console
 92 |   if (bVerbose) {
 93 |       va_list ap;
 94 |       va_start(ap,str);
 95 |       vprintf(str,ap);
 96 |       va_end(ap);
 97 |   }
 98 |   return 0;
 99 | }
100 | 
101 | void Partition::EnableVerbose()
102 | {
103 |   bVerbose = true;
104 | }
105 | 
106 | 
107 | int Partition::Reflect(int data, int len)
108 | {
109 |     int ref = 0;
110 | 
111 |     for(int i=0; i < len; i++) {
112 |         if(data & 0x1) {
113 |             ref |= (1 << ((len - 1) - i));
114 |         }
115 |         data = (data >> 1);
116 |     }
117 | 
118 |    return ref;
119 | }
120 | 
121 | unsigned int Partition::CalcCRC32(unsigned char *buffer, int len)
122 | {
123 |    int k = 8;                   // length of unit (i.e. byte)
124 |    int MSB = 0;
125 |    int gx = 0x04C11DB7;         // IEEE 32bit polynomial
126 |    int regs = 0xFFFFFFFF;       // init to all ones
127 |    int regsMask = 0xFFFFFFFF;   // ensure only 32 bit answer
128 |    int regsMSB = 0;
129 | 
130 |    for( int i=0; i < len; i++) {
131 |      unsigned char DataByte = buffer[i];
132 |      DataByte = (unsigned char)Reflect(DataByte,8);
133 |      for(int j=0; j < k; j++) {
134 |        MSB = DataByte >> (k-1);  // get MSB
135 |        MSB &= 1;                 // ensure just 1 bit
136 |        regsMSB = (regs>>31) & 1; // MSB of regs
137 |        regs = regs<<1;           // shift regs for CRC-CCITT
138 |        if(regsMSB ^ MSB) {       // MSB is a 1
139 |          regs = regs ^ gx;       // XOR with generator poly
140 |        }
141 |        regs = regs & regsMask;   // Mask off excess upper bits
142 |        DataByte <<= 1;           // get to next bit
143 |      }
144 |    }
145 | 
146 |    regs = regs & regsMask;       // Mask off excess upper bits
147 |    return Reflect(regs,32) ^ 0xFFFFFFFF;
148 | }
149 | #if 0
150 | int Partition::ParseXMLString(char *line, const char *key, char *value)
151 | {
152 |   char *eptr;
153 |   char *sptr = strstr(line,key);
154 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
155 |   sptr = strchr(sptr, '"');
156 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
157 |   sptr++;
158 |   eptr = strchr(sptr, '"');
159 |   if( eptr == NULL) return ERROR_INVALID_DATA;
160 |   // Copy the value between the quotes to output string
161 |   strncpy(value,sptr,eptr-sptr);
162 |   value[eptr-sptr] = 0;
163 |   return 0;
164 | }
165 | #endif
166 | int Partition::ParseXMLEvaluate(char *expr, __uint64_t &value, PartitionEntry *pe) const
167 | {
168 |   // Parse simple expression understands -+/*, NUM_DISK_SECTORS,CRC32(offset:length)
169 |   char disk_sectors[64];
170 |   char *sptr, *sptr1, *sptr2;
171 |   sprintf(disk_sectors, "%lu", d_sectors);
172 |   expr = StringReplace(expr,"NUM_DISK_SECTORS",disk_sectors);
173 |   value = atoll(expr);
174 | 
175 |   sptr = strstr(expr,"CRC32");
176 |   if( sptr != NULL ) {
177 |     char tmp[MAX_STRING_LEN];
178 |     sptr1 = strstr(sptr,"(") + 1;
179 |     if( sptr1 == NULL ) return EINVAL;
180 |     sptr2 = strstr(sptr1,",");
181 |     if( sptr2 == NULL ) return EINVAL;
182 |     strncpy(tmp,sptr1,(sptr2-sptr1));
183 |     tmp[sptr2-sptr1] = 0;
184 |     ParseXMLEvaluate(tmp, pe->crc_start, pe);
185 |     sptr1 = sptr2 + 1;
186 |     sptr2 = strstr(sptr1,")");
187 |     if( sptr2 == NULL ) return EINVAL;
188 |     strncpy(tmp,sptr1,(sptr2-sptr1));
189 |     tmp[sptr2-sptr1] = 0;
190 |     ParseXMLEvaluate(tmp, pe->crc_size,pe);
191 |     // Revome the CRC part set value 0
192 |     memset(sptr,' ',(sptr2-sptr+1));
193 |     value = 0;
194 |   }
195 | 
196 |   sptr = strstr(expr,"*");
197 |   if( sptr != NULL ) {
198 |     // Found * do multiplication
199 |     char val1[64];
200 |     char val2[64];
201 |     strncpy(val1,expr,(sptr-expr));
202 |     val1[sptr-expr] = 0;
203 |     strcpy(val2,sptr+1);
204 |     value = atoll(val1) * atoll(val2);
205 |   }
206 | 
207 |   sptr = strstr(expr,"/");
208 |   if( sptr != NULL ) {
209 |     // Found / do division
210 |     char val1[64];
211 |     char val2[64];
212 |     strncpy(val1,expr,(sptr-expr));
213 |     val1[sptr-expr] = 0;
214 |     strcpy(val2,sptr+1);
215 |     value = atoll(val1) / atoll(val2);
216 |   }
217 | 
218 |   sptr = strstr(expr,"-");
219 |   if( sptr != NULL ) {
220 |     // Found - do subtraction
221 |     char val1[32];
222 |     char val2[32];
223 |     strncpy(val1,expr,(sptr-expr));
224 |     val1[sptr-expr] = 0;
225 |     strcpy(val2,sptr+1);
226 |     value = atoll(val1) - atoll(val2);
227 |   }
228 |   
229 |   sptr = strstr(expr,"+");
230 |   if( sptr != NULL ) {
231 |     // Found + do addition
232 |     char val1[32];
233 |     char val2[32];
234 |     strncpy(val1,expr,(sptr-expr));
235 |     val1[sptr-expr] = 0;
236 |     strcpy(val2,sptr+1);
237 |     value = atoll(val1) + atoll(val2);
238 |   }
239 | 
240 |   return 0;
241 | }
242 | 
243 | int Partition::ParseXMLInt64(char *line, const char *key, __uint64_t &value, PartitionEntry *pe) const
244 | {
245 |   char tmp[MAX_STRING_LEN];
246 |   char *eptr;
247 |   char *sptr = strstr(line,key);
248 | 
249 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
250 |   sptr = strchr(sptr,'"');
251 | 
252 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
253 |   sptr++;
254 |   eptr = strchr(sptr, '"');
255 | 
256 |   if( eptr == NULL) return ERROR_INVALID_DATA;
257 | 
258 |   strncpy(tmp,sptr,eptr-sptr);
259 | 
260 |   tmp[eptr-sptr] = 0;
261 | 
262 |   ParseXMLEvaluate(tmp,value, pe);
263 | 
264 |   return 0;
265 | }
266 | 
267 | int Partition::ParseXMLOptions()
268 | {
269 | 
270 |   return 0;
271 | }
272 | 
273 | int Partition::ParsePathList()
274 | {
275 |   return 0;
276 | }
277 | 
278 | bool Partition::CheckEmptyLine(char *str) const
279 | {
280 |   int keylen = strlen(str);
281 |   while (isspace(*str) && (keylen > 0))
282 |   {
283 |     str++;
284 |     keylen--;
285 |   }
286 | 
287 |   return (keylen == 0);
288 | }
289 | 
290 | int Partition::ParseXMLKey(char *key, PartitionEntry *pe)
291 | {
292 |   // If line is whitepsace return CMD_NOP
293 |   if (CheckEmptyLine(key)) {
294 |     pe->eCmd = CMD_NOP;
295 |     return 0;
296 |   }
297 | 
298 |   // First of all check if this is a program, patch or zeroout line
299 |   pe->eCmd = CMD_INVALID;
300 |   if (strstr(key, "<data>") != NULL || strstr(key, "</data>") != NULL
301 |     || strstr(key, "</patches>") != NULL || strstr(key, "</data>") != NULL) {
302 |     pe->eCmd = CMD_NOP;
303 |     return 0;
304 |   } else if (strstr(key, "simlock") != NULL) {
305 |     pe->eCmd = CMD_SIMLOCK;
306 |   } else if (strstr(key, "program") != NULL) {
307 |     pe->eCmd = CMD_PROGRAM;
308 |   } else if( strstr(key,"patch") != NULL ) {
309 |     pe->eCmd = CMD_PATCH;
310 |   } else if( strstr(key,"options") != NULL ) {
311 |     pe->eCmd = CMD_OPTION;
312 |   } else if( strstr(key,"search_path") != NULL ) {
313 |     pe->eCmd = CMD_PATH;
314 |   } else if (strstr(key, "read") != NULL) {
315 |     pe->eCmd = CMD_READ;
316 |   } else if (strstr(key, "peek") != NULL) {
317 |         pe->eCmd = CMD_PEEK;
318 |         return 0;
319 |   } else {
320 |     Log("%s\n", key);
321 |     //return ERROR_INVALID_DATA;
322 |   }
323 |   Log("\n");
324 |   // Set options and search path
325 |   if( pe->eCmd == CMD_OPTION ) {
326 |     ParseXMLOptions();
327 |   } else if( pe->eCmd == CMD_PATH ) {
328 |     ParsePathList();
329 |   }
330 | 
331 |   // All commands need start_sector, physical_partition_number and num_partition_sectors
332 |   if( ParseXMLInt64(key,"start_sector", pe->start_sector, pe) != 0 ) {
333 |     Log("start_sector missing in XML line:%s\n",key);
334 |     return ERROR_INVALID_DATA;
335 |   } else {
336 |     Log("start_sector: %d ",  pe->start_sector);
337 |   }
338 | 	
339 |   __uint64_t partNum;
340 |   if( ParseXMLInt64(key,"physical_partition_number", partNum, pe) != 0 ) {
341 |     Log("physical_partition_number missing in XML line\n");
342 |     return ERROR_INVALID_DATA;
343 |   } else {
344 |     pe->physical_partition_number = (uint8_t)partNum;
345 |     Log("physical_partition_number: %i ", pe->physical_partition_number);
346 |   }
347 | 
348 |   if( ParseXMLInt64(key,"num_partition_sectors", pe->num_sectors, pe) == 0 ) {
349 |     Log("num_partition_sectors: %d ", pe->num_sectors);
350 |     // If zero then write out all sectors for size of file
351 |   } else {
352 |     pe->num_sectors = (__uint64_t )-1;
353 |   }
354 | 
355 |   if( pe->eCmd == CMD_PATCH || pe->eCmd == CMD_PROGRAM || pe->eCmd == CMD_READ || pe->eCmd == CMD_SIMLOCK) {
356 |     // Both program and patch need a filename to be valid
357 |     if( ParseXMLString(key,"filename", pe->filename) != 0 ) {
358 |       Log("filename missing in XML line\n");
359 | 		  return ERROR_INVALID_DATA;
360 |     } else {
361 |       // Only program if filename is specified
362 |       if( strlen(pe->filename) == 0 ) {
363 |         pe->eCmd = CMD_NOP;
364 |         return 0;
365 |       }
366 |       Log("filename: %s ", pe->filename);
367 |     }
368 | 
369 | 
370 |     // File sector offset is optional for both these otherwise use default
371 |     if( ParseXMLInt64(key,"file_sector_offset", pe->offset, pe) == 0 ) {
372 | 			Log("file_sector_offset: %d ", pe->offset);
373 |     } else {
374 |       pe->offset = (__uint64_t )-1;
375 |     }
376 | 	
377 |     // The following entries should only be used in patching
378 |     if( pe->eCmd == CMD_PATCH ) {
379 |       // Get the value parameter
380 | 	  pe->crc_start = (uint64_t) -1;
381 |       pe->crc_size = (uint64_t) -1;
382 |       if( ParseXMLInt64(key,"value", pe->patch_value, pe) == 0 ) {
383 | 	      Log("value: %d ", pe->patch_value);
384 | 	    } else {
385 |         Log("value missing in patch command\n");
386 |         return ERROR_INVALID_DATA;
387 |       }
388 |       Log("crc_size: %i ", (int)pe->crc_size);
389 | 
390 |       // get byte offset for patch value to be written
391 |       if( ParseXMLInt64(key,"byte_offset", pe->patch_offset, pe) == 0 ) {
392 | 	      Log("patch_offset: %d ", pe->patch_offset);
393 | 	    } else {
394 |         Log("byte_offset missing in patch command\n");
395 |         return ERROR_INVALID_DATA;
396 |       }
397 | 
398 |       // Get the size of the patch in bytes
399 |       if( ParseXMLInt64(key,"size_in_bytes", pe->patch_size, pe) == 0 ) {
400 | 	     Log("patch_size: %d ", pe->patch_size);
401 | 	    } else {
402 |         Log("size_in_bytes missing in patch command\n");
403 |         return ERROR_INVALID_DATA;
404 |       }
405 | 
406 |     } // end of CMD_PATCH
407 |   } // end of CMD_PROGRAM || CMD_PATCH
408 |  
409 |   return 0;
410 | }
411 | 
412 | 
413 | 
414 | int Partition::ProgramPartitionEntry(Protocol *proto, PartitionEntry pe, char *key)
415 | {
416 |   int hRead = -1;
417 |   bool bSparse = false;
418 |   int status = 0;
419 | 
420 |   if (proto == NULL) {
421 |     printf("Can't write to disk no protocol passed in.\n");
422 |     return EINVAL;
423 |   }
424 | 
425 |   if (strcmp(pe.filename, "ZERO") == 0) {
426 |     printf("Zeroing out area\n");
427 |   }
428 |   else {
429 |     // First check if the file is a sparse image then program via sparse
430 |     SparseImage sparse;
431 |     char imgfname[MAX_PATH];
432 |     const char* ptr = xmlFilename ? rindex(xmlFilename,'/'): NULL;
433 |     if (ptr != NULL) {
434 |        if (imgDir != NULL) {
435 |            sprintf(imgfname, "%s/%s", imgDir, pe.filename);
436 |        } else {
437 |            strncpy(imgfname, xmlFilename, ptr - xmlFilename);
438 |            sprintf(&imgfname[ptr - xmlFilename], "/%s", pe.filename);
439 |        }
440 |     } else {
441 |        if (imgDir != NULL) {
442 |            sprintf(imgfname, "%s/%s", imgDir, pe.filename);
443 |        } else {
444 |            strcpy(imgfname, pe.filename);
445 |        }
446 |     }
447 | 
448 |     printf("\nSparse image:%s\n", imgfname);
449 |     status = sparse.PreLoadImage(imgfname);
450 |     if (status == 0) {
451 |       bSparse = true;
452 |       printf("detected \n-- loading sparse...\n");
453 |       status = sparse.ProgramImage(proto, pe.start_sector*proto->GetDiskSectorSize());
454 |     }
455 |     else
456 |     {
457 |       printf("not detected \n-- loading binary...\n");
458 |       // Open the file that we are supposed to dump
459 |       status = 0;
460 |       hRead = emmcdl_open(imgfname,O_RDONLY);
461 |       if (hRead < 0) {
462 |         status = errno;
463 |       }
464 |       else {
465 |         // Update the number of sectors based on real file size, rounded to next sector offset
466 | 
467 |         struct stat      my_stat;
468 |         int ret = fstat(hRead, &my_stat);
469 |         // Make sure filesize is valid
470 |         if(ret)
471 |                 return ret;
472 |         int64_t dwTotalSize = my_stat.st_size;
473 |         dwTotalSize = (dwTotalSize + proto->GetDiskSectorSize() - 1) & (int64_t)~(proto->GetDiskSectorSize() - 1);
474 |         dwTotalSize = dwTotalSize / proto->GetDiskSectorSize();
475 |         if (dwTotalSize <= (int64_t)pe.num_sectors) {
476 |           pe.num_sectors = dwTotalSize;
477 |         }
478 |         else {
479 |           printf("\nFileSize is > partition size, truncating file\n");
480 |         }
481 |         status = 0;
482 |       }
483 |     }
484 |   }
485 | 
486 |   if (status == 0 && !bSparse) {
487 |     // Fast copy from input file to output disk
488 |     Log("In offset: %lu out offset: %lu sectors: %lu\n", pe.offset, pe.start_sector, pe.num_sectors);
489 |     status = proto->FastCopy(hRead, pe.offset, proto->GetDiskHandle(),  pe.start_sector, pe.num_sectors,pe.physical_partition_number);
490 |   }
491 |   if (hRead > 0)
492 |     emmcdl_close(hRead);
493 |   return status;
494 | }
495 | 
496 | int Partition::ProgramImage(Protocol *proto)
497 | {
498 |   int status = 0;
499 | 
500 |   PartitionEntry pe;
501 |   char keyName[MAX_STRING_LEN];
502 |   char *key;
503 |   while (GetNextXMLKey(keyName, &key) == 0) {
504 |     // parse the XML key if we don't understand it then continue
505 |     if (ParseXMLKey(key, &pe) != 0) {
506 |       // If we don't understand the command just try sending it otherwise ignore command
507 |       if (pe.eCmd == CMD_INVALID) {
508 |         status = proto->ProgramRawCommand(key);
509 |       }
510 |     }
511 |     else if (pe.eCmd == CMD_PROGRAM) {
512 |       status = ProgramPartitionEntry(proto, pe, key);
513 |     }
514 |     else if (pe.eCmd == CMD_SIMLOCK) {
515 |       status = SimlockPartitionEntry(proto, pe, key);
516 |     }
517 |     else if (pe.eCmd == CMD_PATCH) {
518 |       // Only patch disk entries
519 |       if (strcmp(pe.filename, "DISK") == 0) {
520 |         status = proto->ProgramPatchEntry(pe, key);
521 |       }
522 |     }
523 |     else if (pe.eCmd == CMD_READ) {
524 |       status = proto->DumpDiskContents(pe.start_sector, pe.num_sectors, pe.filename, pe.physical_partition_number, NULL);
525 |     }
526 |     else if (pe.eCmd == CMD_ZEROOUT) {
527 |       status = proto->WipeDiskContents(pe.start_sector, pe.num_sectors, NULL);
528 |     }
529 | 
530 |     if (status != 0) {
531 |       break;
532 |     }
533 |   }
534 | 
535 |   return status;
536 | }
537 | 
538 | int Partition::SimlockPartitionEntry(Protocol *proto, PartitionEntry pe, char *key)
539 | {
540 |   int hRead = -1;
541 |   int status = 0;
542 | 
543 |   if (proto == NULL) {
544 |     printf("Can't write to disk no protocol passed in.\n");
545 |     return EINVAL;
546 |   }
547 | 
548 |   char imgfname[MAX_PATH];
549 |   const char* ptr = rindex(xmlFilename,'/');
550 |   if (ptr != NULL) {
551 |     if (imgDir != NULL) {
552 |       sprintf(imgfname, "%s/%s", imgDir, pe.filename);
553 |     } else {
554 |       strncpy(imgfname, xmlFilename, ptr - xmlFilename);
555 |       sprintf(&imgfname[ptr - xmlFilename], "/%s", pe.filename);
556 |     }
557 |   } else {
558 |     if (imgDir != NULL) {
559 |       sprintf(imgfname, "%s/%s", imgDir, pe.filename);
560 |     } else {
561 |       strcpy(imgfname, pe.filename);
562 |     }
563 |   }
564 | 
565 |   printf("\n-- loading binary...%s\n", imgfname);
566 |   // Open the file that we are supposed to dump
567 |   struct stat      my_stat;
568 |   status = 0;
569 |   hRead = emmcdl_open(imgfname,O_RDONLY);
570 |   if (hRead < 0) {
571 |     printf("-- skip flash simlock\n");
572 |     return 0;//status = errno;
573 |   }
574 |   else {
575 |     // Update the number of sectors based on real file size, rounded to next sector offset
576 | 
577 |     int ret = fstat(hRead, &my_stat);
578 |     // Make sure filesize is valid
579 |     if(ret)
580 |       return ret;
581 |     int64_t dwTotalSize = my_stat.st_size;
582 |     dwTotalSize = (dwTotalSize + proto->GetDiskSectorSize() - 1) & (int64_t)~(proto->GetDiskSectorSize() - 1);
583 |     dwTotalSize = dwTotalSize / proto->GetDiskSectorSize();
584 |     if (dwTotalSize <= (int64_t)pe.num_sectors) {
585 |       pe.num_sectors = dwTotalSize;
586 |     }
587 |     else {
588 |       printf("\nFileSize is > partition size, truncating file\n");
589 |     }
590 |     status = 0;
591 |   }
592 | 
593 |   if (status == 0 ) {
594 |     // Fast copy from input file to output disk
595 |     Log("In offset: %lu out offset: %lu sectors: %lu\n", pe.offset, pe.start_sector, pe.num_sectors);
596 |     unsigned char *bpDataBuf = (unsigned char *)malloc(my_stat.st_size);
597 |     if (!bpDataBuf) return errno;
598 |     status = emmcdl_read(hRead, bpDataBuf, my_stat.st_size);
599 |     uint32_t dwBytesOut = pe.num_sectors;
600 |     status = proto->WriteSimlockData(bpDataBuf, pe.start_sector, my_stat.st_size, &dwBytesOut,pe.physical_partition_number);
601 |     emmcdl_close(hRead);
602 |     free(bpDataBuf);
603 |   }
604 |   return status;
605 | }
606 | 
607 | int Partition::PreLoadImage(char *fname, const char *imgdir)
608 | {
609 | 	return LoadXML(fname, imgdir);
610 | }
611 | 
612 | 
613 | int Partition::GetNextXMLKey(char *keyName, char **key)
614 | {
615 |   bool bRecordKey = true;
616 |   // Find < and make sure it's not a comment
617 |   for(;(keyStart < xmlEnd) && bRecordKey; keyStart++) {
618 |     // Check for starting of a comment
619 |     if( *keyStart == '<' && *(keyStart+1) == '!' && *(keyStart+2) == '-' && *(keyStart+3)== '-' ) {
620 |       // This is a comment search for the closing -->
621 |       for(;keyStart < xmlEnd;keyStart++) {
622 |         if( *keyStart == '-' && *(keyStart+1) == '-' && *(keyStart+2) == '>') break;
623 |       }
624 |     } else if( *keyStart == '<' ) {
625 |       // suck in the keyname up to MAX_STRING_LEN
626 |       // go past until we hit alpha numeric value
627 |       for(keyEnd = keyStart; !isalnum(*keyEnd); keyEnd++);
628 |       for(;keyEnd < xmlEnd; keyEnd++) {
629 |         if( *keyEnd == '>' && *(keyEnd-1) == '/') {
630 |           // TODO:FIXME handle multiple embedded parameters
631 |           break;
632 |         } else if( bRecordKey ) {
633 |           if( isalnum(*keyEnd) ) *keyName++ = *keyEnd;
634 |           else bRecordKey = false;
635 |           *keyName = 0;
636 |         }
637 |       }
638 |     }
639 |   }
640 | 
641 |   // Terminate this string for searches on it
642 |   if( keyStart < xmlEnd ) {
643 |     *keyEnd = 0;
644 |     *key = keyStart-1;
645 |     return 0;
646 |   }
647 |   return EINVAL;
648 | }
649 | 


--------------------------------------------------------------------------------
/src/protocol.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 | * protocol.cpp
  3 | *
  4 | * This class can perform emergency flashing given the transport layer
  5 | *
  6 | * Copyright (c) 2007-2015
  7 | * Qualcomm Technologies Incorporated.
  8 | * All Rights Reserved.
  9 | * Qualcomm Confidential and Proprietary
 10 | *
 11 | *****************************************************************************/
 12 | /*=============================================================================
 13 | Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/protocol.cpp#4 $
 16 | $DateTime: 2015/05/07 21:41:17 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 12/09/14   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #include "protocol.h"
 24 | #include <stdlib.h>
 25 | #include <stdio.h>
 26 | #include <iconv.h>
 27 | #include <wchar.h>
 28 | 
 29 | Protocol::Protocol(void)
 30 | {
 31 |   //hDisk = -1;
 32 |   //modify for 0 is output to uart
 33 |   hDisk = 0;
 34 |   buffer1 = buffer2 = NULL;
 35 |   gpt_entries = NULL;
 36 |   bVerbose = false;
 37 | 
 38 |   disk_size = 0;
 39 |   // Set default sector size
 40 |   DISK_SECTOR_SIZE = 512;
 41 | 
 42 |   bufAlloc1 = (unsigned char *)malloc(MAX_TRANSFER_SIZE + 0x200);
 43 |   if (bufAlloc1) buffer1 = (unsigned char *)(((uintptr_t)bufAlloc1 + 0x200) & ~0x1ff);
 44 |   bufAlloc2 = (unsigned char *)malloc(MAX_TRANSFER_SIZE + 0x200);
 45 |   if (bufAlloc2) buffer2 = (unsigned char *)(((uintptr_t)bufAlloc2 + 0x200) & ~0x1ff);
 46 | }
 47 | 
 48 | Protocol::~Protocol(void)
 49 | {
 50 |   // Free any remaining buffers we may have
 51 |   if (bufAlloc1) free(bufAlloc1);
 52 |   if (bufAlloc2) free(bufAlloc2);
 53 |   if (gpt_entries) free(gpt_entries);
 54 | }
 55 | 
 56 | void Protocol::Log(const char *str, ...)
 57 | {
 58 |   // For now map the log to dump output to console
 59 |   if (bVerbose) {
 60 |     va_list ap;
 61 |     va_start(ap, str);
 62 |     vprintf(str, ap);
 63 |     va_end(ap);
 64 |     printf("\n");
 65 |   }
 66 | }
 67 | 
 68 | void Protocol::EnableVerbose()
 69 | {
 70 |   bVerbose = true;
 71 | }
 72 | 
 73 | int Protocol::LoadPartitionInfo(char *szPartName, PartitionEntry *pEntry)
 74 | {
 75 |   int status = 0;
 76 | 
 77 |   // First of all read in the GPT information and see if it was successful
 78 |   status = ReadGPT(bVerbose);
 79 |   if (status == 0) {
 80 |     // Check to make sure partition name is found
 81 |     status = ENOENT;
 82 |     memset(pEntry, 0, sizeof(PartitionEntry));
 83 |     iconv_t conv = iconv_open("UTF-8", "UTF-16");
 84 |     for (int i = 0; i < 128; i++) {
 85 |       char part_name[36];
 86 |       char* src = gpt_entries[i].part_name;
 87 |       size_t srclen = 72;
 88 |       char* dst = part_name;
 89 |       size_t dstlen = 36;
 90 |       iconv(conv, &src, &srclen, &dst, &dstlen);
 91 |       if (strcmp(szPartName, part_name) == 0) {
 92 |         pEntry->start_sector = gpt_entries[i].first_lba;
 93 |         pEntry->num_sectors = gpt_entries[i].last_lba - gpt_entries[i].first_lba + 1;
 94 |         pEntry->physical_partition_number = 0;
 95 |         status = 0;
 96 |         break;
 97 |       }
 98 |     }
 99 |     iconv_close(conv);
100 |   }
101 |   return status;
102 | }
103 | 
104 | int Protocol::WriteGPT(char *szPartName, char *szBinFile)
105 | {
106 |   int status = 0;
107 |   PartitionEntry partEntry;
108 | 
109 |   char *cmd_pkt = (char *)malloc(MAX_XML_LEN*sizeof(char));
110 |   if (cmd_pkt == NULL) {
111 |     return ENOMEM;
112 |   }
113 | 
114 |   if (LoadPartitionInfo(szPartName, &partEntry) == 0){
115 |     printf("Flash %s bin to %s partition at start sector: %lu for sectors: %lu\n",
116 |                           szBinFile, szPartName, partEntry.start_sector, partEntry.num_sectors);
117 |     Partition partition;
118 |     strcpy(partEntry.filename, szBinFile);
119 |     partEntry.eCmd = CMD_PROGRAM;
120 |     sprintf(cmd_pkt, "<program SECTOR_SIZE_IN_BYTES=\"%i\" num_partition_sectors=\"%li\" physical_partition_number=\"0\" start_sector=\"%li\"/",
121 |                        DISK_SECTOR_SIZE, partEntry.num_sectors, partEntry.start_sector);
122 |     status = partition.ProgramPartitionEntry(this, partEntry, cmd_pkt);
123 |   }
124 | 
125 |   // Free our memory for command packet again
126 |   free(cmd_pkt);
127 |   return status;
128 | }
129 | 
130 | int Protocol::ReadGPT(bool debug)
131 | {
132 |   int status = 0;
133 |   uint32_t bytesRead;
134 |   gpt_header_t gpt_hdr;
135 |   gpt_entries = (gpt_entry_t*)malloc(sizeof(gpt_entry_t)* 128);
136 | 
137 |   if (gpt_entries == NULL) {
138 |     return ENOMEM;
139 |   }
140 | 
141 |   status = ReadData((unsigned char *)&gpt_hdr, DISK_SECTOR_SIZE, DISK_SECTOR_SIZE, &bytesRead,0);
142 |   
143 |   if ((status == 0) && (memcmp("EFI PART", gpt_hdr.signature, 8) == 0)) {
144 |     if (debug) printf("\nSuccessfully found GPT partition\n");
145 |     status = ReadData((unsigned char *)gpt_entries, 2*DISK_SECTOR_SIZE, 32*DISK_SECTOR_SIZE, &bytesRead,0);
146 |     if ((status == 0) && debug) {
147 |       iconv_t conv = iconv_open("UTF-8", "UTF-16");
148 |       for (int i = 0; (i < gpt_hdr.num_entries) && (i < 128); i++) {
149 |         if (gpt_entries[i].first_lba > 0) {
150 |           char part_name[36];
151 |           char* src = gpt_entries[i].part_name;
152 | 	  size_t srclen = 72;
153 |           char* dst = part_name;
154 | 	  size_t dstlen = 36;
155 | 	  iconv(conv, &src, &srclen, &dst, &dstlen);
156 |           printf("%2i. Partition Name: %-36s Start LBA: 0x%.8lx Size in LBA: 0x%.8lx\n",
157 |                i + 1, part_name, gpt_entries[i].first_lba, gpt_entries[i].last_lba - gpt_entries[i].first_lba + 1);
158 |         }
159 |       }
160 |       iconv_close(conv);
161 |     }
162 |   }
163 |   else {
164 |     if (debug) Log("\nNo valid GPT found");
165 |     free(gpt_entries);
166 |     gpt_entries = NULL;
167 |     status = ERROR_INVALID_DATA;
168 |   }
169 | 
170 |   return status;
171 | }
172 | 
173 | 
174 | __uint64_t Protocol::GetNumDiskSectors()
175 | {
176 |   return disk_size / DISK_SECTOR_SIZE;
177 | 
178 | }
179 | 
180 | void Protocol::SetDiskSectorSize(int size)
181 | {
182 |   DISK_SECTOR_SIZE = size;
183 | }
184 | 
185 | int Protocol::GetDiskSectorSize(void)
186 | {
187 |   return DISK_SECTOR_SIZE;
188 | }
189 | 
190 | int Protocol::GetDiskHandle(void)
191 | {
192 |   return hDisk;
193 | }
194 | 
195 | int Protocol::WriteSimlockData(unsigned char *writeBuffer, int64_t writeOffset, uint32_t writeBytes, uint32_t *bytesWritten, uint8_t partNum) {
196 |   return -1;
197 | }
198 | 
199 | int Protocol::DumpDiskContents(__uint64_t start_sector, __uint64_t num_sectors, char *szOutFile, uint8_t partNum, char *szPartName)
200 | {
201 |   int status = 0;
202 | 
203 |   // If there is a partition name provided load the info for the partition name
204 |   if (szPartName != NULL) {
205 |     PartitionEntry pe;
206 |     if (LoadPartitionInfo(szPartName, &pe) == 0) {
207 |       start_sector = pe.start_sector;
208 |       num_sectors = pe.num_sectors;
209 |     }
210 |     else {
211 |       printf("%s partition not found\n", szPartName);
212 |       return ENOENT;
213 |     }
214 | 
215 |   }
216 | 
217 |   // Create the output file and dump contents at offset for num blocks
218 |   int hOutFile = emmcdl_creat(szOutFile,O_CREAT | S_IRUSR | S_IWUSR);
219 | 
220 |   // Make sure we were able to successfully create file handle
221 |   if (hOutFile < 0) {
222 |     return errno;
223 |   }
224 | 
225 |   printf("Dumping at start sector: %lu for sectors: %lu to file: %s\n", start_sector, num_sectors, szOutFile);
226 |   status = FastCopy(hDisk, start_sector, hOutFile, 0, num_sectors, partNum);
227 |   emmcdl_close(hOutFile);
228 | 
229 |   return status;
230 | }
231 | 
232 | int Protocol::WipeDiskContents(__uint64_t start_sector, __uint64_t num_sectors, char *szPartName)
233 | {
234 |   PartitionEntry pe;
235 |   char *cmd_pkt;
236 |   int status = 0;
237 | 
238 |   // If there is a partition name provided load the info for the partition name
239 |   if (szPartName != NULL) {
240 |     PartitionEntry pe;
241 |     if (LoadPartitionInfo(szPartName, &pe) == 0) {
242 |       start_sector = pe.start_sector;
243 |       num_sectors = pe.num_sectors;
244 |     }
245 |     else {
246 |       return ENOENT;
247 |     }
248 | 
249 |   }
250 | 
251 |   printf("Wipe the %s partition at start sector: %lu for sectors: %lu\n", szPartName, start_sector, num_sectors);
252 |   cmd_pkt = (char *)malloc(MAX_XML_LEN*sizeof(char));
253 |   if (cmd_pkt == NULL) {
254 |     return ENOMEM;
255 |   }
256 | 
257 |   memset(&pe, 0, sizeof(pe));
258 |   strcpy(pe.filename, "ZERO");
259 |   pe.start_sector = start_sector;
260 |   pe.num_sectors = num_sectors;
261 |   pe.eCmd = CMD_ERASE;
262 |   pe.physical_partition_number = 0;  // By default the wipe disk only works on physical sector 0
263 |   sprintf(cmd_pkt, "<program SECTOR_SIZE_IN_BYTES=\"%i\" num_partition_sectors=\"%li\" physical_partition_number=\"0\" start_sector=\"%li\"/",
264 |                     DISK_SECTOR_SIZE, num_sectors, start_sector);
265 |   Partition partition;
266 |   status = partition.ProgramPartitionEntry(this,pe, cmd_pkt);
267 | 
268 |   free(cmd_pkt); // Free our buffer
269 |   return status;
270 | }
271 | 
272 | 


--------------------------------------------------------------------------------
/src/sahara.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * sahara.cpp
  3 |  *
  4 |  * This class implements sahara protocol support
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  ****************************************************************************
 12 | =============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/sahara.cpp#9 $
 16 | $DateTime: 2015/04/29 17:06:00 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 30/10/12   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #include "sahara.h"
 24 | #define ERROR_INVALID_DATA  (-10)
 25 | #define ERROR_WRITE_FAULT (-19)
 26 | 
 27 | Sahara::Sahara(SerialPort *port, int hLogFile)
 28 | {
 29 |   sport = port;
 30 |   hLog = hLogFile;
 31 | }
 32 | 
 33 | void Sahara::Log(const char *str,...)
 34 | {
 35 |   // For now map the log to dump output to console
 36 |   va_list ap;
 37 |   va_start(ap,str);
 38 |   vprintf(str,ap);
 39 |   va_end(ap);
 40 | }
 41 | 
 42 | int Sahara::DeviceReset()
 43 | {
 44 |   execute_cmd_t exe_cmd;
 45 |   exe_cmd.cmd = SAHARA_RESET_REQ;
 46 |   exe_cmd.len = 0x8;
 47 |   return sport->Write((unsigned char *)&exe_cmd, sizeof(exe_cmd));
 48 | }
 49 | 
 50 | int Sahara::ReadData(int cmd, unsigned char *buf, int len)
 51 | {
 52 |   int status;
 53 |   uint32_t bytesRead; 
 54 | 
 55 |   execute_cmd_t exe_cmd;
 56 |   exe_cmd.cmd = SAHARA_EXECUTE_REQ;
 57 |   exe_cmd.len = sizeof(exe_cmd);
 58 |   exe_cmd.client_cmd = cmd;
 59 | 
 60 |   status = sport->Write((unsigned char *)&exe_cmd, sizeof(exe_cmd));
 61 |   if (status != 0) {
 62 |     return -1;
 63 |   }
 64 | 
 65 |   execute_rsp_t exe_rsp;
 66 |   bytesRead = sizeof(exe_rsp);
 67 |   status = sport->Read((unsigned char*)&exe_rsp, &bytesRead);
 68 |   if (exe_rsp.data_len > 0 && bytesRead == sizeof(exe_rsp)) {
 69 |     exe_cmd.cmd = SAHARA_EXECUTE_DATA;
 70 |     exe_cmd.len = sizeof(exe_cmd);
 71 |     exe_cmd.client_cmd = cmd;
 72 |     status = sport->Write((unsigned char *)&exe_cmd, sizeof(exe_cmd));
 73 |     if (status != 0) {
 74 |       return -1;
 75 |     }
 76 |     bytesRead = len;
 77 |     status = sport->Read((unsigned char *)buf, &bytesRead);
 78 |     return bytesRead;
 79 |   }
 80 | 
 81 |   return -ERROR_INVALID_DATA;
 82 | }
 83 | 
 84 | int Sahara::DumpDeviceInfo(pbl_info_t *pbl_info)
 85 | {
 86 |   uint32_t dataBuf[64];
 87 |   int status = 0;
 88 | 
 89 |   // Connect to the device in command mode
 90 |   status = ConnectToDevice(true, SAHARA_MODE_COMMAND);
 91 |   if( status != 0) {
 92 |     return status;
 93 |   }
 94 | 
 95 |   // Make sure we get command ready back
 96 |   execute_rsp_t cmd_rdy;
 97 |   uint32_t bytesRead = sizeof(cmd_rdy);
 98 | 
 99 |   status = sport->Read((unsigned char *)&cmd_rdy, &bytesRead);
100 |   if (status != 0 || bytesRead == 0 ) {
101 |     Log("No response from device after switch mode command\n");
102 |     return EINVAL;
103 |   } else if (cmd_rdy.cmd != SAHARA_CMD_READY) {
104 |     Log("Unexpected response for command mode %i\n", cmd_rdy.cmd);
105 |     return EINVAL;
106 |   }
107 | 
108 |   // Dump out all the device information
109 |   status = ReadData(SAHARA_EXEC_CMD_SERIAL_NUM_READ, (unsigned char*)dataBuf, sizeof(dataBuf));
110 |   if ( status > 0 && status < sizeof(dataBuf)) {
111 |     pbl_info->serial = dataBuf[0];
112 |   }
113 |   status = ReadData(SAHARA_EXEC_CMD_MSM_HW_ID_READ, (unsigned char*)dataBuf, sizeof(dataBuf));
114 |   if (status > 0 && status < sizeof(dataBuf)) {
115 |     pbl_info->msm_id = dataBuf[1];
116 |   }
117 |   status = ReadData(SAHARA_EXEC_CMD_OEM_PK_HASH_READ, (unsigned char*)dataBuf, sizeof(dataBuf));
118 |   if (status > 0 && status < sizeof(dataBuf)) {
119 |     memcpy(pbl_info->pk_hash, dataBuf, sizeof(pbl_info->pk_hash));
120 |   }
121 |   status = ReadData(SAHARA_EXEC_CMD_GET_SOFTWARE_VERSION_SBL, (unsigned char*)dataBuf, sizeof(dataBuf));
122 |   if (status > 0 && status < sizeof(dataBuf)) {
123 |     pbl_info->pbl_sw = dataBuf[0];
124 |   }
125 |   
126 |   ModeSwitch(SAHARA_MODE_COMMAND, false);
127 |   return 0;
128 | }
129 | 
130 | int Sahara::ModeSwitch(int mode, bool rsp)
131 | {
132 |   // Finally at the end send switch mode to put us back in original EDL state
133 |   int status = 0;
134 |   execute_cmd_t cmd_switch_mode;
135 |   unsigned char read_data_req[256];
136 |   uint32_t bytesRead = sizeof(read_data_req);
137 | 
138 |   cmd_switch_mode.cmd = SAHARA_SWITCH_MODE;
139 |   cmd_switch_mode.len = sizeof(cmd_switch_mode);
140 |   cmd_switch_mode.client_cmd = mode;
141 |   status = sport->Write((unsigned char*)&cmd_switch_mode, sizeof(cmd_switch_mode));
142 |   
143 |   // Read the response to switch mode if the device responds
144 |   if (rsp) {
145 |       status = sport->Read((unsigned char *)&read_data_req, &bytesRead);
146 |   }
147 |   //sport->UnRead((unsigned char *)&read_data_req, &bytesRead);
148 |   return status;
149 | }
150 | 
151 | int Sahara::LoadFlashProg(char *szFlashPrg)
152 | {
153 |   read_data_t read_data_req = {0};
154 |   read_data_64_t read_data64_req = {0};
155 |   cmd_hdr_t read_cmd_hdr = { 0 };
156 |   image_end_t read_img_end = { 0 };
157 |   uint32_t status = 0;
158 |   uint32_t bytesRead = sizeof(read_data64_req);
159 |   uint32_t totalBytes = 0, read_data_offset = 0, read_data_len = 0;
160 |   unsigned char dataBuf[8192];
161 | 
162 |   int hFlashPrg = emmcdl_open( szFlashPrg, O_RDONLY);
163 |   if( hFlashPrg < 0 ) {
164 |     return ENOENT;
165 |   }
166 | 
167 |   Log("Successfully open flash programmer to write: %s\n",szFlashPrg);
168 | 
169 |   for(;;) {
170 | 
171 |     memset(&read_cmd_hdr,0,sizeof(read_cmd_hdr));
172 |     bytesRead = sizeof(read_cmd_hdr);
173 |     status = sport->Read((unsigned char *)&read_cmd_hdr,&bytesRead);
174 | 
175 |     // Check if it is a 32-bit or 64-bit read
176 |     if (read_cmd_hdr.cmd == SAHARA_64BIT_MEMORY_READ_DATA)
177 |     {
178 |       memset(&read_data64_req, 0, sizeof(read_data64_req));
179 |       bytesRead = sizeof(read_data64_req);
180 |       status = sport->Read((unsigned char *)&read_data64_req, &bytesRead);
181 |       read_data_offset = (uint32_t)read_data64_req.data_offset;
182 |       read_data_len = (uint32_t)read_data64_req.data_len;
183 |     }
184 |     else if (read_cmd_hdr.cmd == SAHARA_READ_DATA)
185 |     {
186 |       memset(&read_data_req, 0, sizeof(read_data_req));
187 |       bytesRead = sizeof(read_data_req);
188 |       status = sport->Read((unsigned char *)&read_data_req, &bytesRead);
189 |       read_data_offset = read_data_req.data_offset;
190 |       read_data_len = read_data_req.data_len;
191 |     }
192 |     else {
193 |       // Didn't find any read data command so break
194 |       break;
195 |     }
196 | 
197 |     // Set the offset in the file requested
198 |     if (emmcdl_lseek(hFlashPrg, read_data_offset, SEEK_SET) < 0) {
199 |       Log("Failed to update FlashProgrammer pointer offset\n");
200 |       emmcdl_close(hFlashPrg);
201 |       return errno;
202 |     }
203 | 
204 |     if ((bytesRead = emmcdl_read(hFlashPrg, dataBuf, read_data_len)) < 0) {
205 |       Log("Failed to read data from flash programmer file\n");
206 |       emmcdl_close(hFlashPrg);
207 |       return errno;
208 |     }
209 | 
210 |     Log("FileOffset %i bytesRead %i\n", read_data_offset, bytesRead);
211 | 
212 |     if (sport->Write(dataBuf,bytesRead) != 0 ) {
213 |       Log("Failed to write data to device in IMEM\n");
214 |       emmcdl_close(hFlashPrg);
215 |       return errno;
216 |     }
217 |     totalBytes += bytesRead;
218 |   }
219 | 
220 |   // Done loading flash programmer so close handle
221 |   emmcdl_close(hFlashPrg);
222 | 
223 |   if (read_cmd_hdr.cmd != SAHARA_END_TRANSFER) {
224 | 	Log("Expecting SAHARA_END_TRANSFER but found: %i\n", read_cmd_hdr.cmd);
225 |     return ERROR_WRITE_FAULT;
226 |   }
227 | 
228 |   // Read the remaining part of the end transfer packet
229 |   bytesRead = sizeof(read_img_end);
230 |   status = sport->Read((unsigned char *)&read_img_end, &bytesRead);
231 |   if (read_img_end.status != SAHARA_ERROR_SUCCESS) {
232 | 	  Log("Image load failed with status: %i\n", read_img_end.status);
233 | 	  return read_img_end.status;
234 |   }
235 | 
236 |   done_t done_pkt = {0};
237 |   done_pkt.cmd = SAHARA_DONE_REQ;
238 |   done_pkt.len = 8;
239 |   status = sport->Write((unsigned char *)&done_pkt,8);
240 |   if( status != 0) {
241 |     return status;
242 |   }
243 |   
244 |   bytesRead = sizeof(done_pkt);
245 |   status = sport->Read((unsigned char*)&done_pkt,&bytesRead);
246 |   if( done_pkt.cmd != SAHARA_DONE_RSP) {
247 | 	Log("Expecting SAHARA_DONE_RSP but found: %i", done_pkt.cmd);
248 |     return ERROR_WRITE_FAULT;
249 |   }
250 | 
251 |   // After Sahara is done set timeout back to 500ms for firehose
252 |   sport->SetTimeout(500);
253 |   emmcdl_sleep_ms(500);
254 |   return 0;
255 | }
256 | 
257 | int Sahara::CheckDevice(void)
258 | {
259 |   hello_req_t hello_req = {0};
260 |   int status = -1;
261 |   uint32_t bytesRead = sizeof(hello_req);
262 |   if (sport->InputBufferCount()) {
263 |       status = sport->Read((unsigned char *)&hello_req,&bytesRead);
264 |       //sport->UnRead((unsigned char *)&hello_req, &bytesRead);
265 |       if (hello_req.cmd == SAHARA_HELLO_REQ ) {
266 |           status = ModeSwitch(SAHARA_MODE_COMMAND, false);
267 |       }
268 |   } else {
269 | 
270 |       // Assume that we already got the hello req so send hello response
271 |       status = ConnectToDevice(false, SAHARA_MODE_COMMAND);
272 |       if (status != 0) {
273 |         return status;
274 |       }
275 | 
276 |       // Make sure we get command ready back
277 |       execute_rsp_t cmd_rdy;
278 |       uint32_t bytesRead = sizeof(cmd_rdy);
279 | 
280 |       sport->SetTimeout(10);
281 |       status = sport->Read((unsigned char *)&cmd_rdy, &bytesRead);
282 |       if (status != 0 || bytesRead == 0 || (cmd_rdy.cmd == SAHARA_END_TRANSFER && cmd_rdy.data_len == SAHARA_NAK_INVALID_CMD)) {
283 |         // Assume there was a data toggle issue and send the mode switch command
284 |         //return ModeSwitch(SAHARA_MODE_COMMAND, false);
285 |       } else if (cmd_rdy.cmd != SAHARA_CMD_READY) {
286 |         Log("PblHack: Error - cmd:%i, status:%i\n", cmd_rdy.cmd, cmd_rdy.data_len);
287 |         return ERROR_INVALID_DATA;
288 |       }
289 |       ModeSwitch(SAHARA_MODE_COMMAND, false);
290 |       status = 0;
291 |   }
292 |   return status;
293 | }
294 | 
295 | int Sahara::ConnectToDevice(bool bReadHello, int mode)
296 | {
297 |   hello_req_t hello_req = {0};
298 |   int status = 0;
299 |   uint32_t bytesRead = sizeof(hello_req);
300 | 
301 |   if (bReadHello) {
302 |     sport->SetTimeout(10);
303 |     status = sport->Read((unsigned char *)&hello_req, &bytesRead);
304 |     if (status < 0) return -1;
305 |     if (hello_req.cmd != SAHARA_HELLO_REQ) {
306 |       // If no hello packet is waiting then try PBL hack to bring device to good state
307 |       if (PblHack() != 0) {
308 |         // If we fail to connect try to do a mode switch command to get hello packet and try again
309 |         Log("Did not receive Sahara hello packet from device\n");
310 |         return -1;
311 |       }
312 |     }
313 |     Log((char *)"Sahara version %d--%d \nmode %d.\n", hello_req.version_min, hello_req.version, hello_req.mode);
314 |     sport->SetTimeout(2000);
315 |   } else {
316 |     // Read any pending data
317 |     sport->Flush();
318 |   }
319 | 
320 |   hello_req.cmd = SAHARA_HELLO_RSP;
321 |   hello_req.len = 0x30;
322 |   hello_req.version = SAHARA_VERSION;
323 |   hello_req.version_min=SAHARA_VERSION_SUPPORTED;
324 |   hello_req.max_cmd_len = 0;
325 |   hello_req.mode = mode;
326 | 
327 |   status = sport->Write((unsigned char *)&hello_req, sizeof(hello_req));
328 | 
329 |   if (status != 0) {
330 |     Log("Failed to write hello response back to device\n");
331 |     return -1;
332 |  }
333 | 
334 |   return 0;
335 | }
336 | 
337 | // This function is to fix issue where PBL does not propery handle PIPE reset need to make sure 1 TX and 1 RX is working we may be out of sync...
338 | int Sahara::PblHack(void)
339 | {
340 |   int status = 0;
341 | 
342 |   // Assume that we already got the hello req so send hello response
343 |   status = ConnectToDevice(false, SAHARA_MODE_COMMAND);
344 |   if (status != 0) {
345 |     return status;
346 |   }
347 | 
348 |   // Make sure we get command ready back
349 |   execute_rsp_t cmd_rdy;
350 |   uint32_t bytesRead = sizeof(cmd_rdy);
351 | 
352 |   sport->SetTimeout(10);
353 |   status = sport->Read((unsigned char *)&cmd_rdy, &bytesRead);
354 |   if (status != 0 || bytesRead == 0) {
355 |     // Assume there was a data toggle issue and send the mode switch command
356 |     return ModeSwitch(SAHARA_MODE_IMAGE_TX_PENDING);
357 |   } else if (cmd_rdy.cmd != SAHARA_CMD_READY) {
358 |     Log("PblHack: Error - cmd:%i, status:%i\n", cmd_rdy.cmd, cmd_rdy.data_len);
359 |     return ERROR_INVALID_DATA;
360 |   }
361 | 
362 |   // Successfully got the CMD_READY so now switch back to normal mode
363 |   return ModeSwitch(SAHARA_MODE_IMAGE_TX_PENDING);
364 | }
365 | 


--------------------------------------------------------------------------------
/src/serialport.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * serialport.cpp
  3 |  *
  4 |  * This file implements the serialport and HDLC protocols and interface
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |  Edit History
 14 | 
 15 |  $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/serialport.cpp#3 $
 16 |  $DateTime: 2014/12/29 17:28:07 $ $Author: pweber $
 17 | 
 18 |  when       who     what, where, why
 19 |  -------------------------------------------------------------------------------
 20 |  11/08/11   pgw     Initial version.
 21 |  =============================================================================*/
 22 | 
 23 | #include "serialport.h"
 24 | #include "stdlib.h"
 25 | #include <termios.h>
 26 | #include <sys/ioctl.h>
 27 | 
 28 | SerialPort::SerialPort() {
 29 | 	hPort = -1;
 30 | 	to_ms = 1000;  // 1 second default timeout for packets to send/rcv
 31 | 	HDLCBuf = (unsigned char *) malloc(MAX_PACKET_SIZE);
 32 | 
 33 | }
 34 | 
 35 | SerialPort::~SerialPort() {
 36 | 	if (hPort >= 0) {
 37 | 		emmcdl_close(hPort);
 38 | 	}
 39 | 	if (HDLCBuf)
 40 | 		free(HDLCBuf);
 41 | }
 42 | 
 43 | int SerialPort::Open(int port) {
 44 | 	char tPath[32];
 45 | 	struct termios tio;
 46 | 
 47 | 	sprintf(tPath, "/dev/ttyUSB%d", port);
 48 | 	// Open handle to serial port and set proper port settings
 49 | 	hPort = emmcdl_open(tPath, O_RDWR | O_NOCTTY | O_NONBLOCK);
 50 | 
 51 | 	if (hPort < 0) {
 52 |                 printf("open serial port:%s fail\n", tPath);
 53 | 		return -1;
 54 | 	}
 55 | 
 56 | 	bzero(&tio, sizeof(tio));
 57 | 	tio.c_lflag = 0; /*disable CANON, ECHO*, etc */
 58 | 	tio.c_cflag = /*B115200 |*/CS8 | CLOCAL | CSTOPB | CREAD;
 59 | 	tio.c_iflag = IGNPAR;
 60 | 	tio.c_oflag = 0;
 61 | 
 62 | 	/*to_ms*10 timeout*/
 63 | 	tio.c_cc[VTIME] = 0;
 64 | 	tio.c_cc[VMIN] = 0;
 65 | 	//tio.c_cc[VSTART] = 0x11;
 66 | 	//tio.c_cc[VSTOP] = 0x13;
 67 | 
 68 | 	tcflush(hPort, TCIFLUSH);
 69 | 
 70 | 	if (tcsetattr(hPort, TCSANOW, &tio)) {
 71 | 		printf("config serial port fail %d:%s\n", errno, strerror(errno));
 72 | 		return -1;
 73 | 	}
 74 | 
 75 | 	return 0;
 76 | }
 77 | 
 78 | int SerialPort::Close() {
 79 | 	if (hPort != -1) {
 80 | 		emmcdl_close(hPort);
 81 | 	}
 82 | 
 83 | 	hPort = -1;
 84 | 	return 0;
 85 | }
 86 | 
 87 | int SerialPort::Write(unsigned char *data, uint32_t length) {
 88 | 	int N = 0;
 89 | 	ssize_t wsize = 0;
 90 | 	ssize_t csize = 0;
 91 | 	ssize_t len = length;
 92 | 
 93 | 	fd_set wfds;
 94 | 	struct timeval tv;
 95 | 	int retval;
 96 | 	time_t tv_sec = ((length*5)/(1024*16));
 97 | 
 98 | 	if (tv_sec < 5) tv_sec = 5;
 99 | 
100 | 	do {
101 | tryagain:
102 | 		/* Watch Serial Port to see when it has output. */
103 | 		FD_ZERO(&wfds);
104 | 
105 | 		FD_SET(hPort, &wfds);
106 | 
107 | 		/* Wait up to five seconds. */
108 | 		tv.tv_sec = tv_sec;
109 | 		tv.tv_usec = 0;
110 | 		/* Don't rely on the value of tv now! */
111 | 		retval = TEMP_FAILURE_RETRY (select(hPort + 1, NULL, &wfds, NULL, &tv));
112 | 		if (retval == -1)
113 | 			perror("select()");
114 | 		else if (retval) {
115 | 			//printf("Serial Port Output is ready now.\n");
116 | 			/* FD_ISSET(hPort, &rfds) will be true. */
117 | 			// Write data to serial port
118 | 			csize = emmcdl_write(hPort, data + wsize, len);
119 | 			if (csize < 0 && errno == EAGAIN) {
120 | 				// Write not complete
121 | 				printf("%s EAGAIN\n", __func__);
122 | 			} else if (csize > 0) {
123 | 				wsize += csize;
124 | 				len -= csize;
125 | 				N = 0;
126 | 			} else {
127 | 				emmcdl_sleep_ms(10);
128 | 			}
129 | 		} else {
130 | 			printf("Serial Port Output not ready within %ld seconds. try read again:%d\n", tv_sec, ++N);
131 | 			goto tryagain;
132 | 		}
133 | 	} while (len);
134 | 	return len ? -1 : 0;
135 | }
136 | 
137 | int SerialPort::Read(unsigned char *data, uint32_t *length) {
138 | 	ssize_t rsize = 0;
139 | 	ssize_t csize = 0;
140 | 	fd_set rfds;
141 | 	struct timeval tv;
142 |         struct timeval *ptv;
143 | 	int retval;
144 | 
145 | 	do {
146 | 		/* Watch Serial Port to see when it has input. */
147 | 		FD_ZERO(&rfds);
148 | 
149 | 		FD_SET(hPort, &rfds);
150 | 
151 |                 if (to_ms > 0) {
152 | 		  tv.tv_sec = to_ms/1000;
153 | 		  tv.tv_usec = (to_ms % 1000) * 1000;
154 |                   ptv = &tv;
155 |                 } else if (to_ms == 0) {
156 | 		  /* Wait up to five seconds. */
157 | 		  tv.tv_sec = 1;
158 | 		  tv.tv_usec = 0;
159 |                   ptv = &tv;
160 |                 } else if (to_ms < 0) {
161 |                   ptv = NULL;
162 |                 }
163 | 		/* Don't rely on the value of tv now! */
164 | 		retval = TEMP_FAILURE_RETRY (select(hPort + 1, &rfds, NULL, NULL, ptv));
165 | 
166 | 		if (retval == -1)
167 | 			perror("select()");
168 | 		else if (retval) {
169 | //tryagain:
170 | 			//printf("Serial port Data is available now.\n");
171 | 			/* FD_ISSET(hPort, &rfds) will be true. */
172 | 			// Read data in from serial port
173 | 			csize = emmcdl_read(hPort, data + rsize, (*length) - rsize);
174 | 			if (csize < 0 && errno == EAGAIN) {
175 | 				// Read not complete
176 | 				printf("%s EAGAIN\n", __func__);
177 | 				continue;
178 | 			} else if (csize > 0) {
179 | 				rsize += csize;
180 | 			} else {
181 | 			   perror("emmcdl_read");
182 |                         }
183 | 		} else {
184 | 			//goto tryagain;
185 |                         if (!rsize) {
186 | 	                    *length = 0;
187 | 			    //perror("select()");
188 | 			    printf("Serial Port No data within five seconds. %s\n", strerror(errno));
189 |                             if (!errno) errno=EAGAIN;
190 | 			    return -1;
191 |                         }
192 |                         else {
193 | 	                    *length = rsize;
194 | 			    return 0;
195 |                         }
196 | 		}
197 | 
198 | 	} while (csize < 0 /*&& (rsize < *length)*/);
199 | 	*length = rsize;
200 | 
201 | 	return rsize ? 0 : -1;
202 | }
203 | 
204 | int64_t SerialPort::InputBufferCount(){
205 |     int64_t count = 0;
206 |     ioctl(hPort, TIOCINQ, &count);
207 |     return count;
208 | }
209 | 
210 | int64_t SerialPort::OutputBufferCount(){
211 |     int64_t count = 0;
212 |     ioctl(hPort, TIOCOUTQ, &count);
213 |     return count;
214 | }
215 | 
216 | int SerialPort::Flush() {
217 | 	unsigned char tmpBuf[1024];
218 | 	uint32_t len = sizeof(tmpBuf);
219 | 
220 | 	// Set timeout to 1ms to just flush any pending data then change back to default
221 | 	SetTimeout(1);
222 | 	Read(tmpBuf, &len);
223 | 	SetTimeout(1000);
224 | 
225 | 	tcflush(hPort, TCIOFLUSH);
226 | 	return 0;
227 | }
228 | 
229 | int SerialPort::SendSync(unsigned char *out_buf, int out_length,
230 | 		unsigned char *in_buf, int *in_length) {
231 | 	uint32_t status = 0;
232 | 	uint32_t bytesOut = 0;
233 | 	uint32_t bytesIn = 0;
234 | 
235 | 	// As long as hPort is valid write the data to the serial port and wait for response for timeout
236 | 	if (hPort == -1) {
237 | 		return EBADF;
238 | 	}
239 | 
240 | 	// Do HDLC encoding then send out packet
241 | 	bytesOut = MAX_PACKET_SIZE;
242 | 	status = HDLCEncodePacket(out_buf, out_length, HDLCBuf, (int *) &bytesOut);
243 | 
244 | 	// We know we have a good handle now so write out data and wait for response
245 | 	status = Write(HDLCBuf, bytesOut);
246 | 	if (status != 0)
247 | 		return status;
248 | 
249 | 	// Keep looping through until we have received 0x7e with size > 1
250 | 	for (int i = 0; i < MAX_PACKET_SIZE; i++) {
251 | 		// Now read response and and wait for up to timeout
252 | 		bytesIn = 1;
253 | 		status = Read(&HDLCBuf[i], &bytesIn);
254 | 		if (status != 0)
255 | 			return status;
256 | 		if (bytesIn == 0)
257 | 			break;
258 | 		if (HDLCBuf[i] == 0x7E) {
259 | 			if (i > 1) {
260 | 				bytesIn = i + 1;
261 | 				break;
262 | 			} else {
263 | 				// If packet starts with multiple 0x7E ignore
264 | 				i = 0;
265 | 			}
266 | 		}
267 | 
268 | 	}
269 | 
270 | 	// Remove HDLC encoding and return the packet
271 | 	status = HDLCDecodePacket(HDLCBuf, bytesIn, in_buf, in_length);
272 | 
273 | 	return status;
274 | }
275 | 
276 | int SerialPort::SetTimeout(int ms) {
277 | #if 0
278 | 	struct termios tio;
279 | 
280 | 	if (tcgetattr(hPort, &tio)) {
281 | 		printf("get serial port config fail %d:%s\n", errno, strerror(errno));
282 | 		return -1;
283 | 	}
284 | 
285 | 	tio.c_cc[VTIME] = ms * 10;
286 | 
287 | 	//tcflush(hPort, TCIFLUSH);
288 | 
289 | 	if (tcsetattr(hPort, TCSANOW, &tio)) {
290 | 		printf("config serial port fail %d:%s\n", errno, strerror(errno));
291 | 		return -1;
292 | 	}
293 | #endif
294 | 	to_ms = ms;
295 | 	return 0;
296 | }
297 | 
298 | int SerialPort::HDLCEncodePacket(unsigned char *in_buf, int in_length,
299 | 		unsigned char *out_buf, int *out_length) {
300 | 	unsigned char *outPtr = out_buf;
301 | 	unsigned short crc = (unsigned short) CalcCRC16(in_buf, in_length);
302 | 
303 | 	// Encoded packets start and end with 0x7E
304 | 	*outPtr++ = ASYNC_HDLC_FLAG;
305 | 	for (int i = 0; i < in_length + 2; i++) {
306 | 		// Read last two bytes of data from crc value
307 | 		if (i == in_length) {
308 | 			in_buf = (unsigned char *) &crc;
309 | 		}
310 | 
311 | 		if (*in_buf == ASYNC_HDLC_FLAG || *in_buf == ASYNC_HDLC_ESC) {
312 | 			*outPtr++ = ASYNC_HDLC_ESC;
313 | 			*outPtr++ = *in_buf++ ^ ASYNC_HDLC_ESC_MASK;
314 | 		} else {
315 | 			*outPtr++ = *in_buf++;
316 | 		}
317 | 	}
318 | 	*outPtr++ = ASYNC_HDLC_FLAG;
319 | 
320 | 	// Update length of packet
321 | 	*out_length = outPtr - out_buf;
322 | 	return 0;
323 | }
324 | 
325 | int SerialPort::HDLCDecodePacket(unsigned char *in_buf, int in_length,
326 | 		unsigned char *out_buf, int *out_length) {
327 | 	unsigned char *outPtr = out_buf;
328 | 	// make sure our output buffer is large enough
329 | 	if (*out_length < in_length) {
330 | 		return ENOMEM;
331 | 	}
332 | 
333 | 	for (int i = 0; i < in_length; i++) {
334 | 		switch (*in_buf) {
335 | 		case ASYNC_HDLC_FLAG:
336 | 			// Do nothing it is an escape flag
337 | 			in_buf++;
338 | 			break;
339 | 		case ASYNC_HDLC_ESC:
340 | 			in_buf++;
341 | 			*outPtr++ = *in_buf++ ^ ASYNC_HDLC_ESC_MASK;
342 | 			break;
343 | 		default:
344 | 			*outPtr++ = *in_buf++;
345 | 		}
346 | 	}
347 | 
348 | 	*out_length = outPtr - out_buf;
349 | 	// Should do CRC check here but for now we are using USB so assume good
350 | 
351 | 	return 0;
352 | }
353 | 


--------------------------------------------------------------------------------
/src/sparse.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 | * sparse.cpp
  3 | *
  4 | * This class implements Sparse image support
  5 | *
  6 | * Copyright (c) 2007-2015
  7 | * Qualcomm Technologies Incorporated.
  8 | * All Rights Reserved.
  9 | * Qualcomm Confidential and Proprietary
 10 | *
 11 | *****************************************************************************/
 12 | /*=============================================================================
 13 | Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/sparse.cpp#2 $
 16 | $DateTime: 2015/04/01 17:01:45 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 02/05/15   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #include "stdio.h"
 24 | #include "stdlib.h"
 25 | #include "sparse.h"
 26 | #include "string.h"
 27 | 
 28 | // Constructor
 29 | SparseImage::SparseImage()
 30 | {
 31 |   bSparseImage = false;
 32 |   hSparseImage = -1;
 33 | }
 34 | 
 35 | // Destructor
 36 | SparseImage::~SparseImage()
 37 | {
 38 |   if (bSparseImage)
 39 |   {
 40 |     emmcdl_close(hSparseImage);
 41 |   }
 42 | }
 43 | 
 44 | // This will load a sparse image into memory and read headers if it is a sparse image
 45 | // RETURN: 
 46 | // 0 - Image and headers we loaded successfully
 47 | // 
 48 | int SparseImage::PreLoadImage(char *szSparseFile)
 49 | {
 50 |   //uint32_t_t dwBytesRead;
 51 |   hSparseImage = emmcdl_open(szSparseFile, O_RDONLY);
 52 |   if (hSparseImage < 0) return -ENOENT;
 53 | 
 54 |   // Load the sparse file header and verify it is valid
 55 |   if (emmcdl_read(hSparseImage, &SparseHeader, sizeof(SparseHeader)) >= 0) {
 56 |     // Check the magic number in the sparse header to see if this is a vaild sparse file
 57 |     if (SparseHeader.dwMagic != SPARSE_MAGIC) {
 58 |       emmcdl_close(hSparseImage);
 59 |       return -9;
 60 |     }
 61 |   }
 62 |   else {
 63 |     // Couldn't read the file likely someone else has it open for exclusive access
 64 |     emmcdl_close(hSparseImage);
 65 |     return errno;
 66 |   }
 67 | 
 68 |   bSparseImage = true;
 69 |   return 0;
 70 | }
 71 | 
 72 | int SparseImage::ProgramImage(Protocol *pProtocol, int64_t dwOffset)
 73 | {
 74 |   CHUNK_HEADER ChunkHeader;
 75 |   unsigned char *bpDataBuf;
 76 |   uint32_t dwBytesRead;
 77 |   uint32_t dwBytesOut = 0;
 78 |   int status = 0;
 79 | 
 80 |   // Make sure we have first successfully found a sparse file and headers are loaded okay
 81 |   if (!bSparseImage)
 82 |   {
 83 |     return -EBADF;
 84 |   }
 85 | 
 86 |   // Allocated a buffer 
 87 | 
 88 |   // Main loop through all block entries in the sparse image
 89 |   for (uint32_t i=0; i < SparseHeader.dwTotalChunks; i++){
 90 |     // Read chunk header 
 91 |     if (emmcdl_read(hSparseImage, &ChunkHeader, sizeof(ChunkHeader))){
 92 |       if (ChunkHeader.wChunkType == SPARSE_RAW_CHUNK){
 93 |         uint32_t dwChunkSize = ChunkHeader.dwChunkSize*SparseHeader.dwBlockSize;
 94 |         // Allocate a buffer the size of the chunk and read in the data
 95 |         bpDataBuf = (unsigned char *)malloc(dwChunkSize);
 96 |         if (bpDataBuf == NULL){
 97 |           return -ENOMEM;
 98 |         }
 99 |         if (emmcdl_read(hSparseImage, bpDataBuf, dwChunkSize)) {
100 |           // Now we have the data so use whatever protocol we need to write this out
101 |           pProtocol->WriteData(bpDataBuf, dwOffset, dwChunkSize, &dwBytesOut,0);
102 |           dwOffset += dwChunkSize;
103 |         }
104 |         else {
105 |           status = errno;
106 |           break;
107 |         }
108 |         free(bpDataBuf);
109 |       }
110 |       else if (ChunkHeader.wChunkType == SPARSE_FILL_CHUNK){
111 |         // Fill chunk with data byte given for now just skip over this area
112 |         dwOffset += ChunkHeader.dwChunkSize*SparseHeader.dwBlockSize;
113 |       }
114 |       else if (ChunkHeader.wChunkType == SPARSE_DONT_CARE){
115 |         // Skip the specified number of bytes in the output file
116 |         dwOffset += ChunkHeader.dwChunkSize*SparseHeader.dwBlockSize;
117 |       }
118 |       else {
119 |         // We have no idea what type of chunk this is return a failure and close file
120 |         status = ERROR_INVALID_DATA;
121 |         break;
122 |       }
123 |     }
124 |     else {
125 |       // Failed to read data something is wrong with the file
126 |       status = errno;
127 |       break;
128 |     }
129 |   }
130 | 
131 |   // If we failed to load the file close the handle and set sparse image back to false
132 |   if (status != 0) {
133 |     bSparseImage = false;
134 |     emmcdl_close(hSparseImage);
135 |   }
136 | 
137 |   return status;
138 | }
139 | 
140 | 


--------------------------------------------------------------------------------
/src/usb_linux.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (C) 2008 The Android Open Source Project
  3 |  * All rights reserved.
  4 |  *
  5 |  * Redistribution and use in source and binary forms, with or without
  6 |  * modification, are permitted provided that the following conditions
  7 |  * are met:
  8 |  *  * Redistributions of source code must retain the above copyright
  9 |  *    notice, this list of conditions and the following disclaimer.
 10 |  *  * Redistributions in binary form must reproduce the above copyright
 11 |  *    notice, this list of conditions and the following disclaimer in
 12 |  *    the documentation and/or other materials provided with the
 13 |  *    distribution.
 14 |  *
 15 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 16 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 17 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 18 |  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 19 |  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 20 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 21 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 22 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 23 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 24 |  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 25 |  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 26 |  * SUCH DAMAGE.
 27 |  */
 28 | 
 29 | #include <stdio.h>
 30 | #include <stdlib.h>
 31 | #include <unistd.h>
 32 | #include <string.h>
 33 | 
 34 | #include <sys/ioctl.h>
 35 | #include <sys/stat.h>
 36 | #include <sys/types.h>
 37 | #include <dirent.h>
 38 | #include <fcntl.h>
 39 | #include <errno.h>
 40 | #include <pthread.h>
 41 | #include <ctype.h>
 42 | 
 43 | #include <linux/usbdevice_fs.h>
 44 | #include <linux/usbdevice_fs.h>
 45 | #include <linux/version.h>
 46 | #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
 47 | #include <linux/usb/ch9.h>
 48 | #else
 49 | #include <linux/usb_ch9.h>
 50 | #endif
 51 | #include <asm/byteorder.h>
 52 | 
 53 | #include "usb.h"
 54 | 
 55 | #define MAX_RETRIES 5
 56 | 
 57 | /* Timeout in seconds for usb_wait_for_disconnect.
 58 |  * It doesn't usually take long for a device to disconnect (almost always
 59 |  * under 2 seconds) but we'll time out after 3 seconds just in case.
 60 |  */
 61 | #define WAIT_FOR_DISCONNECT_TIMEOUT  3
 62 | 
 63 | #ifdef TRACE_USB
 64 | #define DBG1(x...) fprintf(stderr, x)
 65 | #define DBG(x...) fprintf(stderr, x)
 66 | #else
 67 | #define DBG(x...)
 68 | #define DBG1(x...)
 69 | #endif
 70 | 
 71 | /* The max bulk size for linux is 16384 which is defined
 72 |  * in drivers/usb/core/devio.c.
 73 |  */
 74 | #define MAX_USBFS_BULK_SIZE (16 * 1024)
 75 | 
 76 | struct usb_handle
 77 | {
 78 |     char fname[64];
 79 |     int desc;
 80 |     unsigned char ep_in;
 81 |     unsigned char ep_out;
 82 | };
 83 | 
 84 | /* True if name isn't a valid name for a USB device in /sys/bus/usb/devices.
 85 |  * Device names are made up of numbers, dots, and dashes, e.g., '7-1.5'.
 86 |  * We reject interfaces (e.g., '7-1.5:1.0') and host controllers (e.g. 'usb1').
 87 |  * The name must also start with a digit, to disallow '.' and '..'
 88 |  */
 89 | static inline int badname(const char *name)
 90 | {
 91 |     if (!isdigit(*name))
 92 |       return 1;
 93 |     while(*++name) {
 94 |         if(!isdigit(*name) && *name != '.' && *name != '-')
 95 |             return 1;
 96 |     }
 97 |     return 0;
 98 | }
 99 | 
100 | static int check(void *_desc, int len, unsigned type, int size)
101 | {
102 |     struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)_desc;
103 | 
104 |     if(len < size) return -1;
105 |     if(hdr->bLength < size) return -1;
106 |     if(hdr->bLength > len) return -1;
107 |     if(hdr->bDescriptorType != type) return -1;
108 | 
109 |     return 0;
110 | }
111 | 
112 | static int filter_usb_device(char* sysfs_name,
113 |                              char *ptr, int len, int writable,
114 |                              ifc_match_func callback,
115 |                              int *ept_in_id, int *ept_out_id, int *ifc_id)
116 | {
117 |     struct usb_device_descriptor *dev;
118 |     struct usb_config_descriptor *cfg;
119 |     struct usb_interface_descriptor *ifc;
120 |     struct usb_endpoint_descriptor *ept;
121 |     struct usb_ifc_info info;
122 | 
123 |     int in, out;
124 |     unsigned i;
125 |     unsigned e;
126 |     
127 |     if (check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
128 |         return -1;
129 |     dev = (struct usb_device_descriptor *)ptr;
130 |     len -= dev->bLength;
131 |     ptr += dev->bLength;
132 | 
133 |     if (check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
134 |         return -1;
135 |     cfg = (struct usb_config_descriptor *)ptr;
136 |     len -= cfg->bLength;
137 |     ptr += cfg->bLength;
138 | 
139 |     info.dev_vendor = dev->idVendor;
140 |     info.dev_product = dev->idProduct;
141 |     info.dev_class = dev->bDeviceClass;
142 |     info.dev_subclass = dev->bDeviceSubClass;
143 |     info.dev_protocol = dev->bDeviceProtocol;
144 |     info.writable = writable;
145 | 
146 |     snprintf(info.device_path, sizeof(info.device_path), "usb:%s", sysfs_name);
147 | 
148 |     /* Read device serial number (if there is one).
149 |      * We read the serial number from sysfs, since it's faster and more
150 |      * reliable than issuing a control pipe read, and also won't
151 |      * cause problems for devices which don't like getting descriptor
152 |      * requests while they're in the middle of flashing.
153 |      */
154 |     info.serial_number[0] = '\0';
155 |     if (dev->iSerialNumber) {
156 |         char path[80];
157 |         int fd;
158 | 
159 |         snprintf(path, sizeof(path),
160 |                  "/sys/bus/usb/devices/%s/serial", sysfs_name);
161 |         path[sizeof(path) - 1] = '\0';
162 | 
163 |         fd = open(path, O_RDONLY);
164 |         if (fd >= 0) {
165 |             int chars_read = read(fd, info.serial_number,
166 |                                   sizeof(info.serial_number) - 1);
167 |             close(fd);
168 | 
169 |             if (chars_read <= 0)
170 |                 info.serial_number[0] = '\0';
171 |             else if (info.serial_number[chars_read - 1] == '\n') {
172 |                 // strip trailing newline
173 |                 info.serial_number[chars_read - 1] = '\0';
174 |             }
175 |         }
176 |     }
177 | 
178 |     for(i = 0; i < cfg->bNumInterfaces; i++) {
179 | 
180 |         while (len > 0) {
181 |             struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)ptr;
182 |             if (check(hdr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE) == 0)
183 |                 break;
184 |             len -= hdr->bLength;
185 |             ptr += hdr->bLength;
186 |         }
187 | 
188 |         if (len <= 0)
189 |             return -1;
190 | 
191 |         ifc = (struct usb_interface_descriptor *)ptr;
192 |         len -= ifc->bLength;
193 |         ptr += ifc->bLength;
194 | 
195 |         in = -1;
196 |         out = -1;
197 |         info.ifc_class = ifc->bInterfaceClass;
198 |         info.ifc_subclass = ifc->bInterfaceSubClass;
199 |         info.ifc_protocol = ifc->bInterfaceProtocol;
200 | 
201 |         for(e = 0; e < ifc->bNumEndpoints; e++) {
202 |             while (len > 0) {
203 |                 struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)ptr;
204 |                 if (check(hdr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE) == 0)
205 |                     break;
206 |                 len -= hdr->bLength;
207 |                 ptr += hdr->bLength;
208 |             }
209 |             if (len < 0) {
210 |                 break;
211 |             }
212 | 
213 |             ept = (struct usb_endpoint_descriptor *)ptr;
214 |             len -= ept->bLength;
215 |             ptr += ept->bLength;
216 | 
217 |             if((ept->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
218 |                 continue;
219 | 
220 |             if(ept->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
221 |                 in = ept->bEndpointAddress;
222 |             } else {
223 |                 out = ept->bEndpointAddress;
224 |             }
225 | 
226 |             // For USB 3.0 devices skip the SS Endpoint Companion descriptor
227 |             if (check((struct usb_descriptor_hdr *)ptr, len,
228 |                       USB_DT_SS_ENDPOINT_COMP, USB_DT_SS_EP_COMP_SIZE) == 0) {
229 |                 len -= USB_DT_SS_EP_COMP_SIZE;
230 |                 ptr += USB_DT_SS_EP_COMP_SIZE;
231 |             }
232 |         }
233 | 
234 |         info.has_bulk_in = (in != -1);
235 |         info.has_bulk_out = (out != -1);
236 | 
237 |         if(callback(&info) == 0) {
238 |             *ept_in_id = in;
239 |             *ept_out_id = out;
240 |             *ifc_id = ifc->bInterfaceNumber;
241 |             return 0;
242 |         }
243 |     }
244 | 
245 |     return -1;
246 | }
247 | 
248 | static int read_sysfs_string(const char *sysfs_name, const char *sysfs_node,
249 |                              char* buf, int bufsize)
250 | {
251 |     char path[80];
252 |     int fd, n;
253 | 
254 |     snprintf(path, sizeof(path),
255 |              "/sys/bus/usb/devices/%s/%s", sysfs_name, sysfs_node);
256 |     path[sizeof(path) - 1] = '\0';
257 | 
258 |     fd = open(path, O_RDONLY);
259 |     if (fd < 0)
260 |         return -1;
261 | 
262 |     n = read(fd, buf, bufsize - 1);
263 |     close(fd);
264 | 
265 |     if (n < 0)
266 |         return -1;
267 | 
268 |     buf[n] = '\0';
269 | 
270 |     return n;
271 | }
272 | 
273 | static int read_sysfs_number(const char *sysfs_name, const char *sysfs_node)
274 | {
275 |     char buf[16];
276 |     int value;
277 | 
278 |     if (read_sysfs_string(sysfs_name, sysfs_node, buf, sizeof(buf)) < 0)
279 |         return -1;
280 | 
281 |     if (sscanf(buf, "%d", &value) != 1)
282 |         return -1;
283 | 
284 |     return value;
285 | }
286 | 
287 | /* Given the name of a USB device in sysfs, get the name for the same
288 |  * device in devfs. Returns 0 for success, -1 for failure.
289 |  */
290 | static int convert_to_devfs_name(const char* sysfs_name,
291 |                                  char* devname, int devname_size)
292 | {
293 |     int busnum, devnum;
294 | 
295 |     busnum = read_sysfs_number(sysfs_name, "busnum");
296 |     if (busnum < 0)
297 |         return -1;
298 | 
299 |     devnum = read_sysfs_number(sysfs_name, "devnum");
300 |     if (devnum < 0)
301 |         return -1;
302 | 
303 |     snprintf(devname, devname_size, "/dev/bus/usb/%03d/%03d", busnum, devnum);
304 |     return 0;
305 | }
306 | 
307 | static usb_handle *find_usb_device(const char *base, ifc_match_func callback)
308 | {
309 |     usb_handle *usb = 0;
310 |     char devname[64];
311 |     char desc[1024];
312 |     int n, in, out, ifc;
313 | 
314 |     DIR *busdir;
315 |     struct dirent *de;
316 |     int fd;
317 |     int writable;
318 | 
319 |     busdir = opendir(base);
320 |     if(busdir == 0) return 0;
321 | 
322 |     while((de = readdir(busdir)) && (usb == 0)) {
323 |         if(badname(de->d_name)) continue;
324 | 
325 |         if(!convert_to_devfs_name(de->d_name, devname, sizeof(devname))) {
326 | 
327 | //            DBG("[ scanning %s ]\n", devname);
328 |             writable = 1;
329 |             if((fd = open(devname, O_RDWR)) < 0) {
330 |                 // Check if we have read-only access, so we can give a helpful
331 |                 // diagnostic like "adb devices" does.
332 |                 writable = 0;
333 |                 if((fd = open(devname, O_RDONLY)) < 0) {
334 |                     continue;
335 |                 }
336 |             }
337 | 
338 |             n = read(fd, desc, sizeof(desc));
339 | 
340 |             if(filter_usb_device(de->d_name, desc, n, writable, callback,
341 |                                  &in, &out, &ifc) == 0) {
342 |                 usb = calloc(1, sizeof(usb_handle));
343 |                 strcpy(usb->fname, devname);
344 |                 usb->ep_in = in;
345 |                 usb->ep_out = out;
346 |                 usb->desc = fd;
347 | 
348 |                 n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
349 |                 if(n != 0) {
350 |                     close(fd);
351 |                     free(usb);
352 |                     usb = 0;
353 |                     continue;
354 |                 }
355 |             } else {
356 |                 close(fd);
357 |             }
358 |         }
359 |     }
360 |     closedir(busdir);
361 | 
362 |     return usb;
363 | }
364 | 
365 | int usb_write(usb_handle *h, const void *_data, int len)
366 | {
367 |     unsigned char *data = (unsigned char*) _data;
368 |     unsigned count = 0;
369 |     struct usbdevfs_bulktransfer bulk;
370 |     int n;
371 | 
372 |     if(h->ep_out == 0 || h->desc == -1) {
373 |         return -1;
374 |     }
375 | 
376 |     do {
377 |         int xfer;
378 |         xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
379 | 
380 |         bulk.ep = h->ep_out;
381 |         bulk.len = xfer;
382 |         bulk.data = data;
383 |         bulk.timeout = 0;
384 | 
385 |         n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
386 |         if(n != xfer) {
387 |             DBG("ERROR: n = %d, errno = %d (%s)\n",
388 |                 n, errno, strerror(errno));
389 |             return -1;
390 |         }
391 | 
392 |         count += xfer;
393 |         len -= xfer;
394 |         data += xfer;
395 |     } while(len > 0);
396 | 
397 |     return count;
398 | }
399 | 
400 | int usb_read(usb_handle *h, void *_data, int len)
401 | {
402 |     unsigned char *data = (unsigned char*) _data;
403 |     unsigned count = 0;
404 |     struct usbdevfs_bulktransfer bulk;
405 |     int n, retry;
406 | 
407 |     if(h->ep_in == 0 || h->desc == -1) {
408 |         return -1;
409 |     }
410 | 
411 |     while(len > 0) {
412 |         int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
413 | 
414 |         bulk.ep = h->ep_in;
415 |         bulk.len = xfer;
416 |         bulk.data = data;
417 |         bulk.timeout = 0;
418 |         retry = 0;
419 | 
420 |         do{
421 |            DBG("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
422 |            n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
423 |            DBG("[ usb read %d ] = %d, fname=%s, Retry %d \n", xfer, n, h->fname, retry);
424 | 
425 |            if( n < 0 ) {
426 |             DBG1("ERROR: n = %d, errno = %d (%s)\n",n, errno, strerror(errno));
427 |             if ( ++retry > MAX_RETRIES ) return -1;
428 |             sleep( 1 );
429 |            }
430 |         }
431 |         while( n < 0 );
432 | 
433 |         count += n;
434 |         len -= n;
435 |         data += n;
436 | 
437 |         if(n < xfer) {
438 |             break;
439 |         }
440 |     }
441 | 
442 |     return count;
443 | }
444 | 
445 | void usb_kick(usb_handle *h)
446 | {
447 |     int fd;
448 | 
449 |     fd = h->desc;
450 |     h->desc = -1;
451 |     if(fd >= 0) {
452 |         close(fd);
453 |         DBG("[ usb closed %d ]\n", fd);
454 |     }
455 | }
456 | 
457 | int usb_close(usb_handle *h)
458 | {
459 |     int fd;
460 | 
461 |     fd = h->desc;
462 |     h->desc = -1;
463 |     if(fd >= 0) {
464 |         close(fd);
465 |         DBG("[ usb closed %d ]\n", fd);
466 |     }
467 | 
468 |     return 0;
469 | }
470 | 
471 | usb_handle *usb_open(ifc_match_func callback)
472 | {
473 |     return find_usb_device("/sys/bus/usb/devices", callback);
474 | }
475 | 
476 | double now()
477 | {
478 |     struct timeval tv;
479 |     gettimeofday(&tv, NULL);
480 |     return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
481 | }
482 | 
483 | /* Wait for the system to notice the device is gone, so that a subsequent
484 |  * fastboot command won't try to access the device before it's rebooted.
485 |  * Returns 0 for success, -1 for timeout.
486 |  */
487 | int usb_wait_for_disconnect(usb_handle *usb)
488 | {
489 |   double deadline = now() + WAIT_FOR_DISCONNECT_TIMEOUT;
490 |   while (now() < deadline) {
491 |     if (access(usb->fname, F_OK))
492 |       return 0;
493 |     usleep(50000);
494 |   }
495 |   return -1;
496 | }
497 | 


--------------------------------------------------------------------------------
/src/usbport.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * serialport.cpp
  3 |  *
  4 |  * This file implements the serialport and HDLC protocols and interface
  5 |  *
  6 |  * Copyright (c) 2007-2011
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |  Edit History
 14 | 
 15 |  $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/serialport.cpp#3 $
 16 |  $DateTime: 2014/12/29 17:28:07 $ $Author: pweber $
 17 | 
 18 |  when       who     what, where, why
 19 |  -------------------------------------------------------------------------------
 20 |  11/08/11   pgw     Initial version.
 21 |  =============================================================================*/
 22 | 
 23 | #include "serialport.h"
 24 | #include "stdlib.h"
 25 | #include "usb.h"
 26 | //#include <sys/ioctl.h>
 27 | 
 28 | static const char *serial = 0;
 29 | static unsigned short vendor_id = 0;
 30 | static int long_listing = 0;
 31 | static char ERROR[128];
 32 | 
 33 | SerialPort::SerialPort() {
 34 | 	hPort = NULL;
 35 | 	to_ms = 1000;  // 1 second default timeout for packets to send/rcv
 36 | 	HDLCBuf = (unsigned char *) malloc(MAX_PACKET_SIZE);
 37 | 
 38 | }
 39 | 
 40 | SerialPort::~SerialPort() {
 41 | 	if (hPort) {
 42 | 		//TODO
 43 | 	}
 44 | 	if (HDLCBuf)
 45 | 		free(HDLCBuf);
 46 | }
 47 | 
 48 | int match_fastboot_with_serial(usb_ifc_info *info, const char *local_serial)
 49 | {
 50 |     if(!(vendor_id && (info->dev_vendor == vendor_id)) &&
 51 |        (info->dev_vendor != 0x05c6))// Qualcomm
 52 |             return -1;
 53 |     if (info->dev_product  != 0x9008) return -1;
 54 | 
 55 |     if(info->ifc_class != 0xff) return -1;
 56 |     if(info->ifc_subclass != 0xff) return -1;
 57 |     if(info->ifc_protocol != 0xff) return -1;
 58 |     if(info->ifc_protocol != 0xff) return -1;
 59 | 
 60 |     // require matching serial number or device path if requested
 61 |     // at the command line with the -s option.
 62 |     if (local_serial && (strcmp(local_serial, info->serial_number) != 0 &&
 63 |                    strcmp(local_serial, info->device_path) != 0)) return -1;
 64 |     return 0;
 65 | }
 66 | 
 67 | int match_fastboot(usb_ifc_info *info)
 68 | {
 69 |     return match_fastboot_with_serial(info, serial);
 70 | }
 71 | 
 72 | int list_devices_callback(usb_ifc_info *info)
 73 | {
 74 |     if (match_fastboot_with_serial(info, NULL) == 0) {
 75 |         const char* serial = info->serial_number;
 76 |         if (!info->writable) {
 77 |             serial = "no permissions"; // like "adb devices"
 78 |         }
 79 |         if (!serial[0]) {
 80 |             serial = "????????????";
 81 |         }
 82 |         // output compatible with "adb devices"
 83 |         if (!long_listing) {
 84 |             printf("%s\tfastboot\n", serial);
 85 |         } else if (strcmp("", info->device_path) == 0) {
 86 |             printf("%-22s fastboot\n", serial);
 87 |         } else {
 88 |             printf("%-22s fastboot %s\n", serial, info->device_path);
 89 |         }
 90 |     }
 91 | 
 92 |     return -1;
 93 | }
 94 | 
 95 | usb_handle *open_device(void)
 96 | {
 97 |     static usb_handle *usb = 0;
 98 |     int announce = 1;
 99 | 
100 |     if(usb) return usb;
101 | 
102 |     for(;;) {
103 |         usb = usb_open(match_fastboot);
104 |         if(usb) return usb;
105 |         if(announce) {
106 |             announce = 0;
107 |             fprintf(stderr,"< waiting for device >\n");
108 |         }
109 |         usleep(1000);
110 |     }
111 | }
112 | 
113 | void list_devices(void) {
114 |     // We don't actually open a USB device here,
115 |     // just getting our callback called so we can
116 |     // list all the connected devices.
117 |     usb_open(list_devices_callback);
118 | }
119 | 
120 | int SerialPort::Open(int port) {
121 |   usb_handle *usb = open_device();
122 |   hPort = usb;
123 |   return 0;
124 | }
125 | 
126 | int SerialPort::Close() {
127 | 	if (hPort) {
128 |            //TODO
129 | 	}
130 | 
131 | 	hPort = NULL;
132 | 	return 0;
133 | }
134 | 
135 | int SerialPort::Write(unsigned char *data, uint32_t length) {
136 |     int r;
137 | 
138 |     r = usb_write(hPort, data, length);
139 |     if(r < 0) {
140 |         sprintf(ERROR, "data transfer failure (%s)", strerror(errno));
141 |         usb_close(hPort);
142 |         return -1;
143 |     }
144 |     if(r != ((int) length)) {
145 |         sprintf(ERROR, "data transfer failure (short transfer)");
146 |         usb_close(hPort);
147 |         return -1;
148 |     }
149 | 
150 |     return r;
151 | }
152 | 
153 | int SerialPort::Read(unsigned char *data, uint32_t *length) {
154 |     int r;
155 |         r = usb_read(hPort, data, *length);
156 |         if(r < 0) {
157 |             sprintf(ERROR, "status read failed (%s)", strerror(errno));
158 |             usb_close(hPort);
159 |             return -1;
160 |         }
161 | 
162 | 	*length = r;
163 | 	return r ? 0 : -1;
164 | }
165 | 
166 | int64_t SerialPort::InputBufferCount(){
167 |     int64_t count = 0;
168 |     //ioctl(hPort, TIOCINQ, &count);
169 |     return count;
170 | }
171 | 
172 | int64_t SerialPort::OutputBufferCount(){
173 |     int64_t count = 0;
174 |     //ioctl(hPort, TIOCOUTQ, &count);
175 |     return count;
176 | }
177 | 
178 | int SerialPort::Flush() {
179 | 	unsigned char tmpBuf[1024];
180 | 	uint32_t len = sizeof(tmpBuf);
181 | 
182 | 	// Set timeout to 1ms to just flush any pending data then change back to default
183 | 	SetTimeout(1);
184 | 	Read(tmpBuf, &len);
185 | 	SetTimeout(1000);
186 | 
187 | 	//tcflush(hPort, TCIOFLUSH);
188 | 	return 0;
189 | }
190 | 
191 | int SerialPort::SendSync(unsigned char *out_buf, int out_length,
192 | 		unsigned char *in_buf, int *in_length) {
193 | 	uint32_t status = 0;
194 | 	uint32_t bytesOut = 0;
195 | 	uint32_t bytesIn = 0;
196 | 
197 | 	// As long as hPort is valid write the data to the serial port and wait for response for timeout
198 | 	if (hPort == NULL) {
199 | 		return EBADF;
200 | 	}
201 | 
202 | 	// Do HDLC encoding then send out packet
203 | 	bytesOut = MAX_PACKET_SIZE;
204 | 	status = HDLCEncodePacket(out_buf, out_length, HDLCBuf, (int *) &bytesOut);
205 | 
206 | 	// We know we have a good handle now so write out data and wait for response
207 | 	status = Write(HDLCBuf, bytesOut);
208 | 	if (status != 0)
209 | 		return status;
210 | 
211 | 	// Keep looping through until we have received 0x7e with size > 1
212 | 	for (int i = 0; i < MAX_PACKET_SIZE; i++) {
213 | 		// Now read response and and wait for up to timeout
214 | 		bytesIn = 1;
215 | 		status = Read(&HDLCBuf[i], &bytesIn);
216 | 		if (status != 0)
217 | 			return status;
218 | 		if (bytesIn == 0)
219 | 			break;
220 | 		if (HDLCBuf[i] == 0x7E) {
221 | 			if (i > 1) {
222 | 				bytesIn = i + 1;
223 | 				break;
224 | 			} else {
225 | 				// If packet starts with multiple 0x7E ignore
226 | 				i = 0;
227 | 			}
228 | 		}
229 | 
230 | 	}
231 | 
232 | 	// Remove HDLC encoding and return the packet
233 | 	status = HDLCDecodePacket(HDLCBuf, bytesIn, in_buf, in_length);
234 | 
235 | 	return status;
236 | }
237 | 
238 | int SerialPort::SetTimeout(int ms) {
239 | 	to_ms = ms;
240 | 	return 0;
241 | }
242 | 
243 | int SerialPort::HDLCEncodePacket(unsigned char *in_buf, int in_length,
244 | 		unsigned char *out_buf, int *out_length) {
245 | 	unsigned char *outPtr = out_buf;
246 | 	unsigned short crc = (unsigned short) CalcCRC16(in_buf, in_length);
247 | 
248 | 	// Encoded packets start and end with 0x7E
249 | 	*outPtr++ = ASYNC_HDLC_FLAG;
250 | 	for (int i = 0; i < in_length + 2; i++) {
251 | 		// Read last two bytes of data from crc value
252 | 		if (i == in_length) {
253 | 			in_buf = (unsigned char *) &crc;
254 | 		}
255 | 
256 | 		if (*in_buf == ASYNC_HDLC_FLAG || *in_buf == ASYNC_HDLC_ESC) {
257 | 			*outPtr++ = ASYNC_HDLC_ESC;
258 | 			*outPtr++ = *in_buf++ ^ ASYNC_HDLC_ESC_MASK;
259 | 		} else {
260 | 			*outPtr++ = *in_buf++;
261 | 		}
262 | 	}
263 | 	*outPtr++ = ASYNC_HDLC_FLAG;
264 | 
265 | 	// Update length of packet
266 | 	*out_length = outPtr - out_buf;
267 | 	return 0;
268 | }
269 | 
270 | int SerialPort::HDLCDecodePacket(unsigned char *in_buf, int in_length,
271 | 		unsigned char *out_buf, int *out_length) {
272 | 	unsigned char *outPtr = out_buf;
273 | 	// make sure our output buffer is large enough
274 | 	if (*out_length < in_length) {
275 | 		return ENOMEM;
276 | 	}
277 | 
278 | 	for (int i = 0; i < in_length; i++) {
279 | 		switch (*in_buf) {
280 | 		case ASYNC_HDLC_FLAG:
281 | 			// Do nothing it is an escape flag
282 | 			in_buf++;
283 | 			break;
284 | 		case ASYNC_HDLC_ESC:
285 | 			in_buf++;
286 | 			*outPtr++ = *in_buf++ ^ ASYNC_HDLC_ESC_MASK;
287 | 			break;
288 | 		default:
289 | 			*outPtr++ = *in_buf++;
290 | 		}
291 | 	}
292 | 
293 | 	*out_length = outPtr - out_buf;
294 | 	// Should do CRC check here but for now we are using USB so assume good
295 | 
296 | 	return 0;
297 | }
298 | 


--------------------------------------------------------------------------------
/src/xmlparser.cpp:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************
  2 |  * xmlparser.cpp
  3 |  *
  4 |  * This file parses XML contents
  5 |  *
  6 |  * Copyright (c) 2007-2013
  7 |  * Qualcomm Technologies Incorporated.
  8 |  * All Rights Reserved.
  9 |  * Qualcomm Confidential and Proprietary
 10 |  *
 11 |  *****************************************************************************/
 12 | /*=============================================================================
 13 |                         Edit History
 14 | 
 15 | $Header: //source/qcom/qct/platform/uefi/workspaces/pweber/apps/8x26_emmcdl/emmcdl/main/latest/src/xmlparser.cpp#2 $
 16 | $DateTime: 2014/08/05 11:44:01 $ $Author: pweber $
 17 | 
 18 | when       who     what, where, why
 19 | -------------------------------------------------------------------------------
 20 | 05/13/13   pgw     Initial version.
 21 | =============================================================================*/
 22 | 
 23 | #include "xmlparser.h"
 24 | #include "stdio.h"
 25 | #include <stdlib.h>
 26 | 
 27 | XMLParser::XMLParser()
 28 | {
 29 |   xmlStart = NULL;
 30 |   xmlEnd = NULL;
 31 |   keyStart = NULL;
 32 |   keyEnd = NULL;
 33 |   xmlFilename = NULL;
 34 |   imgDir = NULL;
 35 | }
 36 | 
 37 | XMLParser::~XMLParser()
 38 | {
 39 |   if( xmlStart ) {
 40 | 	  free(xmlStart);
 41 | 	  xmlStart = NULL;
 42 | 	  xmlEnd = NULL;
 43 | 	  keyStart = NULL;
 44 | 	  keyEnd = NULL;
 45 | 	  xmlFilename = NULL;
 46 |           imgDir = NULL;
 47 |   }
 48 | }
 49 | 
 50 | int XMLParser::LoadXML(char *fname, const char *imgdir)
 51 | {
 52 | 	  int hXML;
 53 | 	  int status = 0;
 54 | 	  xmlStart = NULL;
 55 | 
 56 | 	  // Open the XML file and read into RAM
 57 | 	  hXML = emmcdl_open( fname,O_RDONLY);
 58 | 
 59 | 	  if( hXML < 0 ) {
 60 | 	    return errno;
 61 | 	  }
 62 | 
 63 | 	  struct stat      my_stat;
 64 | 	  int ret = fstat(hXML, &my_stat);
 65 | 	  // Make sure filesize is valid
 66 | 	  if(ret)
 67 | 	          return ret;
 68 | 
 69 | 	  uint32_t xmlSize = my_stat.st_size;
 70 | 
 71 | 	  // Make sure filesize is valid
 72 | 	  if( xmlSize < 0 ) {
 73 | 	    emmcdl_close(hXML);
 74 | 	    return EINVAL;
 75 | 	  }
 76 | 
 77 | 	  char *xmlTmp = (char *)malloc(xmlSize);
 78 | 	  xmlStart = (char *)malloc((xmlSize+2)*sizeof(char));
 79 | 	  xmlEnd = xmlStart + xmlSize;
 80 | 	  keyStart = xmlStart;
 81 | 
 82 | 	  if( xmlTmp == NULL || xmlStart == NULL ) {
 83 | 	    status = ENOMEM;
 84 | 	  }
 85 | 
 86 | 
 87 | 	  if( status == 0 ) {
 88 | 	    if((xmlSize = emmcdl_read(hXML,xmlTmp,xmlSize)) < 0 ) {
 89 | 	      status = EINVAL;
 90 | 	    }
 91 | 	  }
 92 | 
 93 | 	  emmcdl_close(hXML);
 94 | 	  xmlFilename = fname;
 95 |           imgDir = imgdir;
 96 | 
 97 | 	  // If successful then prep the buffer
 98 | 	  if( status == 0 ) {
 99 | 
100 | 	    strncpy(xmlStart,xmlTmp,xmlSize);
101 | 	    xmlStart[xmlSize] = 0;
102 | 
103 | 	    // skip over xml header should be <?xml....?>
104 | 	    for(keyStart=xmlStart;keyStart < xmlEnd;) {
105 | 	      if((*keyStart++ == '<') && (*keyStart++ == '?') ) break;
106 | 	    }
107 | 
108 | 	    for(;keyStart < xmlEnd;) {
109 | 	      if((*keyStart++ == '?') && (*keyStart++ == '>') ) break;
110 | 	    }
111 | 
112 | 	    // skip the data header for now as hack until we support embedded content
113 | 	    for(;keyStart < xmlEnd;) {
114 | 	      if(*keyStart++ == '>' ) break;
115 | 	    }
116 | 
117 | 	  }
118 | 
119 | 
120 | 	  if(xmlTmp != NULL) free(xmlTmp);
121 | 
122 | 	  return status;
123 | }
124 | 
125 | // Note currently just replace in place and fill in spaces
126 | char *XMLParser::StringSetValue(char *key, const char *keyName, char *value) const
127 | {
128 |   char *sptr = strstr(key, keyName);
129 |   if( sptr == NULL) return key;
130 | 
131 |   sptr = strstr(sptr,"\"");
132 |   if( sptr == NULL) return key;
133 | 
134 |   // Loop through and replace with actual size;
135 |   for(sptr++;;) {
136 |     char tmp = *value++;
137 |     if( *sptr == '"') break;
138 |     if( tmp == 0 ) {
139 |       *sptr++ = '"';
140 |       for(;*sptr!='"';sptr++) {
141 |         *sptr = ' ';
142 |       }
143 |       *sptr = ' ';
144 |       break;
145 |     }
146 |     *sptr++ = tmp;
147 |   }
148 |   return key;
149 | }
150 | 
151 | char *XMLParser::StringReplace(char *inp, const char *find, const char *rep) const
152 | {
153 |   char tmpstr[MAX_STRING_LEN];
154 |   int max_len = MAX_STRING_LEN;
155 |   char *tptr = tmpstr;;
156 |   char *sptr = strstr(inp, find);
157 | 
158 |   if( sptr != NULL ) {
159 |     // Copy part of string before the value to replace
160 |     strncpy(tptr,inp,(sptr-inp));
161 |     max_len -= (sptr-inp);
162 |     tptr += (sptr-inp);
163 |     sptr += strlen(find);
164 |     // Copy the replace value
165 |     strncpy(tptr,(const char*)rep,strlen(rep));
166 |     max_len -= strlen(rep);
167 |     tptr += strlen(rep);
168 | 
169 |     // Copy the rest of the string
170 |     strncpy(tptr, (const char*)sptr,strlen(sptr)+1);
171 | 
172 |     // Copy new temp string back into original
173 |     strcpy(inp,(const char*)tmpstr);
174 |   }
175 | 
176 |   return inp;
177 | }
178 | 
179 | int XMLParser::ParseXMLEvaluate(char *expr, __uint64_t &value) const
180 | {
181 |   // Parse simple expression understands -+/*, NUM_DISK_SECTORS,CRC32(offset:length)
182 |   char *sptr, *sptr1, *sptr2;
183 |   expr = StringReplace(expr,"NUM_DISK_SECTORS","1");
184 |   value = atoll(expr);
185 | 
186 |   sptr = strstr(expr,"CRC32");
187 |   if( sptr != NULL ) {
188 |     char tmp[MAX_STRING_LEN];
189 |     __uint64_t crc;
190 |     sptr1 = strstr(sptr,"(") + 1;
191 |     if( sptr1 == NULL ) {
192 |       return EINVAL;
193 |     }
194 |     sptr2 = strstr(sptr1,",");
195 |     if( sptr2 == NULL ) {
196 |       return EINVAL;
197 |     }
198 |     strncpy(tmp,(const char*)sptr1,(sptr2-sptr1));
199 |     tmp[sptr2-sptr1] = 0;
200 |     ParseXMLEvaluate(tmp, crc);
201 |     sptr1 = sptr2 + 1;
202 |     sptr2 = strstr(sptr1,")");
203 |     if( sptr2 == NULL ) {
204 |       return EINVAL;
205 |     }
206 |     strncpy(tmp,(const char*)sptr1,(sptr2-sptr1));
207 |     tmp[sptr2-sptr1] = 0;
208 |     ParseXMLEvaluate(tmp, crc);
209 |     // Revome the CRC part set value 0
210 |     memset(sptr,' ',(sptr2-sptr+1));
211 |     value = 0;
212 |   }
213 | 
214 |   sptr = strstr(expr,"*");
215 |   if( sptr != NULL ) {
216 |     // Found * do multiplication
217 |     char val1[64];
218 |     char val2[64];
219 |     strncpy(val1, (const char*)expr,(sptr-expr));
220 |     val1[sptr-expr] = 0;
221 |     strcpy(val2,sptr+1);
222 |     value = atoll(val1) * atoll(val2);
223 |   }
224 | 
225 |   sptr = strstr(expr,"/");
226 |   if( sptr != NULL ) {
227 |     // Found / do division
228 |     char val1[64];
229 |     char val2[64];
230 |     strncpy(val1, (const char*)expr,(sptr-expr));
231 |     val1[sptr-expr] = 0;
232 |     strcpy(val2, (const char*)sptr+1);
233 | 
234 |     // Prevent division by 0
235 |     if( atoll(val2) > 0 ) {
236 |       value = atoll(val1) / atoll(val2);
237 |     } else {
238 |       value = 0;
239 |     }
240 |   }
241 | 
242 |   sptr = strstr(expr,"-");
243 |   if( sptr != NULL ) {
244 |     // Found - do subtraction
245 |     char val1[32];
246 |     char val2[32];
247 |     strncpy(val1, (const char*)expr,(sptr-expr));
248 |     val1[sptr-expr] = 0;
249 |     strcpy(val2,(const char*)sptr+1);
250 |     value = atoll(val1) - atoll(val2);
251 |   }
252 |   
253 |   sptr = strstr(expr,"+");
254 |   if( sptr != NULL ) {
255 |     // Found + do addition
256 |     char val1[32];
257 |     char val2[32];
258 |     strncpy(val1,(const char*)expr,(sptr-expr));
259 |     val1[sptr-expr] = 0;
260 |     strcpy(val2,(const char*)sptr+1);
261 |     value = atoll(val1) + atoll(val2);
262 |   }
263 | 
264 |   return 0;
265 | }
266 | 
267 | 
268 | int XMLParser::ParseXMLString(char *line, const char *key, char *value) const
269 | {
270 |   // Check to make sure none of the parameters are null
271 |   if( line == NULL || key == NULL || value == NULL ) {
272 |     return EINVAL;
273 |   }
274 | 
275 |   char *eptr;
276 |   char *sptr = strstr(line,key);
277 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
278 |   sptr = strchr(sptr, '"');
279 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
280 |   sptr++;
281 |   eptr = strchr(sptr, '"');
282 |   if( eptr == NULL) return ERROR_INVALID_DATA;
283 |   // Copy the value between the quotes to output string
284 |   strncpy(value,(const char*)sptr,eptr-sptr);
285 |   value[eptr-sptr] = 0;
286 | 
287 |   return 0;
288 | }
289 | 
290 | int XMLParser::ParseXMLInteger(char *line,const char *key, __uint64_t *value) const
291 | {
292 |   // Check to make sure none of the parameters are null
293 |   if( line == NULL || key == NULL || value == NULL ) {
294 |     return EINVAL;
295 |   }
296 | 
297 |   char *eptr;
298 |   char *sptr = strstr(line,key);
299 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
300 |   sptr = strchr(sptr, '"');
301 |   if( sptr == NULL ) return ERROR_INVALID_DATA;
302 |   sptr++;
303 |   eptr = strchr(sptr, '"');
304 |   if( eptr == NULL) return ERROR_INVALID_DATA;
305 |   // Copy the value between the quotes to output string
306 |   char tmpVal[MAX_STRING_LEN];
307 |   strncpy(tmpVal, (const char*)sptr,MIN(MAX_STRING_LEN-1,eptr-sptr));
308 |   tmpVal[MIN(MAX_STRING_LEN-1,eptr-sptr)] = 0;
309 |   return  ParseXMLEvaluate(tmpVal,*value);
310 | }
311 | 


--------------------------------------------------------------------------------