|
|
/*
|
|
|
* Copyright 2019 Rockchip Electronics Co., Ltd
|
|
|
* Dayao Ji <jdy@rock-chips.com>
|
|
|
*
|
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
|
*/
|
|
|
|
|
|
#include "rkupdate/RKComm.h"
|
|
|
#include "rkupdate/RKLog.h"
|
|
|
#include "rkupdate/RKAndroidDevice.h"
|
|
|
#include <cinttypes>
|
|
|
|
|
|
|
|
|
CRKComm::CRKComm(CRKLog *pLog)
|
|
|
{
|
|
|
m_log = pLog;
|
|
|
m_bEmmc = false;
|
|
|
m_hDev = m_hLbaDev = -1;
|
|
|
}
|
|
|
CRKComm::~CRKComm()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
CRKUsbComm::CRKUsbComm(CRKLog *pLog):CRKComm(pLog)
|
|
|
{
|
|
|
//char bootmode[100];
|
|
|
//property_get("ro.bootmode", bootmode, "unknown");
|
|
|
//if(!strcmp(bootmode, "emmc"))
|
|
|
// m_bEmmc = true;
|
|
|
//else
|
|
|
// m_bEmmc = false;
|
|
|
char *emmc_point = getenv(EMMC_POINT_NAME);
|
|
|
pLog->Record(_T("INFO:emmc_point-->is %s"),emmc_point);
|
|
|
m_hLbaDev = open(emmc_point, O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0){
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:is nand devices..."));
|
|
|
m_bEmmc = false;
|
|
|
}else{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:is emmc devices..."));
|
|
|
m_bEmmc = true;
|
|
|
long long filelen= lseek(m_hLbaDev,0L,SEEK_END);
|
|
|
lseek(m_hLbaDev,0L,SEEK_SET);
|
|
|
printf("flashSize is %lld\n",filelen);
|
|
|
m_FlashSize = filelen;
|
|
|
close(m_hLbaDev);
|
|
|
}
|
|
|
|
|
|
if (m_bEmmc)
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm-->is emmc."));
|
|
|
m_hDev = open(EMMC_DRIVER_DEV_VENDOR,O_RDWR,0);
|
|
|
if (m_hDev<0)
|
|
|
{
|
|
|
if (pLog){
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%s"),EMMC_DRIVER_DEV_VENDOR, strerror(errno));
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->try to read %s."),EMMC_DRIVER_DEV);
|
|
|
}
|
|
|
|
|
|
m_hDev = open(EMMC_DRIVER_DEV,O_RDWR,0);
|
|
|
if(m_hDev<0){
|
|
|
if (pLog){
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%s"),EMMC_DRIVER_DEV, strerror(errno));
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->please to check drmboot.ko."));
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm EMMC_DRIVER_DEV -->%s=%d"),EMMC_DRIVER_DEV,m_hDev);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm EMMC_DRIVER_DEV_VENDOR-->%s=%d"),EMMC_DRIVER_DEV_VENDOR,m_hDev);
|
|
|
}
|
|
|
//get EMMC_DRIVER_DEV_LBA from
|
|
|
m_hLbaDev= open(emmc_point, O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"),emmc_point,errno);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm emmc_point-->%s=%d"),emmc_point,m_hLbaDev);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm-->is nand."));
|
|
|
m_hDev = open(NAND_DRIVER_DEV_VENDOR,O_RDWR,0);
|
|
|
if (m_hDev<0)
|
|
|
{
|
|
|
if (pLog){
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"),NAND_DRIVER_DEV_VENDOR,strerror(errno));
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->try to read from %s."),EMMC_DRIVER_DEV_VENDOR);
|
|
|
}
|
|
|
m_hDev = open(EMMC_DRIVER_DEV_VENDOR,O_RDWR,0);
|
|
|
if (m_hDev<0){
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"),EMMC_DRIVER_DEV_VENDOR,strerror(errno));
|
|
|
}else{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"),EMMC_DRIVER_DEV_VENDOR,m_hDev);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pLog)
|
|
|
pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"),NAND_DRIVER_DEV_VENDOR,m_hDev);
|
|
|
}
|
|
|
|
|
|
// m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
// if (m_hLbaDev<0)
|
|
|
// {
|
|
|
// if (pLog)
|
|
|
// pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// //CtrlNandLbaRead();
|
|
|
// CtrlNandLbaWrite();
|
|
|
// if (pLog)
|
|
|
// pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
}
|
|
|
void CRKUsbComm::RKU_ReopenLBAHandle()
|
|
|
{
|
|
|
if (m_bEmmc)
|
|
|
return;
|
|
|
if (m_hLbaDev>0)
|
|
|
{
|
|
|
close(m_hLbaDev);
|
|
|
m_hLbaDev = -1;
|
|
|
}
|
|
|
// if (m_bEmmc)
|
|
|
// {
|
|
|
// m_hLbaDev= open(EMMC_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
// if (m_hLbaDev<0)
|
|
|
// {
|
|
|
// if (m_log)
|
|
|
// m_log->Record(_T("ERROR:RKU_ReopenLBAHandle-->open %s failed,err=%d"),EMMC_DRIVER_DEV_LBA,errno);
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// if (m_log)
|
|
|
// m_log->Record(_T("INFO:RKU_ReopenLBAHandle-->%s=%d"),EMMC_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
// }
|
|
|
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ReopenLBAHandle-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("INFO:RKU_ReopenLBAHandle-->%s=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
}
|
|
|
// }
|
|
|
|
|
|
}
|
|
|
int CRKUsbComm::RKU_ShowNandLBADevice()
|
|
|
{
|
|
|
if (m_bEmmc)
|
|
|
return ERR_SUCCESS;
|
|
|
BYTE blockState[64];
|
|
|
memset(blockState,0,64);
|
|
|
int iRet;
|
|
|
iRet = RKU_TestBadBlock(0,0,MAX_TEST_BLOCKS,blockState);
|
|
|
if (iRet!=ERR_SUCCESS)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ShowNandLBADevice-->RKU_TestBadBlock failed,ret=%d"),iRet);
|
|
|
}
|
|
|
return iRet;
|
|
|
}
|
|
|
|
|
|
|
|
|
CRKUsbComm::~CRKUsbComm()
|
|
|
{
|
|
|
if (m_hDev>0)
|
|
|
close(m_hDev);
|
|
|
if (m_hLbaDev>0)
|
|
|
{
|
|
|
// if (!m_bEmmc)
|
|
|
// {
|
|
|
// CtrlNandLbaRead(false);
|
|
|
// CtrlNandLbaWrite(false);
|
|
|
// }
|
|
|
close(m_hLbaDev);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int CRKUsbComm::RKU_EraseBlock(BYTE ucFlashCS,DWORD dwPos,DWORD dwCount,BYTE ucEraseType)
|
|
|
{(void)ucFlashCS; (void)dwPos; (void)dwCount; (void)ucEraseType;
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
|
|
|
int CRKUsbComm::RKU_EraseBlock_discard(unsigned int dwPos, unsigned int part_size)
|
|
|
{
|
|
|
u64 range[2];
|
|
|
int ret;
|
|
|
range[0] = (off64_t)dwPos * 512;
|
|
|
range[1] = (off64_t)part_size * 512;
|
|
|
|
|
|
printf("dwPos = %" PRIu64 ", len=%" PRIu64 " \n", range[0], range[1]);
|
|
|
|
|
|
if (m_hLbaDev < 0)
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
|
|
|
ret = ioctl(m_hLbaDev, BLKDISCARD, &range);
|
|
|
if (ret < 0) {
|
|
|
printf("Discard failed\n");
|
|
|
return 1;
|
|
|
} else {
|
|
|
printf("Wipe used discard success\n");
|
|
|
return 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int CRKUsbComm::RKU_ReadChipInfo(BYTE* lpBuffer)
|
|
|
{(void)lpBuffer;
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_ReadFlashID(BYTE* lpBuffer)
|
|
|
{(void)lpBuffer;
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_ReadFlashInfo(BYTE* lpBuffer,UINT *puiRead)
|
|
|
{
|
|
|
int ret;
|
|
|
u32 page_buf[3];
|
|
|
|
|
|
if (m_hDev<0){
|
|
|
page_buf[0] = 0x00800000;
|
|
|
page_buf[1] = 0x00040400;
|
|
|
page_buf[2] = 0x00010028;
|
|
|
memcpy(lpBuffer, (unsigned char*)page_buf, 11);
|
|
|
*puiRead = 11;
|
|
|
}else{
|
|
|
ret = ioctl(m_hDev,GET_FLASH_INFO_IO,lpBuffer);
|
|
|
if (ret)
|
|
|
{
|
|
|
printf("RKU_ReadFlashInfo ioctl failed \n");
|
|
|
page_buf[0] = 0x00800000;
|
|
|
page_buf[1] = 0x00040400;
|
|
|
page_buf[2] = 0x00010028;
|
|
|
memcpy(lpBuffer, (unsigned char*)page_buf, 11);
|
|
|
}
|
|
|
*puiRead = 11;
|
|
|
}
|
|
|
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_ReadLBA(DWORD dwPos,DWORD dwCount,BYTE* lpBuffer,BYTE bySubCode)
|
|
|
{
|
|
|
long long ret;
|
|
|
long long dwPosBuf;
|
|
|
(void)bySubCode;
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (!m_bEmmc)
|
|
|
{
|
|
|
m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("INFO:RKU_ReadLBA-->open %s ok,handle=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
if (m_bEmmc && !CRKAndroidDevice::bGptFlag)
|
|
|
dwPos += 8192;
|
|
|
|
|
|
dwPosBuf = dwPos;
|
|
|
ret = lseek64(m_hLbaDev,(off64_t)dwPosBuf*512,SEEK_SET);
|
|
|
if (ret<0)
|
|
|
{
|
|
|
if (m_log){
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA seek failed,err=%d,ret=%lld."),errno,ret);
|
|
|
m_log->Record(_T("the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf*512);
|
|
|
}
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
ret = read(m_hLbaDev,lpBuffer,dwCount*512);
|
|
|
if (ret!=dwCount*512)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA read failed,err=%d"),errno);
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
|
|
|
int CRKUsbComm::RKU_ReadLBA_Direct(DWORD dwPos,DWORD dwCount,BYTE* lpBuffer,BYTE bySubCode)
|
|
|
{
|
|
|
long long ret;
|
|
|
long long dwPosBuf;
|
|
|
(void)bySubCode;
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (!m_bEmmc)
|
|
|
{
|
|
|
m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("INFO:RKU_ReadLBA-->open %s ok,handle=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
|
|
|
dwPosBuf = dwPos;
|
|
|
ret = lseek64(m_hLbaDev,(off64_t)dwPosBuf*512,SEEK_SET);
|
|
|
if (ret<0)
|
|
|
{
|
|
|
if (m_log){
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA seek failed,err=%d,ret=%lld."),errno,ret);
|
|
|
m_log->Record(_T("the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf*512);
|
|
|
}
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
ret = read(m_hLbaDev,lpBuffer,dwCount*512);
|
|
|
if (ret!=dwCount*512)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA read failed,err=%d"),errno);
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
|
|
|
int CRKUsbComm::RKU_ReadSector(DWORD dwPos,DWORD dwCount,BYTE* lpBuffer)
|
|
|
{
|
|
|
int ret;
|
|
|
if (m_hDev<0){
|
|
|
//printf("RKU_ReadSector m_hDev is negative \n");
|
|
|
return RKU_ReadLBA_Direct(dwPos,dwCount,lpBuffer,RWMETHOD_LBA);
|
|
|
}
|
|
|
DWORD *pOffsetSec=(DWORD *)(lpBuffer);
|
|
|
DWORD *pCountSec=(DWORD *)(lpBuffer+4);
|
|
|
*pOffsetSec = dwPos;
|
|
|
*pCountSec = dwCount;
|
|
|
ret = ioctl(m_hDev,READ_SECTOR_IO,lpBuffer);
|
|
|
if (ret)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("RKU_ReadSector,err=%d"),errno);
|
|
|
return RKU_ReadLBA_Direct(dwPos,dwCount,lpBuffer,RWMETHOD_LBA);
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_ResetDevice(BYTE bySubCode)
|
|
|
{
|
|
|
(void)bySubCode;
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_TestBadBlock(BYTE ucFlashCS,DWORD dwPos,DWORD dwCount,BYTE* lpBuffer)
|
|
|
{
|
|
|
int ret;
|
|
|
(void)ucFlashCS; (void)dwPos; (void)dwCount;
|
|
|
if (m_hDev<0){
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
ret = ioctl(m_hDev,GET_BAD_BLOCK_IO,lpBuffer);
|
|
|
if (ret)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("RKU_TestBadBlock,err=%d"),errno);
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
if (m_log)
|
|
|
{
|
|
|
string strOutput;
|
|
|
m_log->PrintBuffer(strOutput,lpBuffer,64);
|
|
|
m_log->Record(_T("INFO:BadBlockState:\r\n%s"),strOutput.c_str());
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_TestDeviceReady(DWORD *dwTotal,DWORD *dwCurrent,BYTE bySubCode)
|
|
|
{
|
|
|
(void)dwTotal; (void)dwCurrent; (void)bySubCode;
|
|
|
return ERR_DEVICE_READY;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_WriteLBALoader(DWORD dwPos,DWORD dwCount,BYTE* lpBuffer,BYTE bySubCode)
|
|
|
{
|
|
|
long long ret;
|
|
|
long long dwPosBuf;
|
|
|
(void)bySubCode;
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
printf("---------m_hLbaDev<0\n");
|
|
|
if (!m_bEmmc)
|
|
|
{
|
|
|
printf("---------nand\n");
|
|
|
m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("INFO:RKU_WriteLBA-->open %s ok,handle=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
/*
|
|
|
if (m_bEmmc && !CRKAndroidDevice::bGptFlag)
|
|
|
{
|
|
|
m_log->Record(_T("add----8192"));
|
|
|
dwPos += 8192;
|
|
|
}*/
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>GPT<50><54>Ҫ<EFBFBD><D2AA>8192,<2C><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>loader<65><72><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>8192(4M)
|
|
|
/*
|
|
|
if (m_bEmmc)
|
|
|
if(!CRKAndroidDevice::bGptFlag && !CRKAndroidDevice::bOnlyLoader)
|
|
|
{
|
|
|
m_log->Record(_T("aaaaadd----8192"));
|
|
|
dwPos += 8192;
|
|
|
}*/
|
|
|
dwPosBuf = dwPos;
|
|
|
ret = lseek64(m_hLbaDev,(off64_t)dwPosBuf*512,SEEK_SET);
|
|
|
if (ret<0)
|
|
|
{
|
|
|
if (m_log){
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA seek failed,err=%d,ret:%lld"),errno, ret);
|
|
|
m_log->Record(_T("ERROR:the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf*512);
|
|
|
}
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA seek failed,err=%d,ret:%lld"),errno, ret);
|
|
|
m_log->Record(_T("ERROR:the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf*512);
|
|
|
return ERR_FAILED;
|
|
|
|
|
|
}
|
|
|
ret = write(m_hLbaDev,lpBuffer,dwCount*512);
|
|
|
if (ret!=dwCount*512)
|
|
|
{
|
|
|
sleep(1);
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA write failed,err=%d"),errno);
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
// ret = fsync(m_hLbaDev);
|
|
|
// if (ret!=0)
|
|
|
// {
|
|
|
// if (m_log)
|
|
|
// m_log->Record(_T("ERROR:RKU_WriteLBA fsync failed,err=%d"),errno);
|
|
|
// }
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_WriteLBA(DWORD dwPos,DWORD dwCount,BYTE* lpBuffer,BYTE bySubCode)
|
|
|
{
|
|
|
long long ret;
|
|
|
long long dwPosBuf;
|
|
|
(void)bySubCode;
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
printf("---------m_hLbaDev<0\n");
|
|
|
if (!m_bEmmc)
|
|
|
{
|
|
|
printf("---------nand\n");
|
|
|
m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("INFO:RKU_WriteLBA-->open %s ok,handle=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
if (m_bEmmc && !CRKAndroidDevice::bGptFlag)
|
|
|
{
|
|
|
m_log->Record(_T("add----8192"));
|
|
|
dwPos += 8192;
|
|
|
}
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>GPT<50><54>Ҫ<EFBFBD><D2AA>8192,<2C><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>loader<65><72><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>8192(4M)
|
|
|
/*
|
|
|
if (m_bEmmc)
|
|
|
if(!CRKAndroidDevice::bGptFlag && !CRKAndroidDevice::bOnlyLoader)
|
|
|
{
|
|
|
m_log->Record(_T("aaaaadd----8192"));
|
|
|
dwPos += 8192;
|
|
|
}*/
|
|
|
dwPosBuf = dwPos;
|
|
|
ret = lseek64(m_hLbaDev,(off64_t)dwPosBuf*512,SEEK_SET);
|
|
|
if (ret<0)
|
|
|
{
|
|
|
if (m_log){
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA seek failed,err=%d,ret:%lld"),errno, ret);
|
|
|
m_log->Record(_T("ERROR:the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf*512);
|
|
|
}
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA seek failed,err=%d,ret:%lld"),errno, ret);
|
|
|
m_log->Record(_T("ERROR:the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf*512);
|
|
|
return ERR_FAILED;
|
|
|
|
|
|
}
|
|
|
ret = write(m_hLbaDev,lpBuffer,dwCount*512);
|
|
|
if (ret!=dwCount*512)
|
|
|
{
|
|
|
sleep(1);
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_WriteLBA write failed,err=%d"),errno);
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
// ret = fsync(m_hLbaDev);
|
|
|
// if (ret!=0)
|
|
|
// {
|
|
|
// if (m_log)
|
|
|
// m_log->Record(_T("ERROR:RKU_WriteLBA fsync failed,err=%d"),errno);
|
|
|
// }
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_WriteSector(DWORD dwPos,DWORD dwCount,BYTE* lpBuffer)
|
|
|
{
|
|
|
int ret;
|
|
|
if (m_hDev<0){
|
|
|
//printf("RKU_WriteSector m_hDev is negative \n");
|
|
|
return RKU_WriteLBALoader(dwPos,dwCount,lpBuffer,RWMETHOD_LBA);
|
|
|
}
|
|
|
DWORD *pOffset=(DWORD *)(lpBuffer);
|
|
|
DWORD *pCount=(DWORD *)(lpBuffer+4);
|
|
|
*pOffset = dwPos;
|
|
|
*pCount = dwCount;
|
|
|
ret = ioctl(m_hDev,WRITE_SECTOR_IO,lpBuffer);
|
|
|
if (ret)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("RKU_WriteSector,err=%d"),errno);
|
|
|
return RKU_WriteLBALoader(dwPos,dwCount,lpBuffer,RWMETHOD_LBA);
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
|
|
|
int CRKUsbComm::RKU_GetLockFlag(BYTE* lpBuffer)
|
|
|
{
|
|
|
int ret;
|
|
|
if (m_hDev<0){
|
|
|
//printf("RKU_GetLockFlag m_hDev is negative \n");
|
|
|
DWORD *pFlag=(DWORD *)lpBuffer;
|
|
|
*pFlag = 0;
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
ret = ioctl(m_hDev,GET_LOCK_FLAG_IO,lpBuffer);
|
|
|
if (ret)
|
|
|
{
|
|
|
DWORD *pFlag=(DWORD *)lpBuffer;
|
|
|
*pFlag = 0;
|
|
|
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("RKU_GetLockFlag,err=%d"),errno);
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
DWORD *pFlag=(DWORD *)lpBuffer;
|
|
|
if (m_log)
|
|
|
{
|
|
|
m_log->Record(_T("INFO:LockFlag:0x%08x"),*pFlag);
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
int CRKUsbComm::RKU_GetPublicKey(BYTE* lpBuffer)
|
|
|
{
|
|
|
int ret;
|
|
|
if (m_hDev<0)
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
ret = ioctl(m_hDev,GET_PUBLIC_KEY_IO,lpBuffer);
|
|
|
if (ret)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_GetPublicKey failed,err=%d"),errno);
|
|
|
return ERR_FAILED;
|
|
|
}
|
|
|
return ERR_SUCCESS;
|
|
|
}
|
|
|
bool CRKUsbComm::CtrlNandLbaWrite(bool bEnable)
|
|
|
{
|
|
|
int ret;
|
|
|
if (m_bEmmc)
|
|
|
return false;
|
|
|
if (m_hLbaDev<0)
|
|
|
return false;
|
|
|
if (bEnable)
|
|
|
ret = ioctl(m_hLbaDev,ENABLE_NAND_LBA_WRITE_IO);
|
|
|
else
|
|
|
ret = ioctl(m_hLbaDev,DISABLE_NAND_LBA_WRITE_IO);
|
|
|
if (ret)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:CtrlNandLbaWrite failed,enable=%d,err=%d"),bEnable,errno);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
bool CRKUsbComm::CtrlNandLbaRead(bool bEnable)
|
|
|
{
|
|
|
int ret;
|
|
|
if (m_bEmmc)
|
|
|
return false;
|
|
|
if (m_hLbaDev<0)
|
|
|
return false;
|
|
|
if (bEnable)
|
|
|
ret = ioctl(m_hLbaDev,ENABLE_NAND_LBA_READ_IO);
|
|
|
else
|
|
|
ret = ioctl(m_hLbaDev,DISABLE_NAND_LBA_READ_IO);
|
|
|
if (ret)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:CtrlNandLbaRead failed,enable=%d,err=%d"),bEnable,errno);
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
long long CRKUsbComm::RKU_GetFlashSize()
|
|
|
{
|
|
|
long long length;
|
|
|
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (!m_bEmmc)
|
|
|
{
|
|
|
m_hLbaDev= open(NAND_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
|
|
|
if (m_hLbaDev<0)
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("ERROR:RKU_ReadLBA-->open %s failed,err=%d"),NAND_DRIVER_DEV_LBA,errno);
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (m_log)
|
|
|
m_log->Record(_T("INFO:RKU_ReadLBA-->open %s ok,handle=%d"),NAND_DRIVER_DEV_LBA,m_hLbaDev);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
return ERR_DEVICE_OPEN_FAILED;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
length = lseek64(m_hLbaDev,(off64_t)0,SEEK_END);
|
|
|
if (length < 0)
|
|
|
{
|
|
|
if (m_log){
|
|
|
m_log->Record(_T("RKU_GetFlashSize get flash size failed"));
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
return (length/512);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
