2017-03-07 09:12:52 +01:00
|
|
|
/*
|
|
|
|
* (C) Copyright 2017 Fuzhou Rockchip Electronics Co., Ltd
|
|
|
|
* Seth Liu 2017.03.01
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <dirent.h>
|
2017-04-11 12:06:10 +02:00
|
|
|
#include "config.h"
|
2017-03-07 09:12:52 +01:00
|
|
|
#include "DefineHeader.h"
|
2017-04-11 12:06:10 +02:00
|
|
|
#include "gpt.h"
|
2017-03-07 09:12:52 +01:00
|
|
|
#include "RKLog.h"
|
|
|
|
#include "RKScan.h"
|
|
|
|
#include "RKComm.h"
|
|
|
|
#include "RKDevice.h"
|
|
|
|
#include "RKImage.h"
|
|
|
|
extern const char *szManufName[];
|
|
|
|
CRKLog *g_pLogObject=NULL;
|
|
|
|
CONFIG_ITEM_VECTOR g_ConfigItemVec;
|
|
|
|
#define DEFAULT_RW_LBA 128
|
|
|
|
#define CURSOR_MOVEUP_LINE(n) printf("%c[%dA", 0x1B, n)
|
|
|
|
#define CURSOR_DEL_LINE printf("%c[2K", 0x1B)
|
|
|
|
#define CURSOR_MOVE_HOME printf("%c[H", 0x1B)
|
|
|
|
#define CURSOR_CLEAR_SCREEN printf("%c[2J", 0x1B)
|
|
|
|
#define ERROR_COLOR_ATTR printf("%c[30;41m", 0x1B);
|
2017-05-14 18:11:47 +02:00
|
|
|
#define NORMAL_COLOR_ATTR printf("%c[0m", 0x1B);
|
2017-04-11 12:06:10 +02:00
|
|
|
extern UINT CRC_32(unsigned char* pData, UINT ulSize);
|
|
|
|
extern unsigned short CRC_16(unsigned char* aData, UINT aSize);
|
|
|
|
extern void P_RC4(unsigned char* buf, unsigned short len);
|
|
|
|
extern unsigned int crc32_le(unsigned int crc, unsigned char *p, unsigned int len);
|
|
|
|
/*
|
|
|
|
u8 test_gpt_head[] = {
|
|
|
|
0x45, 0x46, 0x49, 0x20, 0x50, 0x41, 0x52, 0x54, 0x00, 0x00, 0x01, 0x00, 0x5C, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0xFF, 0xFF, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0xDE, 0xFF, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x49, 0x94, 0xEC, 0x23, 0xE8, 0x58, 0x4B,
|
|
|
|
0xAE, 0xB7, 0xA9, 0x46, 0x51, 0xD0, 0x08, 0xF8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x51, 0xEA, 0xFE, 0x08};
|
|
|
|
*/
|
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
void usage()
|
|
|
|
{
|
|
|
|
printf("\r\n---------------------Tool Usage ---------------------\r\n");
|
2017-11-15 05:01:30 +01:00
|
|
|
printf("Help:\t\t\t-h or --help\r\n");
|
2017-04-16 15:42:59 +02:00
|
|
|
printf("Version:\t\t-v or --version\r\n");
|
2018-03-28 03:22:40 +02:00
|
|
|
printf("ListDevice:\t\tld\r\n");
|
2017-04-16 15:42:59 +02:00
|
|
|
printf("DownloadBoot:\t\tdb <Loader>\r\n");
|
|
|
|
printf("UpgradeLoader:\t\tul <Loader>\r\n");
|
|
|
|
printf("ReadLBA:\t\trl <BeginSec> <SectorLen> <File>\r\n");
|
|
|
|
printf("WriteLBA:\t\twl <BeginSec> <File>\r\n");
|
2017-08-07 08:39:06 +02:00
|
|
|
printf("WriteLBA:\t\twlx <PartitionName> <File>\r\n");
|
2017-04-16 15:42:59 +02:00
|
|
|
printf("WriteGPT:\t\tgpt <gpt partition table>\r\n");
|
2018-03-28 03:22:40 +02:00
|
|
|
printf("WriteParameter:\t\tprm <parameter>\r\n");
|
|
|
|
printf("PrintPartition:\t\tppt \r\n");
|
2017-04-16 15:42:59 +02:00
|
|
|
printf("EraseFlash:\t\tef \r\n");
|
|
|
|
printf("TestDevice:\t\ttd\r\n");
|
|
|
|
printf("ResetDevice:\t\trd [subcode]\r\n");
|
|
|
|
printf("ReadFlashID:\t\trid\r\n");
|
|
|
|
printf("ReadFlashInfo:\t\trfi\r\n");
|
|
|
|
printf("ReadChipInfo:\t\trci\r\n");
|
2018-03-28 03:22:40 +02:00
|
|
|
printf("ReadCapability:\t\trcb\r\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
printf("PackBootLoader:\t\tpack\r\n");
|
|
|
|
printf("UnpackBootLoader:\tunpack <boot loader>\r\n");
|
2017-04-18 05:06:59 +02:00
|
|
|
printf("TagSPL:\t\t\ttagspl <tag> <U-Boot SPL>\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
printf("-------------------------------------------------------\r\n\r\n");
|
|
|
|
}
|
|
|
|
void ProgressInfoProc(DWORD deviceLayer, ENUM_PROGRESS_PROMPT promptID, long long totalValue, long long currentValue, ENUM_CALL_STEP emCall)
|
|
|
|
{
|
|
|
|
string strInfoText="";
|
|
|
|
char szText[256];
|
|
|
|
switch (promptID) {
|
|
|
|
case TESTDEVICE_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Test Device total %lld, current %lld", totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case LOWERFORMAT_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Lowerformat Device total %lld, current %lld", totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case DOWNLOADIMAGE_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Download Image total %lldK, current %lldK", totalValue/1024, currentValue/1024);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case CHECKIMAGE_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Check Image total %lldK, current %lldK", totalValue/1024, currentValue/1024);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case TAGBADBLOCK_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Tag Bad Block total %lld, current %lld", totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case TESTBLOCK_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Test Block total %lld, current %lld", totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case ERASEFLASH_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Erase Flash total %lld, current %lld", totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case ERASESYSTEM_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "Erase System partition total %lld, current %lld", totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
case ERASEUSERDATA_PROGRESS:
|
2017-05-14 19:38:49 +02:00
|
|
|
sprintf(szText, "<LocationID=%x> Erase Userdata partition total %lld, current %lld", deviceLayer, totalValue, currentValue);
|
2017-03-07 09:12:52 +01:00
|
|
|
strInfoText = szText;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (strInfoText.size() > 0){
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
printf("%s\r\n", strInfoText.c_str());
|
|
|
|
}
|
|
|
|
if (emCall == CALL_LAST)
|
|
|
|
deviceLayer = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *strupr(char *szSrc)
|
|
|
|
{
|
|
|
|
char *p = szSrc;
|
|
|
|
while(*p){
|
|
|
|
if ((*p >= 'a') && (*p <= 'z'))
|
|
|
|
*p = *p - 'a' + 'A';
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
return szSrc;
|
|
|
|
}
|
|
|
|
void PrintData(PBYTE pData, int nSize)
|
|
|
|
{
|
|
|
|
char szPrint[17] = "\0";
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < nSize; i++){
|
|
|
|
if(i % 16 == 0){
|
|
|
|
if(i / 16 > 0)
|
|
|
|
printf(" %s\r\n", szPrint);
|
|
|
|
printf("%08d ", i / 16);
|
|
|
|
}
|
|
|
|
printf("%02X ", pData[i]);
|
|
|
|
szPrint[i%16] = isprint(pData[i]) ? pData[i] : '.';
|
|
|
|
}
|
|
|
|
if(i / 16 > 0)
|
|
|
|
printf(" %s\r\n", szPrint);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool StringToWideString(char *pszSrc, wchar_t *&pszDest)
|
|
|
|
{
|
|
|
|
if (!pszSrc)
|
|
|
|
return false;
|
|
|
|
int nSrcLen = strlen(pszSrc);
|
|
|
|
int nDestLen = nSrcLen * 2;
|
|
|
|
|
|
|
|
pszDest = NULL;
|
|
|
|
pszDest = new wchar_t[nDestLen];
|
|
|
|
if (!pszDest)
|
|
|
|
return false;
|
|
|
|
nDestLen = nDestLen * sizeof(wchar_t);
|
|
|
|
memset(pszDest, 0, nDestLen);
|
|
|
|
int iRet;
|
|
|
|
iconv_t cd;
|
|
|
|
cd = iconv_open("UTF-32", "UTF-8");
|
|
|
|
if((iconv_t)-1 == cd) {
|
|
|
|
delete []pszDest;
|
|
|
|
pszDest = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
char *pIn, *pOut;
|
|
|
|
pIn = (char *)pszSrc;
|
|
|
|
pOut = (char *)pszDest;
|
|
|
|
|
|
|
|
iRet = iconv(cd, (char **)&pIn, (size_t *)&nSrcLen, (char **)&pOut, (size_t *)&nDestLen);
|
|
|
|
|
|
|
|
if(iRet == -1) {
|
|
|
|
delete []pszDest;
|
|
|
|
pszDest = NULL;
|
|
|
|
iconv_close(cd);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
iconv_close(cd);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool WideStringToString(wchar_t *pszSrc, char *&pszDest)
|
|
|
|
{
|
|
|
|
if (!pszSrc)
|
|
|
|
return false;
|
|
|
|
int nSrcLen = wcslen(pszSrc);
|
|
|
|
int nDestLen = nSrcLen * 2;
|
|
|
|
nSrcLen = nSrcLen * sizeof(wchar_t);
|
|
|
|
pszDest = NULL;
|
|
|
|
pszDest = new char[nDestLen];
|
|
|
|
if (!pszDest)
|
|
|
|
return false;
|
|
|
|
memset(pszDest, 0, nDestLen);
|
|
|
|
int iRet;
|
|
|
|
iconv_t cd;
|
|
|
|
cd = iconv_open("UTF-8", "UTF-32");
|
|
|
|
|
|
|
|
if((iconv_t)-1 == cd) {
|
|
|
|
delete []pszDest;
|
|
|
|
pszDest = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
char *pIn, *pOut;
|
|
|
|
pIn = (char *)pszSrc;
|
|
|
|
pOut = (char *)pszDest;
|
|
|
|
iRet = iconv(cd, (char **)&pIn, (size_t *)&nSrcLen, (char **)&pOut, (size_t *)&nDestLen);
|
|
|
|
|
|
|
|
if(iRet == -1) {
|
|
|
|
delete []pszDest;
|
|
|
|
pszDest = NULL;
|
|
|
|
iconv_close(cd);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
iconv_close(cd);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
int find_config_item(CONFIG_ITEM_VECTOR &vecItems, const char *pszName)
|
2017-03-07 09:12:52 +01:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2017-08-04 10:29:29 +02:00
|
|
|
for(i = 0; i < vecItems.size(); i++){
|
|
|
|
if (strcasecmp(pszName, vecItems[i].szItemName) == 0){
|
2017-03-07 09:12:52 +01:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
void string_to_uuid(string strUUid, char *uuid)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
char value;
|
|
|
|
memset(uuid, 0, 16);
|
|
|
|
for (i =0; i < strUUid.size(); i++) {
|
|
|
|
value = 0;
|
|
|
|
if ((strUUid[i] >= '0')&&(strUUid[i] <= '9'))
|
|
|
|
value = strUUid[i] - '0';
|
|
|
|
if ((strUUid[i] >= 'a')&&(strUUid[i] <= 'f'))
|
|
|
|
value = strUUid[i] - 'a' + 10;
|
|
|
|
if ((strUUid[i] >= 'A')&&(strUUid[i] <= 'F'))
|
|
|
|
value = strUUid[i] - 'A' + 10;
|
|
|
|
if ((i % 2) == 0)
|
|
|
|
uuid[i / 2] += (value << 4);
|
|
|
|
else
|
|
|
|
uuid[i / 2] += value;
|
|
|
|
}
|
|
|
|
unsigned int *p32;
|
|
|
|
unsigned short *p16;
|
|
|
|
p32 = (unsigned int*)uuid;
|
|
|
|
*p32 = cpu_to_be32(*p32);
|
|
|
|
p16 = (unsigned short *)(uuid + 4);
|
|
|
|
*p16 = cpu_to_be16(*p16);
|
|
|
|
p16 = (unsigned short *)(uuid + 6);
|
|
|
|
*p16 = cpu_to_be16(*p16);
|
|
|
|
}
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
bool parse_config(char *pConfig, CONFIG_ITEM_VECTOR &vecItem)
|
|
|
|
{
|
|
|
|
|
|
|
|
stringstream configStream(pConfig);
|
|
|
|
string strLine, strItemName, strItemValue;
|
|
|
|
string::size_type line_size,pos;
|
|
|
|
STRUCT_CONFIG_ITEM item;
|
|
|
|
vecItem.clear();
|
|
|
|
while (!configStream.eof()){
|
|
|
|
getline(configStream, strLine);
|
|
|
|
line_size = strLine.size();
|
|
|
|
if (line_size == 0)
|
|
|
|
continue;
|
|
|
|
if (strLine[line_size-1] == '\r'){
|
|
|
|
strLine = strLine.substr(0, line_size-1);
|
|
|
|
}
|
2017-04-11 12:06:10 +02:00
|
|
|
strLine.erase(0, strLine.find_first_not_of(" "));
|
|
|
|
strLine.erase(strLine.find_last_not_of(" ") + 1);
|
|
|
|
if (strLine.size()==0 )
|
|
|
|
continue;
|
|
|
|
if (strLine[0] == '#')
|
|
|
|
continue;
|
2017-03-07 09:12:52 +01:00
|
|
|
pos = strLine.find("=");
|
|
|
|
if (pos == string::npos){
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
strItemName = strLine.substr(0, pos);
|
|
|
|
strItemValue = strLine.substr(pos + 1);
|
|
|
|
strItemName.erase(0, strItemName.find_first_not_of(" "));
|
|
|
|
strItemName.erase(strItemName.find_last_not_of(" ") + 1);
|
|
|
|
strItemValue.erase(0, strItemValue.find_first_not_of(" "));
|
|
|
|
strItemValue.erase(strItemValue.find_last_not_of(" ") + 1);
|
|
|
|
if ((strItemName.size() > 0) && (strItemValue.size() > 0)){
|
|
|
|
strcpy(item.szItemName, strItemName.c_str());
|
|
|
|
strcpy(item.szItemValue, strItemValue.c_str());
|
|
|
|
vecItem.push_back(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
bool parse_config_file(const char *pConfigFile, CONFIG_ITEM_VECTOR &vecItem)
|
|
|
|
{
|
|
|
|
FILE *file = NULL;
|
|
|
|
file = fopen(pConfigFile, "rb");
|
|
|
|
if( !file ){
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("%s failed, err=%d, can't open file: %s\r\n", __func__, errno, pConfigFile);
|
2017-03-07 09:12:52 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int iFileSize;
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
iFileSize = ftell(file);
|
|
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
char *pConfigBuf = NULL;
|
|
|
|
pConfigBuf = new char[iFileSize + 1];
|
|
|
|
if (!pConfigBuf){
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
memset(pConfigBuf, 0, iFileSize + 1);
|
|
|
|
int iRead;
|
|
|
|
iRead = fread(pConfigBuf, 1, iFileSize, file);
|
|
|
|
if (iRead != iFileSize){
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("%s failed, err=%d, read=%d, total=%d\r\n", __func__, errno, iRead, iFileSize);
|
2017-03-07 09:12:52 +01:00
|
|
|
fclose(file);
|
|
|
|
delete []pConfigBuf;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
bool bRet;
|
|
|
|
bRet = parse_config(pConfigBuf, vecItem);
|
|
|
|
delete []pConfigBuf;
|
|
|
|
return bRet;
|
|
|
|
}
|
2017-04-11 12:06:10 +02:00
|
|
|
bool ParsePartitionInfo(string &strPartInfo, string &strName, UINT &uiOffset, UINT &uiLen)
|
|
|
|
{
|
|
|
|
string::size_type pos,prevPos;
|
|
|
|
string strOffset,strLen;
|
|
|
|
int iCount;
|
|
|
|
prevPos = pos = 0;
|
|
|
|
if (strPartInfo.size() <= 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
pos = strPartInfo.find('@');
|
|
|
|
if (pos == string::npos) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
strLen = strPartInfo.substr(prevPos, pos - prevPos);
|
|
|
|
strLen.erase(0, strLen.find_first_not_of(" "));
|
|
|
|
strLen.erase(strLen.find_last_not_of(" ") + 1);
|
|
|
|
if (strchr(strLen.c_str(), '-')) {
|
|
|
|
uiLen = 0xFFFFFFFF;
|
|
|
|
} else {
|
|
|
|
iCount = sscanf(strLen.c_str(), "0x%x", &uiLen);
|
|
|
|
if (iCount != 1) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prevPos = pos + 1;
|
|
|
|
pos = strPartInfo.find('(',prevPos);
|
|
|
|
if (pos == string::npos) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
strOffset = strPartInfo.substr(prevPos, pos - prevPos);
|
|
|
|
strOffset.erase(0, strOffset.find_first_not_of(" "));
|
|
|
|
strOffset.erase(strOffset.find_last_not_of(" ") + 1);
|
|
|
|
iCount = sscanf(strOffset.c_str(), "0x%x", &uiOffset);
|
|
|
|
if (iCount != 1) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
prevPos = pos + 1;
|
|
|
|
pos = strPartInfo.find(')', prevPos);
|
|
|
|
if (pos == string::npos) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
strName = strPartInfo.substr(prevPos, pos - prevPos);
|
|
|
|
strName.erase(0, strName.find_first_not_of(" "));
|
|
|
|
strName.erase(strName.find_last_not_of(" ") + 1);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
bool ParseUuidInfo(string &strUuidInfo, string &strName, string &strUUid)
|
|
|
|
{
|
|
|
|
string::size_type pos(0);
|
|
|
|
|
|
|
|
if (strUuidInfo.size() <= 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
pos = strUuidInfo.find('=');
|
|
|
|
if (pos == string::npos) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
strName = strUuidInfo.substr(0, pos);
|
|
|
|
strName.erase(0, strName.find_first_not_of(" "));
|
|
|
|
strName.erase(strName.find_last_not_of(" ") + 1);
|
|
|
|
|
|
|
|
strUUid = strUuidInfo.substr(pos+1);
|
|
|
|
strUUid.erase(0, strUUid.find_first_not_of(" "));
|
|
|
|
strUUid.erase(strUUid.find_last_not_of(" ") + 1);
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
pos = 0;
|
|
|
|
if( (pos = strUUid.find("-")) != string::npos)
|
|
|
|
strUUid.replace(pos,1,"");
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (strUUid.size() != 32)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-04-11 12:06:10 +02:00
|
|
|
|
2017-08-04 10:29:29 +02:00
|
|
|
bool parse_parameter(char *pParameter, PARAM_ITEM_VECTOR &vecItem, CONFIG_ITEM_VECTOR &vecUuidItem)
|
2017-04-11 12:06:10 +02:00
|
|
|
{
|
|
|
|
stringstream paramStream(pParameter);
|
|
|
|
bool bRet,bFind = false;
|
2017-08-04 10:29:29 +02:00
|
|
|
string strLine, strPartition, strPartInfo, strPartName, strUUid;
|
2017-04-11 12:06:10 +02:00
|
|
|
string::size_type line_size, pos, posColon, posComma;
|
|
|
|
UINT uiPartOffset, uiPartSize;
|
|
|
|
STRUCT_PARAM_ITEM item;
|
2017-08-04 10:29:29 +02:00
|
|
|
STRUCT_CONFIG_ITEM uuid_item;
|
2017-04-11 12:06:10 +02:00
|
|
|
vecItem.clear();
|
2017-08-04 10:29:29 +02:00
|
|
|
vecUuidItem.clear();
|
2017-04-11 12:06:10 +02:00
|
|
|
while (!paramStream.eof()) {
|
|
|
|
getline(paramStream,strLine);
|
|
|
|
line_size = strLine.size();
|
|
|
|
if (line_size == 0)
|
|
|
|
continue;
|
|
|
|
if (strLine[line_size - 1] == '\r'){
|
|
|
|
strLine = strLine.substr(0, line_size - 1);
|
|
|
|
}
|
|
|
|
strLine.erase(0, strLine.find_first_not_of(" "));
|
|
|
|
strLine.erase(strLine.find_last_not_of(" ") + 1);
|
|
|
|
if (strLine.size()==0 )
|
|
|
|
continue;
|
|
|
|
if (strLine[0] == '#')
|
|
|
|
continue;
|
2017-08-04 10:29:29 +02:00
|
|
|
pos = strLine.find("uuid:");
|
|
|
|
if (pos != string::npos) {
|
|
|
|
strPartInfo = strLine.substr(pos+5);
|
|
|
|
bRet = ParseUuidInfo(strPartInfo, strPartName, strUUid);
|
|
|
|
if (bRet) {
|
|
|
|
strcpy(uuid_item.szItemName, strPartName.c_str());
|
|
|
|
string_to_uuid(strUUid,uuid_item.szItemValue);
|
|
|
|
vecUuidItem.push_back(uuid_item);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-04-11 12:06:10 +02:00
|
|
|
pos = strLine.find("mtdparts");
|
|
|
|
if (pos == string::npos) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
bFind = true;
|
|
|
|
posColon = strLine.find(':', pos);
|
|
|
|
if (posColon == string::npos) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
strPartition = strLine.substr(posColon + 1);
|
|
|
|
pos = 0;
|
|
|
|
posComma = strPartition.find(',', pos);
|
|
|
|
while (posComma != string::npos) {
|
|
|
|
strPartInfo = strPartition.substr(pos, posComma - pos);
|
|
|
|
bRet = ParsePartitionInfo(strPartInfo, strPartName, uiPartOffset, uiPartSize);
|
|
|
|
if (bRet) {
|
|
|
|
strcpy(item.szItemName, strPartName.c_str());
|
|
|
|
item.uiItemOffset = uiPartOffset;
|
|
|
|
item.uiItemSize = uiPartSize;
|
|
|
|
vecItem.push_back(item);
|
|
|
|
}
|
|
|
|
pos = posComma + 1;
|
|
|
|
posComma = strPartition.find(',', pos);
|
|
|
|
}
|
|
|
|
strPartInfo = strPartition.substr(pos);
|
|
|
|
if (strPartInfo.size() > 0) {
|
|
|
|
bRet = ParsePartitionInfo(strPartInfo, strPartName, uiPartOffset, uiPartSize);
|
|
|
|
if (bRet) {
|
|
|
|
strcpy(item.szItemName, strPartName.c_str());
|
|
|
|
item.uiItemOffset = uiPartOffset;
|
|
|
|
item.uiItemSize = uiPartSize;
|
|
|
|
vecItem.push_back(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return bFind;
|
|
|
|
|
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
bool parse_parameter_file(char *pParamFile, PARAM_ITEM_VECTOR &vecItem, CONFIG_ITEM_VECTOR &vecUuidItem)
|
2017-04-11 12:06:10 +02:00
|
|
|
{
|
|
|
|
FILE *file = NULL;
|
|
|
|
file = fopen(pParamFile, "rb");
|
|
|
|
if( !file ) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("%s failed, err=%d, can't open file: %s\r\n", __func__, errno, pParamFile);
|
2017-04-11 12:06:10 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int iFileSize;
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
iFileSize = ftell(file);
|
|
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
char *pParamBuf = NULL;
|
|
|
|
pParamBuf = new char[iFileSize];
|
|
|
|
if (!pParamBuf) {
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int iRead;
|
|
|
|
iRead = fread(pParamBuf, 1, iFileSize, file);
|
|
|
|
if (iRead != iFileSize) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("%s failed, err=%d, read=%d, total=%d\r\n", __func__, errno,iRead,iFileSize);
|
2017-04-11 12:06:10 +02:00
|
|
|
fclose(file);
|
|
|
|
delete []pParamBuf;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
bool bRet;
|
2017-08-04 10:29:29 +02:00
|
|
|
bRet = parse_parameter(pParamBuf, vecItem, vecUuidItem);
|
2017-04-11 12:06:10 +02:00
|
|
|
delete []pParamBuf;
|
|
|
|
return bRet;
|
|
|
|
}
|
2017-08-07 08:39:06 +02:00
|
|
|
bool is_sparse_image(char *szImage)
|
|
|
|
{
|
|
|
|
FILE *file = NULL;
|
|
|
|
sparse_header head;
|
|
|
|
u32 uiRead;
|
|
|
|
file = fopen(szImage, "rb");
|
|
|
|
if( !file ) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("%s failed, err=%d, can't open file: %s\r\n", __func__, errno, szImage);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
uiRead = fread(&head, 1, sizeof(head), file);
|
|
|
|
if (uiRead != sizeof(head)) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("%s failed, err=%d, read=%d, total=%d\r\n", __func__, errno, uiRead, sizeof(head));
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
if (head.magic!=SPARSE_HEADER_MAGIC)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
2017-04-11 12:06:10 +02:00
|
|
|
void gen_rand_uuid(unsigned char *uuid_bin)
|
|
|
|
{
|
|
|
|
efi_guid_t id;
|
|
|
|
unsigned int *ptr = (unsigned int *)&id;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/* Set all fields randomly */
|
|
|
|
for (i = 0; i < sizeof(id) / sizeof(*ptr); i++)
|
|
|
|
*(ptr + i) = cpu_to_be32(rand());
|
|
|
|
|
|
|
|
id.uuid.time_hi_and_version = (id.uuid.time_hi_and_version & 0x0FFF) | 0x4000;
|
|
|
|
id.uuid.clock_seq_hi_and_reserved = id.uuid.clock_seq_hi_and_reserved | 0x80;
|
|
|
|
|
|
|
|
memcpy(uuid_bin, id.raw, sizeof(id));
|
|
|
|
}
|
|
|
|
|
2017-08-04 10:29:29 +02:00
|
|
|
void prepare_gpt_backup(u8 *master, u8 *backup)
|
|
|
|
{
|
|
|
|
gpt_header *gptMasterHead = (gpt_header *)(master + SECTOR_SIZE);
|
|
|
|
gpt_header *gptBackupHead = (gpt_header *)(backup + 32 * SECTOR_SIZE);
|
|
|
|
u32 calc_crc32;
|
|
|
|
u64 val;
|
|
|
|
|
|
|
|
/* recalculate the values for the Backup GPT Header */
|
|
|
|
val = le64_to_cpu(gptMasterHead->my_lba);
|
|
|
|
gptBackupHead->my_lba = gptMasterHead->alternate_lba;
|
|
|
|
gptBackupHead->alternate_lba = cpu_to_le64(val);
|
|
|
|
gptBackupHead->partition_entry_lba = cpu_to_le64(le64_to_cpu(gptMasterHead->last_usable_lba) + 1);
|
|
|
|
gptBackupHead->header_crc32 = 0;
|
|
|
|
|
|
|
|
calc_crc32 = crc32_le(0, (unsigned char *)gptBackupHead, le32_to_cpu(gptBackupHead->header_size));
|
|
|
|
gptBackupHead->header_crc32 = cpu_to_le32(calc_crc32);
|
|
|
|
}
|
2017-08-07 08:39:06 +02:00
|
|
|
bool get_lba_from_gpt(u8 *master, char *pszName, u64 *lba, u64 *lba_end)
|
|
|
|
{
|
|
|
|
gpt_header *gptMasterHead = (gpt_header *)(master + SECTOR_SIZE);
|
|
|
|
gpt_entry *gptEntry = NULL;
|
|
|
|
u32 i,j;
|
|
|
|
u8 zerobuf[GPT_ENTRY_SIZE];
|
|
|
|
bool bFound = false;
|
|
|
|
memset(zerobuf,0,GPT_ENTRY_SIZE);
|
|
|
|
|
|
|
|
for (i = 0; i < le32_to_cpu(gptMasterHead->num_partition_entries); i++) {
|
|
|
|
gptEntry = (gpt_entry *)(master + 2 * SECTOR_SIZE + i * GPT_ENTRY_SIZE);
|
|
|
|
if (memcmp(zerobuf, (u8 *)gptEntry, GPT_ENTRY_SIZE) == 0)
|
|
|
|
break;
|
|
|
|
for (j = 0; j < strlen(pszName); j++)
|
|
|
|
if (gptEntry->partition_name[j] != pszName[j])
|
|
|
|
break;
|
|
|
|
if (gptEntry->partition_name[j] != 0)
|
|
|
|
continue;
|
|
|
|
if (j == strlen(pszName)) {
|
|
|
|
bFound = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bFound) {
|
|
|
|
*lba = le64_to_cpu(gptEntry->starting_lba);
|
|
|
|
*lba_end = le64_to_cpu(gptEntry->ending_lba);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2018-03-28 03:22:40 +02:00
|
|
|
bool get_lba_from_param(u8 *param, char *pszName, u32 *part_offset, u32 *part_size)
|
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
bool bFound = false, bRet;
|
|
|
|
PARAM_ITEM_VECTOR vecItem;
|
|
|
|
CONFIG_ITEM_VECTOR vecUuid;
|
|
|
|
|
|
|
|
bRet = parse_parameter((char *)param, vecItem, vecUuid);
|
|
|
|
if (!bRet)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (i = 0; i < vecItem.size(); i++) {
|
|
|
|
if (strcasecmp(pszName, vecItem[i].szItemName)==0) {
|
|
|
|
bFound = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bFound) {
|
|
|
|
*part_offset = vecItem[i].uiItemOffset;
|
|
|
|
*part_size = vecItem[i].uiItemSize;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-08-04 10:29:29 +02:00
|
|
|
void update_gpt_disksize(u8 *master, u8 *backup, u32 total_sector)
|
|
|
|
{
|
|
|
|
gpt_header *gptMasterHead = (gpt_header *)(master + SECTOR_SIZE);
|
|
|
|
gpt_entry *gptLastPartEntry = NULL;
|
|
|
|
u32 i;
|
|
|
|
u64 old_disksize;
|
|
|
|
u8 zerobuf[GPT_ENTRY_SIZE];
|
|
|
|
|
|
|
|
memset(zerobuf,0,GPT_ENTRY_SIZE);
|
|
|
|
old_disksize = le64_to_cpu(gptMasterHead->alternate_lba) + 1;
|
|
|
|
for (i = 0; i < le32_to_cpu(gptMasterHead->num_partition_entries); i++) {
|
|
|
|
gptLastPartEntry = (gpt_entry *)(master + 2 * SECTOR_SIZE + i * GPT_ENTRY_SIZE);
|
|
|
|
if (memcmp(zerobuf, (u8 *)gptLastPartEntry, GPT_ENTRY_SIZE) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
i--;
|
|
|
|
gptLastPartEntry = (gpt_entry *)(master + 2 * SECTOR_SIZE + i * sizeof(gpt_entry));
|
|
|
|
|
|
|
|
gptMasterHead->alternate_lba = cpu_to_le64(total_sector - 1);
|
|
|
|
gptMasterHead->last_usable_lba = cpu_to_le64(total_sector- 34);
|
|
|
|
|
|
|
|
if (gptLastPartEntry->ending_lba == (old_disksize - 34)) {//grow partition
|
|
|
|
gptLastPartEntry->ending_lba = cpu_to_le64(total_sector- 34);
|
|
|
|
gptMasterHead->partition_entry_array_crc32 = cpu_to_le32(crc32_le(0, master + 2 * SECTOR_SIZE, GPT_ENTRY_SIZE * GPT_ENTRY_NUMBERS));
|
|
|
|
}
|
|
|
|
gptMasterHead->header_crc32 = 0;
|
|
|
|
gptMasterHead->header_crc32 = cpu_to_le32(crc32_le(0, master + SECTOR_SIZE, sizeof(gpt_header)));
|
|
|
|
memcpy(backup,master + 2 * SECTOR_SIZE, GPT_ENTRY_SIZE * GPT_ENTRY_NUMBERS);
|
|
|
|
memcpy(backup + GPT_ENTRY_SIZE * GPT_ENTRY_NUMBERS, master + SECTOR_SIZE, SECTOR_SIZE);
|
|
|
|
prepare_gpt_backup(master, backup);
|
|
|
|
|
|
|
|
}
|
|
|
|
bool load_gpt_buffer(char *pParamFile, u8 *master, u8 *backup)
|
|
|
|
{
|
|
|
|
FILE *file = NULL;
|
|
|
|
file = fopen(pParamFile, "rb");
|
|
|
|
if( !file ) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("%s failed, err=%d, can't open file: %s\r\n", __func__, errno, pParamFile);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int iFileSize;
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
iFileSize = ftell(file);
|
|
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
if (iFileSize != 67 * SECTOR_SIZE) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("%s failed, wrong size file: %s\r\n", __func__, pParamFile);
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int iRead;
|
|
|
|
iRead = fread(master, 1, 34 * SECTOR_SIZE, file);
|
|
|
|
if (iRead != 34 * SECTOR_SIZE) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("%s failed,read master gpt err=%d, read=%d, total=%d\r\n", __func__, errno,iRead, 34 * SECTOR_SIZE);
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
iRead = fread(backup, 1, 33 * SECTOR_SIZE, file);
|
|
|
|
if (iRead != 33 * SECTOR_SIZE) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("%s failed,read backup gpt err=%d, read=%d, total=%d\r\n", __func__, errno,iRead, 33 * SECTOR_SIZE);
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
void create_gpt_buffer(u8 *gpt, PARAM_ITEM_VECTOR &vecParts, CONFIG_ITEM_VECTOR &vecUuid, u64 diskSectors)
|
2017-04-11 12:06:10 +02:00
|
|
|
{
|
|
|
|
legacy_mbr *mbr = (legacy_mbr *)gpt;
|
|
|
|
gpt_header *gptHead = (gpt_header *)(gpt + SECTOR_SIZE);
|
|
|
|
gpt_entry *gptEntry = (gpt_entry *)(gpt + 2 * SECTOR_SIZE);
|
|
|
|
u32 i,j;
|
2017-08-04 10:29:29 +02:00
|
|
|
int pos;
|
2017-04-11 12:06:10 +02:00
|
|
|
string strPartName;
|
|
|
|
string::size_type colonPos;
|
|
|
|
/*1.protective mbr*/
|
|
|
|
memset(gpt, 0, SECTOR_SIZE);
|
|
|
|
mbr->signature = MSDOS_MBR_SIGNATURE;
|
|
|
|
mbr->partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT;
|
|
|
|
mbr->partition_record[0].start_sect = 1;
|
|
|
|
mbr->partition_record[0].nr_sects = (u32)-1;
|
|
|
|
/*2.gpt header*/
|
|
|
|
memset(gpt + SECTOR_SIZE, 0, SECTOR_SIZE);
|
|
|
|
gptHead->signature = cpu_to_le64(GPT_HEADER_SIGNATURE);
|
|
|
|
gptHead->revision = cpu_to_le32(GPT_HEADER_REVISION_V1);
|
|
|
|
gptHead->header_size = cpu_to_le32(sizeof(gpt_header));
|
|
|
|
gptHead->my_lba = cpu_to_le64(1);
|
|
|
|
gptHead->alternate_lba = cpu_to_le64(diskSectors - 1);
|
|
|
|
gptHead->first_usable_lba = cpu_to_le64(34);
|
|
|
|
gptHead->last_usable_lba = cpu_to_le64(diskSectors - 34);
|
|
|
|
gptHead->partition_entry_lba = cpu_to_le64(2);
|
|
|
|
gptHead->num_partition_entries = cpu_to_le32(GPT_ENTRY_NUMBERS);
|
|
|
|
gptHead->sizeof_partition_entry = cpu_to_le32(GPT_ENTRY_SIZE);
|
|
|
|
gptHead->header_crc32 = 0;
|
|
|
|
gptHead->partition_entry_array_crc32 = 0;
|
|
|
|
gen_rand_uuid(gptHead->disk_guid.raw);
|
|
|
|
|
|
|
|
/*3.gpt partition entry*/
|
|
|
|
memset(gpt + 2 * SECTOR_SIZE, 0, 32 * SECTOR_SIZE);
|
|
|
|
for (i = 0; i < vecParts.size(); i++) {
|
|
|
|
gen_rand_uuid(gptEntry->partition_type_guid.raw);
|
|
|
|
gen_rand_uuid(gptEntry->unique_partition_guid.raw);
|
|
|
|
gptEntry->starting_lba = cpu_to_le64(vecParts[i].uiItemOffset);
|
|
|
|
gptEntry->ending_lba = cpu_to_le64(gptEntry->starting_lba + vecParts[i].uiItemSize - 1);
|
|
|
|
gptEntry->attributes.raw = 0;
|
|
|
|
strPartName = vecParts[i].szItemName;
|
|
|
|
colonPos = strPartName.find_first_of(':');
|
|
|
|
if (colonPos != string::npos) {
|
|
|
|
if (strPartName.find("bootable") != string::npos)
|
|
|
|
gptEntry->attributes.raw = PART_PROPERTY_BOOTABLE;
|
2017-08-04 10:29:29 +02:00
|
|
|
if (strPartName.find("grow") != string::npos)
|
|
|
|
gptEntry->ending_lba = cpu_to_le64(diskSectors - 34);
|
2017-04-11 12:06:10 +02:00
|
|
|
strPartName = strPartName.substr(0, colonPos);
|
|
|
|
vecParts[i].szItemName[strPartName.size()] = 0;
|
|
|
|
}
|
|
|
|
for (j = 0; j < strlen(vecParts[i].szItemName); j++)
|
|
|
|
gptEntry->partition_name[j] = vecParts[i].szItemName[j];
|
2017-08-04 10:29:29 +02:00
|
|
|
if ((pos = find_config_item(vecUuid, vecParts[i].szItemName)) != -1)
|
|
|
|
memcpy(gptEntry->unique_partition_guid.raw, vecUuid[pos].szItemValue, 16);
|
2017-04-11 12:06:10 +02:00
|
|
|
gptEntry++;
|
|
|
|
}
|
|
|
|
|
|
|
|
gptHead->partition_entry_array_crc32 = cpu_to_le32(crc32_le(0, gpt + 2 * SECTOR_SIZE, GPT_ENTRY_SIZE * GPT_ENTRY_NUMBERS));
|
|
|
|
gptHead->header_crc32 = cpu_to_le32(crc32_le(0, gpt + SECTOR_SIZE, sizeof(gpt_header)));
|
|
|
|
|
|
|
|
}
|
2017-08-02 04:06:45 +02:00
|
|
|
bool MakeSector0(PBYTE pSector, USHORT usFlashDataSec, USHORT usFlashBootSec, bool rc4Flag)
|
2017-04-11 12:06:10 +02:00
|
|
|
{
|
|
|
|
PRK28_IDB_SEC0 pSec0;
|
|
|
|
memset(pSector, 0, SECTOR_SIZE);
|
|
|
|
pSec0 = (PRK28_IDB_SEC0)pSector;
|
|
|
|
|
|
|
|
pSec0->dwTag = 0x0FF0AA55;
|
2017-08-02 04:06:45 +02:00
|
|
|
pSec0->uiRc4Flag = rc4Flag;
|
2017-04-11 12:06:10 +02:00
|
|
|
pSec0->usBootCode1Offset = 0x4;
|
|
|
|
pSec0->usBootCode2Offset = 0x4;
|
|
|
|
pSec0->usBootDataSize = usFlashDataSec;
|
|
|
|
pSec0->usBootCodeSize = usFlashDataSec + usFlashBootSec;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool MakeSector1(PBYTE pSector)
|
|
|
|
{
|
|
|
|
PRK28_IDB_SEC1 pSec1;
|
|
|
|
memset(pSector, 0, SECTOR_SIZE);
|
|
|
|
pSec1 = (PRK28_IDB_SEC1)pSector;
|
|
|
|
|
|
|
|
pSec1->usSysReservedBlock = 0xC;
|
|
|
|
pSec1->usDisk0Size = 0xFFFF;
|
|
|
|
pSec1->uiChipTag = 0x38324B52;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MakeSector2(PBYTE pSector)
|
|
|
|
{
|
|
|
|
PRK28_IDB_SEC2 pSec2;
|
|
|
|
memset(pSector, 0, SECTOR_SIZE);
|
|
|
|
pSec2 = (PRK28_IDB_SEC2)pSector;
|
|
|
|
|
|
|
|
strcpy(pSec2->szVcTag, "VC");
|
|
|
|
strcpy(pSec2->szCrcTag, "CRC");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MakeSector3(PBYTE pSector)
|
|
|
|
{
|
|
|
|
memset(pSector,0,SECTOR_SIZE);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-08-02 04:06:45 +02:00
|
|
|
int MakeIDBlockData(PBYTE pDDR, PBYTE pLoader, PBYTE lpIDBlock, USHORT usFlashDataSec, USHORT usFlashBootSec, DWORD dwLoaderDataSize, DWORD dwLoaderSize, bool rc4Flag)
|
2017-04-11 12:06:10 +02:00
|
|
|
{
|
|
|
|
RK28_IDB_SEC0 sector0Info;
|
|
|
|
RK28_IDB_SEC1 sector1Info;
|
|
|
|
RK28_IDB_SEC2 sector2Info;
|
|
|
|
RK28_IDB_SEC3 sector3Info;
|
|
|
|
UINT i;
|
2017-08-02 04:06:45 +02:00
|
|
|
MakeSector0((PBYTE)§or0Info, usFlashDataSec, usFlashBootSec, rc4Flag);
|
2017-04-11 12:06:10 +02:00
|
|
|
MakeSector1((PBYTE)§or1Info);
|
|
|
|
if (!MakeSector2((PBYTE)§or2Info)) {
|
|
|
|
return -6;
|
|
|
|
}
|
|
|
|
if (!MakeSector3((PBYTE)§or3Info)) {
|
|
|
|
return -7;
|
|
|
|
}
|
|
|
|
sector2Info.usSec0Crc = CRC_16((PBYTE)§or0Info, SECTOR_SIZE);
|
|
|
|
sector2Info.usSec1Crc = CRC_16((PBYTE)§or1Info, SECTOR_SIZE);
|
|
|
|
sector2Info.usSec3Crc = CRC_16((PBYTE)§or3Info, SECTOR_SIZE);
|
|
|
|
|
|
|
|
memcpy(lpIDBlock, §or0Info, SECTOR_SIZE);
|
|
|
|
memcpy(lpIDBlock + SECTOR_SIZE, §or1Info, SECTOR_SIZE);
|
|
|
|
memcpy(lpIDBlock + SECTOR_SIZE * 3, §or3Info, SECTOR_SIZE);
|
2017-08-02 04:06:45 +02:00
|
|
|
|
|
|
|
if (rc4Flag) {
|
|
|
|
for (i = 0; i < dwLoaderDataSize/SECTOR_SIZE; i++)
|
|
|
|
P_RC4(pDDR + i * SECTOR_SIZE, SECTOR_SIZE);
|
|
|
|
for (i = 0; i < dwLoaderSize/SECTOR_SIZE; i++)
|
|
|
|
P_RC4(pLoader + i * SECTOR_SIZE, SECTOR_SIZE);
|
|
|
|
}
|
|
|
|
|
2017-04-11 12:06:10 +02:00
|
|
|
memcpy(lpIDBlock + SECTOR_SIZE * 4, pDDR, dwLoaderDataSize);
|
|
|
|
memcpy(lpIDBlock + SECTOR_SIZE * (4 + usFlashDataSec), pLoader, dwLoaderSize);
|
|
|
|
|
|
|
|
sector2Info.uiBootCodeCrc = CRC_32((PBYTE)(lpIDBlock + SECTOR_SIZE * 4), sector0Info.usBootCodeSize * SECTOR_SIZE);
|
|
|
|
memcpy(lpIDBlock + SECTOR_SIZE * 2, §or2Info, SECTOR_SIZE);
|
|
|
|
for(i = 0; i < 4; i++) {
|
|
|
|
if(i == 1) {
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
P_RC4(lpIDBlock + SECTOR_SIZE * i, SECTOR_SIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
bool check_device_type(STRUCT_RKDEVICE_DESC &dev, UINT uiSupportType)
|
|
|
|
{
|
2017-10-10 15:35:25 +02:00
|
|
|
if (((UINT)dev.emUsbType & uiSupportType) == (UINT)dev.emUsbType)
|
2017-03-07 09:12:52 +01:00
|
|
|
return true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("The device does not support this operation!");
|
2017-03-07 09:12:52 +01:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2018-03-28 03:22:40 +02:00
|
|
|
bool MakeParamBuffer(char *pParamFile, char* &pParamData)
|
|
|
|
{
|
|
|
|
FILE *file=NULL;
|
|
|
|
file = fopen(pParamFile, "rb");
|
|
|
|
if( !file )
|
|
|
|
{
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("MakeParamBuffer failed,err=%d,can't open file: %s\r\n", errno, pParamFile);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int iFileSize;
|
|
|
|
fseek(file,0,SEEK_END);
|
|
|
|
iFileSize = ftell(file);
|
|
|
|
fseek(file,0,SEEK_SET);
|
|
|
|
char *pParamBuf=NULL;
|
|
|
|
pParamBuf = new char[iFileSize + 12];
|
|
|
|
if (!pParamBuf)
|
|
|
|
{
|
|
|
|
fclose(file);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
memset(pParamBuf,0,iFileSize+12);
|
|
|
|
*(UINT *)(pParamBuf) = 0x4D524150;
|
|
|
|
|
|
|
|
int iRead;
|
|
|
|
iRead = fread(pParamBuf+8,1,iFileSize,file);
|
|
|
|
if (iRead!=iFileSize)
|
|
|
|
{
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("MakeParamBuffer failed,err=%d,read=%d,total=%d\r\n", errno, iRead, iFileSize);
|
|
|
|
fclose(file);
|
|
|
|
delete []pParamBuf;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
*(UINT *)(pParamBuf+4) = iFileSize;
|
|
|
|
*(UINT *)(pParamBuf+8+iFileSize) = CRC_32( (PBYTE)pParamBuf+8, iFileSize);
|
|
|
|
pParamData = pParamBuf;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool write_parameter(STRUCT_RKDEVICE_DESC &dev, char *szParameter)
|
|
|
|
{
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
char *pParamBuf = NULL, writeBuf[512*1024];
|
|
|
|
int iRet, nParamSec, nParamSize;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
if (!check_device_type(dev, RKUSB_MASKROM|RKUSB_LOADER))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
if (!MakeParamBuffer(szParameter, pParamBuf)) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Generating parameter failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
printf("Writing parameter...\r\n");
|
|
|
|
nParamSize = *(UINT *)(pParamBuf+4) + 12;
|
|
|
|
nParamSec = BYTE2SECTOR(nParamSize);
|
|
|
|
if (nParamSec > 1024) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("parameter is too large!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
memset(writeBuf, 0, nParamSec*512);
|
|
|
|
memcpy(writeBuf, pParamBuf, nParamSize);
|
|
|
|
iRet = pComm->RKU_WriteLBA(0x2000, nParamSec, (BYTE *)writeBuf);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Writing parameter failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
bSuccess = true;
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
printf("Writing parameter succeeded.\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
2017-04-11 12:06:10 +02:00
|
|
|
bool write_gpt(STRUCT_RKDEVICE_DESC &dev, char *szParameter)
|
|
|
|
{
|
|
|
|
u8 flash_info[SECTOR_SIZE], master_gpt[34 * SECTOR_SIZE], backup_gpt[33 * SECTOR_SIZE];
|
|
|
|
u32 total_size_sector;
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
PARAM_ITEM_VECTOR vecItems;
|
2017-08-04 10:29:29 +02:00
|
|
|
CONFIG_ITEM_VECTOR vecUuid;
|
2017-04-11 12:06:10 +02:00
|
|
|
int iRet;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
if (!check_device_type(dev, RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing gpt...\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
//1.get flash info
|
|
|
|
iRet = pComm->RKU_ReadFlashInfo(flash_info);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Reading Flash Info failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
total_size_sector = *(u32 *)flash_info;
|
2017-08-04 10:29:29 +02:00
|
|
|
if (strstr(szParameter, ".img")) {
|
|
|
|
if (!load_gpt_buffer(szParameter, master_gpt, backup_gpt)) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Loading partition image failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
update_gpt_disksize(master_gpt, backup_gpt, total_size_sector);
|
|
|
|
} else {
|
|
|
|
//2.get partition from parameter
|
|
|
|
bRet = parse_parameter_file(szParameter, vecItems, vecUuid);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Parsing parameter failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
vecItems[vecItems.size()-1].uiItemSize = total_size_sector - 33;
|
|
|
|
//3.generate gpt info
|
|
|
|
create_gpt_buffer(master_gpt, vecItems, vecUuid, total_size_sector);
|
|
|
|
memcpy(backup_gpt, master_gpt + 2* SECTOR_SIZE, 32 * SECTOR_SIZE);
|
|
|
|
memcpy(backup_gpt + 32 * SECTOR_SIZE, master_gpt + SECTOR_SIZE, SECTOR_SIZE);
|
|
|
|
prepare_gpt_backup(master_gpt, backup_gpt);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
|
2017-04-11 12:06:10 +02:00
|
|
|
//4. write gpt
|
|
|
|
iRet = pComm->RKU_WriteLBA(0, 34, master_gpt);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Writing master gpt failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
iRet = pComm->RKU_WriteLBA(total_size_sector - 33, 33, backup_gpt);
|
2017-04-11 12:06:10 +02:00
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Writing backup gpt failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-08-04 10:29:29 +02:00
|
|
|
|
2017-04-11 12:06:10 +02:00
|
|
|
bSuccess = true;
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing gpt succeeded.\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-03-07 09:12:52 +01:00
|
|
|
|
2017-04-17 12:42:08 +02:00
|
|
|
#include "boot_merger.h"
|
|
|
|
#define ENTRY_ALIGN (2048)
|
|
|
|
options gOpts;
|
|
|
|
|
|
|
|
|
|
|
|
char gSubfix[MAX_LINE_LEN] = OUT_SUBFIX;
|
|
|
|
char* gConfigPath;
|
|
|
|
uint8_t gBuf[MAX_MERGE_SIZE];
|
|
|
|
|
|
|
|
static inline void fixPath(char* path) {
|
|
|
|
int i, len = strlen(path);
|
|
|
|
for(i=0; i<len; i++) {
|
|
|
|
if (path[i] == '\\')
|
|
|
|
path[i] = '/';
|
|
|
|
else if (path[i] == '\r' || path[i] == '\n')
|
|
|
|
path[i] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parseChip(FILE* file) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_NAME "=%s", gOpts.chip) != 1) {
|
|
|
|
return false;
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("chip: %s\n", gOpts.chip);
|
2017-04-17 12:42:08 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parseVersion(FILE* file) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_MAJOR "=%d", &gOpts.major) != 1)
|
|
|
|
return false;
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_MINOR "=%d", &gOpts.minor) != 1)
|
|
|
|
return false;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("major: %d, minor: %d\n", gOpts.major, gOpts.minor);
|
2017-04-17 12:42:08 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parse471(FILE* file) {
|
|
|
|
int i, index, pos;
|
|
|
|
char buf[MAX_LINE_LEN];
|
|
|
|
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_NUM "=%d", &gOpts.code471Num) != 1)
|
|
|
|
return false;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("num: %d\n", gOpts.code471Num);
|
2017-04-17 12:42:08 +02:00
|
|
|
if (!gOpts.code471Num)
|
|
|
|
return true;
|
|
|
|
if (gOpts.code471Num < 0)
|
|
|
|
return false;
|
|
|
|
gOpts.code471Path = (line_t*) malloc(sizeof(line_t) * gOpts.code471Num);
|
|
|
|
for (i=0; i<gOpts.code471Num; i++) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_PATH "%d=%[^\r^\n]", &index, buf)
|
|
|
|
!= 2)
|
|
|
|
return false;
|
|
|
|
index--;
|
|
|
|
fixPath(buf);
|
|
|
|
strcpy((char*)gOpts.code471Path[index], buf);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("path%i: %s\n", index, gOpts.code471Path[index]);
|
2017-04-17 12:42:08 +02:00
|
|
|
}
|
|
|
|
pos = ftell(file);
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_SLEEP "=%d", &gOpts.code471Sleep) != 1)
|
|
|
|
fseek(file, pos, SEEK_SET);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("sleep: %d\n", gOpts.code471Sleep);
|
2017-04-17 12:42:08 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parse472(FILE* file) {
|
|
|
|
int i, index, pos;
|
|
|
|
char buf[MAX_LINE_LEN];
|
|
|
|
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_NUM "=%d", &gOpts.code472Num) != 1)
|
|
|
|
return false;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("num: %d\n", gOpts.code472Num);
|
2017-04-17 12:42:08 +02:00
|
|
|
if (!gOpts.code472Num)
|
|
|
|
return true;
|
|
|
|
if (gOpts.code472Num < 0)
|
|
|
|
return false;
|
|
|
|
gOpts.code472Path = (line_t*) malloc(sizeof(line_t) * gOpts.code472Num);
|
|
|
|
for (i=0; i<gOpts.code472Num; i++) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_PATH "%d=%[^\r^\n]", &index, buf)
|
|
|
|
!= 2)
|
|
|
|
return false;
|
|
|
|
fixPath(buf);
|
|
|
|
index--;
|
|
|
|
strcpy((char*)gOpts.code472Path[index], buf);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("path%i: %s\n", index, gOpts.code472Path[index]);
|
2017-04-17 12:42:08 +02:00
|
|
|
}
|
|
|
|
pos = ftell(file);
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_SLEEP "=%d", &gOpts.code472Sleep) != 1)
|
|
|
|
fseek(file, pos, SEEK_SET);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("sleep: %d\n", gOpts.code472Sleep);
|
2017-04-17 12:42:08 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parseLoader(FILE* file) {
|
|
|
|
int i, j, index, pos;
|
|
|
|
char buf[MAX_LINE_LEN];
|
|
|
|
char buf2[MAX_LINE_LEN];
|
|
|
|
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
pos = ftell(file);
|
|
|
|
if (fscanf(file, OPT_NUM "=%d", &gOpts.loaderNum) != 1) {
|
|
|
|
fseek(file, pos, SEEK_SET);
|
|
|
|
if(fscanf(file, OPT_LOADER_NUM "=%d", &gOpts.loaderNum) != 1) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("num: %d\n", gOpts.loaderNum);
|
2017-04-17 12:42:08 +02:00
|
|
|
if (!gOpts.loaderNum)
|
|
|
|
return false;
|
|
|
|
if (gOpts.loaderNum < 0)
|
|
|
|
return false;
|
|
|
|
gOpts.loader = (name_entry*) malloc(sizeof(name_entry) * gOpts.loaderNum);
|
|
|
|
for (i=0; i<gOpts.loaderNum; i++) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_LOADER_NAME "%d=%s", &index, buf)
|
|
|
|
!= 2)
|
|
|
|
return false;
|
|
|
|
strcpy(gOpts.loader[index].name, buf);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("name%d: %s\n", index, gOpts.loader[index].name);
|
2018-01-08 08:38:07 +01:00
|
|
|
index++;
|
2017-04-17 12:42:08 +02:00
|
|
|
}
|
|
|
|
for (i=0; i<gOpts.loaderNum; i++) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, "%[^=]=%[^\r^\n]", buf, buf2)
|
|
|
|
!= 2)
|
|
|
|
return false;
|
|
|
|
for (j=0; j<gOpts.loaderNum; j++) {
|
|
|
|
if (!strcmp(gOpts.loader[j].name, buf)) {
|
|
|
|
fixPath(buf2);
|
|
|
|
strcpy(gOpts.loader[j].path, buf2);
|
|
|
|
printf("%s=%s\n", gOpts.loader[j].name, gOpts.loader[j].path);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (j >= gOpts.loaderNum) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parseOut(FILE* file) {
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fscanf(file, OPT_OUT_PATH "=%[^\r^\n]", gOpts.outPath) != 1)
|
|
|
|
return false;
|
|
|
|
fixPath(gOpts.outPath);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("out: %s\n", gOpts.outPath);
|
2017-04-17 12:42:08 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void printOpts(FILE* out) {
|
|
|
|
int i;
|
|
|
|
fprintf(out, SEC_CHIP "\n" OPT_NAME "=%s\n", gOpts.chip);
|
|
|
|
fprintf(out, SEC_VERSION "\n" OPT_MAJOR "=%d\n" OPT_MINOR
|
|
|
|
"=%d\n", gOpts.major, gOpts.minor);
|
|
|
|
|
|
|
|
fprintf(out, SEC_471 "\n" OPT_NUM "=%d\n", gOpts.code471Num);
|
|
|
|
for (i=0 ;i<gOpts.code471Num ;i++) {
|
|
|
|
fprintf(out, OPT_PATH "%d=%s\n", i+1, gOpts.code471Path[i]);
|
|
|
|
}
|
|
|
|
if (gOpts.code471Sleep > 0)
|
|
|
|
fprintf(out, OPT_SLEEP "=%d\n", gOpts.code471Sleep);
|
|
|
|
|
|
|
|
fprintf(out, SEC_472 "\n" OPT_NUM "=%d\n", gOpts.code472Num);
|
|
|
|
for (i=0 ;i<gOpts.code472Num ;i++) {
|
|
|
|
fprintf(out, OPT_PATH "%d=%s\n", i+1, gOpts.code472Path[i]);
|
|
|
|
}
|
|
|
|
if (gOpts.code472Sleep > 0)
|
|
|
|
fprintf(out, OPT_SLEEP "=%d\n", gOpts.code472Sleep);
|
|
|
|
|
|
|
|
fprintf(out, SEC_LOADER "\n" OPT_NUM "=%d\n", gOpts.loaderNum);
|
|
|
|
for (i=0 ;i<gOpts.loaderNum ;i++) {
|
|
|
|
fprintf(out, OPT_LOADER_NAME "%d=%s\n", i+1, gOpts.loader[i].name);
|
|
|
|
}
|
|
|
|
for (i=0 ;i<gOpts.loaderNum ;i++) {
|
|
|
|
fprintf(out, "%s=%s\n", gOpts.loader[i].name, gOpts.loader[i].path);
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(out, SEC_OUT "\n" OPT_OUT_PATH "=%s\n", gOpts.outPath);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool parseOpts(void) {
|
|
|
|
bool ret = false;
|
|
|
|
bool chipOk = false;
|
|
|
|
bool versionOk = false;
|
|
|
|
bool code471Ok = true;
|
|
|
|
bool code472Ok = true;
|
|
|
|
bool loaderOk = false;
|
|
|
|
bool outOk = false;
|
|
|
|
char buf[MAX_LINE_LEN];
|
|
|
|
|
|
|
|
char* configPath = (gConfigPath == (char*)NULL)? (char*)DEF_CONFIG_FILE: gConfigPath;
|
|
|
|
FILE* file;
|
|
|
|
file = fopen(configPath, "r");
|
|
|
|
if (!file) {
|
2017-05-14 19:38:49 +02:00
|
|
|
fprintf(stderr, "config (%s) not found!\n", configPath);
|
2017-09-18 21:17:14 +02:00
|
|
|
if (strcmp(configPath, (char*)DEF_CONFIG_FILE) == 0) {
|
2017-04-17 12:42:08 +02:00
|
|
|
file = fopen(DEF_CONFIG_FILE, "w");
|
|
|
|
if (file) {
|
2017-05-14 19:38:49 +02:00
|
|
|
fprintf(stderr, "creating defconfig\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
printOpts(file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Starting to parse...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
while(fscanf(file, "%s", buf) == 1) {
|
|
|
|
if (!strcmp(buf, SEC_CHIP)) {
|
|
|
|
chipOk = parseChip(file);
|
|
|
|
if (!chipOk) {
|
|
|
|
printf("parseChip failed!\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else if (!strcmp(buf, SEC_VERSION)) {
|
|
|
|
versionOk = parseVersion(file);
|
|
|
|
if (!versionOk) {
|
|
|
|
printf("parseVersion failed!\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else if (!strcmp(buf, SEC_471)) {
|
|
|
|
code471Ok = parse471(file);
|
|
|
|
if (!code471Ok) {
|
|
|
|
printf("parse471 failed!\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else if (!strcmp(buf, SEC_472)) {
|
|
|
|
code472Ok = parse472(file);
|
|
|
|
if (!code472Ok) {
|
|
|
|
printf("parse472 failed!\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else if (!strcmp(buf, SEC_LOADER)) {
|
|
|
|
loaderOk = parseLoader(file);
|
|
|
|
if (!loaderOk) {
|
|
|
|
printf("parseLoader failed!\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else if (!strcmp(buf, SEC_OUT)) {
|
|
|
|
outOk = parseOut(file);
|
|
|
|
if (!outOk) {
|
|
|
|
printf("parseOut failed!\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else if (buf[0] == '#') {
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
printf("unknown sec: %s!\n", buf);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
if (SCANF_EAT(file) != 0) {
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (chipOk && versionOk && code471Ok && code472Ok
|
|
|
|
&& loaderOk && outOk)
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
|
|
if (file)
|
|
|
|
fclose(file);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool initOpts(void) {
|
|
|
|
//set default opts
|
|
|
|
gOpts.major = DEF_MAJOR;
|
|
|
|
gOpts.minor = DEF_MINOR;
|
|
|
|
strcpy(gOpts.chip, DEF_CHIP);
|
|
|
|
gOpts.code471Sleep = DEF_CODE471_SLEEP;
|
|
|
|
gOpts.code472Sleep = DEF_CODE472_SLEEP;
|
|
|
|
gOpts.code471Num = DEF_CODE471_NUM;
|
|
|
|
gOpts.code471Path = (line_t*) malloc(sizeof(line_t) * gOpts.code471Num);
|
|
|
|
strcpy((char*)gOpts.code471Path[0], DEF_CODE471_PATH);
|
|
|
|
gOpts.code472Num = DEF_CODE472_NUM;
|
|
|
|
gOpts.code472Path = (line_t*) malloc(sizeof(line_t) * gOpts.code472Num);
|
|
|
|
strcpy((char*)gOpts.code472Path[0], DEF_CODE472_PATH);
|
|
|
|
gOpts.loaderNum = DEF_LOADER_NUM;
|
|
|
|
gOpts.loader = (name_entry*) malloc(sizeof(name_entry) * gOpts.loaderNum);
|
|
|
|
strcpy(gOpts.loader[0].name, DEF_LOADER0);
|
|
|
|
strcpy(gOpts.loader[0].path, DEF_LOADER0_PATH);
|
|
|
|
strcpy(gOpts.loader[1].name, DEF_LOADER1);
|
|
|
|
strcpy(gOpts.loader[1].path, DEF_LOADER1_PATH);
|
|
|
|
strcpy(gOpts.outPath, DEF_OUT_PATH);
|
|
|
|
|
|
|
|
return parseOpts();
|
|
|
|
}
|
|
|
|
|
|
|
|
/************merge code****************/
|
|
|
|
|
|
|
|
static inline uint32_t getBCD(unsigned short value) {
|
|
|
|
uint8_t tmp[2] = {0};
|
|
|
|
int i;
|
|
|
|
uint32_t ret;
|
|
|
|
//if (value > 0xFFFF) {
|
|
|
|
// return 0;
|
|
|
|
//}
|
|
|
|
for(i=0; i < 2; i++) {
|
|
|
|
tmp[i] = (((value/10)%10)<<4) | (value%10);
|
|
|
|
value /= 100;
|
|
|
|
}
|
|
|
|
ret = ((uint16_t)(tmp[1] << 8)) | tmp[0];
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("ret: %x\n",ret);
|
2017-04-17 12:42:08 +02:00
|
|
|
return ret&0xFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void str2wide(const char* str, uint16_t* wide, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
wide[i] = (uint16_t) str[i];
|
|
|
|
}
|
|
|
|
wide[len] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void getName(char* path, uint16_t* dst) {
|
|
|
|
char* end;
|
|
|
|
char* start;
|
|
|
|
int len;
|
|
|
|
if (!path || !dst)
|
|
|
|
return;
|
|
|
|
start = strrchr(path, '/');
|
|
|
|
if (!start)
|
|
|
|
start = path;
|
|
|
|
else
|
|
|
|
start++;
|
|
|
|
end = strrchr(path, '.');
|
2017-04-18 04:15:19 +02:00
|
|
|
if (!end || (end < start))
|
2017-04-17 12:42:08 +02:00
|
|
|
end = path + strlen(path);
|
|
|
|
len = end - start;
|
|
|
|
if (len >= MAX_NAME_LEN)
|
|
|
|
len = MAX_NAME_LEN -1;
|
|
|
|
str2wide(start, dst, len);
|
|
|
|
|
|
|
|
|
|
|
|
char name[MAX_NAME_LEN];
|
|
|
|
memset(name, 0, sizeof(name));
|
|
|
|
memcpy(name, start, len);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("path: %s, name: %s\n", path, name);
|
2017-04-17 12:42:08 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool getFileSize(const char *path, uint32_t* size) {
|
|
|
|
struct stat st;
|
|
|
|
if(stat(path, &st) < 0)
|
|
|
|
return false;
|
|
|
|
*size = st.st_size;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("path: %s, size: %d\n", path, *size);
|
2017-04-17 12:42:08 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline rk_time getTime(void) {
|
|
|
|
rk_time rkTime;
|
|
|
|
|
|
|
|
struct tm *tm;
|
|
|
|
time_t tt = time(NULL);
|
|
|
|
tm = localtime(&tt);
|
|
|
|
rkTime.year = tm->tm_year + 1900;
|
|
|
|
rkTime.month = tm->tm_mon + 1;
|
|
|
|
rkTime.day = tm->tm_mday;
|
|
|
|
rkTime.hour = tm->tm_hour;
|
|
|
|
rkTime.minute = tm->tm_min;
|
|
|
|
rkTime.second = tm->tm_sec;
|
|
|
|
printf("%d-%d-%d %02d:%02d:%02d\n",
|
|
|
|
rkTime.year, rkTime.month, rkTime.day,
|
|
|
|
rkTime.hour, rkTime.minute, rkTime.second);
|
|
|
|
return rkTime;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool writeFile(FILE* outFile, const char* path, bool fix) {
|
|
|
|
bool ret = false;
|
|
|
|
uint32_t size = 0, fixSize = 0;
|
|
|
|
uint8_t* buf;
|
|
|
|
|
|
|
|
FILE* inFile = fopen(path, "rb");
|
|
|
|
if (!inFile)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (!getFileSize(path, &size))
|
|
|
|
goto end;
|
|
|
|
if (fix) {
|
|
|
|
fixSize = ((size - 1) / SMALL_PACKET + 1) * SMALL_PACKET;
|
|
|
|
uint32_t tmp = fixSize % ENTRY_ALIGN;
|
|
|
|
tmp = tmp ? (ENTRY_ALIGN - tmp): 0;
|
|
|
|
fixSize +=tmp;
|
|
|
|
memset(gBuf, 0, fixSize);
|
|
|
|
} else {
|
|
|
|
memset(gBuf, 0, size+ENTRY_ALIGN);
|
|
|
|
}
|
|
|
|
if (!fread(gBuf, size, 1, inFile))
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (fix) {
|
|
|
|
|
|
|
|
buf = gBuf;
|
|
|
|
size = fixSize;
|
|
|
|
while(1) {
|
|
|
|
P_RC4(buf, fixSize < SMALL_PACKET ? fixSize : SMALL_PACKET);
|
|
|
|
buf += SMALL_PACKET;
|
|
|
|
if (fixSize <= SMALL_PACKET)
|
|
|
|
break;
|
|
|
|
fixSize -= SMALL_PACKET;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
uint32_t tmp = size % ENTRY_ALIGN;
|
|
|
|
tmp = tmp ? (ENTRY_ALIGN - tmp): 0;
|
|
|
|
size +=tmp;
|
|
|
|
P_RC4(gBuf, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!fwrite(gBuf, size, 1, outFile))
|
|
|
|
goto end;
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
|
|
if (inFile)
|
|
|
|
fclose(inFile);
|
|
|
|
if (!ret)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("writing entry (%s) failed\n", path);
|
2017-04-17 12:42:08 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool saveEntry(FILE* outFile, char* path, rk_entry_type type,
|
|
|
|
uint16_t delay, uint32_t* offset, char* fixName, bool fix) {
|
|
|
|
uint32_t size;
|
|
|
|
rk_boot_entry entry;
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("writing: %s\n", path);
|
2017-04-18 04:15:19 +02:00
|
|
|
memset(&entry, 0, sizeof(rk_boot_entry));
|
2017-04-17 12:42:08 +02:00
|
|
|
getName(fixName ? fixName: path, entry.name);
|
|
|
|
entry.size = sizeof(rk_boot_entry);
|
|
|
|
entry.type = type;
|
|
|
|
entry.dataOffset = *offset;
|
|
|
|
if (!getFileSize(path, &size)) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Saving entry (%s) failed:\n\tCannot get file size.\n", path);
|
2017-04-17 12:42:08 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (fix)
|
|
|
|
size = ((size - 1) / SMALL_PACKET + 1) * SMALL_PACKET;
|
|
|
|
uint32_t tmp = size % ENTRY_ALIGN;
|
|
|
|
size += tmp ? (ENTRY_ALIGN - tmp): 0;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("alignment size: %d\n", size);
|
2017-04-17 12:42:08 +02:00
|
|
|
entry.dataSize = size;
|
|
|
|
entry.dataDelay = delay;
|
|
|
|
*offset += size;
|
|
|
|
fwrite(&entry, sizeof(rk_boot_entry), 1, outFile);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint32_t convertChipType(const char* chip) {
|
|
|
|
char buffer[5];
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
|
|
snprintf(buffer, sizeof(buffer), "%s", chip);
|
|
|
|
return buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3];
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint32_t getChipType(const char* chip) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("chip: %s\n", chip);
|
2017-04-17 12:42:08 +02:00
|
|
|
int chipType = RKNONE_DEVICE;
|
|
|
|
if(!chip) {
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
if (!strcmp(chip, CHIP_RK28)) {
|
|
|
|
chipType = RK28_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK28)) {
|
|
|
|
chipType = RK28_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK281X)) {
|
|
|
|
chipType = RK281X_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RKPANDA)) {
|
|
|
|
chipType = RKPANDA_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK27)) {
|
|
|
|
chipType = RK27_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RKNANO)) {
|
|
|
|
chipType = RKNANO_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RKSMART)) {
|
|
|
|
chipType = RKSMART_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RKCROWN)) {
|
|
|
|
chipType = RKCROWN_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RKCAYMAN)) {
|
|
|
|
chipType = RKCAYMAN_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK29)) {
|
|
|
|
chipType = RK29_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK292X)) {
|
|
|
|
chipType = RK292X_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK30)) {
|
|
|
|
chipType = RK30_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK30B)) {
|
|
|
|
chipType = RK30B_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK31)) {
|
|
|
|
chipType = RK31_DEVICE;
|
|
|
|
} else if (!strcmp(chip, CHIP_RK32)) {
|
|
|
|
chipType = RK32_DEVICE;
|
|
|
|
} else {
|
|
|
|
chipType = convertChipType(chip + 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("type: 0x%x\n", chipType);
|
2017-04-17 12:42:08 +02:00
|
|
|
if (chipType == RKNONE_DEVICE) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("chip type not supported!\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
}
|
|
|
|
return chipType;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void getBoothdr(rk_boot_header* hdr) {
|
|
|
|
memset(hdr, 0, sizeof(rk_boot_header));
|
|
|
|
hdr->tag = TAG;
|
|
|
|
hdr->size = sizeof(rk_boot_header);
|
|
|
|
hdr->version = (getBCD(gOpts.major) << 8) | getBCD(gOpts.minor);
|
|
|
|
hdr->mergerVersion = MERGER_VERSION;
|
|
|
|
hdr->releaseTime = getTime();
|
|
|
|
hdr->chipType = getChipType(gOpts.chip);
|
|
|
|
|
|
|
|
hdr->code471Num = gOpts.code471Num;
|
|
|
|
hdr->code471Offset = sizeof(rk_boot_header);
|
|
|
|
hdr->code471Size = sizeof(rk_boot_entry);
|
|
|
|
|
|
|
|
hdr->code472Num = gOpts.code472Num;
|
|
|
|
hdr->code472Offset = hdr->code471Offset + gOpts.code471Num * hdr->code471Size;
|
|
|
|
hdr->code472Size = sizeof(rk_boot_entry);
|
|
|
|
|
|
|
|
hdr->loaderNum = gOpts.loaderNum;
|
|
|
|
hdr->loaderOffset = hdr->code472Offset + gOpts.code472Num * hdr->code472Size;
|
|
|
|
hdr->loaderSize = sizeof(rk_boot_entry);
|
|
|
|
#ifndef USE_P_RC4
|
|
|
|
hdr->rc4Flag = 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint32_t getCrc(const char* path) {
|
|
|
|
uint32_t size = 0;
|
|
|
|
uint32_t crc = 0;
|
|
|
|
|
|
|
|
FILE* file = fopen(path, "rb");
|
|
|
|
getFileSize(path, &size);
|
|
|
|
if (!file)
|
|
|
|
goto end;
|
|
|
|
if (!fread(gBuf, size, 1, file))
|
|
|
|
goto end;
|
|
|
|
crc = CRC_32(gBuf, size);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("crc: 0x%08x\n", crc);
|
2017-04-17 12:42:08 +02:00
|
|
|
end:
|
|
|
|
if (file)
|
|
|
|
fclose(file);
|
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool mergeBoot(void) {
|
|
|
|
uint32_t dataOffset;
|
|
|
|
bool ret = false;
|
|
|
|
int i;
|
|
|
|
FILE* outFile;
|
|
|
|
uint32_t crc;
|
|
|
|
rk_boot_header hdr;
|
|
|
|
|
|
|
|
if (!initOpts())
|
|
|
|
return false;
|
|
|
|
{
|
|
|
|
char* subfix = strstr(gOpts.outPath, OUT_SUBFIX);
|
|
|
|
char version[MAX_LINE_LEN];
|
|
|
|
snprintf(version, sizeof(version), "%s", gSubfix);
|
|
|
|
if (subfix && !strcmp(subfix, OUT_SUBFIX)) {
|
|
|
|
subfix[0] = '\0';
|
|
|
|
}
|
|
|
|
strcat(gOpts.outPath, version);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("fix opt: %s\n", gOpts.outPath);
|
2017-04-17 12:42:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
printf("---------------\nUSING CONFIG:\n");
|
|
|
|
printOpts(stdout);
|
|
|
|
printf("---------------\n\n");
|
|
|
|
|
|
|
|
|
|
|
|
outFile = fopen(gOpts.outPath, "wb+");
|
|
|
|
if (!outFile) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Opening output file (%s) failed\n", gOpts.outPath);
|
2017-04-17 12:42:08 +02:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
getBoothdr(&hdr);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing header...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
fwrite(&hdr, 1, sizeof(rk_boot_header), outFile);
|
|
|
|
|
|
|
|
dataOffset = sizeof(rk_boot_header) +
|
|
|
|
(gOpts.code471Num + gOpts.code472Num + gOpts.loaderNum) *
|
|
|
|
sizeof(rk_boot_entry);
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing code 471 entry...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<gOpts.code471Num; i++) {
|
|
|
|
if (!saveEntry(outFile, (char*)gOpts.code471Path[i], ENTRY_471, gOpts.code471Sleep,
|
|
|
|
&dataOffset, NULL, false))
|
|
|
|
goto end;
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing code 472 entry...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<gOpts.code472Num; i++) {
|
|
|
|
if (!saveEntry(outFile, (char*)gOpts.code472Path[i], ENTRY_472, gOpts.code472Sleep,
|
|
|
|
&dataOffset, NULL, false))
|
|
|
|
goto end;
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing loader entry...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<gOpts.loaderNum; i++) {
|
|
|
|
if (!saveEntry(outFile, gOpts.loader[i].path, ENTRY_LOADER, 0,
|
|
|
|
&dataOffset, gOpts.loader[i].name, true))
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing code 471...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<gOpts.code471Num; i++) {
|
|
|
|
if (!writeFile(outFile, (char*)gOpts.code471Path[i], false))
|
|
|
|
goto end;
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing code 472...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<gOpts.code472Num; i++) {
|
|
|
|
if (!writeFile(outFile, (char*)gOpts.code472Path[i], false))
|
|
|
|
goto end;
|
|
|
|
}
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing loader...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<gOpts.loaderNum; i++) {
|
|
|
|
if (!writeFile(outFile, gOpts.loader[i].path, true))
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
fflush(outFile);
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Writing crc...\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
crc = getCrc(gOpts.outPath);
|
|
|
|
if (!fwrite(&crc, sizeof(crc), 1, outFile))
|
|
|
|
goto end;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Done.\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
ret = true;
|
|
|
|
end:
|
|
|
|
if (outFile)
|
|
|
|
fclose(outFile);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/************merge code end************/
|
|
|
|
/************unpack code***************/
|
|
|
|
|
|
|
|
static inline void wide2str(const uint16_t* wide, char* str, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
str[i] = (char) (wide[i] & 0xFF);
|
|
|
|
}
|
|
|
|
str[len] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool unpackEntry(rk_boot_entry* entry, const char* name,
|
|
|
|
FILE* inFile) {
|
|
|
|
bool ret = false;
|
|
|
|
int size, i;
|
|
|
|
FILE* outFile = fopen(name, "wb+");
|
|
|
|
if (!outFile)
|
|
|
|
goto end;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("unpacking entry (%s)\n", name);
|
2017-04-17 12:42:08 +02:00
|
|
|
fseek(inFile, entry->dataOffset, SEEK_SET);
|
|
|
|
size = entry->dataSize;
|
|
|
|
if (!fread(gBuf, size, 1, inFile))
|
|
|
|
goto end;
|
|
|
|
if (entry->type == ENTRY_LOADER) {
|
|
|
|
for(i=0; i<size/SMALL_PACKET; i++)
|
|
|
|
P_RC4(gBuf + i * SMALL_PACKET, SMALL_PACKET);
|
|
|
|
if (size % SMALL_PACKET)
|
|
|
|
{
|
|
|
|
P_RC4(gBuf + i * SMALL_PACKET, size - SMALL_PACKET * 512);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
P_RC4(gBuf, size);
|
|
|
|
}
|
|
|
|
if (!fwrite(gBuf, size, 1, outFile))
|
|
|
|
goto end;
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
|
|
if (outFile)
|
|
|
|
fclose(outFile);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool unpackBoot(char* path) {
|
|
|
|
bool ret = false;
|
|
|
|
FILE* inFile = fopen(path, "rb");
|
|
|
|
int entryNum, i;
|
|
|
|
char name[MAX_NAME_LEN];
|
|
|
|
rk_boot_entry* entrys;
|
|
|
|
if (!inFile) {
|
2017-05-14 19:38:49 +02:00
|
|
|
fprintf(stderr, "loader (%s) not found\n", path);
|
2017-04-17 12:42:08 +02:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
rk_boot_header hdr;
|
|
|
|
if (!fread(&hdr, sizeof(rk_boot_header), 1, inFile)) {
|
2017-05-14 19:38:49 +02:00
|
|
|
fprintf(stderr, "reading header failed\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
printf("471 num:%d, 472 num:%d, loader num:%d\n", hdr.code471Num, hdr.code472Num, hdr.loaderNum);
|
|
|
|
entryNum = hdr.code471Num + hdr.code472Num + hdr.loaderNum;
|
|
|
|
entrys = (rk_boot_entry*) malloc(sizeof(rk_boot_entry) * entryNum);
|
|
|
|
if (!fread(entrys, sizeof(rk_boot_entry) * entryNum, 1, inFile)) {
|
2017-05-14 19:38:49 +02:00
|
|
|
fprintf(stderr, "reading data failed\n");
|
2017-04-17 12:42:08 +02:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("entry num: %d\n", entryNum);
|
2017-04-17 12:42:08 +02:00
|
|
|
for (i=0; i<entryNum; i++) {
|
|
|
|
wide2str(entrys[i].name, name, MAX_NAME_LEN);
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("entry: t=%d, name=%s, off=%d, size=%d\n",
|
2017-04-17 12:42:08 +02:00
|
|
|
entrys[i].type, name, entrys[i].dataOffset,
|
|
|
|
entrys[i].dataSize);
|
|
|
|
if (!unpackEntry(entrys + i, name, inFile)) {
|
2017-05-14 19:38:49 +02:00
|
|
|
fprintf(stderr, "unpacking entry (%s) failed\n", name);
|
2017-04-17 12:42:08 +02:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf("done\n");
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
|
|
if (inFile)
|
|
|
|
fclose(inFile);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
bool download_boot(STRUCT_RKDEVICE_DESC &dev, char *szLoader)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKImage *pImage = NULL;
|
|
|
|
CRKBoot *pBoot = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
|
|
|
|
pImage = new CRKImage(szLoader, bRet);
|
|
|
|
if (!bRet){
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Opening loader failed, exiting download boot!");
|
2017-03-07 09:12:52 +01:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
} else {
|
|
|
|
pBoot = (CRKBoot *)pImage->m_bootObject;
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
CRKDevice *pDevice = NULL;
|
|
|
|
|
|
|
|
dev.emDeviceType = pBoot->SupportDevice;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
if (pImage)
|
|
|
|
delete pImage;
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
pDevice = new CRKDevice(dev);
|
|
|
|
if (!pDevice) {
|
|
|
|
if (pImage)
|
|
|
|
delete pImage;
|
|
|
|
if (pComm)
|
|
|
|
delete pComm;
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating device object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
pDevice->SetObject(pImage, pComm, g_pLogObject);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Downloading bootloader...\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
iRet = pDevice->DownloadBoot();
|
|
|
|
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
if (iRet == 0) {
|
|
|
|
bSuccess = true;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Downloading bootloader succeeded.\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Downloading bootloader failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
if (pImage)
|
|
|
|
delete pImage;
|
|
|
|
if(pDevice)
|
|
|
|
delete pDevice;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-04-11 12:06:10 +02:00
|
|
|
bool upgrade_loader(STRUCT_RKDEVICE_DESC &dev, char *szLoader)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKImage *pImage = NULL;
|
|
|
|
CRKBoot *pBoot = NULL;
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
char index;
|
|
|
|
USHORT usFlashDataSec, usFlashBootSec;
|
|
|
|
DWORD dwLoaderSize, dwLoaderDataSize, dwDelay, dwSectorNum;
|
|
|
|
char loaderCodeName[] = "FlashBoot";
|
|
|
|
char loaderDataName[] = "FlashData";
|
|
|
|
PBYTE loaderCodeBuffer = NULL;
|
|
|
|
PBYTE loaderDataBuffer = NULL;
|
|
|
|
PBYTE pIDBData = NULL;
|
|
|
|
pImage = new CRKImage(szLoader, bRet);
|
|
|
|
if (!bRet){
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Opening loader failed, exiting upgrade loader!");
|
2017-04-11 12:06:10 +02:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
} else {
|
|
|
|
pBoot = (CRKBoot *)pImage->m_bootObject;
|
|
|
|
dev.emDeviceType = pBoot->SupportDevice;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Upgrading loader...\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
index = pBoot->GetIndexByName(ENTRYLOADER, loaderCodeName);
|
|
|
|
if (index == -1) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("ERROR: %s --> Get LoaderCode Entry failed", __func__);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
bRet = pBoot->GetEntryProperty(ENTRYLOADER, index, dwLoaderSize, dwDelay);
|
|
|
|
if (!bRet) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("ERROR: %s --> Get LoaderCode Entry Size failed", __func__);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
|
|
|
|
loaderCodeBuffer = new BYTE[dwLoaderSize];
|
|
|
|
memset(loaderCodeBuffer, 0, dwLoaderSize);
|
|
|
|
if (!pBoot->GetEntryData(ENTRYLOADER, index, loaderCodeBuffer)) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("ERROR: %s --> Get LoaderCode Data failed", __func__);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = pBoot->GetIndexByName(ENTRYLOADER, loaderDataName);
|
|
|
|
if (index == -1) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("ERROR: %s --> Get LoaderData Entry failed", __func__);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
|
|
|
delete []loaderCodeBuffer;
|
|
|
|
return -4;
|
|
|
|
}
|
|
|
|
|
|
|
|
bRet = pBoot->GetEntryProperty(ENTRYLOADER, index, dwLoaderDataSize, dwDelay);
|
|
|
|
if (!bRet) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("ERROR: %s --> Get LoaderData Entry Size failed", __func__);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
|
|
|
|
loaderDataBuffer = new BYTE[dwLoaderDataSize];
|
|
|
|
memset(loaderDataBuffer, 0, dwLoaderDataSize);
|
|
|
|
if (!pBoot->GetEntryData(ENTRYLOADER,index,loaderDataBuffer)) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("ERROR: %s --> Get LoaderData Data failed", __func__);
|
2017-04-11 12:06:10 +02:00
|
|
|
}
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
|
|
|
|
usFlashDataSec = (ALIGN(dwLoaderDataSize, 2048)) / SECTOR_SIZE;
|
|
|
|
usFlashBootSec = (ALIGN(dwLoaderSize, 2048)) / SECTOR_SIZE;
|
|
|
|
dwSectorNum = 4 + usFlashDataSec + usFlashBootSec;
|
|
|
|
pIDBData = new BYTE[dwSectorNum*SECTOR_SIZE];
|
|
|
|
if (!pIDBData) {
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Allocating memory failed!");
|
2017-04-11 12:06:10 +02:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
memset(pIDBData, 0, dwSectorNum * SECTOR_SIZE);
|
2017-08-02 04:06:45 +02:00
|
|
|
iRet = MakeIDBlockData(loaderDataBuffer, loaderCodeBuffer, pIDBData, usFlashDataSec, usFlashBootSec, dwLoaderDataSize, dwLoaderSize, pBoot->Rc4DisableFlag);
|
2017-04-11 12:06:10 +02:00
|
|
|
if (iRet != 0) {
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Making idblock failed!");
|
2017-04-11 12:06:10 +02:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
iRet = pComm->RKU_WriteLBA(64, dwSectorNum, pIDBData);
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
if (iRet == ERR_SUCCESS) {
|
2017-08-02 04:06:45 +02:00
|
|
|
//pComm->Reset_Usb_Device();
|
2017-04-11 12:06:10 +02:00
|
|
|
bSuccess = true;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Upgrading loader succeeded.\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Upgrading loader failed!\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
goto Exit_UpgradeLoader;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Exit_UpgradeLoader:
|
|
|
|
if (pImage)
|
|
|
|
delete pImage;
|
|
|
|
if (pComm)
|
|
|
|
delete pComm;
|
|
|
|
if (loaderCodeBuffer)
|
|
|
|
delete []loaderCodeBuffer;
|
|
|
|
if (loaderDataBuffer)
|
|
|
|
delete []loaderDataBuffer;
|
|
|
|
if (pIDBData)
|
|
|
|
delete []pIDBData;
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-08-08 03:09:09 +02:00
|
|
|
bool print_gpt(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
u8 master_gpt[34 * SECTOR_SIZE];
|
|
|
|
gpt_header *gptHead = (gpt_header *)(master_gpt + SECTOR_SIZE);
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
gpt_entry *gptEntry = NULL;
|
|
|
|
u32 i,j;
|
|
|
|
u8 zerobuf[GPT_ENTRY_SIZE];
|
|
|
|
memset(zerobuf,0,GPT_ENTRY_SIZE);
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
char partName[36];
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
iRet = pComm->RKU_ReadLBA( 0, 34, master_gpt);
|
|
|
|
if(ERR_SUCCESS == iRet) {
|
|
|
|
if (gptHead->signature != le64_to_cpu(GPT_HEADER_SIGNATURE)) {
|
|
|
|
goto Exit_PrintGpt;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("Error: read gpt failed, err=%d", iRet);
|
|
|
|
printf("Read GPT failed!\r\n");
|
|
|
|
goto Exit_PrintGpt;
|
|
|
|
}
|
|
|
|
|
2018-03-28 03:22:40 +02:00
|
|
|
printf("**********Partition Info(GPT)**********\r\n");
|
2017-08-08 03:09:09 +02:00
|
|
|
printf("NO LBA Name \r\n");
|
|
|
|
for (i = 0; i < le32_to_cpu(gptHead->num_partition_entries); i++) {
|
|
|
|
gptEntry = (gpt_entry *)(master_gpt + 2 * SECTOR_SIZE + i * GPT_ENTRY_SIZE);
|
|
|
|
if (memcmp(zerobuf, (u8 *)gptEntry, GPT_ENTRY_SIZE) == 0)
|
|
|
|
break;
|
|
|
|
memset(partName, 0 , 36);
|
|
|
|
j = 0;
|
|
|
|
while (gptEntry->partition_name[j]) {
|
|
|
|
partName[j] = (char)gptEntry->partition_name[j];
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
printf("%02d %08X %s\r\n", i, (u32)le64_to_cpu(gptEntry->starting_lba), partName);
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
Exit_PrintGpt:
|
|
|
|
if (pComm)
|
|
|
|
delete pComm;
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2018-03-28 03:22:40 +02:00
|
|
|
bool print_parameter(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
u8 param_buf[512 * SECTOR_SIZE];
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
u32 i, nParamSize;
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
PARAM_ITEM_VECTOR vecParamItem;
|
|
|
|
CONFIG_ITEM_VECTOR vecUuidItem;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
iRet = pComm->RKU_ReadLBA( 0x2000, 512, param_buf);
|
|
|
|
if(ERR_SUCCESS == iRet) {
|
|
|
|
if (*(u32 *)param_buf != 0x4D524150) {
|
|
|
|
goto Exit_PrintParam;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("Error: read parameter failed, err=%d", iRet);
|
|
|
|
printf("Read parameter failed!\r\n");
|
|
|
|
goto Exit_PrintParam;
|
|
|
|
}
|
|
|
|
nParamSize = *(u32 *)(param_buf + 4);
|
|
|
|
memset(param_buf+8+nParamSize, 0, 512*SECTOR_SIZE - nParamSize - 8);
|
|
|
|
|
|
|
|
bRet = parse_parameter((char *)(param_buf+8), vecParamItem, vecUuidItem);
|
|
|
|
if (!bRet) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("Error: parse parameter failed");
|
|
|
|
printf("Parse parameter failed!\r\n");
|
|
|
|
goto Exit_PrintParam;
|
|
|
|
}
|
|
|
|
printf("**********Partition Info(parameter)**********\r\n");
|
|
|
|
printf("NO LBA Name \r\n");
|
|
|
|
for (i = 0; i < vecParamItem.size(); i++) {
|
|
|
|
printf("%02d %08X %s\r\n", i, vecParamItem[i].uiItemOffset, vecParamItem[i].szItemName);
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
Exit_PrintParam:
|
|
|
|
if (pComm)
|
|
|
|
delete pComm;
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-04-11 12:06:10 +02:00
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
bool erase_flash(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKImage *pImage = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
CRKScan *pScan = NULL;
|
|
|
|
pScan = new CRKScan();
|
|
|
|
pScan->SetVidPid();
|
|
|
|
|
|
|
|
CRKComm *pComm = NULL;
|
|
|
|
CRKDevice *pDevice = NULL;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (!bRet) {
|
|
|
|
if (pScan)
|
|
|
|
delete pScan;
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating Comm Object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
pDevice = new CRKDevice(dev);
|
|
|
|
if (!pDevice) {
|
|
|
|
if (pComm)
|
|
|
|
delete pComm;
|
|
|
|
if (pScan)
|
|
|
|
delete pScan;
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Creating device object failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
pDevice->SetObject(pImage, pComm, g_pLogObject);
|
|
|
|
pDevice->CallBackPointer = ProgressInfoProc;
|
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Starting to erase flash...\r\n");
|
2017-08-07 11:43:59 +02:00
|
|
|
bRet = pDevice->GetFlashInfo();
|
|
|
|
if (!bRet) {
|
|
|
|
if (pDevice)
|
|
|
|
delete pDevice;
|
|
|
|
if (pScan)
|
|
|
|
delete pScan;
|
|
|
|
ERROR_COLOR_ATTR;
|
|
|
|
printf("Getting flash info from device failed!");
|
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-03-07 09:12:52 +01:00
|
|
|
iRet = pDevice->EraseAllBlocks();
|
|
|
|
if (pDevice)
|
|
|
|
delete pDevice;
|
|
|
|
|
|
|
|
if (iRet == 0) {
|
|
|
|
if (pScan) {
|
|
|
|
pScan->SetVidPid();
|
|
|
|
pScan->Wait(dev, RKUSB_MASKROM, dev.usVid, dev.usPid);
|
|
|
|
delete pScan;
|
|
|
|
}
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
bSuccess = true;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Erasing flash complete.\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool test_device(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
iRet = pComm->RKU_TestDeviceReady();
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_TestDeviceReady failed, err=%d", iRet);
|
|
|
|
printf("Test Device failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else {
|
|
|
|
bSuccess = true;
|
|
|
|
printf("Test Device OK.\r\n");
|
|
|
|
}
|
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Test Device quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
bool reset_device(STRUCT_RKDEVICE_DESC &dev, BYTE subCode = RST_NONE_SUBCODE)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
iRet = pComm->RKU_ResetDevice(subCode);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_ResetDevice failed, err=%d", iRet);
|
|
|
|
printf("Reset Device failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else {
|
|
|
|
bSuccess = true;
|
|
|
|
printf("Reset Device OK.\r\n");
|
|
|
|
}
|
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Reset Device quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool read_flash_id(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return bSuccess;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
BYTE flashID[5];
|
|
|
|
iRet = pComm->RKU_ReadFlashID(flashID);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_ReadFlashID failed, err=%d", iRet);
|
|
|
|
printf("Reading flash ID failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Flash ID: %02X %02X %02X %02X %02X\r\n", flashID[0], flashID[1], flashID[2], flashID[3], flashID[4]);
|
2017-03-07 09:12:52 +01:00
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read Flash ID quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
bool read_flash_info(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return bSuccess;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
STRUCT_FLASHINFO_CMD info;
|
|
|
|
UINT uiRead;
|
|
|
|
iRet = pComm->RKU_ReadFlashInfo((BYTE *)&info, &uiRead);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_ReadFlashInfo failed, err=%d", iRet);
|
|
|
|
printf("Read Flash Info failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else {
|
|
|
|
printf("Flash Info:\r\n");
|
|
|
|
if (info.bManufCode <= 7) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("\tManufacturer: %s, value=%02X\r\n", szManufName[info.bManufCode], info.bManufCode);
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("\tManufacturer: %s, value=%02X\r\n", "Unknown", info.bManufCode);
|
2017-03-07 09:12:52 +01:00
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("\tFlash Size: %d MB\r\n", info.uiFlashSize / 2 / 1024);
|
|
|
|
printf("\tBlock Size: %d KB\r\n", info.usBlockSize / 2);
|
|
|
|
printf("\tPage Size: %d KB\r\n", info.bPageSize / 2);
|
2017-03-07 09:12:52 +01:00
|
|
|
printf("\tECC Bits: %d\r\n", info.bECCBits);
|
|
|
|
printf("\tAccess Time: %d\r\n", info.bAccessTime);
|
|
|
|
printf("\tFlash CS: ");
|
|
|
|
for(int i = 0; i < 8; i++) {
|
|
|
|
if( info.bFlashCS & (1 << i) )
|
|
|
|
printf("Flash<%d> ", i);
|
|
|
|
}
|
|
|
|
printf("\r\n");
|
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
}else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read Flash Info quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
bool read_chip_info(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return bSuccess;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
BYTE chipInfo[16];
|
|
|
|
iRet = pComm->RKU_ReadChipInfo(chipInfo);
|
|
|
|
if (iRet != ERR_SUCCESS) {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_ReadChipInfo failed, err=%d", iRet);
|
|
|
|
printf("Read Chip Info failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else {
|
|
|
|
string strChipInfo;
|
|
|
|
g_pLogObject->PrintBuffer(strChipInfo, chipInfo, 16, 16);
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Chip Info: %s\r\n", strChipInfo.c_str());
|
2017-03-07 09:12:52 +01:00
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read Chip Info quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2018-03-28 03:22:40 +02:00
|
|
|
bool read_capability(STRUCT_RKDEVICE_DESC &dev)
|
|
|
|
{
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return bSuccess;
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
|
|
|
|
BYTE capability[8];
|
|
|
|
iRet = pComm->RKU_ReadCapability(capability);
|
|
|
|
if (iRet != ERR_SUCCESS)
|
|
|
|
{
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("Error:read_capability failed,err=%d", iRet);
|
|
|
|
printf("Read capability Fail!\r\n");
|
|
|
|
} else {
|
|
|
|
printf("Capability:%02X %02X %02X %02X %02X %02X %02X %02X \r\n",
|
|
|
|
capability[0], capability[1], capability[2], capability[3],
|
|
|
|
capability[4], capability[5], capability[6], capability[7]);
|
|
|
|
if (capability[0] & 1)
|
|
|
|
{
|
|
|
|
printf("Direct LBA:\tenabled\r\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (capability[0] & 2)
|
|
|
|
{
|
|
|
|
printf("Vendor Storage:\tenabled\r\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (capability[0] & 4)
|
|
|
|
{
|
|
|
|
printf("First 4m Access:\tenabled\r\n");
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
printf("Read capability quit, creating comm object failed!\r\n");
|
|
|
|
}
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
bool read_param(STRUCT_RKDEVICE_DESC &dev, u8 *pParam)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
iRet = pComm->RKU_ReadLBA( 0x2000, 512, pParam);
|
|
|
|
if(ERR_SUCCESS == iRet) {
|
|
|
|
if (*(u32 *)pParam != 0x4D524150) {
|
|
|
|
goto Exit_ReadParam;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("Error: read parameter failed, err=%d", iRet);
|
|
|
|
printf("Read parameter failed!\r\n");
|
|
|
|
goto Exit_ReadParam;
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
Exit_ReadParam:
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-08-07 08:39:06 +02:00
|
|
|
bool read_gpt(STRUCT_RKDEVICE_DESC &dev, u8 *pGpt)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
gpt_header *gptHead = (gpt_header *)(pGpt + SECTOR_SIZE);
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
bool bRet, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
iRet = pComm->RKU_ReadLBA( 0, 34, pGpt);
|
|
|
|
if(ERR_SUCCESS == iRet) {
|
|
|
|
if (gptHead->signature != le64_to_cpu(GPT_HEADER_SIGNATURE)) {
|
|
|
|
goto Exit_ReadGPT;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject)
|
|
|
|
g_pLogObject->Record("Error: read gpt failed, err=%d", iRet);
|
|
|
|
printf("Read GPT failed!\r\n");
|
|
|
|
goto Exit_ReadGPT;
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
Exit_ReadGPT:
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-03-07 09:12:52 +01:00
|
|
|
bool read_lba(STRUCT_RKDEVICE_DESC &dev, UINT uiBegin, UINT uiLen, char *szFile)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
FILE *file = NULL;
|
|
|
|
bool bRet, bFirst = true, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
UINT iTotalRead = 0,iRead = 0;
|
|
|
|
int nSectorSize = 512;
|
|
|
|
BYTE pBuf[nSectorSize * DEFAULT_RW_LBA];
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
if(szFile) {
|
|
|
|
file = fopen(szFile, "wb+");
|
|
|
|
if( !file ) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read LBA failed, err=%d, can't open file: %s\r\n", errno, szFile);
|
2017-03-07 09:12:52 +01:00
|
|
|
goto Exit_ReadLBA;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while(uiLen > 0) {
|
|
|
|
memset(pBuf, 0, nSectorSize * DEFAULT_RW_LBA);
|
|
|
|
iRead = (uiLen >= DEFAULT_RW_LBA) ? DEFAULT_RW_LBA : uiLen;
|
|
|
|
iRet = pComm->RKU_ReadLBA( uiBegin + iTotalRead, iRead, pBuf);
|
|
|
|
if(ERR_SUCCESS == iRet) {
|
|
|
|
uiLen -= iRead;
|
|
|
|
iTotalRead += iRead;
|
|
|
|
|
|
|
|
if(szFile) {
|
|
|
|
fwrite(pBuf, 1, iRead * nSectorSize, file);
|
|
|
|
if (bFirst){
|
|
|
|
if (iTotalRead >= 1024)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read LBA to file (%d%%)\r\n", (iTotalRead / 1024) * 100 / ((uiLen + iTotalRead) / 1024));
|
2017-03-07 09:12:52 +01:00
|
|
|
else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read LBA to file (%d%%)\r\n", iTotalRead * 100 / (uiLen + iTotalRead));
|
2017-03-07 09:12:52 +01:00
|
|
|
bFirst = false;
|
|
|
|
} else {
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
if (iTotalRead >= 1024)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read LBA to file (%d%%)\r\n", (iTotalRead / 1024) * 100 / ((uiLen + iTotalRead) / 1024));
|
2017-03-07 09:12:52 +01:00
|
|
|
else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read LBA to file (%d%%)\r\n", iTotalRead * 100 / (uiLen + iTotalRead));
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
PrintData(pBuf, nSectorSize * iRead);
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_ReadLBA failed, err=%d", iRet);
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
printf("Read LBA failed!\r\n");
|
|
|
|
goto Exit_ReadLBA;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Read LBA quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
Exit_ReadLBA:
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
if (file)
|
|
|
|
fclose(file);
|
|
|
|
return bSuccess;
|
|
|
|
}
|
2017-08-07 08:39:06 +02:00
|
|
|
bool erase_partition(CRKUsbComm *pComm, UINT uiOffset, UINT uiSize)
|
|
|
|
{
|
2017-11-15 05:01:30 +01:00
|
|
|
UINT uiErase=1024*32;
|
2017-08-07 08:39:06 +02:00
|
|
|
bool bSuccess = true;
|
|
|
|
int iRet;
|
|
|
|
while (uiSize)
|
|
|
|
{
|
|
|
|
if (uiSize>=uiErase)
|
|
|
|
{
|
|
|
|
iRet = pComm->RKU_EraseLBA(uiOffset,uiErase);
|
|
|
|
uiSize -= uiErase;
|
|
|
|
uiOffset += uiErase;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
iRet = pComm->RKU_EraseLBA(uiOffset,uiSize);
|
|
|
|
uiSize = 0;
|
|
|
|
uiOffset += uiSize;
|
|
|
|
}
|
|
|
|
if (iRet!=ERR_SUCCESS)
|
|
|
|
{
|
|
|
|
if (g_pLogObject)
|
|
|
|
{
|
|
|
|
g_pLogObject->Record("ERROR:erase_partition failed,err=%d",iRet);
|
|
|
|
}
|
|
|
|
bSuccess = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
|
|
|
|
}
|
|
|
|
bool EatSparseChunk(FILE *file, chunk_header &chunk)
|
|
|
|
{
|
|
|
|
UINT uiRead;
|
|
|
|
uiRead = fread(&chunk, 1, sizeof(chunk_header), file);
|
|
|
|
if (uiRead != sizeof(chunk_header)) {
|
|
|
|
if (g_pLogObject)
|
|
|
|
{
|
|
|
|
g_pLogObject->Record("Error:EatSparseChunk failed,err=%d", errno);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool EatSparseData(FILE *file, PBYTE pBuf, DWORD dwSize)
|
|
|
|
{
|
|
|
|
UINT uiRead;
|
|
|
|
uiRead = fread(pBuf, 1, dwSize, file);
|
|
|
|
if (uiRead!=dwSize)
|
|
|
|
{
|
|
|
|
if (g_pLogObject)
|
|
|
|
{
|
|
|
|
g_pLogObject->Record("Error:EatSparseData failed,err=%d",errno);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool write_sparse_lba(STRUCT_RKDEVICE_DESC &dev, UINT uiBegin, UINT uiSize, char *szFile)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
FILE *file = NULL;
|
|
|
|
bool bRet, bSuccess = false, bFirst = true;
|
|
|
|
int iRet;
|
|
|
|
u64 iTotalWrite = 0, iFileSize = 0;
|
|
|
|
UINT iRead = 0, uiTransferSec, curChunk, i;
|
|
|
|
UINT dwChunkDataSize, dwMaxReadWriteBytes, dwTransferBytes, dwFillByte, dwCrc;
|
|
|
|
BYTE pBuf[SECTOR_SIZE * DEFAULT_RW_LBA];
|
|
|
|
sparse_header header;
|
|
|
|
chunk_header chunk;
|
|
|
|
dwMaxReadWriteBytes = DEFAULT_RW_LBA * SECTOR_SIZE;
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
2017-11-15 05:01:30 +01:00
|
|
|
|
2017-08-07 08:39:06 +02:00
|
|
|
file = fopen(szFile, "rb");
|
|
|
|
if( !file ) {
|
|
|
|
printf("%s failed, err=%d, can't open file: %s\r\n", __func__, errno, szFile);
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
fseeko(file, 0, SEEK_SET);
|
|
|
|
iRead = fread(&header, 1, sizeof(header), file);
|
|
|
|
if (iRead != sizeof(sparse_header))
|
|
|
|
{
|
|
|
|
if (g_pLogObject)
|
|
|
|
{
|
|
|
|
g_pLogObject->Record("ERROR:%s-->read sparse header failed,file=%s,err=%d", __func__, szFile, errno);
|
|
|
|
}
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
iFileSize = header.blk_sz * (u64)header.total_blks;
|
|
|
|
iTotalWrite = 0;
|
|
|
|
curChunk = 0;
|
2017-11-15 05:01:30 +01:00
|
|
|
if (uiSize==(u32)-1)
|
|
|
|
uiSize = ALIGN(iFileSize, SECTOR_SIZE);
|
|
|
|
bRet = erase_partition(pComm, uiBegin, uiSize);
|
|
|
|
if (!bRet) {
|
|
|
|
printf("%s failed, erase partition error\r\n", __func__);
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
2017-08-07 08:39:06 +02:00
|
|
|
while(curChunk < header.total_chunks)
|
|
|
|
{
|
|
|
|
if (!EatSparseChunk(file, chunk)) {
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
curChunk++;
|
|
|
|
switch (chunk.chunk_type) {
|
|
|
|
case CHUNK_TYPE_RAW:
|
|
|
|
dwChunkDataSize = chunk.total_sz - sizeof(chunk_header);
|
|
|
|
while (dwChunkDataSize) {
|
|
|
|
memset(pBuf, 0, dwMaxReadWriteBytes);
|
|
|
|
if (dwChunkDataSize >= dwMaxReadWriteBytes) {
|
|
|
|
dwTransferBytes = dwMaxReadWriteBytes;
|
|
|
|
uiTransferSec = DEFAULT_RW_LBA;
|
|
|
|
} else {
|
|
|
|
dwTransferBytes = dwChunkDataSize;
|
|
|
|
uiTransferSec = ((dwTransferBytes % SECTOR_SIZE == 0) ? (dwTransferBytes / SECTOR_SIZE) : (dwTransferBytes / SECTOR_SIZE + 1));
|
|
|
|
}
|
|
|
|
if (!EatSparseData(file, pBuf, dwTransferBytes)) {
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
iRet = pComm->RKU_WriteLBA(uiBegin, uiTransferSec, pBuf);
|
|
|
|
if( ERR_SUCCESS == iRet ) {
|
|
|
|
dwChunkDataSize -= dwTransferBytes;
|
|
|
|
iTotalWrite += dwTransferBytes;
|
|
|
|
uiBegin += uiTransferSec;
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject) {
|
|
|
|
g_pLogObject->Record("ERROR:%s-->RKU_WriteLBA failed,Written(%d),RetCode(%d)", __func__, iTotalWrite, iRet);
|
|
|
|
}
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
if (bFirst) {
|
|
|
|
if (iTotalWrite >= 1024)
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
else
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", iTotalWrite * 100 / iFileSize);
|
|
|
|
bFirst = false;
|
|
|
|
} else {
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHUNK_TYPE_FILL:
|
|
|
|
dwChunkDataSize = chunk.chunk_sz * header.blk_sz;
|
|
|
|
if (!EatSparseData(file, (PBYTE)&dwFillByte, 4)) {
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
while (dwChunkDataSize) {
|
|
|
|
memset(pBuf, 0, dwMaxReadWriteBytes);
|
|
|
|
if (dwChunkDataSize >= dwMaxReadWriteBytes) {
|
|
|
|
dwTransferBytes = dwMaxReadWriteBytes;
|
|
|
|
uiTransferSec = DEFAULT_RW_LBA;
|
|
|
|
} else {
|
|
|
|
dwTransferBytes = dwChunkDataSize;
|
|
|
|
uiTransferSec = ((dwTransferBytes % SECTOR_SIZE == 0) ? (dwTransferBytes / SECTOR_SIZE) : (dwTransferBytes / SECTOR_SIZE + 1));
|
|
|
|
}
|
|
|
|
for (i = 0; i < dwTransferBytes / 4; i++) {
|
|
|
|
*(DWORD *)(pBuf + i * 4) = dwFillByte;
|
|
|
|
}
|
|
|
|
iRet = pComm->RKU_WriteLBA(uiBegin, uiTransferSec, pBuf);
|
|
|
|
if( ERR_SUCCESS == iRet ) {
|
|
|
|
dwChunkDataSize -= dwTransferBytes;
|
|
|
|
iTotalWrite += dwTransferBytes;
|
|
|
|
uiBegin += uiTransferSec;
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject) {
|
|
|
|
g_pLogObject->Record("ERROR:%s-->RKU_WriteLBA failed,Written(%d),RetCode(%d)" ,__func__, iTotalWrite, iRet);
|
|
|
|
}
|
|
|
|
goto Exit_WriteSparseLBA;
|
|
|
|
}
|
|
|
|
if (bFirst) {
|
|
|
|
if (iTotalWrite >= 1024)
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
else
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", iTotalWrite * 100 / iFileSize);
|
|
|
|
bFirst = false;
|
|
|
|
} else {
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHUNK_TYPE_DONT_CARE:
|
|
|
|
dwChunkDataSize = chunk.chunk_sz * header.blk_sz;
|
|
|
|
iTotalWrite += dwChunkDataSize;
|
|
|
|
uiTransferSec = ((dwChunkDataSize % SECTOR_SIZE == 0) ? (dwChunkDataSize / SECTOR_SIZE) : (dwChunkDataSize / SECTOR_SIZE + 1));
|
|
|
|
uiBegin += uiTransferSec;
|
|
|
|
if (bFirst) {
|
|
|
|
if (iTotalWrite >= 1024)
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
else
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", iTotalWrite * 100 / iFileSize);
|
|
|
|
bFirst = false;
|
|
|
|
} else {
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHUNK_TYPE_CRC32:
|
|
|
|
EatSparseData(file,(PBYTE)&dwCrc,4);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
} else {
|
|
|
|
printf("Write LBA quit, creating comm object failed!\r\n");
|
|
|
|
}
|
|
|
|
Exit_WriteSparseLBA:
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
if (file)
|
|
|
|
fclose(file);
|
|
|
|
return bSuccess;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
bool write_lba(STRUCT_RKDEVICE_DESC &dev, UINT uiBegin, char *szFile)
|
|
|
|
{
|
|
|
|
if (!check_device_type(dev, RKUSB_LOADER | RKUSB_MASKROM))
|
|
|
|
return false;
|
|
|
|
CRKUsbComm *pComm = NULL;
|
|
|
|
FILE *file = NULL;
|
|
|
|
bool bRet, bFirst = true, bSuccess = false;
|
|
|
|
int iRet;
|
|
|
|
long long iTotalWrite = 0, iFileSize = 0;
|
|
|
|
UINT iWrite = 0, iRead = 0;
|
|
|
|
UINT uiLen;
|
|
|
|
int nSectorSize = 512;
|
|
|
|
BYTE pBuf[nSectorSize * DEFAULT_RW_LBA];
|
|
|
|
|
|
|
|
pComm = new CRKUsbComm(dev, g_pLogObject, bRet);
|
|
|
|
if (bRet) {
|
|
|
|
file = fopen(szFile, "rb");
|
|
|
|
if( !file ) {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Write LBA failed, err=%d, can't open file: %s\r\n", errno, szFile);
|
2017-03-07 09:12:52 +01:00
|
|
|
goto Exit_WriteLBA;
|
|
|
|
}
|
|
|
|
|
|
|
|
iRet = fseeko(file, 0, SEEK_END);
|
|
|
|
iFileSize = ftello(file);
|
|
|
|
fseeko(file, 0, SEEK_SET);
|
|
|
|
while(iTotalWrite < iFileSize) {
|
|
|
|
memset(pBuf, 0, nSectorSize * DEFAULT_RW_LBA);
|
|
|
|
iWrite = iRead= fread(pBuf, 1, nSectorSize * DEFAULT_RW_LBA, file);
|
|
|
|
uiLen = ((iWrite % 512) == 0) ? (iWrite / 512) : (iWrite / 512 + 1);
|
|
|
|
iRet = pComm->RKU_WriteLBA( uiBegin, uiLen, pBuf);
|
|
|
|
if(ERR_SUCCESS == iRet) {
|
|
|
|
uiBegin += uiLen;
|
|
|
|
iTotalWrite += iWrite;
|
|
|
|
if (bFirst) {
|
|
|
|
if (iTotalWrite >= 1024)
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Write LBA from file (%lld%%)\r\n", iTotalWrite * 100 / iFileSize);
|
2017-03-07 09:12:52 +01:00
|
|
|
bFirst = false;
|
|
|
|
} else {
|
|
|
|
CURSOR_MOVEUP_LINE(1);
|
|
|
|
CURSOR_DEL_LINE;
|
|
|
|
printf("Write LBA from file (%lld%%)\r\n", (iTotalWrite / 1024) * 100 / (iFileSize / 1024));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (g_pLogObject)
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: RKU_WriteLBA failed, err=%d", iRet);
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
printf("Write LBA failed!\r\n");
|
|
|
|
goto Exit_WriteLBA;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bSuccess = true;
|
|
|
|
} else {
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Write LBA quit, creating comm object failed!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
Exit_WriteLBA:
|
|
|
|
if (pComm) {
|
|
|
|
delete pComm;
|
|
|
|
pComm = NULL;
|
|
|
|
}
|
|
|
|
if (file)
|
|
|
|
fclose(file);
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
void split_item(STRING_VECTOR &vecItems, char *pszItems)
|
|
|
|
{
|
|
|
|
string strItem;
|
|
|
|
char szItem[100];
|
|
|
|
char *pos = NULL, *pStart;
|
|
|
|
pStart = pszItems;
|
|
|
|
pos = strchr(pStart, ',');
|
|
|
|
while(pos != NULL) {
|
|
|
|
memset(szItem, 0, 100);
|
|
|
|
strncpy(szItem, pStart, pos - pStart);
|
|
|
|
strItem = szItem;
|
|
|
|
vecItems.push_back(strItem);
|
|
|
|
pStart = pos + 1;
|
|
|
|
if (*pStart == 0)
|
|
|
|
break;
|
|
|
|
pos = strchr(pStart, ',');
|
|
|
|
}
|
|
|
|
if (strlen(pStart) > 0) {
|
|
|
|
memset(szItem, 0, 100);
|
|
|
|
strncpy(szItem, pStart, strlen(pStart));
|
|
|
|
strItem = szItem;
|
|
|
|
vecItems.push_back(strItem);
|
|
|
|
}
|
|
|
|
}
|
2017-04-11 12:06:10 +02:00
|
|
|
|
2017-04-18 05:06:59 +02:00
|
|
|
void tag_spl(char *tag, char *spl)
|
|
|
|
{
|
|
|
|
FILE *file = NULL;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if(!tag || !spl)
|
|
|
|
return;
|
|
|
|
len = strlen(tag);
|
|
|
|
printf("tag len=%d\n",len);
|
|
|
|
file = fopen(spl, "rb");
|
|
|
|
if( !file ){
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
int iFileSize;
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
iFileSize = ftell(file);
|
|
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
char *Buf = NULL;
|
|
|
|
Buf = new char[iFileSize + len + 1];
|
|
|
|
if (!Buf){
|
|
|
|
fclose(file);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memset(Buf, 0, iFileSize + 1);
|
|
|
|
memcpy(Buf, tag, len);
|
|
|
|
int iRead;
|
|
|
|
iRead = fread(Buf+len, 1, iFileSize, file);
|
|
|
|
if (iRead != iFileSize){
|
|
|
|
fclose(file);
|
|
|
|
delete []Buf;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
len = strlen(spl);
|
2017-05-14 19:38:49 +02:00
|
|
|
char *taggedspl = new char[len + 5];
|
|
|
|
strcpy(taggedspl, spl);
|
|
|
|
strcpy(taggedspl + len, ".tag");
|
|
|
|
taggedspl[len+4] = 0;
|
|
|
|
printf("Writing tagged spl to %s\n", taggedspl);
|
2017-04-18 05:06:59 +02:00
|
|
|
|
2017-05-14 19:38:49 +02:00
|
|
|
file = fopen(taggedspl, "wb");
|
2017-04-18 05:06:59 +02:00
|
|
|
if( !file ){
|
2017-05-14 19:38:49 +02:00
|
|
|
delete []taggedspl;
|
2017-04-18 05:06:59 +02:00
|
|
|
delete []Buf;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fwrite(Buf, 1, iFileSize+len, file);
|
|
|
|
fclose(file);
|
2017-05-14 19:38:49 +02:00
|
|
|
delete []taggedspl;
|
2017-04-18 05:06:59 +02:00
|
|
|
delete []Buf;
|
|
|
|
printf("done\n");
|
|
|
|
return;
|
|
|
|
}
|
2018-03-28 03:22:40 +02:00
|
|
|
void list_device(CRKScan *pScan)
|
|
|
|
{
|
|
|
|
STRUCT_RKDEVICE_DESC desc;
|
|
|
|
string strDevType;
|
|
|
|
int i,cnt;
|
|
|
|
cnt = pScan->DEVICE_COUNTS;
|
|
|
|
if (cnt == 0) {
|
|
|
|
printf("not found any devices!\r\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i=0;i<cnt;i++)
|
|
|
|
{
|
|
|
|
pScan->GetDevice(desc, i);
|
|
|
|
if (desc.emUsbType==RKUSB_MASKROM)
|
|
|
|
strDevType = "Maskrom";
|
|
|
|
else if (desc.emUsbType==RKUSB_LOADER)
|
|
|
|
strDevType = "Loader";
|
|
|
|
else
|
|
|
|
strDevType = "Unknown";
|
|
|
|
printf("DevNo=%d\tVid=0x%x,Pid=0x%x,LocationID=%x\t%s\r\n",i+1,desc.usVid,
|
|
|
|
desc.usPid,desc.uiLocationID,strDevType.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-04-18 05:06:59 +02:00
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
bool handle_command(int argc, char* argv[], CRKScan *pScan)
|
|
|
|
{
|
|
|
|
string strCmd;
|
|
|
|
strCmd = argv[1];
|
|
|
|
ssize_t cnt;
|
|
|
|
bool bRet,bSuccess = false;
|
2017-04-16 15:39:58 +02:00
|
|
|
char *s;
|
|
|
|
int i, ret;
|
2017-03-07 09:12:52 +01:00
|
|
|
STRUCT_RKDEVICE_DESC dev;
|
2018-03-28 03:22:40 +02:00
|
|
|
u8 master_gpt[34 * SECTOR_SIZE], param_buffer[512 * SECTOR_SIZE];
|
2017-08-07 08:39:06 +02:00
|
|
|
u64 lba, lba_end;
|
2018-03-28 03:22:40 +02:00
|
|
|
u32 part_size, part_offset;
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
transform(strCmd.begin(), strCmd.end(), strCmd.begin(), (int(*)(int))toupper);
|
2017-04-16 15:39:58 +02:00
|
|
|
s = (char*)strCmd.c_str();
|
|
|
|
for(i = 0; i < (int)strlen(s); i++)
|
|
|
|
s[i] = toupper(s[i]);
|
2017-04-17 12:42:08 +02:00
|
|
|
|
2017-04-16 15:39:58 +02:00
|
|
|
if((strcmp(strCmd.c_str(), "-H") == 0) || (strcmp(strCmd.c_str(), "--HELP")) == 0){
|
2017-03-07 09:12:52 +01:00
|
|
|
usage();
|
|
|
|
return true;
|
2017-04-16 15:39:58 +02:00
|
|
|
} else if((strcmp(strCmd.c_str(), "-V") == 0) || (strcmp(strCmd.c_str(), "--VERSION") == 0)) {
|
2017-04-11 12:06:10 +02:00
|
|
|
printf("rkdeveloptool ver %s\r\n", PACKAGE_VERSION);
|
2017-03-07 09:12:52 +01:00
|
|
|
return true;
|
2017-04-17 12:42:08 +02:00
|
|
|
} else if (strcmp(strCmd.c_str(), "PACK") == 0) {//pack boot loader
|
|
|
|
mergeBoot();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else if (strcmp(strCmd.c_str(), "UNPACK") == 0) {//unpack boot loader
|
|
|
|
string strLoader = argv[2];
|
|
|
|
|
|
|
|
unpackBoot((char*)strLoader.c_str());
|
|
|
|
return true;
|
2017-04-18 05:06:59 +02:00
|
|
|
} else if (strcmp(strCmd.c_str(), "TAGSPL") == 0) {//tag u-boot spl
|
|
|
|
if (argc == 4) {
|
|
|
|
string tag = argv[2];
|
|
|
|
string spl = argv[3];
|
|
|
|
printf("tag %s to %s\n", tag.c_str(), spl.c_str());
|
|
|
|
tag_spl((char*)tag.c_str(), (char*)spl.c_str());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
printf("tagspl: parameter error\n");
|
|
|
|
usage();
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
cnt = pScan->Search(RKUSB_MASKROM | RKUSB_LOADER);
|
2018-03-28 03:22:40 +02:00
|
|
|
if(strcmp(strCmd.c_str(), "LD") == 0) {
|
|
|
|
list_device(pScan);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-03-07 09:12:52 +01:00
|
|
|
if (cnt < 1) {
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Did not find any rockusb device, please plug device in!");
|
2017-03-07 09:12:52 +01:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
} else if (cnt > 1) {
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Found too many rockusb devices, please plug devices out!");
|
2017-03-07 09:12:52 +01:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
bRet = pScan->GetDevice(dev, 0);
|
|
|
|
if (!bRet) {
|
|
|
|
ERROR_COLOR_ATTR;
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Getting information about rockusb device failed!");
|
2017-03-07 09:12:52 +01:00
|
|
|
NORMAL_COLOR_ATTR;
|
|
|
|
printf("\r\n");
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(strcmp(strCmd.c_str(), "RD") == 0) {
|
|
|
|
if ((argc != 2) && (argc != 3))
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [RD] command is invalid, please check help!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
else {
|
|
|
|
if (argc == 2)
|
|
|
|
bSuccess = reset_device(dev);
|
|
|
|
else {
|
|
|
|
UINT uiSubCode;
|
|
|
|
char *pszEnd;
|
|
|
|
uiSubCode = strtoul(argv[2], &pszEnd, 0);
|
|
|
|
if (*pszEnd)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Subcode is invalid, please check!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
else {
|
|
|
|
if (uiSubCode <= 5)
|
|
|
|
bSuccess = reset_device(dev, uiSubCode);
|
|
|
|
else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Subcode is invalid, please check!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if(strcmp(strCmd.c_str(), "TD") == 0) {
|
|
|
|
bSuccess = test_device(dev);
|
|
|
|
} else if (strcmp(strCmd.c_str(), "RID") == 0) {//Read Flash ID
|
|
|
|
bSuccess = read_flash_id(dev);
|
|
|
|
} else if (strcmp(strCmd.c_str(), "RFI") == 0){//Read Flash Info
|
|
|
|
bSuccess = read_flash_info(dev);
|
|
|
|
} else if (strcmp(strCmd.c_str(), "RCI") == 0) {//Read Chip Info
|
|
|
|
bSuccess = read_chip_info(dev);
|
2018-03-28 03:22:40 +02:00
|
|
|
} else if (strcmp(strCmd.c_str(), "RCB") == 0) {//Read Capability
|
|
|
|
bSuccess = read_capability(dev);
|
2017-03-07 09:12:52 +01:00
|
|
|
} else if(strcmp(strCmd.c_str(), "DB") == 0) {
|
|
|
|
if (argc > 2) {
|
|
|
|
string strLoader;
|
|
|
|
strLoader = argv[2];
|
|
|
|
bSuccess = download_boot(dev, (char *)strLoader.c_str());
|
|
|
|
} else if (argc == 2) {
|
2017-08-04 10:29:29 +02:00
|
|
|
ret = find_config_item(g_ConfigItemVec, "loader");
|
2017-03-07 09:12:52 +01:00
|
|
|
if (ret == -1)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Did not find loader item in config!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
else
|
|
|
|
bSuccess = download_boot(dev, g_ConfigItemVec[ret].szItemValue);
|
|
|
|
} else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [DB] command is invalid, please check help!\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
} else if(strcmp(strCmd.c_str(), "GPT") == 0) {
|
|
|
|
if (argc > 2) {
|
|
|
|
string strParameter;
|
|
|
|
strParameter = argv[2];
|
|
|
|
bSuccess = write_gpt(dev, (char *)strParameter.c_str());
|
|
|
|
} else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [GPT] command is invalid, please check help!\r\n");
|
2018-03-28 03:22:40 +02:00
|
|
|
} else if(strcmp(strCmd.c_str(), "PRM") == 0) {
|
|
|
|
if (argc > 2) {
|
|
|
|
string strParameter;
|
|
|
|
strParameter = argv[2];
|
|
|
|
bSuccess = write_parameter(dev, (char *)strParameter.c_str());
|
|
|
|
} else
|
|
|
|
printf("Parameter of [PRM] command is invalid, please check help!\r\n");
|
2017-04-11 12:06:10 +02:00
|
|
|
} else if(strcmp(strCmd.c_str(), "UL") == 0) {
|
|
|
|
if (argc > 2) {
|
|
|
|
string strLoader;
|
|
|
|
strLoader = argv[2];
|
|
|
|
bSuccess = upgrade_loader(dev, (char *)strLoader.c_str());
|
|
|
|
} else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [UL] command is invalid, please check help!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else if(strcmp(strCmd.c_str(), "EF") == 0) {
|
|
|
|
if (argc == 2) {
|
|
|
|
bSuccess = erase_flash(dev);
|
|
|
|
} else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [EF] command is invalid, please check help!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else if(strcmp(strCmd.c_str(), "WL") == 0) {
|
|
|
|
if (argc == 4) {
|
|
|
|
UINT uiBegin;
|
|
|
|
char *pszEnd;
|
|
|
|
uiBegin = strtoul(argv[2], &pszEnd, 0);
|
|
|
|
if (*pszEnd)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Begin is invalid, please check!\r\n");
|
2017-11-15 05:01:30 +01:00
|
|
|
else {
|
|
|
|
if (is_sparse_image(argv[3]))
|
|
|
|
bSuccess = write_sparse_lba(dev, (u32)uiBegin, (u32)-1, argv[3]);
|
|
|
|
else
|
|
|
|
bSuccess = write_lba(dev, (u32)uiBegin, argv[3]);
|
|
|
|
}
|
2017-03-07 09:12:52 +01:00
|
|
|
} else
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [WL] command is invalid, please check help!\r\n");
|
2017-08-07 08:39:06 +02:00
|
|
|
} else if(strcmp(strCmd.c_str(), "WLX") == 0) {
|
|
|
|
if (argc == 4) {
|
|
|
|
bRet = read_gpt(dev, master_gpt);
|
|
|
|
if (bRet) {
|
|
|
|
bRet = get_lba_from_gpt(master_gpt, argv[2], &lba, &lba_end);
|
|
|
|
if (bRet) {
|
|
|
|
if (is_sparse_image(argv[3]))
|
|
|
|
bSuccess = write_sparse_lba(dev, (u32)lba, (u32)(lba_end - lba + 1), argv[3]);
|
|
|
|
else
|
|
|
|
bSuccess = write_lba(dev, (u32)lba, argv[3]);
|
|
|
|
} else
|
|
|
|
printf("No found %s partition\r\n", argv[2]);
|
2018-03-28 03:22:40 +02:00
|
|
|
} else {
|
|
|
|
bRet = read_param(dev, param_buffer);
|
|
|
|
if (bRet) {
|
|
|
|
bRet = get_lba_from_param(param_buffer+8, argv[2], &part_offset, &part_size);
|
|
|
|
if (bRet) {
|
|
|
|
if (is_sparse_image(argv[3]))
|
|
|
|
bSuccess = write_sparse_lba(dev, part_offset, part_size, argv[3]);
|
|
|
|
else
|
|
|
|
bSuccess = write_lba(dev, part_offset, argv[3]);
|
|
|
|
} else
|
|
|
|
printf("No found %s partition\r\n", argv[2]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
printf("Not found any partition table!\r\n");
|
|
|
|
}
|
|
|
|
|
2017-08-07 08:39:06 +02:00
|
|
|
} else
|
|
|
|
printf("Parameter of [WLX] command is invalid, please check help!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else if (strcmp(strCmd.c_str(), "RL") == 0) {//Read LBA
|
|
|
|
char *pszEnd;
|
|
|
|
UINT uiBegin, uiLen;
|
|
|
|
if (argc != 5)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Parameter of [RL] command is invalid, please check help!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
else {
|
|
|
|
uiBegin = strtoul(argv[2], &pszEnd, 0);
|
|
|
|
if (*pszEnd)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Begin is invalid, please check!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
else {
|
|
|
|
uiLen = strtoul(argv[3], &pszEnd, 0);
|
|
|
|
if (*pszEnd)
|
2017-05-14 19:38:49 +02:00
|
|
|
printf("Len is invalid, please check!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
else {
|
|
|
|
bSuccess = read_lba(dev, uiBegin, uiLen, argv[4]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-03-28 03:22:40 +02:00
|
|
|
} else if(strcmp(strCmd.c_str(), "PPT") == 0) {
|
2017-08-08 03:09:09 +02:00
|
|
|
if (argc == 2) {
|
|
|
|
bSuccess = print_gpt(dev);
|
2018-03-28 03:22:40 +02:00
|
|
|
if (!bSuccess) {
|
|
|
|
bSuccess = print_parameter(dev);
|
|
|
|
if (!bSuccess)
|
|
|
|
printf("Not found any partition table!\r\n");
|
|
|
|
}
|
2017-08-08 03:09:09 +02:00
|
|
|
} else
|
2018-03-28 03:22:40 +02:00
|
|
|
printf("Parameter of [PPT] command is invalid, please check help!\r\n");
|
2017-03-07 09:12:52 +01:00
|
|
|
} else {
|
2017-05-14 19:47:34 +02:00
|
|
|
printf("command is invalid!\r\n");
|
|
|
|
usage();
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int main(int argc, char* argv[])
|
|
|
|
{
|
|
|
|
CRKScan *pScan = NULL;
|
|
|
|
int ret;
|
|
|
|
char szProgramProcPath[100];
|
|
|
|
char szProgramDir[256];
|
|
|
|
string strLogDir,strConfigFile;
|
|
|
|
struct stat statBuf;
|
|
|
|
|
|
|
|
g_ConfigItemVec.clear();
|
|
|
|
sprintf(szProgramProcPath, "/proc/%d/exe", getpid());
|
|
|
|
if (readlink(szProgramProcPath, szProgramDir, 256) == -1)
|
|
|
|
strcpy(szProgramDir, ".");
|
|
|
|
else {
|
|
|
|
char *pSlash;
|
|
|
|
pSlash = strrchr(szProgramDir, '/');
|
|
|
|
if (pSlash)
|
|
|
|
*pSlash = '\0';
|
|
|
|
}
|
|
|
|
strLogDir = szProgramDir;
|
|
|
|
strLogDir += "/log/";
|
|
|
|
strConfigFile = szProgramDir;
|
|
|
|
strConfigFile += "/config.ini";
|
|
|
|
if (opendir(strLogDir.c_str()) == NULL)
|
|
|
|
mkdir(strLogDir.c_str(), S_IRWXU | S_IRWXG | S_IROTH);
|
2017-04-25 03:20:40 +02:00
|
|
|
g_pLogObject = new CRKLog(strLogDir.c_str(), "log",true);
|
2017-03-07 09:12:52 +01:00
|
|
|
|
|
|
|
if(stat(strConfigFile.c_str(), &statBuf) < 0) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: failed to stat config.ini, err=%d", errno);
|
2017-03-07 09:12:52 +01:00
|
|
|
}
|
|
|
|
} else if (S_ISREG(statBuf.st_mode)) {
|
|
|
|
parse_config_file(strConfigFile.c_str(), g_ConfigItemVec);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = libusb_init(NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: libusb_init failed, err=%d", ret);
|
2017-03-07 09:12:52 +01:00
|
|
|
delete g_pLogObject;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
pScan = new CRKScan();
|
|
|
|
if (!pScan) {
|
|
|
|
if (g_pLogObject) {
|
2017-05-14 19:38:49 +02:00
|
|
|
g_pLogObject->Record("Error: failed to create object for searching device");
|
2017-03-07 09:12:52 +01:00
|
|
|
delete g_pLogObject;
|
|
|
|
}
|
|
|
|
libusb_exit(NULL);
|
|
|
|
return -2;
|
|
|
|
}
|
|
|
|
pScan->SetVidPid();
|
|
|
|
|
|
|
|
if (argc == 1)
|
|
|
|
usage();
|
|
|
|
else if (!handle_command(argc, argv, pScan))
|
|
|
|
return -0xFF;
|
|
|
|
if (pScan)
|
|
|
|
delete pScan;
|
|
|
|
if (g_pLogObject)
|
|
|
|
delete g_pLogObject;
|
|
|
|
libusb_exit(NULL);
|
|
|
|
return 0;
|
|
|
|
}
|