2 #include "stm32f1xx_hal.h"
6 void _Error_Handler(char * file, int line); // FIXME
8 void usb_init(struct usb *usb, PCD_HandleTypeDef *hpcd)
11 usb->state = USB_STATE_DEFAULT;
12 usb->ep0_state = USB_EP0_IDLE;
14 HAL_PCDEx_PMAConfig(hpcd, 0x00, PCD_SNG_BUF, 0x18);
15 HAL_PCDEx_PMAConfig(hpcd, 0x80, PCD_SNG_BUF, 0x58);
20 static inline uint get_u16(byte *p)
22 return (p[1] << 8) | p[0];
25 static inline void put_u16(byte *p, u16 x)
32 static struct usb_endpoint *ep_by_addr(struct usb *usb, byte ep_addr)
34 return ((ep_addr & 0x80) ? usb->ep_in : usb->ep_out) + (ep_addr & 0x7f);
38 static void usb_ctl_send_status(struct usb *usb)
40 usb->ep0_state = USB_EP0_STATUS_IN;
41 usb_ep_transmit(usb, 0x00, NULL, 0);
45 static void usb_ctl_recv_status(struct usb *usb)
47 usb->ep0_state = USB_EP0_STATUS_OUT;
48 usb_ep_receive(usb, 0x00, NULL, 0);
52 static void usb_ctl_send_data(struct usb *usb, byte *data, uint len)
54 usb->ep0_state = USB_EP0_DATA_IN;
55 usb->ep_in[0].total_length = len;
56 usb->ep_in[0].remaining_length = len;
57 usb_ep_transmit(usb, 0x00, data, len);
60 static void usb_ctl_send_byte(struct usb *usb, byte data)
62 usb->status_buf[0] = data;
63 usb_ctl_send_data(usb, usb->status_buf, 1);
66 static void usb_ctl_send_u16(struct usb *usb, u16 data)
68 put_u16(usb->status_buf, data);
69 usb_ctl_send_data(usb, usb->status_buf, 2);
72 static void usb_ctl_error(struct usb *usb)
74 usb_ep_stall(usb, 0x00);
75 usb_ep_stall(usb, 0x80);
78 struct setup_request {
86 static void usb_ctl_setup_error(struct usb *usb, struct setup_request *setup)
88 usb_ep_stall(usb, setup->bmRequest & USB_REQ_DIRECTION);
91 static void dev_get_status(struct usb *usb, struct setup_request *setup)
93 if ((usb->state != USB_STATE_ADDRESSED && usb->state != USB_STATE_CONFIGURED) ||
94 setup->wValue || setup->wIndex || setup->wLength != 2)
95 return usb_ctl_error(usb);
98 #ifdef USB_SELF_POWERED
99 stat |= USB_DEV_STATUS_SELF_POWERED;
101 if (usb->remote_wakeup)
102 stat |= USB_DEV_STATUS_REMOTE_WAKEUP;
103 usb_ctl_send_u16(usb, stat);
106 static void dev_clear_feature(struct usb *usb, struct setup_request *setup)
108 if (setup->wIndex || setup->wLength)
109 return usb_ctl_error(usb);
111 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
113 usb->remote_wakeup = 0;
114 usb_ctl_send_status(usb);
120 static void dev_set_feature(struct usb *usb, struct setup_request *setup)
122 if (setup->wIndex || setup->wLength)
123 return usb_ctl_error(usb);
125 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
127 usb->remote_wakeup = 1;
128 usb_ctl_send_status(usb);
134 static void dev_set_address(struct usb *usb, struct setup_request *setup)
136 if (setup->wIndex || setup->wLength)
137 return usb_ctl_error(usb);
139 uint addr = setup->wValue & 0x7f;
140 if (usb->state == USB_STATE_CONFIGURED)
145 HAL_PCD_SetAddress(usb->hpcd, addr);
146 usb_ctl_send_status(usb);
147 usb->state = addr ? USB_STATE_ADDRESSED : USB_STATE_DEFAULT;
151 static void dev_get_descriptor(struct usb *usb, struct setup_request *setup)
155 static void dev_get_configuration(struct usb *usb, struct setup_request *setup)
157 if (setup->wValue || setup->wIndex || setup->wLength != 1)
158 return usb_ctl_error(usb);
162 case USB_STATE_ADDRESSED:
163 usb_ctl_send_byte(usb, 0);
165 case USB_STATE_CONFIGURED:
166 usb_ctl_send_byte(usb, usb->config);
173 static void dev_set_configuration(struct usb *usb, struct setup_request *setup)
175 byte cfg = setup->wValue & 0xff;
177 // FIXME: Support more configurations
178 if (cfg > 1 || setup->wIndex || setup->wLength)
179 return usb_ctl_error(usb);
183 case USB_STATE_ADDRESSED:
187 usb->state = USB_STATE_CONFIGURED;
188 // FIXME: Notify that the device was configured
190 usb_ctl_send_status(usb);
192 case USB_STATE_CONFIGURED:
197 usb->state = USB_STATE_ADDRESSED;
198 // FIXME: Notify that the device was unconfigured
200 else if (cfg != usb->config)
203 // FIXME: Notify about configuration change
205 usb_ctl_send_status(usb);
212 static void dev_setup(struct usb *usb, struct setup_request *setup)
214 switch (setup->bRequest)
216 case USB_REQ_GET_STATUS:
217 return dev_get_status(usb, setup);
218 case USB_REQ_CLEAR_FEATURE:
219 return dev_clear_feature(usb, setup);
220 case USB_REQ_SET_FEATURE:
221 return dev_set_feature(usb, setup);
222 case USB_REQ_SET_ADDRESS:
223 return dev_set_address(usb, setup);
224 case USB_REQ_GET_DESCRIPTOR:
225 return dev_get_descriptor(usb, setup);
226 case USB_REQ_GET_CONFIGURATION:
227 return dev_get_configuration(usb, setup);
228 case USB_REQ_SET_CONFIGURATION:
229 return dev_set_configuration(usb, setup);
232 usb_ctl_setup_error(usb, setup);
235 static void intf_setup(struct usb *usb, struct setup_request *setup)
237 byte intf = setup->wIndex & 0xff;
241 // FIXME: Support more interfaces
246 switch (setup->bRequest)
248 case USB_REQ_GET_STATUS:
249 if (setup->wValue || setup->wLength != 2 || usb->state != USB_STATE_CONFIGURED)
252 usb_ctl_send_u16(usb, 0);
255 case USB_REQ_CLEAR_FEATURE:
256 case USB_REQ_SET_FEATURE:
257 // Interfaces have no standard features
258 return usb_ctl_error(usb);
261 usb_ctl_setup_error(usb, setup);
264 static void ep_setup(struct usb *usb, struct setup_request *setup)
266 byte ep_addr = setup->wIndex & 0x8f;
268 switch (setup->bRequest)
270 case USB_REQ_GET_STATUS:
271 if (setup->wValue || setup->wLength != 2)
272 return usb_ctl_error(usb);
275 case USB_STATE_ADDRESSED:
279 case USB_STATE_CONFIGURED:
281 if (usb_ep_is_stalled(usb, ep_addr))
282 usb_ctl_send_u16(usb, 1);
284 usb_ctl_send_u16(usb, 0);
288 return usb_ctl_error(usb);
292 case USB_REQ_SET_FEATURE:
294 return usb_ctl_error(usb);
297 case USB_STATE_ADDRESSED:
301 case USB_STATE_CONFIGURED:
302 if (setup->wValue == USB_FEATURE_EP_HALT)
305 usb_ep_stall(usb, ep_addr);
307 usb_ctl_send_status(usb);
314 case USB_REQ_CLEAR_FEATURE:
316 return usb_ctl_error(usb);
319 case USB_STATE_ADDRESSED:
323 case USB_STATE_CONFIGURED:
324 if (setup->wValue == USB_FEATURE_EP_HALT)
327 usb_ep_unstall(usb, ep_addr);
329 usb_ctl_send_status(usb);
337 usb_ctl_setup_error(usb, setup);
340 static void usb_handle_setup(struct usb *usb, struct setup_request *setup)
342 usb->ep0_state = USB_EP0_SETUP;
343 usb->ep0_data_len = setup->wLength;
345 if ((setup->bmRequest & USB_REQ_TYPE_MASK) != USB_REQ_TYPE_STANDARD)
347 // FIXME: Class-specific and vendor-specific setup packets not supported
348 // FIXME: Check USB_STATE_CONFIGURED here
349 usb_ctl_setup_error(usb, setup);
352 switch (setup->bmRequest & USB_REQ_RECIPIENT_MASK)
354 case USB_REQ_RECIPIENT_DEVICE:
355 return dev_setup(usb, setup);
356 case USB_REQ_RECIPIENT_INTERFACE:
357 return intf_setup(usb, setup);
358 case USB_REQ_RECIPIENT_ENDPOINT:
359 return ep_setup(usb, setup);
362 usb_ctl_setup_error(usb, setup);
365 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
367 struct usb *usb = hpcd->pData;
368 byte *req = (byte *) hpcd->Setup;
370 struct setup_request setup = {
373 .wValue = get_u16(req+2),
374 .wIndex = get_u16(req+4),
375 .wLength = get_u16(req+2),
377 usb_handle_setup(usb, &setup);
380 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
382 struct usb *usb = hpcd->pData;
383 struct usb_endpoint *ep = &usb->ep_out[epnum];
384 byte *data = hpcd->OUT_ep[epnum].xfer_buff;
388 if (usb->ep0_state != USB_EP0_DATA_OUT)
390 if (ep->remaining_length > ep->max_packet_size)
392 ep->remaining_length -= ep->max_packet_size;
393 usb_ep_receive(usb, 0x00, data, MIN(ep->remaining_length, ep->max_packet_size));
397 if (usb->state == USB_STATE_CONFIGURED)
399 // FIXME: Handle incoming control packet
401 usb_ctl_send_status(usb);
406 if (usb->state == USB_STATE_CONFIGURED)
408 // FIXME: Custom data callback
413 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
415 struct usb *usb = hpcd->pData;
416 struct usb_endpoint *ep = &usb->ep_in[epnum];
417 byte *data = hpcd->IN_ep[epnum].xfer_buff;
421 if (usb->ep0_state != USB_EP0_DATA_IN)
423 if (ep->remaining_length > ep->max_packet_size)
425 ep->remaining_length -= ep->max_packet_size;
426 usb_ep_transmit(usb, 0x00, data, ep->remaining_length);
427 usb_ep_receive(usb, 0x00, NULL, 0);
429 else if (ep->total_length && ep->total_length % ep->max_packet_size == 0 && ep->total_length < usb->ep0_data_len)
431 // Send an empty packet if total length is divisible by MTU
432 usb_ep_transmit(usb, 0x00, NULL, 0);
433 usb->ep0_data_len = 0;
434 usb_ep_receive(usb, 0x00, NULL, 0);
438 if (usb->state == USB_STATE_CONFIGURED)
440 // FIXME: Custom data callback
446 if (usb->state == USB_STATE_CONFIGURED)
448 // FIXME: Custom data callback
453 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
458 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
460 struct usb *usb = hpcd->pData;
462 usb->state = USB_STATE_DEFAULT;
463 usb->speed = hpcd->Init.speed;
465 usb_ep_open(usb, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
466 usb->ep_out[0].max_packet_size = USB_MAX_EP0_SIZE;
468 usb_ep_open(usb, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
469 usb->ep_in[0].max_packet_size = USB_MAX_EP0_SIZE;
472 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
474 struct usb *usb = hpcd->pData;
476 usb->pre_suspend_state = usb->state;
477 usb->state = USB_STATE_SUSPENDED;
479 if (hpcd->Init.low_power_enable)
480 SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
483 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
485 struct usb *usb = hpcd->pData;
486 usb->state = usb->pre_suspend_state;
489 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
491 // We do not support isochronous mode
494 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
496 // We do not support isochronous mode
499 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
503 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
505 struct usb *usb = hpcd->pData;
506 usb->state = USB_STATE_DEFAULT;