papp_eve.c

Usb Host/Periphel Control TD1120 codes

   controlInUrb.status = 0;
   controlInUrb.callBackFunction = PCDAPP_EVE_ControlTransferDone;
   controlInUrb.pc = urb->pc;
   controlInUrb.ep = ep0;
   controlInUrb.direction = USB_REQUEST_DIRECTION_IN;
   controlInUrb.oneShot = 0;
   result = PCD_Transfer(urb->pc, &controlInUrb);
   if (result != SCS_SUCCESS)
      {
      PRINT1("(PCDAPP_EVE_ControlInDataPhaseDone) : Status phase error.\n");
      }
   }

/*------------------------------------------------------------------------------
Name      : PCDAPP_EVE_ProcessSetup
Purpose   : Process Setup command
Arguments : pc - peripheral controller handle
            event - Unused parameter
            eventData - Unused parameter
Returns   : SctStatus
Notes     : 
-----------------------------------------------------------------------------*/
void PCDAPP_EVE_ProcessSetup(TdiPeriphController* pc, U32 event, void* eventData)
   {
   SctStatus result;
   PeriphSetupRequest request;

   request.data = NULL;
   request.actualLength = 0;
   
   /* Copy out the SETUP packet from the hardware */   
   PCD_GetSetupPacket(pc, 0, &request);
   
   if (vendorCommandStatus)
      {
      vendorCmdStatClear = SCC_TRUE;
      }

   /* Process the received SETUP command */   
   switch (USB_REQUEST_TYPE(request.bmRequestType))
      {
      case USB_REQUEST_TYPE_CLASS:
         result = PCDAPP_ProcessClassCommand(pc, &request);
      break;

      case USB_REQUEST_TYPE_VENDOR:
         result = PCDAPP_ProcessVendorCommand(pc, &request);
      break;

      case USB_REQUEST_TYPE_STANDARD:
         result = SCS_SUCCESS;
         switch (request.bRequest)
            {
            case USB_GET_STATUS:
               result = PCDAPP_EVE_ProcessGetStatus(pc, &request);
            break;

            case USB_CLEAR_FEATURE:
               result = PCDAPP_EVE_ProcessFeature(pc, &request, SCC_FALSE);
            break;

            case USB_SET_FEATURE:
               result = PCDAPP_EVE_ProcessFeature(pc, &request, SCC_TRUE);
            break;

            case USB_SET_ADDRESS:
               result = PCDAPP_EVE_ProcessSetAddress(pc, &request);
               addressPending = SCC_TRUE;
            break;

            case USB_GET_DESCRIPTOR:
               result = PCDAPP_EVE_ProcessGetDescriptor(pc, &request);
            break;

            case USB_GET_CONFIGURATION:
               result = PCDAPP_EVE_ProcessGetConfiguration(pc, &request);
            break;

            case USB_SET_CONFIGURATION:
               result = PCDAPP_EVE_ProcessSetConfiguration(pc, &request);
            break;
            }
      break;
      } /* EndSwitch */
      
   /* Get ready for new SETUP packet */
   PCD_InitSetupPhase(pc, 0, NULL);
   
   /* Get ready to receive an zero length OUT packet (Status Phase) */
   PCD_ConfigEp(pc, 0, EP_NAK_CLEAR, NULL);
   
   if (SCS_SUCCESS != result)
      {
      /* Invalid/Unsupported command. STALL the endpoint (protocol stall) */
      PCD_ConfigEp(pc, 0, EP_HALT_SET, ep0);
      }
   else
      {
      if ((request.bmRequestType & USB_MASK_REQUEST_DIRECTION) == 
          USB_REQUEST_DIRECTION_IN)
         {
         /* Enqueue IN data phase */
         ep0->urb = &controlInUrb;
         controlInUrb.data = request.data;
         controlInUrb.length = request.actualLength;
         controlInUrb.lengthSoFar = 0;
         controlInUrb.dataPosition = 0;
         controlInUrb.status = 0;
         controlInUrb.callBackFunction = PCDAPP_EVE_ControlInDataPhaseDone;
         controlInUrb.pc = pc;
         controlInUrb.ep = ep0;
         controlInUrb.direction = USB_REQUEST_DIRECTION_IN;
         controlInUrb.oneShot = 0;
         result = PCD_Transfer(pc, &controlInUrb);
         }
      else
         {
         if (request.actualLength)
            {
            /* Enqueue OUT data phase */
            ep0->urb = &controlOutUrb;
            controlOutUrb.data = request.data;
            controlOutUrb.length = request.actualLength;
            controlOutUrb.lengthSoFar = 0;
            controlOutUrb.dataPosition = 0;
            controlOutUrb.status = 0;
            controlOutUrb.callBackFunction = PCDAPP_EVE_ControlOutDataPhaseDone;
            controlOutUrb.pc = pc;
            controlOutUrb.ep = ep0;
            controlOutUrb.direction = 0;
            controlOutUrb.oneShot = 0;
            result = PCD_Transfer(pc, &controlOutUrb);
            }
         else
            {
            /* Enqueue IN status phase */
            ep0->urb = &controlInUrb;
            controlInUrb.data = request.data;
            controlInUrb.length = request.actualLength;
            controlInUrb.lengthSoFar = 0;
            controlInUrb.dataPosition = 0;
            controlInUrb.status = 0;
            controlInUrb.callBackFunction = PCDAPP_EVE_ControlTransferDone;
            controlInUrb.pc = pc;
            controlInUrb.ep = ep0;
            controlInUrb.direction = USB_REQUEST_DIRECTION_IN;
            controlInUrb.oneShot = 0;
            result = PCD_Transfer(pc, &controlInUrb);
            }
         }
      }
   }
   
