2 #include "stm32f1xx_hal.h"
9 void _Error_Handler(char * file, int line); // FIXME
11 #define DESC_U16(x) ((x) & 0xff), ((x) >> 8)
15 DESC_STR_MANUFACTURER,
18 DESC_STR_CONFIGURATION,
22 static const byte desc_device[] = {
24 USB_DESC_TYPE_DEVICE, // bDescriptorType
25 DESC_U16(0x0200), // bcdUSB
27 0x00, // bDeviceSubClass
28 0x00, // bDeviceProtocol
29 USB_MAX_EP0_SIZE, // bMaxPacketSize
30 DESC_U16(0x4242), // idVendor
31 DESC_U16(0x0001), // idProduct
32 DESC_U16(0x0200), // bcdDevice
33 DESC_STR_MANUFACTURER, // iManufacturer
34 DESC_STR_PRODUCT, // iProduct
35 DESC_STR_SERIAL, // iSerialNumber
36 USB_NUM_CONFIGURATIONS, // bNumConfigurations
39 static const byte desc_config[] = {
40 // Configuration descriptor
42 USB_DESC_TYPE_CONFIGURATION, // bDescriptorType
45 0x01, // bNumInterfaces
46 0x01, // bConfigurationValue
47 DESC_STR_CONFIGURATION, // iConfiguration
48 0xc0, // bmAttributes: bus-powered, supports remote wakeup
49 0x32, // Max power: 100 mA
50 // Interface descriptor
52 USB_DESC_TYPE_INTERFACE, // bDescriptorType
53 0x00, // bInterfaceNumber
54 0x00, // bAlternateSetting
55 0x02, // bNumEndpoints
56 0xff, // bInterfaceClass: vendor-defined
57 0x00, // bInterfaceSubClass
58 0x00, // nInterfaceProtocol
59 DESC_STR_INTERFACE, // iInterface
60 // End-point descriptor
62 USB_DESC_TYPE_ENDPOINT, // bDescriptorType
63 0x01, // bEndpointAddress
64 USB_EP_TYPE_BULK, // bmAttributes
65 0x40, 0x00, // wMaxPacketSize
66 0x00, // bInterval: unused
67 // End-point descriptor
69 USB_DESC_TYPE_ENDPOINT, // bDescriptorType
70 0x81, // bEndpointAddress
71 USB_EP_TYPE_BULK, // bmAttributes
72 0x40, 0x00, // wMaxPacketSize
73 0x00, // bInterval: unused
76 static const char * const desc_string[] = {
77 NULL, // DESC_STR_NONE
78 "United Computer Wizards", // DESC_STR_MANUFACTURER
79 "Mysterious Gadget", // DESC_STR_PRODUCT
80 "00000042", // DESC_STR_SERIAL
81 "Default Configuration", // DESC_STR_CONFIGURATION
82 "Default Interface", // DESC_STR_INTERFACE
85 static const byte desc_languages[] = {
87 USB_DESC_TYPE_STRING, // bDescriptorType
88 DESC_U16(1033), // English
91 void usb_init(struct usb *usb, PCD_HandleTypeDef *hpcd)
93 memset(usb, 0, sizeof(*usb));
95 usb->state = USB_STATE_DEFAULT;
96 usb->ep0_state = USB_EP0_IDLE;
100 void usb_start(struct usb *usb)
102 HAL_PCDEx_PMAConfig(usb->hpcd, 0x00, PCD_SNG_BUF, 0x18);
103 HAL_PCDEx_PMAConfig(usb->hpcd, 0x80, PCD_SNG_BUF, 0x58);
105 HAL_PCD_Start(usb->hpcd);
108 static inline uint get_u16(byte *p)
110 return (p[1] << 8) | p[0];
113 static inline void put_u16(byte *p, u16 x)
119 static void usb_ctl_send_status(struct usb *usb)
121 usb_debug("Control send: status\n");
122 usb->ep0_state = USB_EP0_STATUS_IN;
123 usb_ep_transmit(usb, 0x00, NULL, 0);
126 static void usb_ctl_recv_status(struct usb *usb)
128 usb->ep0_state = USB_EP0_STATUS_OUT;
129 usb_ep_receive(usb, 0x00, NULL, 0);
132 static void usb_ctl_send_data(struct usb *usb, const byte *data, uint len)
134 usb_debug("Control send: %u bytes\n", len);
135 usb->ep0_state = USB_EP0_DATA_IN;
136 usb->ep0_total_length = len;
137 usb->ep0_remaining_length = len;
138 usb_ep_transmit(usb, 0x00, data, len);
142 static void usb_ctl_recv_data(struct usb *usb, byte *data, uint len)
144 usb_debug("Control recv: %u bytes\n", len);
145 usb->ep0_state = USB_EP0_DATA_OUT;
146 usb->ep0_total_length = len;
147 usb->ep0_remaining_length = len;
148 usb_ep_transmit(usb, 0x00, data, len);
152 static void usb_ctl_send_byte(struct usb *usb, byte data)
154 usb->ep0_buf[0] = data;
155 usb_ctl_send_data(usb, usb->ep0_buf, 1);
158 static void usb_ctl_send_u16(struct usb *usb, u16 data)
160 put_u16(usb->ep0_buf, data);
161 usb_ctl_send_data(usb, usb->ep0_buf, 2);
164 static void usb_ctl_error(struct usb *usb)
166 usb_debug("Control packet error\n");
167 usb_ep_stall(usb, 0x00);
168 usb_ep_stall(usb, 0x80);
171 struct setup_request {
179 static void usb_ctl_setup_error(struct usb *usb, struct setup_request *setup)
181 usb_debug("Setup packet error\n");
182 usb_ep_stall(usb, setup->bmRequest & USB_REQ_DIRECTION);
185 static void dev_get_status(struct usb *usb, struct setup_request *setup)
187 if ((usb->state != USB_STATE_ADDRESSED && usb->state != USB_STATE_CONFIGURED) ||
188 setup->wValue || setup->wIndex || setup->wLength != 2)
189 return usb_ctl_error(usb);
192 #ifdef USB_SELF_POWERED
193 stat |= USB_DEV_STATUS_SELF_POWERED;
195 if (usb->remote_wakeup)
196 stat |= USB_DEV_STATUS_REMOTE_WAKEUP;
197 usb_ctl_send_u16(usb, stat);
200 static void dev_clear_feature(struct usb *usb, struct setup_request *setup)
202 if (setup->wIndex || setup->wLength)
203 return usb_ctl_error(usb);
205 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
207 usb->remote_wakeup = 0;
208 usb_ctl_send_status(usb);
214 static void dev_set_feature(struct usb *usb, struct setup_request *setup)
216 if (setup->wIndex || setup->wLength)
217 return usb_ctl_error(usb);
219 if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
221 usb->remote_wakeup = 1;
222 usb_ctl_send_status(usb);
228 static void dev_set_address(struct usb *usb, struct setup_request *setup)
230 if (setup->wIndex || setup->wLength)
231 return usb_ctl_error(usb);
233 uint addr = setup->wValue & 0x7f;
234 if (usb->state == USB_STATE_CONFIGURED)
239 HAL_PCD_SetAddress(usb->hpcd, addr);
240 usb_ctl_send_status(usb);
241 usb->state = addr ? USB_STATE_ADDRESSED : USB_STATE_DEFAULT;
245 static void dev_desc_send(struct usb *usb, struct setup_request *setup, const byte *desc, uint len)
247 len = MIN(len, setup->wLength);
249 usb_ctl_send_data(usb, desc, len);
252 static void dev_desc_send_string(struct usb *usb, struct setup_request *setup, const char *str)
254 byte *buf = usb->ep0_buf;
255 uint len = strlen(str);
258 buf[i++] = 2*len + 2;
259 buf[i++] = USB_DESC_TYPE_STRING;
261 while (i <= USB_EP0_BUF_SIZE - 2 && *str)
267 dev_desc_send(usb, setup, buf, i);
270 static void dev_get_descriptor(struct usb *usb, struct setup_request *setup)
272 byte desc_type = setup->wValue >> 8;
273 byte desc_index = setup->wValue & 0xff;
277 case USB_DESC_TYPE_DEVICE:
278 return dev_desc_send(usb, setup, desc_device, sizeof(desc_device));
279 case USB_DESC_TYPE_CONFIGURATION:
280 return dev_desc_send(usb, setup, desc_config, sizeof(desc_config));
281 case USB_DESC_TYPE_STRING:
283 return dev_desc_send(usb, setup, desc_languages, sizeof(desc_languages));
284 if (desc_index < sizeof(desc_string) / sizeof(desc_string[0]))
285 return dev_desc_send_string(usb, setup, desc_string[desc_index]);
287 case USB_DESC_TYPE_DEVICE_QUALIFIER:
289 case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
291 // if (usb->hpcd->Init.speed == PCD_SPEED_HIGH)
298 static void dev_get_configuration(struct usb *usb, struct setup_request *setup)
300 if (setup->wValue || setup->wIndex || setup->wLength != 1)
301 return usb_ctl_error(usb);
305 case USB_STATE_ADDRESSED:
306 usb_ctl_send_byte(usb, 0);
308 case USB_STATE_CONFIGURED:
309 usb_ctl_send_byte(usb, usb->config);
316 static void dev_set_configuration(struct usb *usb, struct setup_request *setup)
318 byte cfg = setup->wValue & 0xff;
320 // FIXME: Support more configurations
321 if (cfg > 1 || setup->wIndex || setup->wLength)
322 return usb_ctl_error(usb);
326 case USB_STATE_ADDRESSED:
330 usb->state = USB_STATE_CONFIGURED;
331 // FIXME: Notify that the device was configured
333 usb_ctl_send_status(usb);
335 case USB_STATE_CONFIGURED:
340 usb->state = USB_STATE_ADDRESSED;
341 // FIXME: Notify that the device was unconfigured
343 else if (cfg != usb->config)
346 // FIXME: Notify about configuration change
348 usb_ctl_send_status(usb);
355 static void dev_setup(struct usb *usb, struct setup_request *setup)
357 switch (setup->bRequest)
359 case USB_REQ_GET_STATUS:
360 return dev_get_status(usb, setup);
361 case USB_REQ_CLEAR_FEATURE:
362 return dev_clear_feature(usb, setup);
363 case USB_REQ_SET_FEATURE:
364 return dev_set_feature(usb, setup);
365 case USB_REQ_SET_ADDRESS:
366 return dev_set_address(usb, setup);
367 case USB_REQ_GET_DESCRIPTOR:
368 return dev_get_descriptor(usb, setup);
369 case USB_REQ_GET_CONFIGURATION:
370 return dev_get_configuration(usb, setup);
371 case USB_REQ_SET_CONFIGURATION:
372 return dev_set_configuration(usb, setup);
375 usb_ctl_setup_error(usb, setup);
378 static void intf_setup(struct usb *usb, struct setup_request *setup)
380 byte intf = setup->wIndex & 0xff;
384 // FIXME: Support more interfaces
389 switch (setup->bRequest)
391 case USB_REQ_GET_STATUS:
392 if (setup->wValue || setup->wLength != 2 || usb->state != USB_STATE_CONFIGURED)
395 usb_ctl_send_u16(usb, 0);
398 case USB_REQ_CLEAR_FEATURE:
399 case USB_REQ_SET_FEATURE:
400 // Interfaces have no standard features
401 return usb_ctl_error(usb);
404 usb_ctl_setup_error(usb, setup);
407 static void ep_setup(struct usb *usb, struct setup_request *setup)
409 byte ep_addr = setup->wIndex & 0x8f;
411 switch (setup->bRequest)
413 case USB_REQ_GET_STATUS:
414 if (setup->wValue || setup->wLength != 2)
415 return usb_ctl_error(usb);
418 case USB_STATE_ADDRESSED:
422 case USB_STATE_CONFIGURED:
424 if (usb_ep_is_stalled(usb, ep_addr))
425 usb_ctl_send_u16(usb, 1);
427 usb_ctl_send_u16(usb, 0);
431 return usb_ctl_error(usb);
435 case USB_REQ_SET_FEATURE:
437 return usb_ctl_error(usb);
440 case USB_STATE_ADDRESSED:
444 case USB_STATE_CONFIGURED:
445 if (setup->wValue == USB_FEATURE_EP_HALT)
448 usb_ep_stall(usb, ep_addr);
450 usb_ctl_send_status(usb);
457 case USB_REQ_CLEAR_FEATURE:
459 return usb_ctl_error(usb);
462 case USB_STATE_ADDRESSED:
466 case USB_STATE_CONFIGURED:
467 if (setup->wValue == USB_FEATURE_EP_HALT)
470 usb_ep_unstall(usb, ep_addr);
472 usb_ctl_send_status(usb);
480 usb_ctl_setup_error(usb, setup);
483 static void usb_handle_setup(struct usb *usb, struct setup_request *setup)
485 usb_debug("Setup: type=%02x req=%02x val=%04x idx=%04x len=%04x\n", setup->bmRequest, setup->bRequest, setup->wValue, setup->wIndex, setup->wLength);
487 usb->ep0_state = USB_EP0_SETUP;
488 usb->ep0_setup_data_length = setup->wLength;
490 if ((setup->bmRequest & USB_REQ_TYPE_MASK) != USB_REQ_TYPE_STANDARD)
492 // FIXME: Class-specific and vendor-specific setup packets not supported
493 // FIXME: Check USB_STATE_CONFIGURED here
494 usb_ctl_setup_error(usb, setup);
497 switch (setup->bmRequest & USB_REQ_RECIPIENT_MASK)
499 case USB_REQ_RECIPIENT_DEVICE:
500 return dev_setup(usb, setup);
501 case USB_REQ_RECIPIENT_INTERFACE:
502 return intf_setup(usb, setup);
503 case USB_REQ_RECIPIENT_ENDPOINT:
504 return ep_setup(usb, setup);
507 usb_ctl_setup_error(usb, setup);
510 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
512 struct usb *usb = hpcd->pData;
513 byte *req = (byte *) hpcd->Setup;
515 struct setup_request setup = {
518 .wValue = get_u16(req+2),
519 .wIndex = get_u16(req+4),
520 .wLength = get_u16(req+6),
522 usb_handle_setup(usb, &setup);
525 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
527 struct usb *usb = hpcd->pData;
528 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
532 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
533 usb_debug("Ep0 OUT: state=%u rem=%u total=%u\n", usb->ep0_state, usb->ep0_remaining_length, usb->ep0_total_length);
534 if (usb->ep0_state != USB_EP0_DATA_OUT)
536 if (usb->ep0_remaining_length > ep->maxpacket)
538 usb->ep0_remaining_length -= ep->maxpacket;
539 usb_ep_receive(usb, 0x00, ep->xfer_buff, MIN(usb->ep0_remaining_length, ep->maxpacket));
543 if (usb->state == USB_STATE_CONFIGURED)
545 // FIXME: Handle incoming control packet
547 usb_ctl_send_status(usb);
552 if (usb->state == USB_STATE_CONFIGURED)
554 // FIXME: Custom data callback
559 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
561 struct usb *usb = hpcd->pData;
562 PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
566 // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
567 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);
568 if (usb->ep0_state != USB_EP0_DATA_IN)
570 if (usb->ep0_remaining_length > ep->maxpacket)
572 usb->ep0_remaining_length -= ep->maxpacket;
573 usb_ep_transmit(usb, 0x00, ep->xfer_buff, usb->ep0_remaining_length);
574 usb_ep_receive(usb, 0x00, NULL, 0);
576 else if (usb->ep0_total_length && usb->ep0_total_length % ep->maxpacket == 0 && usb->ep0_total_length < usb->ep0_setup_data_length)
579 * Each data transfer must be terminated by either a small packet (less than maxpacket)
580 * or by reaching the answer size requested in the setup packet. Send an empty final packet
583 usb_ep_transmit(usb, 0x00, NULL, 0);
584 usb->ep0_setup_data_length = 0;
585 usb_ep_receive(usb, 0x00, NULL, 0);
589 if (usb->state == USB_STATE_CONFIGURED)
591 // FIXME: Custom data callback
592 // All data have been sent
594 usb_ctl_recv_status(usb);
599 if (usb->state == USB_STATE_CONFIGURED)
601 // FIXME: Custom data callback
602 // This gets called when a complete message is sent
607 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
609 // We are not interested in Start of frame packets
610 // (neither we set hpcd->Init.Sof_enable, so this callback does not get called)
613 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
615 struct usb *usb = hpcd->pData;
617 usb->state = USB_STATE_DEFAULT;
619 usb_ep_open(usb, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
620 usb_ep_open(usb, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
623 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
625 struct usb *usb = hpcd->pData;
627 usb->pre_suspend_state = usb->state;
628 usb->state = USB_STATE_SUSPENDED;
630 if (hpcd->Init.low_power_enable)
631 SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
634 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
636 struct usb *usb = hpcd->pData;
637 usb->state = usb->pre_suspend_state;
640 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
642 // We do not support isochronous mode
645 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
647 // We do not support isochronous mode
650 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
654 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
656 struct usb *usb = hpcd->pData;
657 usb->state = USB_STATE_DEFAULT;