2 #include "stm32f1xx_hal.h"
9 // Layout of packet memory
14 void usb_init(struct usb *usb, PCD_HandleTypeDef *hpcd)
16 memset(usb, 0, sizeof(*usb));
18 usb->state = USB_STATE_DEFAULT;
19 usb->ep0_state = USB_EP0_IDLE;
23 void usb_start(struct usb *usb)
25 HAL_PCDEx_PMAConfig(usb->hpcd, 0x00, PCD_SNG_BUF, PMA_EP00);
26 HAL_PCDEx_PMAConfig(usb->hpcd, 0x80, PCD_SNG_BUF, PMA_EP80);
28 HAL_PCD_Start(usb->hpcd);
31 void usb_ctl_send_status(struct usb *usb)
33 usb_debug("Control send: status\n");
34 usb->ep0_state = USB_EP0_STATUS_IN;
35 usb_ep_send(usb, 0x00, NULL, 0);
38 void usb_ctl_recv_status(struct usb *usb)
40 usb->ep0_state = USB_EP0_STATUS_OUT;
41 usb_ep_receive(usb, 0x00, NULL, 0);
44 void usb_ctl_send_data(struct usb *usb, const byte *data, uint len)
46 usb_debug("Control send: %u bytes\n", len);
47 usb->ep0_state = USB_EP0_DATA_IN;
48 usb->ep0_total_length = len;
49 usb->ep0_remaining_length = len;
50 usb_ep_send(usb, 0x00, data, len);
53 void usb_ctl_recv_data(struct usb *usb, byte *data, uint len)
55 usb_debug("Control recv: %u bytes\n", len);
56 usb->ep0_state = USB_EP0_DATA_OUT;
57 usb->ep0_total_length = len;
58 usb->ep0_remaining_length = len;
59 usb_ep_send(usb, 0x00, data, len);
62 static void usb_ctl_send_byte(struct usb *usb, byte data)
64 usb->ep0_buf[0] = data;
65 usb_ctl_send_data(usb, usb->ep0_buf, 1);
68 static void usb_ctl_send_u16(struct usb *usb, u16 data)
70 put_u16_le(usb->ep0_buf, data);
71 usb_ctl_send_data(usb, usb->ep0_buf, 2);
74 void usb_ctl_error(struct usb *usb)
76 usb_debug("Control packet error\n");
77 usb_ep_stall(usb, 0x00);
78 usb_ep_stall(usb, 0x80);
81 void usb_ctl_setup_error(struct usb *usb, struct setup_request *setup)
83 usb_debug("Setup packet error\n");
84 usb_ep_stall(usb, setup->bmRequest & USB_REQ_DIRECTION);
87 static void dev_get_status(struct usb *usb, struct setup_request *setup)
89 if ((usb->state != USB_STATE_ADDRESSED && usb->state != USB_STATE_CONFIGURED) ||
90 setup->wValue || setup->wIndex || setup->wLength != 2)
91 return usb_ctl_error(usb);
94 #ifdef USB_SELF_POWERED
95 stat |= USB_DEV_STATUS_SELF_POWERED;
97 if (usb->remote_wakeup)
98 stat |= USB_DEV_STATUS_REMOTE_WAKEUP;
99 usb_ctl_send_u16(usb, stat);
102 static void dev_clear_feature(struct usb *usb, struct setup_request *setup)
104 if (setup->wIndex || setup->wLength)
105 return usb_ctl_error(usb);
107 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
109 usb->remote_wakeup = 0;
110 usb_ctl_send_status(usb);
116 static void dev_set_feature(struct usb *usb, struct setup_request *setup)
118 if (setup->wIndex || setup->wLength)
119 return usb_ctl_error(usb);
121 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
123 usb->remote_wakeup = 1;
124 usb_ctl_send_status(usb);
130 static void dev_set_address(struct usb *usb, struct setup_request *setup)
132 if (setup->wIndex || setup->wLength)
133 return usb_ctl_error(usb);
135 uint addr = setup->wValue & 0x7f;
136 if (usb->state == USB_STATE_CONFIGURED)
141 HAL_PCD_SetAddress(usb->hpcd, addr);
142 usb_ctl_send_status(usb);
143 usb->state = addr ? USB_STATE_ADDRESSED : USB_STATE_DEFAULT;
147 static void dev_desc_send(struct usb *usb, struct setup_request *setup, const byte *desc, uint len)
149 len = MIN(len, setup->wLength);
151 usb_ctl_send_data(usb, desc, len);
154 static void dev_desc_send_string(struct usb *usb, struct setup_request *setup, const char *str)
156 byte *buf = usb->ep0_buf;
157 uint len = strlen(str);
160 buf[i++] = 2*len + 2;
161 buf[i++] = USB_DESC_TYPE_STRING;
163 while (i <= USB_EP0_BUF_SIZE - 2 && *str)
169 dev_desc_send(usb, setup, buf, i);
172 static void dev_get_descriptor(struct usb *usb, struct setup_request *setup)
174 byte desc_type = setup->wValue >> 8;
175 byte desc_index = setup->wValue & 0xff;
179 case USB_DESC_TYPE_DEVICE:
180 return dev_desc_send(usb, setup, usb->desc_device, usb->desc_device_len);
181 case USB_DESC_TYPE_CONFIGURATION:
182 return dev_desc_send(usb, setup, usb->desc_config, usb->desc_config_len);
183 case USB_DESC_TYPE_STRING:
185 return dev_desc_send(usb, setup, usb->desc_languages, usb->desc_languages_len);
186 if (desc_index < usb->desc_string_items)
187 return dev_desc_send_string(usb, setup, usb->desc_string[desc_index]);
189 case USB_DESC_TYPE_DEVICE_QUALIFIER:
190 case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
191 // We do not support high-speed USB
198 static void dev_get_configuration(struct usb *usb, struct setup_request *setup)
200 if (setup->wValue || setup->wIndex || setup->wLength != 1)
201 return usb_ctl_error(usb);
205 case USB_STATE_ADDRESSED:
206 usb_ctl_send_byte(usb, 0);
208 case USB_STATE_CONFIGURED:
209 usb_ctl_send_byte(usb, usb->config);
216 static void dev_set_configuration(struct usb *usb, struct setup_request *setup)
218 byte cfg = setup->wValue & 0xff;
220 // FIXME: Support more configurations
221 if (cfg > 1 || setup->wIndex || setup->wLength)
222 return usb_ctl_error(usb);
226 case USB_STATE_ADDRESSED:
230 usb->state = USB_STATE_CONFIGURED;
231 usb->last_pma_alloc = PMA_USER;
232 usb_dev_configure(usb);
234 usb_ctl_send_status(usb);
236 case USB_STATE_CONFIGURED:
240 usb_dev_unconfigure(usb);
242 usb->state = USB_STATE_ADDRESSED;
244 else if (cfg != usb->config)
246 usb_dev_unconfigure(usb);
248 usb->last_pma_alloc = PMA_USER;
249 usb_dev_configure(usb);
251 usb_ctl_send_status(usb);
258 static void dev_setup(struct usb *usb, struct setup_request *setup)
260 switch (setup->bRequest)
262 case USB_REQ_GET_STATUS:
263 return dev_get_status(usb, setup);
264 case USB_REQ_CLEAR_FEATURE:
265 return dev_clear_feature(usb, setup);
266 case USB_REQ_SET_FEATURE:
267 return dev_set_feature(usb, setup);
268 case USB_REQ_SET_ADDRESS:
269 return dev_set_address(usb, setup);
270 case USB_REQ_GET_DESCRIPTOR:
271 return dev_get_descriptor(usb, setup);
272 case USB_REQ_GET_CONFIGURATION:
273 return dev_get_configuration(usb, setup);
274 case USB_REQ_SET_CONFIGURATION:
275 return dev_set_configuration(usb, setup);
278 usb_ctl_setup_error(usb, setup);
281 static void intf_setup(struct usb *usb, struct setup_request *setup)
283 byte intf = setup->wIndex & 0xff;
287 // FIXME: Currently, we do not support more than 1 interface per configuration
292 switch (setup->bRequest)
294 case USB_REQ_GET_STATUS:
295 if (setup->wValue || setup->wLength != 2 || usb->state != USB_STATE_CONFIGURED)
298 usb_ctl_send_u16(usb, 0);
301 case USB_REQ_CLEAR_FEATURE:
302 case USB_REQ_SET_FEATURE:
303 // Interfaces have no standard features
304 return usb_ctl_error(usb);
307 usb_ctl_setup_error(usb, setup);
310 static void ep_setup(struct usb *usb, struct setup_request *setup)
312 byte ep_addr = setup->wIndex & 0x8f;
314 switch (setup->bRequest)
316 case USB_REQ_GET_STATUS:
317 if (setup->wValue || setup->wLength != 2)
318 return usb_ctl_error(usb);
321 case USB_STATE_ADDRESSED:
325 case USB_STATE_CONFIGURED:
327 if (usb_ep_is_stalled(usb, ep_addr))
328 usb_ctl_send_u16(usb, 1);
330 usb_ctl_send_u16(usb, 0);
334 return usb_ctl_error(usb);
338 case USB_REQ_SET_FEATURE:
340 return usb_ctl_error(usb);
343 case USB_STATE_ADDRESSED:
347 case USB_STATE_CONFIGURED:
348 if (setup->wValue == USB_FEATURE_EP_HALT)
351 usb_ep_stall(usb, ep_addr);
353 usb_ctl_send_status(usb);
360 case USB_REQ_CLEAR_FEATURE:
362 return usb_ctl_error(usb);
365 case USB_STATE_ADDRESSED:
369 case USB_STATE_CONFIGURED:
370 if (setup->wValue == USB_FEATURE_EP_HALT)
373 usb_ep_unstall(usb, ep_addr);
375 usb_ctl_send_status(usb);
383 usb_ctl_setup_error(usb, setup);
386 static void usb_handle_setup(struct usb *usb, struct setup_request *setup)
388 usb_debug("Setup: type=%02x req=%02x val=%04x idx=%04x len=%04x\n", setup->bmRequest, setup->bRequest, setup->wValue, setup->wIndex, setup->wLength);
389 usb->ep0_state = USB_EP0_SETUP;
390 usb->ep0_setup_data_length = setup->wLength;
392 if (usb_dev_setup_hook(usb, setup))
395 if ((setup->bmRequest & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
397 switch (setup->bmRequest & USB_REQ_RECIPIENT_MASK)
399 case USB_REQ_RECIPIENT_DEVICE:
400 return dev_setup(usb, setup);
401 case USB_REQ_RECIPIENT_INTERFACE:
402 return intf_setup(usb, setup);
403 case USB_REQ_RECIPIENT_ENDPOINT:
404 return ep_setup(usb, setup);
408 usb_ctl_setup_error(usb, setup);
411 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
413 struct usb *usb = hpcd->pData;
414 byte *req = (byte *) hpcd->Setup;
416 struct setup_request setup = {
419 .wValue = get_u16_le(req+2),
420 .wIndex = get_u16_le(req+4),
421 .wLength = get_u16_le(req+6),
423 usb_handle_setup(usb, &setup);
426 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
428 struct usb *usb = hpcd->pData;
429 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
433 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
434 usb_debug("Ep0 OUT: state=%u rem=%u total=%u\n", usb->ep0_state, usb->ep0_remaining_length, usb->ep0_total_length);
435 if (usb->ep0_state != USB_EP0_DATA_OUT)
437 if (usb->ep0_remaining_length > ep->maxpacket)
439 usb->ep0_remaining_length -= ep->maxpacket;
440 usb_ep_receive(usb, 0x00, ep->xfer_buff, MIN(usb->ep0_remaining_length, ep->maxpacket));
444 if (usb->state == USB_STATE_CONFIGURED)
445 usb_dev_ctl_recv_done(usb);
446 usb_ctl_send_status(usb);
451 if (usb->state == USB_STATE_CONFIGURED)
452 usb_dev_recv_done(usb, epnum);
456 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
458 struct usb *usb = hpcd->pData;
459 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
463 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
464 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);
465 if (usb->ep0_state != USB_EP0_DATA_IN)
467 if (usb->ep0_remaining_length > ep->maxpacket)
469 usb->ep0_remaining_length -= ep->maxpacket;
470 usb_ep_send(usb, 0x00, ep->xfer_buff, usb->ep0_remaining_length);
471 usb_ep_receive(usb, 0x00, NULL, 0);
473 else if (usb->ep0_total_length && usb->ep0_total_length % ep->maxpacket == 0 && usb->ep0_total_length < usb->ep0_setup_data_length)
476 * Each data transfer must be terminated by either a small packet (less than maxpacket)
477 * or by reaching the answer size requested in the setup packet. Send an empty final packet
480 usb_ep_send(usb, 0x00, NULL, 0);
481 usb->ep0_setup_data_length = 0;
482 usb_ep_receive(usb, 0x00, NULL, 0);
486 if (usb->state == USB_STATE_CONFIGURED)
487 usb_dev_ctl_send_done(usb);
488 usb_ctl_recv_status(usb);
493 if (usb->state == USB_STATE_CONFIGURED)
494 usb_dev_send_done(usb, epnum);
498 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
500 // We are not interested in Start of frame packets
501 // (neither we set hpcd->Init.Sof_enable, so this callback does not get called)
504 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
506 struct usb *usb = hpcd->pData;
508 usb->state = USB_STATE_DEFAULT;
511 usb_ep_open(usb, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
512 usb_ep_open(usb, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
515 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
517 struct usb *usb = hpcd->pData;
519 usb->pre_suspend_state = usb->state;
520 usb->state = USB_STATE_SUSPENDED;
522 if (hpcd->Init.low_power_enable)
523 SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
526 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
528 struct usb *usb = hpcd->pData;
529 usb->state = usb->pre_suspend_state;
532 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
534 // We do not support isochronous mode
537 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
539 // We do not support isochronous mode
542 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
546 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
548 struct usb *usb = hpcd->pData;
549 usb->state = USB_STATE_DEFAULT;