flashupgraderdlg.cpp

PW芯片方案Flash ROM烧写程序

	//
	if (strHexFile.Right(3).CompareNoCase("HEX")==0)
	{
		CString strLine;
		CHexRegion* pRegion = NULL;
		BOOL bGlomWholeFile = TRUE;

		pHex->m_bExecute = bExecute;
		pHex->m_bVerify = bVerify;

		while (bResult && HexFile.ReadString(strLine))
		{
			// See if this line is the start of a new region
			int nRecordType = GetHexField(strLine, 7, 2);
			int nDataCount = GetHexField(strLine, 1, 2);
			
			if (nRecordType == 2 || nRecordType == 4)
			{
				CHexRegion* pPrev = NULL;
				
				// Get a pointer to the previous region...
				if (!pHex->m_RegionList.IsEmpty())
				{
					pPrev = (CHexRegion*)pHex->m_RegionList.GetTail();
				}
				
				int nSegment = GetHexField(strLine, 9, 4);
                int nAddress = nSegment << ((nRecordType==2)?4:16);
				
				if (pPrev != NULL)
				{
					// See if this current region is a continuation of the
					// previous region.  If so, then just add to the previous
					// region, otherwise, create a new region.
					int nPrevEnd = pPrev->m_nStart+pPrev->m_nLength+1;
					if ((nAddress <= nPrevEnd) || bGlomWholeFile)
					{
						pRegion = pPrev;
					}
					else
					{
						pRegion = new CHexRegion;
						pRegion->m_nStart = nAddress;
						pRegion->m_bExecute = bExecute;
						pRegion->m_bVerify = bVerify;
						pRegion->m_strFile = strHexFile;
						pHex->m_RegionList.AddTail(pRegion);
					}
				}
				else
				{
					// No previous region
					pRegion = new CHexRegion;
					pRegion->m_nStart = nAddress;
					pRegion->m_bExecute = bExecute;
					pRegion->m_bVerify = bVerify;
					pRegion->m_strFile = strHexFile;
					pHex->m_RegionList.AddTail(pRegion);
				}
				
				// BEGIN PATCH CR8629
				if (nRecordType == 4 && !bStartOffset)
				{
					bStartOffset = TRUE;
					HexFile.ReadString(strLine);
					{
						int nOffset = GetHexField(strLine, 3, 4);
						//DEBUG
						//CString szTmp;
						//szTmp.Format("%x",nOffset);
						//MessageBox(szTmp,"1");
						pRegion->m_nOffset = nOffset;
						
						pRegion->m_nLength += nDataCount;
					}
				}
				else if(!bStartOffset)
				{
					pRegion->m_nOffset = 0;
				}
				// END PATCH CR8629
				
				
			}
			else if (nRecordType == 0)
			{
				// This is a data field 
				pRegion->m_nLength += nDataCount;
			}
		}
	}
//	else if (strHexFile.Right(6).CompareNoCase("CRAMFS")==0)
	else  // Assume binary
	{
		CHexRegion* pRegion = NULL;

		pRegion = new CHexRegion;
		pRegion->m_nOffset = 0;
		pRegion->m_nStart = 0;

		if (bResult)
		{
			ASSERT(NULL != HexFile.m_pStream);
			pRegion->m_nLength = HexFile.GetLength();
		}

		pRegion->m_bExecute = bExecute;
		pRegion->m_bVerify = bVerify;

		pRegion->m_strFile = strHexFile;

		pHex->m_bExecute = bExecute;
		pHex->m_bVerify = bVerify;
    pHex->m_RegionList.AddTail(pRegion);
  }

	if (m_bOpened)
		HexFile.Close();

	return bResult;
}

void CFlashUpgraderDlg::DeleteHexFileData()
{
	// Empty out the region list control
	if (m_listRegions.m_hWnd != NULL)
		m_listRegions.DeleteAllItems();

	for (POSITION pos = m_HexFiles.GetHeadPosition(); pos != NULL;)
	{
		CHexFileData* pHex = (CHexFileData*)m_HexFiles.GetNext(pos);
		for (POSITION reg = pHex->m_RegionList.GetHeadPosition(); reg != NULL;)
		{
			CHexRegion* pReg = (CHexRegion*)pHex->m_RegionList.GetNext(reg);
			delete pReg;
		}
		pHex->m_RegionList.RemoveAll();
		delete pHex;
	}
	m_HexFiles.RemoveAll();
}

