usb_t9.c

最新版IAR FOR ARM（EWARM）5.11中的代码例子

/*************************************************************************
 *
 *    Used with ICCARM and AARM.
 *
 *    (c) Copyright IAR Systems 2007
 *
 *    File name   : usb_t9.c
 *    Description : USB T9 subroutines
 *
 *    History :
 *    1. Date        : June 16, 2007
 *       Author      : Stanimir Bonev
 *       Description : Create
 *
 *    $Revision: 19278 $
 **************************************************************************/
#define USB_T9_GLOBAL
#include "usb_t9.h"

static UsbDevCtrl_t UsbDevCtrl;
static Int32U InData;

/*************************************************************************
 * Function Name: UsbCoreInit
 * Parameters: none
 *
 * Return: none
 *
 * Description: Init USB core
 *
 *************************************************************************/
void UsbCoreInit (void)
{
  UsbDevCtrl.State.DS      = UsbDevStatusUnknow;
  UsbDevCtrl.State.Suspend = FALSE;
  UsbDevCtrl.Feature.RemoteWakeupEnable = FALSE;
  UsbDevCtrl.Feature.SelfPowered = USB_SELF_POWERED;
#if USB_HIGH_SPEED > 0
  UsbDevCtrl.HighSpeed = 0;
#endif // USB_HIGH_SPEED > 0
  // Init HW
  USB_HwInit();
}

/*************************************************************************
 * Function Name: UsbCoreReq
 * Parameters:  UsbCoreReqType_t Type
 *
 * Return: Int32U
 *
 * Description: Return device states
 *
 *************************************************************************/
Int32U UsbCoreReq (UsbCoreReqType_t Type)
{
  switch(Type)
  {
  case UsbCoreReqDevState:
    return(UsbDevCtrl.State.DS);
  case UsbCoreReqDevSusState:
    return(UsbDevCtrl.State.Suspend);
  case UsbCoreReqConfiquration:
    return(UsbDevCtrl.Configuration);
  case UsbCoreReqInterface:
    return(UsbDevCtrl.Interfaces);
  case UsbCoreReqDevOwnAddress:
    return(UsbDevCtrl.DevAdd);
  case UsbCoreReqWakeUpEnableStatus:
    return(UsbDevCtrl.Feature.RemoteWakeupEnable);
  case UsbCoreReqSelfPoweredStatus:
    return(USB_SELF_POWERED);
#if USB_HIGH_SPEED > 0
  case UsbCoreReqSpeed:
    return(UsbDevCtrl.HighSpeed);
#endif // USB_HIGH_SPEED > 0
  }
  return((Int32U) -1);
}

#if USB_REMOTE_WAKEUP != 0
/*************************************************************************
 * Function Name: UsbWakeUp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: Wake-up device from suspend mode
 *
 *************************************************************************/
void UsbWakeUp (void)
{
  if(UsbDevCtrl.Feature.RemoteWakeupEnable && UsbDevCtrl.State.Suspend)
  {
    USB_WakeUp();
  }
}
#endif // USB_REMOTE_WAKEUP != 0

/*************************************************************************
 * Function Name: UsbSetDevState
 * Parameters:  UsbT9DevState_t DevState
 *
 * Return: none
 *
 * Description: Set device state
 *
 *************************************************************************/
void UsbSetDevState (UsbT9DevState_t DevState)
{
pUsbStandardInterfaceDescriptor_t pInterface;
  if(UsbDevCtrl.State.DS == UsbDevStatusConfigured)
  {
    // deconfigure device
    for (Int32U i = 0; i < UsbDevCtrl.Interfaces; ++i)
    {
      pInterface = UsbFindInterface(UsbDevCtrl.pCnfg,i,UsbDevCtrl.AlternateSetting[i]);
      UsbEpInterfaceCnfg(pInterface,FALSE);
    }
  }
  switch (DevState)
  {
  case UsbDevStatusAttached:
  case UsbDevStatusPowered:
  case UsbDevStatusDefault:
    USB_Configure(FALSE);
    USB_SetDefAdd();  // Set address 0
    USB_CONFIGURE_HOOK(NULL);
    UsbDevCtrl.DevAdd = UsbDevCtrl.Configuration = 0;
    break;
  case UsbDevStatusAddress:
    USB_Configure(FALSE);
    UsbDevCtrl.Configuration = 0;
    break;
  case UsbDevStatusConfigured:
    // configure device
    for (Int32U i = 0; i < UsbDevCtrl.Interfaces; ++i)
    {
      pInterface = UsbFindInterface(UsbDevCtrl.pCnfg,i,UsbDevCtrl.AlternateSetting[i]);
      UsbEpInterfaceCnfg(pInterface,TRUE);
    }
    USB_Configure(TRUE);
    break;
  default:  // unknown state - disconnected or in process of a connection
    USB_Configure(FALSE);
    USB_CONFIGURE_HOOK(NULL);
    UsbDevCtrl.DevAdd = UsbDevCtrl.Configuration = 0;
  }
  UsbDevCtrl.State.DS = DevState;
}

