2 #include "stm32f1xx_hal.h"
9 void usb_init(struct usb *usb, PCD_HandleTypeDef *hpcd)
11 memset(usb, 0, sizeof(*usb));
13 usb->state = USB_STATE_DEFAULT;
14 usb->ep0_state = USB_EP0_IDLE;
18 void usb_start(struct usb *usb)
20 HAL_PCDEx_PMAConfig(usb->hpcd, 0x00, PCD_SNG_BUF, 0x18);
21 HAL_PCDEx_PMAConfig(usb->hpcd, 0x80, PCD_SNG_BUF, 0x58);
23 HAL_PCD_Start(usb->hpcd);
26 void usb_ctl_send_status(struct usb *usb)
28 usb_debug("Control send: status\n");
29 usb->ep0_state = USB_EP0_STATUS_IN;
30 usb_ep_send(usb, 0x00, NULL, 0);
33 void usb_ctl_recv_status(struct usb *usb)
35 usb->ep0_state = USB_EP0_STATUS_OUT;
36 usb_ep_receive(usb, 0x00, NULL, 0);
39 void usb_ctl_send_data(struct usb *usb, const byte *data, uint len)
41 usb_debug("Control send: %u bytes\n", len);
42 usb->ep0_state = USB_EP0_DATA_IN;
43 usb->ep0_total_length = len;
44 usb->ep0_remaining_length = len;
45 usb_ep_send(usb, 0x00, data, len);
48 void usb_ctl_recv_data(struct usb *usb, byte *data, uint len)
50 usb_debug("Control recv: %u bytes\n", len);
51 usb->ep0_state = USB_EP0_DATA_OUT;
52 usb->ep0_total_length = len;
53 usb->ep0_remaining_length = len;
54 usb_ep_send(usb, 0x00, data, len);
57 static void usb_ctl_send_byte(struct usb *usb, byte data)
59 usb->ep0_buf[0] = data;
60 usb_ctl_send_data(usb, usb->ep0_buf, 1);
63 static void usb_ctl_send_u16(struct usb *usb, u16 data)
65 put_u16_le(usb->ep0_buf, data);
66 usb_ctl_send_data(usb, usb->ep0_buf, 2);
69 void usb_ctl_error(struct usb *usb)
71 usb_debug("Control packet error\n");
72 usb_ep_stall(usb, 0x00);
73 usb_ep_stall(usb, 0x80);
76 void usb_ctl_setup_error(struct usb *usb, struct setup_request *setup)
78 usb_debug("Setup packet error\n");
79 usb_ep_stall(usb, setup->bmRequest & USB_REQ_DIRECTION);
82 static void dev_get_status(struct usb *usb, struct setup_request *setup)
84 if ((usb->state != USB_STATE_ADDRESSED && usb->state != USB_STATE_CONFIGURED) ||
85 setup->wValue || setup->wIndex || setup->wLength != 2)
86 return usb_ctl_error(usb);
89 #ifdef USB_SELF_POWERED
90 stat |= USB_DEV_STATUS_SELF_POWERED;
92 if (usb->remote_wakeup)
93 stat |= USB_DEV_STATUS_REMOTE_WAKEUP;
94 usb_ctl_send_u16(usb, stat);
97 static void dev_clear_feature(struct usb *usb, struct setup_request *setup)
99 if (setup->wIndex || setup->wLength)
100 return usb_ctl_error(usb);
102 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
104 usb->remote_wakeup = 0;
105 usb_ctl_send_status(usb);
111 static void dev_set_feature(struct usb *usb, struct setup_request *setup)
113 if (setup->wIndex || setup->wLength)
114 return usb_ctl_error(usb);
116 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
118 usb->remote_wakeup = 1;
119 usb_ctl_send_status(usb);
125 static void dev_set_address(struct usb *usb, struct setup_request *setup)
127 if (setup->wIndex || setup->wLength)
128 return usb_ctl_error(usb);
130 uint addr = setup->wValue & 0x7f;
131 if (usb->state == USB_STATE_CONFIGURED)
136 HAL_PCD_SetAddress(usb->hpcd, addr);
137 usb_ctl_send_status(usb);
138 usb->state = addr ? USB_STATE_ADDRESSED : USB_STATE_DEFAULT;
142 static void dev_desc_send(struct usb *usb, struct setup_request *setup, const byte *desc, uint len)
144 len = MIN(len, setup->wLength);
146 usb_ctl_send_data(usb, desc, len);
149 static void dev_desc_send_string(struct usb *usb, struct setup_request *setup, const char *str)
151 byte *buf = usb->ep0_buf;
152 uint len = strlen(str);
155 buf[i++] = 2*len + 2;
156 buf[i++] = USB_DESC_TYPE_STRING;
158 while (i <= USB_EP0_BUF_SIZE - 2 && *str)
164 dev_desc_send(usb, setup, buf, i);
167 static void dev_get_descriptor(struct usb *usb, struct setup_request *setup)
169 byte desc_type = setup->wValue >> 8;
170 byte desc_index = setup->wValue & 0xff;
174 case USB_DESC_TYPE_DEVICE:
175 return dev_desc_send(usb, setup, usb->desc_device, usb->desc_device_len);
176 case USB_DESC_TYPE_CONFIGURATION:
177 return dev_desc_send(usb, setup, usb->desc_config, usb->desc_config_len);
178 case USB_DESC_TYPE_STRING:
180 return dev_desc_send(usb, setup, usb->desc_languages, usb->desc_languages_len);
181 if (desc_index < usb->desc_string_items)
182 return dev_desc_send_string(usb, setup, usb->desc_string[desc_index]);
184 case USB_DESC_TYPE_DEVICE_QUALIFIER:
185 case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
186 // We do not support high-speed USB
193 static void dev_get_configuration(struct usb *usb, struct setup_request *setup)
195 if (setup->wValue || setup->wIndex || setup->wLength != 1)
196 return usb_ctl_error(usb);
200 case USB_STATE_ADDRESSED:
201 usb_ctl_send_byte(usb, 0);
203 case USB_STATE_CONFIGURED:
204 usb_ctl_send_byte(usb, usb->config);
211 static void dev_set_configuration(struct usb *usb, struct setup_request *setup)
213 byte cfg = setup->wValue & 0xff;
215 // FIXME: Support more configurations
216 if (cfg > 1 || setup->wIndex || setup->wLength)
217 return usb_ctl_error(usb);
221 case USB_STATE_ADDRESSED:
225 usb->state = USB_STATE_CONFIGURED;
226 usb_dev_configure(usb);
228 usb_ctl_send_status(usb);
230 case USB_STATE_CONFIGURED:
234 usb_dev_unconfigure(usb);
236 usb->state = USB_STATE_ADDRESSED;
238 else if (cfg != usb->config)
240 usb_dev_unconfigure(usb);
242 usb_dev_configure(usb);
244 usb_ctl_send_status(usb);
251 static void dev_setup(struct usb *usb, struct setup_request *setup)
253 switch (setup->bRequest)
255 case USB_REQ_GET_STATUS:
256 return dev_get_status(usb, setup);
257 case USB_REQ_CLEAR_FEATURE:
258 return dev_clear_feature(usb, setup);
259 case USB_REQ_SET_FEATURE:
260 return dev_set_feature(usb, setup);
261 case USB_REQ_SET_ADDRESS:
262 return dev_set_address(usb, setup);
263 case USB_REQ_GET_DESCRIPTOR:
264 return dev_get_descriptor(usb, setup);
265 case USB_REQ_GET_CONFIGURATION:
266 return dev_get_configuration(usb, setup);
267 case USB_REQ_SET_CONFIGURATION:
268 return dev_set_configuration(usb, setup);
271 usb_ctl_setup_error(usb, setup);
274 static void intf_setup(struct usb *usb, struct setup_request *setup)
276 byte intf = setup->wIndex & 0xff;
280 // FIXME: Currently, we do not support more than 1 interface per configuration
285 switch (setup->bRequest)
287 case USB_REQ_GET_STATUS:
288 if (setup->wValue || setup->wLength != 2 || usb->state != USB_STATE_CONFIGURED)
291 usb_ctl_send_u16(usb, 0);
294 case USB_REQ_CLEAR_FEATURE:
295 case USB_REQ_SET_FEATURE:
296 // Interfaces have no standard features
297 return usb_ctl_error(usb);
300 usb_ctl_setup_error(usb, setup);
303 static void ep_setup(struct usb *usb, struct setup_request *setup)
305 byte ep_addr = setup->wIndex & 0x8f;
307 switch (setup->bRequest)
309 case USB_REQ_GET_STATUS:
310 if (setup->wValue || setup->wLength != 2)
311 return usb_ctl_error(usb);
314 case USB_STATE_ADDRESSED:
318 case USB_STATE_CONFIGURED:
320 if (usb_ep_is_stalled(usb, ep_addr))
321 usb_ctl_send_u16(usb, 1);
323 usb_ctl_send_u16(usb, 0);
327 return usb_ctl_error(usb);
331 case USB_REQ_SET_FEATURE:
333 return usb_ctl_error(usb);
336 case USB_STATE_ADDRESSED:
340 case USB_STATE_CONFIGURED:
341 if (setup->wValue == USB_FEATURE_EP_HALT)
344 usb_ep_stall(usb, ep_addr);
346 usb_ctl_send_status(usb);
353 case USB_REQ_CLEAR_FEATURE:
355 return usb_ctl_error(usb);
358 case USB_STATE_ADDRESSED:
362 case USB_STATE_CONFIGURED:
363 if (setup->wValue == USB_FEATURE_EP_HALT)
366 usb_ep_unstall(usb, ep_addr);
368 usb_ctl_send_status(usb);
376 usb_ctl_setup_error(usb, setup);
379 static void usb_handle_setup(struct usb *usb, struct setup_request *setup)
381 usb_debug("Setup: type=%02x req=%02x val=%04x idx=%04x len=%04x\n", setup->bmRequest, setup->bRequest, setup->wValue, setup->wIndex, setup->wLength);
382 usb->ep0_state = USB_EP0_SETUP;
383 usb->ep0_setup_data_length = setup->wLength;
385 if (usb_dev_setup_hook(usb, setup))
388 if ((setup->bmRequest & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
390 switch (setup->bmRequest & USB_REQ_RECIPIENT_MASK)
392 case USB_REQ_RECIPIENT_DEVICE:
393 return dev_setup(usb, setup);
394 case USB_REQ_RECIPIENT_INTERFACE:
395 return intf_setup(usb, setup);
396 case USB_REQ_RECIPIENT_ENDPOINT:
397 return ep_setup(usb, setup);
401 usb_ctl_setup_error(usb, setup);
404 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
406 struct usb *usb = hpcd->pData;
407 byte *req = (byte *) hpcd->Setup;
409 struct setup_request setup = {
412 .wValue = get_u16_le(req+2),
413 .wIndex = get_u16_le(req+4),
414 .wLength = get_u16_le(req+6),
416 usb_handle_setup(usb, &setup);
419 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
421 struct usb *usb = hpcd->pData;
422 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
426 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
427 usb_debug("Ep0 OUT: state=%u rem=%u total=%u\n", usb->ep0_state, usb->ep0_remaining_length, usb->ep0_total_length);
428 if (usb->ep0_state != USB_EP0_DATA_OUT)
430 if (usb->ep0_remaining_length > ep->maxpacket)
432 usb->ep0_remaining_length -= ep->maxpacket;
433 usb_ep_receive(usb, 0x00, ep->xfer_buff, MIN(usb->ep0_remaining_length, ep->maxpacket));
437 if (usb->state == USB_STATE_CONFIGURED)
438 usb_dev_ctl_recv_done(usb);
439 usb_ctl_send_status(usb);
444 if (usb->state == USB_STATE_CONFIGURED)
445 usb_dev_recv_done(usb, epnum);
449 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
451 struct usb *usb = hpcd->pData;
452 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
456 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
457 usb_debug("Ep0 IN: state=%u rem=%u total=%u want=%u\n", usb->ep0_state, usb->ep0_remaining_length, usb->ep0_total_length, usb->ep0_setup_data_length);
458 if (usb->ep0_state != USB_EP0_DATA_IN)
460 if (usb->ep0_remaining_length > ep->maxpacket)
462 usb->ep0_remaining_length -= ep->maxpacket;
463 usb_ep_send(usb, 0x00, ep->xfer_buff, usb->ep0_remaining_length);
464 usb_ep_receive(usb, 0x00, NULL, 0);
466 else if (usb->ep0_total_length && usb->ep0_total_length % ep->maxpacket == 0 && usb->ep0_total_length < usb->ep0_setup_data_length)
469 * Each data transfer must be terminated by either a small packet (less than maxpacket)
470 * or by reaching the answer size requested in the setup packet. Send an empty final packet
473 usb_ep_send(usb, 0x00, NULL, 0);
474 usb->ep0_setup_data_length = 0;
475 usb_ep_receive(usb, 0x00, NULL, 0);
479 if (usb->state == USB_STATE_CONFIGURED)
480 usb_dev_ctl_send_done(usb);
481 usb_ctl_recv_status(usb);
486 if (usb->state == USB_STATE_CONFIGURED)
487 usb_dev_send_done(usb, epnum);
491 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
493 // We are not interested in Start of frame packets
494 // (neither we set hpcd->Init.Sof_enable, so this callback does not get called)
497 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
499 struct usb *usb = hpcd->pData;
501 usb->state = USB_STATE_DEFAULT;
504 usb_ep_open(usb, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
505 usb_ep_open(usb, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
508 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
510 struct usb *usb = hpcd->pData;
512 usb->pre_suspend_state = usb->state;
513 usb->state = USB_STATE_SUSPENDED;
515 if (hpcd->Init.low_power_enable)
516 SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
519 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
521 struct usb *usb = hpcd->pData;
522 usb->state = usb->pre_suspend_state;
525 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
527 // We do not support isochronous mode
530 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
532 // We do not support isochronous mode
535 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
539 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
541 struct usb *usb = hpcd->pData;
542 usb->state = USB_STATE_DEFAULT;