usb_9.c

LPC214x的USB代码

 * Return: none
 *
 * Description: USB Set descriptor
 *
 *************************************************************************/
inline
void UsbSetDescriptor(void)
{
  if(UsbDevCtrl.State.DS >= UsbDevStatusAddress)
  {
    // This request is valid only for Address state and Configured state.
    // If supported
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
  else
  {
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
}

/*************************************************************************
 * Function Name: UsbGetConfiguration
 * Parameters:  none
 *
 * Return: none
 *
 * Description: USB Get configuration implement
 *
 *************************************************************************/
inline
void UsbGetConfiguration(void)
{
  if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
     (UsbEp0SetupPacket.wValue.Word == 0) &&
     (UsbEp0SetupPacket.wIndex.Word == 0) &&
     (UsbEp0SetupPacket.wLength.Word == 1))
  {
    UsbEp0Ctrl.Counter = 1;
    EpCtrlDataBuf[0] = UsbCoreReq(UsbCoreReqConfiquration);
    UsbEp0Ctrl.pData = EpCtrlDataBuf;
    UsbEp0SetupWrite();
  }
  else
  {
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
}

/*************************************************************************
 * Function Name: UsbSetConfiguration
 * Parameters:  none
 *
 * Return: none
 *
 * Description: USB Set configuration implement
 *
 *************************************************************************/
inline
void UsbSetConfiguration(void)
{
  if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
     (UsbEp0SetupPacket.wIndex.Word == 0) &&
     (UsbEp0SetupPacket.wLength.Word == 0) &&
     (UsbSetConfigurtonState(UsbEp0SetupPacket.wValue.Lo) == UsbPass))
  {
    USB_EpWrite(CTRL_ENP_IN,NULL,0);
    UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  }
  else
  {
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
}

/*************************************************************************
 * Function Name: UsbGetInterface
 * Parameters:  none
 *
 * Return: none
 *
 * Description: Implement get interface request
 *
 *************************************************************************/
inline
void UsbGetInterface (void)
{
  if((UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
     (UsbEp0SetupPacket.wIndex.Word == UsbDevCtrl.Interface) &&
     (UsbEp0SetupPacket.wLength.Word == 1) &&
     (UsbEp0SetupPacket.wValue.Word == 0))
  {
    UsbEp0Ctrl.Counter = 1;
    EpCtrlDataBuf[0] = UsbDevCtrl.AlternateSetting;
    UsbEp0Ctrl.pData = EpCtrlDataBuf;
    UsbEp0SetupWrite();
  }
  else
  {
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
}

/*************************************************************************
 * Function Name: UsbSetInterface
 * Parameters:  none
 *
 * Return: none
 *
 * Description: Implement set interface request
 *
 *************************************************************************/
inline
void UsbSetInterface (void)
{
  if((UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
     (UsbEp0SetupPacket.wLength.Word == 0))
  {
    UsbStandardConfigurationDescriptor_t * pData = UsbFindConfiguration(UsbDevCtrl.Configuration);
    UsbDevCtrl_t UsbDevCtrlNew = UsbDevCtrl;

    UsbDevCtrlNew.Interface = UsbEp0SetupPacket.wIndex.Word;
    UsbDevCtrlNew.AlternateSetting = UsbEp0SetupPacket.wValue.Word;
    UsbDevCtrlNew.Feature.RemoteWakeupEnable = 0;

    // Whether the interface is exist into current conficuration?
    if(UsbFindInterface(pData,&UsbDevCtrlNew) != UsbPass)
    {
      UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      return;
    }

    UsbCoreUserFun[UsbUserConfigure]((void *)&UsbDevCtrlNew);
    UsbDevCtrl = UsbDevCtrlNew;

    USB_EpWrite(CTRL_ENP_IN,NULL,0);
    UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  }
  else
  {
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
}

/*************************************************************************
 * Function Name: UsbSynchFrame
 * Parameters:  none
 *
 * Return: none
 *
 * Description: Implement synch frame request
 *
 *************************************************************************/
inline
void UsbSynchFrame (void)
{
  if( USB_SOF_EVENT &&
     (UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
     (UsbEp0SetupPacket.wLength.Word == 2) &&
     (UsbEp0SetupPacket.wValue.Word == 0))
  {
  Int32U FrameNumb = 0;
  #if USB_SOF_EVENT > 0
    FrameNumb = USB_GetFrameNumb();
  #endif
    UsbEp0Ctrl.Counter = 2;
    EpCtrlDataBuf[0]   = FrameNumb;
    EpCtrlDataBuf[1]   = FrameNumb>>8;
    UsbEp0Ctrl.pData   = EpCtrlDataBuf;
    UsbEp0SetupWrite();
  }
  else
  {
    UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  }
}

/*************************************************************************
 * Function Name: UsbCtrlEpCallback
 * Parameters:  void * pArg
 *
 * Return: none
 *
 * Description: USB Ctrl EP Callback
 *
 *************************************************************************/
void UsbCtrlEpCallback (void * pArg)
{
Int32U PacketSize;

  switch((Int32U)pArg)
  {
  case UsbSetupPacket:
setup_packet_overwrited:
    UsbEp0Ctrl.pData   = EpCtrlDataBuf;
    UsbEp0Ctrl.Counter = USB_EpRead(CTRL_ENP_OUT,(Int32U *)EpCtrlDataBuf,Ep0MaxSize);
    if(UsbEp0Ctrl.EpStatus.Status != UsbEpPause)
    {
      // Copy new setup packet int setup buffer
      memcpy((Int8U *)&UsbEp0SetupPacket,EpCtrlDataBuf,sizeof(UsbEp0SetupPacket));
    }
    switch(UsbEp0SetupPacket.mRequestType.Type)
    {
    // Standart
    case UsbTypeStandart:
      // Decoding standart request
      switch (UsbEp0SetupPacket.bRequest)
      {
      case GET_STATUS:
        UsbGetStatus();
        break;
      case CLEAR_FEATURE:
        UsbClearFeature();
        break;
      case SET_FEATURE:
        UsbSetFeature();
        break;
      case SET_ADDRESS:
        UsbSetAddress();
        break;
      case GET_DESCRIPTOR:
        if(UsbEp0SetupPacket.mRequestType.Recipient == UsbRecipientDevice)
        {
          UsbGetDescriptor();
        }
        // Only get descriptof for device is standart request
        else if ((UsbCoreUserFun[UsbUserGetDescriptor] != NULL) &&
                 ((Int32U)UsbCoreUserFun[UsbUserGetDescriptor](&UsbEp0Ctrl) == UsbUserSendPacket))
        {
          if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
          {
            UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
            UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
          }
          else
          {
             UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
          }
          UsbEp0SetupWrite();
        }
        else
        {
          UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
        }
        break;
      case SET_DESCRIPTOR:
        // Optional (only for configuration and string descriptors)
        UsbSetDescriptor();
        break;
      case GET_CONFIGURATION:
        UsbGetConfiguration();
        break;
      case SET_CONFIGURATION:
        UsbSetConfiguration();
        break;
      case GET_INTERFACE:
        UsbGetInterface();
        break;
      case SET_INTERFACE:
        UsbSetInterface();
        break;
      case SYNCH_FRAME:
        UsbSynchFrame();
        break;
      default:
        UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      }
      break;
    // Class
    case UsbTypeClass:
      if(UsbCoreUserFun[UsbUserClass] != NULL)
      {
        switch((Int32U)UsbCoreUserFun[UsbUserClass](&UsbEp0Ctrl))
        {
        case UsbUserNone:
          break;
        case UsbUserSendPacket:
          if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
          {
            UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
            UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
          }
          else
          {
            UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
          }
          UsbEp0SetupWrite();
          break;
        case UsbUserReceivePacket:
          if((UsbEp0Ctrl.Counter == UsbEp0SetupPacket.wLength.Word) &&
             (UsbCoreUserFun[UsbClassEp0OutPacket] != NULL))
          {
            UsbEp0Ctrl.EpStatus.Status = UsbEpClassDataOut;
          }
          else
          {
            UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
          }
          break;
        case UsbUserSendAckn:
          USB_EpWrite(CTRL_ENP_IN,NULL,0);
          UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
          break;
        default :
          UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
        }
      }
      else
      {
        UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      }
      break;
    // Vendor
    case UsbTypeVendor:
      if(UsbCoreUserFun[UsbUserVendor] != NULL)
      {
        switch((Int32U)UsbCoreUserFun[UsbUserClass](&UsbEp0Ctrl))
        {
        case UsbUserNone:
          break;
        case UsbUserSendPacket:
          if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
          {
            UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
            UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
          }
          else
          {
            UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
          }
          UsbEp0SetupWrite();
          break;
        case UsbUserReceivePacket:
          if((UsbEp0Ctrl.Counter == UsbEp0SetupPacket.wLength.Word) &&
             (UsbCoreUserFun[UsbVendorEp0OutPacket] != NULL))
          {
            UsbEp0Ctrl.EpStatus.Status = UsbEpVendorDataOut;
          }
          else
          {
            UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
          }
          break;
        case UsbUserSendAckn:
          USB_EpWrite(CTRL_ENP_IN,NULL,0);
          UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
          break;
        default :
          UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
        }
      }
      else
      {
        UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      }
      break;
    // Other
    default:
      UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
    }
    break;
  // Out Packet
  case UsbDataOutPacket:
    switch(UsbEp0Ctrl.EpStatus.Status)
    {
    case UsbEpSetupDataIn:
    case UsbEpSetupLastIn:
      // Clear output ep buffer
      UsbEp0Ctrl.EpStatus.Status = UsbEpStatusOut;
      UsbEp0Ctrl.Counter = USB_EpRead(CTRL_ENP_OUT,(Int32U *)EpCtrlDataBuf,Ep0MaxSize);
      if (UsbEp0Ctrl.Counter & 0x80000000)
      {
         goto setup_packet_overwrited;
      }
      break;
    case UsbEpWaitStatusOut:
      // Clear output ep buffer
      UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
      UsbEp0Ctrl.Counter = USB_EpRead(CTRL_ENP_OUT,(Int32U *)EpCtrlDataBuf,Ep0MaxSize);
      if (UsbEp0Ctrl.Counter & 0x80000000)
      {
         goto setup_packet_overwrited;
      }
      break;
    case UsbEpSetupDataOut:
      UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      break;
    case UsbEpClassDataOut:
      PacketSize = USB_EpRead(CTRL_ENP_OUT,(Int32U *)UsbEp0Ctrl.pData,Ep0MaxSize);
      if (UsbEp0Ctrl.Counter & 0x80000000)
      {
         goto setup_packet_overwrited;
      }
      UsbEp0Ctrl.pData += PacketSize;
      UsbEp0Ctrl.Counter -= PacketSize;
      if(UsbEp0Ctrl.Counter == 0)
      {
        switch((Int32U)UsbCoreUserFun[UsbClassEp0OutPacket](NULL))
        {
        case UsbUserNone:
          UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
          break;
        case UsbUserSendAckn:
          USB_EpWrite(CTRL_ENP_IN,NULL,0);
          UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
          break;
        default:
          UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
        }
      }
      else if (PacketSize != Ep0MaxSize)
      {
        UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      }
      break;
    case UsbEpVendorDataOut:
      PacketSize = USB_EpRead(CTRL_ENP_OUT,(Int32U *)UsbEp0Ctrl.pData,Ep0MaxSize);
      if (UsbEp0Ctrl.Counter & 0x80000000)
      {
         goto setup_packet_overwrited;
      }
      UsbEp0Ctrl.pData += PacketSize;
      UsbEp0Ctrl.Counter -= PacketSize;
      if(UsbEp0Ctrl.Counter == 0)
      {
        switch((Int32U)UsbCoreUserFun[UsbVendorEp0OutPacket](NULL))
        {
        case UsbUserNone:
          UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
          break;
        case UsbUserSendAckn:
          USB_EpWrite(CTRL_ENP_IN,NULL,0);
          UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
          break;
        default:
          UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
        }
      }
      else if (PacketSize != Ep0MaxSize)
      {
        UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
      }
      break;
    default:
      UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
    }
    break;
  // In Packet
  case UsbDataInPacket:
    switch(UsbEp0Ctrl.EpStatus.Status)
    {
    case UsbEpStatusOut:
    case UsbEpWaitStatusIn:
    case UsbEpStatusIn:
      UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
      break;
    case UsbEpSetupDataIn:
      UsbEp0SetupWrite();
      break;
    case UsbEpSetupLastIn:
      UsbEp0Ctrl.EpStatus.Status = UsbEpWaitStatusOut;
      break;
    case UsbEpStatusInSetAdd:
      USB_SetAdd(UsbEp0SetupPacket.wValue.Lo);
      UsbDevCtrl.DevAdd = UsbEp0SetupPacket.wValue.Lo;
      if(UsbEp0SetupPacket.wValue.Lo)
      {
        UsbSetDevState(UsbDevStatusAddress);
        UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
      }
      else
      {
        UsbSetDevState(UsbDevStatusDefault);
        UsbCoreUserFun[UsbUserConfigure](NULL);
      }
      break;
    default:
      UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
    }
    break;
  }
  if (UsbEp0Ctrl.EpStatus.Status == UsbEpStall)
  {
    USB_SetStallEP(CTRL_ENP_OUT,TRUE);
    USB_SetStallEP(CTRL_ENP_IN ,TRUE);
    UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  }
}