1 /*
2 * Copyright (c) 2006-2024, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2024-07-09 QT-one first version
9 */
10
11 #include "drv_usbd.h"
12
13 #ifdef RT_USING_USB_DEVICE
14 #if !defined(BSP_USING_USBD)
15 #error "Please define at least one BSP_USING_USBD"
16 #endif
17
18 #if defined(BSP_USING_USBD)
19 #include "usb_port.h"
20 #endif
21
22 struct ht32_usbd
23 {
24 char *name;
25 USBDCore_TypeDef *p_usbd_code;
26 IRQn_Type irq;
27 };
28
29 __ALIGN4 USBDCore_TypeDef p_usbd;
30 /* internal mount point */
31 static struct ht32_usbd *p_usbd_instance = RT_NULL;
32
33 /* Endpoint Function List */
34 static struct ep_id endpoint_pool[] =
35 {
36 {0x00, USB_EP_ATTR_CONTROL, USB_DIR_INOUT, 64, ID_ASSIGNED },
37 {0x01, USB_EP_ATTR_BULK, USB_DIR_IN, 64, ID_UNASSIGNED},
38 {0x02, USB_EP_ATTR_BULK, USB_DIR_OUT, 64, ID_UNASSIGNED},
39 {0x03, USB_EP_ATTR_INT, USB_DIR_IN, 64, ID_UNASSIGNED},
40 {0x04, USB_EP_ATTR_INT, USB_DIR_OUT, 64, ID_UNASSIGNED},
41 {0x05, USB_EP_ATTR_ISOC, USB_DIR_IN, 64, ID_UNASSIGNED},
42 {0x06, USB_EP_ATTR_ISOC, USB_DIR_OUT, 64, ID_UNASSIGNED},
43 {0x07, USB_EP_ATTR_TYPE_MASK, USB_DIR_MASK, 64, ID_UNASSIGNED},
44 };
45
46 /* usbd Peripheral List */
47 static struct ht32_usbd usbd_config[] =
48 {
49 #ifdef BSP_USING_USBD
50 {
51 .name = BSP_USING_USBD_NAME,
52 .p_usbd_code = NULL,
53 .irq = USB_IRQn,
54 },
55 #endif
56 };
57
58 /* Start of Frame (SOF) interrupt callbacks */
usbd_sof_callback(USBDCore_TypeDef * pCore)59 void usbd_sof_callback(USBDCore_TypeDef *pCore)
60 {
61 udcd_t udcd = (udcd_t)pCore->pdata;
62 rt_usbd_sof_handler(udcd);
63 }
64 /* USB reset interrupt */
usbd_reset_callback(USBDCore_TypeDef * pCore)65 void usbd_reset_callback(USBDCore_TypeDef *pCore)
66 {
67 udcd_t udcd = (udcd_t)pCore->pdata;
68 rt_usbd_reset_handler(udcd);
69 }
70
71 /* USB Suspend (Disconnect) Interrupt */
usbd_suspend_callback(USBDCore_TypeDef * pCore)72 void usbd_suspend_callback(USBDCore_TypeDef *pCore)
73 {
74 udcd_t udcd = (udcd_t)pCore->pdata;
75 rt_usbd_disconnect_handler(udcd);
76 }
77
78 /* USB recovery (reconnect) interrupt */
usbd_resume_callback(USBDCore_TypeDef * pCore)79 void usbd_resume_callback(USBDCore_TypeDef *pCore)
80 {
81 udcd_t udcd = (udcd_t)pCore->pdata;
82 rt_usbd_connect_handler(udcd);
83 }
84
85 /* USB endpoint 0 interrupt */
usbd_setup_callback(USBDCore_TypeDef * pCore)86 void usbd_setup_callback(USBDCore_TypeDef *pCore)
87 {
88 udcd_t udcd = (udcd_t)pCore->pdata;
89 rt_usbd_ep0_setup_handler(udcd, (struct urequest *)&pCore->Device.Request);
90 }
91
92 /* Endpoint 0 input interrupt£¨Can be classified as other endpoint input interrupt£© */
usbd_ep0_in_callback(USBDCore_TypeDef * pCore)93 void usbd_ep0_in_callback(USBDCore_TypeDef *pCore)
94 {
95 udcd_t udcd = (udcd_t)pCore->pdata;
96 rt_usbd_ep0_in_handler(udcd);
97 }
98
99 /* Endpoint 0 output interrupt£¨Can be classified as other endpoint input interrupt£© */
usbd_ep0_out_callback(USBDCore_TypeDef * pCore)100 void usbd_ep0_out_callback(USBDCore_TypeDef *pCore)
101 {
102 udcd_t udcd = (udcd_t)pCore->pdata;
103 pCore->Device.Transfer.sByteLength = pCore->Device.Request.wLength;
104 rt_usbd_ep0_out_handler(udcd, pCore->Device.Transfer.sByteLength);
105 }
106
107 /* Other endpoint input interrupt */
usbd_ep_in_callback(USBDCore_TypeDef * pCore,USBD_EPTn_Enum EPTn)108 void usbd_ep_in_callback(USBDCore_TypeDef *pCore, USBD_EPTn_Enum EPTn)
109 {
110 udcd_t udcd = (udcd_t)pCore->pdata;
111 pCore->Device.Transfer.sByteLength = 0;
112 rt_usbd_ep_in_handler(udcd, EPTn | 0x80, pCore->Device.Transfer.sByteLength);
113 }
114
115 /* Other Endpoint Output Interrupt */
usbd_ep_out_callback(USBDCore_TypeDef * pCore,USBD_EPTn_Enum EPTn)116 void usbd_ep_out_callback(USBDCore_TypeDef *pCore, USBD_EPTn_Enum EPTn)
117 {
118 udcd_t udcd = (udcd_t)pCore->pdata;
119 rt_usbd_ep_out_handler(udcd, EPTn, pCore->ept_io->trans_len);
120 }
121
122 /* Setting the address */
ht32_set_address(rt_uint8_t address)123 static rt_err_t ht32_set_address(rt_uint8_t address)
124 {
125 /* Setting the device address */
126 p_usbd_instance->p_usbd_code->Info.CurrentStatus = USER_USB_STATE_ADDRESS;
127 API_USB_SET_ADDR(address);
128 return RT_EOK;
129 }
130 /* Configuration settings */
ht32_set_config(rt_uint8_t address)131 static rt_err_t ht32_set_config(rt_uint8_t address)
132 {
133 return RT_EOK;
134 }
135 /* endpoint pause */
ht32_ep_set_stall(rt_uint8_t address)136 static rt_err_t ht32_ep_set_stall(rt_uint8_t address)
137 {
138 if (0 == (address & 0x7f))
139 API_USB_EPTn_SEND_STALL((USBD_EPTn_Enum)(address & 0x7f));
140 else
141 API_USB_EPTn_SET_HALT((USBD_EPTn_Enum)(address & 0x7f));
142 return RT_EOK;
143 }
144 /* Endpoint reboot*/
ht32_ep_clear_stall(rt_uint8_t address)145 static rt_err_t ht32_ep_clear_stall(rt_uint8_t address)
146 {
147 if (0 != (address & 0x7f))
148 {
149 API_USB_EPTn_CLR_HALT((USBD_EPTn_Enum)(address & 0x7f));
150 API_USB_EPTn_CLR_DTG((USBD_EPTn_Enum)(address & 0x7f));
151 }
152 return RT_EOK;
153 }
154 /* endpoint enable */
ht32_ep_enable(struct uendpoint * ep)155 static rt_err_t ht32_ep_enable(struct uendpoint *ep)
156 {
157 /* Functions not found in the firmware library at the moment */
158 RT_ASSERT(ep != RT_NULL);
159 RT_ASSERT(ep->ep_desc != RT_NULL);
160 usbd_ep_enable(p_usbd_instance->p_usbd_code, ep->ep_desc->bEndpointAddress);
161 return RT_EOK;
162 }
163 /* endpoint incapacity */
ht32_ep_disable(struct uendpoint * ep)164 static rt_err_t ht32_ep_disable(struct uendpoint *ep)
165 {
166 /* Functions not found in the firmware library at the moment */
167 RT_ASSERT(ep != RT_NULL);
168 RT_ASSERT(ep->ep_desc != RT_NULL);
169 usbd_ep_disable(p_usbd_instance->p_usbd_code, ep->ep_desc->bEndpointAddress);
170 return RT_EOK;
171 }
172 /* Endpoint Receive Data Preparation */
ht32_ep_read_prepare(rt_uint8_t address,void * buffer,rt_size_t size)173 static rt_ssize_t ht32_ep_read_prepare(rt_uint8_t address, void *buffer, rt_size_t size)
174 {
175 USBDCore_EPTReadOUTData((USBD_EPTn_Enum)(address & 0x7f), (uint32_t *)buffer, size);
176 return size;
177 }
178 /* Endpoint reading data */
ht32_ep_read(rt_uint8_t address,void * buffer)179 static rt_ssize_t ht32_ep_read(rt_uint8_t address, void *buffer)
180 {
181 /* Do not read data from this function */
182 rt_size_t size = 0;
183 RT_ASSERT(buffer != RT_NULL);
184 return size;
185 }
186 /* Endpoint Write Data */
ht32_ep_write(rt_uint8_t address,void * buffer,rt_size_t size)187 static rt_ssize_t ht32_ep_write(rt_uint8_t address, void *buffer, rt_size_t size)
188 {
189 /* Use this function to write data to a USB endpoint */
190 return USBDCore_EPTWriteINData((USBD_EPTn_Enum)(address & 0x7f), (uint32_t *)buffer, size);
191 }
192 /* Endpoint 0 transmit status */
ht32_ep0_send_status(void)193 static rt_err_t ht32_ep0_send_status(void)
194 {
195 uint8_t Date = 0;
196 /* State of send endpoint 0 */
197 API_USB_EPTn_WRITE_IN(USBD_EPT0, (u32*)&Date, 0);
198 return RT_EOK;
199 }
200 /* USB pause */
ht32_suspend(void)201 static rt_err_t ht32_suspend(void)
202 {
203 return RT_EOK;
204 }
205 /* USB awakens */
ht32_wakeup(void)206 static rt_err_t ht32_wakeup(void)
207 {
208 return RT_EOK;
209 }
210
211 /* USB device interface function */
212 const static struct udcd_ops _udc_ops =
213 {
214 .set_address = ht32_set_address,
215 .set_config = ht32_set_config,
216 .ep_set_stall = ht32_ep_set_stall,
217 .ep_clear_stall = ht32_ep_clear_stall,
218 .ep_enable = ht32_ep_enable,
219 .ep_disable = ht32_ep_disable,
220 .ep_read_prepare = ht32_ep_read_prepare,
221 .ep_read = ht32_ep_read,
222 .ep_write = ht32_ep_write,
223 .ep0_send_status = ht32_ep0_send_status,
224 .suspend = ht32_suspend,
225 .wakeup = ht32_wakeup,
226 };
227
usbd_mainroutine(void)228 static void usbd_mainroutine(void)
229 {
230 USBDCore_MainRoutine(p_usbd_instance->p_usbd_code);
231 }
232 /* USB Device Initialisation Functions */
ht32_dcd_init(rt_device_t device)233 static rt_err_t ht32_dcd_init(rt_device_t device)
234 {
235 /* USB object and interface initialisation, and turning on USB interrupts */
236 USB_Configuration(p_usbd_instance->p_usbd_code);
237 rt_thread_idle_sethook(usbd_mainroutine);
238 return RT_EOK;
239 }
240
241 /* USB device registration function */
ht32_usbd_register(void)242 int ht32_usbd_register(void)
243 {
244 rt_size_t obj_num;
245 rt_err_t result = 0;
246 int index;
247 USBDCore_TypeDef *p_usbd_core = &p_usbd;
248 /* Calculate how many USB devices */
249 obj_num = sizeof(usbd_config) / sizeof(struct ht32_usbd);
250
251 for (index = 0; index < obj_num; index++)
252 {
253 /* Request a udcd object memory and clear it. */
254 udcd_t udcd = (udcd_t)rt_malloc(sizeof(struct udcd));
255 if (udcd == RT_NULL)
256 {
257 rt_kprintf("udcd malloc failed\r\n");
258 return -RT_ERROR;
259 }
260 rt_memset((void *)udcd, 0, sizeof(struct udcd));
261
262 /* Assigning a value to the requested udcd object */
263 udcd->parent.type = RT_Device_Class_USBDevice;
264 udcd->parent.init = ht32_dcd_init;
265 udcd->parent.user_data = p_usbd_core;
266 udcd->ops = &_udc_ops;
267
268 p_usbd_core->pdata = udcd;
269 usbd_config[index].p_usbd_code = p_usbd_core;
270
271 /* register endpoint infomation */
272 udcd->ep_pool = endpoint_pool;
273 udcd->ep0.id = &endpoint_pool[0];
274
275 result = rt_device_register((rt_device_t)udcd, usbd_config[index].name, 0);
276 RT_ASSERT(result == RT_EOK);
277
278 p_usbd_instance = &usbd_config[index];
279
280 result = rt_usb_device_init();
281 RT_ASSERT(result == RT_EOK);
282 }
283
284 return result;
285 }
286 INIT_DEVICE_EXPORT(ht32_usbd_register);
287
288
USB_IRQHandler(void)289 void USB_IRQHandler(void)
290 {
291 /* enter interrupt */
292 rt_interrupt_enter();
293
294 /* interrupt callback function */
295 usbd_irq_handler(p_usbd_instance->p_usbd_code);
296
297 /* leave interrupt */
298 rt_interrupt_leave();
299 }
300
301 #endif /* RT_USING_USB_DEVICE */
302