cd_class.c

NXP LPC系列AMR7的开发程序源码（LCD

/*************************************************************************
 *
 *    Used with ICCARM and AARM.
 *
 *    (c) Copyright IAR Systems 2006
 *
 *    File name   : cd_class.c
 *    Description : Communication device class module
 *
 *    History :
 *    1. Date        : June 28, 2006
 *       Author      : Stanimir Bonev
 *       Description : Create
 *
 *    $Revision: 14946 $
**************************************************************************/
#define CD_CLASS_GLOBAL
#include "cd_class.h"

#pragma data_alignment=4
CDC_LineCoding_t CDC_LineCoding;

#if CDC_DEVICE_SUPPORT_LINE_CODING > 0
volatile Int32U LineCodingDelta;
#endif // CDC_DEVICE_SUPPORT_LINE_CODING > 0

#pragma data_alignment=4
CDC_LineState_t  CDC_LineState;

#if CDC_DEVICE_SUPPORT_LINE_STATE > 0
volatile Int32U SerialStateDelta;
#pragma data_alignment=4
SerialState_t CurrSerialState;

volatile Int32U LineStateDelta;
#endif // CDC_DEVICE_SUPPORT_LINE_STATE > 0

#if CDC_DEVICE_SUPPORT_BREAK > 0
volatile Int32U BreakCntr;
#endif // CDC_DEVICE_SUPPORT_BREAK > 0

#pragma data_alignment=4
UsbSetupPacket_t CdcReqPacket;

Int32U CDC_ReceiveIndx, CDC_ReceiveIndxHold;
Int32U CDC_TransmitSize;
volatile Boolean USB_CDC_OutEpBufferNotEmpty;
pInt8U volatile pCDC_TransmitUserBuffer;

#pragma data_alignment=4
Int8U CDC_ReceiveBuffer[CommOutEpMaxSize];
#pragma data_alignment=4
Int8U CDC_TransmitBuffer[CommInEpMaxSize];

volatile Boolean CDC_Configure;

/*************************************************************************
 * Function Name: UsbCdcInit
 * Parameters: LPC_VicIrqSlots_t TimIrqSlot
 *
 * Return: none
 *
 * Description: USB communication device class init
 *
 *************************************************************************/
void UsbCdcInit (LPC_VicIrqSlots_t TimIrqSlot)
{
  // Init CD Class variables
  CDC_Configure               = FALSE;

  CDC_LineCoding.dwDTERate    = CDC_DATA_RATE;
  CDC_LineCoding.bDataBits    = CDC_DATA_BITS;
  CDC_LineCoding.bParityType  = CDC_PARITY;
  CDC_LineCoding.bCharFormat  = CDC_STOP_BITS;

#if CDC_DEVICE_SUPPORT_LINE_CODING > 0
  // Update the line coding
  LineCodingDelta             = TRUE;
#endif // CDC_DEVICE_SUPPORT_LINE_CODING > 0

  CDC_LineState.DTR_State     = CDC_LINE_DTR;
  CDC_LineState.RTS_State     = CDC_LINE_RTS;

#if CDC_DEVICE_SUPPORT_LINE_STATE > 0
  // Update the line state
  LineStateDelta              = TRUE;
  CurrSerialState.Data        = 0;
  SerialStateDelta            = FALSE;
#endif // CDC_DEVICE_SUPPORT_LINE_STATE > 0

#if CDC_DEVICE_SUPPORT_BREAK > 0

  BreakCntr = 0;
  // Init Break timer resolution 1 ms
  TIMER_Init(TIMER0, 1000);
  VIC_SetVectoredIRQ(TIMER0_ISR,TimIrqSlot,VIC_TIMER0);
  VIC_EnableInt(1<<VIC_TIMER0);
#endif // CDC_DEVICE_SUPPORT_BREAK > 0

  CDC_ReceiveIndx      = \
  CDC_ReceiveIndxHold  = \
  CDC_TransmitSize     = 0;

  USB_CDC_OutEpBufferNotEmpty = FALSE;

  pCDC_TransmitUserBuffer = NULL;

  // Registered the class request
  UsbCoreUserFuncRegistering(UsbCdcRequest,UsbUserClass);
  // Registered the function for a data receive of the class request
  UsbCoreUserFuncRegistering(UsbCdcData,UsbClassEp0OutPacket);
}

/*************************************************************************
 * Function Name: UsbCdcConfigure
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB communication device class configure
 *
 *************************************************************************/
void * UsbCdcConfigure (void * pArg)
{
UsbDevCtrl_t * pUsbDevCtrl = (UsbDevCtrl_t *)pArg;
  if(pUsbDevCtrl == NULL)
  {
    if(UsbCoreReq(UsbCoreReqConfiquration) != 0)
    {
      CDC_Configure = FALSE;
      // disable all class EPs
      USB_RealizeEndPoint((USB_Endpoint_t)CommOutEp,1,0,FALSE);
      USB_UserFuncRegistering(NULL,CommOutEp);
      USB_RealizeEndPoint((USB_Endpoint_t)CommInEp,1,0,FALSE);
      USB_UserFuncRegistering(NULL,CommInEp);
      USB_RealizeEndPoint((USB_Endpoint_t)ReportEp,1,0,FALSE);
      USB_UserFuncRegistering(NULL,ReportEp);
    }
  }
  else
  {
    // Init variables
    CDC_ReceiveIndx      = \
    CDC_ReceiveIndxHold  = \
    CDC_TransmitSize     = 0;

    USB_CDC_OutEpBufferNotEmpty = FALSE;

#if CDC_DEVICE_SUPPORT_BREAK > 0
    BreakCntr = 0;
#endif  // CDC_DEVICE_SUPPORT_BREAK > 0

    // enable all class EPs
    USB_RealizeEndPoint((USB_Endpoint_t)CommOutEp,0,CommOutEpMaxSize,TRUE);
    USB_UserFuncRegistering(UsbCdcInHadler,CommOutEp);
    USB_RealizeEndPoint((USB_Endpoint_t)CommInEp,1,CommInEpMaxSize,TRUE);
    USB_UserFuncRegistering(UsbCdcOutHadler,CommInEp);
    USB_RealizeEndPoint((USB_Endpoint_t)ReportEp,1,ReportEpMaxSize,TRUE);
#if CDC_DEVICE_SUPPORT_LINE_STATE > 0
    USB_UserFuncRegistering(UsbCdcReportHadler,ReportEp);
#else
    USB_UserFuncRegistering(NULL,ReportEp);
#endif // CDC_DEVICE_SUPPORT_LINE_STATE > 0

    CDC_Configure = TRUE;
  }
  return(NULL);
}

