ezmain.cpp

FX2 68013的控制面板源程序

////////////////////////////////////////////////////////////////////////////////
// EzMain.cpp : IOCTL call implementation file
// $Header: /USB/Util/EzMr/EzMain.cpp 12    4/25/02 11:29p 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" //TPM for precompiled headers

#include <windows.h>
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

#include "resource.h"

#define USING_MFC //TPM to redirect output 
char PIPE_TYPE_STRINGS[4][4] = 
{
"CTL",
"ISO",
"BLK",
"INT"
};

char PIPE_DIRECTION[2][4] = 
{
"OUT",
"IN "
};

void EzSendMessage(CString& hDlg, int OpType, int* OtherOp, LPARAM pStr);
void ShowSystemError(CString& hOutputBox);
void GetURBErrString(ULONG urbStatus, char* pStr);
void ParseStringDescriptor(PVOID pvBuffer, CString& hOutputBox);

void ParseDeviceDescriptor(PVOID pvBuffer, CString& hOutputBox);
void ParseConfigurationDescriptor(PVOID pvBuffer, CString& hOutputBox);
void DumpBuffer(PVOID pvBuffer, ULONG length, CString& hOutputBox);

BOOL DoIoctl(
  HANDLE hDevice,              // handle to device of interest
  DWORD dwIoControlCode,       // control code of operation to perform
  LPVOID lpInBuffer,           // pointer to buffer to supply input data
  DWORD nInBufferSize,         // size, in bytes, of input buffer
  LPVOID lpOutBuffer,          // pointer to buffer to receive output data
  DWORD nOutBufferSize,        // size, in bytes, of output buffer
  LPDWORD lpBytesReturned,     // pointer to variable to receive byte count
  LPOVERLAPPED lpOverlapped,    // pointer to structure for asynchronous operation
  CString& hOutputBox
);

#include "main.h"

#ifdef USING_MFC
#undef MAINTAIN_OUTPUT_BOX
#define MAINTAIN_OUTPUT_BOX(hO, nI)
#endif

#include "ezmr.h"
#include "ezusbsys.h"

//#define TNG_TEST
#ifdef TNG_TEST
#define ALLOCATE_EXTERN
#define xdata 
/*
#ifndef IN0BUF
#define IN0BUF 0x7F00
#define IN1BUF 0x7E80
#define IN2BUF 0x7E00
#define IN3BUF 0x7D80
#define IN4BUF 0x7D00
#define IN5BUF 0x7C80
#define IN6BUF 0x7C00
#define IN7BUF 0x7B80
#define OUT0BUF 0x7CC0
#define OUT1BUF 0x7E40
#define OUT2BUF 0x7CC0
#define OUT3BUF 0x7D40
#define OUT4BUF 0x7CC0
#define OUT5BUF 0x7C40
#define OUT6BUF 0x7BC0
#define OUT7BUF 0x7B40
#define OUT8DATA 0x7F60
#define IN8DATA 0x7F68
#endif
*/
#include "..\..\..\Examples\Ezusb\DMATest\DMATest.h" // for Vendor Specific Request
#undef ALLOCATE_EXTERN
#undef xdata 
// EzUSB Region Selections (used as source or sink for data transfers)
/*
TYPE_MEM_SEG SegDef[] = 
{ //  ID, StartAddr,   Length			// ID is arbitrary and used for LED output
	0x00, 0,           0,
	0x10, START_MEM00, LENGTH_MEM00, 
	0x11, START_MEM01, LENGTH_MEM01,
	0x12, START_MEM02, LENGTH_MEM02, 
	0x13, START_MEM03, LENGTH_MEM03,

	0xB0, 0x7F00, LENGTH_BULK_BUFF,
	0xB1, 0x7E80, LENGTH_BULK_BUFF,
	0xB2, 0x7E00, LENGTH_BULK_BUFF,
	0xB3, 0x7D80, LENGTH_BULK_BUFF,
	0xB4, 0x7D00, LENGTH_BULK_BUFF,
	0xB5, 0x7C80, LENGTH_BULK_BUFF,
	0xB6, 0x7C00, LENGTH_BULK_BUFF,
	0xB7, 0x7B80, LENGTH_BULK_BUFF,

	0xB8, 0x7EC0, LENGTH_BULK_BUFF,
	0xB9, 0x7E40, LENGTH_BULK_BUFF,
	0xBA, 0x7DC0, LENGTH_BULK_BUFF,
	0xBB, 0x7D40, LENGTH_BULK_BUFF,
	0xBC, 0x7CC0, LENGTH_BULK_BUFF,
	0xBD, 0x7C40, LENGTH_BULK_BUFF,
	0xBE, 0x7BC0, LENGTH_BULK_BUFF,
	0xBF, 0x7B40, LENGTH_BULK_BUFF,

	0xC0, 0x7F60, 0x07,					// ISO Out registers
	0xC1, 0x7F68, 0x07,					// ISO In registers
	0xC2, START_ISO, LENGTH_ISO,			// Reclaimed ISO (ISO buffers as memory)

//	0x20, START_RAM_EXT_0, LENGTH_RAM_EXT_0, //TBD
//	0x21, START_RAM_EXT_1, LENGTH_RAM_EXT_1, //TBD

	0x90, START_WF_DESC, LENGTH_WF_DESC, 	// WF Descr memory

	0xFA, START_FIFO_AOUT, LENGTH_FIFO_AOUT, 	// FIFO A OUT
	0xFB, START_FIFO_BOUT, LENGTH_FIFO_BOUT, 	// FIFO B OUT
//	0xFC, START_FIFO_AOUT, LENGTH_FIFO_AOUT, 	// FIFO A&B OUT
	0xFD, START_FIFO_AIN, LENGTH_FIFO_AIN, 		// FIFO A IN
	0xFE, START_FIFO_BIN, LENGTH_FIFO_BIN, 		// FIFO B IN
//	0xFF, START_FIFO_AIN, LENGTH_FIFO_AIN, 		// FIFO A&B IN
	0xF9, START_FIFO_EXT, LENGTH_FIFO_EXT, 		// Ext Ram as FIFO

	0xDA, START_FIFO_AOUT, LENGTH_FIFO_AOUT, 	// FIFO A OUT (DoubleByte)
	0xDB, START_FIFO_BOUT, LENGTH_FIFO_BOUT, 	// FIFO B OUT (DoubleByte)
	0xDC, START_FIFO_AOUT, LENGTH_FIFO_AOUT, 	// FIFO A&B OUT (Toggle)
	0xDD, START_FIFO_AIN, LENGTH_FIFO_AIN, 		// FIFO A IN (DoubleByte)
	0xDE, START_FIFO_BIN, LENGTH_FIFO_BIN, 		// FIFO B IN (DoubleByte)
	0xDF, START_FIFO_AIN, LENGTH_FIFO_AIN, 		// FIFO A&B IN (Toggle)
};
*/
#endif

