GD32F10x USB-Device: E:/USB Libraries/GD32_USB_Device_Library/Core/src/usbd_it.c Source File

GD32F103 Firmware

previous page next page
usbd_it.c
1 
11 /* Includes ------------------------------------------------------------------*/
12 #include "usbd_it.h"
13 
29 static uint8_t USBINT_LPST (USB_DEVICE_HANDLE *pudev);
30 static uint8_t USBINT_HPST (USB_DEVICE_HANDLE *pudev);
31 static uint8_t USBINT_PMOU (USB_DEVICE_HANDLE *pudev);
32 static uint8_t USBINT_Error (USB_DEVICE_HANDLE *pudev);
33 static uint8_t USBINT_SOF (USB_DEVICE_HANDLE *pudev);
34 static uint8_t USBINT_ESOF (USB_DEVICE_HANDLE *pudev);
35 static uint8_t USBINT_Reset (USB_DEVICE_HANDLE *pudev);
36 static uint8_t USBINT_Suspend (USB_DEVICE_HANDLE *pudev);
37 static uint8_t USBINT_WakeUp (USB_DEVICE_HANDLE *pudev);
38 
46 extern __IO uint8_t SuspendEnabled;
47 
48 USB_INTHandler_TypeDef USB_INTHandler =
49 {
50  USBINT_HPST,
51  USBINT_LPST,
52  USBINT_PMOU,
53  USBINT_Error,
54  USBINT_Reset,
55  USBINT_SOF,
56  USBINT_ESOF,
57  USBINT_Suspend,
58  USBINT_WakeUp,
59 };
60 
61 USB_INTHandler_TypeDef *USB_INT_fops = &USB_INTHandler;
62 
76 static uint8_t USBINT_LPST (USB_DEVICE_HANDLE *pudev)
77 {
78  USB_EP *Ep = NULL;
79  uint8_t EpID = 0;
80  __IO uint16_t Ifr = 0;
81  __IO uint16_t EpValue = 0;
82 
83  /* Wait till interrupts are not pending */
84  while(((Ifr = _GetIFR()) & IFR_STIF) != 0)
85  {
86  /* Get endpoint number and the value of control and state register */
87  EpID = (uint8_t)(Ifr & IFR_EPNUM);
88  EpValue = _GetEPxCSR(EpID);
89 
90  if((Ifr & IFR_DIR) == 0)
91  {
92  /* Handle the In direction transaction */
93 
94  Ep = &(pudev->dev.in_ep[EpID]);
95 
96  if((EpValue & EPTX_ST) != 0)
97  {
98  /* Clear successful transmit interrupt flag */
99  _ClearEPTX_ST(EpID);
100 
101  /* Just handle single buffer situation */
102  Ep->xfer_count = _GetEPTxCount(EpID);
103 
104  /* Maybe mutiple packets */
105  Ep->xfer_buf += Ep->xfer_count;
106 
107  USBD_DataInStage(pudev, EpID);
108  }
109  }
110  else
111  {
112  /* Handle the OUT direction transaction */
113 
114  int count = 0;
115 
116  Ep = &(pudev->dev.out_ep[EpID]);
117 
118  if((EpValue & EPRX_ST) != 0)
119  {
120  /* Clear successful receive interrupt flag */
121  _ClearEPRX_ST(EpID);
122 
123  count = _GetEPRxCount(EpID);
124 
125  if(count != 0)
126  {
127  if((EpValue & EP_SETUP) != 0)
128  {
129  /* Handle setup packet */
130  BufferCopyToUser(&(pudev->dev.setup_packet[0]), Ep->bufaddress, count);
131 
132  USBD_SetupStage(pudev);
133 
134  return USBD_OK;
135  }
136  else
137  {
138  BufferCopyToUser(Ep->xfer_buf, Ep->bufaddress, count);
139  }
140  }
141 
142  /* Maybe mutiple packets */
143  Ep->xfer_count += count;
144  Ep->xfer_buf += count;
145  Ep->xfer_len -= count;
146 
147  if(Ep->xfer_len == 0 || count < Ep->maxpacket)
148  {
149  USBD_DataOutStage(pudev, EpID);
150  Ep->xfer_count = 0;
151  }
152  else
153  {
154  USB_EP_Rx(pudev, EpID, Ep->xfer_buf, Ep->xfer_len);
155  }
156  }
157  }/* if((temp_Ifr & IFR_DIR) == 0) else ... */
158  }/* while(...) */
159 
160  return USBD_OK;
161 }
162 
168 static uint8_t USBINT_HPST (USB_DEVICE_HANDLE *pudev)
169 {
170  USB_EP *Ep = NULL;
171  uint8_t EpID = 0;
172  __IO uint16_t Ifr = 0;
173  __IO uint16_t EpValue = 0;
174 
175  /* wait till interrupts are not pending */
176  while (((Ifr = _GetIFR()) & IFR_STIF) != 0)
177  {
178  /* Get endpoint number and the value of control and states register */
179  EpID = (uint8_t)(Ifr & IFR_EPNUM);
180  EpValue = _GetEPxCSR(EpID);
181 
182  if((Ifr & IFR_DIR) == 0)
183  {
184  /* handle the In direction transaction */
185 
186  Ep = &(pudev->dev.in_ep[EpID]);
187 
188  if((EpValue & EPTX_ST) != 0)
189  {
190  uint16_t len = 0;
191  uint16_t bufaddr = 0;
192 
193  _ClearEPTX_ST(EpID);
194 
195  if (EpValue & EPTX_DTG)
196  {
197  Ep->xfer_count = _GetEPDblBuf0Count(EpID);
198  bufaddr = Ep->buf1addr;
199  }
200  else
201  {
202  Ep->xfer_count = _GetEPDblBuf1Count(EpID);
203  bufaddr = Ep->buf0addr;
204  }
205 
206  Ep->xfer_buf += Ep->xfer_count;
207  Ep->xfer_len -= Ep->xfer_count;
208 
209  if(Ep->xfer_len > Ep->maxpacket)
210  {
211  len = Ep->maxpacket;
212  }
213  else if((0 < Ep->xfer_len) && (Ep->xfer_len <= Ep->maxpacket))
214  {
215  len = Ep->xfer_len;
216  }
217 
218  if(len > 0)
219  {
220  UserCopyToBuffer(Ep->xfer_buf, bufaddr, len);
221  FreeUserBuffer(EpID, DBUF_EP_IN);
222  }
223 
224  if(Ep->xfer_len == 0)
225  {
226  _SetEPTxStatus(EpID, EPTX_NAK);
227  pudev->dev.class_cb->DataIn(&USB_Device_dev, EpID);
228  }
229  }
230  }
231  else
232  {
233  /* Handle the Out direction transaction */
234 
235  Ep = &((&USB_Device_dev)->dev.out_ep[EpID]);
236 
237  if((EpValue & EPRX_ST) != 0)
238  {
239  int count = 0;
240 
241  _ClearEPRX_ST(EpID);
242 
243  if (EpValue & EPRX_DTG)
244  {
245  count = _GetEPDblBuf0Count(EpID);
246  if (count != 0)
247  {
248  BufferCopyToUser(Ep->xfer_buf, Ep->buf0addr, count);
249  }
250  }
251  else
252  {
253  count = _GetEPDblBuf1Count(EpID);
254  if (count != 0)
255  {
256  BufferCopyToUser(Ep->xfer_buf, Ep->buf1addr, count);
257  }
258  }
259 
260  FreeUserBuffer(EpID, DBUF_EP_OUT);
261 
262  /* Maybe multiple packets */
263  Ep->xfer_buf += count;
264  Ep->xfer_count += count;
265  Ep->xfer_len -= count;
266 
267  if((Ep->xfer_len == 0) || (count < Ep->maxpacket))
268  {
269  _SetEPRxStatus(EpID, EPRX_NAK);
270  pudev->dev.class_cb->DataOut(&USB_Device_dev, EpID);
271  Ep->xfer_count = 0;
272  }
273  }
274  }/* if((temp_Ifr & IFR_DIR) == 0) else ... */
275  }/* while(...) */
276 
277  return USBD_OK;
278 }
279 
285 static uint8_t USBINT_PMOU (USB_CORE_HANDLE *pudev)
286 {
287  return USBD_OK;
288 }
289 
295 static uint8_t USBINT_Error (USB_CORE_HANDLE *pudev)
296 {
297  return USBD_OK;
298 }
299 
305 static uint8_t USBINT_SOF (USB_CORE_HANDLE *pudev)
306 {
307  if(pudev->dev.class_cb->SOF)
308  {
309  pudev->dev.class_cb->SOF(pudev);
310  }
311  return USBD_OK;
312 }
313 
319 static uint8_t USBINT_ESOF (USB_CORE_HANDLE *pudev)
320 {
321  /* Control resume time by ESOFs */
322  USBD_Resume(RESUME_ESOF);
323 
324  return USBD_OK;
325 }
326 
332 static uint8_t USBINT_Reset (USB_CORE_HANDLE *pudev)
333 {
334  USB_EP_BufConfig(pudev, 0x00, USB_SNG_BUFTYPE, EP0_RX_ADDRESS);
335  USB_EP_BufConfig(pudev, 0x80, USB_SNG_BUFTYPE, EP0_TX_ADDRESS);
336 
337  /* Initialize endpoint0 in OUT direction */
338  USB_EP_Init(pudev,
339  EP0_OUT,
340  USB_EPTYPE_CONTROL,
341  USB_EP0_MAX_SIZE);
342 
343  /* Initialize endpoint0 in IN direction */
344  USB_EP_Init(pudev,
345  EP0_IN,
346  USB_EPTYPE_CONTROL,
347  USB_EP0_MAX_SIZE);
348 
349  /* Call back user reset function */
350  pudev->dev.user_cb->DeviceReset(pudev->dev.speed);
351 
352  /* Set device address as default address 0 */
353  USB_EP_SetAddress(pudev, 0);
354 
355  pudev->dev.device_cur_status = USB_STATUS_DEFAULT;
356 
357  return USBD_OK;
358 }
359 
365 static uint8_t USBINT_Suspend (USB_CORE_HANDLE *pudev)
366 {
367  /* Store the device current status */
368  pudev->dev.device_old_status = pudev->dev.device_cur_status;
369 
370  /* Set device in suspended state */
371  pudev->dev.device_cur_status = USB_STATUS_SUSPENDED;
372 
373  /* Call back user suspend function */
374  pudev->dev.user_cb->DeviceSuspended();
375 
376  /* Enter usb in suspend and mcu system in low power mode */
377  if (SuspendEnabled)
378  {
379  USBD_Suspend();
380  }
381  else
382  {
383  /* if not possible then resume after xx ms */
384  USBD_Resume(RESUME_LATER);
385  }
386 
387  return USBD_OK;
388 }
389 
395 static uint8_t USBINT_WakeUp (USB_CORE_HANDLE *pudev)
396 {
397  /* Call back user resume function */
398  pudev->dev.user_cb->DeviceResumed();
399 
400  /* Restore the old status */
401  pudev->dev.device_cur_status = pudev->dev.device_old_status;
402 
403  USBD_Resume(RESUME_EXTERNAL);
404 
405  return USBD_OK;
406 }
407 
424 /************************ (C) COPYRIGHT 2014 GIGADEVICE *****END OF FILE****/
EPTX_ST
#define EPTX_ST
Definition: usb_regs.h:202
USB_EPTYPE_CONTROL
#define USB_EPTYPE_CONTROL
USB endpoint type.
Definition: usb_core.h:44
usbd_it.h
USB device interrupt events handle function defines.
USBD_SetupStage
uint8_t USBD_SetupStage(USB_DEVICE_HANDLE *pudev)
Usb setup stage processing.
Definition: usbd_core.c:107
EPRX_DTG
#define EPRX_DTG
Definition: usb_regs.h:197
USB_Device_handle
Definition: usb_core.h:207
USB_EP_SetAddress
void USB_EP_SetAddress(USB_CORE_HANDLE *pudev, uint8_t Addr)
Set USB device and endpoints address.
Definition: usb_core.c:465
EPRX_ST
#define EPRX_ST
EPCSR endpoint control and status register bit definitions.
Definition: usb_regs.h:196
USBD_DataInStage
uint8_t USBD_DataInStage(USB_DEVICE_HANDLE *pudev, uint8_t EpID)
Data in stage processing.
Definition: usbd_core.c:195
USB_ep
USB endpoint struct.
Definition: usb_core.h:101
USBD_Resume
void USBD_Resume(RESUME_STATE ResumeValue)
Resume state machine handling.
Definition: usbd_pwr.c:142
EP0_OUT
#define EP0_OUT
First bit is direction(0 for Rx and 1 for Tx)
Definition: usb_regs.h:97
EPTX_NAK
#define EPTX_NAK
Definition: usb_regs.h:231
IFR_EPNUM
#define IFR_EPNUM
Definition: usb_regs.h:167
USBD_Suspend
void USBD_Suspend(void)
Set usb device to suspend mode.
Definition: usbd_pwr.c:110
_USB_INTHandler
Definition: usbd_it.h:36
IFR_DIR
#define IFR_DIR
Definition: usb_regs.h:166
USB_EP_Init
void USB_EP_Init(USB_CORE_HANDLE *pudev, uint8_t EpAddr, uint8_t EpType, uint16_t EpMps)
Endpoint initialization.
Definition: usb_core.c:152
EPRX_NAK
#define EPRX_NAK
Definition: usb_regs.h:240
_GetEPDblBuf0Count
#define _GetEPDblBuf0Count(EpID)
Get buffer 0/1 byte count.
Definition: usb_regs.h:613
EP_SETUP
#define EP_SETUP
Definition: usb_regs.h:199
IFR_STIF
#define IFR_STIF
IFR interrupt events bits definitions.
Definition: usb_regs.h:158
FreeUserBuffer
void FreeUserBuffer(uint8_t EpID, uint8_t Dir)
Free buffer used from application by toggling the SW_BUF byte.
Definition: usb_buf.c:36
USB_EP0_MAX_SIZE
#define USB_EP0_MAX_SIZE
USB endpoint0 max packet size.
Definition: usb_core.h:68
USBD_DataOutStage
uint8_t USBD_DataOutStage(USB_DEVICE_HANDLE *pudev, uint8_t EpID)
Data out stage processing.
Definition: usbd_core.c:143
_SetEPRxStatus
#define _SetEPRxStatus(EpID, State)
Rx transfer status setting and getting (bits EPRX_STA[1:0])
Definition: usb_regs.h:352
_GetEPTxCount
#define _GetEPTxCount(EpID)
Get Tx/Rx buffer byte count.
Definition: usb_regs.h:547
EPTX_DTG
#define EPTX_DTG
Definition: usb_regs.h:203
UserCopyToBuffer
void UserCopyToBuffer(uint8_t *UsrBuf, uint16_t BufAddr, uint16_t Bytes)
Copy a buffer from user memory area to the allocation buffer area.
Definition: usb_buf.c:55
USB_SNG_BUFTYPE
#define USB_SNG_BUFTYPE
USB endpoint kind.
Definition: usb_core.h:52
USB_EP_BufConfig
void USB_EP_BufConfig(USB_CORE_HANDLE *pudev, uint8_t EpAddr, uint8_t EpKind, uint32_t BufAddr)
Configure buffer for endpoint.
Definition: usb_core.c:98
_ClearEPRX_ST
#define _ClearEPRX_ST(EpID)
Clear bit EPRX_ST / EPTX_ST in the endpoint control and status register.
Definition: usb_regs.h:405
BufferCopyToUser
void BufferCopyToUser(uint8_t *UsrBuf, uint16_t BufAddr, uint16_t Bytes)
Copy a buffer from the allocation buffer area to user memory area.
Definition: usb_buf.c:78
_SetEPTxStatus
#define _SetEPTxStatus(EpID, State)
Tx transfer status setting and getting (bits EPTX_STA[1:0])
Definition: usb_regs.h:338
USB_EP_Rx
void USB_EP_Rx(USB_CORE_HANDLE *pudev, uint8_t EpAddr, uint8_t *pbuf, uint16_t BufLen)
Endpoint prepare to receive data.
Definition: usb_core.c:309
Generated on Fri Feb 6 2015 14:56:36 for GD32F10x USB-Device by   doxygen 1.8.8
previous page start next page