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

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

DNA

开发平台：

Asm

LPC_USB.c：源码内容
  1. /*************************************************************************
  2.  *
  3.  *    Used with ICCARM and AARM.
  4.  *
  5.  *    (c) Copyright IAR Systems 2003
  6.  *
  7.  *    File name   : lpc_usb.c
  8.  *    Description : usb module (HAL)
  9.  *
  10.  *    History :
  11.  *    1. Data        : June 13, 2005
  12.  *       Author      : Stanimir Bonev
  13.  *       Description : Create
  14.  *    2. Data        : August 4, 2005
  15.  *       Author      : Stanimir Bonev
  16.  *       Description : Modify
  17.  *        Modify some functions
  18.  *    3. Data        : November 18, 2005
  19.  *       Author      : Stanimir Bonev
  20.  *       Description : Modify
  21.  *        Add DMA support
  22.  *    4. Data        : December 9, 2005
  23.  *       Author      : Stanimir Bonev
  24.  *       Description : Modify
  25.  *        Fix DMA restart problem for IN EPs
  26.  *    5. Data        : December 20, 2005
  27.  *       Author      : Stanimir Bonev
  28.  *       Description : Modify
  29.  *        Change user function prototype
  30.  *    $Revision: 1.2.4.1 $
  31. **************************************************************************/
  33. #define LPC_USB_GLOBAL
  34. #include "lpc_usb.h"
  36. UsbDevStat_t USB_DevStatus;
  37. UserFunc_t UsbUserFun [UsbLastEvent] =
  38. {
  39.   // Ep 0 Out
  40.   NULL,
  41.   // Ep 0 In
  42.   NULL,
  43.   // Ep 1 Out
  44.   NULL,
  45.   // Ep 1 In
  46.   NULL,
  47.   // Ep 2 Out
  48.   NULL,
  49.   // Ep 2 Int
  50.   NULL,
  51.   // Ep 3 Out
  52.   NULL,
  53.   // Ep 3 In
  54.   NULL,
  55.   // Ep 4 Out
  56.   NULL,
  57.   // Ep 4 In
  58.   NULL,
  59.   // Ep 5 Out
  60.   NULL,
  61.   // Ep 5 In
  62.   NULL,
  63.   // Ep 6 Out
  64.   NULL,
  65.   // Ep 6 In
  66.   NULL,
  67.   // Ep 7 Out
  68.   NULL,
  69.   // Ep 7 In
  70.   NULL,
  71.   // Ep 8 Out
  72.   NULL,
  73.   // Ep 8 In
  74.   NULL,
  75.   // Ep 9 Out
  76.   NULL,
  77.   // Ep 9 In
  78.   NULL,
  79.   // Ep 10 Out
  80.   NULL,
  81.   // Ep 10 In
  82.   NULL,
  83.   // Ep 11 Out
  84.   NULL,
  85.   // Ep 11 In
  86.   NULL,
  87.   // Ep 12 Out
  88.   NULL,
  89.   // Ep 12 In
  90.   NULL,
  91.   // Ep 13 Out
  92.   NULL,
  93.   // Ep 13 In
  94.   NULL,
  95.   // Ep 14 Out
  96.   NULL,
  97.   // Ep 14 In
  98.   NULL,
  99.   // Ep 15 Out
  100.   NULL,
  101.   // Ep 15 In
  102.   NULL,
  103.   // UsbResetEvent
  104.   NULL,
  105.   // UsbConnectEvent
  106.   NULL,
  107.   // UsbSuspendEvent
  108.   NULL,
  109.   // UsbErrorEvent
  110.   NULL,
  111.   // UsbSofEvent
  112.   NULL,
  113.   // UsbHighPrioIntrEvent
  114.   NULL,
  115. };
  117. /*************************************************************************
  118.  * Function Name: USB_Cmd
  119.  * Parameters:  Int16U Command, Int8U Data
  120.  *
  121.  * Return: Int32U - command result
  122.  *
  123.  * Description: Implement commands transmit to USB Engine
  124.  *
  125.  *************************************************************************/
  126. Int32U USB_Cmd (Int16U Command, Int8U Data)
  127. {
  128. Int32U cpu_sr, tmp = 0;
  129.   // Disable interrurp and save current state of the interrupt flags
  130.   cpu_sr = disable_IRQ();
  131.   DEVINTCLR = bmUSB_CommDataFullInterrupt | bmUSB_CommRegEmptyInterrupt;
  132.   // Load commonad in USB engine
  133.   CMDCODE = ((Command&0xFF) << 16) + USB_CMD_WR;
  134.   // Wait until command is accepted
  135.   while ((DEVINTS & bmUSB_CommRegEmptyInterrupt) == 0);
  136.   // clear Command reg. empry interrupt
  137.   DEVINTCLR = bmUSB_CommRegEmptyInterrupt;
  138.   // determinate next phase of the command
  139.   switch (Command)
  140.   {
  141.   case CMD_USB_SET_ADDRESS:
  142.   case CMD_USB_CFG_DEV:
  143.   case CMD_USB_SET_MODE:
  144.   case CMD_USB_SET_DEV_STAT:
  145.     CMDCODE = (Data << 16) + USB_DATA_WR;
  146.     while ((DEVINTS & bmUSB_CommRegEmptyInterrupt) == 0);
  147.     break;
  148.   case CMD_USB_RD_FRAME_NUMB:
  149.   case CMD_USB_RD_TEST_REG:
  150.     CMDCODE = (Command << 16) + USB_DATA_RD;
  151.     while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
  152.     DEVINTCLR = bmUSB_CommDataFullInterrupt;
  153.     tmp = CMDDATA;
  154.     CMDCODE = (Command << 16) + USB_DATA_RD;
  155.     while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
  156.     tmp |= CMDDATA << 8;
  157.     break;
  158.   case CMD_USB_GET_DEV_STAT:
  159.   case CMD_USB_GET_ERROR:
  160.   case CMD_USB_RD_ERROR_STAT:
  161.   case CMD_USB_CLR_BUF:
  162.     CMDCODE = (Command << 16) + USB_DATA_RD;
  163.     while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
  164.     tmp = CMDDATA;
  165.     break;
  166.   default:
  167.     switch (Command & 0x1E0)
  168.     {
  169.     case CMD_USB_SEL_EP:
  170.     case CMD_USB_SEL_CLR_INT_EP:
  171.       CMDCODE = (Command << 16) + USB_DATA_RD;
  172.       while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
  173.       tmp = CMDDATA;
  174.       break;
  175.     case CMD_USB_SET_EP_STAT:
  176.       CMDCODE = (Data << 16) + USB_DATA_WR;
  177.       while ((DEVINTS & bmUSB_CommRegEmptyInterrupt) == 0);
  178.       break;
  179.     }
  180.     break;
  181.   }
  182.   // restore the interrupt flags
  183.   restore_IRQ(cpu_sr);
  184.   return(tmp);
  185. }
  187. /*************************************************************************
  188.  * Function Name: USB_UserFuncRegistered
  189.  * Parameters: UserFunc_t UserFunc, UsbUserEvent_t UserFuncInd
  190.  *
  191.  * Return: UserFunc_t
  192.  *
  193.  * Description: Registered User callback function
  194.  *
  195.  *************************************************************************/
  196. UserFunc_t USB_UserFuncRegistered (UserFunc_t UserFunc, UsbUserEvent_t UserFuncInd)
  197. {
  198. UserFunc_t PrevUserFunc = UsbUserFun[UserFuncInd];
  199.   UsbUserFun[UserFuncInd] = (UserFunc_t) UserFunc;
  200.   return (PrevUserFunc);
  201. }
  203. /*************************************************************************
  204.  * Function Name: USB_EpIntrClr
  205.  * Parameters: USB_Endpoint_t EndPoint
  206.  *
  207.  * Return: Int8U
  208.  *
  209.  * Description: Clear the EP interrupt flag and return the current EP status
  210.  *
  211.  *************************************************************************/
  212. Int8U USB_EpIntrClr(USB_Endpoint_t EndPoint)
  213. {
  214.   ENDPINTCLR = 1 << EndPoint;
  215.   while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
  216.   return(CMDDATA);
  217. }
  219. /*************************************************************************
  220.  * Function Name: USB_HwInit
  221.  * Parameters: LPC_VicIrqSlots_t IntrSlot
  222.  *
  223.  * Return: none
  224.  *
  225.  * Description: Init USB
  226.  *
  227.  *************************************************************************/
  228. void USB_HwInit(LPC_VicIrqSlots_t IntrSlot)
  229. {
  230.   // Init softwate EP priority
  231.   USB_EpSoftPrio = 0;
  232.   // Init SOF number hold
  233.   #if  USB_SOF_EVENT > 0
  234.   USB_SofNumbHold = 0;
  235.   #endif
  236.   // Disable USB inerrupts
  237.   USBINTS_bit.EN_USB_INTS = 0;
  239.   /* Turn on USB */
  240.   PM_OpenPeripheral(0x80000000);
  242.   // Enable Vbus sense and Connect
  243.   PINSEL1_bit.P0_23 = 1;
  244.   PINSEL1_bit.P0_31 = 2;
  246.   // Init Pll for USB engine freq - 48MHz
  247.   //USB_PLL_M, USB_PLL_P are define in lpc_usb_cfg.h
  248.   PLL48CFG_bit.MSEL = USB_PLL_M-1;
  249.   PLL48CFG_bit.PSEL = USB_PLL_P;
  251.   PLL48CON_bit.PLLE = TRUE;     // Enable PLL
  252.   PLL48FEED = PLLFEED_DATA1;
  253.   PLL48FEED = PLLFEED_DATA2;
  255.   while (!PLL48STAT_bit.PLOCK); // Wait PLL lock
  257.   PLL48CON_bit.PLLC = TRUE;     // Connect PLL
  258.   PLL48FEED = PLLFEED_DATA1;
  259.   PLL48FEED = PLLFEED_DATA2;
  261.   // USB interrupt connect to VIC
  262.   VIC_SetVectoredIRQ(USB_ISR,(LPC_VicIrqSlots_t)IntrSlot,VIC_USB);
  263.   VIC_EnableInt(1<<VIC_USB);
  264.   // Enable USB inerrupts
  265.   USBINTS_bit.EN_USB_INTS = 1;
  266.   // Disconnect device
  267.   USB_Connect(FALSE);
  268.   // Set Arrdess 0
  269.   USB_SetDefAdd();
  270.   // Init controls endpoints
  271.   USB_HwReset();
  272.   // Init Device state var
  273.   USB_DevStatus.Data = USB_Cmd(CMD_USB_GET_DEV_STAT,0);
  274. }
  276. /*************************************************************************
  277.  * Function Name: USB_HwReset
  278.  * Parameters: none
  279.  *
  280.  * Return: none
  281.  *
  282.  * Description: Reset Usb engine
  283.  *
  284.  *************************************************************************/
  285. void USB_HwReset (void)
  286. {
  287.   // Disable all endpoint interrups
  288.   ENDPINTEN = 0;
  289.   // Frame is Hp interrupt
  290.   DEVINTPRI = 1;
  291.   // Clear all interupts flag
  292.   ENDPINTCLR  = DEVINTCLR = 0xFFFFFFFF;
  293.   // USB_Configure
  294.   USB_Configure(FALSE);
  295.   // EndPoint Init
  296.   USB_RealizeEndPoint(CTRL_ENP_OUT,0,Ep0MaxSize,TRUE);
  297.   USB_RealizeEndPoint(CTRL_ENP_IN, 1,Ep0MaxSize,TRUE);
  299. #if USB_DMA > 0
  300.   // Enable End_of_Transfer_Interrupt and
  301.   // System_Error_Interrupt USB DMA interrupts
  302. USB_DmaReset(DMA_INT_ENABLE_MASK);
  303. #endif
  304.   // Enable Device interrups
  305.   DEVINTEN = bmUSB_SlowInterrupt | bmUSB_DevStatusInterrupt |
  306.             (USB_HIGH_PRIORITY_EVENT ? bmUSB_FastInterrupt  : 0) |
  307.             (USB_SOF_EVENT           ? bmUSB_FrameInterrupt : 0) |
  308.             (USB_ERROR_EVENT         ? bmUSB_ErrorInterrupt : 0);
  310. }
  311. /*************************************************************************
  312.  * Function Name: USB_SetEpPrio
  313.  * Parameters: USB_Endpoint_t EndPoint,Boolean EpPrio
  314.  *
  315.  * Return: none
  316.  *
  317.  * Description: Set Endpoint priority
  318.  *
  319.  *************************************************************************/
  320. inline
  321. void USB_SetEpPrio (USB_Endpoint_t EndPoint,Boolean EpPrio)
  322. {
  323. Int32U Mask = 1 << EndPoint;
  324.   USB_EpSoftPrio = (EpPrio)?(USB_EpSoftPrio | Mask):(USB_EpSoftPrio & ~Mask);
  325. }
  327. /*************************************************************************
  328.  * Function Name: USB_RealizeEndPoint
  329.  * Parameters: USB_Endpoint_t EndPoint, Boolean EpPrio,
  330.  *                Int32U MaxPacketSize, Boolean IntrEna
  331.  *
  332.  * Return: none
  333.  *
  334.  * Description: Enable or disable endpoint
  335.  *
  336.  *************************************************************************/
  337. void USB_RealizeEndPoint( USB_Endpoint_t EndPoint, Boolean EpPrio,
  338.                              Int32U MaxPacketSize, Boolean IntrEna)
  339. {
  340. Int32U Mask = (1 << EndPoint);
  341.   // Init Ep software priority
  342.   USB_SetEpPrio(EndPoint,EpPrio);
  343.   if (MaxPacketSize)
  344.   {
  345.     // Clear  Realize interrupt bit
  346.     DEVINTCLR = bmUSB_EPRealizeInterrupt;
  347.     // Realize endpoit
  348.     REALIZEENDP  |= Mask;
  349.     // Set endpoit maximum packet size
  350.     ENDPIND       = EndPoint;
  351.     MAXPACKSIZE   = MaxPacketSize;
  352.     // Wait for Realize complete
  353.     while ((DEVINTS & bmUSB_EPRealizeInterrupt) == 0);
  354.     // Enable endpoint interrup
  355.     if (IntrEna)
  356.     {
  357.       ENDPINTEN |= Mask;
  358.     }
  359.     else
  360.     {
  361.       ENDPINTEN &= ~Mask;
  362.     }
  363.   }
  364.   else
  365.   {
  366.     Mask =~ Mask;
  367.     // Disable relevant endpoint and interrupt
  368.     REALIZEENDP &= Mask;
  369.     ENDPINTEN   &= Mask;
  370.   }
  371. }
  373. /*************************************************************************
  374.  * Function Name: USB_ClearBuffer
  375.  * Parameters: USB_Endpoint_t EndPoint - endpoiunt index
  376.  *
  377.  * Return: Int32U Packet overwrite statrus
  378.  *
  379.  * Description: Clear buffer of the corresponding endpoint
  380.  *
  381.  *************************************************************************/
  382. Int32U USB_ClearBuffer(USB_Endpoint_t EndPoint)
  383. {
  384.   // Select endpoint
  385.   USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
  386.   // Clear selected end point
  387.   return(USB_Cmd(CMD_USB_CLR_BUF,0));
  388. }
  390. /*************************************************************************
  391.  * Function Name: USB_ValidateBuffer
  392.  * Parameters: USB_Endpoint_t EndPoint - endpoiunt index
  393.  *
  394.  * Return: none
  395.  *
  396.  * Description: Validate buffer(only for IN Endpoints)
  397.  *
  398.  *************************************************************************/
  399. void USB_ValidateBuffer(USB_Endpoint_t EndPoint)
  400. {
  401.   if (EndPoint & 1)
  402.   {
  403.     USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
  404.     USB_Cmd(CMD_USB_VAL_BUF,0);
  405.   }
  406. }
  408. /*************************************************************************
  409.  * Function Name: USB_SetAdd
  410.  * Parameters: Int32U DevAdd - device address between 0 - 127
  411.  *
  412.  * Return: none
  413.  *
  414.  * Description: Set device address
  415.  *
  416.  *************************************************************************/
  417. void USB_SetAdd(Int32U DevAdd)
  418. {
  419.   USB_Cmd(CMD_USB_SET_ADDRESS,DevAdd | 0x80);
  420.   USB_Cmd(CMD_USB_SET_ADDRESS,DevAdd | 0x80);
  421. }
  423. /*************************************************************************
  424.  * Function Name: USB_Connect
  425.  * Parameters: Boolean Conn
  426.  *
  427.  * Return: none
  428.  *
  429.  * Description: Connect Usb
  430.  *
  431.  *************************************************************************/
  432. void USB_Connect (Boolean Conn)
  433. {
  434.   USB_Cmd(CMD_USB_SET_DEV_STAT, (Conn ? bmUSB_Connect : 0));
  435. }
  437. /*************************************************************************
  438.  * Function Name: USB_Configure
  439.  * Parameters: Boolean Configure
  440.  *
  441.  * Return: none
  442.  *
  443.  * Description: Configure device
  444.  *  When Configure != 0 enable all Realize Ep
  445.  *
  446.  *************************************************************************/
  447. void USB_Configure (Boolean Configure)
  448. {
  449.   USB_Cmd(CMD_USB_CFG_DEV,Configure);
  450. }
  452. /*************************************************************************
  453.  * Function Name: USB_WakeUp
  454.  * Parameters: none
  455.  *
  456.  * Return: none
  457.  *
  458.  * Description: Wake up Usb
  459.  *
  460.  *************************************************************************/
  461. void USB_WakeUp (void)
  462. {
  463.   USB_Cmd(CMD_USB_SET_DEV_STAT, bmUSB_Suspend | (USB_DevStatus.Connect?bmUSB_Connect:0));
  464. }
  466. /*************************************************************************
  467.  * Function Name: USB_GetDevStatus
  468.  * Parameters: USB_DevStatusReqType_t Type
  469.  *
  470.  * Return: Boolean
  471.  *
  472.  * Description: Return USB device status
  473.  *
  474.  *************************************************************************/
  475. Boolean USB_GetDevStatus (USB_DevStatusReqType_t Type)
  476. {
  477.   switch (Type)
  478.   {
  479.   case USB_DevConnectStatus:
  480.     return(USB_DevStatus.Connect);
  481.   case USB_SuspendStatus:
  482.     return(USB_DevStatus.Suspend);
  483.   case USB_ResetStatus:
  484.     return(USB_DevStatus.Reset);
  485.   }
  486.   return(FALSE);
  487. }
  489. /*************************************************************************
  490.  * Function Name: USB_SetStallEP
  491.  * Parameters: USB_Endpoint_t EndPoint, Boolean Stall
  492.  *
  493.  * Return: none
  494.  *
  495.  * Description: The endpoint stall/unstall
  496.  *
  497.  *************************************************************************/
  498. void USB_SetStallEP (USB_Endpoint_t EndPoint, Boolean Stall)
  499. {
  500.   USB_Cmd(CMD_USB_SET_EP_STAT | EndPoint, (Stall ? bmUSB_EpStall : 0));
  501. }
  503. /*************************************************************************
  504.  * Function Name: USB_GetStallEP
  505.  * Parameters: USB_Endpoint_t EndPoint
  506.  *
  507.  * Return: Boolean
  508.  *
  509.  * Description: Get stall state of the endpoint
  510.  *
  511.  *************************************************************************/
  512. Boolean USB_GetStallEP (USB_Endpoint_t EndPoint)
  513. {
  514.   return ((USB_Cmd(CMD_USB_SEL_EP | EndPoint, 0) & bmUSB_EpStallStatus) != 0);
  515. }
  517. /*************************************************************************
  518.  * Function Name: USB_EpWrite
  519.  * Parameters: USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count
  520.  *
  521.  * Return: none
  522.  *
  523.  * Description: Endpoint Write (IN)
  524.  *
  525.  *************************************************************************/
  526. void USB_EpWrite (USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count)
  527. {
  528.   // Convert EP physical address to logical and set write enable bit
  529.   USBCTRL = ((EndPoint << 1) & 0x3C) | bmUSB_CtrlWrEna;
  531.   // Get data size
  532.   TPKTLEN = Count;
  533.   // Write data to SIE buffer
  534.   if(Count)
  535.   {
  536.     do
  537.     {
  538.       TDATA = *pData++;
  539.     }
  540.     while (USBCTRL_bit.WR_EN);
  541.   }
  542.   else
  543.   {
  544.     do
  545.     {
  546.       TDATA = 0;
  547.     }
  548.     while (USBCTRL_bit.WR_EN);
  549.   }
  551.   USBCTRL = 0;
  553.   USB_Cmd(CMD_USB_SEL_EP | EndPoint, 0);
  554.   USB_Cmd(CMD_USB_VAL_BUF, 0);
  556. }
  558. /*************************************************************************
  559.  * Function Name: USB_EpRead
  560.  * Parameters: USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count
  561.  *
  562.  * Return: Int32
  563.  *
  564.  * Description: Endpoint Read (OUT)
  565.  *
  566.  *************************************************************************/
  567. Int32U USB_EpRead (USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count)
  568. {
  569.   // Convert EP physical address to logical and set read enable bit
  570.   USBCTRL = ((EndPoint << 1) & 0x3C) | bmUSB_CtrlRdEna;
  571.   while (RCVEPKTLEN_bit.PKT_RDY == 0);
  572.   // Get data size
  573.   Count = RCVEPKTLEN_bit.PKT_LNGTH;
  574.   // Read data from SIE buffer
  575.   while (RCVEPKTLEN_bit.DV)
  576.   {
  577.     *pData++ = RCVEDATA;
  578.   }
  580.   USBCTRL = 0;
  582.   USB_Cmd(CMD_USB_SEL_EP | EndPoint, 0);
  583.   if(USB_Cmd(CMD_USB_CLR_BUF, 0) & bmUSB_PacketOverWritten)
  584.   {
  585.     Count |= 0x80000000;
  586.   }
  587.   return (Count);
  588. }
  590. /*************************************************************************
  591.  * Function Name: USB_ISR
  592.  * Parameters: none
  593.  *
  594.  * Return: none
  595.  *
  596.  * Description: USB interrupt subroutine
  597.  *
  598.  *************************************************************************/
  599. void USB_ISR (void)
  600. {
  601. Int32U EpIntr,Val,EpIntHold;
  602. UsbDevIntrStat_t UsbDevIntrSt = {DEVINTS};
  604. #if USB_DMA > 0
  605. if (USBINTS & 3)
  606. {
  607. #endif
  608. #if USB_HIGH_PRIORITY_EVENT > 0
  609.   // Fast EP interrupt
  610.   if(UsbDevIntrSt.Fast)
  611.   {
  612.     DEVINTCLR = bmUSB_FastInterrupt;
  613.     if(UsbUserFun[UsbHighPrioIntrEvent] != NULL)
  614.     {
  615.       UsbUserFun[UsbHighPrioIntrEvent]((void *)0);
  616.     }
  617.     // Clear Fast EP interrupt
  618.   }
  619. #endif
  621. #if USB_ERROR_EVENT > 0
  622.   // USB engine error interrupt
  623.   if(UsbDevIntrSt.Error)
  624.   {
  625.     DEVINTCLR = bmUSB_ErrorInterrupt;
  626.     Val = USB_Cmd(CMD_USB_RD_ERROR_STAT,0);
  627.     if(UsbUserFun[UsbErrorEvent] != NULL)
  628.     {
  629.       UsbUserFun[UsbErrorEvent]((void *)Val);
  630.     }
  631.   }
  632. #endif
  634. #if USB_SOF_EVENT > 0
  635.   // Frame interrupt
  636.   if(UsbDevIntrSt.Frame)
  637.   {
  638.     DEVINTCLR = bmUSB_FrameInterrupt;
  639. //     Val = USB_Cmd(CMD_USB_RD_FRAME_NUMB,0);
  640.     if(UsbUserFun[UsbSofEvent] != NULL)
  641.     {
  642.       UsbUserFun[UsbSofEvent]((void *)Val);
  643.     }
  644.   }
  645. #endif
  647.   // Device Status interrupt
  648.   if(UsbDevIntrSt.Status)
  649.   {
  650.     // Clear Device status interrupt
  651.     DEVINTCLR = bmUSB_DevStatusInterrupt;
  652.     // Get device status
  653.     USB_DevStatus.Data = USB_Cmd(CMD_USB_GET_DEV_STAT,0);
  654.     // Device connection status
  655.     if(USB_DevStatus.ConnectChange)
  656.     {
  657.       if(UsbUserFun[UsbConnectEvent] != NULL)
  658.       {
  659.         UsbUserFun[UsbConnectEvent]((void *)USB_DevStatus.Connect);
  660.       }
  661.     }
  662.     // Device suspend status
  663.     if(USB_DevStatus.SuspendChange)
  664.     {
  665.       if(UsbUserFun[UsbSuspendEvent] != NULL)
  666.       {
  667.         UsbUserFun[UsbSuspendEvent]((void *)USB_DevStatus.Suspend);
  668.       }
  669.     }
  670.     // Device reset
  671.     if(USB_DevStatus.Reset)
  672.     {
  673.       USB_HwReset();
  674.       if(UsbUserFun[UsbResetEvent] != NULL)
  675.       {
  676.         UsbUserFun[UsbResetEvent](NULL);
  677.       }
  678.     }
  679.   }
  681.   // Slow EP interrupt
  682.   if(UsbDevIntrSt.Slow)
  683.   {
  684.       // Clear Slow EP interrupt
  685.       DEVINTCLR = bmUSB_SlowInterrupt;
  686.     do
  687.     {
  688.       EpIntr = ENDPINTS;
  689.       // First Software High proirity and then low proirity
  690.         Int32U USB_EpSoftPrioHold = USB_EpSoftPrio;
  691.       for (Int32U i = 2; i; --i, USB_EpSoftPrioHold ^= 0xFFFFFFFF)
  692.       {
  693.       Int32U EpIntrCurrPrio = EpIntr & USB_EpSoftPrioHold;
  694.         // Output ctrl EP
  695.         if(EpIntrCurrPrio & 1)
  696.         {
  697.           Val = USB_EpIntrClr(CTRL_ENP_OUT);
  698.           if(UsbUserFun[UsbEp0Out] != NULL)
  699.           {
  700.             if(Val & bmUSB_EpSetupPacket)
  701.             {
  702.               UsbUserFun[UsbEp0Out]((void *)UsbSetupPacket);
  703.             }
  704.             else
  705.             {
  706.               UsbUserFun[UsbEp0Out]((void *)UsbDataOutPacket);
  707.             }
  708.           }
  709.           break;
  710.         }
  711.         // All other endpoints
  712.         for(Val = 1,EpIntHold = EpIntrCurrPrio >> 1; EpIntHold; ++Val,EpIntHold >>= 1)
  713.         {
  714.           if(EpIntHold & 1)
  715.           {
  716.             USB_EpIntrClr((USB_Endpoint_t)Val);
  717.             if(UsbUserFun[Val] != NULL)
  718.             {
  719.               UsbUserFun[Val]((void *)((Val&1)?UsbDataInPacket:UsbDataOutPacket));
  720.             }
  721.             break;
  722.           }
  723.         }
  724.       }
  725.     }
  726.     while(EpIntr);
  727.   }
  728. #if USB_DMA > 0
  729. }
  730. if (USBINTS_bit.USB_INT_REQ_DMA)
  731. {
  732.     // First Software High proirity and then low proirity
  733.     Int32U UsbDmaInt = 0,Tmp;
  734.     Tmp = EOTINTSTAT;
  735.     if(DMAINTEN & 1)
  736.     {
  737.       UsbDmaInt |= Tmp;
  738.     }
  739.     EOTINTCLR = Tmp;
  740.     Tmp = NEWDDRINTSTAT;
  741.     if(DMAINTEN & 2)
  742.     {
  743.       UsbDmaInt |= Tmp;
  744.     }
  745.     NEWDDRINTCLR = Tmp;
  746.     Tmp = SYSERRINTSTAT;
  747.     if(DMAINTEN & 4)
  748.     {
  749.       UsbDmaInt |= Tmp;
  750.     }
  751.     SYSERRINTCLR = Tmp;
  752.     for (Int32U i = 2; i; --i, USB_EpSoftPrio ^= 0xFFFFFFFF)
  753.     {
  754.       // All endpoints without ctrl EP_In, ctrl EP_Out
  755.       Int32U UsbDmaCurrPriorityInt = USB_EpSoftPrio & UsbDmaInt;
  756.       for(Int32U Val = 2, EpMask = 4; UsbDmaCurrPriorityInt; ++Val,EpMask <<= 1)
  757.       {
  758.         Int32U EpPriorityMask = UsbDmaCurrPriorityInt & EpMask;
  759.         if(EpPriorityMask == 0)
  760.         {
  761.           continue;
  762.         }
  763.         UsbDmaCurrPriorityInt &= ~EpMask;
  764.         // Collect Interrupts status flags and clear interrupt flags
  765.         if(EpPriorityMask && (UsbUserFun[Val] != NULL))
  766.         {
  767.           UsbUserFun[Val]((void *)UsbDmaPacket);
  768.         }
  769.       }
  770.     }
  771. }
  772. #endif
  773.   VICVectAddr = 0;    // Clear interrupt in VIC.
  774. }
  776. /*************************************************************************
  777.  * Function Name: USB_EpLogToPhysAdd
  778.  * Parameters: Int8U EpLogAdd
  779.  *
  780.  * Return: USB_Endpoint_t
  781.  *
  782.  * Description: Convert the logical to physical address
  783.  *
  784.  *************************************************************************/
  785. USB_Endpoint_t USB_EpLogToPhysAdd (Int8U EpLogAdd)
  786. {
  787. USB_Endpoint_t Address = (USB_Endpoint_t)((EpLogAdd & 0x0F)<<1);
  788.   if(EpLogAdd & 0x80)
  789.   {
  790.     ++Address;
  791.   }
  792.   return(Address);
  793. }
  795. /*************************************************************************
  796.  * Function Name: USB_GetFrameNumb
  797.  * Parameters: none
  798.  *
  799.  * Return: Int32U
  800.  *
  801.  * Description: Retunr curent value of SOF number
  802.  *
  803.  *************************************************************************/
  804. #if USB_SOF_EVENT > 0
  805. Int32U USB_GetFrameNumb (void)
  806. {
  807.   return(USB_SofNumbHold);
  808. }
  809. #endif
  811. /*************************************************************************
  812.  *                          U S B   D M A  P a r t                       *
  813.  *************************************************************************/
  815. #if USB_DMA > 0
  816. #pragma segment="DMA_RAM"
  817. #pragma location="DMA_RAM"
  818. #pragma data_alignment=128
  819. __no_init pUSB_DmaDesc_t USB_DDCA[ENP_MAX_NUMB];
  821. #pragma location="DMA_RAM"
  822. __no_init USB_DmaDesc_t USB_DmaDesc[DMA_DD_MAX_NUMB];
  824. /*************************************************************************
  825.  * Function Name: USB_DmaReset
  826.  * Parameters:  Int32U IntrEna
  827.  *
  828.  * Return: none
  829.  *
  830.  * Description: Reset USB DMA
  831.  *
  832.  *************************************************************************/
  833. void USB_DmaReset (Int32U IntrEna)
  834. {
  835.   // Disable All DMA interrupts
  836.   DMAINTEN = 0;
  837.   // DMA Disable
  838.   EPDMADIS      = 0xFFFFFFFF;
  839.   // DMA Request clear
  840.   DMARQSTCLR    = 0xFFFFFFFF;
  841.   // End of Transfer Interrupt Clear
  842.   EOTINTCLR     = 0xFFFFFFFF;
  843.   // New DD Request Interrupt Clear
  844.   NEWDDRINTCLR  = 0xFFFFFFFF;
  845.   // System Error Interrupt Clear
  846.   SYSERRINTCLR  = 0xFFFFFFFF;
  847. for(Int32U i = 0; i < ENP_MAX_NUMB; ++i)
  848.   {
  849.     USB_DDCA[i] = NULL;
  850.   }
  851.   // Set USB UDCA Head register
  852.   UDCAHEAD = (Int32U)&USB_DDCA;
  853.   // Enable DMA interrupts
  854.   DMAINTEN = IntrEna;
  855. }
  857. /*************************************************************************
  858.  * Function Name: USB_DmaInitTransfer
  859.  * Parameters: USB_Endpoint_t EndPoint, Int32U DmaDescInd,
  860.  *             pInt32U pData, Int32U EpMaxSize, Int32U Size
  861.  *             pDmaIsoPacket_t pDmaIsoPacket,  Boolean EpTransferType
  862.  *
  863.  * Return: UsbDmaStateCode_t
  864.  *
  865.  * Description: Init Transfer by DMA
  866.  *
  867.  *************************************************************************/
  868. UsbDmaStateCode_t USB_DmaInitTransfer (USB_Endpoint_t EndPoint,
  869.           Int32U DmaDescInd, pInt32U pData, Int32U EpMaxSize, Int32U Size,
  870.           pDmaIsoPacket_t pDmaIsoPacket, Boolean EpTransferType)
  871. {
  872. Int32U EpReg;
  874.   if ((EndPoint == CTRL_ENP_OUT) || (EndPoint == CTRL_ENP_IN))
  875.   {
  876.     return(UsbDmaParametersError);
  877.   }
  878.   if (USB_DmaDesc[DmaDescInd].Status == UsbDmaBeingServiced)
  879.   {
  880.     return(UsbDmaBeingServiced);
  881.   }
  883.   // Init DMA Descriptor
  884.   USB_DmaDesc[DmaDescInd].pNextDD        = NULL;
  885.   USB_DmaDesc[DmaDescInd].NextDDValid    = FALSE;
  886.   USB_DmaDesc[DmaDescInd].pDmaIsoPacket  = pDmaIsoPacket;
  887.   USB_DmaDesc[DmaDescInd].DmaMode        = UsbDmaNormalMode;
  888.   USB_DmaDesc[DmaDescInd].Isochronous    = EpTransferType;
  889.   USB_DmaDesc[DmaDescInd].pDmaBuffer     = pData;
  890.   USB_DmaDesc[DmaDescInd].DmaBufferLegtn = Size;
  891.   USB_DmaDesc[DmaDescInd].MaxPacketSize  = EpMaxSize;
  892.   USB_DmaDesc[DmaDescInd].Status         = UsbDmaNoServiced;
  894.   // Set DD
  895.   USB_DDCA[EndPoint] = &USB_DmaDesc[DmaDescInd];
  897.   // Enable DMA Transfer
  898.   EPDMAEN = 1 << EndPoint;
  900.   // Check state of IN/OUT Ep buffer
  901.   EpReg = USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
  903.   if( ((EndPoint & 1) && !(EpReg & 0x60)) ||
  904.      (!(EndPoint & 1) && ((EpReg & 0x60) == 0x60)))
  905.   {
  906.     if((USB_DmaDesc[DmaDescInd].DdState != UsbDmaBeingServiced))
  907.     {
  908.       // Retrigger DMA Transfer
  909.       DMARQSTSET = 1 << EndPoint;
  910.     }
  911.   }
  913.   return(UsbDmaNoServiced);
  914. }
  916. /*************************************************************************
  917.  * Function Name: USB_DmaGetDesc
  918.  * Parameters: Int32U DmaDescInd
  919.  *
  920.  * Return: pUSB_DmaDesc_t
  921.  *
  922.  * Description: Retur pointer to DMA descriptor
  923.  *
  924.  *************************************************************************/
  925. pUSB_DmaDesc_t USB_DmaGetDesc (Int32U DmaDescInd)
  926. {
  927.   return(&USB_DmaDesc[DmaDescInd]);
  928. }
  930. /*************************************************************************
  931.  * Function Name: USB_DmaDisable
  932.  * Parameters: USB_Endpoint_t EndPoint
  933.  *
  934.  * Return: none
  935.  *
  936.  * Description: Disable DMA transfer for the EP
  937.  *
  938.  *************************************************************************/
  939. void USB_DmaDisable (USB_Endpoint_t EndPoint)
  940. {
  941.   EPDMADIS = 1 << EndPoint;
  942. }
  944. /*************************************************************************
  945.  * Function Name: USB_DmaRestattTransfer
  946.  * Parameters: USB_Endpoint_t EndPoint, Int32U DmaDescInd,
  947.  *             pInt32U pData, Int32U EpMaxSize, Int32U Size
  948.  *             pDmaIsoPacket_t pDmaIsoPacket,  Boolean EpTransferType
  949.  *
  950.  * Return: none
  951.  *
  952.  * Description: Restart DMA Transfer
  953.  *
  954.  *************************************************************************/
  955. void USB_DmaRestattTransfer (USB_Endpoint_t EndPoint,Int32U DmaDescInd)
  956. {
  957.   // Init DD DMA status
  958.   USB_DmaDesc[DmaDescInd].Status = UsbDmaNoServiced;
  959.   // Enable DMA Transfer
  960.   EPDMAEN = 1 << EndPoint;
  961.   // Check state of IN/OUT Ep buffer
  962.   Int32U EpReg = USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
  963.   if(!(EndPoint & 1) && ((EpReg & 0x60) == 0x60))
  964.   {
  965.     // Retrigger DMA Transfer
  966.     DMARQSTSET = 1 << EndPoint;
  967.   }
  968.   else if ((EndPoint & 1) && !(EpReg & 0x60))
  969.   {
  970.     // Retrigger DMA Transfer
  971.     DMARQSTSET = 1 << EndPoint;   //