开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DNA > 查看源码
usb_9.c
资源名称：LPC2148_IAR_LPC2148.zip　[点击查看]
上传用户：sourcesun
上传日期：2013-09-23
资源大小：362k
文件大小：41k
源码类别：

DNA

开发平台：

Asm

usb_9.c：源码内容
  1. /*************************************************************************
  2.  *
  3.  *    Used with ICCARM and AARM.
  4.  *
  5.  *    (c) Copyright IAR Systems 2003
  6.  *
  7.  *    File name   : usb_9.c
  8.  *    Description : USB chapter 9 (device framework) module
  9.  *
  10.  *    History :
  11.  *    1. Data        : August 5, 2005
  12.  *       Author      : Stanimir Bonev
  13.  *       Description : Create
  14.  *    2. Data        : December 19, 2005
  15.  *       Author      : Stanimir Bonev
  16.  *       Description : Modify
  17.  *        Modify user callback function for EP0
  18.  *        Change prameter transfered to function form packet type to
  19.  *        pointer to UsbEp0Ctrl structure
  20.  *
  21.  *    $Revision: 1.1.2.1 $
  22. **************************************************************************/
  23. #include "usb_9.h"
  25. UsbEpCtrl_t UsbEp0Ctrl;
  26. UsbSetupPacket_t UsbEp0SetupPacket;
  28. #pragma data_alignment=4
  29. Int8U EpCtrlDataBuf[Ep0MaxSize];
  30. UsbDevCtrl_t UsbDevCtrl = {{UsbDevStatusUnknow,UsbDevStatusNoSuspend},0,0,0,0};
  32. // User funcrions
  33. CommUserFpnt_t UsbCoreUserFun[UsbUserLastInd] =
  34. {
  35.   // UsbUserClass
  36.   NULL,
  37.   // UsbUserVendor
  38.   NULL,
  39.   // UsbClassEp0OutPacket
  40.   NULL,
  41.   // UsbVendorEp0OutPacket
  42.   NULL,
  43.   // UsbUserConfigure
  44.   NULL,
  45.   // UsbUserReset
  46.   NULL,
  47.   // UsbUserConnect
  48.   NULL,
  49.   // UsbUserSuspend
  50.   NULL,
  51. };
  53. /*************************************************************************
  54.  * Function Name: UsbCoreInit
  55.  * Parameters:  CommUserFpnt_t UserCoreConfigure
  56.  *
  57.  * Return: none
  58.  *
  59.  * Description: USB init core
  60.  *
  61.  *************************************************************************/
  62. void UsbCoreInit (CommUserFpnt_t UserCoreConfigure)
  63. {
  64.   UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  65.   UserCoreConfigure(NULL);
  66.   UsbCoreUserFuncRegistered(UserCoreConfigure,UsbUserConfigure);
  67.   UsbSetDevState(UsbDevStatusUnknow);
  68.   // Registerd Core functions
  69.   USB_UserFuncRegistered(UsbDevResetCallback  ,UsbResetEvent  );
  70.   USB_UserFuncRegistered(UsbDevConnectCallback,UsbConnectEvent);
  71.   USB_UserFuncRegistered(UsbDevSuspendCallback,UsbSuspendEvent);
  72.   USB_UserFuncRegistered(UsbCtrlEpCallback    ,UsbEp0Out      );
  73.   USB_UserFuncRegistered(UsbCtrlEpCallback    ,UsbEp0In       );
  74. }
  76. /*************************************************************************
  77.  * Function Name: UsbCoreUserFuncRegistered
  78.  * Parameters: CommUserFpnt_t UserFunc, UsbCoreUserFuncInd_t UserFuncInd
  79.  *
  80.  * Return: CommUserFpnt_t
  81.  *
  82.  * Description: Registed User core callback function
  83.  *
  84.  *************************************************************************/
  85. CommUserFpnt_t UsbCoreUserFuncRegistered (CommUserFpnt_t UserCoreFunc,
  86.                                           UsbCoreUserFuncInd_t UserFuncInd)
  87. {
  88. CommUserFpnt_t PrevUserFunc = UsbCoreUserFun[UserFuncInd];
  89.   UsbCoreUserFun[UserFuncInd] = UserCoreFunc;
  90.   return(PrevUserFunc);
  91. }
  93. /*************************************************************************
  94.  * Function Name: UsbCoreReq
  95.  * Parameters:  UsbCoreReqType_t Type
  96.  *
  97.  * Return: Int32U
  98.  *
  99.  * Description: Return different device states
  100.  *
  101.  *************************************************************************/
  102. Int32U UsbCoreReq (UsbCoreReqType_t Type)
  103. {
  104.   switch(Type)
  105.   {
  106.   case UsbCoreReqDevState:
  107.     return(UsbDevCtrl.State.DS);
  108.   case UsbCoreReqDevSusState:
  109.     return(UsbDevCtrl.State.Suspend);
  110.   case UsbCoreReqConfiquration:
  111.     return(UsbDevCtrl.Configuration);
  112.   case UsbCoreReqInterface:
  113.     return(UsbDevCtrl.Interface);
  114.   case UsbCoreReqAlternateSetting:
  115.     return(UsbDevCtrl.AlternateSetting);
  116.   case UsbCoreReqDevOwnAddress:
  117.     return(UsbDevCtrl.DevAdd);
  118.   case UsbCoreReqWakeUpEnableStatus:
  119.     return(UsbDevCtrl.Feature.RemoteWakeupEnable);
  120.   case UsbCoreReqSelfPoweredStatus:
  121.     return(UsbDevCtrl.Feature.SelfPowered);
  122.   }
  123.   return((Int32U) -1);
  124. }
  126. /*************************************************************************
  127.  * Function Name: UsbWakeUp
  128.  * Parameters:  none
  129.  *
  130.  * Return: none
  131.  *
  132.  * Description: WakeUp device from suspend mode
  133.  *
  134.  *************************************************************************/
  135. void UsbWakeUp (void)
  136. {
  137.   if(UsbDevCtrl.Feature.RemoteWakeupEnable && UsbDevCtrl.State.Suspend)
  138.   {
  139.     USB_WakeUp();
  140.   }
  141. }
  143. /*************************************************************************
  144.  * Function Name: UsbSetDevState
  145.  * Parameters:  _UsbDevState_t DevState
  146.  *
  147.  * Return: none
  148.  *
  149.  * Description: Set device state
  150.  *
  151.  *************************************************************************/
  152. void UsbSetDevState (_UsbDevState_t DevState)
  153. {
  154.   UsbDevCtrl.State.DS = DevState;
  155.   switch (DevState)
  156.   {
  157.   case UsbDevStatusConfigured:
  158.     USB_Configure(TRUE);
  159.     break;
  160.   case UsbDevStatusAddress:
  161.     UsbDevCtrl.Configuration = UsbDevCtrl.AlternateSetting =
  162.     UsbDevCtrl.Interface = 0;
  163.     USB_Configure(FALSE);
  164.     break;
  165.   default:
  166.     UsbDevCtrl.DevAdd = UsbDevCtrl.Configuration = 
  167.     UsbDevCtrl.AlternateSetting = UsbDevCtrl.Interface = 0;
  168.     USB_Configure(FALSE);
  170.   }
  171. }
  173. /*************************************************************************
  174.  * Function Name: UsbGetDevState
  175.  * Parameters:  none
  176.  *
  177.  * Return: UsbDevState_t
  178.  *
  179.  * Description: Get device state
  180.  *
  181.  *************************************************************************/
  182. UsbDevState_t UsbGetDevState (void)
  183. {
  184.   return(UsbDevCtrl.State);
  185. }
  187. /*************************************************************************
  188.  * Function Name: UsbSetDevSuspend
  189.  * Parameters:  none
  190.  *
  191.  * Return: UsbDevState_t
  192.  *
  193.  * Description: Set device suspend mode
  194.  *
  195.  *************************************************************************/
  196. void UsbSetDevSuspend (Boolean Suspend)
  197. {
  198.   UsbDevCtrl.State.Suspend = Suspend ? UsbDevStatusSuspend : UsbDevStatusNoSuspend;
  199. }
  201. /*************************************************************************
  202.  * Function Name: UsbFindInterface
  203.  * Parameters:  UsbStandardConfigurationDescriptor_t * pConfiguration
  204.  *              Int32U Interface,Int32U AlternativeSetting
  205.  *
  206.  * Return: UsbCommStatus_t
  207.  *
  208.  * Description: Set Interface and  Alternative setting state
  209.  *
  210.  *************************************************************************/
  211. UsbCommStatus_t UsbFindInterface (UsbStandardConfigurationDescriptor_t * pConfiguration,
  212.                                   UsbDevCtrl_t * UsbDev)
  213. {
  214. UsbStandardInterfaceDescriptor_t *pData;
  215.   // Find Interface
  216.   for(pData = (UsbStandardInterfaceDescriptor_t *)pConfiguration;
  217.       (Int8U*)pData < (Int8U *)pConfiguration + pConfiguration->wTotalLength;
  218.       pData =(UsbStandardInterfaceDescriptor_t *)((Int8U *)pData + pData->bLength))
  219.   {
  220.     if((pData->bDescriptorType == UsbDescriptorInterface) &&
  221.        (pData->bInterfaceNumber == UsbDev->Interface) &&
  222.        (pData->bAlternateSetting == UsbDev->AlternateSetting))
  223.     {
  224.       return(UsbPass);
  225.     }
  226.   }
  227.   return(UsbFault);
  228. }
  230. /*************************************************************************
  231.  * Function Name: UsbFindConfiguration
  232.  * Parameters:  Int32U
  233.  *
  234.  * Return: UsbStandardConfigurationDescriptor_t *
  235.  *
  236.  * Description: Return pointer to current configuration
  237.  *
  238.  *************************************************************************/
  239. UsbStandardConfigurationDescriptor_t * UsbFindConfiguration(Int32U Configuration)
  240. {
  241. UsbStandardConfigurationDescriptor_t * pData =
  242.  (UsbStandardConfigurationDescriptor_t *) &UsbStandardConfigurationDescriptor[0];
  243.   while(pData->bLength)
  244.   {
  245.     if(pData->bDescriptorType == UsbDescriptorConfiguration)
  246.     {
  247.       if(pData->bConfigurationValue == Configuration)
  248.       {
  249.          return(pData);
  250.       }
  251.     }
  252.     pData = (UsbStandardConfigurationDescriptor_t *)((Int8U *)pData + pData->bLength);
  253.   }
  254.   return(NULL);
  255. }
  257. /*************************************************************************
  258.  * Function Name: UsbDevConnectCallback
  259.  * Parameters:  void * pArg
  260.  *
  261.  * Return: none
  262.  *
  263.  * Description: USB connect callback
  264.  *
  265.  *************************************************************************/
  266. void UsbDevConnectCallback (void * pArg)
  267. {
  268.   UsbSetDevState(pArg?UsbDevStatusAttached:UsbDevStatusUnknow);
  269.   if(UsbCoreUserFun[UsbUserConnect] != NULL)
  270.   {
  271.     UsbCoreUserFun[UsbUserConnect](pArg);
  272.   }
  273. }
  275. /*************************************************************************
  276.  * Function Name: UsbDevSuspendCallback
  277.  * Parameters:  void * pArg
  278.  *
  279.  * Return: none
  280.  *
  281.  * Description: USB suspend callback
  282.  *
  283.  *************************************************************************/
  284. void UsbDevSuspendCallback (void * pArg)
  285. {
  286.   UsbSetDevSuspend(pArg?UsbDevStatusSuspend:UsbDevStatusNoSuspend);
  287.   if(UsbCoreUserFun[UsbUserSuspend] != NULL)
  288.   {
  289.     UsbCoreUserFun[UsbUserSuspend](pArg);
  290.   }
  291. }
  293. /*************************************************************************
  294.  * Function Name: UsbDevResetCallback
  295.  * Parameters:  void * pArg
  296.  *
  297.  * Return: none
  298.  *
  299.  * Description: USB reset callback
  300.  *
  301.  *************************************************************************/
  302. void UsbDevResetCallback (void * pArg)
  303. {
  304.   UsbSetDevState(UsbDevStatusDefault);
  305.   UsbCoreUserFun[UsbUserConfigure](NULL);
  307.   if(UsbCoreUserFun[UsbUserReset] != NULL)
  308.   {
  309.     UsbCoreUserFun[UsbUserReset](pArg);
  310.   }
  311. }
  313. /*************************************************************************
  314.  * Function Name: UsbEp0SetupWrite
  315.  * Parameters:  none
  316.  *
  317.  * Return: none
  318.  *
  319.  * Description: USB EP Write implement (IN)
  320.  *
  321.  *************************************************************************/
  322. void UsbEp0SetupWrite (void)
  323. {
  324. Int32U CurrCount = Ep0MaxSize;
  325.   if((UsbEp0Ctrl.Counter == Ep0MaxSize) && UsbEp0Ctrl.EpStatus.NoZeroLength)
  326.   {
  327.     UsbEp0Ctrl.EpStatus.Status = UsbEpSetupLastIn;
  328.   }
  329.   else if(UsbEp0Ctrl.Counter < Ep0MaxSize)
  330.   {
  331.     CurrCount = UsbEp0Ctrl.Counter;
  332.     UsbEp0Ctrl.EpStatus.Status = UsbEpSetupLastIn;
  333.   }
  334.   else
  335.   {
  336.     UsbEp0Ctrl.EpStatus.Status = UsbEpSetupDataIn;
  337.   }
  339.   USB_EpWrite(CTRL_ENP_IN,(Int32U *)UsbEp0Ctrl.pData,CurrCount);
  340.   UsbEp0Ctrl.Counter -= CurrCount;
  341.   UsbEp0Ctrl.pData += CurrCount;
  342. }
  344. /*************************************************************************
  345.  * Function Name: UsbSetConfigurtonState
  346.  * Parameters:  Int32U
  347.  *
  348.  * Return: UsbCommStatus_t
  349.  *
  350.  * Description: Set configuration state
  351.  *
  352.  *************************************************************************/
  353. inline
  354. UsbCommStatus_t UsbSetConfigurtonState (Int32U Configuration)
  355. {
  356.   if(Configuration)
  357.   {
  358.     // Find configuration
  359.     UsbStandardConfigurationDescriptor_t * pData = UsbFindConfiguration(Configuration);
  360.     UsbDevCtrl_t UsbDevCtrlNew = UsbDevCtrl;
  362.     if(pData == NULL)
  363.     {
  364.       return(UsbFault);
  365.     }
  366.     // Set Interfce and Alternative Setting
  367.     UsbDevCtrlNew.Configuration = Configuration;
  368.     UsbDevCtrlNew.Interface = UsbDevCtrlNew.AlternateSetting = 0;
  369.     UsbDevCtrlNew.Feature.RemoteWakeupEnable = 0;
  370.     UsbDevCtrlNew.Feature.SelfPowered = pData->bmAttributes.SelfPowered?1:0;
  371.     // Whether the interface is exist into current conficuration?
  372.     if(UsbFindInterface(pData,&UsbDevCtrlNew) != UsbPass)
  373.     {
  374.       return(UsbFault);
  375.     }
  376.     // User function that realize EP and init buffers
  377.     UsbCoreUserFun[UsbUserConfigure]((void *)&UsbDevCtrlNew);
  378.     UsbDevCtrl = UsbDevCtrlNew;
  379.     UsbSetDevState(UsbDevStatusConfigured);
  380.   }
  381.   else
  382.   {
  383.     UsbCoreUserFun[UsbUserConfigure](NULL);
  384.     UsbSetDevState(UsbDevStatusAddress);
  385.   }
  386.   return(UsbPass);
  387. }
  389. /*************************************************************************
  390.  * Function Name: UsbDevStatus
  391.  * Parameters:  Int8U * pData, Int16U Index
  392.  *
  393.  * Return: UsbCommStatus_t
  394.  *
  395.  * Description: Usb Return device status into pData
  396.  *
  397.  *************************************************************************/
  398. inline
  399. UsbCommStatus_t UsbDevStatus(Int8U * pData, Int16U Index)
  400. {
  401.   if(Index == 0)
  402.   {
  403.     UsbEp0Ctrl.pData = pData;
  404.     UsbEp0Ctrl.Counter = 2;
  405.     *pData++ = UsbDevCtrl.Feature.Data;
  406.     *pData   = 0;
  407.     return(UsbPass);
  408.   }
  409.   return(UsbFault);
  410. }
  412. /*************************************************************************
  413.  * Function Name: UsbInterfaceStatus
  414.  * Parameters:  Int8U * pData, Int16U Index
  415.  *
  416.  * Return: UsbCommStatus_t
  417.  *
  418.  * Description: Usb Return interface status into pData
  419.  *
  420.  *************************************************************************/
  421. inline
  422. UsbCommStatus_t UsbInterfaceStatus(Int8U * pData, Int16U Index)
  423. {
  424.   UsbEp0Ctrl.pData = pData;
  425.   UsbEp0Ctrl.Counter = 2;
  426.   *pData++ = 0;
  427.   *pData   = 0;
  428.   return(UsbPass);
  429. }
  431. /*************************************************************************
  432.  * Function Name: UsbEpStatus
  433.  * Parameters:  Int8U * pData, Int16U Index
  434.  *
  435.  * Return: UsbCommStatus_t
  436.  *
  437.  * Description: Usb Return Ep status into pData
  438.  *
  439.  *************************************************************************/
  440. inline
  441. UsbCommStatus_t UsbEpStatus(Int8U * pData, Int16U Index)
  442. {
  443.   if((Index & 0x7F) > 16)
  444.   {
  445.     return(UsbFault);
  446.   }
  447.   UsbEp0Ctrl.pData = pData;
  448.   UsbEp0Ctrl.Counter = 2;
  449.   *pData++ = USB_GetStallEP(USB_EpLogToPhysAdd(Index)) ? 1:0;
  450.   *pData = 0;
  451.   return(UsbPass);
  452. }
  454. /*************************************************************************
  455.  * Function Name: UsbGetStatus
  456.  * Parameters:  none
  457.  *
  458.  * Return: none
  459.  *
  460.  * Description: Usb Get status implement
  461.  *
  462.  *************************************************************************/
  463. inline
  464. void UsbGetStatus (void)
  465. {
  466.   if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
  467.      // Length must be 2
  468.      (UsbEp0SetupPacket.wLength.Word == 2) &&
  469.      // Direction of data from device
  470.      (UsbEp0SetupPacket.mRequestType.Dir == 1) &&
  471.      // wValue mut be 0
  472.      (UsbEp0SetupPacket.wValue.Word == 0) )
  473.   {
  474.     // This request is valid only for Address and Configured device's states
  475.     switch(UsbEp0SetupPacket.mRequestType.Recipient)
  476.     {
  477.     case UsbRecipientDevice:
  478.       if(UsbDevStatus(EpCtrlDataBuf,UsbEp0SetupPacket.wIndex.Word) == UsbPass)
  479.       {
  480.         UsbEp0SetupWrite();
  481.       }
  482.       else
  483.       {
  484.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  485.       }
  486.       break;
  487.     case UsbRecipientInterface:
  488.       if(UsbInterfaceStatus(EpCtrlDataBuf,UsbEp0SetupPacket.wIndex.Word) == UsbPass)
  489.       {
  490.         UsbEp0SetupWrite();
  491.       }
  492.       else
  493.       {
  494.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  495.       }
  496.       break;
  497.     case UsbRecipientEndpoint:
  498.       if(UsbEpStatus(EpCtrlDataBuf,UsbEp0SetupPacket.wIndex.Word) == UsbPass)
  499.       {
  500.         UsbEp0SetupWrite();
  501.       }
  502.       else
  503.       {
  504.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  505.       }
  506.       break;
  507.     default:
  508.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  509.     }
  510.   }
  511.   else
  512.   {
  513.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  514.   }
  515. }
  517. /*************************************************************************
  518.  * Function Name: UsbClearFeature
  519.  * Parameters:  Int16U Feature,Int16U Index
  520.  *
  521.  * Return: UsbCommStatus_t
  522.  *
  523.  * Description: USB Clear Device feature implement
  524.  *
  525.  *************************************************************************/
  526. inline
  527. UsbCommStatus_t UsbClearDevFeature(Int16U Feature,Int16U Index)
  528. {
  529.   if((Index != 0) || (Feature != UsbDeviceRemoteWakeupSelector))
  530.   {
  531.     return(UsbFault);
  532.   }
  533.   UsbDevCtrl.Feature.RemoteWakeupEnable = 0;
  534.   return(UsbPass);
  535. }
  536. /*************************************************************************
  537.  * Function Name: UsbClearInterfaceFeature
  538.  * Parameters:  Int16U Feature,Int16U Index
  539.  *
  540.  * Return: UsbCommStatus_t
  541.  *
  542.  * Description: USB Clear Interface feature implement
  543.  *
  544.  *************************************************************************/
  545. inline
  546. UsbCommStatus_t UsbClearInterfaceFeature(Int16U Feature,Int16U Index)
  547. {
  548.   return(UsbFault);
  549. }
  551. /*************************************************************************
  552.  * Function Name: UsbClearEpFeature
  553.  * Parameters:  Int16U Feature,Int16U Index
  554.  *
  555.  * Return: UsbCommStatus_t
  556.  *
  557.  * Description: USB Clear Ep feature implement
  558.  *
  559.  *************************************************************************/
  560. inline
  561. UsbCommStatus_t UsbClearEpFeature(Int16U Feature,Int16U Index)
  562. {
  563. USB_Endpoint_t UsbEpAdd;
  564.   if(((Index & 0x7F) > 16) || (Feature != UsbEpHaltSelector))
  565.   {
  566.     return(UsbFault);
  567.   }
  568.   UsbEpAdd = USB_EpLogToPhysAdd(Index);
  569.   USB_SetStallEP(UsbEpAdd,FALSE);
  570.   if (UsbUserFun[UsbEpAdd] != NULL)
  571.   {
  572.     UsbUserFun[UsbEpAdd]((void *)UsbEpUnstall);
  573.   }
  574.   return(UsbPass);
  575. }
  577. /*************************************************************************
  578.  * Function Name: UsbClearFeature
  579.  * Parameters:  none
  580.  *
  581.  * Return: none
  582.  *
  583.  * Description: USB Clear feature implement
  584.  *
  585.  *************************************************************************/
  586. inline
  587. void UsbClearFeature (void)
  588. {
  589.   if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
  590.      // Length must be 0
  591.      (UsbEp0SetupPacket.wLength.Word == 0))
  592.   {
  593.     switch(UsbEp0SetupPacket.mRequestType.Recipient)
  594.     {
  595.     case UsbRecipientDevice:
  596.       if(UsbClearDevFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) == UsbPass)
  597.       {
  598.         USB_EpWrite(CTRL_ENP_IN,NULL,0);
  599.         UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  600.       }
  601.       else
  602.       {
  603.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  604.       }
  605.       break;
  606.     case UsbRecipientInterface:
  607.       if((UsbDevCtrl.State.DS > UsbDevStatusAddress) &&
  608.          (UsbClearInterfaceFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) == UsbPass))
  609.       {
  610.         USB_EpWrite(CTRL_ENP_IN,NULL,0);
  611.         UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  612.       }
  613.       else
  614.       {
  615.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  616.       }
  617.       break;
  618.     case UsbRecipientEndpoint:
  619.       if(((UsbDevCtrl.State.DS > UsbDevStatusAddress) || ((UsbEp0SetupPacket.wIndex.Word & 0x7F) == 0)) &&
  620.          (UsbClearEpFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) == UsbPass))
  621.       {
  622.         USB_EpWrite(CTRL_ENP_IN,NULL,0);
  623.         UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  624.       }
  625.       else
  626.       {
  627.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  628.       }
  629.       break;
  630.     default:
  631.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  632.     }
  633.   }
  634.   else
  635.   {
  636.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  637.   }
  638. }
  640. /*************************************************************************
  641.  * Function Name: UsbSetFeature
  642.  * Parameters:  Int16U Feature,Int16U Index
  643.  *
  644.  * Return: UsbCommStatus_t
  645.  *
  646.  * Description: USB Set Device feature implement
  647.  *
  648.  *************************************************************************/
  649. inline
  650. UsbCommStatus_t UsbSetDevFeature(Int16U Feature,Int16U Index)
  651. {
  652.   if((Index != 0) || (Feature != UsbDeviceRemoteWakeupSelector))
  653.   {
  654.     return(UsbFault);
  655.   }
  656.   UsbDevCtrl.Feature.RemoteWakeupEnable = 1;
  657.   return(UsbPass);
  658. }
  659. /*************************************************************************
  660.  * Function Name: UsbSetInterfaceFeature
  661.  * Parameters:  Int16U Feature,Int16U Index
  662.  *
  663.  * Return: UsbCommStatus_t
  664.  *
  665.  * Description: USB Set Interface feature implement
  666.  *
  667.  *************************************************************************/
  668. inline
  669. UsbCommStatus_t UsbSetInterfaceFeature(Int16U Feature,Int16U Index)
  670. {
  671.   return(UsbFault);
  672. }
  674. /*************************************************************************
  675.  * Function Name: UsbSetEpFeature
  676.  * Parameters:  Int16U Feature,Int16U Index
  677.  *
  678.  * Return: UsbCommStatus_t
  679.  *
  680.  * Description: USB Set Ep feature implement
  681.  *
  682.  *************************************************************************/
  683. inline
  684. UsbCommStatus_t UsbSetEpFeature(Int16U Feature,Int16U Index)
  685. {
  686. USB_Endpoint_t UsbEpAdd;
  687.   if(((Index & 0x7F) > 16) || (Feature != UsbEpHaltSelector))
  688.   {
  689.     return(UsbFault);
  690.   }
  691.   UsbEpAdd = USB_EpLogToPhysAdd(Index);
  692.   USB_SetStallEP(UsbEpAdd,TRUE);
  693.   if (UsbUserFun[UsbEpAdd] != NULL)
  694.   {
  695.     UsbUserFun[UsbEpAdd]((void *)UsbEpStall);
  696.   }
  697.   return(UsbPass);
  698. }
  700. /*************************************************************************
  701.  * Function Name: UsbSetFeature
  702.  * Parameters:  none
  703.  *
  704.  * Return: none
  705.  *
  706.  * Description: USB Set feature implement
  707.  *
  708.  *************************************************************************/
  709. inline
  710. void UsbSetFeature (void)
  711. {
  712.   if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
  713.      // Length must be 0
  714.      (UsbEp0SetupPacket.wLength.Word == 0))
  715.   {
  716.     switch(UsbEp0SetupPacket.mRequestType.Recipient)
  717.     {
  718.     case UsbRecipientDevice:
  719.       if(UsbSetDevFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) == UsbPass)
  720.       {
  721.         USB_EpWrite(CTRL_ENP_IN,NULL,0);
  722.         UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  723.       }
  724.       else
  725.       {
  726.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  727.       }
  728.       break;
  729.     case UsbRecipientInterface:
  730.       if((UsbDevCtrl.State.DS > UsbDevStatusAddress) &&
  731.          (UsbSetInterfaceFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) == UsbPass))
  732.       {
  733.         USB_EpWrite(CTRL_ENP_IN,NULL,0);
  734.         UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  735.       }
  736.       else
  737.       {
  738.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  739.       }
  740.       break;
  741.     case UsbRecipientEndpoint:
  742.       if(((UsbDevCtrl.State.DS > UsbDevStatusAddress) || ((UsbEp0SetupPacket.wIndex.Lo & 0x7F) == 0)) &&
  743.          (UsbSetEpFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) == UsbPass))
  744.       {
  745.         USB_EpWrite(CTRL_ENP_IN,NULL,0);
  746.         UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  747.       }
  748.       else
  749.       {
  750.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  751.       }
  752.       break;
  753.     default:
  754.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  755.     }
  756.   }
  757.   else
  758.   {
  759.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  760.   }
  761. }
  763. /*************************************************************************
  764.  * Function Name: UsbSetAddress
  765.  * Parameters:  none
  766.  *
  767.  * Return: none
  768.  *
  769.  * Description: USB Set address request implement
  770.  *
  771.  *************************************************************************/
  772. inline
  773. void UsbSetAddress (void)
  774. {
  775.   if((UsbDevCtrl.State.DS >= UsbDevStatusDefault) &&
  776.      (UsbEp0SetupPacket.mRequestType.Recipient == 0) &&
  777.      (UsbEp0SetupPacket.wIndex.Word  == 0) &&
  778.      (UsbEp0SetupPacket.wLength.Word == 0) &&
  779.      (UsbEp0SetupPacket.wValue.Word < 128))
  780.   {
  781.     USB_EpWrite(CTRL_ENP_IN,NULL,0);
  782.     UsbEp0Ctrl.EpStatus.Status = UsbEpStatusInSetAdd;
  783.   }
  784.   else
  785.   {
  786.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  787.   }
  788. }
  790. /*************************************************************************
  791.  * Function Name: UsbGetDescriptorDevice
  792.  * Parameters:  Int8U Index - must be 0
  793.  *
  794.  * Return: UsbCommStatus_t
  795.  *
  796.  * Description: USB get device's descriptor request implement
  797.  *
  798.  *************************************************************************/
  799. inline
  800. UsbCommStatus_t UsbGetDescriptorDevice(Int8U Index)
  801. {
  802.   if(Index == 0)
  803.   {
  804.     UsbEp0Ctrl.Counter = UsbStandardDeviceDescriptorStr.bLength;
  805.     UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  806.     if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
  807.     {
  808.       UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  809.       UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  810.     }
  811.     UsbEp0Ctrl.pData = (Int8U *)&UsbStandardDeviceDescriptorStr;
  812.     UsbEp0SetupWrite();
  813.     return(UsbPass);
  814.   }
  815.   return(UsbFault);
  816. }
  818. /*************************************************************************
  819.  * Function Name: UsbGetDescriptorConfiguration
  820.  * Parameters:  Int8U Index
  821.  *
  822.  * Return: UsbCommStatus_t
  823.  *
  824.  * Description: USB get configuration's descriptor request implement
  825.  *
  826.  *************************************************************************/
  827. inline
  828. UsbCommStatus_t UsbGetDescriptorConfiguration(Int8U Index)
  829. {
  830. UsbStandardConfigurationDescriptor_t *pData;
  831.   for(pData = (UsbStandardConfigurationDescriptor_t *)UsbStandardConfigurationDescriptor;
  832.       pData->bLength;
  833.       pData=(UsbStandardConfigurationDescriptor_t*)((Int8U *)pData + pData->bLength))
  834.   {
  835.     if((pData->bDescriptorType == UsbDescriptorConfiguration) &&
  836.        ((UsbStandardDeviceDescriptorStr.bNumConfigurations == 1) ||
  837.        (pData->bConfigurationValue == Index)))
  838.     {
  839.       break;
  840.     }
  841.   }
  842.   if(pData->bLength == 0)
  843.   {
  844.      return(UsbFault);
  845.   }
  846.   UsbEp0Ctrl.Counter = ((UsbStandardConfigurationDescriptor_t*)pData)->wTotalLength;
  847.   UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  848.   if(UsbEp0Ctrl.Counter > UsbEp0SetupPacket.wLength.Word)
  849.   {
  850.     UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  851.     UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  852.   }
  853.   UsbEp0Ctrl.pData = (Int8U *)pData;
  854.   UsbEp0SetupWrite();
  855.   return(UsbPass);
  856. }
  858. /*************************************************************************
  859.  * Function Name: UsbGetDescriptorString
  860.  * Parameters:  Int8U Index
  861.  *
  862.  * Return: UsbCommStatus_t
  863.  *
  864.  * Description: USB get string's descriptor request implement
  865.  *
  866.  *************************************************************************/
  867. inline
  868. UsbCommStatus_t UsbGetDescriptorString(Int8U Index)
  869. {
  870. Int8U **pData;
  871. Int32U i;
  872.   if(Index == 0)
  873.   {
  874.     UsbEp0Ctrl.Counter = UsbLanguagesStr[UsbDescLengthOffset];
  875.     UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  876.     if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
  877.     {
  878.       UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  879.       UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  880.     }
  881.     UsbEp0Ctrl.pData = (Int8U *)&UsbLanguagesStr;
  882.     UsbEp0SetupWrite();
  883.     return(UsbPass);
  884.   }
  885.   else
  886.   {
  887.     Int32U LanguagesOffset = 0;
  888.     // Find Languages index
  889.     for(i = 2; i < UsbLanguagesStr[UsbDescLengthOffset]; i+=2)
  890.     {
  891.       if((UsbLanguagesStr[i] == UsbEp0SetupPacket.wIndex.Lo) &&
  892.          (UsbLanguagesStr[i+1] == UsbEp0SetupPacket.wIndex.Hi))
  893.       {
  894.         break;
  895.       }
  896.       ++LanguagesOffset;
  897.     }
  898.     if(i >= UsbLanguagesStr[UsbDescLengthOffset])
  899.     {
  900.       return(UsbFault);
  901.     }
  902.     // Find String index
  903.     for(pData = (Int8U **)UsbString[LanguagesOffset]; pData ; ++pData)
  904.     {
  905.       if(--Index == 0)
  906.       {
  907.         break;
  908.       }
  909.     }
  910.     if(pData == NULL)
  911.     {
  912.       return(UsbFault);
  913.     }
  914.     UsbEp0Ctrl.Counter = *(*pData+UsbDescLengthOffset);
  915.     UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  916.     if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
  917.     {
  918.       UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  919.       UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  920.     }
  921.     UsbEp0Ctrl.pData = *pData;
  922.     UsbEp0SetupWrite();
  923.   }
  924.   return(UsbPass);
  925. }
  927. /*************************************************************************
  928.  * Function Name: UsbGetDescriptor
  929.  * Parameters:  none
  930.  *
  931.  * Return: none
  932.  *
  933.  * Description: USB get descriptor request implement
  934.  *
  935.  *************************************************************************/
  936. inline
  937. void UsbGetDescriptor (void)
  938. {
  939.     if(UsbDevCtrl.State.DS >= UsbDevStatusDefault)
  940.     {
  941.       switch(UsbEp0SetupPacket.wValue.Hi)
  942.       {
  943.       case UsbDescriptorDevice:
  944.         if(UsbGetDescriptorDevice(UsbEp0SetupPacket.wValue.Lo) != UsbPass)
  945.         {
  946.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  947.         }
  948.         break;
  949.       case UsbDescriptorConfiguration:
  950.         if(UsbGetDescriptorConfiguration(UsbEp0SetupPacket.wValue.Lo) != UsbPass)
  951.         {
  952.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  953.         }
  954.         break;
  955.       case UsbDescriptorString:
  956.         if(UsbGetDescriptorString(UsbEp0SetupPacket.wValue.Lo) != UsbPass)
  957.         {
  958.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  959.         }
  960.         break;
  961.       default:
  962.         if ((UsbCoreUserFun[UsbUserGetDescriptor] == NULL) ||
  963.             ((Int32U)UsbCoreUserFun[UsbUserGetDescriptor](&UsbEp0Ctrl) != UsbPass))
  964.         {
  965.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  966.         }
  967.       }
  968.     }
  969.     else
  970.     {
  971.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  972.     }
  973. }
  975. /*************************************************************************
  976.  * Function Name: UsbSetDescriptor
  977.  * Parameters:  none
  978.  *
  979.  * Return: none
  980.  *
  981.  * Description: USB Set descriptor
  982.  *
  983.  *************************************************************************/
  984. inline
  985. void UsbSetDescriptor(void)
  986. {
  987.   if(UsbDevCtrl.State.DS >= UsbDevStatusAddress)
  988.   {
  989.     // This request is valid only for Address state and Configured state.
  990.     // If supported
  991.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  992.   }
  993.   else
  994.   {
  995.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  996.   }
  997. }
  999. /*************************************************************************
  1000.  * Function Name: UsbGetConfiguration
  1001.  * Parameters:  none
  1002.  *
  1003.  * Return: none
  1004.  *
  1005.  * Description: USB Get configuration implement
  1006.  *
  1007.  *************************************************************************/
  1008. inline
  1009. void UsbGetConfiguration(void)
  1010. {
  1011.   if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
  1012.      (UsbEp0SetupPacket.wValue.Word == 0) &&
  1013.      (UsbEp0SetupPacket.wIndex.Word == 0) &&
  1014.      (UsbEp0SetupPacket.wLength.Word == 1))
  1015.   {
  1016.     UsbEp0Ctrl.Counter = 1;
  1017.     EpCtrlDataBuf[0] = UsbCoreReq(UsbCoreReqConfiquration);
  1018.     UsbEp0Ctrl.pData = EpCtrlDataBuf;
  1019.     UsbEp0SetupWrite();
  1020.   }
  1021.   else
  1022.   {
  1023.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1024.   }
  1025. }
  1027. /*************************************************************************
  1028.  * Function Name: UsbSetConfiguration
  1029.  * Parameters:  none
  1030.  *
  1031.  * Return: none
  1032.  *
  1033.  * Description: USB Set configuration implement
  1034.  *
  1035.  *************************************************************************/
  1036. inline
  1037. void UsbSetConfiguration(void)
  1038. {
  1039.   if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
  1040.      (UsbEp0SetupPacket.wIndex.Word == 0) &&
  1041.      (UsbEp0SetupPacket.wLength.Word == 0) &&
  1042.      (UsbSetConfigurtonState(UsbEp0SetupPacket.wValue.Lo) == UsbPass))
  1043.   {
  1044.     USB_EpWrite(CTRL_ENP_IN,NULL,0);
  1045.     UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  1046.   }
  1047.   else
  1048.   {
  1049.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1050.   }
  1051. }
  1053. /*************************************************************************
  1054.  * Function Name: UsbGetInterface
  1055.  * Parameters:  none
  1056.  *
  1057.  * Return: none
  1058.  *
  1059.  * Description: Implement get interface request
  1060.  *
  1061.  *************************************************************************/
  1062. inline
  1063. void UsbGetInterface (void)
  1064. {
  1065.   if((UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
  1066.      (UsbEp0SetupPacket.wIndex.Word == UsbDevCtrl.Interface) &&
  1067.      (UsbEp0SetupPacket.wLength.Word == 1) &&
  1068.      (UsbEp0SetupPacket.wValue.Word == 0))
  1069.   {
  1070.     UsbEp0Ctrl.Counter = 1;
  1071.     EpCtrlDataBuf[0] = UsbDevCtrl.AlternateSetting;
  1072.     UsbEp0Ctrl.pData = EpCtrlDataBuf;
  1073.     UsbEp0SetupWrite();
  1074.   }
  1075.   else
  1076.   {
  1077.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1078.   }
  1079. }
  1081. /*************************************************************************
  1082.  * Function Name: UsbSetInterface
  1083.  * Parameters:  none
  1084.  *
  1085.  * Return: none
  1086.  *
  1087.  * Description: Implement set interface request
  1088.  *
  1089.  *************************************************************************/
  1090. inline
  1091. void UsbSetInterface (void)
  1092. {
  1093.   if((UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
  1094.      (UsbEp0SetupPacket.wLength.Word == 0))
  1095.   {
  1096.     UsbStandardConfigurationDescriptor_t * pData = UsbFindConfiguration(UsbDevCtrl.Configuration);
  1097.     UsbDevCtrl_t UsbDevCtrlNew = UsbDevCtrl;
  1099.     UsbDevCtrlNew.Interface = UsbEp0SetupPacket.wIndex.Word;
  1100.     UsbDevCtrlNew.AlternateSetting = UsbEp0SetupPacket.wValue.Word;
  1101.     UsbDevCtrlNew.Feature.RemoteWakeupEnable = 0;
  1103.     // Whether the interface is exist into current conficuration?
  1104.     if(UsbFindInterface(pData,&UsbDevCtrlNew) != UsbPass)
  1105.     {
  1106.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1107.       return;
  1108.     }
  1110.     UsbCoreUserFun[UsbUserConfigure]((void *)&UsbDevCtrlNew);
  1111.     UsbDevCtrl = UsbDevCtrlNew;
  1113.     USB_EpWrite(CTRL_ENP_IN,NULL,0);
  1114.     UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  1115.   }
  1116.   else
  1117.   {
  1118.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1119.   }
  1120. }
  1122. /*************************************************************************
  1123.  * Function Name: UsbSynchFrame
  1124.  * Parameters:  none
  1125.  *
  1126.  * Return: none
  1127.  *
  1128.  * Description: Implement synch frame request
  1129.  *
  1130.  *************************************************************************/
  1131. inline
  1132. void UsbSynchFrame (void)
  1133. {
  1134.   if( USB_SOF_EVENT &&
  1135.      (UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
  1136.      (UsbEp0SetupPacket.wLength.Word == 2) &&
  1137.      (UsbEp0SetupPacket.wValue.Word == 0))
  1138.   {
  1139.   Int32U FrameNumb = 0;
  1140.   #if USB_SOF_EVENT > 0
  1141.     FrameNumb = USB_GetFrameNumb();
  1142.   #endif
  1143.     UsbEp0Ctrl.Counter = 2;
  1144.     EpCtrlDataBuf[0]   = FrameNumb;
  1145.     EpCtrlDataBuf[1]   = FrameNumb>>8;
  1146.     UsbEp0Ctrl.pData   = EpCtrlDataBuf;
  1147.     UsbEp0SetupWrite();
  1148.   }
  1149.   else
  1150.   {
  1151.     UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1152.   }
  1153. }
  1155. /*************************************************************************
  1156.  * Function Name: UsbCtrlEpCallback
  1157.  * Parameters:  void * pArg
  1158.  *
  1159.  * Return: none
  1160.  *
  1161.  * Description: USB Ctrl EP Callback
  1162.  *
  1163.  *************************************************************************/
  1164. void UsbCtrlEpCallback (void * pArg)
  1165. {
  1166. Int32U PacketSize;
  1168.   switch((Int32U)pArg)
  1169.   {
  1170.   case UsbSetupPacket:
  1171. setup_packet_overwrited:
  1172.     UsbEp0Ctrl.pData   = EpCtrlDataBuf;
  1173.     UsbEp0Ctrl.Counter = USB_EpRead(CTRL_ENP_OUT,(Int32U *)EpCtrlDataBuf,Ep0MaxSize);
  1174.     if(UsbEp0Ctrl.EpStatus.Status != UsbEpPause)
  1175.     {
  1176.       // Copy new setup packet int setup buffer
  1177.       memcpy((Int8U *)&UsbEp0SetupPacket,EpCtrlDataBuf,sizeof(UsbEp0SetupPacket));
  1178.     }
  1179.     switch(UsbEp0SetupPacket.mRequestType.Type)
  1180.     {
  1181.     // Standart
  1182.     case UsbTypeStandart:
  1183.       // Decoding standart request
  1184.       switch (UsbEp0SetupPacket.bRequest)
  1185.       {
  1186.       case GET_STATUS:
  1187.         UsbGetStatus();
  1188.         break;
  1189.       case CLEAR_FEATURE:
  1190.         UsbClearFeature();
  1191.         break;
  1192.       case SET_FEATURE:
  1193.         UsbSetFeature();
  1194.         break;
  1195.       case SET_ADDRESS:
  1196.         UsbSetAddress();
  1197.         break;
  1198.       case GET_DESCRIPTOR:
  1199.         if(UsbEp0SetupPacket.mRequestType.Recipient == UsbRecipientDevice)
  1200.         {
  1201.           UsbGetDescriptor();
  1202.         }
  1203.         // Only get descriptof for device is standart request
  1204.         else if ((UsbCoreUserFun[UsbUserGetDescriptor] != NULL) &&
  1205.                  ((Int32U)UsbCoreUserFun[UsbUserGetDescriptor](&UsbEp0Ctrl) == UsbUserSendPacket))
  1206.         {
  1207.           if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
  1208.           {
  1209.             UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  1210.             UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  1211.           }
  1212.           else
  1213.           {
  1214.              UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  1215.           }
  1216.           UsbEp0SetupWrite();
  1217.         }
  1218.         else
  1219.         {
  1220.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1221.         }
  1222.         break;
  1223.       case SET_DESCRIPTOR:
  1224.         // Optional (only for configuration and string descriptors)
  1225.         UsbSetDescriptor();
  1226.         break;
  1227.       case GET_CONFIGURATION:
  1228.         UsbGetConfiguration();
  1229.         break;
  1230.       case SET_CONFIGURATION:
  1231.         UsbSetConfiguration();
  1232.         break;
  1233.       case GET_INTERFACE:
  1234.         UsbGetInterface();
  1235.         break;
  1236.       case SET_INTERFACE:
  1237.         UsbSetInterface();
  1238.         break;
  1239.       case SYNCH_FRAME:
  1240.         UsbSynchFrame();
  1241.         break;
  1242.       default:
  1243.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1244.       }
  1245.       break;
  1246.     // Class
  1247.     case UsbTypeClass:
  1248.       if(UsbCoreUserFun[UsbUserClass] != NULL)
  1249.       {
  1250.         switch((Int32U)UsbCoreUserFun[UsbUserClass](&UsbEp0Ctrl))
  1251.         {
  1252.         case UsbUserNone:
  1253.           break;
  1254.         case UsbUserSendPacket:
  1255.           if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
  1256.           {
  1257.             UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  1258.             UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  1259.           }
  1260.           else
  1261.           {
  1262.             UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  1263.           }
  1264.           UsbEp0SetupWrite();
  1265.           break;
  1266.         case UsbUserReceivePacket:
  1267.           if((UsbEp0Ctrl.Counter == UsbEp0SetupPacket.wLength.Word) &&
  1268.              (UsbCoreUserFun[UsbClassEp0OutPacket] != NULL))
  1269.           {
  1270.             UsbEp0Ctrl.EpStatus.Status = UsbEpClassDataOut;
  1271.           }
  1272.           else
  1273.           {
  1274.             UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1275.           }
  1276.           break;
  1277.         case UsbUserSendAckn:
  1278.           USB_EpWrite(CTRL_ENP_IN,NULL,0);
  1279.           UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  1280.           break;
  1281.         default :
  1282.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1283.         }
  1284.       }
  1285.       else
  1286.       {
  1287.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1288.       }
  1289.       break;
  1290.     // Vendor
  1291.     case UsbTypeVendor:
  1292.       if(UsbCoreUserFun[UsbUserVendor] != NULL)
  1293.       {
  1294.         switch((Int32U)UsbCoreUserFun[UsbUserClass](&UsbEp0Ctrl))
  1295.         {
  1296.         case UsbUserNone:
  1297.           break;
  1298.         case UsbUserSendPacket:
  1299.           if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word)
  1300.           {
  1301.             UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
  1302.             UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
  1303.           }
  1304.           else
  1305.           {
  1306.             UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
  1307.           }
  1308.           UsbEp0SetupWrite();
  1309.           break;
  1310.         case UsbUserReceivePacket:
  1311.           if((UsbEp0Ctrl.Counter == UsbEp0SetupPacket.wLength.Word) &&
  1312.              (UsbCoreUserFun[UsbVendorEp0OutPacket] != NULL))
  1313.           {
  1314.             UsbEp0Ctrl.EpStatus.Status = UsbEpVendorDataOut;
  1315.           }
  1316.           else
  1317.           {
  1318.             UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1319.           }
  1320.           break;
  1321.         case UsbUserSendAckn:
  1322.           USB_EpWrite(CTRL_ENP_IN,NULL,0);
  1323.           UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  1324.           break;
  1325.         default :
  1326.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1327.         }
  1328.       }
  1329.       else
  1330.       {
  1331.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1332.       }
  1333.       break;
  1334.     // Other
  1335.     default:
  1336.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1337.     }
  1338.     break;
  1339.   // Out Packet
  1340.   case UsbDataOutPacket:
  1341.     switch(UsbEp0Ctrl.EpStatus.Status)
  1342.     {
  1343.     case UsbEpSetupDataIn:
  1344.     case UsbEpSetupLastIn:
  1345.       // Clear output ep buffer
  1346.       UsbEp0Ctrl.EpStatus.Status = UsbEpStatusOut;
  1347.       UsbEp0Ctrl.Counter = USB_EpRead(CTRL_ENP_OUT,(Int32U *)EpCtrlDataBuf,Ep0MaxSize);
  1348.       if (UsbEp0Ctrl.Counter & 0x80000000)
  1349.       {
  1350.          goto setup_packet_overwrited;
  1351.       }
  1352.       break;
  1353.     case UsbEpWaitStatusOut:
  1354.       // Clear output ep buffer
  1355.       UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  1356.       UsbEp0Ctrl.Counter = USB_EpRead(CTRL_ENP_OUT,(Int32U *)EpCtrlDataBuf,Ep0MaxSize);
  1357.       if (UsbEp0Ctrl.Counter & 0x80000000)
  1358.       {
  1359.          goto setup_packet_overwrited;
  1360.       }
  1361.       break;
  1362.     case UsbEpSetupDataOut:
  1363.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1364.       break;
  1365.     case UsbEpClassDataOut:
  1366.       PacketSize = USB_EpRead(CTRL_ENP_OUT,(Int32U *)UsbEp0Ctrl.pData,Ep0MaxSize);
  1367.       if (UsbEp0Ctrl.Counter & 0x80000000)
  1368.       {
  1369.          goto setup_packet_overwrited;
  1370.       }
  1371.       UsbEp0Ctrl.pData += PacketSize;
  1372.       UsbEp0Ctrl.Counter -= PacketSize;
  1373.       if(UsbEp0Ctrl.Counter == 0)
  1374.       {
  1375.         switch((Int32U)UsbCoreUserFun[UsbClassEp0OutPacket](NULL))
  1376.         {
  1377.         case UsbUserNone:
  1378.           UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  1379.           break;
  1380.         case UsbUserSendAckn:
  1381.           USB_EpWrite(CTRL_ENP_IN,NULL,0);
  1382.           UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  1383.           break;
  1384.         default:
  1385.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1386.         }
  1387.       }
  1388.       else if (PacketSize != Ep0MaxSize)
  1389.       {
  1390.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1391.       }
  1392.       break;
  1393.     case UsbEpVendorDataOut:
  1394.       PacketSize = USB_EpRead(CTRL_ENP_OUT,(Int32U *)UsbEp0Ctrl.pData,Ep0MaxSize);
  1395.       if (UsbEp0Ctrl.Counter & 0x80000000)
  1396.       {
  1397.          goto setup_packet_overwrited;
  1398.       }
  1399.       UsbEp0Ctrl.pData += PacketSize;
  1400.       UsbEp0Ctrl.Counter -= PacketSize;
  1401.       if(UsbEp0Ctrl.Counter == 0)
  1402.       {
  1403.         switch((Int32U)UsbCoreUserFun[UsbVendorEp0OutPacket](NULL))
  1404.         {
  1405.         case UsbUserNone:
  1406.           UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  1407.           break;
  1408.         case UsbUserSendAckn:
  1409.           USB_EpWrite(CTRL_ENP_IN,NULL,0);
  1410.           UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
  1411.           break;
  1412.         default:
  1413.           UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1414.         }
  1415.       }
  1416.       else if (PacketSize != Ep0MaxSize)
  1417.       {
  1418.         UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1419.       }
  1420.       break;
  1421.     default:
  1422.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1423.     }
  1424.     break;
  1425.   // In Packet
  1426.   case UsbDataInPacket:
  1427.     switch(UsbEp0Ctrl.EpStatus.Status)
  1428.     {
  1429.     case UsbEpStatusOut:
  1430.     case UsbEpWaitStatusIn:
  1431.     case UsbEpStatusIn:
  1432.       UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  1433.       break;
  1434.     case UsbEpSetupDataIn:
  1435.       UsbEp0SetupWrite();
  1436.       break;
  1437.     case UsbEpSetupLastIn:
  1438.       UsbEp0Ctrl.EpStatus.Status = UsbEpWaitStatusOut;
  1439.       break;
  1440.     case UsbEpStatusInSetAdd:
  1441.       USB_SetAdd(UsbEp0SetupPacket.wValue.Lo);
  1442.       UsbDevCtrl.DevAdd = UsbEp0SetupPacket.wValue.Lo;
  1443.       if(UsbEp0SetupPacket.wValue.Lo)
  1444.       {
  1445.         UsbSetDevState(UsbDevStatusAddress);
  1446.         UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  1447.       }
  1448.       else
  1449.       {
  1450.         UsbSetDevState(UsbDevStatusDefault);
  1451.         UsbCoreUserFun[UsbUserConfigure](NULL);
  1452.       }
  1453.       break;
  1454.     default:
  1455.       UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
  1456.     }
  1457.     break;
  1458.   }
  1459.   if (UsbEp0Ctrl.EpStatus.Status == UsbEpStall)
  1460.   {
  1461.     USB_SetStallEP(CTRL_ENP_OUT,TRUE);
  1462.     USB_SetStallEP(CTRL_ENP_IN ,TRUE);
  1463.     UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
  1464.   }
  1465. }