API tools faq
paste
Guest User

usbd_MKL25Z4.c

a guest
Nov 15th, 2012
124
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.68 KB | None | 0 0
raw download clone embed print report
  1. /*----------------------------------------------------------------------------
  2.  *      RL-ARM - USB
  3.  *----------------------------------------------------------------------------
  4.  *      Name:    usbd_MKL25Z4.c
  5.  *      Purpose: Hardware Layer module for Freescale MKL25Z4
  6.  *      Rev.:    V4.60
  7.  *----------------------------------------------------------------------------
  8.  *      This code is part of the RealView Run-Time Library.
  9.  *      Copyright (c) 2004-2012 KEIL - An ARM Company. All rights reserved.
  10.  *---------------------------------------------------------------------------*/
  11.  
  12. #include <RTL.h>
  13. #include <rl_usb.h>
  14. #include <MKL25Z4.H>
  15.  
  16. #define __NO_USB_LIB_C
  17. #include "usb_config.c"
  18.  
  19. typedef struct __BUF_DESC {
  20.   uint8_t    stat;
  21.   uint8_t    reserved;
  22.   uint16_t   bc;
  23.   uint32_t   buf_addr;
  24. }BUF_DESC;
  25.  
  26. BUF_DESC __align(512) BD[(USBD_EP_NUM + 1) * 2 * 2];
  27. uint8_t EPBuf[(USBD_EP_NUM + 1)* 2 * 2][64];
  28. uint8_t OutEpSize[USBD_EP_NUM + 1];
  29.  
  30. uint32_t Data1  = 0x55555555;
  31.  
  32. #define BD_OWN_MASK        0x80
  33. #define BD_DATA01_MASK     0x40
  34. #define BD_KEEP_MASK       0x20
  35. #define BD_NINC_MASK       0x10
  36. #define BD_DTS_MASK        0x08
  37. #define BD_STALL_MASK      0x04
  38.  
  39. #define TX    1
  40. #define RX    0
  41. #define ODD   0
  42. #define EVEN  1
  43. #define IDX(Ep, dir, Ev_Odd) ((((Ep & 0x0F) * 4) + (2 * dir) + (1 *  Ev_Odd)))
  44.  
  45. #define SETUP_TOKEN    0x0D
  46. #define IN_TOKEN       0x09
  47. #define OUT_TOKEN      0x01
  48. #define TOK_PID(idx)   ((BD[idx].stat >> 2) & 0x0F)
  49.  
  50. /*
  51.  *  USB Device Interrupt enable
  52.  *   Called by USBD_Init to enable the USB Interrupt
  53.  *    Return Value:    None
  54.  */
  55.  
  56. #ifdef __RTX
  57. void __svc(1) USBD_IntrEna (void);
  58. void __SVC_1               (void) {
  59. #else
  60. void          USBD_IntrEna (void) {
  61. #endif
  62.   NVIC_EnableIRQ   (USB0_IRQn);         /* Enable OTG interrupt               */
  63. }
  64.  
  65.  
  66. /*
  67.  *  USB Device Initialize Function
  68.  *   Called by the User to initialize USB
  69.  *   Return Value:    None
  70.  */
  71.  
  72. void USBD_Init (void) {
  73.   OutEpSize[0] = USBD_MAX_PACKET0;
  74.  
  75.   /* Enable all clocks needed for USB to function                             */
  76.   /* Set USB clock to 48 MHz                                                  */
  77.   SIM->SOPT2   |=   SIM_SOPT2_USBSRC_MASK     | /* MCGPLLCLK used as src      */
  78.                     SIM_SOPT2_PLLFLLSEL_MASK  ; /* Select MCGPLLCLK as clock  */
  79.   SIM->SCGC4   |=   SIM_SCGC4_USBOTG_MASK;      /* Enable USBOTG clock        */
  80.  
  81.   USBD_IntrEna ();
  82.  
  83.   USB0->USBTRC0 |= USB_USBTRC0_USBRESET_MASK;
  84.   while (USB0->USBTRC0 & USB_USBTRC0_USBRESET_MASK);
  85.  
  86.   USB0->BDTPAGE1 = (uint8_t) ((uint32_t) BD >> 8 );
  87.   USB0->BDTPAGE2 = (uint8_t) ((uint32_t) BD >> 16);
  88.   USB0->BDTPAGE3 = (uint8_t) ((uint32_t) BD >> 24);
  89.  
  90.   USB0->ISTAT   = 0xFF;                 /* clear interrupt flags              */
  91.  
  92.   /* enable interrupts                                                        */
  93.   USB0->INTEN =                            USB_INTEN_USBRSTEN_MASK |
  94.                                            USB_INTEN_TOKDNEEN_MASK |
  95.                                            USB_INTEN_SLEEPEN_MASK  |
  96. #ifdef __RTX
  97.               ((USBD_RTX_DevTask   != 0) ? USB_INTEN_SOFTOKEN_MASK : 0) |
  98.               ((USBD_RTX_DevTask   != 0) ? USB_INTEN_ERROREN_MASK  : 0) ;
  99. #else
  100.               ((USBD_P_SOF_Event   != 0) ? USB_INTEN_SOFTOKEN_MASK : 0) |
  101.               ((USBD_P_Error_Event != 0) ? USB_INTEN_ERROREN_MASK  : 0) ;
  102. #endif
  103.  
  104.   USB0->USBCTRL  = USB_USBCTRL_PDE_MASK;/* pull dawn on D+ and D-             */
  105.   USB0->USBTRC0 |= (1 << 6);            /* bit 6 must be set to 1             */
  106. }
  107.  
  108.  
  109. /*
  110.  *  USB Device Connect Function
  111.  *   Called by the User to Connect/Disconnect USB Device
  112.  *    Parameters:      con:   Connect/Disconnect
  113.  *    Return Value:    None
  114.  */
  115.  
  116. void USBD_Connect (uint32_t con) {
  117.  
  118.   if ( con) {
  119.     USB0->CTL  |= USB_CTL_USBENSOFEN_MASK;            /* enable USB           */
  120.     USB0->CONTROL = USB_CONTROL_DPPULLUPNONOTG_MASK;  /* pull up on D+        */
  121.   }
  122.   else {
  123.     USB0->CTL  &= ~USB_CTL_USBENSOFEN_MASK;           /* disable USB          */
  124.     USB0->CONTROL &= ~USB_CONTROL_DPPULLUPNONOTG_MASK;/* pull down on D+      */
  125.   }
  126. }
  127.  
  128.  
  129. /*
  130.  *  USB Device Reset Function
  131.  *   Called automatically on USB Device Reset
  132.  *    Return Value:    None
  133.  */
  134.  
  135. void USBD_Reset (void) {
  136.   uint32_t i;
  137.  
  138.   for (i = 1; i < 16; i++) {
  139.     USB0->ENDPOINT[i].ENDPT = 0x00;
  140.   }
  141.  
  142.   /* EP0 control endpoint                                                     */
  143.   BD[IDX(0, RX, ODD )].bc       = USBD_MAX_PACKET0;
  144.   BD[IDX(0, RX, ODD )].buf_addr = (uint32_t) &(EPBuf[IDX(0, RX, ODD )][0]);
  145.   BD[IDX(0, RX, ODD )].stat     = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK;
  146.  
  147.   BD[IDX(0, RX, EVEN)].bc       = USBD_MAX_PACKET0;
  148.   BD[IDX(0, RX, EVEN)].buf_addr = (uint32_t) &(EPBuf[IDX(0, RX, EVEN)][0]);
  149.   BD[IDX(0, RX, EVEN)].stat     = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK;
  150.  
  151.   BD[IDX(0, TX, ODD )].buf_addr = (uint32_t) &(EPBuf[IDX(0, TX, ODD )][0]);
  152.   BD[IDX(0, TX, EVEN)].buf_addr = (uint32_t) &(EPBuf[IDX(0, TX, EVEN)][0]);
  153.  
  154.   USB0->ENDPOINT[0].ENDPT = USB_ENDPT_EPHSHK_MASK | /* enable ep handshaking  */
  155.                             USB_ENDPT_EPTXEN_MASK | /* enable TX (IN) tran.   */
  156.                             USB_ENDPT_EPRXEN_MASK;  /* enable RX (OUT) tran.  */
  157.  
  158.   Data1 = 0x55555555;
  159.   USB0->CTL    |=  USB_CTL_ODDRST_MASK;
  160.  
  161.   USB0->ISTAT   =  0xFF;                /* clear all interrupt status flags   */
  162.   USB0->ERRSTAT =  0xFF;                /* clear all error flags              */
  163.   USB0->ERREN   =  0xFF;                /* enable error interrupt sources     */
  164.   USB0->ADDR    =  0x00;                /* set default address                */
  165.  
  166. }
  167.  
  168.  
  169. /*
  170.  *  USB Device Suspend Function
  171.  *   Called automatically on USB Device Suspend
  172.  *    Return Value:    None
  173.  */
  174.  
  175. void USBD_Suspend (void) {
  176.   USB0->INTEN |= USB_INTEN_RESUMEEN_MASK;
  177. }
  178.  
  179.  
  180. /*
  181.  *  USB Device Resume Function
  182.  *   Called automatically on USB Device Resume
  183.  *    Return Value:    None
  184.  */
  185.  
  186. void USBD_Resume (void) {
  187.   USB0->INTEN &= ~USB_INTEN_RESUMEEN_MASK;
  188.  
  189. }
  190.  
  191.  
  192. /*
  193.  *  USB Device Remote Wakeup Function
  194.  *   Called automatically on USB Device Remote Wakeup
  195.  *    Return Value:    None
  196.  */
  197.  
  198. void USBD_WakeUp (void) {
  199.   uint32_t i = 50000;
  200.   if (USBD_DeviceStatus & USB_GETSTATUS_REMOTE_WAKEUP) {
  201.     USB0->CTL |=  USB_CTL_RESUME_MASK;
  202.     while (i--)   __nop();
  203.     USB0->CTL &= ~USB_CTL_RESUME_MASK;
  204.   }
  205. }
  206.  
  207.  
  208. /*
  209.  *  USB Device Remote Wakeup Configuration Function
  210.  *    Parameters:      cfg:   Device Enable/Disable
  211.  *    Return Value:    None
  212.  */
  213.  
  214. void USBD_WakeUpCfg (uint32_t cfg) {
  215.   /* Not needed                                                               */
  216. }
  217.  
  218.  
  219. /*
  220.  *  USB Device Set Address Function
  221.  *    Parameters:      adr:   USB Device Address
  222.  *    Return Value:    None
  223.  */
  224.  
  225. void USBD_SetAddress (uint32_t  adr, uint32_t setup) {
  226.   if (!setup) {
  227.     USB0->ADDR    = adr & 0x7F;
  228.   }
  229. }
  230.  
  231.  
  232. /*
  233.  *  USB Device Configure Function
  234.  *    Parameters:      cfg:   Device Configure/Deconfigure
  235.  *    Return Value:    None
  236.  */
  237.  
  238. void USBD_Configure (uint32_t cfg) {
  239. }
  240.  
  241.  
  242. /*
  243.  *  Configure USB Device Endpoint according to Descriptor
  244.  *    Parameters:      pEPD:  Pointer to Device Endpoint Descriptor
  245.  *    Return Value:    None
  246.  */
  247.  
  248. void USBD_ConfigEP (USB_ENDPOINT_DESCRIPTOR *pEPD) {
  249.   uint32_t num, val;
  250.  
  251.   num  = pEPD->bEndpointAddress;
  252.   val  = pEPD->wMaxPacketSize;
  253.  
  254.   if (!(pEPD->bEndpointAddress & 0x80)) {
  255.     OutEpSize[num] = val;
  256.   }
  257.   USBD_ResetEP (num);
  258. }
  259.  
  260.  
  261. /*
  262.  *  Set Direction for USB Device Control Endpoint
  263.  *    Parameters:      dir:   Out (dir == 0), In (dir <> 0)
  264.  *    Return Value:    None
  265.  */
  266.  
  267. void USBD_DirCtrlEP (uint32_t dir) {
  268.   /* Not needed                                                               */
  269. }
  270.  
  271.  
  272. /*
  273.  *  Enable USB Device Endpoint
  274.  *    Parameters:      EPNum: Device Endpoint Number
  275.  *                       EPNum.0..3: Address
  276.  *                       EPNum.7:    Dir
  277.  *    Return Value:    None
  278.  */
  279.  
  280. void USBD_EnableEP (uint32_t EPNum) {
  281.  
  282.   if (EPNum & 0x80) {
  283.     EPNum &= 0x0F;
  284.     USB0->ENDPOINT[EPNum].ENDPT |= USB_ENDPT_EPHSHK_MASK | /*en ep handshaking*/
  285.                                    USB_ENDPT_EPTXEN_MASK;  /*en TX (IN) tran  */
  286.   }
  287.   else {
  288.     USB0->ENDPOINT[EPNum].ENDPT |= USB_ENDPT_EPHSHK_MASK | /*en ep handshaking*/
  289.                                    USB_ENDPT_EPRXEN_MASK;  /*en RX (OUT) tran.*/
  290.   }
  291. }
  292.  
  293.  
  294. /*
  295.  *  Disable USB Endpoint
  296.  *    Parameters:      EPNum: Endpoint Number
  297.  *                       EPNum.0..3: Address
  298.  *                       EPNum.7:    Dir
  299.  *    Return Value:    None
  300.  */
  301.  
  302. void USBD_DisableEP (uint32_t EPNum) {
  303.   if (EPNum & 0x80) {
  304.     EPNum &= 0x0F;
  305.     USB0->ENDPOINT[EPNum].ENDPT &= ~(USB_ENDPT_EPHSHK_MASK |/*dis handshaking */
  306.                                      USB_ENDPT_EPTXEN_MASK);/*dis TX(IN) tran */
  307.   }
  308.   else {
  309.     USB0->ENDPOINT[EPNum].ENDPT &= ~(USB_ENDPT_EPHSHK_MASK |/*dis handshaking */
  310.                                      USB_ENDPT_EPRXEN_MASK);/*dis RX(OUT) tran*/
  311.   }
  312. }
  313.  
  314.  
  315. /*
  316.  *  Reset USB Device Endpoint
  317.  *    Parameters:      EPNum: Device Endpoint Number
  318.  *                       EPNum.0..3: Address
  319.  *                       EPNum.7:    Dir
  320.  *    Return Value:    None
  321.  */
  322.  
  323. void USBD_ResetEP (uint32_t EPNum) {
  324.   if (EPNum & 0x80) {
  325.     EPNum &= 0x0F;
  326.     Data1 |= (1 << ((EPNum * 2) + 1));
  327.     BD[IDX(EPNum, TX, ODD )].buf_addr = (uint32_t) &(EPBuf[IDX(EPNum, TX, ODD )][0]);
  328.     BD[IDX(EPNum, TX, EVEN)].buf_addr = (uint32_t) &(EPBuf[IDX(EPNum, TX, EVEN)][0]);
  329.   }
  330.   else {
  331.     Data1 &= ~(1 << ((EPNum * 2)));
  332.     BD[IDX(EPNum, RX, ODD )].bc       = OutEpSize[EPNum];
  333.     BD[IDX(EPNum, RX, ODD )].buf_addr = (uint32_t) &(EPBuf[IDX(EPNum, RX, ODD )][0]);
  334.     BD[IDX(EPNum, RX, ODD )].stat     = BD_OWN_MASK | BD_DTS_MASK;
  335.  
  336.     BD[IDX(EPNum, RX, EVEN)].bc       = OutEpSize[EPNum];
  337.     BD[IDX(EPNum, RX, EVEN)].buf_addr = (uint32_t) &(EPBuf[IDX(EPNum, RX, EVEN)][0]);
  338.     BD[IDX(EPNum, RX, EVEN)].stat     = BD_OWN_MASK | BD_DTS_MASK;
  339.   }
  340. }
  341.  
  342. /*
  343.  *  Set Stall for USB Device Endpoint
  344.  *    Parameters:      EPNum: Device Endpoint Number
  345.  *                       EPNum.0..3: Address
  346.  *                       EPNum.7:    Dir
  347.  *    Return Value:    None
  348.  */
  349.  
  350. void USBD_SetStallEP (uint32_t EPNum) {
  351.   EPNum &= 0x0F;
  352.   USB0->ENDPOINT[EPNum].ENDPT |= USB_ENDPT_EPSTALL_MASK;
  353. }
  354.  
  355.  
  356. /*
  357.  *  Clear Stall for USB Device Endpoint
  358.  *    Parameters:      EPNum: Device Endpoint Number
  359.  *                       EPNum.0..3: Address
  360.  *                       EPNum.7:    Dir
  361.  *    Return Value:    None
  362.  */
  363.  
  364. void USBD_ClrStallEP (uint32_t EPNum) {
  365.   USB0->ENDPOINT[EPNum & 0x0F].ENDPT &= ~USB_ENDPT_EPSTALL_MASK;
  366.   USBD_ResetEP (EPNum);
  367. }
  368.  
  369.  
  370. /*
  371.  *  Clear USB Device Endpoint Buffer
  372.  *    Parameters:      EPNum: Device Endpoint Number
  373.  *                       EPNum.0..3: Address
  374.  *                       EPNum.7:    Dir
  375.  *    Return Value:    None
  376.  */
  377.  
  378. void USBD_ClearEPBuf (uint32_t EPNum) {
  379. }
  380.  
  381.  
  382. /*
  383.  *  Read USB Device Endpoint Data
  384.  *    Parameters:      EPNum: Device Endpoint Number
  385.  *                       EPNum.0..3: Address
  386.  *                       EPNum.7:    Dir
  387.  *                     pData: Pointer to Data Buffer
  388.  *    Return Value:    Number of bytes read
  389.  */
  390.  
  391. uint32_t USBD_ReadEP (uint32_t EPNum, uint8_t *pData) {
  392.   uint32_t n, sz, idx;
  393.  
  394.   idx = IDX(EPNum, RX, ((USB0->STAT >> 2) & 0x01));
  395.   sz  = BD[idx].bc;
  396.   for (n = 0; n < sz; n++) {
  397.     pData[n] = EPBuf[idx][n];
  398.   }
  399.  
  400.   BD[idx].bc = OutEpSize[EPNum];
  401.   if ((Data1 >> (idx / 2)) & 1) {
  402.     BD[idx].stat = BD_OWN_MASK | BD_DTS_MASK;
  403.   }
  404.   else {
  405.     BD[idx].stat = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK;
  406.   }
  407.   Data1 ^= (1 << (idx / 2));
  408.   USB0->CTL &= ~USB_CTL_TXSUSPENDTOKENBUSY_MASK;
  409.   return (sz);
  410. }
  411.  
  412.  
  413. /*
  414.  *  Write USB Device Endpoint Data
  415.  *    Parameters:      EPNum: Device Endpoint Number
  416.  *                       EPNum.0..3: Address
  417.  *                       EPNum.7:    Dir
  418.  *                     pData: Pointer to Data Buffer
  419.  *                     cnt:   Number of bytes to write
  420.  *    Return Value:    Number of bytes written
  421.  */
  422.  
  423. uint32_t USBD_WriteEP (uint32_t EPNum, uint8_t *pData, uint32_t cnt) {
  424.  
  425.   uint32_t idx;
  426.   uint32_t n;
  427.  
  428.   EPNum &=0x0F;
  429.  
  430.   idx    = IDX(EPNum, TX, ((USB0->STAT >> 2) & 1));
  431.   BD[idx].bc = cnt;
  432.   for (n = 0; n < cnt; n++) {
  433.     EPBuf[idx][n] = pData[n];
  434.   }
  435.   if ((Data1 >> (idx / 2)) & 1) {
  436.     BD[idx].stat = BD_OWN_MASK | BD_DTS_MASK;
  437.   }
  438.   else {
  439.     BD[idx].stat = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK;
  440.   }
  441.   Data1 ^= (1 << (idx / 2));
  442.   return(cnt);
  443. }
  444.  
  445. /*
  446.  *  Get USB Device Last Frame Number
  447.  *    Parameters:      None
  448.  *    Return Value:    Frame Number
  449.  */
  450.  
  451. uint32_t USBD_GetFrame (void) {
  452.   return((USB0->FRMNUML | (USB0->FRMNUMH << 8) & 0x07FF));
  453. }
  454.  
  455. #ifdef __RTX
  456. U32 LastError;                          /* Last Error                         */
  457.  
  458. /*
  459.  *  Get USB Device Last Error Code
  460.  *    Parameters:      None
  461.  *    Return Value:    Error Code
  462.  */
  463.  
  464. U32 USBD_GetError (void) {
  465.   return (LastError);
  466. }
  467. #endif
  468.  
  469.  
  470. /*
  471.  *  USB Device Interrupt Service Routine
  472.  */
  473. void USB0_IRQHandler(void) {
  474.   uint32_t istr, num, dir, ev_odd;
  475.  
  476.   istr = USB0->ISTAT & USB0->INTEN;
  477.  
  478. /* reset interrupt                                                            */
  479.   if (istr & USB_ISTAT_USBRST_MASK) {
  480.     USBD_Reset();
  481.     usbd_reset_core();
  482. #ifdef __RTX
  483.     if (USBD_RTX_DevTask) {
  484.       isr_evt_set(USBD_EVT_RESET, USBD_RTX_DevTask);
  485.     }
  486. #else
  487.     if (USBD_P_Reset_Event) {
  488.       USBD_P_Reset_Event();
  489.     }
  490. #endif
  491.     USB0->ISTAT = USB_ISTAT_USBRST_MASK;
  492.   }
  493.  
  494. /* suspend interrupt                                                          */
  495.   if (istr & USB_ISTAT_SLEEP_MASK) {
  496.     USBD_Suspend();
  497. #ifdef __RTX
  498.     if (USBD_RTX_DevTask) {
  499.       isr_evt_set(USBD_EVT_SUSPEND, USBD_RTX_DevTask);
  500.     }
  501. #else
  502.     if (USBD_P_Suspend_Event) {
  503.       USBD_P_Suspend_Event();
  504.     }
  505. #endif
  506.     USB0->ISTAT = USB_ISTAT_SLEEP_MASK |
  507.                   USB_ISTAT_RESUME_MASK;
  508.   }
  509.  
  510. /* resume interrupt                                                           */
  511.   if (istr & USB_ISTAT_RESUME_MASK) {
  512.     USBD_Resume();
  513. #ifdef __RTX
  514.     if (USBD_RTX_DevTask) {
  515.       isr_evt_set(USBD_EVT_RESUME, USBD_RTX_DevTask);
  516.     }
  517. #else
  518.     if (USBD_P_Resume_Event) {
  519.       USBD_P_Resume_Event();
  520.     }
  521. #endif
  522.     USB0->ISTAT = USB_ISTAT_RESUME_MASK;
  523.   }
  524.  
  525.  
  526. /* Start Of Frame                                                             */
  527.   if (istr & USB_ISTAT_SOFTOK_MASK) {
  528. #ifdef __RTX
  529.     if (USBD_RTX_DevTask) {
  530.       isr_evt_set(USBD_EVT_SOF, USBD_RTX_DevTask);
  531.     }
  532. #else
  533.     if (USBD_P_SOF_Event) {
  534.       USBD_P_SOF_Event();
  535.     }
  536. #endif
  537.     USB0->ISTAT = USB_ISTAT_SOFTOK_MASK;
  538.   }
  539.  
  540.  
  541. /* Error interrupt                                                            */
  542.   if (istr == USB_ISTAT_ERROR_MASK) {
  543. #ifdef __RTX
  544.     LastError = USB0->ERRSTAT;
  545.     if (USBD_RTX_DevTask) {
  546.       isr_evt_set(USBD_EVT_ERROR, USBD_RTX_DevTask);
  547.     }
  548. #else
  549.     if (USBD_P_Error_Event) {
  550.       USBD_P_Error_Event(USB0->ERRSTAT);
  551.     }
  552. #endif
  553.     USB0->ERRSTAT = 0xFF;
  554.     USB0->ISTAT = USB_ISTAT_ERROR_MASK;
  555.   }
  556.  
  557.  
  558. /* token interrupt                                                            */
  559.   if (istr & USB_ISTAT_TOKDNE_MASK) {
  560.  
  561.     num    = (USB0->STAT >> 4) & 0x0F;
  562.     dir    = (USB0->STAT >> 3) & 0x01;
  563.     ev_odd = (USB0->STAT >> 2) & 0x01;
  564.  
  565. /* setup packet                                                               */
  566.     if ((num == 0) && (TOK_PID((IDX(num, dir, ev_odd))) == SETUP_TOKEN)) {
  567.       Data1 &= ~0x02;
  568.       BD[IDX(0, TX, EVEN)].stat &= ~BD_OWN_MASK;
  569.       BD[IDX(0, TX, ODD)].stat  &= ~BD_OWN_MASK;
  570. #ifdef __RTX
  571.         if (USBD_RTX_EPTask[num]) {
  572.           isr_evt_set(USBD_EVT_SETUP, USBD_RTX_EPTask[num]);
  573.         }
  574. #else
  575.         if (USBD_P_EP[num]) {
  576.           USBD_P_EP[num](USBD_EVT_SETUP);
  577.         }
  578. #endif
  579.     }
  580.     else {
  581.  
  582. /* OUT packet                                                                 */
  583.       if (TOK_PID((IDX(num, dir, ev_odd))) == OUT_TOKEN) {
  584. #ifdef __RTX
  585.         if (USBD_RTX_EPTask[num]) {
  586.           isr_evt_set(USBD_EVT_OUT, USBD_RTX_EPTask[num]);
  587.         }
  588. #else
  589.         if (USBD_P_EP[num]) {
  590.           USBD_P_EP[num](USBD_EVT_OUT);
  591.         }
  592. #endif
  593.       }
  594.  
  595. /* IN packet                                                                  */
  596.       if (TOK_PID((IDX(num, dir, ev_odd))) == IN_TOKEN) {
  597. #ifdef __RTX
  598.         if (USBD_RTX_EPTask[num]) {
  599.           isr_evt_set(USBD_EVT_IN,  USBD_RTX_EPTask[num]);
  600.         }
  601. #else
  602.         if (USBD_P_EP[num]) {
  603.           USBD_P_EP[num](USBD_EVT_IN);
  604.         }
  605. #endif
  606.       }
  607.     }
  608.     USB0->ISTAT = USB_ISTAT_TOKDNE_MASK;
  609.   }
  610. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!