2 #include "stm32f1xx_hal.h"
8 void _Error_Handler(char * file, int line); // FIXME
10 #define DESC_U16(x) ((x) & 0xff), ((x) >> 8)
14 DESC_STR_MANUFACTURER,
17 DESC_STR_CONFIGURATION,
21 static const byte desc_device[] = {
23 USB_DESC_TYPE_DEVICE, // bDescriptorType
24 DESC_U16(0x0200), // bcdUSB
26 0x00, // bDeviceSubClass
27 0x00, // bDeviceProtocol
28 USB_MAX_EP0_SIZE, // bMaxPacketSize
29 DESC_U16(0x4242), // idVendor
30 DESC_U16(0x0001), // idProduct
31 DESC_U16(0x0200), // bcdDevice
32 DESC_STR_MANUFACTURER, // iManufacturer
33 DESC_STR_PRODUCT, // iProduct
34 DESC_STR_SERIAL, // iSerialNumber
35 USB_NUM_CONFIGURATIONS, // bNumConfigurations
38 static const byte desc_config[] = {
39 // Configuration descriptor
41 USB_DESC_TYPE_CONFIGURATION, // bDescriptorType
44 0x01, // bNumInterfaces
45 0x01, // bConfigurationValue
46 DESC_STR_CONFIGURATION, // iConfiguration
47 0xc0, // bmAttributes: bus-powered, supports remote wakeup
48 0x32, // Max power: 100 mA
49 // Interface descriptor
51 USB_DESC_TYPE_INTERFACE, // bDescriptorType
52 0x00, // bInterfaceNumber
53 0x00, // bAlternateSetting
54 0x01, // bNumEndpoints
55 0xff, // bInterfaceClass: vendor-defined
56 0x00, // bInterfaceSubClass
57 0x00, // nInterfaceProtocol
58 DESC_STR_INTERFACE, // iInterface
59 // End-point descriptor
61 USB_DESC_TYPE_ENDPOINT, // bDescriptorType
62 0x01, // bEndpointAddress
63 USB_EP_TYPE_BULK, // bmAttributes
64 0x40, 0x00, // wMaxPacketSize
65 0x00, // bInterval: unused
66 // End-point descriptor
68 USB_DESC_TYPE_ENDPOINT, // bDescriptorType
69 0x81, // bEndpointAddress
70 USB_EP_TYPE_BULK, // bmAttributes
71 0x40, 0x00, // wMaxPacketSize
72 0x00, // bInterval: unused
75 static const char * const desc_string[] = {
77 "United Computer Wizards", // DESC_STR_MANUFACTURER
78 "Mysterious Gadget", // DESC_STR_PRODUCT
79 "00000042", // DESC_STR_SERIAL
80 "Default Configuration", // DESC_STR_CONFIGURATION
81 "Default Interface", // DESC_STR_INTERFACE
84 void usb_init(struct usb *usb, PCD_HandleTypeDef *hpcd)
86 memset(usb, 0, sizeof(*usb));
88 usb->state = USB_STATE_DEFAULT;
89 usb->ep0_state = USB_EP0_IDLE;
91 HAL_PCDEx_PMAConfig(hpcd, 0x00, PCD_SNG_BUF, 0x18);
92 HAL_PCDEx_PMAConfig(hpcd, 0x80, PCD_SNG_BUF, 0x58);
97 static inline uint get_u16(byte *p)
99 return (p[1] << 8) | p[0];
102 static inline void put_u16(byte *p, u16 x)
109 static struct usb_endpoint *ep_by_addr(struct usb *usb, byte ep_addr)
111 return ((ep_addr & 0x80) ? usb->ep_in : usb->ep_out) + (ep_addr & 0x7f);
115 static void usb_ctl_send_status(struct usb *usb)
117 usb->ep0_state = USB_EP0_STATUS_IN;
118 usb_ep_transmit(usb, 0x00, NULL, 0);
122 static void usb_ctl_recv_status(struct usb *usb)
124 usb->ep0_state = USB_EP0_STATUS_OUT;
125 usb_ep_receive(usb, 0x00, NULL, 0);
129 static void usb_ctl_send_data(struct usb *usb, const byte *data, uint len)
131 usb->ep0_state = USB_EP0_DATA_IN;
132 usb->ep0_total_length = len;
133 usb->ep0_remaining_length = len;
134 usb_ep_transmit(usb, 0x00, data, len);
138 static void usb_ctl_recv_data(struct usb *usb, byte *data, uint len)
140 usb->ep0_state = USB_EP0_DATA_OUT;
141 usb->ep0_total_length = len;
142 usb->ep0_remaining_length = len;
143 usb_ep_transmit(usb, 0x00, data, len);
147 static void usb_ctl_send_byte(struct usb *usb, byte data)
149 usb->ep0_buf[0] = data;
150 usb_ctl_send_data(usb, usb->ep0_buf, 1);
153 static void usb_ctl_send_u16(struct usb *usb, u16 data)
155 put_u16(usb->ep0_buf, data);
156 usb_ctl_send_data(usb, usb->ep0_buf, 2);
159 static void usb_ctl_error(struct usb *usb)
161 usb_ep_stall(usb, 0x00);
162 usb_ep_stall(usb, 0x80);
165 struct setup_request {
173 static void usb_ctl_setup_error(struct usb *usb, struct setup_request *setup)
175 usb_ep_stall(usb, setup->bmRequest & USB_REQ_DIRECTION);
178 static void dev_get_status(struct usb *usb, struct setup_request *setup)
180 if ((usb->state != USB_STATE_ADDRESSED && usb->state != USB_STATE_CONFIGURED) ||
181 setup->wValue || setup->wIndex || setup->wLength != 2)
182 return usb_ctl_error(usb);
185 #ifdef USB_SELF_POWERED
186 stat |= USB_DEV_STATUS_SELF_POWERED;
188 if (usb->remote_wakeup)
189 stat |= USB_DEV_STATUS_REMOTE_WAKEUP;
190 usb_ctl_send_u16(usb, stat);
193 static void dev_clear_feature(struct usb *usb, struct setup_request *setup)
195 if (setup->wIndex || setup->wLength)
196 return usb_ctl_error(usb);
198 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
200 usb->remote_wakeup = 0;
201 usb_ctl_send_status(usb);
207 static void dev_set_feature(struct usb *usb, struct setup_request *setup)
209 if (setup->wIndex || setup->wLength)
210 return usb_ctl_error(usb);
212 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
214 usb->remote_wakeup = 1;
215 usb_ctl_send_status(usb);
221 static void dev_set_address(struct usb *usb, struct setup_request *setup)
223 if (setup->wIndex || setup->wLength)
224 return usb_ctl_error(usb);
226 uint addr = setup->wValue & 0x7f;
227 if (usb->state == USB_STATE_CONFIGURED)
232 HAL_PCD_SetAddress(usb->hpcd, addr);
233 usb_ctl_send_status(usb);
234 usb->state = addr ? USB_STATE_ADDRESSED : USB_STATE_DEFAULT;
238 static void dev_desc_send(struct usb *usb, struct setup_request *setup, const byte *desc, uint len)
240 len = MIN(len, setup->wLength);
242 usb_ctl_send_data(usb, desc, len);
245 static void dev_desc_send_string(struct usb *usb, struct setup_request *setup, const char *str)
247 byte *buf = usb->ep0_buf;
248 uint len = strlen(str);
251 buf[i++] = 2*len + 2;
252 buf[i++] = USB_DESC_TYPE_STRING;
254 while (i <= USB_EP0_BUF_SIZE - 2 && *str)
260 dev_desc_send(usb, setup, buf, i);
263 static void dev_get_descriptor(struct usb *usb, struct setup_request *setup)
265 byte desc_type = setup->wValue >> 8;
266 byte desc_index = setup->wValue & 0xff;
270 case USB_DESC_TYPE_DEVICE:
271 return dev_desc_send(usb, setup, desc_device, sizeof(desc_device));
272 case USB_DESC_TYPE_CONFIGURATION:
273 return dev_desc_send(usb, setup, desc_config, sizeof(desc_config));
274 case USB_DESC_TYPE_STRING:
275 if (desc_index < sizeof(desc_string) / sizeof(desc_string[0]))
276 return dev_desc_send_string(usb, setup, desc_string[desc_index]);
278 case USB_DESC_TYPE_DEVICE_QUALIFIER:
280 case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
282 // if (usb->hpcd->Init.speed == PCD_SPEED_HIGH)
289 static void dev_get_configuration(struct usb *usb, struct setup_request *setup)
291 if (setup->wValue || setup->wIndex || setup->wLength != 1)
292 return usb_ctl_error(usb);
296 case USB_STATE_ADDRESSED:
297 usb_ctl_send_byte(usb, 0);
299 case USB_STATE_CONFIGURED:
300 usb_ctl_send_byte(usb, usb->config);
307 static void dev_set_configuration(struct usb *usb, struct setup_request *setup)
309 byte cfg = setup->wValue & 0xff;
311 // FIXME: Support more configurations
312 if (cfg > 1 || setup->wIndex || setup->wLength)
313 return usb_ctl_error(usb);
317 case USB_STATE_ADDRESSED:
321 usb->state = USB_STATE_CONFIGURED;
322 // FIXME: Notify that the device was configured
324 usb_ctl_send_status(usb);
326 case USB_STATE_CONFIGURED:
331 usb->state = USB_STATE_ADDRESSED;
332 // FIXME: Notify that the device was unconfigured
334 else if (cfg != usb->config)
337 // FIXME: Notify about configuration change
339 usb_ctl_send_status(usb);
346 static void dev_setup(struct usb *usb, struct setup_request *setup)
348 switch (setup->bRequest)
350 case USB_REQ_GET_STATUS:
351 return dev_get_status(usb, setup);
352 case USB_REQ_CLEAR_FEATURE:
353 return dev_clear_feature(usb, setup);
354 case USB_REQ_SET_FEATURE:
355 return dev_set_feature(usb, setup);
356 case USB_REQ_SET_ADDRESS:
357 return dev_set_address(usb, setup);
358 case USB_REQ_GET_DESCRIPTOR:
359 return dev_get_descriptor(usb, setup);
360 case USB_REQ_GET_CONFIGURATION:
361 return dev_get_configuration(usb, setup);
362 case USB_REQ_SET_CONFIGURATION:
363 return dev_set_configuration(usb, setup);
366 usb_ctl_setup_error(usb, setup);
369 static void intf_setup(struct usb *usb, struct setup_request *setup)
371 byte intf = setup->wIndex & 0xff;
375 // FIXME: Support more interfaces
380 switch (setup->bRequest)
382 case USB_REQ_GET_STATUS:
383 if (setup->wValue || setup->wLength != 2 || usb->state != USB_STATE_CONFIGURED)
386 usb_ctl_send_u16(usb, 0);
389 case USB_REQ_CLEAR_FEATURE:
390 case USB_REQ_SET_FEATURE:
391 // Interfaces have no standard features
392 return usb_ctl_error(usb);
395 usb_ctl_setup_error(usb, setup);
398 static void ep_setup(struct usb *usb, struct setup_request *setup)
400 byte ep_addr = setup->wIndex & 0x8f;
402 switch (setup->bRequest)
404 case USB_REQ_GET_STATUS:
405 if (setup->wValue || setup->wLength != 2)
406 return usb_ctl_error(usb);
409 case USB_STATE_ADDRESSED:
413 case USB_STATE_CONFIGURED:
415 if (usb_ep_is_stalled(usb, ep_addr))
416 usb_ctl_send_u16(usb, 1);
418 usb_ctl_send_u16(usb, 0);
422 return usb_ctl_error(usb);
426 case USB_REQ_SET_FEATURE:
428 return usb_ctl_error(usb);
431 case USB_STATE_ADDRESSED:
435 case USB_STATE_CONFIGURED:
436 if (setup->wValue == USB_FEATURE_EP_HALT)
439 usb_ep_stall(usb, ep_addr);
441 usb_ctl_send_status(usb);
448 case USB_REQ_CLEAR_FEATURE:
450 return usb_ctl_error(usb);
453 case USB_STATE_ADDRESSED:
457 case USB_STATE_CONFIGURED:
458 if (setup->wValue == USB_FEATURE_EP_HALT)
461 usb_ep_unstall(usb, ep_addr);
463 usb_ctl_send_status(usb);
471 usb_ctl_setup_error(usb, setup);
474 static void usb_handle_setup(struct usb *usb, struct setup_request *setup)
476 usb->ep0_state = USB_EP0_SETUP;
477 usb->ep0_setup_data_length = setup->wLength;
479 if ((setup->bmRequest & USB_REQ_TYPE_MASK) != USB_REQ_TYPE_STANDARD)
481 // FIXME: Class-specific and vendor-specific setup packets not supported
482 // FIXME: Check USB_STATE_CONFIGURED here
483 usb_ctl_setup_error(usb, setup);
486 switch (setup->bmRequest & USB_REQ_RECIPIENT_MASK)
488 case USB_REQ_RECIPIENT_DEVICE:
489 return dev_setup(usb, setup);
490 case USB_REQ_RECIPIENT_INTERFACE:
491 return intf_setup(usb, setup);
492 case USB_REQ_RECIPIENT_ENDPOINT:
493 return ep_setup(usb, setup);
496 usb_ctl_setup_error(usb, setup);
499 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
501 struct usb *usb = hpcd->pData;
502 byte *req = (byte *) hpcd->Setup;
504 struct setup_request setup = {
507 .wValue = get_u16(req+2),
508 .wIndex = get_u16(req+4),
509 .wLength = get_u16(req+2),
511 usb_handle_setup(usb, &setup);
514 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
516 struct usb *usb = hpcd->pData;
517 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
521 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
522 if (usb->ep0_state != USB_EP0_DATA_OUT)
524 if (usb->ep0_remaining_length > ep->maxpacket)
526 usb->ep0_remaining_length -= ep->maxpacket;
527 usb_ep_receive(usb, 0x00, ep->xfer_buff, MIN(usb->ep0_remaining_length, ep->maxpacket));
531 if (usb->state == USB_STATE_CONFIGURED)
533 // FIXME: Handle incoming control packet
535 usb_ctl_send_status(usb);
540 if (usb->state == USB_STATE_CONFIGURED)
542 // FIXME: Custom data callback
547 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
549 struct usb *usb = hpcd->pData;
550 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
554 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
555 if (usb->ep0_state != USB_EP0_DATA_IN)
557 if (usb->ep0_remaining_length > ep->maxpacket)
559 usb->ep0_remaining_length -= ep->maxpacket;
560 usb_ep_transmit(usb, 0x00, ep->xfer_buff, usb->ep0_remaining_length);
561 usb_ep_receive(usb, 0x00, NULL, 0);
563 else if (usb->ep0_total_length && usb->ep0_total_length % ep->maxpacket == 0 && usb->ep0_total_length < usb->ep0_setup_data_length)
566 * Each data transfer must be terminated by either a small packet (less than maxpacket)
567 * or by reaching the answer size requested in the setup packet. Send an empty final packet
570 usb_ep_transmit(usb, 0x00, NULL, 0);
571 usb->ep0_setup_data_length = 0;
572 usb_ep_receive(usb, 0x00, NULL, 0);
576 if (usb->state == USB_STATE_CONFIGURED)
578 // FIXME: Custom data callback
579 // All data have been sent
585 if (usb->state == USB_STATE_CONFIGURED)
587 // FIXME: Custom data callback
588 // This gets called when a complete message is sent
593 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
595 // We are not interested in Start of frame packets
596 // (neither we set hpcd->Init.Sof_enable, so this callback does not get called)
599 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
601 struct usb *usb = hpcd->pData;
603 usb->state = USB_STATE_DEFAULT;
605 usb_ep_open(usb, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
606 usb_ep_open(usb, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
609 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
611 struct usb *usb = hpcd->pData;
613 usb->pre_suspend_state = usb->state;
614 usb->state = USB_STATE_SUSPENDED;
616 if (hpcd->Init.low_power_enable)
617 SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
620 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
622 struct usb *usb = hpcd->pData;
623 usb->state = usb->pre_suspend_state;
626 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
628 // We do not support isochronous mode
631 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
633 // We do not support isochronous mode
636 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
640 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
642 struct usb *usb = hpcd->pData;
643 usb->state = USB_STATE_DEFAULT;