/*------------------------------------------------------------------------------
Name      : PCDAPP_EVE_ProcessVbusChange
Purpose   : Application's event callback function
Arguments : pc - peripheral controller handle
            event - Unused parameter
            dummy - Unused parameter
Returns   : none
Notes     : 
-----------------------------------------------------------------------------*/   
void PCDAPP_EVE_ProcessVbusChange(TdiPeriphController *pc, U32 event, void* dummy)
   {
   SctStatus status = SCS_ERROR;
   if (PCD_IsVbusOn(pc))
      {
      /* need to change appState to prevent from getting stuck in the main loop
         when VBus change is detected in the middle of processing other 
         transfer */
      appState = 0xFF;
      status = PCD_ControlBusParams(pc, USB_PERIPH_CONNECT, 0);
      if (SCS_SUCCESS != status)
         {
         PRINT1("(PCDAPP_EVE_ProcessVbusChange) Connect Error.\n");
         }
      }
   else
      {
      appState = APP_STATE_DEVICE_DETACHED;
      enumerationDone = SCC_FALSE;
      configurationDone = SCC_FALSE;
      status = PCD_ControlBusParams(pc, USB_PERIPH_DISCONNECT, 0);
      if (SCS_SUCCESS != status)
         {
         PRINT1("(PCDAPP_EVE_ProcessVbusChange) Diconnect Error.\n");
         }
      }
   }
   
/*------------------------------------------------------------------------------
Name      : PCDAPP_EVE_ProcessVbusChange
Purpose   : Application's event callback function
Arguments : pc - peripheral controller handle
            event - unused parameter
            dummy - unused parameter
Returns   : none
Notes     : 
-----------------------------------------------------------------------------*/   
void PCDAPP_EVE_ProcessBusReset(TdiPeriphController *pc, U32 event, void* dummy)
   {
   /* Nothing to do */
   }

/*------------------------------------------------------------------------------
Name      : PCDAPP_EVE_ProcessSpeedDetection
Purpose   : Application's event callback function
Arguments : pc - peripheral controller handle
            event - Any data that needs to be processed
            busSpeed - speed of the bus
Returns   : none
Notes     : 
-----------------------------------------------------------------------------*/   
void PCDAPP_EVE_ProcessSpeedDetection(TdiPeriphController *pc, U32 event, 
                                  void* busSpeed)   
   {
   SctStatus status;
   U32* speed = (U32* )busSpeed;
   U8* currentDeviceDescriptor;
   U8* currentConfigDescriptor;
   U8* currentDeviceQualifierDescriptor;
   U8* currentOtherSpeedConfigDescriptor;
   
   if (*speed)
      {
      currentDeviceDescriptor = hsDeviceDescriptor;
      currentConfigDescriptor = hsConfigDescriptor;
      currentDeviceQualifierDescriptor = fsDeviceQualifierDescriptor;
      currentOtherSpeedConfigDescriptor = fsOtherSpeedConfigDescriptor;
      }
   else
      {
      currentDeviceDescriptor = fsDeviceDescriptor;
      currentConfigDescriptor = fsConfigDescriptor;
      currentDeviceQualifierDescriptor = hsDeviceQualifierDescriptor;
      currentOtherSpeedConfigDescriptor = hsOtherSpeedConfigDescriptor;
      }
      
   /* register USB descriptors */
   status = PCD_RegisterDescriptor(pc, USB_DEVICE_DESCRIPTOR, 
      currentDeviceDescriptor, 0);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: Device Descriptor registration failed."));
      }

   status = PCD_RegisterDescriptor(pc, USB_CONFIG_DESCRIPTOR, 
      currentConfigDescriptor, 0);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: Configuration Descriptor registration failed."));
      }
      
   status = PCD_RegisterDescriptor(pc, USB_DEVICE_QUALIFIER_DESCRIPTOR, 
      currentDeviceQualifierDescriptor, 0);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: Device Qualifier Descriptor registration failed."));
      }
      
   status = PCD_RegisterDescriptor(pc, USB_OTHER_SPEED_CONFIG_DESCRIPTOR, 
      currentOtherSpeedConfigDescriptor, 0);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: Other Speed Configuration Descriptor registration failed."));
      }
      
   status = PCD_RegisterDescriptor(pc, USB_STRING_DESCRIPTOR, 
      StringDescriptor0, 0);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: String Descriptor 0 registration failed."));
      }
      
   status = PCD_RegisterDescriptor(pc, USB_STRING_DESCRIPTOR, 
      StringDescriptor1, 1);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: String Descriptor 1 registration failed."));
      }
      
   status = PCD_RegisterDescriptor(pc, USB_STRING_DESCRIPTOR, 
      StringDescriptor2, 2);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: String Descriptor 2 registration failed."));
      }
      
   status = PCD_RegisterDescriptor(pc, USB_STRING_DESCRIPTOR, 
      StringDescriptor3, 3);
   if (status != SCS_SUCCESS) 
      {
      PRINT1(("\nERROR: String Descriptor 3 registration failed."));
      }
      
   status = PCD_CreateEp(pc, 0, 0, 0, \
      pc->currentDeviceDescriptor[USBDESC_DEVICE_BMAXPACKETSIZE0], &ep0);
   if (status != SCS_SUCCESS)
      {
      PRINT1("(PCDAPP_EVE_ProcessBusReset) Failed to create and init control endpoint.\n");
      }
   }