1 #include "usbd_core.h"
2 #include "hpm_usb_device.h"
3 #include "board.h"
4
5 #ifndef USBD_IRQHandler
6 #define USBD_IRQHandler USBD_IRQHandler // use actual usb irq name instead
7 #endif
8
9 #ifndef USB_NUM_BIDIR_ENDPOINTS
10 #define USB_NUM_BIDIR_ENDPOINTS USB_SOC_DCD_MAX_ENDPOINT_COUNT
11 #endif
12
13 #if !defined(CONFIG_HPM_USBD_BASE) || !defined(CONFIG_HPM_USBD_IRQn)
14 #error "hpm dcd must config CONFIG_HPM_USBD_BASE and CONFIG_HPM_USBD_IRQn"
15 #endif
16
17 /* USBSTS, USBINTR */
18 enum {
19 intr_usb = HPM_BITSMASK(1, 0),
20 intr_error = HPM_BITSMASK(1, 1),
21 intr_port_change = HPM_BITSMASK(1, 2),
22 intr_reset = HPM_BITSMASK(1, 6),
23 intr_sof = HPM_BITSMASK(1, 7),
24 intr_suspend = HPM_BITSMASK(1, 8),
25 intr_nak = HPM_BITSMASK(1, 16)
26 };
27
28 /* Endpoint state */
29 struct hpm_ep_state {
30 uint16_t ep_mps; /* Endpoint max packet size */
31 uint8_t ep_type; /* Endpoint type */
32 uint8_t ep_stalled; /* Endpoint stall flag */
33 uint8_t ep_enable; /* Endpoint enable */
34 uint8_t *xfer_buf;
35 uint32_t xfer_len;
36 uint32_t actual_xfer_len;
37 };
38
39 /* Driver state */
40 struct hpm_udc {
41 usb_device_handle_t *handle;
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;
45
46 static ATTR_PLACE_AT_NONCACHEABLE_WITH_ALIGNMENT(USB_SOC_DCD_DATA_RAM_ADDRESS_ALIGNMENT) dcd_data_t _dcd_data;
47 static ATTR_PLACE_AT_NONCACHEABLE usb_device_handle_t usb_device_handle[USB_SOC_MAX_COUNT];
48
49 /* Index to bit position in register */
ep_idx2bit(uint8_t ep_idx)50 static inline uint8_t ep_idx2bit(uint8_t ep_idx)
51 {
52 return ep_idx / 2 + ((ep_idx % 2) ? 16 : 0);
53 }
54
usb_dc_low_level_init(void)55 __WEAK void usb_dc_low_level_init(void)
56 {
57 }
58
usb_dc_low_level_deinit(void)59 __WEAK void usb_dc_low_level_deinit(void)
60 {
61 }
62
usb_dc_init(void)63 int usb_dc_init(void)
64 {
65 usb_dc_low_level_init();
66
67 memset(&g_hpm_udc, 0, sizeof(struct hpm_udc));
68 g_hpm_udc.handle = &usb_device_handle[0];
69 g_hpm_udc.handle->regs = (USB_Type *)CONFIG_HPM_USBD_BASE;
70 g_hpm_udc.handle->dcd_data = &_dcd_data;
71
72 uint32_t int_mask;
73 int_mask = (USB_USBINTR_UE_MASK | USB_USBINTR_UEE_MASK |
74 USB_USBINTR_PCE_MASK | USB_USBINTR_URE_MASK);
75
76 usb_device_init(g_hpm_udc.handle, int_mask);
77
78 intc_m_enable_irq(CONFIG_HPM_USBD_IRQn);
79 return 0;
80 }
81
usb_dc_deinit(void)82 int usb_dc_deinit(void)
83 {
84 intc_m_disable_irq(CONFIG_HPM_USBD_IRQn);
85
86 usb_device_deinit(g_hpm_udc.handle);
87
88 return 0;
89 }
90
usbd_set_address(const uint8_t addr)91 int usbd_set_address(const uint8_t addr)
92 {
93 usb_device_handle_t *handle = g_hpm_udc.handle;
94 usb_dcd_set_address(handle->regs, addr);
95 return 0;
96 }
97
usbd_get_port_speed(const uint8_t port)98 uint8_t usbd_get_port_speed(const uint8_t port)
99 {
100 (void)port;
101 uint8_t speed;
102
103 speed = usb_get_port_speed(g_hpm_udc.handle->regs);
104
105 if (speed == 0x00) {
106 return USB_SPEED_FULL;
107 }
108 if (speed == 0x01) {
109 return USB_SPEED_LOW;
110 }
111 if (speed == 0x02) {
112 return USB_SPEED_HIGH;
113 }
114
115 return 0;
116 }
117
usbd_ep_open(const struct usbd_endpoint_cfg * ep_cfg)118 int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
119 {
120 usb_endpoint_config_t tmp_ep_cfg;
121 usb_device_handle_t *handle = g_hpm_udc.handle;
122
123 uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
124
125 if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
126 g_hpm_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
127 g_hpm_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
128 g_hpm_udc.out_ep[ep_idx].ep_enable = true;
129 } else {
130 g_hpm_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
131 g_hpm_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
132 g_hpm_udc.in_ep[ep_idx].ep_enable = true;
133 }
134
135 tmp_ep_cfg.xfer = ep_cfg->ep_type;
136 tmp_ep_cfg.ep_addr = ep_cfg->ep_addr;
137 tmp_ep_cfg.max_packet_size = ep_cfg->ep_mps;
138
139 usb_device_edpt_open(handle, &tmp_ep_cfg);
140 return 0;
141 }
142
usbd_ep_close(const uint8_t ep)143 int usbd_ep_close(const uint8_t ep)
144 {
145 usb_device_handle_t *handle = g_hpm_udc.handle;
146
147 usb_device_edpt_close(handle, ep);
148 return 0;
149 }
150
usbd_ep_set_stall(const uint8_t ep)151 int usbd_ep_set_stall(const uint8_t ep)
152 {
153 usb_device_handle_t *handle = g_hpm_udc.handle;
154
155 usb_device_edpt_stall(handle, ep);
156 return 0;
157 }
158
usbd_ep_clear_stall(const uint8_t ep)159 int usbd_ep_clear_stall(const uint8_t ep)
160 {
161 usb_device_handle_t *handle = g_hpm_udc.handle;
162
163 usb_device_edpt_clear_stall(handle, ep);
164 return 0;
165 }
166
usbd_ep_is_stalled(const uint8_t ep,uint8_t * stalled)167 int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled)
168 {
169 usb_device_handle_t *handle = g_hpm_udc.handle;
170
171 *stalled = usb_device_edpt_check_stall(handle, ep);
172 return 0;
173 }
174
usbd_ep_start_write(const uint8_t ep,const uint8_t * data,uint32_t data_len)175 int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len)
176 {
177 uint8_t ep_idx = USB_EP_GET_IDX(ep);
178 usb_device_handle_t *handle = g_hpm_udc.handle;
179
180 if (!data && data_len) {
181 return -1;
182 }
183 if (!g_hpm_udc.in_ep[ep_idx].ep_enable) {
184 return -2;
185 }
186
187 g_hpm_udc.in_ep[ep_idx].xfer_buf = (uint8_t *)data;
188 g_hpm_udc.in_ep[ep_idx].xfer_len = data_len;
189 g_hpm_udc.in_ep[ep_idx].actual_xfer_len = 0;
190
191 usb_device_edpt_xfer(handle, ep, (uint8_t *)data, data_len);
192
193 return 0;
194 }
195
usbd_ep_start_read(const uint8_t ep,uint8_t * data,uint32_t data_len)196 int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len)
197 {
198 uint8_t ep_idx = USB_EP_GET_IDX(ep);
199 usb_device_handle_t *handle = g_hpm_udc.handle;
200
201 if (!data && data_len) {
202 return -1;
203 }
204 if (!g_hpm_udc.out_ep[ep_idx].ep_enable) {
205 return -2;
206 }
207
208 g_hpm_udc.out_ep[ep_idx].xfer_buf = (uint8_t *)data;
209 g_hpm_udc.out_ep[ep_idx].xfer_len = data_len;
210 g_hpm_udc.out_ep[ep_idx].actual_xfer_len = 0;
211
212 usb_device_edpt_xfer(handle, ep, data, data_len);
213
214 return 0;
215 }
216
USBD_IRQHandler(void)217 void USBD_IRQHandler(void)
218 {
219 uint32_t int_status;
220 usb_device_handle_t *handle = g_hpm_udc.handle;
221 uint32_t transfer_len = 0;
222
223 /* Acknowledge handled interrupt */
224 int_status = usb_device_status_flags(handle);
225 int_status &= usb_device_interrupts(handle);
226 usb_device_clear_status_flags(handle, int_status);
227
228 /* disabled interrupt sources */
229 if (int_status == 0) {
230 return;
231 }
232
233 if (int_status & intr_reset) {
234 memset(g_hpm_udc.in_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS);
235 memset(g_hpm_udc.out_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS);
236 usbd_event_reset_handler();
237 usb_device_bus_reset(handle, 64);
238 }
239
240 if (int_status & intr_suspend) {
241 if (usb_device_get_suspend_status(handle)) {
242 /* Note: Host may delay more than 3 ms before and/or after bus reset
243 * before doing enumeration. */
244 if (usb_device_get_address(handle)) {
245 }
246 }
247 }
248
249 if (int_status & intr_port_change) {
250 if (!usb_device_get_port_ccs(handle)) {
251 } else {
252 if (usb_device_get_port_reset_status(handle) == 0) {
253 }
254 }
255 }
256
257 if (int_status & intr_usb) {
258 uint32_t const edpt_complete = usb_device_get_edpt_complete_status(handle);
259 usb_device_clear_edpt_complete_status(handle, edpt_complete);
260 uint32_t edpt_setup_status = usb_device_get_setup_status(handle);
261
262 if (edpt_setup_status) {
263 /*------------- Set up Received -------------*/
264 usb_device_clear_setup_status(handle, edpt_setup_status);
265 dcd_qhd_t *qhd0 = usb_device_qhd_get(handle, 0);
266 usbd_event_ep0_setup_complete_handler((uint8_t *)&qhd0->setup_request);
267 }
268
269 if (edpt_complete) {
270 for (uint8_t ep_idx = 0; ep_idx < USB_SOS_DCD_MAX_QHD_COUNT; ep_idx++) {
271 if (edpt_complete & (1 << ep_idx2bit(ep_idx))) {
272 /* Failed QTD also get ENDPTCOMPLETE set */
273 dcd_qtd_t *p_qtd = usb_device_qtd_get(handle, ep_idx);
274 while (1) {
275 if (p_qtd->halted || p_qtd->xact_err || p_qtd->buffer_err) {
276 USB_LOG_ERR("usbd transfer error!\r\n");
277 return;
278 } else {
279 transfer_len += p_qtd->expected_bytes - p_qtd->total_bytes;
280 }
281
282 if (p_qtd->next == USB_SOC_DCD_QTD_NEXT_INVALID){
283 break;
284 } else {
285 p_qtd = (dcd_qtd_t *)p_qtd->next;
286 }
287 }
288
289 uint8_t const ep_addr = (ep_idx / 2) | ((ep_idx & 0x01) ? 0x80 : 0);
290 if (ep_addr & 0x80) {
291 usbd_event_ep_in_complete_handler(ep_addr, transfer_len);
292 } else {
293 usbd_event_ep_out_complete_handler(ep_addr, transfer_len);
294 }
295 }
296 }
297 }
298 }
299 }
300
isr_usbd(void)301 void isr_usbd(void)
302 {
303 USBD_IRQHandler();
304 }
305 SDK_DECLARE_EXT_ISR_M(CONFIG_HPM_USBD_IRQn, isr_usbd)
306