HINSTANCE hGInstance = NULL;

int my_sscanf(LPCSTR cBuffer, DWORD *data);

char *build_time = __TIME__;
char *build_date = __DATE__;

/**************************************************
 * Main Dialog proc                               *
 **************************************************/

BOOL CALLBACK bMainDlgProc(LPVOID pThread, HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
#ifndef USING_MFC
    HWND    hOutputBox                      = NULL;
    char    pcDriverName[MAX_DRIVER_NAME]   = "";
    hOutputBox = GetDlgItem (hDlg, IDC_OUTPUT_BOX); // Get a handle to the output box
    GetDlgItemText (hDlg, IDC_DRIVER_NAME, pcDriverName, MAX_DRIVER_NAME);
#else
	CThreadInfo* pTh = (CThreadInfo*)pThread;
	char* pcDriverName = (LPTSTR)(LPCTSTR)pTh->strpcDriverName;
	TRACE("TPM:CEzMain::Exec IOCTL:OpType=%d\n", wParam);
	CString& hOutputBox = pTh->strIoctlOut;
#endif
    char    tempbuff[256];
    HANDLE  hDevice                         = NULL;
    BOOLEAN bResult                         = FALSE;
    int     nBytes                          = 0;
    PVOID   pvBuffer                        = 0;
    int     nItems                          = 0;
    ULONG   ulLength                         = 0;


    MAINTAIN_OUTPUT_BOX (hOutputBox, nItems);

    switch(message)
    {
	case WM_LBUTTONDOWN:
		MAINTAIN_OUTPUT_BOX (hOutputBox, nItems);
		EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"you clicked");
		break;
		
	case WM_INITDIALOG:
		sprintf(tempbuff,"EZ-USB Control Panel - built %s %s",build_time,build_date);
		EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)tempbuff);
		break; /*end WM_INITDIALOG case*/
		
	case WM_COMMAND:
		switch(LOWORD(wParam))
		{
		case IDC_CLEAR:
			{
				EzSendMessage (hOutputBox, LB_RESETCONTENT, 0, 0);
			}
			break;
			
		case IDC_RESET_HLD:
		case IDC_RESET_RLS:
			{
				VENDOR_REQUEST_IN	myRequest;
				MAINTAIN_OUTPUT_BOX (hOutputBox, nItems);
				EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Toggle 8051 Reset");
				
				// Open the driver
				if (bOpenDriver (&hDevice, pcDriverName) != TRUE)
				{
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Failed to Open Driver");
					hDevice = NULL;
				}
				
				myRequest.bRequest = 0xA0;
				if(pTh->bFX2)
				  myRequest.wValue = 0xE600; // using CPUCS.0 in FX2
				else
				  myRequest.wValue = 0x7F92;
				myRequest.wIndex = 0x00;
				myRequest.wLength = 0x01;
				myRequest.bData = (LOWORD(wParam) == IDC_RESET_HLD) ? 1 : 0;
				myRequest.direction = 0x00;
				
				if (hDevice != NULL) 
				{// Perform the Get-Descriptor IOCTL
					bResult = DeviceIoControl (hDevice,
						IOCTL_Ezusb_VENDOR_REQUEST,
						&myRequest,
						sizeof(VENDOR_REQUEST_IN),
						NULL,
						0,
						(unsigned long *)&nBytes,
						NULL);
					
				}/* if valid driver handle */
				
				if (bResult==TRUE)
				{
					// do nothin
				}
				else
				{
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Reset Failed");
					ShowSystemError(hOutputBox);
				}
				
				// Close the handle
				CloseHandle (hDevice);
			}
			
			break;
			
		case IDC_VEND_REQUEST:
			{
                VENDOR_OR_CLASS_REQUEST_CONTROL	myRequest;
                char *buffer;
                ULONG bufferSize = 0;
                
                MAINTAIN_OUTPUT_BOX (hOutputBox, nItems);
                
                EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Vendor Request");
                
                // Open the driver
                if (bOpenDriver (&hDevice, pcDriverName) != TRUE)
				{
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Failed to Open Driver");
					hDevice = NULL;
                }
                
                
#ifdef USING_MFC
                myRequest.request = (UCHAR) pTh->request;
                myRequest.value = (USHORT) pTh->value;
                myRequest.index = (USHORT) pTh->index;
                myRequest.direction = pTh->direction;
                bufferSize = pTh->length;
                buffer = (char *)pTh->pBuf;
#else
                char tempbuff[MAX_DRIVER_NAME];
                DWORD myDword;
                BOOL Success;
                GetDlgItemText (hDlg, IDC_BREQUEST, tempbuff, MAX_DRIVER_NAME);
                my_sscanf(tempbuff,&myDword);
                myRequest.request = (BYTE) myDword;
                GetDlgItemText (hDlg, IDC_WVALUE, tempbuff, MAX_DRIVER_NAME);
                my_sscanf(tempbuff,&myDword);
                myRequest.value = (WORD) myDword;
                GetDlgItemText (hDlg, IDC_WINDEX, tempbuff, MAX_DRIVER_NAME);
                my_sscanf(tempbuff,&myDword);
                myRequest.index = (WORD) myDword;
                GetDlgItemText (hDlg, IDC_WLENGTH, tempbuff, MAX_DRIVER_NAME);
                my_sscanf(tempbuff,&myDword);
                bufferSize = (WORD) myDword;
                myRequest.direction = GetDlgItemInt(hDlg,IDC_DIRECTION,&Success,FALSE);
#endif
                myRequest.requestType=2; // vendor specific request type (2)
                myRequest.recepient=0; // recepient is device (0)
				
#ifdef TNG_TEST
				if((pTh->request == 0xCa))
				{

				  BYTE SrcIdx;
				  WORD i;
				  PTYPE_MEM_SEG pSrc;
				  PTYPE_MEM_SEG pDst;
				  bufferSize = (WORD) 0x32;
				  for(SrcIdx=1; SrcIdx<(sizeof(SegDef)/sizeof(TYPE_MEM_SEG)); SrcIdx++)
//				  for(SrcIdx=1; SrcIdx<2; SrcIdx++)
				  {
					for(i=1; i<(sizeof(SegDef)/sizeof(TYPE_MEM_SEG)); i++)
					//for(i=1; i<5; i++)
					{
					  pSrc = &SegDef[SrcIdx];
					  pDst = &SegDef[i];

					  myRequest.request = 0xAa;
					  myRequest.value = (WORD) (pSrc->Id << 8);
					  myRequest.value |= (WORD) pDst->Id;
//					  myRequest.index = (0x0100);
					  myRequest.direction = 0x1;
					  bufferSize = 32;

						bResult = DoIoctl(hDevice,
						IOCTL_EZUSB_VENDOR_OR_CLASS_REQUEST,
						&myRequest,
						sizeof(VENDOR_OR_CLASS_REQUEST_CONTROL),
						buffer,
						bufferSize,
						(unsigned long *)&nBytes,
						NULL,
						hOutputBox);
					}
				  }	
				  break;
				}
				if((pTh->request == 0xCb))
				{
				  WORD i;
				  bufferSize = (WORD) 0x32;
				  for(i=1; i<(sizeof(FifoTestDef)/sizeof(TYPE_FIFO_TESTS)); i++)
				  {
					  myRequest.request = 0xAb;
					  myRequest.value = (WORD) 0x3F00;
					  if((i==0x9)||(i==0xA)||(i==0xB)||(i==0xC)||(i==0xF))
						myRequest.value = (WORD) 0x1F00;
//					  if(i==0xA)
//						  continue; //TPMTPMTPM // SKIP A TEST!
					  myRequest.value |= (WORD) i;
					  myRequest.direction = 0x1;

						bResult = DoIoctl(hDevice,
						IOCTL_EZUSB_VENDOR_OR_CLASS_REQUEST,
						&myRequest,
						sizeof(VENDOR_OR_CLASS_REQUEST_CONTROL),
						buffer,
						bufferSize,
						(unsigned long *)&nBytes,
						NULL,
						hOutputBox);
				  }
				  break;
				}
#endif
                if (hDevice != NULL) 
				{
					bResult = DeviceIoControl (hDevice,
						IOCTL_EZUSB_VENDOR_OR_CLASS_REQUEST,
						&myRequest,
						sizeof(VENDOR_OR_CLASS_REQUEST_CONTROL),
						buffer,
						bufferSize,
						(unsigned long *)&nBytes,
						NULL);
                }/* if valid driver handle */
                
                if (bResult==TRUE)
                {
					if(theApp.m_nVerbose)
						//DumpBuffer(buffer,bufferSize,hOutputBox);
						DumpBuffer(buffer,nBytes,hOutputBox); // show nBytes returned
                }
                else
				{
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Vendor Request failed");
					ShowSystemError(hOutputBox);
				}
                
                CloseHandle (hDevice);
			}
			break;
			
		case IDC_GET_PIPE_INFO:
			{
				UCHAR InterfaceInfo[1024];
				PUSBD_INTERFACE_INFORMATION pInterface;
				PUSBD_PIPE_INFORMATION pPipe;
				
				MAINTAIN_OUTPUT_BOX (hOutputBox, nItems);
				
				EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Get PipeInfo");
				
				// Open the driver
				if (bOpenDriver (&hDevice, pcDriverName) != TRUE)
				{
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Failed to Open Driver");
					hDevice = NULL;
				}
				
				
				if (hDevice != NULL) 
				{// Perform the Get-Descriptor IOCTL
					bResult = DeviceIoControl (hDevice,
						IOCTL_Ezusb_GET_PIPE_INFO,
						NULL,
						0,
						InterfaceInfo,
						sizeof(InterfaceInfo),
						(unsigned long *)&nBytes,
						NULL);
				}/* if valid driver handle */
				
				if (bResult==TRUE)
				{
					int i;
					char                   temp[64]  = "";
					wsprintf (temp, "Interface Size %d",nBytes);
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)temp);
					pInterface = (PUSBD_INTERFACE_INFORMATION) InterfaceInfo;
					pPipe = pInterface->Pipes;
#ifdef USING_MFC
					memcpy(theApp.m_uInterfaceInfo, pInterface, sizeof(InterfaceInfo));
#endif
					for (i = 0; i < (int) pInterface->NumberOfPipes; i++)
					{
	                       wsprintf (temp, "Pipe: %2d   Type: %s Endpoint: %2d %s  MaxPktSize: 0x%x",i,PIPE_TYPE_STRINGS[pPipe[i].PipeType],(pPipe[i].EndpointAddress & 0x0F),
							   PIPE_DIRECTION[(pPipe[i].EndpointAddress >> 7)],pPipe[i].MaximumPacketSize);
						   EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)temp);
					}
				}
				else
				{
					EzSendMessage (hOutputBox, LB_ADDSTRING, 0, (LPARAM)"Get Pipe Info failed");
					ShowSystemError(hOutputBox);
				}
				// Close the handle
				CloseHandle (hDevice);
			}
			break;
			
		case IDC_ISO_TRANSFER:
			{