int CFlashUpgraderDlg::GetHexField(CString strLine, int nStart, int nLength)
{
	int nData=0;
	CString strField = strLine.Mid(nStart, nLength);
	if (sscanf(strField, "%x", &nData)==1)
	{
		return nData;
	}

	return -1;
}

void CFlashUpgraderDlg::LoadRegionList()
{
	CPtrList Regions;
	// Gather up a list of all the regions....
	for (POSITION hex = m_HexFiles.GetHeadPosition(); hex != NULL;)
	{
		BOOL bAddName = TRUE;
		CHexFileData* pHex = (CHexFileData*)m_HexFiles.GetNext(hex);
		
		for (POSITION reg = pHex->m_RegionList.GetHeadPosition(); reg != NULL;)
		{
			CHexRegion* pReg = (CHexRegion*)pHex->m_RegionList.GetNext(reg);
			Regions.AddTail((void*)pReg);
		}
	}

	// Assume no conflicts until proven otherwise.
	m_bConflicts = FALSE;
	
	int nItem = 0;
	for (hex = m_HexFiles.GetHeadPosition(); hex != NULL;)
	{
		BOOL bAddName = TRUE;
		CHexFileData* pHex = (CHexFileData*)m_HexFiles.GetNext(hex);

		pHex->m_nFileLength = pHex->GetDownloadSize();

		if (pHex->m_RegionList.IsEmpty())
		{
			nItem = m_listRegions.InsertItem(nItem, pHex->m_strName, pHex->GetIcon());
			m_listRegions.SetItemData(nItem, (DWORD)pHex);
			nItem++;
		}

		for (POSITION reg = pHex->m_RegionList.GetHeadPosition(); reg != NULL;)
		{
			CHexRegion* pReg = (CHexRegion*)pHex->m_RegionList.GetNext(reg);
			CString strStart;
			CString strEnd;
			CString strFile;
			CString strLen;

			strStart.Format("0x%05X", pReg->m_nStart);
			strEnd.Format("0x%05X", (pReg->m_nLength + pReg->m_nStart));
			strLen.Format("%d", pReg->m_nLength);

			if (bAddName)
			{
				strFile = pHex->m_strName;
			}

			pHex->m_bExecute = pReg->m_bExecute;

			// Compare this region against all other regions to determine if
			// there is a conflict...
			for (POSITION cmp = Regions.GetHeadPosition(); cmp != NULL;)
			{
				CHexRegion* pCmp = (CHexRegion*)Regions.GetNext(cmp);
				if (pCmp != pReg)
				{
					int nRegStart = pReg->m_nStart + pReg->m_nOffset;
					int nRegEnd = pReg->m_nStart + pReg->m_nOffset + pReg->m_nLength;
					int nCmpStart = pCmp->m_nStart + pCmp->m_nOffset;
					int nCmpEnd = pCmp->m_nStart + pCmp->m_nOffset + pCmp->m_nLength;

					if (((nRegStart >= nCmpStart) && (nRegStart <= nCmpEnd)) ||
						((nRegEnd >= nCmpStart) && (nRegEnd <= nCmpEnd)))
					{
						pHex->m_bConflict = TRUE;
						m_bConflicts = TRUE;
					}
				}
			}

			nItem = m_listRegions.InsertItem(nItem, strFile, pHex->GetIcon());
			m_listRegions.SetItemData(nItem, (DWORD)pHex);

// BEGIN PATCH CR8629
            CString strStartTotal;
            int iStartTotal =  pReg->m_nStart + pReg->m_nOffset;   
            strStartTotal.Format("0x%05X", iStartTotal);

            CString strEndTotal;
            int iEndTotal =  pReg->m_nStart + pReg->m_nLength + pReg->m_nOffset;
            strEndTotal.Format("0x%05X", iEndTotal);
// END PATCH CR8629

            int nCol = 1;
			m_listRegions.SetItemText(nItem, nCol++, strStartTotal);    // PATCH CR8629
			m_listRegions.SetItemText(nItem, nCol++, strEndTotal);      // PATCH CR8629
			m_listRegions.SetItemText(nItem, nCol++, strLen);

			nItem++;
		}
	}

	UpdateControls();
}

