pcd_echo.c

来自「Usb Host/Periphel Control TD1120 codes」· C语言 代码 · 共 702 行 · 第 1/2 页

/*------------------------------------------------------------------------------
$File: //tdi_sw/tdi/examples/usb/pcd/echo/pcd_echo.c $
$DateTime: 2004/12/20 19:06:16 $
$Revision: #11 $
Purpose: PCD test application to exercise the PCD API
------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
CONFIDENTIAL AND PROPRIETARY INFORMATION OF SOFTCONNEX TECHNOLOGIES, INC.

THIS NOTICE IS NOT TO BE DELETED, MODIFIED, MOVED OR CHANGED IN ANY WAY.

Copyright (c) 1999 - 2004 by SoftConnex Technologies, Inc. 

This software is protected by copyright laws and international copyright 
treaties, as well as other intellectual property laws and treaties.  This
software is a CONFIDENTIAL, unpublished work of authorship, and with portions 
constituting TRADE SECRETS of SoftConnex Technologies, Inc., a Delaware USA 
corporation.  Any unauthorized use, disclosure,	and/or reproduction of this 
software, or any part of this software; or distribution of this software in any 
form or by any means; or storage of this software in any database or retrieval 
system, without the express written consent of, and license from, SoftConnex 
Technologies, Inc. is strictly prohibited.  This software is protected under the
copyright and/or trade secret laws in other countries in addition to USA.  All 
Rights Reserved.  Failure to abide by the use, disclosure and/or reproduction 
restrictions may result in civil and /or criminal penalties, and will be 
prosecuted to the maximum extent of the law.
------------------------------------------------------------------------------*/
#include "project.h"

extern TdiPeriphController* globalPeriphHandle;
extern volatile SctBool enumerationDone;
extern volatile SctBool configurationDone;
extern volatile U32 appState;

extern volatile U8 vendorCommandStatus;

U8 tempVar = 0;

STATIC volatile SctBool bulkInTransferDone= SCC_FALSE;
STATIC volatile SctBool bulkOutTransferDone = SCC_FALSE;
STATIC volatile SctBool intrInTransferDone = SCC_FALSE;
STATIC volatile SctBool intrOutTransferDone = SCC_FALSE;
STATIC volatile SctBool isoInTransferDone = SCC_FALSE;
STATIC volatile SctBool isoOutTransferDone = SCC_FALSE;
STATIC volatile U32 deviceState;

STATIC U8 PCDECHO_BulkBuffer[PCDAPPXFERLENGTH];
STATIC U8 PCDECHO_IsoBuffer[PCDAPPXFERLENGTH];
STATIC U8 PCDECHO_IntrBuffer[PCDAPPXFERLENGTH];

TdiPurb bulkInUrb;
TdiPurb bulkInUrb0;
TdiPurb bulkInUrb1;
TdiPurb bulkOutUrb;
TdiPurb isoInUrb;
TdiPurb isoOutUrb;
TdiPurb intrInUrb;
TdiPurb intrOutUrb;

/*------------------------------------------------------------------------------
Name      : PCDAPP_ProcessClassCommand
Purpose   : Process Class command
Arguments : pc - peripheral controller handle
            request - setup packet
Returns   : SctStatus
Notes     : 
-----------------------------------------------------------------------------*/
SctStatus PCDAPP_ProcessClassCommand(TdiPeriphController* pc, 
                                     PeriphSetupRequest* request)
   {
   /* Nothing to do- Dummy function */
   return SCS_SUCCESS;
   }

