pcd_echo.c

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

      {
      PRINTF1(("\nCould not cancel Transfer 1."));
      }
      
   vendorCommandStatus = 1;
   
   while (vendorCommandStatus)
      {
      /* Do nothing */
      }
   }
/*------------------------------------------------------------------------------
Name      : PCDECHO_AppTestCancelAllTransfers
Purpose   : Test 'Cancel all transfers' on the same endpoint
Arguments : pc - peripheral controller handle
            bulkInUrb0 - pointer to urb structure
            bulkInUrb1 - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/   
STATIC void PCDECHO_AppTestCancelAllTransfers(TdiPeriphController* pc)
   {
   SctStatus status;
   U32 transferStatus;
   
   /* Now enqueue two transfers and cancel all tranfers */
   /* 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;
   bulkInUrb1.nextUrb = NULL;
   
   /* 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."));
      }
      
   /* Cancel the enqueued transfer */   
   status = PCD_CancelAllTransfers(pc, ep6);
   
   /* Check transfer Status */   
   status = PCD_GetTransferStatus(pc, &bulkInUrb0, &transferStatus);
   
   if (TRANSFER_STATUS_CANCELLED != transferStatus)
      {
      PRINTF1(("\nCould not cancel Transfer 2."));
      }
      
   /* Check transfer Status */   
   status = PCD_GetTransferStatus(pc, &bulkInUrb1, &transferStatus);
   
   if (TRANSFER_STATUS_CANCELLED != transferStatus)
      {
      PRINTF1(("\nCould not cancel Transfer 3."));
      }
      
   vendorCommandStatus = 1;
   
   while (vendorCommandStatus)
      {
      /* Do nothing */
      }
   }
/*------------------------------------------------------------------------------
Name      : PCDECHO_AppTestOUTTransfers
Purpose   : Test Iso Out, Intrpt Out, and Bulk Out transfers on the an endpoint
Arguments : pc - peripheral controller handle
            isoOutUrb - pointer to urb structure
            intrOutUrb - pointer to urb structure
            bulkOutUrb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/    
STATIC void PCDECHO_AppTestOUTTransfers(TdiPeriphController* pc)
   {
   SctStatus status;
   
   ep1->urb = &isoOutUrb;
   isoOutUrb.direction = 0;
   isoOutUrb.length = PCDAPPXFERLENGTH;
   isoOutUrb.lengthSoFar = 0;
   isoOutUrb.dataPosition = 0;
   isoOutUrb.status = 0;
   isoOutUrb.ep = ep1;
   isoOutUrb.data = PCDECHO_IsoBuffer;
   isoOutUrb.pc = pc;
   isoOutUrb.callBackFunction = PCDECHO_IsoOutCallBack;
   
   /* init URB for Isochronous Rx */
   status = PCD_Transfer(pc, &isoOutUrb);
   
   if (status != SCS_SUCCESS)
      {
      PRINTF1(("\nISO OUT Transfer Error."));
      }
   
   ep3->urb = &intrOutUrb;
   intrOutUrb.direction = 0;
   intrOutUrb.length = PCDAPPXFERLENGTH;
   intrOutUrb.lengthSoFar = 0;
   intrOutUrb.dataPosition = 0;
   intrOutUrb.status = 0;
   intrOutUrb.ep = ep3;
   intrOutUrb.data = PCDECHO_IntrBuffer;
   intrOutUrb.pc = pc;
   intrOutUrb.callBackFunction = PCDECHO_IntrOutCallBack;
   
   /* init URB interrupt Rx */
   status = PCD_Transfer(pc, &intrOutUrb);
   
   if (status != SCS_SUCCESS)
      {
      PRINTF1(("\nINTR OUT Transfer Error."));
      }
   
   ep5->urb = &bulkOutUrb;
   bulkOutUrb.direction = 0;
   bulkOutUrb.length = PCDAPPXFERLENGTH;
   bulkOutUrb.lengthSoFar = 0;
   bulkOutUrb.dataPosition = 0;
   bulkOutUrb.status = 0;
   bulkOutUrb.ep = ep5;
   bulkOutUrb.data = PCDECHO_BulkBuffer;
   bulkOutUrb.pc = pc;
   bulkOutUrb.callBackFunction = PCDECHO_BulkOutCallBack;
   
   /* init URB for bulk Rx */
   status = PCD_Transfer(pc, &bulkOutUrb);
   
   if (status != SCS_SUCCESS)
      {
      PRINTF1(("\nBULK OUT Transfer Error."));
      }
      
   vendorCommandStatus = 1;
   
   while (vendorCommandStatus)
      {
      /* Do nothing */
      }
      
   appState = 0xFF;
   
   while (!(isoOutTransferDone && intrOutTransferDone && bulkOutTransferDone))
      {
      }
      
   isoOutTransferDone = SCC_FALSE;
   intrOutTransferDone = SCC_FALSE;
   bulkOutTransferDone = SCC_FALSE;
   }
   
