test-shutters: USB interface via control requests

[home-hw.git] / test-shutters / main.c

diff --git a/test-shutters/main.c b/test-shutters/main.c
index 275b9ba7860d00b78ad4fed9633f08361efb006a..fd7b72858ac390d87fb3bcc5a7c9b952c27fa42d 100644 (file)
--- a/test-shutters/main.c
+++ b/test-shutters/main.c
@@ -131,27 +131,17 @@ static const struct usb_device_descriptor device = {
        .bNumConfigurations = 1,
 };
 
-static const struct usb_endpoint_descriptor endpoints[] = {{
-       // Bulk end-point for sending values to the display
-       .bLength = USB_DT_ENDPOINT_SIZE,
-       .bDescriptorType = USB_DT_ENDPOINT,
-       .bEndpointAddress = 0x01,
-       .bmAttributes = USB_ENDPOINT_ATTR_BULK,
-       .wMaxPacketSize = 64,
-       .bInterval = 1,
-}};
-
 static const struct usb_interface_descriptor iface = {
        .bLength = USB_DT_INTERFACE_SIZE,
        .bDescriptorType = USB_DT_INTERFACE,
        .bInterfaceNumber = 0,
        .bAlternateSetting = 0,
-       .bNumEndpoints = 1,
+       .bNumEndpoints = 0,
        .bInterfaceClass = 0xFF,
        .bInterfaceSubClass = 0,
        .bInterfaceProtocol = 0,
        .iInterface = 0,
-       .endpoint = endpoints,
+       .endpoint = NULL,
 };
 
 static const struct usb_dfu_descriptor dfu_function = {
@@ -201,6 +191,8 @@ static const struct usb_config_descriptor config = {
 static byte usb_configured;
 static uint8_t usbd_control_buffer[64];
 
+uint csense_counters[2] = { 0, 0 };
+
 static void dfu_detach_complete(usbd_device *dev UNUSED, struct usb_setup_data *req UNUSED)
 {
        // Reset to bootloader, which implements the rest of DFU
@@ -222,22 +214,69 @@ static enum usbd_request_return_codes dfu_control_cb(usbd_device *dev UNUSED,
        return USBD_REQ_HANDLED;
 }
 
-static void ep01_cb(usbd_device *dev, uint8_t ep UNUSED)
+static enum usbd_request_return_codes control_cb(
+       usbd_device *dev UNUSED,
+       struct usb_setup_data *req,
+       uint8_t **buf,
+       uint16_t *len,
+       void (**complete)(usbd_device *dev, struct usb_setup_data *req) UNUSED)
 {
-       // We received a frame from the USB host
-       byte buf[8];
-       uint len = usbd_ep_read_packet(dev, 0x01, buf, 8);
-       debug_printf("USB: Host sent %u bytes\n", len);
+       uint index = req->wIndex;
+       uint value = req->wValue;
+
+       if (req->bmRequestType == (USB_REQ_TYPE_IN | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE)) {
+               debug_printf("Control request IN %02x (index=%d, len=%d)\n", req->bRequest, index, *len);
+
+               const byte *reply = NULL;
+               uint reply_len = 0;
+
+               switch (req->bRequest) {
+                       case 0:
+                               reply = (const byte *) &csense_counters;
+                               reply_len = sizeof(csense_counters);
+                               break;
+                       default:
+                               return USBD_REQ_NOTSUPP;
+               }
+
+               uint n = MIN(*len, reply_len);
+               memcpy(*buf, reply, n);
+               *len = n;
+               return USBD_REQ_HANDLED;
+       } else if (req->bmRequestType == (USB_REQ_TYPE_OUT | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE)) {
+               debug_printf("Control request OUT %02x (index=%d, val=%d, len=%d)\n", req->bRequest, index, value, *len);
+
+               switch (req->bRequest) {
+                       case 1:
+                               if (*len != 0)
+                                       return USBD_REQ_NOTSUPP;
+                               if (value & 1)
+                                       gpio_clear(GPIOB, GPIO6);
+                               else
+                                       gpio_set(GPIOB, GPIO6);
+                               break;
+                       default:
+                               return USBD_REQ_NOTSUPP;
+               }
+
+               return USBD_REQ_HANDLED;
+       } else {
+               return USBD_REQ_NOTSUPP;
+       }
 }
 
 static void set_config_cb(usbd_device *dev, uint16_t wValue UNUSED)
 {
+       usbd_register_control_callback(
+               dev,
+               USB_REQ_TYPE_VENDOR,
+               USB_REQ_TYPE_TYPE,
+               control_cb);
        usbd_register_control_callback(
                dev,
                USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE,
                USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
                dfu_control_cb);
-       usbd_ep_setup(dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, ep01_cb);
        usb_configured = 1;
 }
 
@@ -300,17 +339,15 @@ int main(void)
        usb_init();
 
        u32 last_blink = 0;
-       uint csense[2] = { 0, 0 };
 
        for (;;) {
                if (ms_ticks - last_blink >= 1000) {
                        debug_led_toggle();
                        last_blink = ms_ticks;
-                       debug_printf("C: %u %u\n", csense[0], csense[1]);
-                       csense[0] = csense[1] = 0;
+                       debug_printf("C: %u %u\n", csense_counters[0], csense_counters[1]);
                }
 
-               csense[gpio_get(GPIOA, GPIO0)]++;
+               csense_counters[gpio_get(GPIOA, GPIO0)]++;
 
                if (usart_get_flag(USART1, USART_SR_RXNE)) {
                        uint ch = usart_recv(USART1);