/*------------------------------------------------------------------------------
Name      : PCDAPP_ProcessVendorCommand
Purpose   : Process Vendor command
Arguments : pc - peripheral controller handle
            request - setup packet
Returns   : SctStatus
Notes     : 
-----------------------------------------------------------------------------*/
SctStatus PCDAPP_ProcessVendorCommand(TdiPeriphController* pc, 
                                      PeriphSetupRequest* request)
   {
   /* All class-specific commands to be processed here */
   switch (request->bRequest)
      {
      case TDI_TRANSFER_STATUS_TEST_DONE:
         appState = APP_STATE_XFER_STAT_CMD_RX;
         request->data = (U8 *)&vendorCommandStatus;
         request->actualLength = 1;
      break;
      case TDI_CANCEL_TRANSFER_TEST:
         appState = APP_STATE_XFER_CANCEL_CMD_RX;
         request->data = (U8 *)&vendorCommandStatus;
         request->actualLength = 1;
      break;
      case TDI_CANCEL_SECOND_TRANSFER_TEST:
         appState = APP_STATE_2ND_XFER_CANCEL_CMD_RX;
         request->data = (U8 *)&vendorCommandStatus;
         request->actualLength = 1;
      break;
      case TDI_CANCEL_EP_ALL_TRANSFER_TEST:
         appState = APP_STATE_CANCEL_ALL_XFERS_CMD_RX;
         request->data = (U8 *)&vendorCommandStatus;
         request->actualLength = 1;
      break;
      case TDI_START_ECHO_TEST:
         appState = APP_STATE_START_ECHO_TEST_CMD_RX;
         request->data = (U8 *)&tempVar;
         request->actualLength = 1;
         vendorCommandStatus = 0;
      break;
      case TDI_TEST_DEVICE_READY_FOR_OUT:
         appState = APP_STATE_RDY_FOR_OUT_CMD_RX;
         request->data = (U8 *)&vendorCommandStatus;
         request->actualLength = 1;
      break;
      case TDI_TEST_DEVICE_READY_FOR_IN:
         appState = APP_STATE_RDY_FOR_IN_CMD_RX;
         request->data = (U8 *)&vendorCommandStatus;
         request->actualLength = 1;
      return SCS_SUCCESS;
      default:
         return SCS_ERROR;
      }
   return SCS_SUCCESS;
   }

