ezmrview.cpp

EZ _USB Control PANEL 源代码

////////////////////////////////////////////////////////////////////////////////
// EzMrView.cpp : implementation of the CEzMrView class
// $Header: /USB/Util/EzMr/EzMrView.cpp 23    3/07/02 11:18p Tpm $
// Copyright (c) 2000 Cypress Semiconductor. May not be reproduced without permission.
// See the EzUsb Developer's Kit license agreement for more details.
////////////////////////////////////////////////////////////////////////////////


#include "stdafx.h"
#include "EzMr.h"
#include "main.h" // for PUSBD_INTERFACE_INFORMATION

#include "EzMrDoc.h"
#include "CntrItem.h"
#include "EzMrFrm.h" // for access to m_wndDlgMain
#include "EzMrView.h"

#include "Vend_Ax.h"

extern INTEL_HEX_RECORD Vend_Ax[];
extern INTEL_HEX_RECORD Vend_Ax_Fx2[];

#include <fstream.h>

int my_sscanf(LPCSTR cBuffer, DWORD *data);
UINT SendOpThread(LPVOID pParam);

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CEzMrView

IMPLEMENT_DYNCREATE(CEzMrView, CRichEditView)

BEGIN_MESSAGE_MAP(CEzMrView, CRichEditView)
	//{{AFX_MSG_MAP(CEzMrView)
	ON_WM_DESTROY()
	ON_WM_TIMER()
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CRichEditView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CRichEditView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CRichEditView::OnFilePrintPreview)

	ON_COMMAND(ID_OPS_SEND, OnOpsSend) //TPMDo: Add ToolBar manually
	//ON_UPDATE_COMMAND_UI(ID_OPS_SEND, OnUpdateOpsSend) //TPMDo: Add ToolBar manually
	ON_COMMAND(IDC_CLEAR, OnOpsClear) 
	ON_COMMAND(IDC_BDRIVER_NAME, OnStatTextButton) 
	ON_COMMAND(IDC_BDEV_STRING, OnStatTextButton) 
	ON_COMMAND(IDC_8051_HOLD, On_8051_HOLD)
	ON_COMMAND(IDC_8051_RUN, On_8051_RUN)
	ON_COMMAND(IDC_LOAD_MON, On_LOAD_MON)
	ON_COMMAND(IDC_RELOAD, OnIDC_RELOAD)
	ON_UPDATE_COMMAND_UI(IDC_RELOAD, OnUpdateIDC_RELOAD)

	ON_COMMAND(ID_BVEN_LBL, OnID_BVEN_LBL) 
	ON_COMMAND(ID_BREQ, OnStatTextButton) //TPMDo: Add m_wndTBarVen manually
	ON_COMMAND(ID_BVAL, OnStatTextButton) 
	ON_COMMAND(ID_BIND, OnStatTextButton) 
	ON_COMMAND(ID_BLEN, OnStatTextButton) 
	ON_COMMAND(ID_BDIR, OnStatTextButton) 
	ON_COMMAND(ID_BDAT, OnStatTextButton) 

	ON_COMMAND(ID_BISO_LBL, OnID_BISO_LBL) 
	ON_COMMAND(ID_BPIPE, OnStatTextButton) 
	ON_COMMAND(ID_BPACKETS, OnStatTextButton) 
	ON_COMMAND(ID_BSIZE, OnStatTextButton) 
	ON_COMMAND(ID_BDATA, OnStatTextButton) 

	ON_COMMAND(ID_BBLK_LBL, OnID_BBLK_LBL) 
	ON_COMMAND(IDC_BBLK_PIPE, OnStatTextButton) 
	ON_COMMAND(IDC_BEDIT_WRITE_DATA_LENGTH, OnStatTextButton) 
	ON_COMMAND(IDC_BWRITE_LOOPS, OnStatTextButton)
	ON_COMMAND(IDC_BDATA_VALUE, OnStatTextButton)

	ON_COMMAND(IDC_BFIL_PIPE, OnStatTextButton) 
	ON_COMMAND(IDC_BFIL_FILE, OnStatTextButton) 

	ON_COMMAND(IDC_RESET_PIPE, OnIDC_RESET_PIPE) 
	ON_COMMAND(IDC_ABORT_PIPE, OnIDC_ABORT_PIPE)
	ON_COMMAND(IDC_FILE_TRANS, OnIDC_FILE_TRANS)

	ON_COMMAND(ID_BCFG_LBL, OnID_BCFG_LBL) 
	ON_COMMAND(IDC_BINTERFACE, OnStatTextButton) 
	ON_COMMAND(IDC_BALTSET, OnStatTextButton) 

	ON_COMMAND(IDC_EZ_LOOP, OnIDC_EZ_LOOP) 
	ON_UPDATE_COMMAND_UI(IDC_EZ_LOOP, OnUpdateIDC_EZ_LOOP)
	ON_COMMAND(IDC_EPROM_LD, OnIDC_EPROM_LD)
	ON_COMMAND(IDC_GET_DD, OnIDC_GET_DD) 
	ON_COMMAND(IDC_GET_CD, OnIDC_GET_CD) 
	ON_COMMAND(IDC_GET_PI, OnIDC_GET_PI) 
	ON_COMMAND(IDC_DOWN_LOAD, OnIDC_DOWN_LOAD) 

	ON_COMMAND(IDC_ABORT_ALL, OnIDC_ABORT_ALL)
	ON_COMMAND(IDC_GET_URB_STAT, OnIDC_GET_URB_STAT)
	ON_COMMAND(IDC_GET_SD, OnIDC_GET_SD)

	// These commands depend on target selection (not available for Sx2)
	ON_UPDATE_COMMAND_UI(IDC_LOAD_MON, OnUpdateTargetSel)
	ON_UPDATE_COMMAND_UI(IDC_DOWN_LOAD, OnUpdateTargetSel)
	ON_UPDATE_COMMAND_UI(IDC_EPROM_LD, OnUpdateTargetSel)
	ON_UPDATE_COMMAND_UI(IDC_8051_HOLD, OnUpdateTargetSel)
	ON_UPDATE_COMMAND_UI(IDC_8051_RUN, OnUpdateTargetSel)

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CEzMrView construction/destruction

