请教stm32 usb虚拟串口程序移植到gd32的问题

使用的是 libopencm3的库 和 它的例子, 就是个简单的usb虚拟串口, 能够回显输入的内容。
把其中的 rcc_clock_setup_in_hse_8mhz_out_72mhz(); 改成 rcc_clock_setup_in_hse_12mhz_out_72mhz(); 就能识别设备了， 但用putty打开后一开始输入的一些字符能回显， 但是很快就不再显示了。 同样的程序在stm32上面正常。 请教这是什么原因呢? 多谢了

https://raw.githubusercontent.com/libopencm3/libopencm3-examples/master/examples/stm32/f1/stm32-maple/usb_cdcacm/cdcacm.c

1. /*
   
2. * This file is part of the libopencm3 project.
   
3. *
   
4. * Copyright (C) 2010 Gareth McMullin <gareth@blacksphere.co.nz>
   
5. *
   
6. * This library is free software: you can redistribute it and/or modify
   
7. * it under the terms of the GNU Lesser General Public License as published by
   
8. * the Free Software Foundation, either version 3 of the License, or
   
9. * (at your option) any later version.
   
10. *
    
11. * This library is distributed in the hope that it will be useful,
    
12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
14. * GNU Lesser General Public License for more details.
    
15. *
    
16. * You should have received a copy of the GNU Lesser General Public License
    
17. * along with this library.  If not, see <http://www.gnu.org/licenses/>.
    
18. */
    
19. 
    
20. #include <stdlib.h>
    
21. #include <libopencm3/stm32/rcc.h>
    
22. #include <libopencm3/stm32/gpio.h>
    
23. #include <libopencm3/usb/usbd.h>
    
24. #include <libopencm3/usb/cdc.h>
    
25. #include <libopencm3/cm3/scb.h>
    
26. 
    
27. static const struct usb_device_descriptor dev = {
    
28.         .bLength = USB_DT_DEVICE_SIZE,
    
29.         .bDescriptorType = USB_DT_DEVICE,
    
30.         .bcdUSB = 0x0200,
    
31.         .bDeviceClass = USB_CLASS_CDC,
    
32.         .bDeviceSubClass = 0,
    
33.         .bDeviceProtocol = 0,
    
34.         .bMaxPacketSize0 = 64,
    
35.         .idVendor = 0x0483,
    
36.         .idProduct = 0x5740,
    
37.         .bcdDevice = 0x0200,
    
38.         .iManufacturer = 1,
    
39.         .iProduct = 2,
    
40.         .iSerialNumber = 3,
    
41.         .bNumConfigurations = 1,
    
42. };
    
43. 
    
44. /*
    
45. * This notification endpoint isn't implemented. According to CDC spec its
    
46. * optional, but its absence causes a NULL pointer dereference in Linux
    
47. * cdc_acm driver.
    
48. */
    
49. static const struct usb_endpoint_descriptor comm_endp[] = {{
    
50.         .bLength = USB_DT_ENDPOINT_SIZE,
    
51.         .bDescriptorType = USB_DT_ENDPOINT,
    
52.         .bEndpointAddress = 0x83,
    
53.         .bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
    
54.         .wMaxPacketSize = 16,
    
55.         .bInterval = 255,
    
56. }};
    
57. 
    
58. static const struct usb_endpoint_descriptor data_endp[] = {{
    
59.         .bLength = USB_DT_ENDPOINT_SIZE,
    
60.         .bDescriptorType = USB_DT_ENDPOINT,
    
61.         .bEndpointAddress = 0x01,
    
62.         .bmAttributes = USB_ENDPOINT_ATTR_BULK,
    
63.         .wMaxPacketSize = 64,
    
64.         .bInterval = 1,
    
65. }, {
    
66.         .bLength = USB_DT_ENDPOINT_SIZE,
    
67.         .bDescriptorType = USB_DT_ENDPOINT,
    
68.         .bEndpointAddress = 0x82,
    
69.         .bmAttributes = USB_ENDPOINT_ATTR_BULK,
    
70.         .wMaxPacketSize = 64,
    
71.         .bInterval = 1,
    
72. }};
    
73. 
    