/*------------------------------------------------------------------------------
Name      : PCDECHO_BulkInCallBack
Purpose   : Call back function for Bulk In completion
Arguments : urb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_BulkInCallBack(TdiPurb *urb)
   {
   bulkInTransferDone = SCC_TRUE;
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_BulkOutCallBack
Purpose   : Call back function for Bulk Out completion
Arguments : urb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_BulkOutCallBack(TdiPurb *urb)
   {
   bulkOutTransferDone = SCC_TRUE;
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_IntrInCallBack
Purpose   : Call back function for Intr In completion
Arguments : urb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_IntrInCallBack(TdiPurb *urb)
   {
   intrInTransferDone = SCC_TRUE;
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_IntrOutCallBack
Purpose   : Call back function for Intr Out completion
Arguments : urb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_IntrOutCallBack(TdiPurb *urb)
   {
   intrOutTransferDone = SCC_TRUE;
   }
  
/*------------------------------------------------------------------------------
Name      : PCDECHO_IsoInCallBack
Purpose   : Call back function for Iso In completion
Arguments : urb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_IsoInCallBack(TdiPurb *urb)
   {
   isoInTransferDone = SCC_TRUE;
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_IsoOutCallBack
Purpose   : Call back function for Iso Out completion
Arguments : urb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_IsoOutCallBack(TdiPurb *urb)
   {
   isoOutTransferDone = SCC_TRUE;
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_AppTestTransferStatus
Purpose   : Test 'Get Transfer Status' on peripheral
Arguments : pc - peripheral controller handle
            bulkInUrb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_AppTestTransferStatus(TdiPeriphController* pc)
   {
   SctStatus status;
   U32 transferStatus;
   
   /* Create and initialize an Urb for handling a bulk transfer */
   ep6->urb = &bulkInUrb;
   bulkInUrb.direction = USB_SEND;
   bulkInUrb.length = PCDAPPXFERLENGTH;
   bulkInUrb.lengthSoFar = 0;
   bulkInUrb.dataPosition = 0;
   bulkInUrb.status = 0;
   bulkInUrb.ep = ep6;
   bulkInUrb.data = PCDECHO_BulkBuffer;
   bulkInUrb.pc = pc;
   bulkInUrb.callBackFunction = PCDECHO_BulkInCallBack;
   
   /* Some transfer that won't be initiated by host */
   status = PCD_Transfer(pc, &bulkInUrb);

   /* Check transfer Status */   
   status = PCD_GetTransferStatus(pc, &bulkInUrb, &transferStatus);
   
   if (TRANSFER_STATUS_COMPLETE == transferStatus)
      {
      PRINTF1(("\nTransfer completed so can't cancel transfer."));
      }
      
   vendorCommandStatus = 1;
   
   /* Wait for vendor-specific command to complete before moving 
   ** onto next command 
   */
   while (vendorCommandStatus)
      {
      /* Do nothing */
      }
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_AppTestCancelTransfer
Purpose   : Test 'Transfer Cancel' on peripheral
Arguments : pc - peripheral controller handle
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_AppTestCancelTransfer(TdiPeriphController* pc)
   {
   SctStatus status;
   U32 transferStatus;
   
   /* Cancel the enqueued transfer */   
   status = PCD_CancelTransfer(pc, &bulkInUrb);
      
   status = PCD_GetTransferStatus(pc, &bulkInUrb, &transferStatus);
   
   /* Should return cancelled because the previous transfer should have 
      cancelled right away */
   if (transferStatus != TRANSFER_STATUS_CANCELLED)
      {
      PRINTF1(("\nCould not cancel Transfer 0."));
      }
      
   vendorCommandStatus = 1;
      
   while (vendorCommandStatus)
      {
      /* Do nothing */
      }
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_AppTestCancel2ndTransfer
Purpose   : Test 'Cancel 2nd transfer of two enqueued' on peripheral
Arguments : pc - peripheral controller handle
            bulkInUrb0 - pointer to urb structure
            bulkInUrb1 - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/
STATIC void PCDECHO_AppTestCancel2ndTransfer(TdiPeriphController* pc)
   {
   SctStatus status;
   U32 transferStatus;
   
   /* Now enqueue two transfers and cancel second Urb  */
   ep6->urb = &bulkInUrb0;
   bulkInUrb0.direction = USB_SEND;
   bulkInUrb0.length = PCDAPPXFERLENGTH;
   bulkInUrb0.lengthSoFar = 0;
   bulkInUrb0.dataPosition = 0;
   bulkInUrb0.status = 0;
   bulkInUrb0.ep = ep6;
   bulkInUrb0.data = PCDECHO_BulkBuffer;
   bulkInUrb0.pc = pc;
   bulkInUrb0.callBackFunction = PCDECHO_BulkInCallBack;
   
   /* Some transfer that won't be initiated by host */
   status = PCD_Transfer(pc, &bulkInUrb0);
   
   /* Now enqueue two transfers and cancel second Urb  */
   ep6->urb->nextUrb = &bulkInUrb1;
   bulkInUrb1.direction = USB_SEND;
   bulkInUrb1.length = PCDAPPXFERLENGTH;
   bulkInUrb1.lengthSoFar = 0;
   bulkInUrb1.dataPosition = 0;
   bulkInUrb1.status = 0;
   bulkInUrb1.ep = ep6;
   bulkInUrb1.data = PCDECHO_BulkBuffer;
   bulkInUrb1.pc = pc;
   bulkInUrb1.callBackFunction = PCDECHO_BulkInCallBack;
   
   /* Some transfer that won't be initiated by host */
   status = PCD_Transfer(pc, &bulkInUrb1);
   
   /* Check transfer Status */   
   status = PCD_GetTransferStatus(pc, &bulkInUrb0, &transferStatus);
   
   if (TRANSFER_STATUS_COMPLETE == transferStatus)
      {
      PRINTF1(("\nTransfer completed on Urb 0."));
      }
      
   /* Check transfer Status */   
   status = PCD_GetTransferStatus(pc, &bulkInUrb1, &transferStatus);
   
   if (TRANSFER_STATUS_COMPLETE == transferStatus)
      {
      PRINTF1(("\nTransfer completed on Urb 1."));
      }
   else
      {
      /* Cancel the enqueued transfer */   
      status = PCD_CancelTransfer(pc, &bulkInUrb1);
      }
      
   /* Check transfer Status */   
   status = PCD_GetTransferStatus(pc, &bulkInUrb1, &transferStatus);
   
   if (TRANSFER_STATUS_CANCELLED != transferStatus)