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

GD32F103 Firmware

previous page next page
usbd_enum.c
1 
12 /* Includes ------------------------------------------------------------------*/
13 #include "usbd_enum.h"
14 
27 /* USB enumeration handle functions */
28 static void USBD_GetDescriptor (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
29 static void USBD_SetAddress (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
30 static void USBD_SetConfiguration (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
31 static void USBD_GetConfiguration (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
32 static void USBD_GetStatus (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
33 static void USBD_SetFeature (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
34 static void USBD_ClearFeature (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
35 static void USBD_Reserved (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
36 static void USBD_SetDescriptor (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
37 static void USBD_GetInterface (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
38 static void USBD_SetInterface (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
39 static void USBD_SynchFrame (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req);
40 
44 uint8_t gAddress = 0;
45 uint8_t USBD_StrDesc[USB_STR_DESC_MAX_SIZE];
46 
47 static void (*StandardDeviceRequest[])(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req) =
48 {
49  USBD_GetStatus,
50  USBD_ClearFeature,
51  USBD_Reserved,
52  USBD_SetFeature,
53  USBD_Reserved,
54  USBD_SetAddress,
55  USBD_GetDescriptor,
56  USBD_SetDescriptor,
57  USBD_GetConfiguration,
58  USBD_SetConfiguration,
59  USBD_GetInterface,
60  USBD_SetInterface,
61  USBD_SynchFrame,
62 };
63 
78 uint8_t USBD_StdReq (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
79 {
80  /* Call device request handle function */
81  (*StandardDeviceRequest[req->bRequest])(pudev, req);
82 
83  return USBD_OK;
84 }
85 
92 uint8_t USBD_DevClsReq (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
93 {
94  USBD_Status ret;
95 
96  switch (pudev->dev.device_cur_status)
97  {
98  case USB_STATUS_CONFIGURED:
99  if (LOWBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
100  {
101  /* Call back device class handle function */
102  ret = (USBD_Status)(pudev->dev.class_cb->ClassReqHandle(pudev, req));
103 
104  if((req->wLength == 0) && (ret == USBD_OK))
105  {
106  /* No data stage */
107  USB_CtlTransmitStatus(pudev);
108  }
109  }
110  else
111  {
112  USBD_EnumError(pudev, req);
113  }
114  break;
115 
116  default:
117  USBD_EnumError(pudev, req);
118  break;
119  }
120 
121  return USBD_OK;
122 }
123 
130 uint8_t USBD_VdrDefReq (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
131 {
132  /* Added by user... */
133 
134  return USBD_OK;
135 }
136 
143 static void USBD_Reserved (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
144 {
145  /* No operation... */
146 }
147 
154 static void USBD_GetStatus (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
155 {
156  uint8_t ep_addr;
157  uint16_t config_status = 0x0000;
158  uint16_t endp_status = 0x0000;
159 
160  switch(req->bmRequestType & USB_REQ_RECIPIENT_MASK)
161  {
162  case USB_REQTYPE_DEVICE:
163  switch (pudev->dev.device_cur_status)
164  {
165  case USB_STATUS_ADDRESSED:
166  case USB_STATUS_CONFIGURED:
167 
168 #ifdef USBD_SELF_POWERED
169  config_status = USB_STATUS_SELF_POWERED;
170 #endif
171 
172  if (pudev->dev.DevRemoteWakeup)
173  {
174  config_status |= USB_STATUS_REMOTE_WAKEUP;
175  }
176  USB_CtlTx(pudev, (uint8_t *)&config_status, 2);
177  break;
178 
179  default:
180  break;
181  }
182  break;
183 
184  case USB_REQTYPE_INTERFACE:
185  switch (pudev->dev.device_cur_status)
186  {
187  case USB_STATUS_ADDRESSED:
188  USBD_EnumError(pudev, req);
189  break;
190 
191  case USB_STATUS_CONFIGURED:
192  if (LOWBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
193  {
194  USB_CtlTx(pudev, (uint8_t *)&config_status, 2);
195  }
196  else
197  {
198  USBD_EnumError(pudev, req);
199  }
200  break;
201 
202  default:
203  break;
204  }
205  break;
206 
207  case USB_REQTYPE_ENDPOINT:
208  ep_addr = LOWBYTE(req->wIndex);
209 
210  switch (pudev->dev.device_cur_status)
211  {
212  case USB_STATUS_ADDRESSED:
213  if (IS_NOT_EP0(ep_addr))
214  {
215  USBD_EnumError(pudev, req);
216  }
217  break;
218 
219  case USB_STATUS_CONFIGURED:
220  if ((ep_addr & 0x80)== 0x80)
221  {
222  if(pudev->dev.in_ep[ep_addr & 0x7F].is_stall)
223  {
224  endp_status = 0x0001;
225  }
226  }
227  else
228  {
229  if(pudev->dev.out_ep[ep_addr].is_stall)
230  {
231  endp_status = 0x0001;
232  }
233  }
234  USB_CtlTx(pudev, (uint8_t *)&endp_status, 2);
235  break;
236 
237  default:
238  break;
239  }
240  break;
241 
242  default:
243  USBD_EnumError(pudev, req);
244  break;
245  }
246 }
247 
254 static void USBD_ClearFeature (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
255 {
256  uint8_t ep_addr = 0;
257 
258  switch(req->bmRequestType & USB_REQ_RECIPIENT_MASK)
259  {
260  case USB_REQTYPE_DEVICE:
261  switch (pudev->dev.device_cur_status)
262  {
263  case USB_STATUS_ADDRESSED:
264  case USB_STATUS_CONFIGURED:
265  if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
266  {
267  pudev->dev.DevRemoteWakeup = 0;
268  USB_CtlTransmitStatus(pudev);
269  }
270  else if(req->wValue == USB_FEATURE_TEST_MODE)
271  {
272  /* Can not clear test_mode feature */
273  USBD_EnumError(pudev, req);
274  }
275  break;
276 
277  default:
278  break;
279  }
280  break;
281 
282  case USB_REQTYPE_INTERFACE:
283  switch(pudev->dev.device_cur_state)
284  {
285  case USB_STATUS_ADDRESSED:
286  USBD_EnumError(pudev, req);
287  break;
288 
289  case USB_STATUS_CONFIGURED:
290  if (LOWBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
291  {/* No operation */
292  }
293  else
294  {
295  USBD_EnumError(pudev, req);
296  }
297  break;
298 
299  default:
300  break;
301  }
302  break;
303 
304  case USB_REQTYPE_ENDPOINT:
305  ep_addr = LOWBYTE(req->wIndex);
306 
307  switch (pudev->dev.device_cur_status)
308  {
309  case USB_STATUS_ADDRESSED:
310  if (IS_NOT_EP0(ep_addr))
311  {
312  USBD_EnumError(pudev, req);
313  }
314  break;
315 
316  case USB_STATUS_CONFIGURED:
317  if (req->wValue == USB_FEATURE_ENDP_HALT)
318  {
319  if (IS_NOT_EP0(ep_addr))
320  {
321  USB_EP_ClrStall(pudev, ep_addr);
322  }
323  }
324  USB_CtlTransmitStatus(pudev);
325  break;
326 
327  default:
328  break;
329  }
330  break;
331 
332  default:
333  USBD_EnumError(pudev, req);
334  break;
335  }
336 }
337 
344 static void USBD_SetFeature (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
345 {
346  uint8_t ep_addr = 0;
347 
348  switch(req->bmRequestType & USB_REQ_RECIPIENT_MASK)
349  {
350  case USB_REQTYPE_DEVICE:
351  switch (pudev->dev.device_cur_status)
352  {
353  case USB_STATUS_ADDRESSED:
354  case USB_STATUS_CONFIGURED:
355  if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
356  {
357  pudev->dev.DevRemoteWakeup = 1;
358  USB_CtlTransmitStatus(pudev);
359  }
360  break;
361 
362  default:
363  break;
364  }
365  break;
366 
367  case USB_REQTYPE_INTERFACE:
368  switch(pudev->dev.device_cur_state)
369  {
370  case USB_STATUS_ADDRESSED:
371  USBD_EnumError(pudev, req);
372  break;
373 
374  case USB_STATUS_CONFIGURED:
375  if (LOWBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
376  {/* No operation */
377  }
378  else
379  {
380  USBD_EnumError(pudev, req);
381  }
382  break;
383 
384  default:
385  break;
386  }
387  break;
388 
389  case USB_REQTYPE_ENDPOINT:
390  switch (pudev->dev.device_cur_status)
391  {
392  case USB_STATUS_ADDRESSED:
393  if (IS_NOT_EP0(ep_addr))
394  {
395  USBD_EnumError(pudev, req);
396  }
397  break;
398 
399  case USB_STATUS_CONFIGURED:
400  if (req->wValue == USB_FEATURE_ENDP_HALT)
401  {
402  if (IS_NOT_EP0(ep_addr))
403  {
404  USB_EP_Stall(pudev, ep_addr);
405  }
406  }
407  USB_CtlTransmitStatus(pudev);
408  break;
409 
410  default:
411  break;
412  }
413  break;
414 
415  default:
416  USBD_EnumError(pudev, req);
417  break;
418  }
419 }
420 
427 static void USBD_SetAddress (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
428 {
429  if ((req->wIndex == 0) && (req->wLength == 0))
430  {
431  gAddress = (uint8_t)(req->wValue) & 0x7F;
432 
433  if (pudev->dev.device_cur_status == USB_STATUS_CONFIGURED)
434  {
435  USBD_EnumError(pudev, req);
436  }
437  else
438  {
439  USB_CtlTransmitStatus(pudev);
440 
441  if (gAddress != 0)
442  {
443  pudev->dev.device_cur_status = USB_STATUS_ADDRESSED;
444  }
445  else
446  {
447  pudev->dev.device_cur_status = USB_STATUS_DEFAULT;
448  }
449  }
450  }
451  else
452  {
453  USBD_EnumError(pudev , req);
454  }
455 }
456 
463 static void USBD_GetDescriptor (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
464 {
465  if((req->bmRequestType & USB_REQ_RECIPIENT_MASK) == USB_REQTYPE_DEVICE)
466  {
467  uint16_t len;
468  uint8_t *pbuf;
469 
470  switch (req->wValue >> 8)
471  {
472  case USB_DESCTYPE_DEVICE:
473  pbuf = pudev->dev.desc_cb->GetDeviceDescriptor(pudev->dev.speed, &len);
474  if (req->wLength == 64) len = 8;
475  break;
476 
477  case USB_DESCTYPE_CONFIGURATION:
478  pbuf = (uint8_t *)pudev->dev.class_cb->GetConfigDescriptor(pudev->dev.speed, &len);
479  break;
480 
481  case USB_DESCTYPE_STRING:
482  switch ((uint8_t)(req->wValue))
483  {
484  case USBD_LANGID_STR_IDX:
485  pbuf = pudev->dev.desc_cb->GetLangIDStrDescriptor(pudev->dev.speed, &len);
486  break;
487 
488  case USBD_MFC_STR_IDX:
489  pbuf = pudev->dev.desc_cb->GetManufacturerStrDescriptor(pudev->dev.speed, &len);
490  break;
491 
492  case USBD_PRODUCT_STR_IDX:
493  pbuf = pudev->dev.desc_cb->GetProductStrDescriptor(pudev->dev.speed, &len);
494  break;
495 
496  case USBD_SERIAL_STR_IDX:
497  pbuf = pudev->dev.desc_cb->GetSerialStrDescriptor(pudev->dev.speed, &len);
498  break;
499 
500  case USBD_CONFIG_STR_IDX:
501  pbuf = pudev->dev.desc_cb->GetConfigurationStrDescriptor(pudev->dev.speed, &len);
502  break;
503 
504  case USBD_INTERFACE_STR_IDX:
505  pbuf = pudev->dev.desc_cb->GetInterfaceStrDescriptor(pudev->dev.speed, &len);
506  break;
507 
508  default:
509 #ifdef USB_SUPPORT_USER_STRING_DESC
510  pbuf = pudev->dev.class_cb->GetUsrStrDescriptor(pudev->dev.speed, (req->wValue), &len);
511  break;
512 #else
513  USBD_EnumError(pudev, req);
514  return;
515 #endif
516  }
517  break;
518 
519  case USB_DESCTYPE_DEVICE_QUALIFIER:
520  USBD_EnumError(pudev, req);
521  return;
522 
523  case USB_DESCTYPE_OTHER_SPEED_CONFIGURATION:
524  USBD_EnumError(pudev, req);
525  return;
526 
527  default:
528  USBD_EnumError(pudev, req);
529  return;
530  }
531 
532  if((len != 0) && (req->wLength != 0))
533  {
534  len = MIN(len, req->wLength);
535 
536  USB_CtlTx (pudev, pbuf,len);
537  }
538  }
539  else if((req->bmRequestType & USB_REQ_RECIPIENT_MASK) == USB_REQTYPE_INTERFACE)
540  {
541  pudev->dev.class_cb->GetClassDescriptor(pudev, req);
542  }
543 }
544 
551 static void USBD_SetDescriptor (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
552 {
553  /* No handle... */
554 }
555 
562 static void USBD_GetConfiguration (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
563 {
564  uint32_t USBD_default_config = 0;
565 
566  if (req->wLength != 1)
567  {
568  USBD_EnumError(pudev, req);
569  }
570  else
571  {
572  switch (pudev->dev.device_cur_status)
573  {
574  case USB_STATUS_ADDRESSED:
575  USB_CtlTx (pudev, (uint8_t *)&USBD_default_config, 1);
576  break;
577 
578  case USB_STATUS_CONFIGURED:
579  USB_CtlTx (pudev, &pudev->dev.device_cur_config, 1);
580  break;
581 
582  default:
583  break;
584  }
585  }
586 }
587 
594 static void USBD_SetConfiguration (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
595 {
596  static uint8_t cfgidx;
597 
598  cfgidx = (uint8_t)(req->wValue);
599 
600  if (cfgidx > USBD_CFG_MAX_NUM)
601  {
602  USBD_EnumError(pudev, req);
603  }
604  else
605  {
606  switch (pudev->dev.device_cur_status)
607  {
608  case USB_STATUS_ADDRESSED:
609  if (cfgidx)
610  {
611  pudev->dev.device_cur_config = cfgidx;
612  pudev->dev.device_cur_status = USB_STATUS_CONFIGURED;
613  USBD_SetCfg(pudev, cfgidx);
614  USB_CtlTransmitStatus(pudev);
615  }
616  else
617  {
618  USB_CtlTransmitStatus(pudev);
619  }
620  break;
621 
622  case USB_STATUS_CONFIGURED:
623  if (cfgidx == 0)
624  {
625  pudev->dev.device_cur_status = USB_STATUS_ADDRESSED;
626  pudev->dev.device_cur_config = cfgidx;
627  USBD_ClrCfg(pudev, cfgidx);
628  USB_CtlTransmitStatus(pudev);
629  }
630  else if (cfgidx != pudev->dev.device_cur_config)
631  {
632  /* Clear old configuration */
633  USBD_ClrCfg(pudev, pudev->dev.device_cur_config);
634 
635  /* Set new configuration */
636  pudev->dev.device_cur_config = cfgidx;
637  USBD_SetCfg(pudev, cfgidx);
638  USB_CtlTransmitStatus(pudev);
639  }
640  else
641  {
642  USB_CtlTransmitStatus(pudev);
643  }
644  break;
645 
646  default:
647  break;
648  }
649  }
650 }
651 
658 static void USBD_GetInterface (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
659 {
660  switch (pudev->dev.device_cur_status)
661  {
662  case USB_STATUS_ADDRESSED:
663  USBD_EnumError(pudev, req);
664  break;
665 
666  case USB_STATUS_CONFIGURED:
667  if (LOWBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
668  {
669  pudev->dev.class_cb->GetInterface (pudev, req);
670  }
671  else
672  {
673  USBD_EnumError(pudev, req);
674  }
675  break;
676 
677  default:
678  break;
679  }
680 }
681 
688 static void USBD_SetInterface (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
689 {
690  switch (pudev->dev.device_cur_status)
691  {
692  case USB_STATUS_ADDRESSED:
693  USBD_EnumError(pudev, req);
694  break;
695 
696  case USB_STATUS_CONFIGURED:
697  if (LOWBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
698  {
699  pudev->dev.class_cb->SetInterface (pudev, req);
700  }
701  else
702  {
703  USBD_EnumError(pudev, req);
704  }
705  break;
706 
707  default:
708  break;
709  }
710 }
711 
718 static void USBD_SynchFrame (USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
719 {
720  /* No handle... */
721 }
722 
723 
731 void USBD_ParseSetupRequest (USB_CORE_HANDLE *pudev, USB_DEVICE_REQ *req)
732 {
733  req->bmRequestType = *(uint8_t *) (pudev->dev.setup_packet);
734  req->bRequest = *(uint8_t *) (pudev->dev.setup_packet + 1);
735  req->wValue = SWAPBYTE (pudev->dev.setup_packet + 2);
736  req->wIndex = SWAPBYTE (pudev->dev.setup_packet + 4);
737  req->wLength = SWAPBYTE (pudev->dev.setup_packet + 6);
738 
739  pudev->dev.device_cur_state = USB_CTRL_SETUP;
740 }
741 
749 void USBD_EnumError (USB_CORE_HANDLE *pudev, USB_DEVICE_REQ *req)
750 {
751  USB_EP_Stall(pudev, EP0);
752 }
753 
754 
762 void USBD_GetUnicodeString (uint8_t *desc, uint8_t *unicode, uint16_t *len)
763 {
764  uint8_t idx = 1;
765 
766  if (desc != NULL)
767  {
768  unicode[idx++] = USB_DESCTYPE_STRING;
769 
770  for (; *desc != NULL; )
771  {
772  unicode[idx++] = *desc++;
773  unicode[idx++] = 0x00;
774  }
775 
776  *len = idx;
777  unicode[0] = *len;
778  }
779 }
780 
797 /************************ (C) COPYRIGHT 2014 GIGADEVICE *****END OF FILE****/
USBD_VdrDefReq
uint8_t USBD_VdrDefReq(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle usb vendor request.
Definition: usbd_enum.c:130
USB_Device_handle
Definition: usb_core.h:207
USBD_EnumError
void USBD_EnumError(USB_CORE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle usb enumeration error event.
Definition: usbd_enum.c:749
USBD_StdReq
uint8_t USBD_StdReq(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle usb standard device request.
Definition: usbd_enum.c:78
USB_EP_ClrStall
void USB_EP_ClrStall(USB_CORE_HANDLE *pudev, uint8_t EpID)
Clear endpoint stalled status.
Definition: usb_core.c:437
USB_CtlTransmitStatus
uint8_t USB_CtlTransmitStatus(USB_CORE_HANDLE *pudev)
Transmit status stage on the control pipe.
Definition: usb_core.c:570
USBD_DevClsReq
uint8_t USBD_DevClsReq(USB_DEVICE_HANDLE *pudev, USB_DEVICE_REQ *req)
Handle device class request.
Definition: usbd_enum.c:92
USBD_SetCfg
USBD_Status USBD_SetCfg(USB_DEVICE_HANDLE *pudev, uint8_t ConfigIndex)
Device configuration and interface setting.
Definition: usbd_core.c:263
USBD_Status
USBD_Status
USB device operation status.
Definition: usbd_core.h:40
USB_CtlTx
uint8_t USB_CtlTx(USB_CORE_HANDLE *pudev, uint8_t *pbuf, uint16_t Len)
Transmit data on the control pipe.
Definition: usb_core.c:504
USB_EP_Stall
void USB_EP_Stall(USB_CORE_HANDLE *pudev, uint8_t EpID)
Set an endpoint to STALL status.
Definition: usb_core.c:405
USBD_GetUnicodeString
void USBD_GetUnicodeString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
Convert normal string into unicode one.
Definition: usbd_enum.c:762
USBD_ParseSetupRequest
void USBD_ParseSetupRequest(USB_CORE_HANDLE *pudev, USB_DEVICE_REQ *req)
Decode setup data packet.
Definition: usbd_enum.c:731
usbd_enum.h
USB enumeration function prototypes.
USBD_ClrCfg
USBD_Status USBD_ClrCfg(USB_DEVICE_HANDLE *pudev, uint8_t ConfigIndex)
Clear current configuration.
Definition: usbd_core.c:279
usb_device_req
USB standard device request struct.
Definition: usb_core.h:120
Generated on Fri Feb 6 2015 14:56:36 for GD32F10x USB-Device by   doxygen 1.8.8
previous page start next page