/*************************************************************************
 * Function Name: UsbDevConnectCallback
 * Parameters:  void * pArg
 *
 * Return: none
 *
 * Description: USB connect callback
 *
 *************************************************************************/
void UsbDevConnectCallback (Boolean Connect)
{
  UsbSetDevState(Connect?UsbDevStatusAttached:UsbDevStatusUnknow);
  USB_CONNECT_HOOK(Connect);
}

/*************************************************************************
 * Function Name: UsbDevSuspendCallback
 * Parameters:  Boolean Suspend
 *
 * Return: none
 *
 * Description: USB suspend callback
 *
 *************************************************************************/
void UsbDevSuspendCallback (Boolean Suspend)
{
  UsbDevCtrl.State.Suspend = Suspend ? UsbDevStatusSuspend : UsbDevStatusNoSuspend;
  USB_SUSPEND_HOOK(Suspend);
}

/*************************************************************************
 * Function Name: UsbDevResetCallback
 * Parameters: none
 *
 * Return: none
 *
 * Description: USB reset callback
 *
 *************************************************************************/
void UsbDevResetCallback (void)
{
  UsbSetDevState(UsbDevStatusDefault);
  USB_RESET_HOOK();
}

#if USB_HIGH_SPEED > 0
/*************************************************************************
 * Function Name: UsbDevSpeedCallback
 * Parameters: Boolean HighSpeed
 *
 * Return: none
 *
 * Description: USB Speed change callback
 *
 *************************************************************************/
void UsbDevSpeedCallback(Boolean HighSpeed)
{
  UsbDevCtrl.HighSpeed = HighSpeed;
}
#endif // USB_HIGH_SPEED > 0

/*************************************************************************
 * Function Name: USB_T9_Size
 * Parameters:  Int32U Size,Int32U HostExpSize
 *
 * Return: Int32U
 *
 * Description: Return lower from Host expected size and size and set
 * a flag bZeroPacketPossible when size is lower that host expected size
 *
 *************************************************************************/
Int32U USB_T9_Size(Int32U Size,Int32U HostExpSize)
{
Int32U ActSize = HostExpSize;
  if(Size < HostExpSize)
  {
    ActSize = Size;
    EpCnfg[CTRL_ENP_IN].bZeroPacketPossible = 1;
  }
  return(ActSize);
}

/*************************************************************************
 * Function Name: USB_SetupHandler
 * Parameters: void
 *
 * Return: none
 *
 * Description: Setup packet handler
 *
 *************************************************************************/
void USB_SetupHandler (void)
{
  switch(UsbEp0SetupPacket.mRequestType.Type)
  {
  // Standard
  case UsbTypeStandart:
    // Decoding standard 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 descriptor for device is standard request
      else if ((UsbEp0SetupPacket.mRequestType.Dir == UsbDevice2Host) &&
               (USB_GET_DESCRIPTOR_HOOK(&UsbEp0SetupPacket) == UsbPass))
      {
      }
      else
      {
        USB_T9_ERROR_REQUEST();
      }
      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:
      USB_T9_ERROR_REQUEST();
    }
    break;
  // Class
  case UsbTypeClass:
    if(USB_CLASS_REQUEST_HOOK(&UsbEp0SetupPacket) != UsbPass)
    {
      USB_T9_ERROR_REQUEST();
    }
    else
    {
    }
    break;
  // Vendor
  case UsbTypeVendor:
    if( USB_VENDOR_REQUEST_HOOK(&UsbEp0SetupPacket) != UsbPass)
    {
      USB_T9_ERROR_REQUEST();
    }
    else
    {
    }
    break;
  // Other
  default:
    USB_T9_ERROR_REQUEST();
  }
}

/*************************************************************************
 * Function Name: USB_StatusHandler
 * Parameters: USB_Endpoint_t EP
 *
 * Return: none
 *
 * Description: Address status handler
 *
 *************************************************************************/
void USB_StatusHandler (USB_Endpoint_t EP)
{
  if (UsbEp0SetupPacket.mRequestType.Dir == UsbDevice2Host)
  {
    USB_StatusPhase(CTRL_ENP_OUT);
    EpCnfg[CTRL_ENP_OUT].pFn = (void *)USB_StatusEndHandler;
  }
  else
  {
    USB_StatusPhase(CTRL_ENP_IN);
    EpCnfg[CTRL_ENP_IN].pFn = (UsbEp0SetupPacket.bRequest == SET_ADDRESS)
                               ?(void *)USB_AddStatusEndHandler
                               :(void *)USB_StatusEndHandler;
  }
}

