34a13723d8
Rationale:
In USB device mode, the f103 chip provides 512 bytes
of memory for USB traffic. In the 'master' branch
of the blackmagic probe, the control endpoint pipe size
is set to 64 bytes, effectively consuming a quarter
(1 'in' endpoint, 1 'out' endpoint == 2 endpoints,
2 /* endpoints */ x 64 /* bytes per endpoint */ == 128 bytes
out of 512 /* bytes of precious usb packet memory */).
The USB standard, for full speed devices, does allow
a control endpoint size of 8 bytes.
I am not too aware of all the details of the USB standard,
but the USB standard seems to allow fragmented transactions
on the control USB pipe (endpoint 0), which libopencm3
apparently supports:
libopencm3/lib/usb/usb_control.c:usb_control_send_chunk()
I am using this change (from 64, to 8 bytes)
on a windows 10 machine, on an stlink hardware
('PROBE_HOST=stlink'). It works on my machine.
This change can potentially provide other USB endpoints
in the blackmagic firmware with more memory
566 lines
15 KiB
C
566 lines
15 KiB
C
/*
|
|
* This file is part of the Black Magic Debug project.
|
|
*
|
|
* Copyright (C) 2011 Black Sphere Technologies Ltd.
|
|
* Written by Gareth McMullin <gareth@blacksphere.co.nz>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* This file implements a the USB Communications Device Class - Abstract
|
|
* Control Model (CDC-ACM) as defined in CDC PSTN subclass 1.2.
|
|
* A Device Firmware Upgrade (DFU 1.1) class interface is provided for
|
|
* field firmware upgrade.
|
|
*
|
|
* The device's unique id is used as the USB serial number string.
|
|
*/
|
|
|
|
#include "general.h"
|
|
#include "gdb_if.h"
|
|
#include "cdcacm.h"
|
|
#if defined(PLATFORM_HAS_TRACESWO)
|
|
# include "traceswo.h"
|
|
#endif
|
|
#include "usbuart.h"
|
|
#include "serialno.h"
|
|
|
|
#include <libopencm3/cm3/nvic.h>
|
|
#include <libopencm3/usb/usbd.h>
|
|
#include <libopencm3/usb/cdc.h>
|
|
#include <libopencm3/cm3/scb.h>
|
|
#include <libopencm3/usb/dfu.h>
|
|
#include <stdlib.h>
|
|
|
|
#define DFU_IF_NO 4
|
|
|
|
usbd_device * usbdev;
|
|
|
|
static int configured;
|
|
static int cdcacm_gdb_dtr = 1;
|
|
|
|
static void cdcacm_set_modem_state(usbd_device *dev, int iface, bool dsr, bool dcd);
|
|
|
|
static const struct usb_device_descriptor dev = {
|
|
.bLength = USB_DT_DEVICE_SIZE,
|
|
.bDescriptorType = USB_DT_DEVICE,
|
|
.bcdUSB = 0x0200,
|
|
.bDeviceClass = 0xEF, /* Miscellaneous Device */
|
|
.bDeviceSubClass = 2, /* Common Class */
|
|
.bDeviceProtocol = 1, /* Interface Association */
|
|
.bMaxPacketSize0 = 8,
|
|
.idVendor = 0x1D50,
|
|
.idProduct = 0x6018,
|
|
.bcdDevice = 0x0100,
|
|
.iManufacturer = 1,
|
|
.iProduct = 2,
|
|
.iSerialNumber = 3,
|
|
.bNumConfigurations = 1,
|
|
};
|
|
|
|
/* This notification endpoint isn't implemented. According to CDC spec its
|
|
* optional, but its absence causes a NULL pointer dereference in Linux cdc_acm
|
|
* driver. */
|
|
static const struct usb_endpoint_descriptor gdb_comm_endp[] = {{
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x82,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
|
|
.wMaxPacketSize = 16,
|
|
.bInterval = 255,
|
|
}};
|
|
|
|
static const struct usb_endpoint_descriptor gdb_data_endp[] = {{
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x01,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_BULK,
|
|
.wMaxPacketSize = CDCACM_PACKET_SIZE,
|
|
.bInterval = 1,
|
|
}, {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x81,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_BULK,
|
|
.wMaxPacketSize = CDCACM_PACKET_SIZE,
|
|
.bInterval = 1,
|
|
}};
|
|
|
|
static const struct {
|
|
struct usb_cdc_header_descriptor header;
|
|
struct usb_cdc_call_management_descriptor call_mgmt;
|
|
struct usb_cdc_acm_descriptor acm;
|
|
struct usb_cdc_union_descriptor cdc_union;
|
|
} __attribute__((packed)) gdb_cdcacm_functional_descriptors = {
|
|
.header = {
|
|
.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
|
|
.bcdCDC = 0x0110,
|
|
},
|
|
.call_mgmt = {
|
|
.bFunctionLength =
|
|
sizeof(struct usb_cdc_call_management_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
|
|
.bmCapabilities = 0,
|
|
.bDataInterface = 1,
|
|
},
|
|
.acm = {
|
|
.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_ACM,
|
|
.bmCapabilities = 2, /* SET_LINE_CODING supported */
|
|
},
|
|
.cdc_union = {
|
|
.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_UNION,
|
|
.bControlInterface = 0,
|
|
.bSubordinateInterface0 = 1,
|
|
}
|
|
};
|
|
|
|
static const struct usb_interface_descriptor gdb_comm_iface[] = {{
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 0,
|
|
.bAlternateSetting = 0,
|
|
.bNumEndpoints = 1,
|
|
.bInterfaceClass = USB_CLASS_CDC,
|
|
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
|
.bInterfaceProtocol = USB_CDC_PROTOCOL_AT,
|
|
.iInterface = 4,
|
|
|
|
.endpoint = gdb_comm_endp,
|
|
|
|
.extra = &gdb_cdcacm_functional_descriptors,
|
|
.extralen = sizeof(gdb_cdcacm_functional_descriptors)
|
|
}};
|
|
|
|
static const struct usb_interface_descriptor gdb_data_iface[] = {{
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 1,
|
|
.bAlternateSetting = 0,
|
|
.bNumEndpoints = 2,
|
|
.bInterfaceClass = USB_CLASS_DATA,
|
|
.bInterfaceSubClass = 0,
|
|
.bInterfaceProtocol = 0,
|
|
.iInterface = 0,
|
|
|
|
.endpoint = gdb_data_endp,
|
|
}};
|
|
|
|
static const struct usb_iface_assoc_descriptor gdb_assoc = {
|
|
.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
|
|
.bFirstInterface = 0,
|
|
.bInterfaceCount = 2,
|
|
.bFunctionClass = USB_CLASS_CDC,
|
|
.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
|
|
.bFunctionProtocol = USB_CDC_PROTOCOL_AT,
|
|
.iFunction = 0,
|
|
};
|
|
|
|
/* Serial ACM interface */
|
|
static const struct usb_endpoint_descriptor uart_comm_endp[] = {{
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x84,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
|
|
.wMaxPacketSize = 16,
|
|
.bInterval = 255,
|
|
}};
|
|
|
|
static const struct usb_endpoint_descriptor uart_data_endp[] = {{
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x03,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_BULK,
|
|
.wMaxPacketSize = CDCACM_PACKET_SIZE / 2,
|
|
.bInterval = 1,
|
|
}, {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x83,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_BULK,
|
|
.wMaxPacketSize = CDCACM_PACKET_SIZE,
|
|
.bInterval = 1,
|
|
}};
|
|
|
|
static const struct {
|
|
struct usb_cdc_header_descriptor header;
|
|
struct usb_cdc_call_management_descriptor call_mgmt;
|
|
struct usb_cdc_acm_descriptor acm;
|
|
struct usb_cdc_union_descriptor cdc_union;
|
|
} __attribute__((packed)) uart_cdcacm_functional_descriptors = {
|
|
.header = {
|
|
.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
|
|
.bcdCDC = 0x0110,
|
|
},
|
|
.call_mgmt = {
|
|
.bFunctionLength =
|
|
sizeof(struct usb_cdc_call_management_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
|
|
.bmCapabilities = 0,
|
|
.bDataInterface = 3,
|
|
},
|
|
.acm = {
|
|
.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_ACM,
|
|
.bmCapabilities = 2, /* SET_LINE_CODING supported*/
|
|
},
|
|
.cdc_union = {
|
|
.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
|
|
.bDescriptorType = CS_INTERFACE,
|
|
.bDescriptorSubtype = USB_CDC_TYPE_UNION,
|
|
.bControlInterface = 2,
|
|
.bSubordinateInterface0 = 3,
|
|
}
|
|
};
|
|
|
|
static const struct usb_interface_descriptor uart_comm_iface[] = {{
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 2,
|
|
.bAlternateSetting = 0,
|
|
.bNumEndpoints = 1,
|
|
.bInterfaceClass = USB_CLASS_CDC,
|
|
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
|
.bInterfaceProtocol = USB_CDC_PROTOCOL_AT,
|
|
.iInterface = 5,
|
|
|
|
.endpoint = uart_comm_endp,
|
|
|
|
.extra = &uart_cdcacm_functional_descriptors,
|
|
.extralen = sizeof(uart_cdcacm_functional_descriptors)
|
|
}};
|
|
|
|
static const struct usb_interface_descriptor uart_data_iface[] = {{
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 3,
|
|
.bAlternateSetting = 0,
|
|
.bNumEndpoints = 2,
|
|
.bInterfaceClass = USB_CLASS_DATA,
|
|
.bInterfaceSubClass = 0,
|
|
.bInterfaceProtocol = 0,
|
|
.iInterface = 0,
|
|
|
|
.endpoint = uart_data_endp,
|
|
}};
|
|
|
|
static const struct usb_iface_assoc_descriptor uart_assoc = {
|
|
.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
|
|
.bFirstInterface = 2,
|
|
.bInterfaceCount = 2,
|
|
.bFunctionClass = USB_CLASS_CDC,
|
|
.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
|
|
.bFunctionProtocol = USB_CDC_PROTOCOL_AT,
|
|
.iFunction = 0,
|
|
};
|
|
|
|
const struct usb_dfu_descriptor dfu_function = {
|
|
.bLength = sizeof(struct usb_dfu_descriptor),
|
|
.bDescriptorType = DFU_FUNCTIONAL,
|
|
.bmAttributes = USB_DFU_CAN_DOWNLOAD | USB_DFU_WILL_DETACH,
|
|
.wDetachTimeout = 255,
|
|
.wTransferSize = 1024,
|
|
.bcdDFUVersion = 0x011A,
|
|
};
|
|
|
|
const struct usb_interface_descriptor dfu_iface = {
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = DFU_IF_NO,
|
|
.bAlternateSetting = 0,
|
|
.bNumEndpoints = 0,
|
|
.bInterfaceClass = 0xFE,
|
|
.bInterfaceSubClass = 1,
|
|
.bInterfaceProtocol = 1,
|
|
.iInterface = 6,
|
|
|
|
.extra = &dfu_function,
|
|
.extralen = sizeof(dfu_function),
|
|
};
|
|
|
|
static const struct usb_iface_assoc_descriptor dfu_assoc = {
|
|
.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
|
|
.bFirstInterface = 4,
|
|
.bInterfaceCount = 1,
|
|
.bFunctionClass = 0xFE,
|
|
.bFunctionSubClass = 1,
|
|
.bFunctionProtocol = 1,
|
|
.iFunction = 6,
|
|
};
|
|
|
|
#if defined(PLATFORM_HAS_TRACESWO)
|
|
static const struct usb_endpoint_descriptor trace_endp[] = {{
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 0x85,
|
|
.bmAttributes = USB_ENDPOINT_ATTR_BULK,
|
|
.wMaxPacketSize = 64,
|
|
.bInterval = 0,
|
|
}};
|
|
|
|
const struct usb_interface_descriptor trace_iface = {
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 5,
|
|
.bAlternateSetting = 0,
|
|
.bNumEndpoints = 1,
|
|
.bInterfaceClass = 0xFF,
|
|
.bInterfaceSubClass = 0xFF,
|
|
.bInterfaceProtocol = 0xFF,
|
|
.iInterface = 7,
|
|
|
|
.endpoint = trace_endp,
|
|
};
|
|
|
|
static const struct usb_iface_assoc_descriptor trace_assoc = {
|
|
.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
|
|
.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
|
|
.bFirstInterface = 5,
|
|
.bInterfaceCount = 1,
|
|
.bFunctionClass = 0xFF,
|
|
.bFunctionSubClass = 0xFF,
|
|
.bFunctionProtocol = 0xFF,
|
|
.iFunction = 7,
|
|
};
|
|
#endif
|
|
|
|
static const struct usb_interface ifaces[] = {{
|
|
.num_altsetting = 1,
|
|
.iface_assoc = &gdb_assoc,
|
|
.altsetting = gdb_comm_iface,
|
|
}, {
|
|
.num_altsetting = 1,
|
|
.altsetting = gdb_data_iface,
|
|
}, {
|
|
.num_altsetting = 1,
|
|
.iface_assoc = &uart_assoc,
|
|
.altsetting = uart_comm_iface,
|
|
}, {
|
|
.num_altsetting = 1,
|
|
.altsetting = uart_data_iface,
|
|
}, {
|
|
.num_altsetting = 1,
|
|
.iface_assoc = &dfu_assoc,
|
|
.altsetting = &dfu_iface,
|
|
#if defined(PLATFORM_HAS_TRACESWO)
|
|
}, {
|
|
.num_altsetting = 1,
|
|
.iface_assoc = &trace_assoc,
|
|
.altsetting = &trace_iface,
|
|
#endif
|
|
}};
|
|
|
|
static const struct usb_config_descriptor config = {
|
|
.bLength = USB_DT_CONFIGURATION_SIZE,
|
|
.bDescriptorType = USB_DT_CONFIGURATION,
|
|
.wTotalLength = 0,
|
|
#if defined(PLATFORM_HAS_TRACESWO)
|
|
.bNumInterfaces = 6,
|
|
#else
|
|
.bNumInterfaces = 5,
|
|
#endif
|
|
.bConfigurationValue = 1,
|
|
.iConfiguration = 0,
|
|
.bmAttributes = 0x80,
|
|
.bMaxPower = 0x32,
|
|
|
|
.interface = ifaces,
|
|
};
|
|
|
|
#if defined(STM32L0) || defined(STM32F3) || defined(STM32F4)
|
|
char serial_no[13];
|
|
#else
|
|
char serial_no[9];
|
|
#endif
|
|
|
|
static const char *usb_strings[] = {
|
|
"Black Sphere Technologies",
|
|
BOARD_IDENT,
|
|
serial_no,
|
|
"Black Magic GDB Server",
|
|
"Black Magic UART Port",
|
|
DFU_IDENT,
|
|
#if defined(PLATFORM_HAS_TRACESWO)
|
|
"Black Magic Trace Capture",
|
|
#endif
|
|
};
|
|
|
|
static void dfu_detach_complete(usbd_device *dev, struct usb_setup_data *req)
|
|
{
|
|
(void)dev;
|
|
(void)req;
|
|
|
|
platform_request_boot();
|
|
|
|
/* Reset core to enter bootloader */
|
|
scb_reset_core();
|
|
}
|
|
|
|
static enum usbd_request_return_codes cdcacm_control_request(usbd_device *dev,
|
|
struct usb_setup_data *req, uint8_t **buf, uint16_t *len,
|
|
void (**complete)(usbd_device *dev, struct usb_setup_data *req))
|
|
{
|
|
(void)dev;
|
|
(void)complete;
|
|
(void)buf;
|
|
(void)len;
|
|
|
|
switch(req->bRequest) {
|
|
case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
|
|
cdcacm_set_modem_state(dev, req->wIndex, true, true);
|
|
/* Ignore if not for GDB interface */
|
|
if(req->wIndex != 0)
|
|
return USBD_REQ_HANDLED;
|
|
|
|
cdcacm_gdb_dtr = req->wValue & 1;
|
|
|
|
return USBD_REQ_HANDLED;
|
|
case USB_CDC_REQ_SET_LINE_CODING:
|
|
if(*len < sizeof(struct usb_cdc_line_coding))
|
|
return USBD_REQ_NOTSUPP;
|
|
|
|
switch(req->wIndex) {
|
|
case 2:
|
|
usbuart_set_line_coding((struct usb_cdc_line_coding*)*buf);
|
|
return USBD_REQ_HANDLED;
|
|
case 0:
|
|
return USBD_REQ_HANDLED; /* Ignore on GDB Port */
|
|
default:
|
|
return USBD_REQ_NOTSUPP;
|
|
}
|
|
case DFU_GETSTATUS:
|
|
if(req->wIndex == DFU_IF_NO) {
|
|
(*buf)[0] = DFU_STATUS_OK;
|
|
(*buf)[1] = 0;
|
|
(*buf)[2] = 0;
|
|
(*buf)[3] = 0;
|
|
(*buf)[4] = STATE_APP_IDLE;
|
|
(*buf)[5] = 0; /* iString not used here */
|
|
*len = 6;
|
|
|
|
return USBD_REQ_HANDLED;
|
|
}
|
|
return USBD_REQ_NOTSUPP;
|
|
case DFU_DETACH:
|
|
if(req->wIndex == DFU_IF_NO) {
|
|
*complete = dfu_detach_complete;
|
|
return USBD_REQ_HANDLED;
|
|
}
|
|
return USBD_REQ_NOTSUPP;
|
|
}
|
|
return USBD_REQ_NOTSUPP;
|
|
}
|
|
|
|
int cdcacm_get_config(void)
|
|
{
|
|
return configured;
|
|
}
|
|
|
|
int cdcacm_get_dtr(void)
|
|
{
|
|
return cdcacm_gdb_dtr;
|
|
}
|
|
|
|
static void cdcacm_set_modem_state(usbd_device *dev, int iface, bool dsr, bool dcd)
|
|
{
|
|
char buf[10];
|
|
struct usb_cdc_notification *notif = (void*)buf;
|
|
/* We echo signals back to host as notification */
|
|
notif->bmRequestType = 0xA1;
|
|
notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE;
|
|
notif->wValue = 0;
|
|
notif->wIndex = iface;
|
|
notif->wLength = 2;
|
|
buf[8] = (dsr ? 2 : 0) | (dcd ? 1 : 0);
|
|
buf[9] = 0;
|
|
usbd_ep_write_packet(dev, 0x82 + iface, buf, 10);
|
|
}
|
|
|
|
static void cdcacm_set_config(usbd_device *dev, uint16_t wValue)
|
|
{
|
|
configured = wValue;
|
|
|
|
/* GDB interface */
|
|
#if defined(STM32F4) || defined(LM4F)
|
|
usbd_ep_setup(dev, 0x01, USB_ENDPOINT_ATTR_BULK,
|
|
CDCACM_PACKET_SIZE, gdb_usb_out_cb);
|
|
#else
|
|
usbd_ep_setup(dev, 0x01, USB_ENDPOINT_ATTR_BULK,
|
|
CDCACM_PACKET_SIZE, NULL);
|
|
#endif
|
|
usbd_ep_setup(dev, 0x81, USB_ENDPOINT_ATTR_BULK,
|
|
CDCACM_PACKET_SIZE, NULL);
|
|
usbd_ep_setup(dev, 0x82, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
|
|
|
|
/* Serial interface */
|
|
usbd_ep_setup(dev, 0x03, USB_ENDPOINT_ATTR_BULK,
|
|
CDCACM_PACKET_SIZE / 2, usbuart_usb_out_cb);
|
|
usbd_ep_setup(dev, 0x83, USB_ENDPOINT_ATTR_BULK,
|
|
CDCACM_PACKET_SIZE, usbuart_usb_in_cb);
|
|
usbd_ep_setup(dev, 0x84, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
|
|
|
|
#if defined(PLATFORM_HAS_TRACESWO)
|
|
/* Trace interface */
|
|
usbd_ep_setup(dev, 0x85, USB_ENDPOINT_ATTR_BULK,
|
|
64, trace_buf_drain);
|
|
#endif
|
|
|
|
usbd_register_control_callback(dev,
|
|
USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE,
|
|
USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
|
|
cdcacm_control_request);
|
|
|
|
/* Notify the host that DCD is asserted.
|
|
* Allows the use of /dev/tty* devices on *BSD/MacOS
|
|
*/
|
|
cdcacm_set_modem_state(dev, 0, true, true);
|
|
cdcacm_set_modem_state(dev, 2, true, true);
|
|
}
|
|
|
|
/* We need a special large control buffer for this device: */
|
|
uint8_t usbd_control_buffer[256];
|
|
|
|
void cdcacm_init(void)
|
|
{
|
|
void exti15_10_isr(void);
|
|
|
|
serialno_read(serial_no);
|
|
|
|
usbdev = usbd_init(&USB_DRIVER, &dev, &config, usb_strings,
|
|
sizeof(usb_strings)/sizeof(char *),
|
|
usbd_control_buffer, sizeof(usbd_control_buffer));
|
|
|
|
usbd_register_set_config_callback(usbdev, cdcacm_set_config);
|
|
|
|
nvic_set_priority(USB_IRQ, IRQ_PRI_USB);
|
|
nvic_enable_irq(USB_IRQ);
|
|
}
|
|
|
|
void USB_ISR(void)
|
|
{
|
|
usbd_poll(usbdev);
|
|
}
|