74. static const struct {
    
75.         struct usb_cdc_header_descriptor header;
    
76.         struct usb_cdc_call_management_descriptor call_mgmt;
    
77.         struct usb_cdc_acm_descriptor acm;
    
78.         struct usb_cdc_union_descriptor cdc_union;
    
79. } __attribute__((packed)) cdcacm_functional_descriptors = {
    
80.         .header = {
    
81.                 .bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
    
82.                 .bDescriptorType = CS_INTERFACE,
    
83.                 .bDescriptorSubtype = USB_CDC_TYPE_HEADER,
    
84.                 .bcdCDC = 0x0110,
    
85.         },
    
86.         .call_mgmt = {
    
87.                 .bFunctionLength =
    
88.                         sizeof(struct usb_cdc_call_management_descriptor),
    
89.                 .bDescriptorType = CS_INTERFACE,
    
90.                 .bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
    
91.                 .bmCapabilities = 0,
    
92.                 .bDataInterface = 1,
    
93.         },
    
94.         .acm = {
    
95.                 .bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
    
96.                 .bDescriptorType = CS_INTERFACE,
    
97.                 .bDescriptorSubtype = USB_CDC_TYPE_ACM,
    
98.                 .bmCapabilities = 0,
    
99.         },
    
100.         .cdc_union = {
     
101.                 .bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
     
102.                 .bDescriptorType = CS_INTERFACE,
     
103.                 .bDescriptorSubtype = USB_CDC_TYPE_UNION,
     
104.                 .bControlInterface = 0,
     
105.                 .bSubordinateInterface0 = 1,
     
106.          },
     
107. };
     
108. 
     
109. static const struct usb_interface_descriptor comm_iface[] = {{
     
110.         .bLength = USB_DT_INTERFACE_SIZE,
     
111.         .bDescriptorType = USB_DT_INTERFACE,
     
112.         .bInterfaceNumber = 0,
     
113.         .bAlternateSetting = 0,
     
114.         .bNumEndpoints = 1,
     
115.         .bInterfaceClass = USB_CLASS_CDC,
     
116.         .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
     
117.         .bInterfaceProtocol = USB_CDC_PROTOCOL_AT,
     
118.         .iInterface = 0,
     
119. 
     
120.         .endpoint = comm_endp,
     
121. 
     
122.         .extra = &cdcacm_functional_descriptors,
     
123.         .extralen = sizeof(cdcacm_functional_descriptors),
     
124. }};
     
125. 
     
126. static const struct usb_interface_descriptor data_iface[] = {{
     
127.         .bLength = USB_DT_INTERFACE_SIZE,
     
128.         .bDescriptorType = USB_DT_INTERFACE,
     
129.         .bInterfaceNumber = 1,
     
130.         .bAlternateSetting = 0,
     
131.         .bNumEndpoints = 2,
     
132.         .bInterfaceClass = USB_CLASS_DATA,
     
133.         .bInterfaceSubClass = 0,
     
134.         .bInterfaceProtocol = 0,
     
135.         .iInterface = 0,
     
136. 
     
137.         .endpoint = data_endp,
     
138. }};
     
139. 
     
140. static const struct usb_interface ifaces[] = {{
     
141.         .num_altsetting = 1,
     
142.         .altsetting = comm_iface,
     
143. }, {
     
144.         .num_altsetting = 1,
     
145.         .altsetting = data_iface,
     
146. }};
     
147. 
     
148. static const struct usb_config_descriptor config = {
     
149.         .bLength = USB_DT_CONFIGURATION_SIZE,
     
150.         .bDescriptorType = USB_DT_CONFIGURATION,
     
151.         .wTotalLength = 0,
     
152.         .bNumInterfaces = 2,
     
153.         .bConfigurationValue = 1,
     
154.         .iConfiguration = 0,
     
155.         .bmAttributes = 0x80,
     
156.         .bMaxPower = 0x32,
     
157. 
     
158.         .interface = ifaces,
     
159. };
     
160. 
     
161. static const char *usb_strings[] = {
     
162.         "Black Sphere Technologies",
     
163.         "CDC-ACM Demo",
     
164.         "DEMO",
     
165. };
     
166. 
     
