1 /*
2 * Copyright (c) 2006-2021, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2023-02-28 leo first version
9 */
10
11 #include <rtthread.h>
12 #include <rtdevice.h>
13 #include "drv_common.h"
14
15 #if defined(BSP_USING_DEVICE_USBOTG1) || defined(BSP_USING_DEVICE_USBOTG2)
16 #include "usbd_int.h"
17 #include "drv_usbotg.h"
18 #include "drv_config.h"
19
20 static struct at32_usbotg *p_usbotg_instance = RT_NULL;
21 static struct ep_id endpoint_pool[] =
22 {
23 {0x0, USB_EP_ATTR_CONTROL, USB_DIR_INOUT, 64, ID_ASSIGNED },
24 {0x1, USB_EP_ATTR_BULK, USB_DIR_IN, 64, ID_UNASSIGNED},
25 {0x1, USB_EP_ATTR_BULK, USB_DIR_OUT, 64, ID_UNASSIGNED},
26 {0x2, USB_EP_ATTR_INT, USB_DIR_IN, 64, ID_UNASSIGNED},
27 {0x2, USB_EP_ATTR_INT, USB_DIR_OUT, 64, ID_UNASSIGNED},
28 {0x3, USB_EP_ATTR_ISOC, USB_DIR_IN, 64, ID_UNASSIGNED},
29 {0x3, USB_EP_ATTR_ISOC, USB_DIR_OUT, 64, ID_UNASSIGNED},
30 {0xFF, USB_EP_ATTR_TYPE_MASK, USB_DIR_MASK, 0, ID_ASSIGNED },
31 };
32
33 enum
34 {
35 #ifdef BSP_USING_DEVICE_USBOTG1
36 USBOTG1_INDEX,
37 #endif
38 #ifdef BSP_USING_DEVICE_USBOTG2
39 USBOTG2_INDEX,
40 #endif
41 };
42
43 static struct at32_usbotg usbotgd_config[] = {
44 #ifdef BSP_USING_DEVICE_USBOTG1
45 USBOTG1_CONFIG,
46 #endif
47 #ifdef BSP_USING_DEVICE_USBOTG2
48 USBOTG2_CONFIG,
49 #endif
50 };
51
52 #ifdef BSP_USING_DEVICE_USBOTG1
OTGFS1_IRQHandler(void)53 void OTGFS1_IRQHandler(void)
54 {
55 /* enter interrupt */
56 rt_interrupt_enter();
57
58 usbd_irq_handler(p_usbotg_instance->p_otg_core);
59
60 /* leave interrupt */
61 rt_interrupt_leave();
62 }
63 #endif
64
65 #ifdef BSP_USING_DEVICE_USBOTG2
OTGFS2_IRQHandler(void)66 void OTGFS2_IRQHandler(void)
67 {
68 /* enter interrupt */
69 rt_interrupt_enter();
70
71 usbd_irq_handler(p_usbotg_instance->p_otg_core);
72
73 /* leave interrupt */
74 rt_interrupt_leave();
75 }
76 #endif
77
usbd_reset_callback(usbd_core_type * udev)78 void usbd_reset_callback(usbd_core_type *udev)
79 {
80 udcd_t udcd = (udcd_t)udev->pdata;
81 rt_usbd_reset_handler(udcd);
82 }
83
usbd_connectCallback(usbd_core_type * udev)84 void usbd_connectCallback(usbd_core_type *udev)
85 {
86 udcd_t udcd = (udcd_t)udev->pdata;
87 rt_usbd_connect_handler(udcd);
88 }
89
usbd_disconnectCallback(usbd_core_type * udev)90 void usbd_disconnectCallback(usbd_core_type *udev)
91 {
92 udcd_t udcd = (udcd_t)udev->pdata;
93 rt_usbd_disconnect_handler(udcd);
94 }
95
usbd_setup_phase_done_callback(usbd_core_type * udev)96 void usbd_setup_phase_done_callback(usbd_core_type *udev)
97 {
98 udcd_t udcd = (udcd_t)udev->pdata;
99 rt_usbd_ep0_setup_handler(udcd, (struct urequest*)udev->setup_buffer);
100 }
101
usbd_data_in_stage_callback(usbd_core_type * udev,uint32_t ept_num)102 void usbd_data_in_stage_callback(usbd_core_type *udev, uint32_t ept_num)
103 {
104 udcd_t udcd = (udcd_t)udev->pdata;
105
106 if (ept_num == 0)
107 {
108 rt_usbd_ep0_in_handler(udcd);
109 }
110 else
111 {
112 rt_usbd_ep_in_handler(udcd, 0x80 | ept_num, udev->ept_in[ept_num].trans_len);
113 }
114 }
115
usbd_sof_callback(usbd_core_type * udev)116 void usbd_sof_callback(usbd_core_type *udev)
117 {
118 udcd_t udcd = (udcd_t)udev->pdata;
119 rt_usbd_sof_handler(udcd);
120 }
121
usbd_data_out_stage_callback(usbd_core_type * udev,uint32_t ept_num)122 void usbd_data_out_stage_callback(usbd_core_type *udev, uint32_t ept_num)
123 {
124 udcd_t udcd = (udcd_t)udev->pdata;
125
126 if (ept_num != 0)
127 {
128 rt_usbd_ep_out_handler(udcd, ept_num, udev->ept_out[ept_num].trans_len);
129 }
130 else
131 {
132 rt_usbd_ep0_out_handler(udcd, udev->ept_out[0].trans_len);
133 }
134 }
135
_ep_set_stall(rt_uint8_t address)136 static rt_err_t _ep_set_stall(rt_uint8_t address)
137 {
138 usbd_set_stall(&p_usbotg_instance->p_otg_core->dev, address);
139 return RT_EOK;
140 }
141
_ep_clear_stall(rt_uint8_t address)142 static rt_err_t _ep_clear_stall(rt_uint8_t address)
143 {
144 usbd_clear_stall(&p_usbotg_instance->p_otg_core->dev, address);
145 return RT_EOK;
146 }
147
_set_address(rt_uint8_t address)148 static rt_err_t _set_address(rt_uint8_t address)
149 {
150 usbd_set_device_addr(&p_usbotg_instance->p_otg_core->dev, address);
151 return RT_EOK;
152 }
153
_set_config(rt_uint8_t address)154 static rt_err_t _set_config(rt_uint8_t address)
155 {
156 return RT_EOK;
157 }
158
_ep_enable(uep_t ep)159 static rt_err_t _ep_enable(uep_t ep)
160 {
161 RT_ASSERT(ep != RT_NULL);
162 RT_ASSERT(ep->ep_desc != RT_NULL);
163
164 usbd_ept_open(&p_usbotg_instance->p_otg_core->dev, ep->ep_desc->bEndpointAddress, \
165 ep->ep_desc->bmAttributes, ep->ep_desc->wMaxPacketSize);
166 return RT_EOK;
167 }
168
_ep_disable(uep_t ep)169 static rt_err_t _ep_disable(uep_t ep)
170 {
171 RT_ASSERT(ep != RT_NULL);
172 RT_ASSERT(ep->ep_desc != RT_NULL);
173
174 usbd_ept_close(&p_usbotg_instance->p_otg_core->dev, ep->ep_desc->bEndpointAddress);
175 return RT_EOK;
176 }
177
_ep_read(rt_uint8_t address,void * buffer)178 static rt_ssize_t _ep_read(rt_uint8_t address, void *buffer)
179 {
180 rt_size_t size = 0;
181 RT_ASSERT(buffer != RT_NULL);
182 return size;
183 }
184
_ep_read_prepare(rt_uint8_t address,void * buffer,rt_size_t size)185 static rt_ssize_t _ep_read_prepare(rt_uint8_t address, void *buffer, rt_size_t size)
186 {
187 usbd_ept_recv(&p_usbotg_instance->p_otg_core->dev, address, buffer, size);
188 return size;
189 }
190
_ep_write(rt_uint8_t address,void * buffer,rt_size_t size)191 static rt_ssize_t _ep_write(rt_uint8_t address, void *buffer, rt_size_t size)
192 {
193 usbd_ept_send(&p_usbotg_instance->p_otg_core->dev, address, buffer, size);
194 return size;
195 }
196
_ep0_send_status(void)197 static rt_err_t _ep0_send_status(void)
198 {
199 usbd_ept_send(&p_usbotg_instance->p_otg_core->dev, 0x00, RT_NULL, 0);
200 return RT_EOK;
201 }
202
_suspend(void)203 static rt_err_t _suspend(void)
204 {
205 return RT_EOK;
206 }
207
_wakeup(void)208 static rt_err_t _wakeup(void)
209 {
210 return RT_EOK;
211 }
212
at32_dcd_init(rt_device_t device)213 static rt_err_t at32_dcd_init(rt_device_t device)
214 {
215 /* usb gpio config */
216 at32_msp_usb_init(device);
217
218 /* enable otgfs irq */
219 nvic_irq_enable(p_usbotg_instance->irqn, 2, 0);
220
221 /* init usb */
222 p_usbotg_instance->p_otg_core->usb_reg = usb_global_select_core(p_usbotg_instance->id);
223
224 /* usb device core config */
225 usb_core_config(p_usbotg_instance->p_otg_core, p_usbotg_instance->dev_spd);
226
227 if(p_usbotg_instance->p_otg_core->cfg.sof_out)
228 {
229 p_usbotg_instance->p_otg_core->usb_reg->gccfg_bit.sofouten = TRUE;
230 }
231
232 if(p_usbotg_instance->p_otg_core->cfg.vbusig)
233 {
234 p_usbotg_instance->p_otg_core->usb_reg->gccfg_bit.vbusig = TRUE;
235 }
236
237 /* usb device core init */
238 usbd_core_init(&(p_usbotg_instance->p_otg_core->dev), p_usbotg_instance->p_otg_core->usb_reg,
239 p_usbotg_instance->dev_spd);
240
241 return RT_EOK;
242 }
243
244 const static struct udcd_ops _udc_ops =
245 {
246 _set_address,
247 _set_config,
248 _ep_set_stall,
249 _ep_clear_stall,
250 _ep_enable,
251 _ep_disable,
252 _ep_read_prepare,
253 _ep_read,
254 _ep_write,
255 _ep0_send_status,
256 _suspend,
257 _wakeup,
258 };
259
at32_usbd_register(void)260 int at32_usbd_register(void)
261 {
262 rt_size_t obj_num;
263 rt_err_t result = 0;
264 int index;
265
266 obj_num = sizeof(usbotgd_config) / sizeof(struct at32_usbotg);
267
268 for (index = 0; index < obj_num; index++) {
269 udcd_t udcd = (udcd_t)rt_malloc(sizeof(struct udcd));
270 if (udcd == RT_NULL)
271 {
272 rt_kprintf("uhcd malloc failed\r\n");
273 return -RT_ERROR;
274 }
275 rt_memset((void *)udcd, 0, sizeof(struct udcd));
276
277 otg_core_type *p_otg_core = (otg_core_type *)rt_malloc(sizeof(otg_core_type));
278 if (p_otg_core == RT_NULL)
279 {
280 rt_kprintf("otg_core malloc failed\r\n");
281 return -RT_ERROR;
282 }
283 rt_memset((void *)p_otg_core, 0, sizeof(otg_core_type));
284
285 udcd->parent.type = RT_Device_Class_USBDevice;
286 udcd->parent.init = at32_dcd_init;
287
288 udcd->parent.user_data = &(p_otg_core->dev);
289 udcd->ops = &_udc_ops;
290 p_otg_core->dev.pdata = udcd;
291 usbotgd_config[index].p_otg_core = p_otg_core;
292
293 /* register endpoint infomation */
294 udcd->ep_pool = endpoint_pool;
295 udcd->ep0.id = &endpoint_pool[0];
296
297 result = rt_device_register((rt_device_t)udcd, usbotgd_config[index].name, 0);
298 RT_ASSERT(result == RT_EOK);
299
300 p_usbotg_instance = &usbotgd_config[index];
301
302 result = rt_usb_device_init();
303 RT_ASSERT(result == RT_EOK);
304 }
305
306 return result;
307 }
308
309 INIT_DEVICE_EXPORT(at32_usbd_register);
310
311 #endif
312