CEzMrView::CEzMrView()
{
	m_nLooping = 0;

	m_strTransFile = theApp.m_strPathUSBRoot + "\\Util\\Test";

	m_CFont.CreateFont(13,7,0,0,400,0,0,0,
	0,1,2,
	1,49,"Courier");
	m_CFont.GetLogFont(&m_lf);

	m_nOpsPending = 0;
	m_nOpsCount = 0;

}

CEzMrView::~CEzMrView()
{
///*
	if(m_nOpsPending)
	{
		theApp.report_error("Operations are pending: You should disconnect the development board now to avoid a system hangup.\n");
	}
//*/
/*
	int i;
	int j = m_nOpsPending;
	int bResult;
	CThreadInfo* pTh;

	for(i=0; i<j; i++)
	{
		if(m_pTh[i]->wParam == IDC_TRAN_BULK_DATA)
		{ // we can kill the bulk and interrupt transfers, at least
		  pTh =  new CThreadInfo();
		  pTh = m_pTh[i];
		  pTh->wParam = IDC_ABORTPIPE;
		  pTh->m_hOpPended = 0;
		  pTh->m_hEventOpDone = 0;
		  pTh->pView = 0;
		  pTh->hOutputBox = 0;
	      pTh->OpIndex = m_nOpsCount++;
		  m_pTh[i]->m_hEventOpDone = 0;
		  m_pTh[i]->pView = 0;
		  m_pTh[i]->hOutputBox = 0;
		  bResult = SendOpThread(pTh); // call directly - don't spawn a thread
		  delete(pTh);
		}
	}
*/
}

BOOL CEzMrView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CRichEditView::PreCreateWindow(cs);
}

void CEzMrView::OnInitialUpdate()
{
	CRichEditView::OnInitialUpdate();

	// Set the printing margins (720 twips = 1/2 inch).
	SetMargins(CRect(720, 720, 720, 720));
	SetFont(&m_CFont, TRUE);

	m_hMain = ::GetDlgItem (((CEzMrFrame*)GetParentFrame())->m_wndDlgMain, IDC_OUTPUT_BOX);
	CToolBar* pwndTBarOps = &(((CEzMrFrame*)GetParentFrame())->m_wndTBarOps);
	CRichEditCtrl& aRECtrl = GetRichEditCtrl();
	CRichEditCtrl* hOutputBox = &aRECtrl;
	bMainDlgProcThread(GetDrv(), hOutputBox, m_hMain, WM_INITDIALOG, NULL, NULL);
	char* pVenbuf = (char *)((CEzMrFrame*)GetParentFrame())->VenBuf;
	m_strLastLoadedFile = "";
}

/////////////////////////////////////////////////////////////////////////////
// CEzMrView printing

BOOL CEzMrView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}