167. /* Buffer to be used for control requests. */
     
168. uint8_t usbd_control_buffer[128];
     
169. 
     
170. static int cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, uint8_t **buf,
     
171.                 uint16_t *len, void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req))
     
172. {
     
173.         (void)complete;
     
174.         (void)buf;
     
175.         (void)usbd_dev;
     
176. 
     
177.         switch (req->bRequest) {
     
178.         case USB_CDC_REQ_SET_CONTROL_LINE_STATE: {
     
179.                 /*
     
180.                  * This Linux cdc_acm driver requires this to be implemented
     
181.                  * even though it's optional in the CDC spec, and we don't
     
182.                  * advertise it in the ACM functional descriptor.
     
183.                  */
     
184.                 char local_buf[10];
     
185.                 struct usb_cdc_notification *notif = (void *)local_buf;
     
186. 
     
187.                 /* We echo signals back to host as notification. */
     
188.                 notif->bmRequestType = 0xA1;
     
189.                 notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE;
     
190.                 notif->wValue = 0;
     
191.                 notif->wIndex = 0;
     
192.                 notif->wLength = 2;
     
193.                 local_buf[8] = req->wValue & 3;
     
194.                 local_buf[9] = 0;
     
195.                 // usbd_ep_write_packet(0x83, buf, 10);
     
196.                 return 1;
     
197.                 }
     
198.         case USB_CDC_REQ_SET_LINE_CODING:
     
199.                 if (*len < sizeof(struct usb_cdc_line_coding))
     
200.                         return 0;
     
201.                 return 1;
     
202.         }
     
203.         return 0;
     
204. }
     
205. 
     
206. static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
     
207. {
     
208.         (void)ep;
     
209.         (void)usbd_dev;
     
210. 
     
211.         char buf[64];
     
212.         int len = usbd_ep_read_packet(usbd_dev, 0x01, buf, 64);
     
213. 
     
214.         if (len) {
     
215.                 usbd_ep_write_packet(usbd_dev, 0x82, buf, len);
     
216.                 buf[len] = 0;
     
217.         }
     
218. }
     
219. 
     
220. static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
     
221. {
     
222.         (void)wValue;
     
223.         (void)usbd_dev;
     
224. 
     
225.         usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
     
226.         usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, NULL);
     
227.         usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
     
228. 
     
229.         usbd_register_control_callback(
     
230.                                 usbd_dev,
     
231.                                 USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE,
     
232.                                 USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
     
233.                                 cdcacm_control_request);
     
234. }
     
235. 
     
236. int main(void)
     
237. {
     
238.         int i;
     
239. 
     
240.         usbd_device *usbd_dev;
     
241. 
     
242.         SCB_VTOR = (uint32_t) 0x08005000;
     
243. 
     
244.         rcc_clock_setup_in_hse_8mhz_out_72mhz();
     
245. 
     
246.         rcc_periph_clock_enable(RCC_GPIOA);
     
247.         rcc_periph_clock_enable(RCC_GPIOC);
     
248. 
     
249.         /* Setup GPIOC Pin 12 to pull up the D+ high, so autodect works
     
250.          * with the bootloader.  The circuit is active low. */
     
251.         gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_2_MHZ,
     
252.                       GPIO_CNF_OUTPUT_OPENDRAIN, GPIO12);
     
253.         gpio_clear(GPIOC, GPIO12);
     
254. 
     
255.         /* Setup GPIOA Pin 5 for the LED */
     
256.         gpio_set(GPIOA, GPIO5);
     
257.         gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ,
     
258.                       GPIO_CNF_OUTPUT_PUSHPULL, GPIO5);
     
259. 
     
260.         usbd_dev = usbd_init(&st_usbfs_v1_usb_driver, &dev, &config, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer));
     
261.         usbd_register_set_config_callback(usbd_dev, cdcacm_set_config);
     
262. 
     
263.         for (i = 0; i < 0x800000; i++)
     
264.                 __asm__("nop");
     
265.         gpio_clear(GPIOA, GPIO5);
     
266. 
     
267.         while (1)
     
268.                 usbd_poll(usbd_dev);
     
269. }

复制代码

没人知道么，看来还是不能用gd的产品啊