/*------------------------------------------------------------------------------
Name      : PCDECHO_AppTestINTransfers
Purpose   : Test Iso In, Intrpt In, and Bulk In transfers on the an endpoint
Arguments : pc - peripheral controller handle
            isoInUrb - pointer to urb structure
            intrInUrb - pointer to urb structure
            bulkInUrb - pointer to urb structure
Returns   : None
Notes     : None
-----------------------------------------------------------------------------*/    
STATIC void PCDECHO_AppTestINTransfers(TdiPeriphController* pc)
   {
   SctStatus status;
   
   ep2->urb = &isoInUrb;      
   isoInUrb.direction = USB_REQUEST_DIRECTION_IN;
   isoInUrb.length = PCDAPPXFERLENGTH;
   isoInUrb.lengthSoFar = 0;
   isoInUrb.dataPosition = 0;
   isoInUrb.status = 0;
   isoInUrb.ep = ep2;
   isoInUrb.data = PCDECHO_IsoBuffer;
   isoInUrb.pc = pc;
   isoInUrb.callBackFunction = PCDECHO_IsoInCallBack;
   
   /* init URB for Isochronous Rx */
   status = PCD_Transfer(pc, &isoInUrb);
   
   if (status != SCS_SUCCESS)
      {
      PRINTF1(("\nISO IN Transfer Error."));
      }
   
   ep4->urb = &intrInUrb;
   intrInUrb.direction = USB_REQUEST_DIRECTION_IN;
   intrInUrb.length = PCDAPPXFERLENGTH;
   intrInUrb.lengthSoFar = 0;
   intrInUrb.dataPosition = 0;
   intrInUrb.status = 0;
   intrInUrb.ep = ep4;
   intrInUrb.data = PCDECHO_IntrBuffer;
   intrInUrb.pc = pc;
   intrInUrb.callBackFunction = PCDECHO_IntrInCallBack;
   
   /* init URB for Interrupt Rx */
   status = PCD_Transfer(pc, &intrInUrb);
   
   if (status != SCS_SUCCESS)
      {
      PRINTF1(("\nINTR IN Transfer Error."));
      }
   
   ep6->urb = &bulkInUrb;
   bulkInUrb.direction = USB_REQUEST_DIRECTION_IN;
   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;
   
   /* init URB for Bulk Tx */
   status = PCD_Transfer(pc, &bulkInUrb);
   
   if (status != SCS_SUCCESS)
      {
      PRINTF1(("\nBulk IN Transfer Error."));
      }
   
   vendorCommandStatus = 1;
   
   while (vendorCommandStatus)
      {
      /* Do nothing */
      }
      
   appState = 0xFF;
      
   while (!(isoInTransferDone && intrInTransferDone && bulkInTransferDone))
      {
      }
      
   isoInTransferDone = SCC_FALSE;
   intrInTransferDone = SCC_FALSE;
   bulkInTransferDone = SCC_FALSE;
   }

/*------------------------------------------------------------------------------
Name      : PCDECHO_App
Purpose   : This function is used to run a test application to exercise different
            PCD API functions
Arguments : None
Returns   : None
Notes     : This function is an example for PCD API usage
-----------------------------------------------------------------------------*/
void PCDECHO_App(void)
   {
   U32 status;
   U32 frameNum;
   TdiPeriphController* pc = globalPeriphHandle;
   
   while (!enumerationDone)
      {
      /* Do nothing */
      }
      
   while (!configurationDone)
      {
      /* Do nothing */
      }

   while (1)
      {   
      switch (appState)
         {
         case APP_STATE_DEVICE_DETACHED:
         break;
         case APP_STATE_CONFIG_DONE:
            /* Get frame number */
            status = PCD_GetFrameNumber(pc, &frameNum);

            /* Get current device state */   
            status = PCD_GetDeviceState(pc, (U32*)&deviceState);
         break;
         case APP_STATE_XFER_STAT_CMD_RX:
            appState = 0xFF;
            PCDECHO_AppTestTransferStatus(pc);
         break;
         case APP_STATE_XFER_CANCEL_CMD_RX:
            appState = 0xFF;
            PCDECHO_AppTestCancelTransfer(pc);
         break;
         case APP_STATE_2ND_XFER_CANCEL_CMD_RX:
            appState = 0xFF;
            PCDECHO_AppTestCancel2ndTransfer(pc);
         break;
         case APP_STATE_CANCEL_ALL_XFERS_CMD_RX:
            appState = 0xFF;
            PCDECHO_AppTestCancelAllTransfers(pc);
         break;
         case APP_STATE_START_ECHO_TEST_CMD_RX:
            appState = 0xFF;
            while (vendorCommandStatus)
               {
               /* Wait until cleared by control transfer completion routine */
               }
         break;
         case APP_STATE_RDY_FOR_OUT_CMD_RX:
            appState = 0xFF;
            PCDECHO_AppTestOUTTransfers(pc);
         break;
         case APP_STATE_RDY_FOR_IN_CMD_RX:
            appState = 0xFF;
            PCDECHO_AppTestINTransfers(pc);
         break;
         default:
         break;
         }
      }
   }