1 /*
2  * Copyright (c) 2022-2025 HPMicro
3  *
4  * SPDX-License-Identifier: BSD-3-Clause
5  *
6  */
7 #include "usbd_core.h"
8 #include "hpm_usb_device.h"
9 #include "usb_glue_hpm.h"
10 
11 #define USB_NUM_BIDIR_ENDPOINTS USB_SOC_DCD_MAX_ENDPOINT_COUNT
12 
13 /* USBSTS, USBINTR */
14 enum {
15     intr_usb = USB_USBINTR_UE_MASK,
16     intr_error = USB_USBINTR_UEE_MASK,
17     intr_port_change = USB_USBINTR_PCE_MASK,
18     intr_reset = USB_USBINTR_URE_MASK,
19     intr_sof = USB_USBINTR_SRE_MASK,
20     intr_suspend = USB_USBINTR_SLE_MASK,
21     intr_nak = USB_USBINTR_NAKE_MASK,
22 };
23 
24 /* Endpoint state */
25 struct hpm_ep_state {
26     uint16_t ep_mps;    /* Endpoint max packet size */
27     uint8_t ep_type;    /* Endpoint type */
28     uint8_t ep_stalled; /* Endpoint stall flag */
29     uint8_t ep_enable;  /* Endpoint enable */
30     uint8_t *xfer_buf;
31     uint32_t xfer_len;
32     uint32_t actual_xfer_len;
33 };
34 
35 /*---------------------------------------------------------------------*
36  * Variable Definitions
37  *---------------------------------------------------------------------*/
38 /* Driver state */
39 struct hpm_udc {
40     usb_device_handle_t *handle;
41     bool is_suspend;
42     struct hpm_ep_state in_ep[USB_NUM_BIDIR_ENDPOINTS];  /*!< IN endpoint parameters*/
43     struct hpm_ep_state out_ep[USB_NUM_BIDIR_ENDPOINTS]; /*!< OUT endpoint parameters */
44 } g_hpm_udc[CONFIG_USBDEV_MAX_BUS];
45 
46 static USB_NOCACHE_RAM_SECTION ATTR_ALIGN(USB_SOC_DCD_DATA_RAM_ADDRESS_ALIGNMENT)
47     uint8_t _dcd_data[CONFIG_USBDEV_MAX_BUS][HPM_ALIGN_UP(sizeof(dcd_data_t), USB_SOC_DCD_DATA_RAM_ADDRESS_ALIGNMENT)];
48 static USB_NOCACHE_RAM_SECTION usb_device_handle_t usb_device_handle[CONFIG_USBDEV_MAX_BUS];
49 
50 /* Index to bit position in register */
ep_idx2bit(uint8_t ep_idx)51 static inline uint8_t ep_idx2bit(uint8_t ep_idx)
52 {
53     return ep_idx / 2 + ((ep_idx % 2) ? 16 : 0);
54 }
55 
usb_dc_isr_connect(uint8_t busid)56 static void usb_dc_isr_connect(uint8_t busid)
57 {
58     if (g_usbdev_bus[busid].reg_base == HPM_USB0_BASE) {
59         g_usb_hpm_busid[0] = busid;
60         g_usb_hpm_irq[0] = USBD_IRQHandler;
61 
62         hpm_usb_isr_enable(HPM_USB0_BASE);
63     } else {
64 #ifdef HPM_USB1_BASE
65         g_usb_hpm_busid[1] = busid;
66         g_usb_hpm_irq[1] = USBD_IRQHandler;
67 
68         hpm_usb_isr_enable(HPM_USB1_BASE);
69 #endif
70     }
71 }
72 
usb_dc_isr_disconnect(uint8_t busid)73 static void usb_dc_isr_disconnect(uint8_t busid)
74 {
75     if (g_usbdev_bus[busid].reg_base == HPM_USB0_BASE) {
76         hpm_usb_isr_disable(HPM_USB0_BASE);
77 
78         g_usb_hpm_busid[0] = 0;
79         g_usb_hpm_irq[0] = NULL;
80     } else {
81 #ifdef HPM_USB1_BASE
82         hpm_usb_isr_disable(HPM_USB1_BASE);
83 
84         g_usb_hpm_busid[1] = 0;
85         g_usb_hpm_irq[1] = NULL;
86 #endif
87     }
88 }
89 
usb_dc_init(uint8_t busid)90 int usb_dc_init(uint8_t busid)
91 {
92     memset(&g_hpm_udc[busid], 0, sizeof(struct hpm_udc));
93     g_hpm_udc[busid].handle = &usb_device_handle[busid];
94     g_hpm_udc[busid].handle->regs = (USB_Type *)g_usbdev_bus[busid].reg_base;
95     g_hpm_udc[busid].handle->dcd_data = (dcd_data_t *)&_dcd_data[busid][0];
96 
97     uint32_t int_mask;
98     int_mask = (intr_usb | intr_error |intr_port_change | intr_reset | intr_suspend);
99 
100 #ifdef CONFIG_USBDEV_SOF_ENABLE
101     int_mask |= intr_sof;
102 #endif
103 
104     usb_device_init(g_hpm_udc[busid].handle, int_mask);
105 
106     usb_dc_isr_connect(busid);
107 
108     return 0;
109 }
110 
usb_dc_deinit(uint8_t busid)111 int usb_dc_deinit(uint8_t busid)
112 {
113     usb_dc_isr_disconnect(busid);
114 
115     usb_device_deinit(g_hpm_udc[busid].handle);
116 
117     return 0;
118 }
119 
usbd_set_address(uint8_t busid,const uint8_t addr)120 int usbd_set_address(uint8_t busid, const uint8_t addr)
121 {
122     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
123     usb_dcd_set_address(handle->regs, addr);
124     return 0;
125 }
126 
usbd_set_remote_wakeup(uint8_t busid)127 int usbd_set_remote_wakeup(uint8_t busid)
128 {
129     USB_Type *ptr;
130 
131     ptr = g_hpm_udc[busid].handle->regs;
132 
133     if (!usb_get_suspend_status(ptr)) {
134         return -1;
135     }
136 
137     usb_force_port_resume(ptr);
138 
139     return 0;
140 }
141 
usbd_execute_test_mode(uint8_t busid,uint8_t test_mode)142 void usbd_execute_test_mode(uint8_t busid, uint8_t test_mode)
143 {
144     usb_set_port_test_mode(g_hpm_udc[busid].handle->regs, test_mode);
145 }
146 
usbd_get_port_speed(uint8_t busid)147 uint8_t usbd_get_port_speed(uint8_t busid)
148 {
149     uint8_t speed;
150 
151     speed = usb_get_port_speed(g_hpm_udc[busid].handle->regs);
152 
153     if (speed == 0x00) {
154         return USB_SPEED_FULL;
155     }
156     if (speed == 0x01) {
157         return USB_SPEED_LOW;
158     }
159     if (speed == 0x02) {
160         return USB_SPEED_HIGH;
161     }
162 
163     return 0;
164 }
165 
usbd_ep_open(uint8_t busid,const struct usb_endpoint_descriptor * ep)166 int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep)
167 {
168     usb_endpoint_config_t tmp_ep_cfg;
169     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
170     uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
171 
172     tmp_ep_cfg.xfer = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
173     tmp_ep_cfg.ep_addr = ep->bEndpointAddress;
174     tmp_ep_cfg.max_packet_size = ep->wMaxPacketSize;
175 
176     usb_device_edpt_open(handle, &tmp_ep_cfg);
177 
178     if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
179         g_hpm_udc[busid].out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
180         g_hpm_udc[busid].out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
181         g_hpm_udc[busid].out_ep[ep_idx].ep_enable = true;
182     } else {
183         g_hpm_udc[busid].in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
184         g_hpm_udc[busid].in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
185         g_hpm_udc[busid].in_ep[ep_idx].ep_enable = true;
186     }
187 
188     return 0;
189 }
190 
usbd_ep_close(uint8_t busid,const uint8_t ep)191 int usbd_ep_close(uint8_t busid, const uint8_t ep)
192 {
193     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
194     uint8_t ep_idx = USB_EP_GET_IDX(ep);
195 
196     if (USB_EP_DIR_IS_OUT(ep)) {
197         g_hpm_udc[busid].out_ep[ep_idx].ep_enable = false;
198     } else {
199         g_hpm_udc[busid].in_ep[ep_idx].ep_enable = false;
200     }
201 
202     usb_device_edpt_close(handle, ep);
203 
204     return 0;
205 }
206 
usbd_ep_set_stall(uint8_t busid,const uint8_t ep)207 int usbd_ep_set_stall(uint8_t busid, const uint8_t ep)
208 {
209     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
210 
211     usb_device_edpt_stall(handle, ep);
212     return 0;
213 }
214 
usbd_ep_clear_stall(uint8_t busid,const uint8_t ep)215 int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep)
216 {
217     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
218 
219     usb_device_edpt_clear_stall(handle, ep);
220     return 0;
221 }
222 
usbd_ep_is_stalled(uint8_t busid,const uint8_t ep,uint8_t * stalled)223 int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled)
224 {
225     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
226 
227     *stalled = usb_device_edpt_check_stall(handle, ep);
228     return 0;
229 }
230 
usbd_ep_start_write(uint8_t busid,const uint8_t ep,const uint8_t * data,uint32_t data_len)231 int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len)
232 {
233     uint8_t ep_idx = USB_EP_GET_IDX(ep);
234     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
235 
236     if (!data && data_len) {
237         return -1;
238     }
239     if (!g_hpm_udc[busid].in_ep[ep_idx].ep_enable) {
240         return -2;
241     }
242 
243     g_hpm_udc[busid].in_ep[ep_idx].xfer_buf = (uint8_t *)data;
244     g_hpm_udc[busid].in_ep[ep_idx].xfer_len = data_len;
245     g_hpm_udc[busid].in_ep[ep_idx].actual_xfer_len = 0;
246 
247     usb_device_edpt_xfer(handle, ep, (uint8_t *)data, data_len);
248 
249     return 0;
250 }
251 
usbd_ep_start_read(uint8_t busid,const uint8_t ep,uint8_t * data,uint32_t data_len)252 int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len)
253 {
254     uint8_t ep_idx = USB_EP_GET_IDX(ep);
255     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
256 
257     if (!data && data_len) {
258         return -1;
259     }
260     if (!g_hpm_udc[busid].out_ep[ep_idx].ep_enable) {
261         return -2;
262     }
263 
264     g_hpm_udc[busid].out_ep[ep_idx].xfer_buf = (uint8_t *)data;
265     g_hpm_udc[busid].out_ep[ep_idx].xfer_len = data_len;
266     g_hpm_udc[busid].out_ep[ep_idx].actual_xfer_len = 0;
267 
268     usb_device_edpt_xfer(handle, ep, data, data_len);
269 
270     return 0;
271 }
272 
USBD_IRQHandler(uint8_t busid)273 void USBD_IRQHandler(uint8_t busid)
274 {
275     uint32_t int_status;
276     usb_device_handle_t *handle = g_hpm_udc[busid].handle;
277     uint32_t transfer_len;
278     bool ep_cb_req;
279 
280     /* Acknowledge handled interrupt */
281     int_status = usb_device_status_flags(handle);
282     int_status &= usb_device_interrupts(handle);
283     usb_device_clear_status_flags(handle, int_status);
284 
285     if (int_status & intr_error) {
286         USB_LOG_ERR("usbd intr error!\r\n");
287     }
288 
289 #ifdef CONFIG_USBDEV_SOF_ENABLE
290     if (int_status & intr_sof) {
291         usbd_event_sof_handler(busid);
292     }
293 #endif
294 
295     if (int_status & intr_reset) {
296         g_hpm_udc[busid].is_suspend = false;
297         memset(g_hpm_udc[busid].in_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS);
298         memset(g_hpm_udc[busid].out_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS);
299         usbd_event_reset_handler(busid);
300         usb_device_bus_reset(handle, 64);
301     }
302 
303     if (int_status & intr_suspend) {
304         if (usb_device_get_suspend_status(handle)) {
305             /* Note: Host may delay more than 3 ms before and/or after bus reset before doing enumeration. */
306             if (usb_device_get_address(handle)) {
307                 g_hpm_udc[busid].is_suspend = true;
308                 usbd_event_suspend_handler(busid);
309             }
310         } else {
311         }
312     }
313 
314     if (int_status & intr_port_change) {
315         if (!usb_device_get_port_ccs(handle)) {
316             usbd_event_disconnect_handler(busid);
317         } else {
318             if (g_hpm_udc[busid].is_suspend) {
319                 g_hpm_udc[busid].is_suspend = false;
320                 usbd_event_resume_handler(busid);
321             }
322             usbd_event_connect_handler(busid);
323         }
324     }
325 
326     if (int_status & intr_usb) {
327         uint32_t const edpt_complete = usb_device_get_edpt_complete_status(handle);
328         uint32_t const edpt_setup_status = usb_device_get_setup_status(handle);
329 
330         if (edpt_complete) {
331             usb_device_clear_edpt_complete_status(handle, edpt_complete);
332             for (uint8_t ep_idx = 0; ep_idx < USB_SOS_DCD_MAX_QHD_COUNT; ep_idx++) {
333                 if (edpt_complete & (1 << ep_idx2bit(ep_idx))) {
334                     transfer_len = 0;
335                     ep_cb_req = true;
336 
337                     /* Failed QTD also get ENDPTCOMPLETE set */
338                     dcd_qhd_t *p_qhd = usb_device_qhd_get(handle, ep_idx);
339                     dcd_qtd_t *p_qtd = p_qhd->attached_qtd;
340                     while (1) {
341                         if (p_qtd->halted || p_qtd->xact_err || p_qtd->buffer_err) {
342                             USB_LOG_ERR("usbd transfer error!\r\n");
343                             ep_cb_req = false;
344                             break;
345                         } else if (p_qtd->active) {
346                             ep_cb_req = false;
347                             break;
348                         } else {
349                             transfer_len += p_qtd->expected_bytes - p_qtd->total_bytes;
350                             p_qtd->in_use = false;
351                         }
352 
353                         if (p_qtd->next == USB_SOC_DCD_QTD_NEXT_INVALID) {
354                             break;
355                         } else {
356                             p_qtd = (dcd_qtd_t *)p_qtd->next;
357                         }
358                     }
359 
360                     if (ep_cb_req) {
361                         uint8_t const ep_addr = (ep_idx / 2) | ((ep_idx & 0x01) ? 0x80 : 0);
362                         if (ep_addr & 0x80) {
363                             usbd_event_ep_in_complete_handler(busid, ep_addr, transfer_len);
364                         } else {
365                             usbd_event_ep_out_complete_handler(busid, ep_addr, transfer_len);
366                         }
367                     }
368                 }
369             }
370         }
371 
372         if (edpt_setup_status) {
373             /*------------- Set up Received -------------*/
374             usb_device_clear_setup_status(handle, edpt_setup_status);
375             dcd_qhd_t *qhd0 = usb_device_qhd_get(handle, 0);
376             usbd_event_ep0_setup_complete_handler(busid, (uint8_t *)&qhd0->setup_request);
377         }
378     }
379 }