GD32F1x0: USB/GD32_USB_Device_Library/Core/src/usbd_core.c Source File

GD32F1x0

usbd_core.c
Go to the documentation of this file.
1 
11 /* Includes ------------------------------------------------------------------*/
12 #include "usbd_core.h"
13 
14 /* Private variables ---------------------------------------------------------*/
15 extern uint8_t gAddress;
16 
39 {
40  USB_Cable_Config(ENABLE);
41  pudev->dev.device_cur_status = USB_STATUS_CONNECTED;
42 }
43 
50 {
51  USB_Cable_Config(DISABLE);
52  DR_StopDevice();
53  pudev->dev.device_cur_status = USB_STATUS_UNCONNECTED;
54 }
55 
65  USBD_Desc_cb_TypeDef *device_desc,
66  USBD_Class_cb_TypeDef *class_cb,
67  USBD_User_cb_TypeDef *user_cb)
68 {
69  USBD_DeInit(pudev);
70 
71  /* Device descriptor class and user callbacks */
72  pudev->dev.class_cb = class_cb;
73  pudev->dev.user_cb = user_cb;
74  pudev->dev.desc_cb = device_desc;
75 
76  /* Get serial string from the unique ID */
77  Get_SerialString();
78 
79  /* Disable remote wakeup feature */
80  pudev->dev.DevRemoteWakeup = 0;
81 
82  /* USB full-speed device */
83  pudev->dev.speed = USB_SPEED_FULL;
84 
85  /* Set device register */
86  DR_Init();
87 
88 #ifdef USE_LCD_LOG
89  /* Callback user function */
90  pudev->dev.user_cb->DeviceInit();
91 #endif
92 }
93 
100 {
101  return USBD_OK;
102 }
103 
110 {
111  USB_DEVICE_REQ req;
112 
113  USBD_ParseSetupRequest(pudev, &req);
114 
115  switch (req.bmRequestType & USB_REQ_MASK)
116  {
117  /* Standard device request */
118  case USB_STANDARD_REQ:
119  USBD_StdReq(pudev, &req);
120  break;
121 
122  /* Device class request */
123  case USB_CLASS_REQ:
124  USBD_DevClsReq(pudev, &req);
125  break;
126 
127  /* Vendor defined request */
128  case USB_VENDOR_REQ:
129  USBD_VdrDefReq(pudev, &req);
130  break;
131 
132  default:
133  USB_EP_Stall(pudev, 0x00);
134  break;
135  }
136  return USBD_OK;
137 }
138 
145 uint8_t USBD_DataOutStage (USB_DEVICE_HANDLE *pudev, uint8_t EpID)
146 {
147  USB_EP *ep = &pudev->dev.out_ep[EpID];
148 
149  if(EpID == 0)
150  {
151  if(pudev->dev.device_cur_state == USB_CTRL_DATA_OUT)
152  {
153  if(ep->xfer_len > ep->maxpacket)
154  {
155  /* One data packet has been received, update xfer_len */
156  ep->xfer_len -= ep->maxpacket;
157 
158  /* Continue to receive remain data */
159  USB_CtlContinueRx(pudev, ep->xfer_buf, ep->xfer_len);
160  }
161  else
162  {
163  if((pudev->dev.class_cb->EP0_RxReady != NULL)&&
164  (pudev->dev.device_cur_status == USB_STATUS_CONFIGURED))
165  {
166  /* Device class handle */
167  pudev->dev.class_cb->EP0_RxReady(pudev);
168  }
169 
170  /* Enter the control transaction status stage */
171  USB_CtlTransmitStatus(pudev);
172  }
173  }
174  else if( pudev->dev.device_cur_state == USB_CTRL_STATUS_OUT)
175  {
176  /* Clear endpoint status_out status */
177  _Clear_Status_Out(EP0);
178  }
179  }
180  else
181  {
182  if((pudev->dev.class_cb->DataOut != NULL)&&
183  (pudev->dev.device_cur_status == USB_STATUS_CONFIGURED))
184  {
185  pudev->dev.class_cb->DataOut(pudev, EpID);
186  }
187  }
188  return USBD_OK;
189 }
190 
197 uint8_t USBD_DataInStage (USB_DEVICE_HANDLE *pudev, uint8_t EpID)
198 {
199  USB_EP *ep = &pudev->dev.in_ep[EpID];
200 
201  if(EpID == 0)
202  {
203  if(pudev->dev.device_cur_state == USB_CTRL_DATA_IN)
204  {
205  if(ep->xfer_len > ep->maxpacket)
206  {
207  /* One data packet has been transmited, update xfer_len */
208  ep->xfer_len -= ep->maxpacket;
209 
210  /* Continue to receive remain data */
211  USB_CtlContinueTx(pudev, ep->xfer_buf, ep->xfer_len);
212  }
213  else
214  {
215  /* Transmit length is maxpacket multiple, so send zero length packet */
216  if(((ep->xfer_len % ep->maxpacket) == 0) && (ep->xfer_len < ep->ctrl_count))
217  {
218  USB_CtlContinueTx(pudev, NULL, 0);
219 
220  ep->ctrl_count = 0;
221  }
222  else
223  {
224  ep->xfer_len = 0;
225 
226  if((pudev->dev.class_cb->EP0_TxSent != NULL) &&
227  (pudev->dev.device_cur_status == USB_STATUS_CONFIGURED))
228  {
229  pudev->dev.class_cb->EP0_TxSent(pudev);
230  }
231 
232  USB_CtlReceiveStatus(pudev);
233  }
234  }
235  }
236  else if((pudev->dev.device_cur_state == USB_CTRL_STATUS_IN) && (gAddress != 0))
237  {
238  USB_EP_SetAddress(pudev, gAddress);
239  gAddress = 0;
240  }
241  }
242  else
243  {
244  ep->xfer_len -= ep->xfer_count;
245 
246  if(ep->xfer_len == 0)
247  {
248  if((pudev->dev.class_cb->DataIn != NULL) &&
249  (pudev->dev.device_cur_status == USB_STATUS_CONFIGURED))
250  {
251  pudev->dev.class_cb->DataIn(pudev, EpID);
252  }
253  }
254  else
255  {
256  USB_EP_Tx(pudev, EpID, ep->xfer_buf, ep->xfer_len);
257  }
258  }
259  return USBD_OK;
260 }
261 
269 USBD_Status USBD_SetCfg (USB_DEVICE_HANDLE *pudev, uint8_t ConfigIndex)
270 {
271  /* Configure USB device class */
272  pudev->dev.class_cb->Init(pudev, ConfigIndex);
273 
274 #ifdef USE_LCD_LOG
275  pudev->dev.user_cb->DeviceConfigured();
276 #endif
277 
278  return USBD_OK;
279 }
280 
287 USBD_Status USBD_ClrCfg (USB_DEVICE_HANDLE *pudev, uint8_t ConfigIndex)
288 {
289  pudev->dev.class_cb->DeInit(pudev, ConfigIndex);
290 
291  return USBD_OK;
292 }
293 
310 /************************ (C) COPYRIGHT 2014 GIGADEVICE *****END OF FILE****/
311 
USB device class callback type define.
Definition: usb_core.h:153
void DR_StopDevice(void)
Device register configure when stop device.
Definition: usb_core.c:76
USBD_Status USBD_ClrCfg(USB_DEVICE_HANDLE *pudev, uint8_t ConfigIndex)
Clear current configuration.
Definition: usbd_core.c:287
void USB_EP_Tx(USB_CORE_HANDLE *pudev, uint8_t EpAddr, uint8_t *pbuf, uint16_t BufLen)
Endpoint prepare to transmit data.
Definition: usb_core.c:376
uint8_t USB_CtlReceiveStatus(USB_CORE_HANDLE *pudev)
Receive status stage on the control pipe.
Definition: usb_core.c:623
#define USB_STATUS_UNCONNECTED
USB device status.
Definition: usb_core.h:73
void USB_EP_SetAddress(USB_CORE_HANDLE *pudev, uint8_t Addr)
Set USB device and endpoints address.
Definition: usb_core.c:501
uint8_t USBD_SetupStage(USB_DEVICE_HANDLE *pudev)
Usb setup stage processing.
Definition: usbd_core.c:109
void USBD_Connect(USB_DEVICE_HANDLE *pudev)
Configure usb device to be connected.
Definition: usbd_core.c:38
void USBD_ParseSetupRequest(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Decode setup data packet.
Definition: usbd_enum.c:736
USB endpoint struct.
Definition: usb_core.h:101
USB device descriptor callback type define.
Definition: usb_core.h:135
void USBD_Init(USB_DEVICE_HANDLE *pudev, USBD_Desc_cb_TypeDef *device_desc, USBD_Class_cb_TypeDef *class_cb, USBD_User_cb_TypeDef *user_cb)
Initialize usb device stack.
Definition: usbd_core.c:64
uint8_t USBD_VdrDefReq(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle usb vendor request.
Definition: usbd_enum.c:130
uint8_t USB_CtlTransmitStatus(USB_CORE_HANDLE *pudev)
Transmit status stage on the control pipe.
Definition: usb_core.c:609
uint8_t USBD_StdReq(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle usb standard device request.
Definition: usbd_enum.c:78
uint8_t USBD_DataInStage(USB_DEVICE_HANDLE *pudev, uint8_t EpID)
Data in stage processing.
Definition: usbd_core.c:197
USBD_Status
USB device operation status.
Definition: usbd_core.h:40
uint8_t USBD_DataOutStage(USB_DEVICE_HANDLE *pudev, uint8_t EpID)
Data out stage processing.
Definition: usbd_core.c:145
uint8_t USBD_DevClsReq(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle device class request.
Definition: usbd_enum.c:92
USBD_Status USBD_SetCfg(USB_DEVICE_HANDLE *pudev, uint8_t ConfigIndex)
Device configuration and interface setting.
Definition: usbd_core.c:269
void USB_EP_Stall(USB_CORE_HANDLE *pudev, uint8_t EpID)
Set an endpoint to STALL status.
Definition: usb_core.c:438
uint8_t USB_CtlContinueTx(USB_CORE_HANDLE *pudev, uint8_t *pbuf, uint16_t Len)
Continue transmitting data on the control pipe.
Definition: usb_core.c:561
void USBD_Disconnect(USB_DEVICE_HANDLE *pudev)
Configure usb device to be unconnected.
Definition: usbd_core.c:49
USBD_Status USBD_DeInit(USB_DEVICE_HANDLE *pudev)
De-Initialize USB device stack.
Definition: usbd_core.c:99
void DR_Init(void)
Device register initialization.
Definition: usb_core.c:44
USB user callback type define.
Definition: usb_core.h:179
uint8_t USB_CtlContinueRx(USB_CORE_HANDLE *pudev, uint8_t *pbuf, uint16_t Len)
Continue receive data on the contrl pipe.
Definition: usb_core.c:595
USB device core function protoype.
USB standard device request struct.
Definition: usb_core.h:122
Generated by   doxygen 1.8.10