void CFlashUpgraderDlg::AddBitmap(int nIDC, CImageList *pList, COLORREF cr)
{
	CBitmap bm;

	bm.LoadBitmap(nIDC);
	pList->Add(&bm, cr);
	bm.DeleteObject();
}

void CFlashUpgraderDlg::OnColumnclickListRegions(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
	int nCol = pNMListView->iSubItem;

	switch (nCol)
	{
	case 0: // filename
		bSortByNameAsc = !bSortByNameAsc;
		m_listRegions.SortItems(SortByName, (LPARAM)&m_listRegions);
		break;

	case 1: // start address
		bSortByStartAsc = !bSortByStartAsc;
		m_listRegions.SortItems(SortByStart, (LPARAM)&m_listRegions);
		break;

	case 2: // end address
		bSortByEndAsc = !bSortByEndAsc;
		m_listRegions.SortItems(SortByEnd, (LPARAM)&m_listRegions);
		break;

	case 3: // region length
		bSortByLengthAsc = !bSortByLengthAsc;
		m_listRegions.SortItems(SortByLength, (LPARAM)&m_listRegions);
		break;
	}
	
	*pResult = 0;
}

void CFlashUpgraderDlg::DisableControls(BOOL bDisable)
{
	m_cmbConnection.EnableWindow(!bDisable);
	m_cmbInfFile.EnableWindow(!bDisable);
	m_butBrowse.EnableWindow(!bDisable);
	m_chkContinuous.EnableWindow(!bDisable);
	m_butClose.EnableWindow(!bDisable);
	m_butHelp.EnableWindow(!bDisable);
	m_ctrlProgress.SetPos(0);
	//m_listRegions.EnableWindow(!bDisable);


	EnableSerialControls(!bDisable);

	m_editResetTime.EnableWindow(!bDisable & m_bContinuous);

	if (bDisable)
	{
		m_butFlash.SetWindowText("Cancel");
	}
	else
	{
		SetFlashText();
		m_strFileName = "";
		UpdateData(FALSE);
	}
}

BOOL CFlashUpgraderDlg::ValidateROMFiles()
{
    FILE_ITEM       fileItem;
    LINECONTEXT     lineContext;

	UpdateData();

    if (FALSE == m_InfFile.FindFirstLine(&lineContext, "DownloadFiles"))
    {
        TRACE("[DownloadFiles] doesn't exist\n");
        return FALSE;
    }

    BOOL bLastFile = FALSE;
    while(FALSE == bLastFile)
    {
        CString strField;
        fileItem.eType = ftHexEx;
        fileItem.wIntelSegment = 0;
        fileItem.cFlashFlags = m_cFlashFlags;

        if (FALSE == m_InfFile.GetStringField(&lineContext, 0, strField))
        {
            TRACE("[DownloadFiles] missing field identifier.\n");
            return FALSE;
        }

        if (FALSE == m_InfFile.GetStringField(&lineContext, 1, fileItem.strPath))
        {
            TRACE("[DownloadFiles] missing filename.\n");
            return FALSE;
        }

        if (0 == strField.CompareNoCase("File"))
        {
            fileItem.cFlashFlags |= DISABLE_CODE_EXECUTION;
			// if the verify is check, add the verify flag
			if (m_bVerifyOnly)
				fileItem.cFlashFlags |= VERIFY_FLASH_ONLY;

			if (m_bEraseOnly)
				fileItem.cFlashFlags |= ERASE_FLASH_ONLY;
        }
        else if (0 == strField.CompareNoCase("VerifyFile"))
        {
            fileItem.cFlashFlags |= DISABLE_CODE_EXECUTION;
            fileItem.cFlashFlags |= VERIFY_FLASH_ONLY;

			if (m_bEraseOnly)
			{
				//
				// Don't verify, just erase...
				//
				fileItem.cFlashFlags &= ~VERIFY_FLASH_ONLY;
				fileItem.cFlashFlags |= ERASE_FLASH_ONLY;
			}
        }
        else if (0 == strField.CompareNoCase("ResetFile"))
        {
            fileItem.cFlashFlags |= DISABLE_CODE_EXECUTION;
            fileItem.cFlashFlags |= RESET_AFTER_FILE_DOWNLOADED;
        }
        else if (0 != strField.CompareNoCase("ExecuteFile"))
        {
            TRACE("[DownloadFiles] invalid field identifier.\n");
        }

        if (FALSE == CheckIfFileExist(fileItem.strPath))
        {
            return FALSE;
        }

        if (FALSE == m_InfFile.FindNextLine(&lineContext))
        {
            if (m_bResetAfterLastFileLoaded)
            {
                fileItem.cFlashFlags |= RESET_AFTER_FILE_DOWNLOADED;
            }

            bLastFile = TRUE;
        }

		if (0 == fileItem.strPath.Right(4).CompareNoCase(".TXT"))
		{
			// Text file format (series of ascii hex bytes i.e. 4b c3 5d ...)
			// Used for EDID programming.  Assumes initial address of 00)
			fileItem.eType = ftText;
		}
		else if (0 != fileItem.strPath.Right(4).CompareNoCase(".HEX"))
		{
			// Binary file format
			fileItem.eType = ftBinary;
    }
        m_FlashItemArray.Add(fileItem);
    }

    return TRUE;
}