/*************************************************************************
 * Function Name: USB_AddStatusEndHandler
 * Parameters: USB_Endpoint_t EP
 *
 * Return: none
 *
 * Description: Setup packet status phase end handler
 *
 *************************************************************************/
static
void USB_StatusEndHandler (USB_Endpoint_t EP)
{
  USB_IO_Data(CTRL_ENP_IN ,NULL,(Int32U)-1,NULL);
  USB_IO_Data(CTRL_ENP_OUT,NULL,(Int32U)-1,NULL);
}

/*************************************************************************
 * Function Name: USB_AddStatusEndHandler
 * Parameters: USB_Endpoint_t EP
 *
 * Return: none
 *
 * Description: Setup packet - set address status phase end handler
 *
 *************************************************************************/
static
void USB_AddStatusEndHandler (USB_Endpoint_t EP)
{
  // Device address is set after status phase of set address request
  UsbDevCtrl.DevAdd = UsbEp0SetupPacket.wValue.Lo;
  USB_SetAdd(UsbDevCtrl.DevAdd);
  if(UsbDevCtrl.DevAdd)
  {
    UsbSetDevState(UsbDevStatusAddress);
  }
  else
  {
    // when address is 0 put device init configuration state
    UsbSetDevState(UsbDevStatusDefault);
  }
  USB_IO_Data(CTRL_ENP_IN ,NULL,(Int32U)-1,NULL);
  USB_IO_Data(CTRL_ENP_OUT,NULL,(Int32U)-1,NULL);
}

/*************************************************************************
 * Function Name: UsbFindInterface
 * Parameters:  UsbStandardConfigurationDescriptor_t * pConfiguration,
 *              Int32U Interface, Int32U AlternateSetting
 *
 * Return: pUsbStandardInterfaceDescriptor_t
 *
 * Description: Set Interface and  Alternative setting state
 *
 *************************************************************************/
static
pUsbStandardInterfaceDescriptor_t UsbFindInterface (
                      UsbStandardConfigurationDescriptor_t * pConfiguration,
                      Int32U Interface, Int32U AlternateSetting)
{
pUsbStandardInterfaceDescriptor_t pData;
  assert(pConfiguration != NULL);
  // Find Interface
  for( pData = (UsbStandardInterfaceDescriptor_t *)pConfiguration;
      (Int8U*)pData < (Int8U *)pConfiguration + pConfiguration->wTotalLength;
       pData =(UsbStandardInterfaceDescriptor_t *)((Int8U *)pData + pData->bLength))
  {
    if((pData->bDescriptorType == UsbDescriptorInterface) &&
       (pData->bInterfaceNumber == Interface) &&
       (pData->bAlternateSetting == AlternateSetting))
    {
      return(pData);
    }
  }
  return(NULL);
}

/*************************************************************************
 * Function Name: UsbFindConfiguration
 * Parameters:  Int32U
 *
 * Return: UsbStandardConfigurationDescriptor_t *
 *
 * Description: Return pointer to current configuration
 *
 *************************************************************************/
static
UsbStandardConfigurationDescriptor_t * UsbFindConfiguration(Int32U Configuration)
{
#if USB_HIGH_SPEED > 0
const Int8U ** ppCfgArray = (const Int8U**)UsbDescArray[(UsbDevCtrl.HighSpeed?USB_HS_CFG_ARRAY:USB_FS_CFG_ARRAY)];
#else
const Int8U ** ppCfgArray = (const Int8U**)UsbDescArray[USB_FS_CFG_ARRAY];
#endif
pUsbStandardConfigurationDescriptor_t pData = (pUsbStandardConfigurationDescriptor_t)*ppCfgArray;
  while((pData = (pUsbStandardConfigurationDescriptor_t)*ppCfgArray) != NULL)
  {
    if(pData->bDescriptorType == UsbDescriptorConfiguration)
    {
      if(pData->bConfigurationValue == Configuration)
      {
         return(pData);
      }

    }
    ++*ppCfgArray;
  }
  return(NULL);
}

/*************************************************************************
 * Function Name: UsbFindEP
 * Parameters: pUsbStandardInterfaceDescriptor_t pInterface,
 *             pUsbStandardEpDescriptor_t pEp
 *
 * Return: pUsbStandardEpDescriptor_t
 *
 * Description: Return pointer to next EP
 *
 *************************************************************************/