void CEzMrView::OnDestroy()
{
	// Deactivate the item on destruction; this is important
	// when a splitter view is being used.
   CRichEditView::OnDestroy();
   COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
   if (pActiveItem != NULL && pActiveItem->GetActiveView() == this)
   {
      pActiveItem->Deactivate();
      ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
   }
}


/////////////////////////////////////////////////////////////////////////////
// CEzMrView diagnostics

#ifdef _DEBUG
void CEzMrView::AssertValid() const
{
	CRichEditView::AssertValid();
}

void CEzMrView::Dump(CDumpContext& dc) const
{
	CRichEditView::Dump(dc);
}

CEzMrDoc* CEzMrView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CEzMrDoc)));
	return (CEzMrDoc*)m_pDocument;
}
#endif //_DEBUG

//////////////////////////////////////////////////////////////////////////////////////////
// The following - SendOpThread(LPVOID pParam) - will normally be executing within a 
// spawned thread, but it can also be called diretly for non-threaded operation
//////////////////////////////////////////////////////////////////////////////////////////
UINT SendOpThread(LPVOID pParam)
{
	int bResult;
	CThreadInfo* pTh = (CThreadInfo*)pParam;

	TRACE("TPM:CEzMrView::SendOpThread(): Thread started: Idx: %d\n", pTh->OpIndex);
	bResult = bMainDlgProc(pTh, pTh->hDlg, pTh->message, pTh->wParam, pTh->lParam );
	if(pTh->m_hEventOpDone)
	  SetEvent(pTh->m_hEventOpDone); // Alert the main thread ASAP - it may still be waiting
	if(pTh->pView)
	  ((CEzMrView*)(pTh->pView))->m_nOpsPending--;
	if(pTh->m_hOpPended == 1)
	{ // Op was pended - main task is no longer waiting - clean up here
      ((CEzMrFrame*)(pTh->pParentFrame))->OpDone((CThreadInfo*)pParam);
      delete (CThreadInfo*)pParam; // this makes the thread evaporate
	}
	return(bResult);
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// CEzMrView message handlers

int CEzMrView::bMainDlgProcThread(char* pcDriverName, CRichEditCtrl* hOutputBox, HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	fstream file;
	CFileStatus status;
	int bResult;
	char tempbuff[MAX_DRIVER_NAME];
	DWORD myDword;

	CThreadInfo* pTh =  new CThreadInfo();

	pTh->OpIndex = m_nOpsCount++;
	pTh->strpcDriverName = pcDriverName;
	pTh->hOutputBox = hOutputBox;
	pTh->hDlg = hDlg;
	pTh->message = message;
	pTh->wParam = wParam;
	pTh->lParam = lParam;
	pTh->pParentFrame = (void*)GetParentFrame();
	pTh->pView = (this);
	pTh->m_hOpPended = 0;
	pTh->pApp = &theApp;

	if(message==WM_INITDIALOG)
		pTh->pBuf = ((CEzMrFrame*)GetParentFrame())->VenBuf;

	switch(wParam)
	{ // Pre Op processing
	case IDC_ISO_TRANSFER:
		pTh->pipeNum = ::GetDlgItemInt(hDlg, IDC_ISO_PIPE, NULL, FALSE);
		pTh->packets = ::GetDlgItemInt(hDlg,IDC_ISO_PACKETS, NULL,FALSE);
		pTh->length = ::GetDlgItemInt(hDlg,IDC_ISO_SIZE,NULL,FALSE);
		pTh->bufCount = ::GetDlgItemInt(hDlg,IDC_ISO_BUF_CNT, NULL,FALSE);
		pTh->pakPer = ::GetDlgItemInt(hDlg,IDC_PAK_PER, NULL,FALSE);
		pTh->pBuf = ((CEzMrFrame*)GetParentFrame())->IsoBuf;
		break;
	case IDC_VEND_REQUEST:
		pTh->pBuf = ((CEzMrFrame*)GetParentFrame())->VenBuf;
		pTh->length = ::GetDlgItemInt(hDlg,IDC_WLENGTH,NULL,FALSE);
		pTh->direction = ::GetDlgItemInt(hDlg,IDC_DIRECTION,NULL,FALSE);
		::GetDlgItemText (hDlg, IDC_BREQUEST, tempbuff, MAX_DRIVER_NAME);
		my_sscanf(tempbuff,&myDword);
		pTh->request = (BYTE) myDword;
		::GetDlgItemText (hDlg, IDC_WVALUE, tempbuff, MAX_DRIVER_NAME);
		my_sscanf(tempbuff,&myDword);
		pTh->value = (WORD) myDword;
		::GetDlgItemText (hDlg, IDC_WINDEX, tempbuff, MAX_DRIVER_NAME);
		my_sscanf(tempbuff,&myDword);
		pTh->index = (WORD) myDword;
		break;
	case IDC_GET_PIPE_INFO: 
		break;
	case IDC_RESET_HLD:
	case IDC_RESET_RLS:
		pTh->bFX2 = theApp.m_nTarg;
		break;
	case IDC_ANCHOR_DOWNLOAD:
		pTh->pBuf = ((CEzMrFrame*)GetParentFrame())->BlkBuf;
		pTh->length = m_DldLen;
		pTh->dldOffset = m_dldOffset;
		break;
	case IDC_TRAN_BULK_DATA:
		pTh->pBuf = ((CEzMrFrame*)GetParentFrame())->BlkBuf;
		pTh->length = ::GetDlgItemInt (hDlg, IDC_EDIT_WRITE_DATA_LENGTH, NULL, FALSE);
		pTh->pipeNum = ::GetDlgItemInt (hDlg,IDC_EDIT_OUT_EP_INDEX, NULL, FALSE);
		pTh->data = ::GetDlgItemInt (hDlg, IDC_EDIT_WRITE_DATA_VALUE, NULL, FALSE);
		if(theApp.m_nQuietMode)
		{ // If doing the cable test
			if(!m_nLooping)
				for(int i=0; i<64; i++)
					memset (pTh->pBuf+i, (i%2) ? 0x55 : 0xAA, 1);
		}
		break;
	case IDC_RESETPIPE:
		pTh->pipeNum = ::GetDlgItemInt (hDlg,IDC_RESETPIPENUM, NULL, FALSE);
		break;
	case IDC_ABORTPIPE:
		pTh->pipeNum = ::GetDlgItemInt (hDlg,IDC_RESETPIPENUM, NULL, FALSE);
		break;
	case IDC_SETINTERFACE:
		pTh->interfaceNum = ::GetDlgItemInt (hDlg, IDC_INTERFACENUM, NULL, FALSE);
		pTh->alternateSetting = ::GetDlgItemInt (hDlg, IDC_ALTERNATESETTING, NULL, FALSE);
		break;
	case IDC_GETSTRINGDESCRIPTOR:
		pTh->index = theApp.m_nStringIndex;
		break;
	default:
		break;
	}

	if(!theApp.m_bThreaded)
	{
		m_nOpsPending++;
	    ((CEzMrFrame*)(pTh->pParentFrame))->OpStart(pTh);
		pTh->m_hEventOpDone = 0;
		bResult = SendOpThread(pTh); // not threaded - call directly - don't spawn a thread
        ((CEzMrFrame*)(pTh->pParentFrame))->OpDone(pTh);
		delete pTh;
	}
	else
	{
		bResult = 0;
		if( m_nOpsPending+1 < theApp.m_nMaxOpsPending)
		{
			TRACE("TPM:CEzMrView::bMainDlgProcThread(): Sending Thread\n");
			int nWaitTime = 3000;
			if((pTh->wParam == IDC_ANCHOR_DOWNLOAD))
				nWaitTime = 6000;
			if((pTh->wParam == IDC_VEND_REQUEST) && 
				(pTh->request == 0xA2))
				nWaitTime = 48000; // wait up to 48 secs for EEPROM write to complete

			pTh->m_hEventOpDone = CreateEvent(NULL, TRUE, FALSE, NULL); // manual reset, initially set

			m_nOpsPending++;
	        ((CEzMrFrame*)(pTh->pParentFrame))->OpStart(pTh);
			CWinThread* myWinThread = AfxBeginThread(SendOpThread, pTh, THREAD_PRIORITY_HIGHEST);

			// Pause here and wait for a timely return from thread
			TRACE("TPM:CEzMrView::bMainDlgProcThread(): Waiting after starting thread\n");
			DWORD ThreadStat = WaitForSingleObject(pTh->m_hEventOpDone, nWaitTime);
			CloseHandle(pTh->m_hEventOpDone);

			switch(ThreadStat)
			{
				case WAIT_OBJECT_0: // This is the normal way threads exit quickly
					TRACE("TPM:CEzMrView::bMainDlgProcThread(): Thread WAIT_OBJECT_0\n"); 
					bResult = 1;
					switch(wParam)
					{ // Post Op processing