#if CDC_DEVICE_SUPPORT_LINE_STATE > 0
/*************************************************************************
 * Function Name: UsbCdcReportHadler
 * Parameters:  void * pArg
 *
 * Return: none
 *
 * Description: USB Communication Device Class Report (In) EP handler
 *
 *************************************************************************/
void UsbCdcReportHadler (void *Arg)
{
  SerialStateDelta = FALSE;
}
#endif // CDC_DEVICE_SUPPORT_LINE_STATE > 0

/*************************************************************************
 * Function Name: UsbCdcInHadler
 * Parameters:  void * pArg
 *
 * Return: none
 *
 * Description: USB Communication Device Class Out EP handler
 *
 *************************************************************************/
void UsbCdcInHadler (void *Arg)
{
    if(CDC_ReceiveIndx == 0)
    {
      CDC_ReceiveIndx = USB_EpRead((USB_Endpoint_t)CommOutEp,
                                   (pInt32U)CDC_ReceiveBuffer,
                                   CommOutEpMaxSize);
    }
    else
    {
      USB_CDC_OutEpBufferNotEmpty = TRUE;
    }
}

/*************************************************************************
 * Function Name: UsbCdcOutHadler
 * Parameters:  void * pArg
 *
 * Return: none
 *
 * Description: USB Communication Device Class In EP handler
 *
 *************************************************************************/
void UsbCdcOutHadler (void *Arg)
{
Int32U Counter, CurrWriteSize;
  if(CDC_TransmitSize != 0)
  {
    CurrWriteSize = MIN(CDC_TransmitSize,CommInEpMaxSize);
    for(Counter = 0; Counter < CurrWriteSize; ++Counter)
    {
      CDC_TransmitBuffer[Counter] = *pCDC_TransmitUserBuffer++;
    }
    CDC_TransmitSize -= CurrWriteSize;
    USB_EpWrite((USB_Endpoint_t)CommInEp,(pInt32U)CDC_TransmitBuffer,CurrWriteSize);
  }
  else
  {
    pCDC_TransmitUserBuffer = NULL;
  }
}

/*************************************************************************
 * Function Name: UsbCdcRequest
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: The class requests processing
 *
 *************************************************************************/
void * UsbCdcRequest (void * pArg)
{
UsbEpCtrl_t * pCdcReqCtrl = (UsbEpCtrl_t *) pArg;
  CdcReqPacket = *(UsbSetupPacket_t *)pCdcReqCtrl->pData;
  // Validate Request
  if (CdcReqPacket.mRequestType.Recipient == UsbRecipientInterface)
  {
    switch (CdcReqPacket.bRequest)
    {
    case SET_LINE_CODING:
      if ((CdcReqPacket.wValue.Word == 0) &&
          (CdcReqPacket.wIndex.Word == 0))
      {
        pCdcReqCtrl->Counter = MIN(sizeof(CDC_LineCoding_t),
                                  ((CdcReqPacket.wLength.Hi << 8) + CdcReqPacket.wLength.Lo));
        pCdcReqCtrl->pData = (pInt8U)&CDC_LineCoding;
        return((void *)UsbUserReceivePacket);
      }
      break;
    case GET_LINE_CODING:
      if ((CdcReqPacket.wValue.Word == 0) &&
          (CdcReqPacket.wIndex.Word == 0))
      {
        pCdcReqCtrl->Counter = sizeof(CDC_LineCoding_t);
        pCdcReqCtrl->pData   = (pInt8U)&CDC_LineCoding;
        return((void*)UsbUserSendPacket);
      }
      break;
    case SET_CONTROL_LINE_STATE:
      if ((CdcReqPacket.wLength.Word == 0) &&
          (CdcReqPacket.wIndex.Word == 0))
      {
        CDC_LineState.DTR_State = ((CdcReqPacket.wValue.Lo & 1) != 0);
        CDC_LineState.RTS_State = ((CdcReqPacket.wValue.Lo & 2) != 0);
#if CDC_DEVICE_SUPPORT_LINE_STATE > 0
        LineStateDelta = TRUE;
#endif // CDC_DEVICE_SUPPORT_LINE_STATE > 0
        return((void*)UsbUserSendAckn);
      }
      break;

#if CDC_DEVICE_SUPPORT_BREAK > 0
    case SEND_BREAK:
#if CDC_DEVICE_SUPPORT_LINE_STATE > 0
      BreakCntr = CdcReqPacket.wValue.Word;
      LineStateDelta = TRUE;
      if(BreakCntr != 0 && BreakCntr != 0xFFFF)
      {
        // Stop Timer 0
        TIMER_Stop(TIMER0);