BOOL CFlashUpgraderDlg::CheckIfFileExist(LPCSTR lpszFilePath, BOOL bMessage)
{
    BOOL        bStatus = TRUE;
    CString     cStr;

    CFile file;
    if (FALSE == file.Open(lpszFilePath, CFile::modeRead))
    {
        cStr.Format("Unable to open %s.", lpszFilePath);
        bStatus = FALSE;
    }

    if (bStatus)
    {
        int nSize = (int)file.GetLength();
        file.Close();

        if (0 == nSize)
        {
            cStr.Format("File %s is empty.", lpszFilePath);
            bStatus = FALSE;
        }
    }

    if (FALSE == bStatus && bMessage)
    {
        MessageBox(cStr, "Error", MB_OK | MB_ICONEXCLAMATION);
    }

    return bStatus;
}

BOOL CFlashUpgraderDlg::ValidateInfFile()
{
    m_FlashItemArray.RemoveAll();

	CString strFile = m_strDirectory + m_strInfFile;

    CString cStrPath(m_strDirectory);
    if (FALSE == cStrPath.IsEmpty())
    {
        if (FALSE == SetCurrentDirectory(cStrPath))
        {
            TRACE("SetCurrentDirectory failed: %s\n", cStrPath);
            return FALSE;  // stay on this property page
        }
    }

    if (FALSE == m_InfFile.OpenInfFile(strFile))
    {
        return FALSE;      // stay on this property page
    }

    CString cstrText;
    if (FALSE == m_InfFile.GetLineText("Version", "Class", cstrText))
    {
        TRACE("Section [Version], 'Class' doesn't exist in INF file.\n");
        return FALSE;
    }

    if (0 != cstrText.CompareNoCase("Firmware"))
    {
        TRACE("Section [Version], 'Class=Firmware' bad.\n");
        return FALSE;
    }

    //------------------------------------------------------------------------
    // Get Version flags from INF file.
    //------------------------------------------------------------------------
    m_cFlashFlags = FLASH_FLAGS_NONE;
    if (m_InfFile.GetLineText("Version", "BootROMWrite", cstrText))
    {
        if (0 == cstrText.CompareNoCase("Enable"))
        {
            m_cFlashFlags |= FLASH_BOOT_WRITE_ENABLE;
        }
    }

    if (m_InfFile.GetLineText("Version", "FlashWrite", cstrText))
    {
        if (0 == cstrText.CompareNoCase("Enable"))
        {
            m_cFlashFlags |= FLASH_WRITE_ENABLE;
        }
    }

    m_bResetAfterLastFileLoaded = FALSE;
    if (m_InfFile.GetLineText("Version", "Reset", cstrText))
    {
        if (0 == cstrText.CompareNoCase("Enable"))
        {
            m_bResetAfterLastFileLoaded = TRUE;
        }
    }