diff options
Diffstat (limited to 'atmel-samd/asf4/samd21/usb')
24 files changed, 6879 insertions, 0 deletions
diff --git a/atmel-samd/asf4/samd21/usb/class/cdc/device/cdcdf_acm.c b/atmel-samd/asf4/samd21/usb/class/cdc/device/cdcdf_acm.c new file mode 100644 index 000000000..f0a8de446 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/cdc/device/cdcdf_acm.c @@ -0,0 +1,389 @@ +/** + * \file + * + * \brief USB Device Stack CDC ACM Function Implementation. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel micro controller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#include "cdcdf_acm.h" + +#define CDCDF_ACM_VERSION 0x00000001u +#define CDCDF_ACM_COMM_EP_INDEX 0 +#define CDCDF_ACM_DATA_EP_INDEX 1 + +/** USB Device CDC ACM Fucntion Specific Data */ +struct cdcdf_acm_func_data { + /** CDC Device ACM Interface information */ + uint8_t func_iface[2]; + /** CDC Device ACM IN Endpoint */ + uint8_t func_ep_in[2]; + /** CDC Device ACM OUT Endpoint */ + uint8_t func_ep_out; + /** CDC Device ACM Enable Flag */ + bool enabled; +}; + +static struct usbdf_driver _cdcdf_acm; +static struct cdcdf_acm_func_data _cdcdf_acm_funcd; +static struct usb_cdc_line_coding usbd_cdc_line_coding; + +static cdcdf_acm_notify_state_t cdcdf_acm_notify_state = NULL; +static cdcdf_acm_set_line_coding_t cdcdf_acm_set_line_coding = NULL; + +/** + * \brief Enable CDC ACM Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB interface descriptor + * \return Operation status. + */ +static int32_t cdcdf_acm_enable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + struct cdcdf_acm_func_data *func_data = (struct cdcdf_acm_func_data *)(drv->func_data); + + usb_ep_desc_t ep_desc; + usb_iface_desc_t ifc_desc; + uint8_t * ifc, *ep; + uint8_t i; + + ifc = desc->sod; + for (i = 0; i < 2; i++) { + if (NULL == ifc) { + return ERR_NOT_FOUND; + } + + ifc_desc.bInterfaceNumber = ifc[2]; + ifc_desc.bInterfaceClass = ifc[5]; + + if ((CDC_CLASS_COMM == ifc_desc.bInterfaceClass) || (CDC_CLASS_DATA == ifc_desc.bInterfaceClass)) { + if (func_data->func_iface[i] == ifc_desc.bInterfaceNumber) { // Initialized + return ERR_ALREADY_INITIALIZED; + } else if (func_data->func_iface[i] != 0xFF) { // Occupied + return ERR_NO_RESOURCE; + } else { + func_data->func_iface[i] = ifc_desc.bInterfaceNumber; + } + } else { // Not supported by this function driver + return ERR_NOT_FOUND; + } + + // Install endpoints + ep = usb_find_desc(ifc, desc->eod, USB_DT_ENDPOINT); + while (NULL != ep) { + ep_desc.bEndpointAddress = ep[2]; + ep_desc.bmAttributes = ep[3]; + ep_desc.wMaxPacketSize = usb_get_u16(ep + 4); + if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) { + return ERR_NOT_INITIALIZED; + } + if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) { + func_data->func_ep_in[i] = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_in[i]); + } else { + func_data->func_ep_out = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_out); + } + desc->sod = ep; + ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod); + } + ifc = usb_find_desc(usb_desc_next(desc->sod), desc->eod, USB_DT_INTERFACE); + } + // Installed + _cdcdf_acm_funcd.enabled = true; + return ERR_NONE; +} + +/** + * \brief Disable CDC ACM Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB device descriptor + * \return Operation status. + */ +static int32_t cdcdf_acm_disable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + struct cdcdf_acm_func_data *func_data = (struct cdcdf_acm_func_data *)(drv->func_data); + + usb_iface_desc_t ifc_desc; + uint8_t i; + + if (desc) { + ifc_desc.bInterfaceClass = desc->sod[5]; + // Check interface + if ((ifc_desc.bInterfaceClass != CDC_CLASS_COMM) && (ifc_desc.bInterfaceClass != CDC_CLASS_DATA)) { + return ERR_NOT_FOUND; + } + } + + for (i = 0; i < 2; i++) { + if (func_data->func_iface[i] == 0xFF) { + continue; + } else { + func_data->func_iface[i] = 0xFF; + if (func_data->func_ep_in[i] != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_in[i]); + func_data->func_ep_in[i] = 0xFF; + } + } + } + + if (func_data->func_ep_out != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_out); + func_data->func_ep_out = 0xFF; + } + + _cdcdf_acm_funcd.enabled = false; + return ERR_NONE; +} + +/** + * \brief CDC ACM Control Function + * \param[in] drv Pointer to USB device function driver + * \param[in] ctrl USB device general function control type + * \param[in] param Parameter pointer + * \return Operation status. + */ +static int32_t cdcdf_acm_ctrl(struct usbdf_driver *drv, enum usbdf_control ctrl, void *param) +{ + switch (ctrl) { + case USBDF_ENABLE: + return cdcdf_acm_enable(drv, (struct usbd_descriptors *)param); + + case USBDF_DISABLE: + return cdcdf_acm_disable(drv, (struct usbd_descriptors *)param); + + case USBDF_GET_IFACE: + return ERR_UNSUPPORTED_OP; + + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the CDC class set request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t cdcdf_acm_set_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + struct usb_cdc_line_coding line_coding_tmp; + uint16_t len = req->wLength; + uint8_t * ctrl_buf = usbdc_get_ctrl_buffer(); + + switch (req->bRequest) { + case USB_REQ_CDC_SET_LINE_CODING: + if (sizeof(struct usb_cdc_line_coding) != len) { + return ERR_INVALID_DATA; + } + if (USB_SETUP_STAGE == stage) { + return usbdc_xfer(ep, ctrl_buf, len, false); + } else { + memcpy(&line_coding_tmp, ctrl_buf, sizeof(struct usb_cdc_line_coding)); + if ((NULL == cdcdf_acm_set_line_coding) || (true == cdcdf_acm_set_line_coding(&line_coding_tmp))) { + usbd_cdc_line_coding = line_coding_tmp; + } + return ERR_NONE; + } + case USB_REQ_CDC_SET_CONTROL_LINE_STATE: + usbdc_xfer(0, NULL, 0, 0); + if (NULL != cdcdf_acm_notify_state) { + cdcdf_acm_notify_state(req->wValue); + } + return ERR_NONE; + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the CDC class get request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t cdcdf_acm_get_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + uint16_t len = req->wLength; + + if (USB_DATA_STAGE == stage) { + return ERR_NONE; + } + + switch (req->bRequest) { + case USB_REQ_CDC_GET_LINE_CODING: + if (sizeof(struct usb_cdc_line_coding) != len) { + return ERR_INVALID_DATA; + } + return usbdc_xfer(ep, (uint8_t *)&usbd_cdc_line_coding, len, false); + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the CDC class request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t cdcdf_acm_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request + return ERR_NOT_FOUND; + } + if ((req->wIndex == _cdcdf_acm_funcd.func_iface[0]) || (req->wIndex == _cdcdf_acm_funcd.func_iface[1])) { + if (req->bmRequestType & USB_EP_DIR_IN) { + return cdcdf_acm_get_req(ep, req, stage); + } else { + return cdcdf_acm_set_req(ep, req, stage); + } + } else { + return ERR_NOT_FOUND; + } +} + +/** USB Device CDC ACM Handler Struct */ +static struct usbdc_handler cdcdf_acm_req_h = {NULL, (FUNC_PTR)cdcdf_acm_req}; + +/** + * \brief Initialize the USB CDC ACM Function Driver + */ +int32_t cdcdf_acm_init(void) +{ + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _cdcdf_acm.ctrl = cdcdf_acm_ctrl; + _cdcdf_acm.func_data = &_cdcdf_acm_funcd; + + usbdc_register_function(&_cdcdf_acm); + usbdc_register_handler(USBDC_HDL_REQ, &cdcdf_acm_req_h); + return ERR_NONE; +} + +/** + * \brief Deinitialize the USB CDC ACM Function Driver + */ +void cdcdf_acm_deinit(void) +{ + usb_d_ep_deinit(_cdcdf_acm_funcd.func_ep_in[CDCDF_ACM_COMM_EP_INDEX]); + usb_d_ep_deinit(_cdcdf_acm_funcd.func_ep_in[CDCDF_ACM_DATA_EP_INDEX]); + usb_d_ep_deinit(_cdcdf_acm_funcd.func_ep_out); +} + +/** + * \brief USB CDC ACM Function Read Data + */ +int32_t cdcdf_acm_read(uint8_t *buf, uint32_t size) +{ + if (!cdcdf_acm_is_enabled()) { + return ERR_DENIED; + } + return usbdc_xfer(_cdcdf_acm_funcd.func_ep_out, buf, size, false); +} + +/** + * \brief USB CDC ACM Function Write Data + */ +int32_t cdcdf_acm_write(uint8_t *buf, uint32_t size) +{ + if (!cdcdf_acm_is_enabled()) { + return ERR_DENIED; + } + return usbdc_xfer(_cdcdf_acm_funcd.func_ep_in[CDCDF_ACM_DATA_EP_INDEX], buf, size, true); +} + +/** + * \brief USB CDC ACM Stop the data transfer + */ +void cdcdf_acm_stop_xfer(void) +{ + /* Stop transfer. */ + usb_d_ep_abort(_cdcdf_acm_funcd.func_ep_in[CDCDF_ACM_DATA_EP_INDEX]); + usb_d_ep_abort(_cdcdf_acm_funcd.func_ep_out); +} + +/** + * \brief USB CDC ACM Function Register Callback + */ +int32_t cdcdf_acm_register_callback(enum cdcdf_acm_cb_type cb_type, FUNC_PTR func) +{ + switch (cb_type) { + case CDCDF_ACM_CB_READ: + usb_d_ep_register_callback(_cdcdf_acm_funcd.func_ep_out, USB_D_EP_CB_XFER, func); + break; + case CDCDF_ACM_CB_WRITE: + usb_d_ep_register_callback(_cdcdf_acm_funcd.func_ep_in[CDCDF_ACM_DATA_EP_INDEX], USB_D_EP_CB_XFER, func); + break; + case CDCDF_ACM_CB_LINE_CODING_C: + cdcdf_acm_set_line_coding = (cdcdf_acm_set_line_coding_t)func; + break; + case CDCDF_ACM_CB_STATE_C: + cdcdf_acm_notify_state = (cdcdf_acm_notify_state_t)func; + break; + default: + return ERR_INVALID_ARG; + } + return ERR_NONE; +} + +/** + * \brief Check whether CDC ACM Function is enabled + */ +bool cdcdf_acm_is_enabled(void) +{ + return _cdcdf_acm_funcd.enabled; +} + +/** + * \brief Return the CDC ACM line coding structure start address + */ +const struct usb_cdc_line_coding *cdcdf_acm_get_line_coding(void) +{ + return (const struct usb_cdc_line_coding *)&usbd_cdc_line_coding; +} + +/** + * \brief Return version + */ +uint32_t cdcdf_acm_get_version(void) +{ + return CDCDF_ACM_VERSION; +} diff --git a/atmel-samd/asf4/samd21/usb/class/cdc/device/cdcdf_acm.h b/atmel-samd/asf4/samd21/usb/class/cdc/device/cdcdf_acm.h new file mode 100644 index 000000000..913e734be --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/cdc/device/cdcdf_acm.h @@ -0,0 +1,114 @@ +/** + * \file + * + * \brief USB Device Stack CDC ACM Function Definition. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef USBDF_CDC_ACM_SER_H_ +#define USBDF_CDC_ACM_SER_H_ + +#include "usbdc.h" +#include "usb_protocol_cdc.h" + +/** CDC ACM Class Callback Type */ +enum cdcdf_acm_cb_type { CDCDF_ACM_CB_READ, CDCDF_ACM_CB_WRITE, CDCDF_ACM_CB_LINE_CODING_C, CDCDF_ACM_CB_STATE_C }; + +/** CDC ACM Notify Line State Callback. */ +typedef void (*cdcdf_acm_notify_state_t)(uint16_t); + +/** CDC ACM Set Line Coding Callback. */ +typedef bool (*cdcdf_acm_set_line_coding_t)(struct usb_cdc_line_coding *); + +/** + * \brief Initialize the USB CDC ACM Function Driver + * \return Operation status. + */ +int32_t cdcdf_acm_init(void); + +/** + * \brief Deinitialize the USB CDC ACM Function Driver + * \return Operation status. + */ +void cdcdf_acm_deinit(void); + +/** + * \brief USB CDC ACM Function Read Data + * \param[in] buf Pointer to the buffer which receives data + * \param[in] size the size of data to be received + * \return Operation status. + */ +int32_t cdcdf_acm_read(uint8_t *buf, uint32_t size); + +/** + * \brief USB CDC ACM Function Write Data + * \param[in] buf Pointer to the buffer which stores data + * \param[in] size the size of data to be sent + * \return Operation status. + */ +int32_t cdcdf_acm_write(uint8_t *buf, uint32_t size); + +/** + * \brief USB CDC ACM Stop the currnet data transfer + */ +void cdcdf_acm_stop_xfer(void); + +/** + * \brief USB CDC ACM Function Register Callback + * \param[in] cb_type Callback type of CDC ACM Function + * \param[in] func Pointer to callback function + * \return Operation status. + */ +int32_t cdcdf_acm_register_callback(enum cdcdf_acm_cb_type cb_type, FUNC_PTR func); + +/** + * \brief Check whether CDC ACM Function is enabled + * \return Operation status. + * \return true CDC ACM Function is enabled + * \return false CDC ACM Function is disabled + */ +bool cdcdf_acm_is_enabled(void); + +/** + * \brief Return the CDC ACM line coding structure start address + * \return Pointer to USB CDC ACM line coding data. + */ +const struct usb_cdc_line_coding *cdcdf_acm_get_line_coding(void); + +/** + * \brief Return version + */ +uint32_t cdcdf_acm_get_version(void); + +#endif /* USBDF_CDC_ACM_SER_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/cdc/usb_protocol_cdc.h b/atmel-samd/asf4/samd21/usb/class/cdc/usb_protocol_cdc.h new file mode 100644 index 000000000..6017864cb --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/cdc/usb_protocol_cdc.h @@ -0,0 +1,407 @@ +/** + * \file + * + * \brief USB Communication Device Class (CDC) protocol definitions + * + * Copyright (c) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ +/* + * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a> + */ +#ifndef _USB_PROTOCOL_CDC_H_ +#define _USB_PROTOCOL_CDC_H_ + +#include "usb_includes.h" + +/** + * \ingroup usb_protocol_group + * \defgroup cdc_protocol_group Communication Device Class Definitions + * @{ + */ + +/** + * \name Possible values of class + */ +//@{ +#define CDC_CLASS_DEVICE 0x02 //!< USB Communication Device Class +#define CDC_CLASS_COMM 0x02 //!< CDC Communication Class Interface +#define CDC_CLASS_DATA 0x0A //!< CDC Data Class Interface +//@} + +//! \name USB CDC Subclass IDs +//@{ +#define CDC_SUBCLASS_DLCM 0x01 //!< Direct Line Control Model +#define CDC_SUBCLASS_ACM 0x02 //!< Abstract Control Model +#define CDC_SUBCLASS_TCM 0x03 //!< Telephone Control Model +#define CDC_SUBCLASS_MCCM 0x04 //!< Multi-Channel Control Model +#define CDC_SUBCLASS_CCM 0x05 //!< CAPI Control Model +#define CDC_SUBCLASS_ETH 0x06 //!< Ethernet Networking Control Model +#define CDC_SUBCLASS_ATM 0x07 //!< ATM Networking Control Model +//@} + +//! \name USB CDC Communication Interface Protocol IDs +//@{ +#define CDC_PROTOCOL_V25TER 0x01 //!< Common AT commands +//@} + +//! \name USB CDC Data Interface Protocol IDs +//@{ +#define CDC_PROTOCOL_I430 0x30 //!< ISDN BRI +#define CDC_PROTOCOL_HDLC 0x31 //!< HDLC +#define CDC_PROTOCOL_TRANS 0x32 //!< Transparent +#define CDC_PROTOCOL_Q921M 0x50 //!< Q.921 management protocol +#define CDC_PROTOCOL_Q921 0x51 //!< Q.931 [sic] Data link protocol +#define CDC_PROTOCOL_Q921TM 0x52 //!< Q.921 TEI-multiplexor +#define CDC_PROTOCOL_V42BIS 0x90 //!< Data compression procedures +#define CDC_PROTOCOL_Q931 0x91 //!< Euro-ISDN protocol control +#define CDC_PROTOCOL_V120 0x92 //!< V.24 rate adaption to ISDN +#define CDC_PROTOCOL_CAPI20 0x93 //!< CAPI Commands +#define CDC_PROTOCOL_HOST 0xFD //!< Host based driver + /** + * \brief Describes the Protocol Unit Functional Descriptors [sic] + * on Communication Class Interface + */ +#define CDC_PROTOCOL_PUFD 0xFE +//@} + +//! \name USB CDC Functional Descriptor Types +//@{ +#define CDC_CS_INTERFACE 0x24 //!< Interface Functional Descriptor +#define CDC_CS_ENDPOINT 0x25 //!< Endpoint Functional Descriptor +//@} + +//! \name USB CDC Functional Descriptor Subtypes +//@{ +#define CDC_SCS_HEADER 0x00 //!< Header Functional Descriptor +#define CDC_SCS_CALL_MGMT 0x01 //!< Call Management +#define CDC_SCS_ACM 0x02 //!< Abstract Control Management +#define CDC_SCS_UNION 0x06 //!< Union Functional Descriptor +//@} + +//! \name USB CDC Request IDs +//@{ +#define USB_REQ_CDC_SEND_ENCAPSULATED_COMMAND 0x00 +#define USB_REQ_CDC_GET_ENCAPSULATED_RESPONSE 0x01 +#define USB_REQ_CDC_SET_COMM_FEATURE 0x02 +#define USB_REQ_CDC_GET_COMM_FEATURE 0x03 +#define USB_REQ_CDC_CLEAR_COMM_FEATURE 0x04 +#define USB_REQ_CDC_SET_AUX_LINE_STATE 0x10 +#define USB_REQ_CDC_SET_HOOK_STATE 0x11 +#define USB_REQ_CDC_PULSE_SETUP 0x12 +#define USB_REQ_CDC_SEND_PULSE 0x13 +#define USB_REQ_CDC_SET_PULSE_TIME 0x14 +#define USB_REQ_CDC_RING_AUX_JACK 0x15 +#define USB_REQ_CDC_SET_LINE_CODING 0x20 +#define USB_REQ_CDC_GET_LINE_CODING 0x21 +#define USB_REQ_CDC_SET_CONTROL_LINE_STATE 0x22 +#define USB_REQ_CDC_SEND_BREAK 0x23 +#define USB_REQ_CDC_SET_RINGER_PARMS 0x30 +#define USB_REQ_CDC_GET_RINGER_PARMS 0x31 +#define USB_REQ_CDC_SET_OPERATION_PARMS 0x32 +#define USB_REQ_CDC_GET_OPERATION_PARMS 0x33 +#define USB_REQ_CDC_SET_LINE_PARMS 0x34 +#define USB_REQ_CDC_GET_LINE_PARMS 0x35 +#define USB_REQ_CDC_DIAL_DIGITS 0x36 +#define USB_REQ_CDC_SET_UNIT_PARAMETER 0x37 +#define USB_REQ_CDC_GET_UNIT_PARAMETER 0x38 +#define USB_REQ_CDC_CLEAR_UNIT_PARAMETER 0x39 +#define USB_REQ_CDC_GET_PROFILE 0x3A +#define USB_REQ_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40 +#define USB_REQ_CDC_SET_ETHERNET_POWER_MANAGEMENT_PATTERNFILTER 0x41 +#define USB_REQ_CDC_GET_ETHERNET_POWER_MANAGEMENT_PATTERNFILTER 0x42 +#define USB_REQ_CDC_SET_ETHERNET_PACKET_FILTER 0x43 +#define USB_REQ_CDC_GET_ETHERNET_STATISTIC 0x44 +#define USB_REQ_CDC_SET_ATM_DATA_FORMAT 0x50 +#define USB_REQ_CDC_GET_ATM_DEVICE_STATISTICS 0x51 +#define USB_REQ_CDC_SET_ATM_DEFAULT_VC 0x52 +#define USB_REQ_CDC_GET_ATM_VC_STATISTICS 0x53 +// Added bNotification codes according cdc spec 1.1 chapter 6.3 +#define USB_REQ_CDC_NOTIFY_RING_DETECT 0x09 +#define USB_REQ_CDC_NOTIFY_SERIAL_STATE 0x20 +#define USB_REQ_CDC_NOTIFY_CALL_STATE_CHANGE 0x28 +#define USB_REQ_CDC_NOTIFY_LINE_STATE_CHANGE 0x29 +//@} + +/* + * Need to pack structures tightly, or the compiler might insert padding + * and violate the spec-mandated layout. + */ +COMPILER_PACK_SET(1) + +//! \name USB CDC Descriptors +//@{ + +//! CDC Header Functional Descriptor +typedef struct usb_cdc_hdr_desc { + uint8_t bFunctionLength; + uint8_t bDescriptorType; + uint8_t bDescriptorSubtype; + le16_t bcdCDC; +} usb_cdc_hdr_desc_t; + +#define USB_CDC_HDR_DESC_LEN 5 +#define USB_CDC_HDR_DESC_BYTES(bcdCDC) \ + USB_CDC_HDR_DESC_LEN, /* bFunctionLength */ \ + CDC_CS_INTERFACE, /* bDescriptorType */ \ + CDC_SCS_HEADER, /* bDescriptorSubtype */ \ + LE_BYTE0(bcdCDC), LE_BYTE1(bcdCDC) /* bcdCDC */ + +//! CDC Call Management Functional Descriptor +typedef struct usb_cdc_call_mgmt_desc { + uint8_t bFunctionLength; + uint8_t bDescriptorType; + uint8_t bDescriptorSubtype; + uint8_t bmCapabilities; + uint8_t bDataInterface; +} usb_cdc_call_mgmt_desc_t; + +#define USB_CDC_CALL_MGMT_DESC_LEN 5 +#define USB_CDC_CALL_MGMT_DESC_BYTES(bmCapabilities, bDataInterface) \ + USB_CDC_CALL_MGMT_DESC_LEN, /* bFunctionLength */ \ + CDC_CS_INTERFACE, /* bDescriptorType */ \ + CDC_SCS_CALL_MGMT, /* bDescriptorSubtype */ \ + bmCapabilities, bDataInterface + +//! CDC ACM Functional Descriptor +typedef struct usb_cdc_acm_desc { + uint8_t bFunctionLength; + uint8_t bDescriptorType; + uint8_t bDescriptorSubtype; + uint8_t bmCapabilities; +} usb_cdc_acm_desc_t; + +#define USB_CDC_ACM_DESC_LEN 4 +#define USB_CDC_ACM_DESC_BYTES(bmCapabilities) \ + USB_CDC_ACM_DESC_LEN, /* bFunctionLength */ \ + CDC_CS_INTERFACE, /* bDescriptorType */ \ + CDC_SCS_ACM, /* bDescriptorSubType */ \ + bmCapabilities + +//! CDC Union Functional Descriptor +typedef struct usb_cdc_union_desc { + uint8_t bFunctionLength; + uint8_t bDescriptorType; + uint8_t bDescriptorSubtype; + uint8_t bMasterInterface; + uint8_t bSlaveInterface0; +} usb_cdc_union_desc_t; + +#define USB_CDC_UNION_DESC_LEN 5 +#define USB_CDC_UNION_DESC_BYTES(bMasterInterface, bSlaveInterface) \ + USB_CDC_UNION_DESC_LEN, CDC_CS_INTERFACE, CDC_SCS_UNION, bMasterInterface, bSlaveInterface + +//! \name USB CDC Call Management Capabilities +//@{ +//! Device handles call management itself +#define CDC_CALL_MGMT_SUPPORTED (1 << 0) +//! Device can send/receive call management info over a Data Class interface +#define CDC_CALL_MGMT_OVER_DCI (1 << 1) +//@} + +//! \name USB CDC ACM Capabilities +//@{ +//! Device supports the request combination of +//! Set_Comm_Feature, Clear_Comm_Feature, and Get_Comm_Feature. +#define CDC_ACM_SUPPORT_FEATURE_REQUESTS (1 << 0) +//! Device supports the request combination of +//! Set_Line_Coding, Set_Control_Line_State, Get_Line_Coding, +//! and the notification Serial_State. +#define CDC_ACM_SUPPORT_LINE_REQUESTS (1 << 1) +//! Device supports the request Send_Break +#define CDC_ACM_SUPPORT_SENDBREAK_REQUESTS (1 << 2) +//! Device supports the notification Network_Connection. +#define CDC_ACM_SUPPORT_NOTIFY_REQUESTS (1 << 3) +//@} +//@} + +//! \name USB CDC line control +//@{ + +//! \name USB CDC line coding +//@{ + +//! Line Coding structure +typedef struct usb_cdc_line_coding { + le32_t dwDTERate; //!< Data rate, bits per second + uint8_t bCharFormat; //!< 0-1 Stop bit,1-1.5 Stop bits,2-2 Stop bits + uint8_t bParityType; //!< 0-None,1-Odd,2-Even,3-Mark,4-Space + uint8_t bDataBits; //!< 5,6,7,8 or 16 +} usb_cdc_line_coding_t; + +//! Possible values of bCharFormat +enum cdc_char_format { + CDC_STOP_BITS_1 = 0, //!< 1 stop bit + CDC_STOP_BITS_1_5 = 1, //!< 1.5 stop bits + CDC_STOP_BITS_2 = 2 //!< 2 stop bits +}; + +//! Possible values of bParityType +enum cdc_parity { + CDC_PAR_NONE = 0, //!< No parity + CDC_PAR_ODD = 1, //!< Odd parity + CDC_PAR_EVEN = 2, //!< Even parity + CDC_PAR_MARK = 3, //!< Parity forced to 0 (space) + CDC_PAR_SPACE = 4 //!< Parity forced to 1 (mark) +}; +//@} + +//! \name USB CDC control signals +//! spec 1.1 chapter 6.2.14 +//@{ + +//! Control signal structure +typedef struct usb_cdc_control_signal { + union { + le16_t value; + struct { + uint8_t dte_present; + uint8_t carrier_ctrl; + } modem; + struct { + uint8_t DTR : 1; //!< Data Terminal Ready + uint8_t RTS : 1; //!< Request To Send + } rs232; + struct { + uint8_t s108_2 : 1; //!< V.24 signal 108/2 + uint8_t s105 : 1; //!< V.24 signal 105 + } v24; + }; +} usb_cdc_control_signal_t; + +//! \name Possible values in usb_cdc_control_signal_t +//@{ +//! Carrier control for half duplex modems. +//! This signal corresponds to V.24 signal 105 and RS-232 signal RTS. +//! The device ignores the value of this bit +//! when operating in full duplex mode. +#define CDC_CTRL_SIGNAL_ACTIVATE_CARRIER (1 << 1) +//! Indicates to DCE if DTE is present or not. +//! This signal corresponds to V.24 signal 108/2 and RS-232 signal DTR. +#define CDC_CTRL_SIGNAL_DTE_PRESENT (1 << 0) +//@} +//@} + +//! \name USB CDC notification message +//@{ + +typedef struct usb_cdc_notify_msg { + uint8_t bmRequestType; + uint8_t bNotification; + union { + le16_t wValue; + struct { + uint8_t low; + uint8_t high; + } wValueBytes; + }; + union { + le16_t wIndex; + struct { + uint8_t low; + uint8_t high; + } wIndexBytes; + }; + union { + le16_t wLength; + struct { + uint8_t low; + uint8_t high; + } wLengthBytes; + }; +} usb_cdc_notify_msg_t; + +//! \name USB CDC serial state +//@{* + +//! UART State Bitmap (cdc spec 1.1 chapter 6.3.5) +typedef union usb_cdc_uart_state { + le16_t value; + struct { + uint8_t bRxCarrier : 1; + uint8_t bTxCarrier : 1; + uint8_t bBreak : 1; + uint8_t bRingSignal : 1; + uint8_t bFraming : 1; + uint8_t bParity : 1; + uint8_t bOverRun; + } bitmap; + struct { + uint8_t bDCD : 1; + uint8_t bDSR : 1; + uint8_t bBreak : 1; + uint8_t bRingSignal : 1; + uint8_t bFraming : 1; + uint8_t bParity : 1; + uint8_t bOverRun; + } rs232; + struct { + uint8_t bS109 : 1; //!< V.24 signal 109 + uint8_t bS106 : 1; //!< V.24 signal 106 + uint8_t bBreak : 1; + uint8_t bRingSignal : 1; + uint8_t bFraming : 1; + uint8_t bParity : 1; + uint8_t bOverRun; + } v24; +} usb_cdc_uart_state_t; + +//! Hardware handshake support (cdc spec 1.1 chapter 6.3.5) +typedef struct usb_cdc_notify_serial_state { + usb_cdc_notify_msg_t header; + union usb_cdc_uart_state state; +} usb_cdc_notify_serial_state_t; + +//! \name Possible values in usb_cdc_notify_serial_state_t +//@{ +#define CDC_SERIAL_STATE_DCD CPU_TO_LE16((1 << 0)) +#define CDC_SERIAL_STATE_DSR CPU_TO_LE16((1 << 1)) +#define CDC_SERIAL_STATE_BREAK CPU_TO_LE16((1 << 2)) +#define CDC_SERIAL_STATE_RING CPU_TO_LE16((1 << 3)) +#define CDC_SERIAL_STATE_FRAMING CPU_TO_LE16((1 << 4)) +#define CDC_SERIAL_STATE_PARITY CPU_TO_LE16((1 << 5)) +#define CDC_SERIAL_STATE_OVERRUN CPU_TO_LE16((1 << 6)) +//@} +//! @} + +//! @} + +COMPILER_PACK_RESET() + +//! @} + +#endif // _USB_PROTOCOL_CDC_H_ diff --git a/atmel-samd/asf4/samd21/usb/class/composite/device/composite_desc.h b/atmel-samd/asf4/samd21/usb/class/composite/device/composite_desc.h new file mode 100644 index 000000000..68db57af9 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/composite/device/composite_desc.h @@ -0,0 +1,170 @@ +/** + * \file + * + * \brief USB Device Stack Composite Class Descriptor Setting. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef USBDF_COMPOSITE_DESC_H_ +#define USBDF_COMPOSITE_DESC_H_ + +#include "usb_protocol.h" +#include "usbd_composite_config.h" + +#if CONF_USB_COMPOSITE_CDC_ACM_EN == 1 +#define CONF_CDC_ACM_IFC_LEN 66 +#define CONF_CDC_ACM_IFC_NUM 2 +#define CONF_USB_COMPOSITE_CDC_ACM_COMM_BIFCNUM 0 +#define CONF_USB_COMPOSITE_CDC_ACM_DATA_BIFCNUM 1 +#define CONF_CDC_ACM_IFC_DESC \ + USB_IAD_DESC_BYTES( \ + CONF_USB_COMPOSITE_CDC_ACM_COMM_BIFCNUM, 0x02, CDC_CLASS_DEVICE, CDC_SUBCLASS_ACM, CDC_PROTOCOL_V25TER, 0x00) \ + , \ + USB_IFACE_DESC_BYTES(CONF_USB_COMPOSITE_CDC_ACM_COMM_BIFCNUM, \ + 0x00, \ + 0x01, \ + CDC_CLASS_DEVICE, \ + CDC_SUBCLASS_ACM, \ + CDC_PROTOCOL_V25TER, \ + 0x00), \ + USB_CDC_HDR_DESC_BYTES(0x1001), USB_CDC_CALL_MGMT_DESC_BYTES(0x01, 0x00), USB_CDC_ACM_DESC_BYTES(0x02), \ + USB_CDC_UNION_DESC_BYTES(CONF_USB_COMPOSITE_CDC_ACM_COMM_BIFCNUM, 0x01), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_CDC_ACM_COMM_INT_EPADDR, 3, CONF_USB_COMPOSITE_CDC_ACM_COMM_INT_MAXPKSZ, 10), \ + USB_IFACE_DESC_BYTES(CONF_USB_COMPOSITE_CDC_ACM_DATA_BIFCNUM, 0x00, 2, 0x0A, 0x00, 0x00, 0x00), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKOUT_EPADDR, 2, CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKOUT_MAXPKSZ, 0x00), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKIN_EPADDR, 2, CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKIN_MAXPKSZ, 0x00), +#else +#define CONF_CDC_ACM_IFC_LEN 0 +#define CONF_CDC_ACM_IFC_NUM 0 +#define CONF_USB_COMPOSITE_CDC_ACM_COMM_BIFCNUM -2 +#define CONF_USB_COMPOSITE_CDC_ACM_DATA_BIFCNUM -1 +#define CONF_CDC_ACM_IFC_DESC +#endif + +#if CONF_USB_COMPOSITE_HID_MOUSE_EN == 1 +#define CONF_HID_MOUSE_IFC_LEN 25 +#define CONF_HID_MOUSE_IFC_NUM 1 +#define CONF_USB_COMPOSITE_HID_MOUSE_BIFCNUM (CONF_USB_COMPOSITE_CDC_ACM_DATA_BIFCNUM + 1) +#define CONF_HID_MOUSE_IFC_DESC \ + USB_IFACE_DESC_BYTES(CONF_USB_COMPOSITE_HID_MOUSE_BIFCNUM, 0x00, 0x01, 0x03, 0x01, 0x02, 0x00) \ + , USB_HID_DESC_BYTES(0x09, 0x21, 0x01, 0x22, 0x34), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_HID_MOUSE_INTIN_EPADDR, 0x03, CONF_USB_COMPOSITE_HID_MOUSE_INTIN_MAXPKSZ, 10), +#else +#define CONF_HID_MOUSE_IFC_LEN 0 +#define CONF_HID_MOUSE_IFC_NUM 0 +#define CONF_USB_COMPOSITE_HID_MOUSE_BIFCNUM CONF_USB_COMPOSITE_CDC_ACM_DATA_BIFCNUM +#define CONF_HID_MOUSE_IFC_DESC +#endif + +#if CONF_USB_COMPOSITE_HID_KEYBOARD_EN == 1 +#define CONF_HID_KEYBOARD_IFC_LEN 32 +#define CONF_HID_KEYBOARD_IFC_NUM 1 +#define CONF_USB_COMPOSITE_HID_KEYBOARD_BIFCNUM (CONF_USB_COMPOSITE_HID_MOUSE_BIFCNUM + 1) +#define CONF_HID_KEYBOARD_IFC_DESC \ + USB_IFACE_DESC_BYTES(CONF_USB_COMPOSITE_HID_KEYBOARD_BIFCNUM, 0x00, 0x02, 0x03, 0x01, 0x01, 0x00) \ + , USB_HID_DESC_BYTES(0x09, 0x21, 0x01, 0x22, 59), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_HID_KEYBOARD_INTIN_EPADDR, 0x03, CONF_USB_COMPOSITE_HID_KEYBOARD_INTIN_MAXPKSZ, 10), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_HID_KEYBOARD_INTOUT_EPADDR, 0x03, CONF_USB_COMPOSITE_HID_KEYBOARD_INTOUT_MAXPKSZ, 10), +#else +#define CONF_HID_KEYBOARD_IFC_LEN 0 +#define CONF_HID_KEYBOARD_IFC_NUM 0 +#define CONF_USB_COMPOSITE_HID_KEYBOARD_BIFCNUM CONF_USB_COMPOSITE_HID_MOUSE_BIFCNUM +#define CONF_HID_KEYBOARD_IFC_DESC +#endif + +#if CONF_USB_COMPOSITE_HID_GENERIC_EN == 1 +#define CONF_HID_GENERIC_IFC_LEN 32 +#define CONF_HID_GENERIC_IFC_NUM 1 +#define CONF_USB_COMPOSITE_HID_GENERIC_BIFCNUM (CONF_USB_COMPOSITE_HID_KEYBOARD_BIFCNUM + 1) +#define CONF_HID_GENERIC_IFC_DESC \ + USB_IFACE_DESC_BYTES(CONF_USB_COMPOSITE_HID_GENERIC_BIFCNUM, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00) \ + , USB_HID_DESC_BYTES(0x09, 0x21, 0x01, 0x22, CONF_USB_COMPOSITE_HID_GENERIC_REPORT_LEN), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_HID_GENERIC_INTIN_EPADDR, 0x03, CONF_USB_COMPOSITE_HID_GENERIC_INTIN_MAXPKSZ, 10), \ + USB_ENDP_DESC_BYTES( \ + CONF_USB_COMPOSITE_HID_GENERIC_INTOUT_EPADDR, 0x03, CONF_USB_COMPOSITE_HID_GENERIC_INTOUT_MAXPKSZ, 10), +#else +#define CONF_HID_GENERIC_IFC_LEN 0 +#define CONF_HID_GENERIC_IFC_NUM 0 +#define CONF_USB_COMPOSITE_HID_GENERIC_BIFCNUM CONF_USB_COMPOSITE_HID_KEYBOARD_BIFCNUM +#define CONF_HID_GENERIC_IFC_DESC +#endif + +#define CONF_USB_COMPOSITE_TOTAL_LEN \ + (USB_CONFIG_DESC_LEN + CONF_CDC_ACM_IFC_LEN + CONF_HID_MOUSE_IFC_LEN + CONF_HID_KEYBOARD_IFC_LEN \ + + CONF_HID_GENERIC_IFC_LEN) + +#define CONF_USB_COMPOSITE_IFC_NUM \ + (CONF_CDC_ACM_IFC_NUM + CONF_HID_MOUSE_IFC_NUM + CONF_HID_KEYBOARD_IFC_NUM + CONF_HID_GENERIC_IFC_NUM) + +#define COMPOSITE_DEV_DESC \ + USB_DEV_DESC_BYTES(CONF_USB_COMPOSITE_BCDUSB, \ + 0xEF, \ + 0x02, \ + 0x01, \ + CONF_USB_COMPOSITE_BMAXPKSZ0, \ + CONF_USB_COMPOSITE_IDVENDER, \ + CONF_USB_COMPOSITE_IDPRODUCT, \ + CONF_USB_COMPOSITE_BCDDEVICE, \ + CONF_USB_COMPOSITE_IMANUFACT, \ + CONF_USB_COMPOSITE_IPRODUCT, \ + CONF_USB_COMPOSITE_ISERIALNUM, \ + CONF_USB_COMPOSITE_BNUMCONFIG) + +#define COMPOSITE_CFG_DESC \ + USB_CONFIG_DESC_BYTES(CONF_USB_COMPOSITE_TOTAL_LEN, \ + CONF_USB_COMPOSITE_IFC_NUM, \ + CONF_USB_COMPOSITE_BCONFIGVAL, \ + CONF_USB_COMPOSITE_ICONFIG, \ + CONF_USB_COMPOSITE_BMATTRI, \ + CONF_USB_COMPOSITE_BMAXPOWER) + +#define COMPOSITE_IFACE_DESCES \ + CONF_CDC_ACM_IFC_DESC \ + CONF_HID_MOUSE_IFC_DESC \ + CONF_HID_KEYBOARD_IFC_DESC \ + CONF_HID_GENERIC_IFC_DESC + +/** USB Device descriptors and configuration descriptors */ +#define COMPOSITE_DESCES_LS_FS \ + COMPOSITE_DEV_DESC, COMPOSITE_CFG_DESC, COMPOSITE_IFACE_DESCES CONF_USB_COMPOSITE_LANGUAGE_ID_STR_DESC, \ + CONF_USB_COMPOSITE_MANUFACTOR_STR_DESC, CONF_USB_COMPOSITE_PRODUCT_STR_DESC + +#endif /* USBDF_COMPOSITE_DESC_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/composite/device/usbd_composite_config.h b/atmel-samd/asf4/samd21/usb/class/composite/device/usbd_composite_config.h new file mode 100644 index 000000000..1b29802b0 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/composite/device/usbd_composite_config.h @@ -0,0 +1,355 @@ +/* Auto-generated config file usbd_composite_config.h */ +#ifndef USBD_COMPOSITE_CONFIG_H +#define USBD_COMPOSITE_CONFIG_H + +// <<< Use Configuration Wizard in Context Menu >>> + +// <h> Composite Device Descriptor + +// <o> bcdUSB +// <0x0200=> USB 2.0 version +// <0x0210=> USB 2.1 version +// <id> usb_composite_bcdusb +#ifndef CONF_USB_COMPOSITE_BCDUSB +#define CONF_USB_COMPOSITE_BCDUSB 0x200 +#endif + +// <o> bMaxPackeSize0 +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_bmaxpksz0 +#ifndef CONF_USB_COMPOSITE_BMAXPKSZ0 +#define CONF_USB_COMPOSITE_BMAXPKSZ0 0x40 +#endif + +// <o> idVender <0x0000-0xFFFF> +// <id> usb_composite_idvender +#ifndef CONF_USB_COMPOSITE_IDVENDER +#define CONF_USB_COMPOSITE_IDVENDER 0x3eb +#endif + +// <o> idProduct <0x0000-0xFFFF> +// <id> usb_composite_idproduct +#ifndef CONF_USB_COMPOSITE_IDPRODUCT +#define CONF_USB_COMPOSITE_IDPRODUCT 0x2421 +#endif + +// <o> bcdDevice <0x0000-0xFFFF> +// <id> usb_composite_bcddevice +#ifndef CONF_USB_COMPOSITE_BCDDEVICE +#define CONF_USB_COMPOSITE_BCDDEVICE 0x100 +#endif + +// <o> iManufacturer <0x00-0xFF> +// <id> usb_composite_imanufact +#ifndef CONF_USB_COMPOSITE_IMANUFACT +#define CONF_USB_COMPOSITE_IMANUFACT 0x0 +#endif + +#ifndef CONF_USB_COMPOSITE_LANGUAGE_ID_STR_DESC +#define CONF_USB_COMPOSITE_LANGUAGE_ID_STR_DESC 0x04, 0x03, 0x09, 0x04 +#endif + +#ifndef CONF_USB_COMPOSITE_MANUFACTOR_STR_DESC +#define CONF_USB_COMPOSITE_MANUFACTOR_STR_DESC \ + 0x14, 0x03, 0x41, 0x00, 0x54, 0x00, 0x4D, 0x00, 0x45, 0x00, 0x4C, 0x00, 0x20, 0x00, 0x41, 0x00, 0x53, 0x00, 0x46, \ + 0x00 +#endif + +// <o> iProduct <0x00-0xFF> +// <id> usb_composite_iproduct +#ifndef CONF_USB_COMPOSITE_IPRODUCT +#define CONF_USB_COMPOSITE_IPRODUCT 0x0 +#endif + +#ifndef CONF_USB_COMPOSITE_PRODUCT_STR_DESC +#define CONF_USB_COMPOSITE_PRODUCT_STR_DESC \ + 0x22, 0x03, 0x43, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x69, 0x00, 0x74, 0x00, 0x65, \ + 0x00, 0x20, 0x00, 0x44, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00 +#endif + +// <o> iSerialNumber <0x00-0xFF> +// <id> usb_composite_iserialnum +#ifndef CONF_USB_COMPOSITE_ISERIALNUM +#define CONF_USB_COMPOSITE_ISERIALNUM 0x0 +#endif + +// <o> bNumConfigurations <0x01-0xFF> +// <id> usb_composite_bnumconfig +#ifndef CONF_USB_COMPOSITE_BNUMCONFIG +#define CONF_USB_COMPOSITE_BNUMCONFIG 0x1 +#endif +// </h> + +// <h> Composite Configuration Descriptor + +// <o> bConfigurationValue <0x01-0xFF> +// <id> usb_composite_bconfigval +#ifndef CONF_USB_COMPOSITE_BCONFIGVAL +#define CONF_USB_COMPOSITE_BCONFIGVAL 0x1 +#endif + +// <o> iConfiguration <0x00-0xFF> +// <id> usb_composite_iconfig +#ifndef CONF_USB_COMPOSITE_ICONFIG +#define CONF_USB_COMPOSITE_ICONFIG 0x0 +#endif + +// <o> bmAttributes +// <0x80=> Bus power supply, not support for remote wakeup +// <0xA0=> Bus power supply, support for remote wakeup +// <0xC0=> Self powered, not support for remote wakeup +// <0xE0=> Self powered, support for remote wakeup +// <id> usb_composite_bmattri +#ifndef CONF_USB_COMPOSITE_BMATTRI +#define CONF_USB_COMPOSITE_BMATTRI 0x80 +#endif + +// <o> bMaxPower <0x00-0xFF> +// <id> usb_composite_bmaxpower +#ifndef CONF_USB_COMPOSITE_BMAXPOWER +#define CONF_USB_COMPOSITE_BMAXPOWER 0x32 +#endif +// </h> + +// <e> CDC ACM Support +// <id> usb_composite_cdc_acm_support +#ifndef CONF_USB_COMPOSITE_CDC_ACM_EN +#define CONF_USB_COMPOSITE_CDC_ACM_EN 1 +#endif + +// <o> CDC ACM Comm Interrupt IN Endpoint Address +// <0x81=> EndpointAddress = 0x81 +// <0x82=> EndpointAddress = 0x82 +// <0x83=> EndpointAddress = 0x83 +// <0x84=> EndpointAddress = 0x84 +// <0x85=> EndpointAddress = 0x85 +// <0x86=> EndpointAddress = 0x86 +// <0x87=> EndpointAddress = 0x87 +// <id> usb_composite_cdc_acm_epaddr +#ifndef CONF_USB_COMPOSITE_CDC_ACM_COMM_INT_EPADDR +#define CONF_USB_COMPOSITE_CDC_ACM_COMM_INT_EPADDR 0x82 +#endif + +// <o> CDC ACM Comm Interrupt IN Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_cdc_acm_comm_int_maxpksz +#ifndef CONF_USB_COMPOSITE_CDC_ACM_COMM_INT_MAXPKSZ +#define CONF_USB_COMPOSITE_CDC_ACM_COMM_INT_MAXPKSZ 0x40 +#endif + +// <o> CDC ACM Data BULK IN Endpoint Address +// <0x81=> EndpointAddress = 0x81 +// <0x82=> EndpointAddress = 0x82 +// <0x83=> EndpointAddress = 0x83 +// <0x84=> EndpointAddress = 0x84 +// <0x85=> EndpointAddress = 0x85 +// <0x86=> EndpointAddress = 0x86 +// <0x87=> EndpointAddress = 0x87 +// <id> usb_composite_cdc_acm_data_bulkin_epaddr +#ifndef CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKIN_EPADDR +#define CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKIN_EPADDR 0x81 +#endif + +// <o> CDC ACM Data BULK IN Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_cdc_acm_data_builin_maxpksz +#ifndef CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKIN_MAXPKSZ +#define CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKIN_MAXPKSZ 0x40 +#endif + +// <o> CDC ACM Data BULK OUT Endpoint Address +// <0x01=> EndpointAddress = 0x01 +// <0x02=> EndpointAddress = 0x02 +// <0x03=> EndpointAddress = 0x03 +// <0x04=> EndpointAddress = 0x04 +// <0x05=> EndpointAddress = 0x05 +// <0x06=> EndpointAddress = 0x06 +// <0x07=> EndpointAddress = 0x07 +// <id> usb_composite_cdc_acm_data_bulkout_epaddr +#ifndef CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKOUT_EPADDR +#define CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKOUT_EPADDR 0x1 +#endif + +// <o> CDC ACM Data BULK OUT Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_cdc_acm_data_buckout_maxpksz +#ifndef CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKOUT_MAXPKSZ +#define CONF_USB_COMPOSITE_CDC_ACM_DATA_BULKOUT_MAXPKSZ 0x40 +#endif +// </e> + +// <e> HID Mouse Support +// <id> usb_composite_hid_mouse_support +#ifndef CONF_USB_COMPOSITE_HID_MOUSE_EN +#define CONF_USB_COMPOSITE_HID_MOUSE_EN 0 +#endif + +// <o> HID Mouse INTERRUPT IN Endpoint Address +// <0x81=> EndpointAddress = 0x81 +// <0x82=> EndpointAddress = 0x82 +// <0x83=> EndpointAddress = 0x83 +// <0x84=> EndpointAddress = 0x84 +// <0x85=> EndpointAddress = 0x85 +// <0x86=> EndpointAddress = 0x86 +// <0x87=> EndpointAddress = 0x87 +// <id> usb_composite_hid_mouse_intin_epaddr +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_MOUSE_INTIN_EPADDR +#define CONF_USB_COMPOSITE_HID_MOUSE_INTIN_EPADDR 0x83 +#endif + +// <o> HID Mouse INTERRUPT IN Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_hid_mouse_intin_maxpksz +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_MOUSE_INTIN_MAXPKSZ +#define CONF_USB_COMPOSITE_HID_MOUSE_INTIN_MAXPKSZ 0x8 +#endif + +// </e> + +// <e> HID Keyboard Support +// <id> usb_composite_hid_keyboard_support +#ifndef CONF_USB_COMPOSITE_HID_KEYBOARD_EN +#define CONF_USB_COMPOSITE_HID_KEYBOARD_EN 0 +#endif + +// <o> HID Keyboard INTERRUPT IN Endpoint Address +// <0x81=> EndpointAddress = 0x81 +// <0x82=> EndpointAddress = 0x82 +// <0x83=> EndpointAddress = 0x83 +// <0x84=> EndpointAddress = 0x84 +// <0x85=> EndpointAddress = 0x85 +// <0x86=> EndpointAddress = 0x86 +// <0x87=> EndpointAddress = 0x87 +// <id> usb_composite_hid_keyboard_intin_epaddr +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_KEYBOARD_INTIN_EPADDR +#define CONF_USB_COMPOSITE_HID_KEYBOARD_INTIN_EPADDR 0x84 +#endif + +// <o> HID Keyboard INTERRUPT IN Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_hid_keyboard_intin_maxpksz +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_KEYBOARD_INTIN_MAXPKSZ +#define CONF_USB_COMPOSITE_HID_KEYBOARD_INTIN_MAXPKSZ 0x8 +#endif + +// <o> HID Keyboard INTERRUPT OUT Endpoint Address +// <0x01=> EndpointAddress = 0x01 +// <0x02=> EndpointAddress = 0x02 +// <0x03=> EndpointAddress = 0x03 +// <0x04=> EndpointAddress = 0x04 +// <0x05=> EndpointAddress = 0x05 +// <0x06=> EndpointAddress = 0x06 +// <0x07=> EndpointAddress = 0x07 +// <id> usb_composite_hid_keyboard_intout_epaddr +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_KEYBOARD_INTOUT_EPADDR +#define CONF_USB_COMPOSITE_HID_KEYBOARD_INTOUT_EPADDR 0x2 +#endif + +// <o> HID Keyboard INTERRUPT OUT Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_hid_keyboard_intout_maxpksz +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_KEYBOARD_INTOUT_MAXPKSZ +#define CONF_USB_COMPOSITE_HID_KEYBOARD_INTOUT_MAXPKSZ 0x8 +#endif + +// </e> + +// <e> HID Generic Support +// <id> usb_composite_hid_generic_support +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_EN +#define CONF_USB_COMPOSITE_HID_GENERIC_EN 0 +#endif + +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_REPORT_LEN +#define CONF_USB_COMPOSITE_HID_GENERIC_REPORT_LEN 53 +#endif + +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_REPORT +#define CONF_USB_COMPOSITE_HID_GENERIC_REPORT \ + 0x06, 0xFF, 0xFF, 0x09, 0x01, 0xA1, 0x01, 0x09, 0x02, 0x09, 0x03, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, \ + 0x40, 0x81, 0x02, 0x09, 0x04, 0x09, 0x05, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x40, 0x91, 0x02, \ + 0x09, 0x06, 0x09, 0x07, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x04, 0xB1, 0x02, 0xC0 +#endif + +// <o> HID Generic INTERRUPT IN Endpoint Address +// <0x81=> EndpointAddress = 0x81 +// <0x82=> EndpointAddress = 0x82 +// <0x83=> EndpointAddress = 0x83 +// <0x84=> EndpointAddress = 0x84 +// <0x85=> EndpointAddress = 0x85 +// <0x86=> EndpointAddress = 0x86 +// <0x87=> EndpointAddress = 0x87 +// <id> usb_composite_hid_generic_intin_epaddr +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_INTIN_EPADDR +#define CONF_USB_COMPOSITE_HID_GENERIC_INTIN_EPADDR 0x85 +#endif + +// <o> HID Generic INTERRUPT IN Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_hid_generic_intin_maxpksz +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_INTIN_MAXPKSZ +#define CONF_USB_COMPOSITE_HID_GENERIC_INTIN_MAXPKSZ 0x40 +#endif + +// <o> HID Generic INTERRUPT OUT Endpoint Address +// <0x01=> EndpointAddress = 0x01 +// <0x02=> EndpointAddress = 0x02 +// <0x03=> EndpointAddress = 0x03 +// <0x04=> EndpointAddress = 0x04 +// <0x05=> EndpointAddress = 0x05 +// <0x06=> EndpointAddress = 0x06 +// <0x07=> EndpointAddress = 0x07 +// <id> usb_composite_hid_generic_intout_epaddr +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_INTOUT_EPADDR +#define CONF_USB_COMPOSITE_HID_GENERIC_INTOUT_EPADDR 0x3 +#endif + +// <o> HID Generic INTERRUPT OUT Endpoint wMaxPacketSize +// <0x0008=> 8 bytes +// <0x0010=> 16 bytes +// <0x0020=> 32 bytes +// <0x0040=> 64 bytes +// <id> usb_composite_hid_generic_intout_maxpksz +// <i> Please make sure that the setting here is coincide with the endpoint setting in USB device driver. +#ifndef CONF_USB_COMPOSITE_HID_GENERIC_INTOUT_MAXPKSZ +#define CONF_USB_COMPOSITE_HID_GENERIC_INTOUT_MAXPKSZ 0x40 +#endif + +// </e> + +// <<< end of configuration section >>> + +#endif // USBD_COMPOSITE_CONFIG_H diff --git a/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_generic.c b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_generic.c new file mode 100644 index 000000000..2c7cd3584 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_generic.c @@ -0,0 +1,358 @@ +/** + * \file + * + * \brief USB Device Stack HID Generic Function Implementation. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel micro controller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#include "hiddf_generic.h" +#include <string.h> + +#define HIDDF_GENERIC_VERSION 0x00000001u + +/** USB Device HID Generic Function Specific Data */ +struct hiddf_generic_func_data { + /** HID Device Generic Interface information */ + uint8_t func_iface; + /** HID Device Generic IN Endpoint */ + uint8_t func_ep_in; + /** HID Device Generic OUT Endpoint */ + uint8_t func_ep_out; + /** HID Device Generic Report Descriptor */ + const uint8_t *report_desc; + /** HID Device Generic Report Descriptor Length */ + uint32_t report_desc_len; + /** HID Device Generic Enable Flag */ + bool enabled; +}; + +/* USB Device HID Generic Function Instance */ +static struct usbdf_driver _hiddf_generic; + +/* USB Device HID Generic Function Data Instance */ +static struct hiddf_generic_func_data _hiddf_generic_funcd; + +/* USB Device HID Generic Set Report Function Callback */ +static hiddf_generic_set_report_t hiddf_generic_set_report = NULL; + +/** + * \brief Enable HID Generic Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB interface descriptor + * \return Operation status. + */ +static int32_t hid_generic_enable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + uint8_t * ifc, *ep, i; + usb_iface_desc_t ifc_desc; + usb_ep_desc_t ep_desc; + + struct hiddf_generic_func_data *func_data = (struct hiddf_generic_func_data *)(drv->func_data); + + ifc = desc->sod; + if (NULL == ifc) { + return ERR_NOT_FOUND; + } + + ifc_desc.bInterfaceNumber = ifc[2]; + ifc_desc.bInterfaceClass = ifc[5]; + + if (HID_CLASS == ifc_desc.bInterfaceClass) { + if (func_data->func_iface == ifc_desc.bInterfaceNumber) { // Initialized + return ERR_ALREADY_INITIALIZED; + } else if (func_data->func_iface != 0xFF) { // Occupied + return ERR_NO_RESOURCE; + } else { + func_data->func_iface = ifc_desc.bInterfaceNumber; + } + } else { // Not supported by this function driver + return ERR_NOT_FOUND; + } + + // Install endpoints + for (i = 0; i < 2; i++) { + ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod); + desc->sod = ep; + if (NULL != ep) { + ep_desc.bEndpointAddress = ep[2]; + ep_desc.bmAttributes = ep[3]; + ep_desc.wMaxPacketSize = usb_get_u16(ep + 4); + if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) { + return ERR_NOT_INITIALIZED; + } + if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) { + func_data->func_ep_in = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_in); + } else { + func_data->func_ep_out = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_out); + } + } else { + return ERR_NOT_FOUND; + } + } + + // Installed + _hiddf_generic_funcd.enabled = true; + return ERR_NONE; +} + +/** + * \brief Disable HID Generic Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB device descriptor + * \return Operation status. + */ +static int32_t hid_generic_disable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + struct hiddf_generic_func_data *func_data = (struct hiddf_generic_func_data *)(drv->func_data); + + usb_iface_desc_t ifc_desc; + + if (desc) { + ifc_desc.bInterfaceClass = desc->sod[5]; + if (ifc_desc.bInterfaceClass != HID_CLASS) { + return ERR_NOT_FOUND; + } + } + + if (func_data->func_iface != 0xFF) { + func_data->func_iface = 0xFF; + } + + if (func_data->func_ep_in != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_in); + func_data->func_ep_in = 0xFF; + } + + if (func_data->func_ep_out != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_out); + func_data->func_ep_out = 0xFF; + } + + _hiddf_generic_funcd.enabled = false; + return ERR_NONE; +} + +/** + * \brief HID Generic Control Function + * \param[in] drv Pointer to USB device function driver + * \param[in] ctrl USB device general function control type + * \param[in] param Parameter pointer + * \return Operation status. + */ +static int32_t hid_generic_ctrl(struct usbdf_driver *drv, enum usbdf_control ctrl, void *param) +{ + switch (ctrl) { + case USBDF_ENABLE: + return hid_generic_enable(drv, (struct usbd_descriptors *)param); + + case USBDF_DISABLE: + return hid_generic_disable(drv, (struct usbd_descriptors *)param); + + case USBDF_GET_IFACE: + return ERR_UNSUPPORTED_OP; + + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the HID class get descriptor + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t hid_generic_get_desc(uint8_t ep, struct usb_req *req) +{ + switch (req->wValue >> 8) { + case USB_DT_HID_REPORT: + return usbdc_xfer(ep, (uint8_t *)_hiddf_generic_funcd.report_desc, _hiddf_generic_funcd.report_desc_len, false); + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the HID class request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t hid_generic_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + uint8_t *ctrl_buf = usbdc_get_ctrl_buffer(); + uint16_t len = req->wLength; + + if ((0x81 == req->bmRequestType) && (0x06 == req->bRequest) && (req->wIndex == _hiddf_generic_funcd.func_iface)) { + return hid_generic_get_desc(ep, req); + } else { + if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request + return ERR_NOT_FOUND; + } + if (req->wIndex == _hiddf_generic_funcd.func_iface) { + if (req->bmRequestType & USB_EP_DIR_IN) { + return ERR_INVALID_ARG; + } else { + if (USB_REQ_HID_SET_REPORT == req->bRequest) { + if (USB_SETUP_STAGE == stage) { + return usbdc_xfer(ep, ctrl_buf, len, false); + } else { + if (NULL != hiddf_generic_set_report) { + hiddf_generic_set_report(ctrl_buf, len); + } + return ERR_NONE; + } + } else { + return usbdc_xfer(0, NULL, 0, 0); + } + } + } else { + return ERR_NOT_FOUND; + } + } +} + +/** USB Device HID Generic Handler Struct */ +static struct usbdc_handler hid_generic_req_h = {NULL, (FUNC_PTR)hid_generic_req}; + +/** + * \brief Initialize the USB HID Generic Function Driver + */ +int32_t hiddf_generic_init(const uint8_t *report_desc, uint32_t len) +{ + if (NULL == report_desc || 0 == len) { + return ERR_INVALID_ARG; + } + + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _hiddf_generic_funcd.report_desc = report_desc; + _hiddf_generic_funcd.report_desc_len = len; + _hiddf_generic.ctrl = hid_generic_ctrl; + _hiddf_generic.func_data = &_hiddf_generic_funcd; + + usbdc_register_function(&_hiddf_generic); + usbdc_register_handler(USBDC_HDL_REQ, &hid_generic_req_h); + + return ERR_NONE; +} + +/** + * \brief Deinitialize the USB HID Generic Function Driver + */ +int32_t hiddf_generic_deinit(void) +{ + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _hiddf_generic.ctrl = NULL; + _hiddf_generic.func_data = NULL; + + usbdc_unregister_function(&_hiddf_generic); + usbdc_unregister_handler(USBDC_HDL_REQ, &hid_generic_req_h); + return ERR_NONE; +} + +/** + * \brief Check whether HID Generic Function is enabled + */ +bool hiddf_generic_is_enabled(void) +{ + return _hiddf_generic_funcd.enabled; +} + +/** + * \brief USB HID Generic Function Read Data + */ +int32_t hiddf_generic_read(uint8_t *buf, uint32_t size) +{ + if (!hiddf_generic_is_enabled()) { + return ERR_DENIED; + } + return usbdc_xfer(_hiddf_generic_funcd.func_ep_out, buf, size, false); +} + +/** + * \brief USB HID Generic Function Write Data + */ +int32_t hiddf_generic_write(uint8_t *buf, uint32_t size) +{ + if (!hiddf_generic_is_enabled()) { + return ERR_DENIED; + } + return usbdc_xfer(_hiddf_generic_funcd.func_ep_in, buf, size, false); +} + +/** + * \brief USB HID Generic Function Register Callback + */ +int32_t hiddf_generic_register_callback(enum hiddf_generic_cb_type cb_type, FUNC_PTR func) +{ + if (!hiddf_generic_is_enabled()) { + return ERR_DENIED; + } + switch (cb_type) { + case HIDDF_GENERIC_CB_READ: + usb_d_ep_register_callback(_hiddf_generic_funcd.func_ep_out, USB_D_EP_CB_XFER, func); + break; + case HIDDF_GENERIC_CB_WRITE: + usb_d_ep_register_callback(_hiddf_generic_funcd.func_ep_in, USB_D_EP_CB_XFER, func); + break; + case HIDDF_GENERIC_CB_SET_REPORT: + hiddf_generic_set_report = (hiddf_generic_set_report_t)func; + break; + default: + return ERR_INVALID_ARG; + } + + return ERR_NONE; +} + +/** + * \brief Return version + */ +uint32_t hiddf_generic_get_version(void) +{ + return HIDDF_GENERIC_VERSION; +} diff --git a/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_generic.h b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_generic.h new file mode 100644 index 000000000..c12f1575a --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_generic.h @@ -0,0 +1,102 @@ +/** + * \file + * + * \brief USB Device Stack HID Generic Function Definition. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef USBDF_HID_GENERIC_H_ +#define USBDF_HID_GENERIC_H_ + +#include "usbdc.h" +#include "usb_protocol_hid.h" + +/** HID Generic Callback Type */ +enum hiddf_generic_cb_type { HIDDF_GENERIC_CB_READ, HIDDF_GENERIC_CB_WRITE, HIDDF_GENERIC_CB_SET_REPORT }; + +/** HID Generic Set Report Callback. */ +typedef bool (*hiddf_generic_set_report_t)(uint8_t *, uint16_t); + +/** + * \brief Initialize the USB HID Generic Function Driver + * \param[in] report_desc Point to usr HID Report Descriptor + * \param[in] len length of usr HID Report Descriptor + * \return Operation status. + */ +int32_t hiddf_generic_init(const uint8_t *report_desc, uint32_t len); + +/** + * \brief Deinitialize the USB HID Generic Function Driver + * \return Operation status. + */ +int32_t hiddf_generic_deinit(void); + +/** + * \brief Check whether HID Generic Function is enabled + * \return Operation status. + * \return true HID Generic Function is enabled + * \return false HID Generic Function is disabled + */ +bool hiddf_generic_is_enabled(void); + +/** + * \brief USB HID Generic Function Read Data + * \param[in] buf Pointer to the buffer which receives data + * \param[in] size the size of data to be received + * \return Operation status. + */ +int32_t hiddf_generic_read(uint8_t *buf, uint32_t size); + +/** + * \brief USB HID Generic Function Write Data + * \param[in] buf Pointer to the buffer which stores data + * \param[in] size the size of data to be sent + * \return Operation status. + */ +int32_t hiddf_generic_write(uint8_t *buf, uint32_t size); + +/** + * \brief USB HID Generic Function Register Callback + * \param[in] cb_type Callback type of HID Generic Function + * \param[in] func Pointer to callback function + * \return Operation status. + */ +int32_t hiddf_generic_register_callback(enum hiddf_generic_cb_type cb_type, FUNC_PTR func); + +/** + * \brief Return version + */ +uint32_t hiddf_generic_get_version(void); + +#endif /* USBDF_HID_GENERIC_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_keyboard.c b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_keyboard.c new file mode 100644 index 000000000..835481e41 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_keyboard.c @@ -0,0 +1,365 @@ +/** + * \file + * + * \brief USB Device Stack HID Keyboard Function Implementation. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel micro controller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#include "hiddf_keyboard.h" +#include <string.h> + +#define HIDDF_KEYBOARD_VERSION 0x00000001u + +#define KEYBOARD_REPORT_DESC_LEN 59 + +/** USB Device HID Keyboard Function Specific Data */ +struct hiddf_keyboard_func_data { + /* HID Device Keyboard Report */ + uint8_t kb_report[8]; + /** HID Device Keyboard Interface information */ + uint8_t func_iface; + /** HID Device Keyboard IN Endpoint */ + uint8_t func_ep_in; + /** HID Device Keyboard OUT Endpoint */ + uint8_t func_ep_out; + /** HID Device Keyboard Enable Flag */ + bool enabled; +}; + +/* HID report descriptor for standard HID keyboard */ +const uint8_t keyboard_report_desc[KEYBOARD_REPORT_DESC_LEN] = { + 0x05, 0x01, /* Usage Page (Generic Desktop) */ + 0x09, 0x06, /* Usage (Keyboard) */ + 0xA1, 0x01, /* Collection (Application) */ + 0x05, 0x07, /* Usage Page (Keyboard) */ + 0x19, 0xE0, /* Usage Minimum (224) */ + 0x29, 0xE7, /* Usage Maximum (231) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x25, 0x01, /* Logical Maximum (1) */ + 0x75, 0x01, /* Report Size (1) */ + 0x95, 0x08, /* Report Count (8) */ + 0x81, 0x02, /* Input (Data, Variable, Absolute) */ + 0x81, 0x01, /* Input (Constant) */ + 0x19, 0x00, /* Usage Minimum (0) */ + 0x29, 0x65, /* Usage Maximum (101) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x25, 0x65, /* Logical Maximum (101) */ + 0x75, 0x08, /* Report Size (8) */ + 0x95, 0x06, /* Report Count (6) */ + 0x81, 0x00, /* Input (Data, Array) */ + 0x05, 0x08, /* Usage Page (LED) */ + 0x19, 0x01, /* Usage Minimum (1) */ + 0x29, 0x05, /* Usage Maximum (5) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x25, 0x01, /* Logical Maximum (1) */ + 0x75, 0x01, /* Report Size (1) */ + 0x95, 0x05, /* Report Count (5) */ + 0x91, 0x02, /* Output (Data, Variable, Absolute) */ + 0x95, 0x03, /* Report Count (3) */ + 0x91, 0x01, /* Output (Constant) */ + 0xC0 /* End Collection */ +}; + +/* USB Device HID Keyboard Function Instance */ +static struct usbdf_driver _hiddf_keyboard; + +/* USB Device HID Keyboard Function Data Instance */ +static struct hiddf_keyboard_func_data _hiddf_keyboard_funcd; + +/** + * \brief Enable HID Keyboard Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB interface descriptor + * \return Operation status. + */ +static int32_t hid_keyboard_enable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + uint8_t * ifc, *ep, i; + usb_iface_desc_t ifc_desc; + usb_ep_desc_t ep_desc; + + struct hiddf_keyboard_func_data *func_data = (struct hiddf_keyboard_func_data *)(drv->func_data); + + ifc = desc->sod; + if (NULL == ifc) { + return ERR_NOT_FOUND; + } + + ifc_desc.bInterfaceNumber = ifc[2]; + ifc_desc.bInterfaceClass = ifc[5]; + + if (HID_CLASS == ifc_desc.bInterfaceClass) { + if (func_data->func_iface == ifc_desc.bInterfaceNumber) { // Initialized + return ERR_ALREADY_INITIALIZED; + } else if (func_data->func_iface != 0xFF) { // Occupied + return ERR_NO_RESOURCE; + } else { + func_data->func_iface = ifc_desc.bInterfaceNumber; + } + } else { // Not supported by this function driver + return ERR_NOT_FOUND; + } + + // Install endpoints + for (i = 0; i < 2; i++) { + ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod); + desc->sod = ep; + if (NULL != ep) { + ep_desc.bEndpointAddress = ep[2]; + ep_desc.bmAttributes = ep[3]; + ep_desc.wMaxPacketSize = usb_get_u16(ep + 4); + if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) { + return ERR_NOT_INITIALIZED; + } + if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) { + func_data->func_ep_in = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_in); + } else { + func_data->func_ep_out = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_out); + } + } else { + return ERR_NOT_FOUND; + } + } + + // Installed + _hiddf_keyboard_funcd.enabled = true; + return ERR_NONE; +} + +/** + * \brief Disable HID Keyboard Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB device descriptor + * \return Operation status. + */ +static int32_t hid_keyboard_disable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + struct hiddf_keyboard_func_data *func_data = (struct hiddf_keyboard_func_data *)(drv->func_data); + + usb_iface_desc_t ifc_desc; + + if (desc) { + ifc_desc.bInterfaceClass = desc->sod[5]; + if (ifc_desc.bInterfaceClass != HID_CLASS) { + return ERR_NOT_FOUND; + } + } + + if (func_data->func_iface != 0xFF) { + func_data->func_iface = 0xFF; + } + + if (func_data->func_ep_in != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_in); + func_data->func_ep_in = 0xFF; + } + + if (func_data->func_ep_out != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_out); + func_data->func_ep_out = 0xFF; + } + + _hiddf_keyboard_funcd.enabled = false; + return ERR_NONE; +} + +/** + * \brief HID Keyboard Control Function + * \param[in] drv Pointer to USB device function driver + * \param[in] ctrl USB device general function control type + * \param[in] param Parameter pointer + * \return Operation status. + */ +static int32_t hid_keyboard_ctrl(struct usbdf_driver *drv, enum usbdf_control ctrl, void *param) +{ + switch (ctrl) { + case USBDF_ENABLE: + return hid_keyboard_enable(drv, (struct usbd_descriptors *)param); + + case USBDF_DISABLE: + return hid_keyboard_disable(drv, (struct usbd_descriptors *)param); + + case USBDF_GET_IFACE: + return ERR_UNSUPPORTED_OP; + + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the HID class get descriptor + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t hid_keyboard_get_desc(uint8_t ep, struct usb_req *req) +{ + switch (req->wValue >> 8) { + case USB_DT_HID_REPORT: + return usbdc_xfer(ep, (uint8_t *)keyboard_report_desc, KEYBOARD_REPORT_DESC_LEN, false); + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the HID class request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t hid_keyboard_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + if ((0x81 == req->bmRequestType) && (0x06 == req->bRequest) && (req->wIndex == _hiddf_keyboard_funcd.func_iface)) { + return hid_keyboard_get_desc(ep, req); + } else { + if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request + return ERR_NOT_FOUND; + } + if (req->wIndex == _hiddf_keyboard_funcd.func_iface) { + if (req->bmRequestType & USB_EP_DIR_IN) { + return ERR_INVALID_ARG; + } else { + return usbdc_xfer(0, NULL, 0, 0); + } + } else { + return ERR_NOT_FOUND; + } + } + (void)stage; +} + +/** USB Device HID Keyboard Handler Struct */ +static struct usbdc_handler hid_keyboard_req_h = {NULL, (FUNC_PTR)hid_keyboard_req}; + +/** + * \brief Initialize the USB HID Keyboard Function Driver + */ +int32_t hiddf_keyboard_init(void) +{ + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _hiddf_keyboard.ctrl = hid_keyboard_ctrl; + _hiddf_keyboard.func_data = &_hiddf_keyboard_funcd; + + usbdc_register_function(&_hiddf_keyboard); + usbdc_register_handler(USBDC_HDL_REQ, &hid_keyboard_req_h); + return ERR_NONE; +} + +/** + * \brief Deinitialize the USB HID Keyboard Function Driver + */ +int32_t hiddf_keyboard_deinit(void) +{ + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _hiddf_keyboard.ctrl = NULL; + _hiddf_keyboard.func_data = NULL; + + usbdc_unregister_function(&_hiddf_keyboard); + usbdc_unregister_handler(USBDC_HDL_REQ, &hid_keyboard_req_h); + return ERR_NONE; +} + +/** + * \brief Check whether HID Keyboard Function is enabled + */ +bool hiddf_keyboard_is_enabled(void) +{ + return _hiddf_keyboard_funcd.enabled; +} + +/** + * \brief Process the HID Keyboard key state change request + * \param keys_desc[] keys_descriptor array for state changing + * \param keys_count total keys amount for state changing + * \return Operation status. + */ +int32_t hiddf_keyboard_keys_state_change(struct hiddf_kb_key_descriptors keys_desc[], uint8_t keys_count) +{ + uint8_t i, j; + uint8_t modifier_keys, regular_keys; + + if (!hiddf_keyboard_is_enabled()) { + return ERR_DENIED; + } + + memset(_hiddf_keyboard_funcd.kb_report, 0x00, 8); + modifier_keys = 0; + + for (i = 0; i < keys_count; i++) { + if (true == keys_desc[i].b_modifier) { + modifier_keys++; + } + } + + regular_keys = keys_count - modifier_keys; + + if (regular_keys > 6) { + memset(&_hiddf_keyboard_funcd.kb_report[2], 0xFF, 6); + } else { + i = 2; + for (j = 0; j < keys_count; j++) { + if (HID_KB_KEY_DOWN == keys_desc[j].state) { + if (true == keys_desc[j].b_modifier) { + _hiddf_keyboard_funcd.kb_report[0] |= keys_desc[j].key_id; + } else { + _hiddf_keyboard_funcd.kb_report[i++] = keys_desc[j].key_id; + } + } + } + } + return usbdc_xfer(_hiddf_keyboard_funcd.func_ep_in, &_hiddf_keyboard_funcd.kb_report[0], 8, false); +} + +/** + * \brief Return version + */ +uint32_t hiddf_keyboard_get_version(void) +{ + return HIDDF_KEYBOARD_VERSION; +} diff --git a/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_keyboard.h b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_keyboard.h new file mode 100644 index 000000000..3295d1b78 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_keyboard.h @@ -0,0 +1,91 @@ +/** + * \file + * + * \brief USB Device Stack HID Keyboard Function Definition. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef USBDF_HID_KEYBOARD_H_ +#define USBDF_HID_KEYBOARD_H_ + +#include "usbdc.h" +#include "usb_protocol_hid.h" + +/** HID Keyboard Class Key State Type */ +enum hiddf_kb_key_state { HID_KB_KEY_UP, HID_KB_KEY_DOWN }; + +/** Describes the USB HID Keyboard Key descriptors. */ +struct hiddf_kb_key_descriptors { + /* HID Key Value, defined in usb_protocol_hid.h */ + uint8_t key_id; + /* Flag whether it is a modifier key */ + bool b_modifier; + /* Key State */ + enum hiddf_kb_key_state state; +}; + +/** + * \brief Initialize the USB HID Keyboard Function Driver + * \return Operation status. + */ +int32_t hiddf_keyboard_init(void); + +/** + * \brief Deinitialize the USB HID Keyboard Function Driver + * \return Operation status. + */ +int32_t hiddf_keyboard_deinit(void); + +/** + * \brief Check whether HID Keyboard Function is enabled + * \return Operation status. + * \return true HID Keyboard Function is enabled + * \return false HID Keyboard Function is disabled + */ +bool hiddf_keyboard_is_enabled(void); + +/** + * \brief Process the HID Keyboard key state change request + * \param keys_desc[] keys_descriptor array for state changing + * \param keys_count total keys amount for state changing + * \return Operation status. + */ +int32_t hiddf_keyboard_keys_state_change(struct hiddf_kb_key_descriptors keys_desc[], uint8_t keys_count); + +/** + * \brief Return version + */ +uint32_t hiddf_keyboard_get_version(void); + +#endif /* USBDF_HID_KEYBOARD_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_mouse.c b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_mouse.c new file mode 100644 index 000000000..7a58ce66e --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_mouse.c @@ -0,0 +1,363 @@ +/** + * \file + * + * \brief USB Device Stack HID Mouse Function Implementation. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel micro controller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#include "hiddf_mouse.h" + +#define HIDDF_MOUSE_VERSION 0x00000001u + +#define MOUSE_REPORT_DESC_LEN 52 + +/** USB Device HID Mouse Function Specific Data */ +struct hiddf_mouse_func_data { + /* HID Device Mouse Report */ + union { + /** Interpreted by bytes. */ + struct { + /** Button Status. */ + uint8_t button_state; + /** X Axis Variant.*/ + uint8_t x_axis_var; + /** Y Axis Variant.*/ + uint8_t y_axis_var; + /** Scroll Variant.*/ + uint8_t scroll_var; + } bytes; + uint32_t u32; + } mouse_report; + /** HID Device Mouse Interface information */ + uint8_t func_iface; + /** HID Device Mouse IN Endpoint */ + uint8_t func_ep_in; + /** HID Device Mouse Enable Flag */ + bool enabled; +}; + +/* HID report descriptor for standard HID mouse */ +const uint8_t mouse_report_desc[MOUSE_REPORT_DESC_LEN] = { + 0x05, 0x01, /* Usage Page (Generic Desktop), */ + 0x09, 0x02, /* Usage (Mouse), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x09, 0x01, /* Usage (Pointer), */ + 0xA1, 0x00, /* Collection (Physical), */ + 0x05, 0x09, /* Usage Page (Buttons), */ + 0x19, 0x01, /* Usage Minimum (01), */ + 0x29, 0x03, /* Usage Maximum (03), */ + 0x15, 0x00, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x02, /* Input (Data, Variable, Absolute) */ + 0x75, 0x05, /* Report Size (5), */ + 0x95, 0x01, /* Report Count (1), */ + 0x81, 0x01, /* Input (Constant), */ + 0x05, 0x01, /* Usage Page (Generic Desktop), */ + 0x09, 0x30, /* Usage (X), */ + 0x09, 0x31, /* Usage (Y), */ + 0x09, 0x38, /* Usage (Scroll), */ + 0x15, 0x81, /* Logical Minimum (-127), */ + 0x25, 0x7F, /* Logical Maximum (127), */ + 0x75, 0x08, /* Report Size (8), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x06, /* Input (Data, Variable, Relative) */ + 0xC0, /* End Collection, */ + 0xC0, /* End Collection */ +}; + +/* USB Device HID Mouse Function Instance */ +static struct usbdf_driver _hiddf_mouse; + +/* USB Device HID Mouse Function Data Instance */ +static struct hiddf_mouse_func_data _hiddf_mouse_funcd; + +/** + * \brief Enable HID Mouse Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB interface descriptor + * \return Operation status. + */ +static int32_t hid_mouse_enable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + uint8_t * ifc, *ep; + usb_iface_desc_t ifc_desc; + usb_ep_desc_t ep_desc; + + struct hiddf_mouse_func_data *func_data = (struct hiddf_mouse_func_data *)(drv->func_data); + + ifc = desc->sod; + if (NULL == ifc) { + return ERR_NOT_FOUND; + } + + ifc_desc.bInterfaceNumber = ifc[2]; + ifc_desc.bInterfaceClass = ifc[5]; + + if (HID_CLASS == ifc_desc.bInterfaceClass) { + if (func_data->func_iface == ifc_desc.bInterfaceNumber) { // Initialized + return ERR_ALREADY_INITIALIZED; + } else if (func_data->func_iface != 0xFF) { // Occupied + return ERR_NO_RESOURCE; + } else { + func_data->func_iface = ifc_desc.bInterfaceNumber; + } + } else { // Not supported by this function driver + return ERR_NOT_FOUND; + } + + // Install endpoints + ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod); + desc->sod = ep; + if (NULL != ep) { + ep_desc.bEndpointAddress = ep[2]; + ep_desc.bmAttributes = ep[3]; + ep_desc.wMaxPacketSize = usb_get_u16(ep + 4); + if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) { + return ERR_NOT_INITIALIZED; + } + if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) { + func_data->func_ep_in = ep_desc.bEndpointAddress; + usb_d_ep_enable(func_data->func_ep_in); + } else { + return ERR_INVALID_DATA; + } + } else { + return ERR_NOT_FOUND; + } + // Installed + _hiddf_mouse_funcd.enabled = true; + return ERR_NONE; +} + +/** + * \brief Disable HID Mouse Function + * \param[in] drv Pointer to USB device function driver + * \param[in] desc Pointer to USB device descriptor + * \return Operation status. + */ +static int32_t hid_mouse_disable(struct usbdf_driver *drv, struct usbd_descriptors *desc) +{ + struct hiddf_mouse_func_data *func_data = (struct hiddf_mouse_func_data *)(drv->func_data); + + usb_iface_desc_t ifc_desc; + + if (desc) { + ifc_desc.bInterfaceClass = desc->sod[5]; + if (ifc_desc.bInterfaceClass != HID_CLASS) { + return ERR_NOT_FOUND; + } + } + + if (func_data->func_iface != 0xFF) { + func_data->func_iface = 0xFF; + } + + if (func_data->func_ep_in != 0xFF) { + usb_d_ep_deinit(func_data->func_ep_in); + func_data->func_ep_in = 0xFF; + } + + _hiddf_mouse_funcd.enabled = false; + return ERR_NONE; +} + +/** + * \brief HID Mouse Control Function + * \param[in] drv Pointer to USB device function driver + * \param[in] ctrl USB device general function control type + * \param[in] param Parameter pointer + * \return Operation status. + */ +static int32_t hid_mouse_ctrl(struct usbdf_driver *drv, enum usbdf_control ctrl, void *param) +{ + switch (ctrl) { + case USBDF_ENABLE: + return hid_mouse_enable(drv, (struct usbd_descriptors *)param); + + case USBDF_DISABLE: + return hid_mouse_disable(drv, (struct usbd_descriptors *)param); + + case USBDF_GET_IFACE: + return ERR_UNSUPPORTED_OP; + + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the HID class get descriptor + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t hid_mouse_get_desc(uint8_t ep, struct usb_req *req) +{ + switch (req->wValue >> 8) { + case USB_DT_HID_REPORT: + return usbdc_xfer(ep, (uint8_t *)mouse_report_desc, MOUSE_REPORT_DESC_LEN, false); + default: + return ERR_INVALID_ARG; + } +} + +/** + * \brief Process the HID class request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + */ +static int32_t hid_mouse_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + if ((0x81 == req->bmRequestType) && (0x06 == req->bRequest) && (req->wIndex == _hiddf_mouse_funcd.func_iface)) { + return hid_mouse_get_desc(ep, req); + } else { + if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request + return ERR_NOT_FOUND; + } + if (req->wIndex == _hiddf_mouse_funcd.func_iface) { + if (req->bmRequestType & USB_EP_DIR_IN) { + return ERR_INVALID_ARG; + } else { + return usbdc_xfer(0, NULL, 0, 0); + } + } else { + return ERR_NOT_FOUND; + } + } + (void)stage; +} + +/** USB Device HID Mouse Handler Struct */ +static struct usbdc_handler hid_mouse_req_h = {NULL, (FUNC_PTR)hid_mouse_req}; + +/** + * \brief Initialize the USB HID Mouse Function Driver + */ +int32_t hiddf_mouse_init(void) +{ + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _hiddf_mouse.ctrl = hid_mouse_ctrl; + _hiddf_mouse.func_data = &_hiddf_mouse_funcd; + + usbdc_register_function(&_hiddf_mouse); + usbdc_register_handler(USBDC_HDL_REQ, &hid_mouse_req_h); + return ERR_NONE; +} + +/** + * \brief Deinitialize the USB HID Mouse Function Driver + */ +int32_t hiddf_mouse_deinit(void) +{ + if (usbdc_get_state() > USBD_S_POWER) { + return ERR_DENIED; + } + + _hiddf_mouse.ctrl = NULL; + _hiddf_mouse.func_data = NULL; + + usbdc_unregister_function(&_hiddf_mouse); + usbdc_unregister_handler(USBDC_HDL_REQ, &hid_mouse_req_h); + return ERR_NONE; +} + +/** + * \brief Check whether HID Mouse Function is enabled + */ +bool hiddf_mouse_is_enabled(void) +{ + return _hiddf_mouse_funcd.enabled; +} + +/** + * \brief Move the mouse pointer + * \param pos Signed value to move + * \param type HID mouse class pointer move type + * \return Operation status. + */ +int32_t hiddf_mouse_move(int8_t pos, enum hiddf_mouse_move_type type) +{ + + _hiddf_mouse_funcd.mouse_report.u32 = 0; + + if (type == HID_MOUSE_X_AXIS_MV) { + _hiddf_mouse_funcd.mouse_report.bytes.x_axis_var = pos; + } else if (type == HID_MOUSE_Y_AXIS_MV) { + _hiddf_mouse_funcd.mouse_report.bytes.y_axis_var = pos; + } else if (type == HID_MOUSE_SCROLL_MV) { + _hiddf_mouse_funcd.mouse_report.bytes.scroll_var = pos; + } else { + return ERR_INVALID_ARG; + } + + return usbdc_xfer(_hiddf_mouse_funcd.func_ep_in, &_hiddf_mouse_funcd.mouse_report.bytes.button_state, 4, false); +} + +/** + * \brief Changes button state + * \param b_state New button state + * \param type Button type + * \return Operation status. + */ +int32_t hiddf_mouse_button_change(enum hiddf_mouse_button_state b_state, enum hiddf_mouse_button_type type) +{ + _hiddf_mouse_funcd.mouse_report.u32 = 0; + + if (b_state == HID_MOUSE_BTN_DOWN) { + _hiddf_mouse_funcd.mouse_report.bytes.button_state = type; + } else { + _hiddf_mouse_funcd.mouse_report.bytes.button_state = 0x00; + } + + return usbdc_xfer(_hiddf_mouse_funcd.func_ep_in, &_hiddf_mouse_funcd.mouse_report.bytes.button_state, 4, false); +} + +/** + * \brief Return version + */ +uint32_t hiddf_mouse_get_version(void) +{ + return HIDDF_MOUSE_VERSION; +} diff --git a/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_mouse.h b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_mouse.h new file mode 100644 index 000000000..464b1e92d --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/device/hiddf_mouse.h @@ -0,0 +1,95 @@ +/** + * \file + * + * \brief USB Device Stack HID Mouse Function Definition. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef USBDF_HID_MOUSE_H_ +#define USBDF_HID_MOUSE_H_ + +#include "usbdc.h" +#include "usb_protocol_hid.h" + +/** HID Mouse Class Button State Type */ +enum hiddf_mouse_button_state { HID_MOUSE_BTN_UP, HID_MOUSE_BTN_DOWN }; + +/* HID Mosue Class Button Type */ +enum hiddf_mouse_button_type { HID_MOUSE_LEFT_BTN = 0x01, HID_MOUSE_RIGHT_BTN = 0x02, HID_MOUSE_MIDDLE_BTN = 0x04 }; + +/* HID Mouse Class Pointer Move Type */ +enum hiddf_mouse_move_type { HID_MOUSE_X_AXIS_MV = 0x01, HID_MOUSE_Y_AXIS_MV = 0x02, HID_MOUSE_SCROLL_MV = 0x03 }; + +/** + * \brief Initialize the USB HID Mouse Function Driver + * \return Operation status. + */ +int32_t hiddf_mouse_init(void); + +/** + * \brief Deinitialize the USB HID Mouse Function Driver + * \return Operation status. + */ +int32_t hiddf_mouse_deinit(void); + +/** + * \brief Check whether HID Mouse Function is enabled + * \return Operation status. + * \return true HID Mouse Function is enabled + * \return false HID Mouse Function is disabled + */ +bool hiddf_mouse_is_enabled(void); + +/** + * \brief Move the mouse pointer + * \param pos Signed value to move + * \param type HID mouse class pointer move type + * \return Operation status. + */ +int32_t hiddf_mouse_move(int8_t pos, enum hiddf_mouse_move_type type); + +/** + * \brief Changes button state + * \param b_state New button state + * \param type Button type + * \return Operation status. + */ +int32_t hiddf_mouse_button_change(enum hiddf_mouse_button_state b_state, enum hiddf_mouse_button_type type); + +/** + * \brief Return version + */ +uint32_t hiddf_mouse_get_version(void); + +#endif /* USBDF_CDC_ACM_SER_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/hid/usb_protocol_hid.h b/atmel-samd/asf4/samd21/usb/class/hid/usb_protocol_hid.h new file mode 100644 index 000000000..71d74e632 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hid/usb_protocol_hid.h @@ -0,0 +1,597 @@ +/** + * \file + * + * \brief USB Human Interface Device (HID) protocol definitions. + * + * Copyright (c) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#ifndef _USB_PROTOCOL_HID_H_ +#define _USB_PROTOCOL_HID_H_ + +#include "usb_includes.h" + +/** + * \ingroup usb_protocol_group + * \defgroup usb_hid_protocol USB Human Interface Device (HID) + * protocol definitions + * \brief USB Human Interface Device (HID) protocol definitions + * + * @{ + */ + +//! \name Possible Class value +//@{ +#define HID_CLASS 0x03 +//@} + +//! \name Possible SubClass value +//@{ +//! Interface subclass NO support BOOT protocol +#define HID_SUB_CLASS_NOBOOT 0x00 +//! Interface subclass support BOOT protocol +#define HID_SUB_CLASS_BOOT 0x01 +//@} + +//! \name Possible protocol value +//@{ +//! Protocol generic standard +#define HID_PROTOCOL_GENERIC 0x00 +//! Protocol keyboard standard +#define HID_PROTOCOL_KEYBOARD 0x01 +//! Protocol mouse standard +#define HID_PROTOCOL_MOUSE 0x02 +//@} + +//! \brief Hid USB requests (bRequest) + +#define USB_REQ_HID_GET_REPORT 0x01 +#define USB_REQ_HID_GET_IDLE 0x02 +#define USB_REQ_HID_GET_PROTOCOL 0x03 +#define USB_REQ_HID_SET_REPORT 0x09 +#define USB_REQ_HID_SET_IDLE 0x0A +#define USB_REQ_HID_SET_PROTOCOL 0x0B + +//! \brief HID USB descriptor types +#define USB_DT_HID 0x21 +#define USB_DT_HID_REPORT 0x22 +#define USB_DT_HID_PHYSICAL 0x23 + +//! \brief HID Type for report descriptor +#define USB_HID_ITEM_REPORT_TYPE_MAIN 0 +#define USB_HID_ITEM_REPORT_TYPE_GLOBAL 1 +#define USB_HID_ITEM_REPORT_TYPE_LOCAL 2 +#define USB_HID_ITEM_REPORT_TYPE_LONG 3 + +//! \brief HID report type +#define USB_HID_REPORT_TYPE_INPUT 1 +#define USB_HID_REPORT_TYPE_OUTPUT 2 +#define USB_HID_REPORT_TYPE_FEATURE 3 + +//! \brief HID protocol +#define USB_HID_PROCOTOL_BOOT 0 +#define USB_HID_PROCOTOL_REPORT 1 + +#define USB_HID_DESC_BYTES(bLength, bCountryCode, bNumDescriptors, bDescriptorType, bDescriptorLength) \ + bLength, 0x21, 0x10, 0x01, bCountryCode, bNumDescriptors, bDescriptorType, LE_BYTE0(bDescriptorLength), \ + LE_BYTE1(bDescriptorLength) + +COMPILER_PACK_SET(1) + +//! \brief HID Descriptor +typedef struct usb_hid_descriptor { + uint8_t bLength; //!< Size of this descriptor in bytes + uint8_t bDescriptorType; //!< HID descriptor type + le16_t bcdHID; //!< Binary Coded Decimal Spec. release + uint8_t bCountryCode; //!< Hardware target country + uint8_t bNumDescriptors; //!< Number of HID class descriptors to follow + uint8_t bRDescriptorType; //!< Report descriptor type + le16_t wDescriptorLength; //!< Total length of Report descriptor +} usb_hid_descriptor_t; + +COMPILER_PACK_RESET() + +//! \name HID Report type +//! Used by SETUP_HID_GET_REPORT & SETUP_HID_SET_REPORT +//! @{ +#define REPORT_TYPE_INPUT 0x01 +#define REPORT_TYPE_OUTPUT 0x02 +#define REPORT_TYPE_FEATURE 0x03 +//! @} + +//! \name Constants of field DESCRIPTOR_HID +//! @{ +//! Numeric expression identifying the HID Class +//! Specification release (here V1.11) +#define USB_HID_BDC_V1_11 0x0111 +//! Numeric expression specifying the number of class descriptors +//! Note: Always at least one i.e. Report descriptor. +#define USB_HID_NUM_DESC 0x01 + +//! \name Country code +//! @{ +#define USB_HID_NO_COUNTRY_CODE 0 // Not Supported +#define USB_HID_COUNTRY_ARABIC 1 // Arabic +#define USB_HID_COUNTRY_BELGIAN 2 // Belgian +#define USB_HID_COUNTRY_CANADIAN_BILINGUAL 3 // Canadian-Bilingual +#define USB_HID_COUNTRY_CANADIAN_FRENCH 4 // Canadian-French +#define USB_HID_COUNTRY_CZECH_REPUBLIC 5 // Czech Republic +#define USB_HID_COUNTRY_DANISH 6 // Danish +#define USB_HID_COUNTRY_FINNISH 7 // Finnish +#define USB_HID_COUNTRY_FRENCH 8 // French +#define USB_HID_COUNTRY_GERMAN 9 // German +#define USB_HID_COUNTRY_GREEK 10 // Greek +#define USB_HID_COUNTRY_HEBREW 11 // Hebrew +#define USB_HID_COUNTRY_HUNGARY 12 // Hungary +#define USB_HID_COUNTRY_INTERNATIONAL_ISO 13 // International (ISO) +#define USB_HID_COUNTRY_ITALIAN 14 // Italian +#define USB_HID_COUNTRY_JAPAN_KATAKANA 15 // Japan (Katakana) +#define USB_HID_COUNTRY_KOREAN 16 // Korean +#define USB_HID_COUNTRY_LATIN_AMERICAN 17 // Latin American +#define USB_HID_COUNTRY_NETHERLANDS_DUTCH 18 // Netherlands/Dutch +#define USB_HID_COUNTRY_NORWEGIAN 19 // Norwegian +#define USB_HID_COUNTRY_PERSIAN_FARSI 20 // Persian (Farsi) +#define USB_HID_COUNTRY_POLAND 21 // Poland +#define USB_HID_COUNTRY_PORTUGUESE 22 // Portuguese +#define USB_HID_COUNTRY_RUSSIA 23 // Russia +#define USB_HID_COUNTRY_SLOVAKIA 24 // Slovakia +#define USB_HID_COUNTRY_SPANISH 25 // Spanish +#define USB_HID_COUNTRY_SWEDISH 26 // Swedish +#define USB_HID_COUNTRY_SWISS_FRENCH 27 // Swiss/French +#define USB_HID_COUNTRY_SWISS_GERMAN 28 // Swiss/German +#define USB_HID_COUNTRY_SWITZERLAND 29 // Switzerland +#define USB_HID_COUNTRY_TAIWAN 30 // Taiwan +#define USB_HID_COUNTRY_TURKISH_Q 31 // Turkish-Q +#define USB_HID_COUNTRY_UK 32 // UK +#define USB_HID_COUNTRY_US 33 // US +#define USB_HID_COUNTRY_YUGOSLAVIA 34 // Yugoslavia +#define USB_HID_COUNTRY_TURKISH_F 35 // Turkish-F + //! @} + //! @} +//! @} + +//! \name HID KEYS values +//! @{ +#define HID_A 0x04 +#define HID_B 0x05 +#define HID_C 0x06 +#define HID_D 0x07 +#define HID_E 0x08 +#define HID_F 0x09 +#define HID_G 0x0A +#define HID_H 0x0B +#define HID_I 0x0C +#define HID_J 0x0D +#define HID_K 0x0E +#define HID_L 0x0F +#define HID_M 0x10 +#define HID_N 0x11 +#define HID_O 0x12 +#define HID_P 0x13 +#define HID_Q 0x14 +#define HID_R 0x15 +#define HID_S 0x16 +#define HID_T 0x17 +#define HID_U 0x18 +#define HID_V 0x19 +#define HID_W 0x1A +#define HID_X 0x1B +#define HID_Y 0x1C +#define HID_Z 0x1D +#define HID_1 30 +#define HID_2 31 +#define HID_3 32 +#define HID_4 33 +#define HID_5 34 +#define HID_6 35 +#define HID_7 36 +#define HID_8 37 +#define HID_9 38 +#define HID_0 39 +#define HID_ENTER 40 +#define HID_ESCAPE 41 +#define HID_BACKSPACE 42 +#define HID_TAB 43 +#define HID_SPACEBAR 44 +#define HID_UNDERSCORE 45 +#define HID_PLUS 46 +#define HID_OPEN_BRACKET 47 // { +#define HID_CLOSE_BRACKET 48 // } +#define HID_BACKSLASH 49 +#define HID_ASH 50 // # ~ +#define HID_COLON 51 // ; : +#define HID_QUOTE 52 // ' " +#define HID_TILDE 53 +#define HID_COMMA 54 +#define HID_DOT 55 +#define HID_SLASH 56 +#define HID_CAPS_LOCK 57 +#define HID_F1 58 +#define HID_F2 59 +#define HID_F3 60 +#define HID_F4 61 +#define HID_F5 62 +#define HID_F6 63 +#define HID_F7 64 +#define HID_F8 65 +#define HID_F9 66 +#define HID_F10 67 +#define HID_F11 68 +#define HID_F12 69 +#define HID_PRINTSCREEN 70 +#define HID_SCROLL_LOCK 71 +#define HID_PAUSE 72 +#define HID_INSERT 73 +#define HID_HOME 74 +#define HID_PAGEUP 75 +#define HID_DELETE 76 +#define HID_END 77 +#define HID_PAGEDOWN 78 +#define HID_RIGHT 79 +#define HID_LEFT 80 +#define HID_DOWN 81 +#define HID_UP 82 +#define HID_KEYPAD_NUM_LOCK 83 +#define HID_KEYPAD_DIVIDE 84 +#define HID_KEYPAD_AT 85 +#define HID_KEYPAD_MULTIPLY 85 +#define HID_KEYPAD_MINUS 86 +#define HID_KEYPAD_PLUS 87 +#define HID_KEYPAD_ENTER 88 +#define HID_KEYPAD_1 89 +#define HID_KEYPAD_2 90 +#define HID_KEYPAD_3 91 +#define HID_KEYPAD_4 92 +#define HID_KEYPAD_5 93 +#define HID_KEYPAD_6 94 +#define HID_KEYPAD_7 95 +#define HID_KEYPAD_8 96 +#define HID_KEYPAD_9 97 +#define HID_KEYPAD_0 98 + +//! \name HID modifier values +//! @{ +#define HID_MODIFIER_NONE 0x00 +#define HID_MODIFIER_LEFT_CTRL 0x01 +#define HID_MODIFIER_LEFT_SHIFT 0x02 +#define HID_MODIFIER_LEFT_ALT 0x04 +#define HID_MODIFIER_LEFT_UI 0x08 +#define HID_MODIFIER_RIGHT_CTRL 0x10 +#define HID_MODIFIER_RIGHT_SHIFT 0x20 +#define HID_MODIFIER_RIGHT_ALT 0x40 +#define HID_MODIFIER_RIGHT_UI 0x80 +//! @} +//! @} + +//! \name HID KEYS LED values +//! @{ +#define HID_LED_NUM_LOCK (1 << 0) +#define HID_LED_CAPS_LOCK (1 << 1) +#define HID_LED_SCROLL_LOCK (1 << 2) +#define HID_LED_COMPOSE (1 << 3) +#define HID_LED_KANA (1 << 4) +//! @} + +/** \name Standard HID mouse definitions from HID spec. example */ +/*@{*/ + +/** \brief Structure for standard HID keyboard modified keys */ +typedef union hid_kbd_modifier { + uint8_t byte; + struct { + uint8_t lctrl : 1; /**< Left Ctrl */ + uint8_t lshift : 1; /**< Left Shift */ + uint8_t lalt : 1; /**< Left Alt */ + uint8_t lgui : 1; /**< Left Gui */ + uint8_t rctrl : 1; /**< Right Ctrl */ + uint8_t rshift : 1; /**< Right Shift */ + uint8_t ralt : 1; /**< Right Alt */ + uint8_t rgui : 1; /**< Right Gui */ + } bm; +} hid_kbd_modifier_t; +#define HID_KBD_L_CTRL (1 << 0) /**< Left Ctrl */ +#define HID_KBD_L_SHIFT (1 << 1) /**< Left Shift */ +#define HID_KBD_L_ALT (1 << 2) /**< Left Alt */ +#define HID_KBD_L_GUI (1 << 3) /**< Left Gui */ +#define HID_KBD_R_CTRL (1 << 4) /**< Right Ctrl */ +#define HID_KBD_R_SHIFT (1 << 5) /**< Right Shift */ +#define HID_KBD_R_ALT (1 << 6) /**< Right Alt */ +#define HID_KBD_R_GUI (1 << 7) /**< Right Gui */ + +/** \brief Structure for standard HID keyboard input report */ +typedef union hid_kbd_input_report { + uint8_t byte[8]; + struct { + union hid_kbd_modifier modifier; + uint8_t reserved_oem; + uint8_t key[6]; /** < Key array */ + } field; +} hid_kbd_input_report_t; +/** Access to the modifier keys in HID keyboard report + * \param rpt Pointer to report data of bytes + */ +#define hid_kbd_modifier_keys(rpt) (rpt[0]) +/** Access to the OEM reserved in HID keyboard report + * \param rpt Pointer to report data of bytes + */ +#define hid_kbd_oem(rpt) (rpt[1]) +/** Access to the Key code in HID keyboard report + * \param rpt Pointer to report data of bytes + * \param i Index in the report key array (0~n) + */ +#define hid_kbd_keycode(rpt, i) (rpt[2 + i]) + +/** \brief Structure for standard HID keyboard output report */ +typedef union hid_kbd_output_report { + uint8_t byte; + struct { + uint8_t num_lock : 1; /**< LED of Num Lock */ + uint8_t caps_lock : 1; /**< LED of Caps Lock */ + uint8_t scroll_lock : 1; /**< LED of Scroll Lock */ + uint8_t compose : 1; /**< LED of COMPOSE LOCK */ + uint8_t kana : 1; /**< LED of KANA */ + uint8_t constant : 3; + } field; +} hid_kbd_output_report_t; +#define HID_KBD_NUM_LOCK (1 << 0) /**< LED of Num Lock */ +#define HID_KBD_CAPS_LOCK (1 << 1) /**< LED of Caps Lock */ +#define HID_KBD_SCROLL_LOCK (1 << 2) /**< LED of Scroll Lock */ +#define HID_KBD_COMPOSE (1 << 3) /**< LED of COMPOSE LOCK */ +#define HID_KBD_KANA (1 << 4) /**< LED of KANA */ + +/*@}*/ + +/** \name Standard HID mouse definitions from HID spec. example */ +/*@{*/ +/** \brief Structure for standard HID mouse report */ +typedef union hid_mouse_report { + uint8_t byte[3]; + struct { + uint8_t btn1 : 1; /**< Button 1 */ + uint8_t btn2 : 2; /**< Button 2 */ + uint8_t btn3 : 3; /**< Button 3 */ + uint8_t device_spec : 5; + int8_t x; /**< X displacement */ + int8_t y; /**< Y displacement */ + } field; + /* More bytes are optional */ +} hid_mouse_report_t; +#define HID_MOUSE_BTN1 (1 << 0) /**< Button 1 */ +#define HID_MOUSE_BTN2 (1 << 1) /**< Button 2 */ +#define HID_MOUSE_BTN3 (1 << 2) /**< Button 3 */ + +/** Access to the button state in HID mouse report + * \param rpt Pointer to report data of bytes + */ +#define hid_mouse_btn_state(rpt) (rpt[0]) +/** Check if the button is done in HID mouse report + * \param rpt Pointer to report data of bytes + * \param btn Button bitmap to check + */ +#define hid_mouse_is_btn_down(rpt, btn) (rpt[0] & (btn)) +/** Access to the relative X displacement in HID mouse report + * \param rpt Pointer to report data of bytes + */ +#define hid_mouse_x(rpt) ((int8_t)rpt[1]) +/** Access to the relative Y displacement in HID mouse report + * \param rpt Pointer to report data of bytes + */ +#define hid_mouse_y(rpt) ((int8_t)rpt[2]) + +/*@}*/ + +/** \name Standard HID joystick definitions from HID spec. example */ +/*@{*/ + +/** \brief Structure for standard HID joystick report */ +typedef union hid_joystick_report { + uint8_t byte[4]; + struct { + int8_t x; + int8_t y; + uint8_t hat_sw : 4; /**< Hat switch */ + uint8_t btn1 : 1; /**< Button 1 */ + uint8_t btn2 : 1; /**< Button 2 */ + uint8_t btn3 : 1; /**< Button 3 */ + uint8_t btn4 : 1; /**< Button 4 */ + uint8_t throttle; + } field; +} hid_joystick_report_t; +#define HID_JOYSTICK_BTN1 (1 << 4) /**< Button 1 */ +#define HID_JOYSTICK_BTN2 (1 << 5) /**< Button 2 */ +#define HID_JOYSTICK_BTN3 (1 << 6) /**< Button 3 */ +#define HID_JOYSTICK_BTN4 (1 << 7) /**< Button 4 */ + +/** Access to the absolute X position in HID joystick report + * \param rpt Pointer to report data of bytes + */ +#define hid_joystick_x(rpt) ((int8_t)rpt[0]) +/** Access to the absolute Y position in HID joystick report + * \param rpt Pointer to report data of bytes + */ +#define hid_joystick_y(rpt) ((int8_t)rpt[1]) +/** Access to the button state in HID joystick report + * \param rpt Pointer to report data of bytes + */ +#define hid_joystick_btn_state(rpt) (rpt[2]) +/** Check if the button is done in HID joystick report + * \param rpt Pointer to report data of bytes + * \param btn Button bitmap to check + */ +#define hid_joystick_is_btn_down(rpt, btn) (rpt[2] & (btn)) +/** Get the Hat switch in HID joystick report + * \param rpt Pointer to report data of bytes + */ +#define hid_joystick_hat_sw(rpt) (rpt[2] & 0xF) +/** Access to the throttle in HID joystick report + * \param rpt Pointer to report data of bytes + */ +#define hid_joystick_throttle(rpt) (rpt[3]) + +/*@}*/ + +/** + * \brief Fill a GetHIDDescriptor request + * \param[out] req Pointer to the request to fill + * \param[in] type Descriptor type + * \param[in] index Descriptor index + * \param[in] iface Interface Number + * \param[in] len Descriptor Length + */ +static inline void usb_fill_GetHIDDesc_req(struct usb_req *req, uint8_t type, uint8_t index, uint8_t iface, + uint16_t len) +{ + req->bmRequestType = 0x81; + req->bRequest = USB_REQ_GET_DESC; + req->wValue = (type << 8) | index; + req->wIndex = iface; + req->wLength = len; +} + +/** + * \brief Fill a SetHIDDescriptor request + * \param[out] req Pointer to the request to fill + * \param[in] type Descriptor type + * \param[in] index Descriptor index + * \param[in] iface Interface Number + * \param[in] len Descriptor Length + */ +static inline void usb_fill_SetHIDDesc_req(struct usb_req *req, uint8_t type, uint8_t index, uint8_t iface, + uint16_t len) +{ + req->bmRequestType = 0x01; + req->bRequest = USB_REQ_SET_DESC; + req->wValue = (type << 8) | index; + req->wIndex = iface; + req->wLength = len; +} + +/** + * \brief Fill a GetReport request + * \param[out] req Pointer to the request to fill + * \param[in] type Report type + * \param[in] id Report ID + * \param[in] iface Interface Number + * \param[in] len Report Length + */ +static inline void usb_fill_GetReport_req(struct usb_req *req, uint8_t type, uint8_t id, uint8_t iface, uint16_t len) +{ + req->bmRequestType = 0xA1; + req->bRequest = USB_REQ_HID_GET_REPORT; + req->wValue = (type << 8) | id; + req->wIndex = iface; + req->wLength = len; +} + +/** + * \brief Fill a SetReport request + * \param[out] req Pointer to the request to fill + * \param[in] type Report type + * \param[in] id Report ID + * \param[in] iface Interface Number + * \param[in] len Report Length + */ +static inline void usb_fill_SetReport_req(struct usb_req *req, uint8_t type, uint8_t id, uint8_t iface, uint16_t len) +{ + req->bmRequestType = 0x21; + req->bRequest = USB_REQ_HID_GET_REPORT; + req->wValue = (type << 8) | id; + req->wIndex = iface; + req->wLength = len; +} + +/** + * \brief Fill a GetIdle request + * \param[out] req Pointer to the request to fill + * \param[in] id Report ID + * \param[in] iface Interface Number + */ +static inline void usb_fill_GetIdle_req(struct usb_req *req, uint8_t id, uint8_t iface) +{ + req->bmRequestType = 0xA1; + req->bRequest = USB_REQ_HID_GET_IDLE; + req->wValue = id; + req->wIndex = iface; + req->wLength = 1; +} + +/** + * \brief Fill a SetIdle request + * \param[out] req Pointer to the request to fill + * \param[in] duration Duration value + * \param[in] id Report ID + * \param[in] iface Interface Number + */ +static inline void usb_fill_SetIdle_req(struct usb_req *req, uint8_t duration, uint8_t id, uint8_t iface) +{ + req->bmRequestType = 0x21; + req->bRequest = USB_REQ_HID_SET_IDLE; + req->wValue = (duration << 8) | id; + req->wIndex = iface; + req->wLength = 0; +} + +/** + * \brief Fill a GetProtocol request + * \param[out] req Pointer to the request to fill + * \param[in] iface Interface Number + */ +static inline void usb_fill_GetProtocol_req(struct usb_req *req, uint8_t iface) +{ + req->bmRequestType = 0xA1; + req->bRequest = USB_REQ_HID_GET_PROTOCOL; + req->wValue = 0; + req->wIndex = iface; + req->wLength = 1; +} + +/** + * \brief Fill a SetProtocol request + * \param[out] req Pointer to the request to fill + * \param[in] iface Interface Number + */ +static inline void usb_fill_SetProtocol_req(struct usb_req *req, uint8_t protocol, uint8_t iface) +{ + req->bmRequestType = 0x21; + req->bRequest = USB_REQ_HID_SET_PROTOCOL; + req->wValue = protocol; + req->wIndex = iface; + req->wLength = 0; +} + +#endif // _USB_PROTOCOL_HID_H_ diff --git a/atmel-samd/asf4/samd21/usb/class/hub/usb_protocol_hub.h b/atmel-samd/asf4/samd21/usb/class/hub/usb_protocol_hub.h new file mode 100644 index 000000000..dbfc04a2c --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/hub/usb_protocol_hub.h @@ -0,0 +1,364 @@ +/** + * \file + * + * \brief USB hub protocol definitions. + * + * Copyright (c) 2016 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#ifndef _USB_PROTOCOL_HUB_H_ +#define _USB_PROTOCOL_HUB_H_ + +#include <usb_protocol.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** \name Possible class value */ +/*@{*/ +#define HUB_CLASS 0x09 +/*@}*/ + +/** \brief Hub USB requests (bRequest) */ +enum usb_reqid_hub { + USB_REQ_HUB_GET_STATUS = 0, + /** CLEAR_FEATURE */ + USB_REQ_HUB_CLR_FTR = 1, + /** SET_FEATURE */ + USB_REQ_HUB_SET_FTR = 3, + /** GET_DESCRIPTOR */ + USB_REQ_HUB_GET_DESC = 6, + /** SET_DESCRIPTOR */ + USB_REQ_HUB_SET_DESC = 7, + /** CLEAR_TT_BUFFER */ + USB_REQ_HUB_CLR_TT_BUF = 8, + /** RESET_TT */ + USB_REQ_HUB_RESET_TT = 9, + /** GET_TT_STATE */ + USB_REQ_HUB_GET_TT_STATE = 10, + /** STOP_TT */ + USB_REQ_HUB_STOP_TT +}; + +/** \brief Hub USB descriptor type */ +enum usb_descriptor_type_hub { USB_DT_HUB = 0x29 }; + +/** \brief Hub feature selector */ +enum usb_hub_ftr_sel { + USB_HUB_FTR_C_HUB_LOCAL_POWER = 0, + USB_HUB_FTR_C_HUB_OVER_CURRENT = 1, + USB_HUB_FTR_PORT_CONNECTION = 0, + USB_HUB_FTR_PORT_ENABLE = 1, + USB_HUB_FTR_PORT_SUSPEND = 2, + USB_HUB_FTR_PORT_OVER_CURRENT = 3, + USB_HUB_FTR_PORT_RESET = 4, + USB_HUB_FTR_PORT_POWER = 8, + USB_HUB_FTR_PORT_LOW_SPEED = 9, + USB_HUB_FTR_PORT_LS = 9, + USB_HUB_FTR_PORT_HIGH_SPEED = 10, + USB_HUB_FTR_PORT_HS = 10, + USB_HUB_FTR_C_PORT_CONNECTION = 16, + USB_HUB_FTR_C_PORT_ENABLE = 17, + USB_HUB_FTR_C_PORT_SUSPEND = 18, + USB_HUB_FTR_C_PORT_OVER_CURRENT = 19, + USB_HUB_FTR_C_PORT_RESET = 20, + USB_HUB_FTR_PORT_TEST = 21, + USB_HUB_FTR_PORT_INDICATOR +}; + +COMPILER_PACK_SET(1) + +/** + * \brief General Hub Descriptor + */ +typedef struct usb_hub_descriptor { + uint8_t bDescLength; + uint8_t bDescriptorType; + uint8_t bNbrPorts; + uint16_t wHubCharacteristics; + uint8_t bPwrOn2PwrGood; + uint8_t bHubContrCurrent; + uint32_t variables[1]; +} usb_hub_descriptor_t; + +/** + * \brief Hub Descriptor with no more than 7 ports + */ +typedef struct usb_hub_descriptor_7p { + uint8_t bDescLength; + uint8_t bDescriptorType; + uint8_t bNbrPorts; + uint16_t wHubCharacteristics; + uint8_t bPwrOn2PwrGood; + uint8_t bHubContrCurrent; + uint8_t DeviceRemovable[1]; + uint8_t PortPwrCtrlMask[1]; +} usb_hub_descriptor_7p_t; + +/** + * \brief Hub Descriptor with no more than 15 ports + */ +typedef struct usb_hub_descriptor_15p { + uint8_t bDescLength; + uint8_t bDescriptorType; + uint8_t bNbrPorts; + uint16_t wHubCharacteristics; + uint8_t bPwrOn2PwrGood; + uint8_t bHubContrCurrent; + uint8_t DeviceRemovable[2]; + uint8_t PortPwrCtrlMask[2]; +} usb_hub_descriptor_15p_t; + +/** + * \brief Hub Descriptor with no more than 23 ports + */ +typedef struct usb_hub_descriptor_23p { + uint8_t bDescLength; + uint8_t bDescriptorType; + uint8_t bNbrPorts; + uint16_t wHubCharacteristics; + uint8_t bPwrOn2PwrGood; + uint8_t bHubContrCurrent; + uint8_t DeviceRemovable[3]; + uint8_t PortPwrCtrlMask[3]; +} usb_hub_descriptor_23p_t; + +/** + * \brief Hub Descriptor with no more than 31 ports + */ +typedef struct usb_hub_descriptor_31p { + uint8_t bDescLength; + uint8_t bDescriptorType; + uint8_t bNbrPorts; + uint16_t wHubCharacteristics; + uint8_t bPwrOn2PwrGood; + uint8_t bHubContrCurrent; + uint8_t DeviceRemovable[4]; + uint8_t PortPwrCtrlMask[4]; +} usb_hub_descriptor_31p_t; + +COMPILER_PACK_RESET() + +/** + * \brief Check if hub change is detected + * \param[in] bitmap Pointer to the bitmap location + * \return \c true if hub change is detected + */ +static inline bool usb_is_hub_change_detected(const uint8_t *bitmap) +{ + return (*bitmap & 0x1); +} + +/** + * \brief Check if port change is detected + * \param[in] bitmap Pointer to the bitmap location + * \param[in] port Port number ( 1 ~ n ) + * \return \c true if port change is detected + */ +static inline bool usb_is_port_change_detected(const uint8_t *bitmap, const uint8_t port) +{ + uint8_t idx = port >> 3; + uint8_t pos = port & 0x7; + return (bitmap[idx] & (1u << pos)); +} + +/** + * \brief Fill a ClearHubFeature request + * \param[out] req Pointer to the request to fill + * \param[in] ftr Feature selector + */ +static inline void usb_fill_ClrHubFtr_req(struct usb_req *req, uint8_t ftr) +{ + req->bmRequestType = 0x20; + req->bRequest = USB_REQ_CLEAR_FTR; + req->wValue = ftr; + req->wIndex = 0; + req->wLength = 0; +} + +/** + * \brief Fill a ClearPortFeature request + * \param[out] req Pointer to the request to fill + * \param[in] ftr Feature selector + * \param[in] port Port number ( 1 ~ n ) + */ +static inline void usb_fill_ClrPortFtr_req(struct usb_req *req, uint8_t ftr, uint8_t port) +{ + req->bmRequestType = 0x23; + req->bRequest = USB_REQ_CLEAR_FTR; + req->wValue = ftr; + req->wIndex = port; + req->wLength = 0; +} + +/** + * \brief Fill a ClearTTBuffer request + * \param[out] req Pointer to the request to fill + * \param[in] dev Dev_Addr + * \param[in] ep EP_Num + * \param[in] tt_port TT_port + */ +static inline void usb_fill_ClrTTBuf_req(struct usb_req *req, uint8_t dev, uint8_t ep, uint8_t tt_port) +{ + req->bmRequestType = 0x23; + req->bRequest = USB_REQ_HUB_CLR_TT_BUF; + req->wValue = (dev << 8) | ep; + req->wIndex = tt_port; + req->wLength = 0; +} + +/** + * \brief Fill a GetHubDescriptor request + * \param[out] req Pointer to the request to fill + * \param[in] len Length of available buffer for request data + */ +static inline void usb_fill_GetHubDesc_req(struct usb_req *req, uint16_t len) +{ + req->bmRequestType = 0xA0; + req->bRequest = USB_REQ_GET_DESC; + req->wValue = (USB_DT_HUB << 8) | 0; + req->wIndex = 0; + req->wLength = len; +} + +/** + * \brief Fill a GetHubStatus request + * \param[out] req Pointer to the request to fill + */ +static inline void usb_fill_GetHubStatus_req(struct usb_req *req) +{ + req->bmRequestType = 0xA0; + req->bRequest = USB_REQ_GET_STATUS; + req->wValue = 0; + req->wIndex = 0; + req->wLength = 4; +} + +/** + * \brief Fill a GetPortStatus request + * \param[out] req Pointer to the request to fill + * \param[in] port Port number ( 1 ~ n ) + */ +static inline void usb_fill_GetPortStatus_req(struct usb_req *req, uint8_t port) +{ + req->bmRequestType = 0xA3; + req->bRequest = USB_REQ_GET_STATUS; + req->wValue = 0; + req->wIndex = port; + req->wLength = 4; +} + +/** + * \brief Fill a ResetTT request + * \param[out] req Pointer to the request to fill + * \param[in] port Port number ( 1 ~ n ) + */ +static inline void usb_fill_ResetTT_req(struct usb_req *req, uint8_t port) +{ + req->bmRequestType = 0x23; + req->bRequest = USB_REQ_HUB_RESET_TT; + req->wValue = 0; + req->wIndex = port; + req->wLength = 0; +} + +/** + * \brief Fill a SetHubFeature request + * \param[out] req Pointer to the request to fill + * \param[in] ftr Feature selector + */ +static inline void usb_fill_SetHubFtr_req(struct usb_req *req, uint8_t ftr) +{ + req->bmRequestType = 0x20; + req->bRequest = USB_REQ_SET_FTR; + req->wValue = ftr; + req->wIndex = 0; + req->wLength = 0; +} + +/** + * \brief Fill a SetPortFeature request + * \param[out] req Pointer to the request to fill + * \param[in] ftr Feature selector + * \param[in] port Port number ( 1 ~ n ) + */ +static inline void usb_fill_SetPortFtr_req(struct usb_req *req, uint8_t ftr, uint8_t port) +{ + req->bmRequestType = 0x23; + req->bRequest = USB_REQ_SET_FTR; + req->wValue = ftr; + req->wIndex = port; + req->wLength = 0; +} + +/** + * \brief Fill a GetTTState request + * \param[out] req Pointer to the request to fill + * \param[in] tt_flags TT_Flags + * \param[in] port Port number ( 1 ~ n ) + * \param[in] len TT State Length + */ +static inline void usb_fill_GetTTState_req(struct usb_req *req, uint16_t tt_flags, uint8_t port, uint16_t len) +{ + req->bmRequestType = 0xA3; + req->bRequest = USB_REQ_HUB_GET_TT_STATE; + req->wValue = tt_flags; + req->wIndex = port; + req->wLength = len; +} + +/** + * \brief Fill a StopTT request + * \param[out] req Pointer to the request to fill + * \param[in] port Port number ( 1 ~ n ) + */ +static inline void usb_fill_StopTT_req(struct usb_req *req, uint8_t port) +{ + req->bmRequestType = 0x23; + req->bRequest = USB_REQ_HUB_STOP_TT; + req->wValue = 0; + req->wIndex = port; + req->wLength = 0; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _USB_PROTOCOL_HUB_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/msc/sbc_protocol.h b/atmel-samd/asf4/samd21/usb/class/msc/sbc_protocol.h new file mode 100644 index 000000000..925933522 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/msc/sbc_protocol.h @@ -0,0 +1,163 @@ +/** + * \file + * + * \brief SCSI Block Commands + * + * This file contains definitions of some of the commands found in the + * SCSI SBC-2 standard. + * + * Note that the SBC specification depends on several commands defined + * by the SCSI Primary Commands (SPC) standard. Each version of the SBC + * standard is meant to be used in conjunction with a specific version + * of the SPC standard, as follows: + * - SBC depends on SPC + * - SBC-2 depends on SPC-3 + * - SBC-3 depends on SPC-4 + * + * Copyright (c) 2016 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ +#ifndef _SBC_PROTOCOL_H_ +#define _SBC_PROTOCOL_H_ + +/** + * \ingroup usb_msc_protocol + * \defgroup usb_sbc_protocol SCSI Block Commands protocol definitions + * + * @{ + */ + +/** \name SCSI commands defined by SBC-2 */ +#define SBC_FORMAT_UNIT 0x04 +#define SBC_READ6 0x08 +#define SBC_WRITE6 0x0A +#define SBC_START_STOP_UNIT 0x1B +#define SBC_READ_CAPACITY10 0x25 +#define SBC_READ10 0x28 +#define SBC_WRITE10 0x2A +#define SBC_VERIFY10 0x2F + +/** \name SBC-2 Mode page definitions */ +enum scsi_sbc_mode { + SCSI_MS_MODE_RW_ERR_RECOV = 0x01, /**< Read-Write Error Recovery mode page */ + SCSI_MS_MODE_FORMAT_DEVICE = 0x03, /**< Format Device mode page */ + SCSI_MS_MODE_FLEXIBLE_DISK = 0x05, /**< Flexible Disk mode page */ + SCSI_MS_MODE_CACHING = 0x08 +}; + +/** \name SBC-2 Device-Specific Parameter */ +#define SCSI_MS_SBC_WP 0x80 /**< Write Protected */ +#define SCSI_MS_SBC_DPOFUA 0x10 /**< DPO and FUA supported */ + +/** + * \brief SBC-2 Short LBA mode parameter block descriptor + * \note Fields are MSB first (BE) + */ +struct sbc_slba_block_desc { + be32_t nr_blocks; /**< Number of Blocks (BE32) */ + be32_t block_len; /**< Block Length (BE32) */ +#define SBC_SLBA_BLOCK_LEN_MASK 0x00FFFFFFU /**< Mask reserved bits */ +}; + +/** + * \brief SBC-2 Caching mode page + * \note Fields are MSB first (BE) + */ +struct sbc_caching_mode_page { + uint8_t page_code; + uint8_t page_length; + uint8_t flags2; +#define SBC_MP_CACHE_IC (1 << 7) /**< Initiator Control */ +#define SBC_MP_CACHE_ABPF (1 << 6) /**< Abort Pre-Fetch */ +#define SBC_MP_CACHE_CAP (1 << 5) /**< Catching Analysis Permitted */ +#define SBC_MP_CACHE_DISC (1 << 4) /**< Discontinuity */ +#define SBC_MP_CACHE_SIZE (1 << 3) /**< Size enable */ +#define SBC_MP_CACHE_WCE (1 << 2) /**< Write back Cache Enable */ +#define SBC_MP_CACHE_MF (1 << 1) /**< Multiplication Factor */ +#define SBC_MP_CACHE_RCD (1 << 0) /**< Read Cache Disable */ + uint8_t retention; + be16_t dis_pf_transfer_len; + be16_t min_prefetch; + be16_t max_prefetch; + be16_t max_prefetch_ceil; + uint8_t flags12; +#define SBC_MP_CACHE_FSW (1 << 7) /**< Force Sequential Write */ +#define SBC_MP_CACHE_LBCSS (1 << 6) /**< Logical Blk Cache Seg Sz */ +#define SBC_MP_CACHE_DRA (1 << 5) /**< Disable Read-Ahead */ +#define SBC_MP_CACHE_NV_DIS (1 << 0) /**< Non-Volatile Cache Disable */ + uint8_t nr_cache_segments; + be16_t cache_segment_size; + uint8_t reserved[4]; +}; + +/** + * \brief SBC-2 Read-Write Error Recovery mode page + * \note Fields are MSB first (BE) + */ +struct sbc_rdwr_error_recovery_mode_page { + uint8_t page_code; + uint8_t page_length; +#define SPC_MP_RW_ERR_RECOV_PAGE_LENGTH 0x0A + uint8_t flags1; +#define SBC_MP_RW_ERR_RECOV_AWRE (1 << 7) +#define SBC_MP_RW_ERR_RECOV_ARRE (1 << 6) +#define SBC_MP_RW_ERR_RECOV_TB (1 << 5) +#define SBC_MP_RW_ERR_RECOV_RC (1 << 4) +#define SBC_MP_RW_ERR_RECOV_ERR (1 << 3) +#define SBC_MP_RW_ERR_RECOV_PER (1 << 2) +#define SBC_MP_RW_ERR_RECOV_DTE (1 << 1) +#define SBC_MP_RW_ERR_RECOV_DCR (1 << 0) + uint8_t read_retry_count; + uint8_t correction_span; + uint8_t head_offset_count; + uint8_t data_strobe_offset_count; + uint8_t flags2; + uint8_t write_retry_count; + uint8_t flags3; + be16_t recovery_time_limit; +}; + +/** + * \brief SBC-2 READ CAPACITY (10) parameter data (8 bytes) + * \note Fields are MSB first (BE) + */ +struct sbc_read_capacity10_data { + be32_t max_lba; /**< LBA of last logical block (BE32) */ + be32_t block_len; /**< Number of bytes in the last logical block (BE32) */ +}; + +#endif /*_SBC_PROTOCOL_H_*/ diff --git a/atmel-samd/asf4/samd21/usb/class/msc/spc_protocol.h b/atmel-samd/asf4/samd21/usb/class/msc/spc_protocol.h new file mode 100644 index 000000000..c44cbef32 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/msc/spc_protocol.h @@ -0,0 +1,340 @@ +/** + * \file + * + * \brief SCSI Primary Commands + * + * This file contains definitions of some of the commands found in the + * SPC-2 standard. + * + * Copyright (c) 2009-2012 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ +#ifndef _SPC_PROTOCOL_H_ +#define _SPC_PROTOCOL_H_ + +/** + * \ingroup usb_msc_protocol + * \defgroup usb_spc_protocol SCSI Primary Commands protocol definitions + * + * + */ + +/**< \name SCSI commands defined by SPC-2 */ +#define SPC_TEST_UNIT_READY 0x00 +#define SPC_REQUEST_SENSE 0x03 +#define SPC_INQUIRY 0x12 +#define SPC_MODE_SELECT6 0x15 +#define SPC_MODE_SENSE6 0x1A +#define SPC_SEND_DIAGNOSTIC 0x1D +#define SPC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1E +#define SPC_MODE_SENSE10 0x5A +#define SPC_REPORT_LUNS 0xA0 + +/**< \brief May be set in byte 0 of the INQUIRY CDB */ +/**< Enable Vital Product Data */ +#define SCSI_INQ_REQ_EVPD 0x01 +/**< Command Support Data specified by the PAGE OR OPERATION CODE field */ +#define SCSI_INQ_REQ_CMDT 0x02 + +COMPILER_PACK_SET(1) + +/** + * \brief SCSI Standard Inquiry data structure + */ +struct scsi_inquiry_data { + uint8_t pq_pdt; /**< Peripheral Qual / Peripheral Dev Type */ +#define SCSI_INQ_PQ_CONNECTED 0x00 /**< Peripheral connected */ +#define SCSI_INQ_PQ_NOT_CONN 0x20 /**< Peripheral not connected */ +#define SCSI_INQ_PQ_NOT_SUPP 0x60 /**< Peripheral not supported */ +#define SCSI_INQ_DT_DIR_ACCESS 0x00 /**< Direct Access (SBC) */ +#define SCSI_INQ_DT_SEQ_ACCESS 0x01 /**< Sequential Access */ +#define SCSI_INQ_DT_PRINTER 0x02 /**< Printer */ +#define SCSI_INQ_DT_PROCESSOR 0x03 /**< Processor device */ +#define SCSI_INQ_DT_WRITE_ONCE 0x04 /**< Write-once device */ +#define SCSI_INQ_DT_CD_DVD 0x05 /**< CD/DVD device */ +#define SCSI_INQ_DT_OPTICAL 0x07 /**< Optical Memory */ +#define SCSI_INQ_DT_MC 0x08 /**< Medium Changer */ +#define SCSI_INQ_DT_ARRAY 0x0c /**< Storage Array Controller */ +#define SCSI_INQ_DT_ENCLOSURE 0x0d /**< Enclosure Services */ +#define SCSI_INQ_DT_RBC 0x0e /**< Simplified Direct Access */ +#define SCSI_INQ_DT_OCRW 0x0f /**< Optical card reader/writer */ +#define SCSI_INQ_DT_BCC 0x10 /**< Bridge Controller Commands */ +#define SCSI_INQ_DT_OSD 0x11 /**< Object-based Storage */ +#define SCSI_INQ_DT_NONE 0x1f /**< No Peripheral */ + uint8_t flags1; /**< Flags (byte 1) */ +#define SCSI_INQ_RMB 0x80 /**< Removable Medium */ + uint8_t version; /**< Version */ +#define SCSI_INQ_VER_NONE 0x00 /**< No standards conformance */ +#define SCSI_INQ_VER_SPC 0x03 /**< SCSI Primary Commands (link to SBC) */ +#define SCSI_INQ_VER_SPC2 0x04 /**< SCSI Primary Commands - 2 (link to SBC-2) */ +#define SCSI_INQ_VER_SPC3 0x05 /**< SCSI Primary Commands - 3 (link to SBC-2) */ +#define SCSI_INQ_VER_SPC4 0x06 /**< SCSI Primary Commands - 4 (link to SBC-3) */ + uint8_t flags3; /**< Flags (byte 3) */ +#define SCSI_INQ_NORMACA 0x20 /**< Normal ACA Supported */ +#define SCSI_INQ_HISUP 0x10 /**< Hierarchal LUN addressing */ +#define SCSI_INQ_RSP_SPC2 0x02 /**< SPC-2 / SPC-3 response format */ + uint8_t addl_len; /**< Additional Length (n-4) */ +#define SCSI_INQ_ADDL_LEN(tot) ((tot)-5) /**< Total length is \a tot */ + uint8_t flags5; /**< Flags (byte 5) */ +#define SCSI_INQ_SCCS 0x80 + uint8_t flags6; /**< Flags (byte 6) */ +#define SCSI_INQ_BQUE 0x80 +#define SCSI_INQ_ENCSERV 0x40 +#define SCSI_INQ_MULTIP 0x10 +#define SCSI_INQ_MCHGR 0x08 +#define SCSI_INQ_ADDR16 0x01 + uint8_t flags7; /**< Flags (byte 7) */ +#define SCSI_INQ_WBUS16 0x20 +#define SCSI_INQ_SYNC 0x10 +#define SCSI_INQ_LINKED 0x08 +#define SCSI_INQ_CMDQUE 0x02 + uint8_t vendor_id[8]; /**< T10 Vendor Identification */ + uint8_t product_id[16]; /**< Product Identification */ + uint8_t product_rev[4]; /**< Product Revision Level */ +}; + +/** + * \brief SCSI Standard Request sense data structure + */ +#define SCSI_SENSE_VALID 0x80 /**< Indicates the INFORMATION field contains valid information */ +#define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F +#define SCSI_SENSE_CURRENT 0x70 /**< Response code 70h (current errors) */ +#define SCSI_SENSE_DEFERRED 0x71 + +#define SCSI_SENSE_FILEMARK 0x80 /**< Indicates that the current command has read a filemark or setmark. */ +#define SCSI_SENSE_EOM 0x40 /**< Indicates that an end-of-medium condition exists. */ +#define SCSI_SENSE_ILI \ + 0x20 /**< Indicates that the requested logical block length did not match the logical block length of the data on \ + the medium. */ +#define SCSI_SENSE_RESERVED 0x10 /**< Reserved */ +#define SCSI_SENSE_KEY(x) (x & 0x0F) /**< Sense Key */ + +#define SCSI_SENSE_ADDL_LEN(total_len) ((total_len)-8) + +#define SCSI_SENSE_SKSV 0x80 /**< Indicates the SENSE-KEY SPECIFIC field contains valid information */ + +struct scsi_request_sense_data { + /** 1st byte: REQUEST SENSE response flags*/ + uint8_t valid_reponse_code; + /** 2nd byte */ + uint8_t obsolete; + /** 3rd byte */ + uint8_t sense_flag_key; + /** 4th to 7th bytes - INFORMATION field */ + uint8_t information[4]; + /** 8th byte - ADDITIONAL SENSE LENGTH field */ + uint8_t AddSenseLen; + /** 9th to 12th byte - COMMAND-SPECIFIC INFORMATION field */ + uint8_t CmdSpecINFO[4]; + /** 13th to 14th byte - ADDITIONAL SENSE CODE and QUALIFIER field */ + union { + struct { + uint8_t code; /**< ADDITIONAL SENSE CODE (ASC) */ + uint8_t qualifier; /**< ADDITIONAL SENSE CODE QUALIFIER (ASCQ) */ + } add_sense; + be16_t AddSense; /**< ASC | ASCQ */ + }; + /** 15th byte - FIELD REPLACEABLE UNIT CODE field */ + uint8_t FldReplUnitCode; + /** 16th byte */ + uint8_t SenseKeySpec[3]; +}; + +COMPILER_PACK_RESET() + +/**< Vital Product Data page codes */ +enum scsi_vpd_page_code { + SCSI_VPD_SUPPORTED_PAGES = 0x00, + SCSI_VPD_UNIT_SERIAL_NUMBER = 0x80, + SCSI_VPD_DEVICE_IDENTIFICATION = 0x83 +}; +#define SCSI_VPD_HEADER_SIZE 4 + +/**< Constants associated with the Device Identification VPD page */ +#define SCSI_VPD_ID_HEADER_SIZE 4 + +#define SCSI_VPD_CODE_SET_BINARY 1 +#define SCSI_VPD_CODE_SET_ASCII 2 +#define SCSI_VPD_CODE_SET_UTF8 3 + +#define SCSI_VPD_ID_TYPE_T10 1 + +/**< Sense keys */ +enum scsi_sense_key { + SCSI_SK_NO_SENSE = 0x0, + SCSI_SK_RECOVERED_ERROR = 0x1, + SCSI_SK_NOT_READY = 0x2, + SCSI_SK_MEDIUM_ERROR = 0x3, + SCSI_SK_HARDWARE_ERROR = 0x4, + SCSI_SK_ILLEGAL_REQUEST = 0x5, + SCSI_SK_UNIT_ATTENTION = 0x6, + SCSI_SK_DATA_PROTECT = 0x7, + SCSI_SK_BLANK_CHECK = 0x8, + SCSI_SK_VENDOR_SPECIFIC = 0x9, + SCSI_SK_COPY_ABORTED = 0xa, + SCSI_SK_ABORTED_COMMAND = 0xb, + SCSI_SK_VOLUME_OVERFLOW = 0xd, + SCSI_SK_MISCOMPARE = 0xe +}; + +/**< Additional Sense Code | Additional Sense Code Qualifier pairs (BE16) */ +enum scsi_asc_ascq { + SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000, + SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405, + SCSI_ASC_WRITE_ERROR = 0x0c00, + SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100, + SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000, + SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400, + SCSI_ASC_WRITE_PROTECTED = 0x2700, + SCSI_ASC_NOT_READY_TO_READY_CHANGE = 0x2800, + SCSI_ASC_MEDIUM_NOT_PRESENT = 0x3A00, + SCSI_ASC_INTERNAL_TARGET_FAILURE = 0x4400 +}; + +/** + * \brief SPC-2 Mode parameter + * This subclauses describes the block descriptors and the pages + * used with MODE SELECT and MODE SENSE commands + * that are applicable to all SCSI devices. + */ +enum scsi_spc_mode { + SCSI_MS_MODE_VENDOR_SPEC = 0x00, + SCSI_MS_MODE_INFEXP = 0x1C, /**< Informational exceptions control page */ + SCSI_MS_MODE_ALL = 0x3f +}; + +/** + * \brief SPC-2 Informational exceptions control page + * See chapter 8.3.8 + * \note Fields are MSB first (BE) + */ +struct spc_control_page_info_execpt { + uint8_t page_code; + uint8_t page_length; +#define SPC_MP_INFEXP_PAGE_LENGTH 0x0A + uint8_t flags1; +#define SPC_MP_INFEXP_PERF (1 << 7) /**< Initiator Control */ +#define SPC_MP_INFEXP_EBF (1 << 5) /**< Caching Analysis Permitted */ +#define SPC_MP_INFEXP_EWASC (1 << 4) /**< Discontinuity */ +#define SPC_MP_INFEXP_DEXCPT (1 << 3) /**< Size enable */ +#define SPC_MP_INFEXP_TEST (1 << 2) /**< Write-back Cache Enable */ +#define SPC_MP_INFEXP_LOGERR (1 << 0) /**< Log errors bit */ + uint8_t mrie; +#define SPC_MP_INFEXP_MRIE_NO_REPORT 0x00 +#define SPC_MP_INFEXP_MRIE_ASYNC_EVENT 0x01 +#define SPC_MP_INFEXP_MRIE_GEN_UNIT 0x02 +#define SPC_MP_INFEXP_MRIE_COND_RECOV_ERROR 0x03 +#define SPC_MP_INFEXP_MRIE_UNCOND_RECOV_ERROR 0x04 +#define SPC_MP_INFEXP_MRIE_NO_SENSE 0x05 +#define SPC_MP_INFEXP_MRIE_ONLY_REPORT 0x06 + be32_t interval_timer; + be32_t report_count; +}; + +enum scsi_spc_mode_sense_pc { + SCSI_MS_SENSE_PC_CURRENT = 0, + SCSI_MS_SENSE_PC_CHANGEABLE = 1, + SCSI_MS_SENSE_PC_DEFAULT = 2, + SCSI_MS_SENSE_PC_SAVED = 3 +}; + +/** + * \brief Check whether dbd field is set in sense code + * \param[in] cdb pointer to the sense code block + * \return Operation status. + */ +static inline bool scsi_mode_sense_dbd_is_set(const uint8_t *cdb) +{ + return (cdb[1] >> 3) & 1; +} + +/** + * \brief Get page code from mode sense code + * \param[in] cdb pointer to the sense code block + * \return Operation status. + */ +static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t *cdb) +{ + return cdb[2] & 0x3f; +} + +/** + * \brief Get pc from mode sense code + * \param[in] cdb pointer to the sense code block + * \return Operation status. + */ +static inline uint8_t scsi_mode_sense_get_pc(const uint8_t *cdb) +{ + return cdb[2] >> 6; +} + +/** + * \brief SCSI Mode Parameter Header used by MODE SELECT(6) and MODE SENSE(6) + * \note Fields are MSB first (BE) + */ +struct scsi_mode_param_header6 { + uint8_t mode_data_length; /**< Number of bytes after this */ + uint8_t medium_type; /**< Medium Type */ + uint8_t device_specific_parameter; /**< Defined by command set */ + uint8_t block_descriptor_length; /**< Length of block descriptors */ +}; + +/** + * \brief SCSI Mode Parameter Header used by MODE SELECT(10) and MODE SENSE(10) + * \note Fields are MSB first (BE) + */ +struct scsi_mode_param_header10 { + le16_t mode_data_length; /**< Number of bytes after this */ + uint8_t medium_type; /**< Medium Type */ + uint8_t device_specific_parameter; /**< Defined by command set */ + uint8_t flags4; /**< LONGLBA in bit 0 */ + uint8_t reserved; + le16_t block_descriptor_length; /**< Length of block descriptors */ +}; + +/** + * \brief SCSI Page_0 Mode Page header (SPF not set) + */ +struct scsi_mode_page_0_header { + uint8_t page_code; +#define SCSI_PAGE_CODE_PS (1 << 7) /**< Parameters Savable */ +#define SCSI_PAGE_CODE_SPF (1 << 6) /**< SubPage Format */ + uint8_t page_length; /**< Number of bytes after this */ +#define SCSI_MS_PAGE_LEN(total) ((total)-2) +}; + +#endif /**< SPC_PROTOCOL_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/class/msc/usb_protocol_msc.h b/atmel-samd/asf4/samd21/usb/class/msc/usb_protocol_msc.h new file mode 100644 index 000000000..f69eae232 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/msc/usb_protocol_msc.h @@ -0,0 +1,177 @@ +/** + * \file + * + * \brief USB Mass Storage Class (MSC) protocol definitions. + * + * Copyright (c) 2016 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#ifndef _USB_PROTOCOL_MSC_H_ +#define _USB_PROTOCOL_MSC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \ingroup usb_protocol_group + * \defgroup usb_msc_protocol USB Mass Storage Class (MSC) protocol definitions + * + * @{ + */ + +/** + * \name Possible Class value + */ +//@{ +#define MSC_CLASS 0x08 +//@} + +/** + * \name Possible SubClass value + * \note In practice, most devices should use + * #MSC_SUBCLASS_TRANSPARENT and specify the actual command set in + * the standard INQUIRY data block, even if the MSC spec indicates + * otherwise. In particular, RBC is not supported by certain major + * operating systems like Windows XP. + */ +//@{ +#define MSC_SUBCLASS_RBC 0x01 /**< Reduced Block Commands */ +#define MSC_SUBCLASS_ATAPI 0x02 /**< CD/DVD devices */ +#define MSC_SUBCLASS_QIC_157 0x03 /**< Tape devices */ +#define MSC_SUBCLASS_UFI 0x04 /**< Floppy disk drives */ +#define MSC_SUBCLASS_SFF_8070I 0x05 /**< Floppy disk drives */ +#define MSC_SUBCLASS_TRANSPARENT 0x06 /**< Determined by INQUIRY */ + //@} + +/** + * \name Possible protocol value + * \note Only the BULK protocol should be used in new designs. + */ +//@{ +#define MSC_PROTOCOL_CBI 0x00 /**< Command/Bulk/Interrupt */ +#define MSC_PROTOCOL_CBI_ALT 0x01 /**< W/o command completion */ +#define MSC_PROTOCOL_BULK 0x50 /**< Bulk-only */ + //@} + +/** + * \brief MSC USB requests (bRequest) + */ + +#define USB_REQ_MSC_BULK_RESET 0xFF /**< Mass Storage Reset */ +#define USB_REQ_MSC_GET_MAX_LUN 0xFE /**< Get Max LUN */ + +COMPILER_PACK_SET(1) + +/** + * \name A Command Block Wrapper (CBW) + * \note Fields are LSB first (LE) + */ +//@{ +struct usb_msc_cbw { + le32_t dCBWSignature; /**< Must contain 'USBC' (0x43425355, LE32) */ + le32_t dCBWTag; /**< Unique command ID (LE32) */ + le32_t dCBWDataTransferLength; /**< Number of bytes to transfer (LE32) */ + uint8_t bmCBWFlags; /**< Direction in bit 7 */ + uint8_t bCBWLUN; /**< Logical Unit Number */ + uint8_t bCBWCBLength; /**< Number of valid CDB bytes */ + uint8_t CDB[16]; /**< SCSI Command Descriptor Block */ +}; + +#define USB_CBW_SIGNATURE 0x43425355 /**< dCBWSignature value */ +#define USB_CBW_DIRECTION_IN (1 << 7) /**< Data from device to host */ +#define USB_CBW_DIRECTION_OUT (0 << 7) /**< Data from host to device */ +#define USB_CBW_LUN_MASK 0x0F /**< Valid bits in bCBWLUN */ +#define USB_CBW_LEN_MASK 0x1F /**< Valid bits in bCBWCBLength */ + //@} + +/** + * \name A Command Status Wrapper (CSW) + * \note Fields are LSB first (LE) + */ +//@{ +struct usb_msc_csw { + le32_t dCSWSignature; /**< Must contain 'USBS' */ + le32_t dCSWTag; /**< Same as dCBWTag */ + le32_t dCSWDataResidue; /**< Number of bytes not transfered */ + uint8_t bCSWStatus; /**< Status code */ +}; + +#define USB_CSW_SIGNATURE 0x53425355 /**< dCSWSignature value */ +#define USB_CSW_STATUS_PASS 0x00 /**< Command Passed */ +#define USB_CSW_STATUS_FAIL 0x01 /**< Command Failed */ +#define USB_CSW_STATUS_PE 0x02 /**< Phase Error */ +//@} + +COMPILER_PACK_RESET() + +//@} + +/** + * \brief Fill a Bulk-Only Mass Storage Reset request + * \param[out] req Pointer to the request to fill + * \param[in] iface Interface Number + */ +static inline void usb_fill_BOMSReset_req(struct usb_req *req, uint8_t iface) +{ + req->bmRequestType = 0x21; + req->bRequest = USB_REQ_MSC_BULK_RESET; + req->wValue = 0; + req->wIndex = iface; + req->wLength = 0; +} + +/** + * \brief Fill a GetMaxLUN request + * \param[out] req Pointer to the request to fill + * \param[in] iface Interface Number + */ +static inline void usb_fill_GetMaxLUN_req(struct usb_req *req, uint8_t iface) +{ + req->bmRequestType = 0xA1; + req->bRequest = USB_REQ_MSC_GET_MAX_LUN; + req->wValue = 0; + req->wIndex = iface; + req->wLength = 1; +} + +#ifdef __cplusplus +} +#endif + +#endif // _USB_PROTOCOL_MSC_H_ diff --git a/atmel-samd/asf4/samd21/usb/class/vendor/usb_protocol_vendor.h b/atmel-samd/asf4/samd21/usb/class/vendor/usb_protocol_vendor.h new file mode 100644 index 000000000..e865fb808 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/class/vendor/usb_protocol_vendor.h @@ -0,0 +1,63 @@ +/** + * \file + * + * \brief USB Vendor class protocol definitions. + * + * Copyright (c) 2016 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ +/* + * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a> + */ + +#ifndef _USB_PROTOCOL_VENDOR_H_ +#define _USB_PROTOCOL_VENDOR_H_ + +/** + * \ingroup usb_protocol_group + * \defgroup usb_vendor_protocol USB Vendor Class definitions + * + */ + +/** + * \name Vendor class values + */ +#define VENDOR_CLASS 0xFF +#define VENDOR_SUBCLASS 0xFF +#define VENDOR_PROTOCOL 0xFF + +#endif /* _USB_PROTOCOL_VENDOR_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/device/usbdc.c b/atmel-samd/asf4/samd21/usb/device/usbdc.c new file mode 100644 index 000000000..f5243cad0 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/device/usbdc.c @@ -0,0 +1,836 @@ +/** + * \file + * + * \brief USB Device Stack Core Layer Implementation. + * + * Copyright (C) 2015-2016 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel micro controller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ + +#include "usbdc.h" + +#define USBDC_VERSION 0x00000001u + +/** + * \brief USB Device Core Sof Handler + */ +struct usbdc_sof_handler { + struct usbdc_sof_handler *next; + usbdc_sof_cb_t cb; +}; + +/** + * \brief USB Device Core Request Handler + */ +struct usbdc_req_handler { + struct usbdc_req_handler *next; + usbdc_req_cb_t cb; +}; + +/** + * \brief USB Device Core Change Handler + */ +struct usbdc_change_handler { + struct usbdc_change_handler *next; + usbdc_change_cb_t cb; +}; + +/** + * \brief USB Device Core Handler + */ +struct usbdc_handlers { + struct list_descriptor sof_list; + struct list_descriptor req_list; + struct list_descriptor change_list; +}; + +/** + * \brief USB Device Core Driver Structure + */ +struct usbdc_driver { + /** Pointer to descriptions of descriptors. */ + struct usbdc_descriptors desces; + /** Callback handlers. */ + struct usbdc_handlers handlers; + /** list of function drivers. */ + struct list_descriptor func_list; + /** Control buffer. */ + uint8_t *ctrl_buf; + /** Device status. */ + uint16_t status; + /** Device state. */ + uint8_t state; + /** Configuration value. */ + uint8_t cfg_value; + /** Control endpoint size. */ + uint8_t ctrl_size; +}; + +/** + * \brief USB Device Core Driver Instance + */ +static struct usbdc_driver usbdc; + +/** + * \brief Process the GetDescriptor request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_get_desc_req(const uint8_t ep, struct usb_req *req) +{ + uint8_t *cfg_desc, *str_desc; + uint16_t total_len; + uint16_t length = req->wLength; + uint8_t type = (uint8_t)(req->wValue >> 8); + uint8_t index = req->wValue & 0x00FF; + bool need_zlp = !(length & (usbdc.ctrl_size - 1)); + + switch (type) { + case USB_DT_DEVICE: + if (length > 0x12) { + length = 0x12; + } + usbdc_xfer(ep, usbdc.desces.ls_fs->sod, length, false); + return true; + case USB_DT_CONFIG: + cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index + 1); + if (NULL == cfg_desc) { + return false; + } + total_len = usb_cfg_desc_total_len(cfg_desc); + if (length <= total_len) { + need_zlp = false; + } else { + length = total_len; + } + usbdc_xfer(ep, cfg_desc, length, need_zlp); + return true; + case USB_DT_STRING: + str_desc = usb_find_str_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index); + if (NULL == str_desc) { + return false; + } + total_len = str_desc[0]; + if (length <= total_len) { + need_zlp = false; + } else { + length = total_len; + } + usbdc_xfer(ep, str_desc, length, need_zlp); + return true; + + default: + break; + } + return false; +} + +/** + * \brief Process the GetStatus request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_get_status_req(const uint8_t ep, const struct usb_req *req) +{ + int32_t st; + (void)ep; + + switch (req->bmRequestType & USB_REQT_RECIP_MASK) { + case USB_REQT_RECIP_DEVICE: + case USB_REQT_RECIP_INTERFACE: + st = 0; + break; + case USB_REQT_RECIP_ENDPOINT: + st = usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_GET); + if (st < 0) { + return false; + } + st = st & 0x1; + break; + default: + return false; + } + memcpy(usbdc.ctrl_buf, &st, 2); + usbdc_xfer(ep, usbdc.ctrl_buf, 2, false); + return true; +} + +/** + * \brief Process the standard Get Interface + * \param[in] req Point to usb request struct. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_get_interface(struct usb_req *req) +{ + struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head; + int32_t rc; + + while (NULL != func) { + if (0 > (rc = func->ctrl(func, USBDF_GET_IFACE, req))) { + func = func->next; + } else { + usbdc.ctrl_buf[0] = (uint8_t)rc; + usbdc_xfer(0, usbdc.ctrl_buf, 1, false); + return true; + } + } + return false; +} + +/** + * \brief Process the standard Get request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_get_req(const uint8_t ep, struct usb_req *req) +{ + switch (req->bRequest) { + case USB_REQ_GET_DESC: + return usbdc_get_desc_req(ep, req); + case USB_REQ_GET_CONFIG: + *(uint8_t *)usbdc.ctrl_buf = usbdc.cfg_value; + usbdc_xfer(ep, usbdc.ctrl_buf, 1, false); + return true; + case USB_REQ_GET_STATUS: + return usbdc_get_status_req(ep, req); + case USB_REQ_GET_INTERFACE: + return usbdc_get_interface(req); + default: + return false; + } +} + +/** + * \brief Process the standard ClearFeature request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_clear_ftr_req(const uint8_t ep, const struct usb_req *req) +{ + (void)ep; + switch (req->bmRequestType & USB_REQT_RECIP_MASK) { + case USB_REQT_RECIP_ENDPOINT: + if (req->wLength != 0) { + return false; + } + usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_CLR); + return true; + default: + return false; + } +} + +/** + * \brief Process the standard SetFeature request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_set_ftr_req(const uint8_t ep, const struct usb_req *req) +{ + (void)ep; + switch (req->bmRequestType & USB_REQT_RECIP_MASK) { + case USB_REQT_RECIP_ENDPOINT: + if (req->wLength != 0) { + return false; + } + usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_SET); + return true; + default: + return false; + } +} + +/** + * \brief Unconfig, close all interfaces + */ +static void usbdc_unconfig(void) +{ + struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head; + while (NULL != func) { + func->ctrl(func, USBDF_DISABLE, NULL); + func = func->next; + } +} + +/** + * \brief Apply Set Configuration Value + */ +static void usbdc_set_config(void) +{ + struct usbd_descriptors desc; + struct usbdf_driver * func; + uint8_t * cfg_desc; + uint16_t total_len; + uint8_t last_iface = 0xFF; + + if (usbdc.cfg_value == 0) { + usbdc_unconfig(); + return; + } + + cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, usbdc.cfg_value); + + if (NULL == cfg_desc) { + return; + } + + total_len = usb_cfg_desc_total_len(cfg_desc); + desc.eod = cfg_desc + total_len; + desc.sod = usb_find_desc(cfg_desc, desc.eod, USB_DT_INTERFACE); + + while (NULL != desc.sod) { + /* Apply very first alternate setting (must be 0) of the interface */ + if (last_iface != desc.sod[2] /* bInterfaceNumber */) { + last_iface = desc.sod[2]; + func = (struct usbdf_driver *)usbdc.func_list.head; + while (NULL != func) { + if (func->ctrl(func, USBDF_ENABLE, &desc)) { + func = func->next; + } else { + break; + } + } + } + desc.sod = usb_desc_next(desc.sod); + desc.sod = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); + } +} + +/** + * \brief Apply the USB device address + * \param[in] addr address to be set. + */ +static void usbdc_set_address(uint8_t addr) +{ + usb_d_set_address(addr); +} + +/** + * \brief Process the standard Set Interface + * \param[in] alt_set Alternate Setting. + * \param[in] ifc_id Interface Index. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_set_interface(uint16_t alt_set, uint16_t ifc_id) +{ + struct usbd_descriptors desc; + struct usbdf_driver * func; + uint8_t * ifc; + + desc.sod = usbdc.desces.ls_fs->sod; + desc.eod = usbdc.desces.ls_fs->eod; + if (NULL == (ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE))) { + return false; + } + + while (ifc[2] != ifc_id || ifc[3] != alt_set) { + desc.sod = usb_desc_next(desc.sod); + ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); + if (NULL == ifc) { + return false; + } + } + + desc.sod = ifc; + func = (struct usbdf_driver *)usbdc.func_list.head; + + while (NULL != func) { + if (func->ctrl(func, USBDF_DISABLE, &desc)) { + func = func->next; + } else if (ERR_NONE == func->ctrl(func, USBDF_ENABLE, &desc)) { + usbdc_xfer(0, NULL, 0, 0); + return true; + } else { + return false; + } + } + + return false; +} + +/** + * \brief Process the standard Set request + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_set_req(const uint8_t ep, struct usb_req *req) +{ + switch (req->bRequest) { + case USB_REQ_SET_ADDRESS: + case USB_REQ_SET_CONFIG: + if (ERR_NONE == usbdc_xfer(ep, NULL, 0, true)) { + return true; + } else { + return false; + } + case USB_REQ_CLEAR_FTR: + return usbdc_clear_ftr_req(ep, req); + case USB_REQ_SET_FTR: + return usbdc_set_ftr_req(ep, req); + case USB_REQ_SET_INTERFACE: + return usbdc_set_interface(req->wValue, req->wIndex); + default: + return false; + } +} + +/** Invoke all registered SOF callbacks. */ +static void usbdc_sof_notify(void) +{ + struct usbdc_sof_handler *sof = (struct usbdc_sof_handler *)usbdc.handlers.sof_list.head; + + while (sof != NULL) { + if (NULL != sof->cb) { + sof->cb(); + } + sof = sof->next; + } +} + +/** Invoke all registered Change notification callbacks. */ +static void usbdc_change_notify(enum usbdc_change_type change, uint32_t value) +{ + struct usbdc_change_handler *cg = (struct usbdc_change_handler *)usbdc.handlers.change_list.head; + + while (cg != NULL) { + if (NULL != cg->cb) { + cg->cb(change, value); + } + cg = cg->next; + } +} + +/** Invoke all registered request callbacks until request handled. */ +static bool usbdc_request_handler(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage) +{ + struct usbdc_req_handler *h = (struct usbdc_req_handler *)usbdc.handlers.req_list.head; + int32_t rc; + + while (h != NULL) { + if (NULL != h->cb) { + rc = h->cb(ep, req, stage); + if (0 == rc) { + return true; + } else if (ERR_NOT_FOUND != rc) { + return false; + } + } + h = h->next; + } + return false; +} + +/** + * \brief Callback invoked on USB device SOF + */ +static void usbd_sof_cb(void) +{ + usbdc_sof_notify(); +} + +/** + * \brief Callback invoked when control request is received + * \param[in] ep Endpoint address. + * \param[in] req Pointer to the request. + * \return Operation status. + * \retval true Request is handled OK. + * \retval false Request not supported. + */ +static bool usbdc_cb_ctl_req(const uint8_t ep, struct usb_req *req) +{ + if (usbdc_request_handler(ep, req, USB_SETUP_STAGE)) { + return true; + } + + // STD request handling + switch (req->bmRequestType & (USB_REQT_TYPE_MASK | USB_REQT_DIR_IN)) { + case USB_REQT_TYPE_STANDARD: + return usbdc_set_req(ep, req); + case (USB_REQT_TYPE_STANDARD | USB_REQT_DIR_IN): + return usbdc_get_req(ep, req); + default: + return false; + } +} + +/** + * \brief When control status stage is end + * \param[in] req Pointer to the request. + */ +static void usbdc_ctrl_status_end(const struct usb_req *req) +{ + switch (req->bRequest) { + case USB_REQ_SET_CONFIG: + usbdc.cfg_value = req->wValue; + usbdc_set_config(); + usbdc.state = req->wValue ? USBD_S_CONFIG : USBD_S_ADDRESS; + usbdc_change_notify(USBDC_C_STATE, usbdc.state); + break; + case USB_REQ_SET_ADDRESS: + usbdc_set_address(req->wValue); + usbdc.state = req->wValue ? USBD_S_ADDRESS : USBD_S_DEFAULT; + usbdc_change_notify(USBDC_C_STATE, usbdc.state); + break; + default: + break; + } +} + +/** + * \brief When control data stage is end + * \param[in] req Pointer to the request. + */ +static bool usbdc_ctrl_data_end(struct usb_req *req) +{ + usbdc_request_handler(0, req, USB_DATA_STAGE); + return false; +} + +/** + * \brief Callback invoked when control data done or status done + * \param[in] ep Endpoint number with direction on bit 8. + * \param[in] code Status code. + * \param[in] req Pointer to the control setup request. + * \return Data has error or not. + * \retval true There is data error, protocol error. + * \retval false There is no data error. + */ +static bool usbdc_cb_ctl_done(const uint8_t ep, const enum usb_xfer_code code, struct usb_req *req) +{ + (void)ep; + + switch (code) { + case USB_XFER_DONE: + usbdc_ctrl_status_end(req); + break; + case USB_XFER_DATA: + return usbdc_ctrl_data_end(req); + default: + break; + } + return false; +} + +/** + * \brief USB Device Core Reset + */ +void usbdc_reset(void) +{ + usbdc_unconfig(); + + usbdc.state = USBD_S_DEFAULT; + usbdc.cfg_value = 0; + + // Setup EP0 + usb_d_ep_deinit(0); + usb_d_ep0_init(usbdc.ctrl_size); + usb_d_ep_register_callback(0, USB_D_EP_CB_SETUP, (FUNC_PTR)usbdc_cb_ctl_req); + usb_d_ep_register_callback(0, USB_D_EP_CB_XFER, (FUNC_PTR)usbdc_cb_ctl_done); + usb_d_ep_enable(0); +} + +/** + * \brief Callback invoked on USB device events + * \param[in] ev Event code. + * \param[in] param Event parameter for event handling. + */ +static void usbd_event_cb(const enum usb_event ev, const uint32_t param) +{ + (void)param; + + switch (ev) { + case USB_EV_VBUS: + usbdc_change_notify(USBDC_C_CONN, param); + break; + + case USB_EV_RESET: + usbdc_reset(); + break; + + default: + break; + } +} + +/** + * \brief Issue USB device transfer + */ +int32_t usbdc_xfer(uint8_t ep, uint8_t *buf, uint32_t size, bool zlp) +{ + struct usb_d_transfer xfer = {(uint8_t *)buf, size, ep, zlp}; + return usb_d_ep_transfer(&xfer); +} + +/** + * \brief Register the handler + */ +void usbdc_register_handler(enum usbdc_handler_type type, const struct usbdc_handler *h) +{ + switch (type) { + case USBDC_HDL_SOF: + list_insert_at_end(&usbdc.handlers.sof_list, (void *)h); + break; + case USBDC_HDL_REQ: + list_insert_at_end(&usbdc.handlers.req_list, (void *)h); + break; + case USBDC_HDL_CHANGE: + list_insert_at_end(&usbdc.handlers.change_list, (void *)h); + break; + default: + break; + } +} + +/** + * \brief Unregister the handler + */ +void usbdc_unregister_handler(enum usbdc_handler_type type, const struct usbdc_handler *h) +{ + switch (type) { + case USBDC_HDL_SOF: + list_delete_element(&usbdc.handlers.sof_list, (void *)h); + break; + case USBDC_HDL_REQ: + list_delete_element(&usbdc.handlers.req_list, (void *)h); + break; + case USBDC_HDL_CHANGE: + list_delete_element(&usbdc.handlers.change_list, (void *)h); + break; + default: + break; + } +} + +/** + * \brief Initialize the USB device core driver + */ +int32_t usbdc_init(uint8_t *ctrl_buf) +{ + ASSERT(ctrl_buf); + + int32_t rc; + + rc = usb_d_init(); + if (rc < 0) { + return rc; + } + + memset(&usbdc, 0, sizeof(usbdc)); + usbdc.ctrl_buf = ctrl_buf; + usb_d_register_callback(USB_D_CB_SOF, (FUNC_PTR)usbd_sof_cb); + usb_d_register_callback(USB_D_CB_EVENT, (FUNC_PTR)usbd_event_cb); + + return 0; +} + +/** + * \brief De-initialize the USB device core driver + */ +int32_t usbdc_deinit(void) +{ + usb_d_deinit(); + return 0; +} + +/** + * \brief Register/unregister function support of a USB device function + * + * Must be invoked when USB device is stopped. + */ +void usbdc_register_function(struct usbdf_driver *func) +{ + list_insert_at_end(&usbdc.func_list, func); +} + +/** + * \brief Unregister function support of a USB device function + * + * Must be invoked when USB device is stopped. + */ +void usbdc_unregister_function(struct usbdf_driver *func) +{ + list_delete_element(&usbdc.func_list, func); +} + +/** + * \brief Validate the descriptor + */ +int32_t usbdc_validate_desces(struct usbd_descriptors *desces) +{ + uint8_t *sod, *eod; + if (desces == NULL) { + return ERR_NOT_FOUND; + } + sod = usb_find_desc(desces->sod, desces->eod, USB_DT_DEVICE); + if (sod == NULL) { + return ERR_BAD_DATA; + } + sod = usb_find_desc(desces->sod, desces->eod, USB_DT_CONFIG); + if (sod == NULL) { + return ERR_BAD_DATA; + } + eod = sod + usb_cfg_desc_total_len(sod); + if (eod > desces->eod) { + return ERR_BAD_DATA; + } + return 0; +} + +/** + * \brief Validate the descriptor + */ +int32_t usbdc_check_desces(struct usbdc_descriptors *desces) +{ +#ifdef CONF_USBD_HS_SP + int32_t rc; + if (desces->hs == NULL && desces->ls_fs == NULL) { + return ERR_NOT_FOUND; + } + if (desces->hs) { + rc = usbdc_validate_desces(desces->hs); + if (rc < 0) { + return rc; + } + } +#endif + return usbdc_validate_desces(desces->ls_fs); +} + +/** + * \brief Start the USB device driver with specific descriptors set + */ +int32_t usbdc_start(struct usbd_descriptors *desces) +{ + if (usbdc.state >= USBD_S_POWER) { + return ERR_BUSY; + } + + if (desces) { + usbdc.desces.ls_fs = desces; + } else { + return ERR_BAD_DATA; + } + + usbdc.ctrl_size = desces->sod[7]; + usbdc.state = USBD_S_POWER; + usb_d_enable(); + return ERR_NONE; +} + +/** + * \brief Stop the USB device driver + */ +int32_t usbdc_stop(void) +{ + usb_d_disable(); + usbdc.state = USBD_S_OFF; + return ERR_NONE; +} + +/** + * \brief Attach the USB device to host + */ +void usbdc_attach(void) +{ + usb_d_attach(); +} + +/** + * \brief Detach the USB device from host + */ +void usbdc_detach(void) +{ + usb_d_detach(); +} + +/** + * \brief Send remote wakeup to host + */ +void usbdc_remotewakeup(void) +{ + usb_d_send_remotewakeup(); + usbdc.state = USBD_S_POWER; +} + +/** + * \brief Return USB Device endpoint0 buffer + */ +uint8_t *usbdc_get_ctrl_buffer(void) +{ + return usbdc.ctrl_buf; +} + +/** + * \brief Return current USB state + */ +uint8_t usbdc_get_state(void) +{ + if (usbdc.state & USBD_S_SUSPEND) { + return USBD_S_SUSPEND; + } + return usbdc.state; +} + +/** + * \brief Return version + */ +uint32_t usbdc_get_version(void) +{ + return USBDC_VERSION; +} diff --git a/atmel-samd/asf4/samd21/usb/device/usbdc.h b/atmel-samd/asf4/samd21/usb/device/usbdc.h new file mode 100644 index 000000000..515d28f1b --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/device/usbdc.h @@ -0,0 +1,246 @@ +/** + * \file + * + * \brief USB Device Stack Core Layer Definition. + * + * Copyright (C) 2015-2016 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef _USB_USBDC_H_ +#define _USB_USBDC_H_ + +#include "usb_includes.h" +#include "usb_protocol.h" +#include "hal_usb_device.h" + +/** USB device states. */ +enum usbd_state { + USBD_S_OFF = 0, + USBD_S_POWER = 1, + USBD_S_DEFAULT = 2, + USBD_S_ADDRESS = 3, + USBD_S_CONFIG = 4, + USBD_S_SUSPEND = 0x10 +}; + +/** USB device core handler type. */ +enum usbdc_handler_type { USBDC_HDL_SOF, USBDC_HDL_REQ, USBDC_HDL_CHANGE }; + +/** USB device core change notification type. */ +enum usbdc_change_type { + /** Change of connection, detected by vbus. */ + USBDC_C_CONN, + /** Change of state, by RESET, SetAddress(), SetConfig(). */ + USBDC_C_STATE, + /** Change of power. */ + USBDC_C_POWER, + /** Change of remote wakeup setting. */ + USBDC_C_REMOTE_WAKEUP +}; + +/** Power change. */ +enum usbdc_power_type { USBDC_ACTIVE, USBDC_SLEEP, USBDC_SUSPEND }; + +/** USB device general function control code. */ +enum usbdf_control { + /** Enable the function. + * int32_t ctrl(usbdf, USBDF_ENABLE, struct usbd_descriptors *desc); + * Parameter holds interface descriptor and + * configuration descriptor end position. + */ + USBDF_ENABLE, + /** Disable the function. + * int32_t ctrl(usbdf, USBDF_DISABLE, struct usbd_descriptors *desc); + * Parameter holds interface descriptor and + * configuration descriptor end position. + * Input NULL to force disable the function anyway. + */ + USBDF_DISABLE, + /** Get interface alternate setting. + * int32_t ctrl(usbdf, USBDF_GET_IFACE, struct usb_req *req); + * Parameter holds interface number who should return + * the alternate setting. + */ + USBDF_GET_IFACE +}; + +/** Describes a list of USB descriptors. */ +struct usbd_descriptors { + /** Pointer to Start of Descriptors. */ + uint8_t *sod; + /** Pointer to End of Descriptors. */ + uint8_t *eod; +}; + +/** Describes the USB device core descriptors. */ +struct usbdc_descriptors { + struct usbd_descriptors *ls_fs; +#ifdef CONF_USBD_HS_SP + struct usbd_descriptors *hs; +#endif +}; + +/** Describes a list of core handler descriptor. */ +struct usbdc_handler { + /** Pointer to next handler. */ + struct usbdc_handler *next; + /** Pointer to handler function. */ + FUNC_PTR func; +}; + +/** Forward declaration for USB device function driver. */ +struct usbdf_driver; + +/** SOF handling function. */ +typedef void (*usbdc_sof_cb_t)(void); + +/** REQ handling function. */ +typedef int32_t (*usbdc_req_cb_t)(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage); + +/** Change notification callback function. */ +typedef void (*usbdc_change_cb_t)(enum usbdc_change_type change, uint32_t value); + +/** Control function for USB device general function driver. */ +typedef int32_t (*usbdf_control_cb_t)(struct usbdf_driver *drv, enum usbdf_control ctrl, void *param); + +/** USB device general function driver descriptor. */ +struct usbdf_driver { + /** Pointer to next function.*/ + struct usbdf_driver *next; + /** Pointer to control function.*/ + usbdf_control_cb_t ctrl; + /** Pointer to function driver specific data. */ + void *func_data; +}; + +/** + * \brief Register the handler + * \param[in] type USB device core handler type. + * \param[in] h Pointer to usb device core handler. + */ +void usbdc_register_handler(enum usbdc_handler_type type, const struct usbdc_handler *h); + +/** + * \brief Unregister the handler + * \param[in] type USB device core handler type. + * \param[in] h Pointer to usb device core handler. + */ +void usbdc_unregister_handler(enum usbdc_handler_type type, const struct usbdc_handler *h); + +/** + * \brief Initialize the USB device core driver + * \param[in] ctrl_buf Pointer to a buffer to be used by usb device ctrl endpoint + * Note: the size of ctrl_buf should not be less than the size of EP0 + * \return Operation status. + */ +int32_t usbdc_init(uint8_t *ctrl_buf); + +/** + * \brief Deinitialize the USB device core driver + * \return Operation status. + */ +int32_t usbdc_deinit(void); + +/** + * \brief Register function support of a USB device function + * \param[in] func Pointer to usb device function driver structure + */ +void usbdc_register_function(struct usbdf_driver *func); + +/** + * \brief Unregister function support of a USB device function + * \param[in] func Pointer to usb device function driver structure + */ +void usbdc_unregister_function(struct usbdf_driver *func); + +/** + * \brief Validate the descriptors + * \param[in] desces Pointer to usb device core descriptors + * \return Operation status. + */ +int32_t usbdc_validate_desces(struct usbd_descriptors *desces); + +/** + * \brief Issue USB device data transfer + * \param[in] ep endpointer address. + * \param[in] buf Pointer to data transfer buffer. + * \param[in] size the size of data transfer. + * \param[in] zlp flag to indicate zero length packet. + * \return Operation status. + */ +int32_t usbdc_xfer(uint8_t ep, uint8_t *buf, uint32_t size, bool zlp); + +/** + * \brief Start the USB device driver with specific descriptors set + * \param[in] desces Pointer to usb device core descriptors + * \return Operation status. + */ +int32_t usbdc_start(struct usbd_descriptors *desces); + +/** + * \brief Stop the USB device driver + * \return Operation status. + */ +int32_t usbdc_stop(void); + +/** + * \brief Attach the USB device to host + */ +void usbdc_attach(void); + +/** + * \brief Detach the USB device from host + */ +void usbdc_detach(void); + +/** + * \brief Send remote wakeup to host + */ +void usbdc_remotewakeup(void); + +/** + * \brief Return USB device ctrl end pointer buffer start address + */ +uint8_t *usbdc_get_ctrl_buffer(void); + +/** + * \brief Return current USB state + */ +uint8_t usbdc_get_state(void); + +/** + * \brief Return version + */ +uint32_t usbdc_get_version(void); + +#endif /* USBDC_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/usb_atmel.h b/atmel-samd/asf4/samd21/usb/usb_atmel.h new file mode 100644 index 000000000..3ca7a2927 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/usb_atmel.h @@ -0,0 +1,189 @@ +/** + * \file + * + * \brief All USB VIDs and PIDs from Atmel USB applications + * + * Copyright (c) 2015 Atmel Corporation. All rights reserved. + * + * \asf_license_start + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel microcontroller product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * \asf_license_stop + * + */ +/* + * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a> + */ + +#ifndef _USB_ATMEL_H_ +#define _USB_ATMEL_H_ + +/** + * \defgroup usb_group USB Stack + * + * This stack includes the USB Device Stack, USB Host Stack and common + * definitions. + * @{ + */ + +//! @} + +/** + * \ingroup usb_group + * \defgroup usb_atmel_ids_group Atmel USB Identifiers + * + * This module defines Atmel PID and VIDs constants. + * + * @{ + */ + +//! \name Vendor Identifier assigned by USB org to ATMEL +#define USB_VID_ATMEL 0x03EB + +//! \name Product Identifier assigned by ATMEL to AVR applications +//! @{ + +//! \name The range from 2000h to 20FFh is reserved to the old PID for C51, MEGA, and others. +//! @{ +#define USB_PID_ATMEL_MEGA_HIDGENERIC 0x2013 +#define USB_PID_ATMEL_MEGA_HIDKEYBOARD 0x2017 +#define USB_PID_ATMEL_MEGA_CDC 0x2018 +#define USB_PID_ATMEL_MEGA_AUDIO_IN 0x2019 +#define USB_PID_ATMEL_MEGA_MS 0x201A +#define USB_PID_ATMEL_MEGA_AUDIO_IN_OUT 0x201B +#define USB_PID_ATMEL_MEGA_HIDMOUSE 0x201C +#define USB_PID_ATMEL_MEGA_HIDMOUSE_CERTIF_U4 0x201D +#define USB_PID_ATMEL_MEGA_CDC_MULTI 0x201E +#define USB_PID_ATMEL_MEGA_MS_HIDMS_HID_USBKEY 0x2022 +#define USB_PID_ATMEL_MEGA_MS_HIDMS_HID_STK525 0x2023 +#define USB_PID_ATMEL_MEGA_MS_2 0x2029 +#define USB_PID_ATMEL_MEGA_MS_HIDMS 0x202A +#define USB_PID_ATMEL_MEGA_MS_3 0x2032 +#define USB_PID_ATMEL_MEGA_LIBUSB 0x2050 +//! @} + +//! \name The range 2100h to 21FFh is reserved to PIDs for AVR Tools. +//! @{ +#define USB_PID_ATMEL_XPLAINED 0x2122 +#define USB_PID_ATMEL_XMEGA_USB_ZIGBIT_2_4GHZ 0x214A +#define USB_PID_ATMEL_XMEGA_USB_ZIGBIT_SUBGHZ 0x214B +//! @} + +//! \name The range 2300h to 23FFh is reserved to PIDs for demo from ASF1.7=> +//! @{ +#define USB_PID_ATMEL_UC3_ENUM 0x2300 +#define USB_PID_ATMEL_UC3_MS 0x2301 +#define USB_PID_ATMEL_UC3_MS_SDRAM_LOADER 0x2302 +#define USB_PID_ATMEL_UC3_EVK1100_CTRLPANEL 0x2303 +#define USB_PID_ATMEL_UC3_HID 0x2304 +#define USB_PID_ATMEL_UC3_EVK1101_CTRLPANEL_HID 0x2305 +#define USB_PID_ATMEL_UC3_EVK1101_CTRLPANEL_HID_MS 0x2306 +#define USB_PID_ATMEL_UC3_CDC 0x2307 +#define USB_PID_ATMEL_UC3_AUDIO_MICRO 0x2308 +#define USB_PID_ATMEL_UC3_CDC_DEBUG 0x2310 // Virtual Com (debug interface) on EVK11xx +#define USB_PID_ATMEL_UC3_AUDIO_SPEAKER_MICRO 0x2311 +#define USB_PID_ATMEL_UC3_CDC_MSC 0x2312 +//! @} + +//! \name The range 2400h to 24FFh is reserved to PIDs for ASF applications +//! @{ +#define USB_PID_ATMEL_ASF_HIDMOUSE 0x2400 +#define USB_PID_ATMEL_ASF_HIDKEYBOARD 0x2401 +#define USB_PID_ATMEL_ASF_HIDGENERIC 0x2402 +#define USB_PID_ATMEL_ASF_MSC 0x2403 +#define USB_PID_ATMEL_ASF_CDC 0x2404 +#define USB_PID_ATMEL_ASF_PHDC 0x2405 +#define USB_PID_ATMEL_ASF_HIDMTOUCH 0x2406 +#define USB_PID_ATMEL_ASF_MSC_HIDMOUSE 0x2420 +#define USB_PID_ATMEL_ASF_MSC_HIDS_CDC 0x2421 +#define USB_PID_ATMEL_ASF_MSC_HIDKEYBOARD 0x2422 +#define USB_PID_ATMEL_ASF_VENDOR_CLASS 0x2423 +#define USB_PID_ATMEL_ASF_MSC_CDC 0x2424 +#define USB_PID_ATMEL_ASF_TWO_CDC 0x2425 +#define USB_PID_ATMEL_ASF_SEVEN_CDC 0x2426 +#define USB_PID_ATMEL_ASF_XPLAIN_BC_POWERONLY 0x2430 +#define USB_PID_ATMEL_ASF_XPLAIN_BC_TERMINAL 0x2431 +#define USB_PID_ATMEL_ASF_XPLAIN_BC_TOUCH 0x2432 +#define USB_PID_ATMEL_ASF_AUDIO_SPEAKER 0x2433 +#define USB_PID_ATMEL_ASF_XMEGA_B1_XPLAINED 0x2434 +//! @} + +//! \name The range 2F00h to 2FFFh is reserved to official PIDs for AVR bootloaders +//! Note, !!!! don't use this range for demos or examples !!!! +//! @{ +#define USB_PID_ATMEL_DFU_ATXMEGA64C3 0x2FD6 +#define USB_PID_ATMEL_DFU_ATXMEGA128C3 0x2FD7 +#define USB_PID_ATMEL_DFU_ATXMEGA16C4 0x2FD8 +#define USB_PID_ATMEL_DFU_ATXMEGA32C4 0x2FD9 +#define USB_PID_ATMEL_DFU_ATXMEGA256C3 0x2FDA +#define USB_PID_ATMEL_DFU_ATXMEGA384C3 0x2FDB +#define USB_PID_ATMEL_DFU_ATUCL3_L4 0x2FDC +#define USB_PID_ATMEL_DFU_ATXMEGA64A4U 0x2FDD +#define USB_PID_ATMEL_DFU_ATXMEGA128A4U 0x2FDE + +#define USB_PID_ATMEL_DFU_ATXMEGA64B3 0x2FDF +#define USB_PID_ATMEL_DFU_ATXMEGA128B3 0x2FE0 +#define USB_PID_ATMEL_DFU_ATXMEGA64B1 0x2FE1 +#define USB_PID_ATMEL_DFU_ATXMEGA256A3BU 0x2FE2 +#define USB_PID_ATMEL_DFU_ATXMEGA16A4U 0x2FE3 +#define USB_PID_ATMEL_DFU_ATXMEGA32A4U 0x2FE4 +#define USB_PID_ATMEL_DFU_ATXMEGA64A3U 0x2FE5 +#define USB_PID_ATMEL_DFU_ATXMEGA128A3U 0x2FE6 +#define USB_PID_ATMEL_DFU_ATXMEGA192A3U 0x2FE7 +#define USB_PID_ATMEL_DFU_ATXMEGA64A1U 0x2FE8 +#define USB_PID_ATMEL_DFU_ATUC3D 0x2FE9 +#define USB_PID_ATMEL_DFU_ATXMEGA128B1 0x2FEA +#define USB_PID_ATMEL_DFU_AT32UC3C 0x2FEB +#define USB_PID_ATMEL_DFU_ATXMEGA256A3U 0x2FEC +#define USB_PID_ATMEL_DFU_ATXMEGA128A1U 0x2FED +#define USB_PID_ATMEL_DFU_ATMEGA8U2 0x2FEE +#define USB_PID_ATMEL_DFU_ATMEGA16U2 0x2FEF +#define USB_PID_ATMEL_DFU_ATMEGA32U2 0x2FF0 +#define USB_PID_ATMEL_DFU_AT32UC3A3 0x2FF1 +#define USB_PID_ATMEL_DFU_ATMEGA32U6 0x2FF2 +#define USB_PID_ATMEL_DFU_ATMEGA16U4 0x2FF3 +#define USB_PID_ATMEL_DFU_ATMEGA32U4 0x2FF4 +#define USB_PID_ATMEL_DFU_AT32AP7200 0x2FF5 +#define USB_PID_ATMEL_DFU_AT32UC3B 0x2FF6 +#define USB_PID_ATMEL_DFU_AT90USB82 0x2FF7 +#define USB_PID_ATMEL_DFU_AT32UC3A 0x2FF8 +#define USB_PID_ATMEL_DFU_AT90USB64 0x2FF9 +#define USB_PID_ATMEL_DFU_AT90USB162 0x2FFA +#define USB_PID_ATMEL_DFU_AT90USB128 0x2FFB +// 2FFCh to 2FFFh used by C51 family products +//! @} + +//! @} + +//! @} + +#endif // _USB_ATMEL_H_ diff --git a/atmel-samd/asf4/samd21/usb/usb_debug.h b/atmel-samd/asf4/samd21/usb/usb_debug.h new file mode 100644 index 000000000..4d8893208 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/usb_debug.h @@ -0,0 +1,47 @@ +/** + * \file + * + * \brief USB Debug Files. + * + * This file contains the USB definitions and data structures provided by the + * USB 2.0 specification. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef _USB_DEBUG_H_ +#define _USB_DEBUG_H_ + +#define udbg_print(...) + +#endif diff --git a/atmel-samd/asf4/samd21/usb/usb_includes.h b/atmel-samd/asf4/samd21/usb/usb_includes.h new file mode 100644 index 000000000..b3874d31e --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/usb_includes.h @@ -0,0 +1,137 @@ +/** + * \file + * + * \brief USB Include Header Files. + * + * This file contains the USB definitions and data structures provided by the + * USB 2.0 specification. + * + * Copyright (C) 2015 - 2017 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef _USB_INCLUDES_H_ +#define _USB_INCLUDES_H_ + +#ifdef USB_USER_INCLUDES + +#include "usb_user_includes.h" + +#else +/* Include START headers */ +#include <stdbool.h> +#include <stdint.h> +#include <string.h> +#include <utils.h> +#include <utils_list.h> +#include <utils_assert.h> +#include <hal_atomic.h> + +typedef uint16_t le16_t; +typedef uint32_t le32_t; +typedef uint16_t be16_t; +typedef uint32_t be32_t; + +#if (defined __GNUC__) || (defined __CC_ARM) +#define is_constant(exp) __builtin_constant_p(exp) +#else +#define is_constant(exp) (0) +#endif + +/*! \brief Toggles the endianism of \a u16 (by swapping its bytes). + * + * \param u16 U16 of which to toggle the endianism. + * + * \return Value resulting from \a u16 with toggled endianism. + * + * \note More optimized if only used with values known at compile time. + */ +#define swap_u16(u16) ((uint16_t)(((uint16_t)(u16) >> 8) | ((uint16_t)(u16) << 8))) + +/*! \brief Toggles the endianism of \a u32 (by swapping its bytes). + * + * \param u32 U32 of which to toggle the endianism. + * + * \return Value resulting from \a u32 with toggled endianism. + * + * \note More optimized if only used with values known at compile time. + */ +#if (defined __GNUC__) +#define swap_u32(u32) \ + (is_constant(u32) \ + ? ((uint32_t)(((uint32_t)swap_u16((uint32_t)(u32) >> 16)) | ((uint32_t)swap_u16((uint32_t)(u32)) << 16))) \ + : ((uint32_t)__builtin_bswap32((uint32_t)(u32)))) +#else +#define swap_u32(u32) \ + ((uint32_t)(((uint32_t)swap_u16((uint32_t)(u32) >> 16)) | ((uint32_t)swap_u16((uint32_t)(u32)) << 16))) +#endif + +/** Get a value from/to LE16 data */ +#define LE16(x) (x) +/** Get a value from/to LE32 data */ +#define LE32(x) (x) +/** Get a value from/to BE16 data */ +#define BE16(x) swap_u16(x) +/** Get a value from/to BE32 data */ +#define BE32(x) swap_u32(x) + +/** Get byte 0 for BE 16-bit value */ +#define BE16B0(a) ((uint8_t)((a) >> 8)) +/** Get byte 1 for BE 16-bit value */ +#define BE16B1(a) ((uint8_t)((a) >> 0)) + +/** Get byte 0 for BE 32-bit value */ +#define BE32B0(a) ((uint8_t)((a) >> 24)) +/** Get byte 1 for BE 32-bit value */ +#define BE32B1(a) ((uint8_t)((a) >> 16)) +/** Get byte 2 for BE 32-bit value */ +#define BE32B2(a) ((uint8_t)((a) >> 8)) +/** Get byte 3 for BE 32-bit value */ +#define BE32B3(a) ((uint8_t)((a) >> 0)) + +/** Get byte 0 for LE 16-bit value */ +#define LE16B0(a) ((uint8_t)((a) >> 0)) +/** Get byte 1 for LE 16-bit value */ +#define LE16B1(a) ((uint8_t)((a) >> 8)) + +/** Get byte 0 for LE 32-bit value */ +#define LE32B0(a) ((uint8_t)((a) >> 0)) +/** Get byte 1 for LE 32-bit value */ +#define LE32B1(a) ((uint8_t)((a) >> 8)) +/** Get byte 2 for LE 32-bit value */ +#define LE32B2(a) ((uint8_t)((a) >> 16)) +/** Get byte 3 for LE 32-bit value */ +#define LE32B3(a) ((uint8_t)((a) >> 24)) + +#endif /* USB_USER_INCLUDES */ + +#endif /* _USB_INCLUDES_H_ */ diff --git a/atmel-samd/asf4/samd21/usb/usb_protocol.c b/atmel-samd/asf4/samd21/usb/usb_protocol.c new file mode 100644 index 000000000..534e4d1d9 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/usb_protocol.c @@ -0,0 +1,146 @@ +/** + * \file + * + * \brief USB protocol implementation. + * + * This file contains the USB definitions and data structures provided by the + * USB 2.0 specification. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#define CONF_NO_ASSERT_CHECK + +#include "usb_protocol.h" + +#ifdef CONF_NO_ASSERT_CHECK +#define _param_error_check(cond) +#define _desc_len_check() \ + if (usb_desc_len(desc) < 2) { \ + /* Encounter an invalid descriptor. */ \ + return NULL; \ + } +#else +#define _param_error_check(cond) ASSERT(cond) +#define _desc_len_check() ASSERT(usb_desc_len(desc) >= 2) +#endif + +uint8_t *usb_find_desc(uint8_t *desc, uint8_t *eof, uint8_t type) +{ + _param_error_check(desc && eof && (desc < eof)); + + while (desc < eof) { + _desc_len_check(); + if (type == usb_desc_type(desc)) { + return desc; + } + desc = usb_desc_next(desc); + } + return NULL; +} + +uint8_t *usb_find_iface_after(uint8_t *desc, uint8_t *eof, uint8_t iface_n) +{ + _param_error_check(desc && eof && (desc < eof)); + + while (desc < eof) { + _desc_len_check(); + if (USB_DT_INTERFACE == usb_desc_type(desc)) { + if (iface_n != desc[2]) { + return desc; + } + } + desc = usb_desc_next(desc); + } + return eof; +} + +uint8_t *usb_find_ep_desc(uint8_t *desc, uint8_t *eof) +{ + _param_error_check(desc && eof && (desc < eof)); + + while (desc < eof) { + _desc_len_check(); + if (USB_DT_INTERFACE == usb_desc_type(desc)) { + break; + } + if (USB_DT_ENDPOINT == usb_desc_type(desc)) { + return desc; + } + desc = usb_desc_next(desc); + } + return NULL; +} + +uint8_t *usb_find_cfg_desc(uint8_t *desc, uint8_t *eof, uint8_t cfg_value) +{ + _param_error_check(desc && eof && (desc < eof)); + + desc = usb_find_desc(desc, eof, USB_DT_CONFIG); + if (!desc) { + return NULL; + } + while (desc < eof) { + _desc_len_check(); + if (desc[1] != USB_DT_CONFIG) { + break; + } + if (desc[5] == cfg_value) { + return desc; + } + desc = usb_cfg_desc_next(desc); + } + return NULL; +} + +uint8_t *usb_find_str_desc(uint8_t *desc, uint8_t *eof, uint8_t str_index) +{ + uint8_t i; + + _param_error_check(desc && eof && (desc < eof)); + + for (i = 0; desc < eof;) { + desc = usb_find_desc(desc, eof, USB_DT_STRING); + if (desc) { + _desc_len_check(); + if (i == str_index) { + return desc; + } + i++; + desc = usb_desc_next(desc); + } else { + return NULL; + } + } + return NULL; +} diff --git a/atmel-samd/asf4/samd21/usb/usb_protocol.h b/atmel-samd/asf4/samd21/usb/usb_protocol.h new file mode 100644 index 000000000..bb8d1ecd5 --- /dev/null +++ b/atmel-samd/asf4/samd21/usb/usb_protocol.h @@ -0,0 +1,765 @@ +/** + * \file + * + * \brief USB protocol definitions. + * + * This file contains the USB definitions and data structures provided by the + * USB 2.0 specification. + * + * Copyright (C) 2015 Atmel Corporation. All rights reserved. + * + * \page License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. The name of Atmel may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 4. This software may only be redistributed and used in connection with an + * Atmel AVR product. + * + * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#ifndef _USB_PROTOCOL_H_ +#define _USB_PROTOCOL_H_ + +#include "usb_includes.h" + +/** + * \ingroup usb_group + * \defgroup usb_protocol_group USB Protocol Definitions + * + * This module defines constants and data structures provided by the USB + * 2.0 specification. + * + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __CC_ARM +#pragma anon_unions +#endif + +/*! Value for field bcdUSB */ +#define USB_V2_0 (0x0200) /*!< USB Specification version 2.00 */ +#define USB_V2_1 (0x0201) /*!< USB Specification version 2.01 (support BOS) */ + +/*! \name Generic definitions (Class, subclass and protocol) + */ +/*! @{ */ +#define USB_CLASS_NO (0x00) +#define USB_SUBCLASS_NO (0x00) +#define USB_PROTOCOL_NO (0x00) +/*! @} */ + +/*! \name IAD (Interface Association Descriptor) constants */ +/*! @{ */ +#define USB_CLASS_IAD (0xEF) +#define USB_SUBCLASS_IAD (0x02) +#define USB_PROTOCOL_IAD (0x01) +/*! @} */ + +/** + * \brief USB request data transfer direction (bmRequestType) + */ +#define USB_REQT_DIR_OUT (0 << 7) /*!< Host to device */ +#define USB_REQT_DIR_H2D (0 << 7) /*!< Host to device */ +#define USB_REQT_DIR_IN (1 << 7) /*!< Device to host */ +#define USB_REQT_DIR_D2H (1 << 7) /*!< Device to host */ +#define USB_REQT_DIR_MASK (1 << 7) /*!< Mask */ + +/** + * \brief USB request types (bmRequestType) + */ +#define USB_REQT_TYPE_STANDARD (0 << 5) /*!< Standard request */ +#define USB_REQT_TYPE_CLASS (1 << 5) /*!< Class-specific request */ +#define USB_REQT_TYPE_VENDOR (2 << 5) /*!< Vendor-specific request */ +#define USB_REQT_TYPE_MASK (3 << 5) /*!< Mask */ + +/** + * \brief USB recipient codes (bmRequestType) + */ +#define USB_REQT_RECIP_DEVICE (0 << 0) /*!< Recipient device */ +#define USB_REQT_RECIP_INTERFACE (1 << 0) /*!< Recipient interface */ +#define USB_REQT_RECIP_ENDPOINT (2 << 0) /*!< Recipient endpoint */ +#define USB_REQT_RECIP_OTHER (3 << 0) /*!< Recipient other */ +#define USB_REQT_RECIP_MASK (0x1F) /*!< Mask */ + +/** + * \brief Standard USB control transfer stages. + */ +enum usb_ctrl_stage { USB_SETUP_STAGE = 0, USB_DATA_STAGE = 1, USB_STATUS_STAGE = 2 }; + +/** + * \brief Standard USB requests (bRequest) + */ +enum usb_req_code { + USB_REQ_GET_STATUS = 0, + USB_REQ_CLEAR_FTR = 1, + USB_REQ_SET_FTR = 3, + USB_REQ_SET_ADDRESS = 5, + USB_REQ_GET_DESC = 6, + USB_REQ_SET_DESC = 7, + USB_REQ_GET_CONFIG = 8, + USB_REQ_SET_CONFIG = 9, + USB_REQ_GET_INTERFACE = 10, + USB_REQ_SET_INTERFACE = 11, + USB_REQ_SYNCH_FRAME = 12, + USB_REQ_SET_SEL = 48, + USB_REQ_ISOCH_DELAY = 49 +}; + +/** + * \brief Standard USB device status flags + * + */ +enum usb_dev_status { + USB_DEV_STAT_BUS_POWERED = 0, + USB_DEV_STAT_SELF_POWERED = 1, + USB_DEV_STAT_REMOTEWAKEUP = 2, + USB_DEV_STAT_U1_ENABLE = 4, + USB_DEV_STAT_U2_ENABLE = 8, + USB_DEV_STAT_LTM_ENABLE = 16 +}; + +/** + * \brief Standard USB Interface status flags + * + */ +enum usb_interface_status { + USB_IFACE_STAT_RESERVED = 0, + USB_IFACE_STAT_REMOTEWAKE_CAP = 1, + USB_IFACE_STAT_REMOTEWAKE = 2 +}; + +/** + * \brief Standard USB endpoint status flags + * + */ +enum usb_endpoint_status { USB_EP_STAT_HALT = 1 }; + +/** + * \brief Standard USB device feature flags + * + * \note valid for SetFeature request. + */ +enum usb_device_feature { + USB_DEV_FTR_REMOTE_WAKEUP = 1, /*!< Remote wakeup enabled */ + USB_DEV_FTR_TEST_MODE = 2, /*!< USB test mode */ + USB_DEV_FTR_OTG_B_HNP_ENABLE = 3, + USB_DEV_FTR_OTG_A_HNP_SP = 4, + USB_DEV_FTR_OTG_A_ALT_HNP_SP = 5, + USB_DEV_FTR_U1_ENABLE = 48, + USB_DEV_FTR_U2_ENABLE = 49, + USB_DEV_FTR_LTM_ENABLE = 50 +}; + +/** + * \brief Test Mode possible on HS USB device + * + * \note valid for USB_DEV_FTR_TEST_MODE request. + */ +enum usb_device_hs_test_mode { + USB_DEV_TEST_MODE_J = 1, + USB_DEV_TEST_MODE_K = 2, + USB_DEV_TEST_MODE_SE0_NAK = 3, + USB_DEV_TEST_MODE_PACKET = 4, + USB_DEV_TEST_MODE_FORCE_ENABLE = 5 +}; + +/** + * \brief Standard Feature Selectors for Interface + */ +enum usb_iface_feature { USB_IFACE_FTR_FUNC_SUSP = 0 }; + +/** + * \brief Standard USB endpoint feature/status flags + */ +enum usb_endpoint_feature { USB_EP_FTR_HALT = 0 }; + +/** + * \brief Standard USB Test Mode Selectors + */ +enum usb_test_mode_selector { + USB_TEST_J = 0x01, + USB_TEST_K = 0x02, + USB_TEST_SE0_NAK = 0x03, + USB_TEST_PACKET = 0x04, + USB_TEST_FORCE_ENABLE = 0x05 +}; + +/** + * \brief Standard USB descriptor types + */ +enum usb_descriptor_type { + USB_DT_DEVICE = 1, + USB_DT_CONFIG = 2, + USB_DT_STRING = 3, + USB_DT_INTERFACE = 4, + USB_DT_ENDPOINT = 5, + USB_DT_DEVICE_QUALIFIER = 6, + USB_DT_OTHER_SPEED_CONFIG = 7, + USB_DT_INTERFACE_POWER = 8, + USB_DT_OTG = 9, + USB_DT_DEBUG = 10, + USB_DT_IAD = 11, + USB_DT_BOS = 15, + USB_DT_DEV_CAP = 16, + USB_DT_SS_EP_COMPANION = 48 +}; + +/** + * \brief Capability types + */ +enum usb_capability_type { + USB_CAPT_WIRELESS = 1, + USB_CAPT_2_0_EXT = 2, + USB_CAPT_SUPER_SPEED = 3, + USB_CAPT_CONTAINER_ID = 4 +}; + +/** + * \brief USB 2.0 Extension attributes + */ +enum usb_2_0_ext_attr { USB_2_0_EXT_LPM_SP = 1 }; + +/** + * \brief USB SuperSpeed Capability attributes + */ +enum usb_ss_cap_attr { USB_SS_LTM_SP }; + +/** + * \brief USB Speed Supports + */ +enum usb_speed_sp { + USB_SPEED_LOW_SP = 1, + USB_SPEED_LS_SP = 1, + USB_SPEED_FULL_SP = 2, + USB_SPEED_FS_SP = 2, + USB_SPEED_HIGH_SP = 4, + USB_SPEED_HS_SP = 4, + USB_SPEED_SUPER_SP = 8, + USB_SPEED_SS_SP = 8 +}; + +/** + * \brief Standard USB endpoint transfer types + */ +enum usb_ep_type { + USB_EP_TYPE_CONTROL = 0x00, + USB_EP_TYPE_ISOCHRONOUS = 0x01, + USB_EP_TYPE_BULK = 0x02, + USB_EP_TYPE_INTERRUPT = 0x03, + USB_EP_TYPE_MASK = 0x03u +}; + +/** + * \brief USB endpoint interrupt types + */ +enum usb_ep_int_type { USB_EP_INT_T_PERIODIC = 0x00u, USB_EP_INT_T_NOTIFICATION = 0x01u, USB_EP_INT_T_MASK = 0x03u }; + +/** + * \brief Standard USB endpoint synchronization types + */ +enum usb_ep_sync_type { + USB_EP_SYNC_T_NO = 0x00u, + USB_EP_SYNC_T_ASYNC = 0x02u, + USB_EP_SYNC_T_ADAPTIVE = 0x02u, + USB_EP_SYNC_T_SYNC = 0x03u, + USB_EP_SYNC_T_MASK = 0x03u +}; + +/** + * \brief Standard USB endpoint usage types + */ +enum usb_ep_usage_type { + USB_EP_USAGE_T_DATA = 0x00u, + USB_EP_USAGE_T_FEEDBACK = 0x01u, + USB_EP_USAGE_T_FEEDBACK_DATA = 0x02u, + USB_EP_USAGE_T_MASK = 0x03u +}; + +/** + * \brief Standard USB language IDs for string descriptors + */ +enum usb_langid { + USB_LANGID_EN_US = 0x0409 /*!< English (United States) */ +}; + +/** + * \brief Mask selecting the index part of an endpoint address + */ +#define USB_EP_ADDR_MASK 0x0f +/** + * \brief Endpoint transfer direction is IN + */ +#define USB_EP_DIR_IN 0x80 +/** + * \brief Endpoint transfer direction is OUT + */ +#define USB_EP_DIR_OUT 0x00 + +/** + * \brief Maximum length in bytes of a USB descriptor + * + * The maximum length of a USB descriptor is limited by the 8-bit + * bLength field. + */ +#define USB_DESC_LEN_MAX 255 + +/* + * 2-byte alignment requested for all USB structures. + */ +COMPILER_PACK_SET(1) + +/** + * \brief A USB Device SETUP request + * + * The data payload of SETUP packets always follows this structure. + */ +typedef struct usb_req { + uint8_t bmRequestType; + uint8_t bRequest; + union { + le16_t wValue; + struct { + uint8_t l; + uint8_t h; + } wValueBytes; + }; + union { + le16_t wIndex; + struct { + uint8_t l; + uint8_t h; + } wIndexBytes; + }; + union { + le16_t wLength; + struct { + uint8_t l; + uint8_t h; + } wLengthBytes; + }; +} usb_req_t; + +/** + * \brief Standard USB device descriptor structure + */ +typedef struct usb_dev_desc { + uint8_t bLength; + uint8_t bDescriptorType; + le16_t bcdUSB; + uint8_t bDeviceClass; + uint8_t bDeviceSubClass; + uint8_t bDeviceProtocol; + uint8_t bMaxPacketSize0; + le16_t idVendor; + le16_t idProduct; + le16_t bcdDevice; + uint8_t iManufacturer; + uint8_t iProduct; + uint8_t iSerialNumber; + uint8_t bNumConfigurations; +} usb_dev_desc_t; + +/** + * \brief Binary device Object Store (BOS) descriptor structure + */ +typedef struct usb_bos_desc { + uint8_t bLength; + uint8_t bDescriptorType; + le16_t wTotalLength; + uint8_t bNumDeviceCaps; +} usb_bos_desc_t; + +/** + * \brief Device Capability Descriptor structure + */ +typedef struct usb_cap_desc { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bDevCapabilityType; + uint8_t Vars[1]; +} usb_cap_desc_t; + +/** + * \brief USB 2.0 Extension Descriptor structure + */ +typedef struct usb_2_0_ext { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bDevCapabilityType; + uint32_t bmAttributes; +} usb_2_0_ext_t; + +/** + * \brief LPM Device Capabilities descriptor structure + */ +typedef struct usb_2_0_ext usb_lpm_cap_desc_t; + +/** + * \brief SuperSpeed USB Device Capability structure + */ +typedef struct usb_ss_cap_desc { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bDevCapabilityType; + uint8_t bmAttributes; + le16_t wSpeedsSupported; + uint8_t bFunctionalitySupport; + uint8_t bU1DevExitLat; + uint8_t bU2DevExitLat; +} usb_ss_cap_desc_t; + +/** + * \brief USB Container ID Descriptor structure + */ +typedef struct usb_container_id_desc { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bDevCapabilityType; + uint8_t bReserved; + uint8_t ContainerID[16]; +} usb_container_id_desc_t; + +/** + * \brief Standard USB device qualifier descriptor structure + * + * This descriptor contains information about the device when running at + * the "other" speed (i.e. if the device is currently operating at high + * speed, this descriptor can be used to determine what would change if + * the device was operating at full speed.) + */ +typedef struct usb_dev_qual_desc { + uint8_t bLength; + uint8_t bDescriptorType; + le16_t bcdUSB; + uint8_t bDeviceClass; + uint8_t bDeviceSubClass; + uint8_t bDeviceProtocol; + uint8_t bMaxPacketSize0; + uint8_t bNumConfigurations; + uint8_t bReserved; +} usb_dev_qual_desc_t; + +/** + * \brief Standard USB configuration descriptor structure + */ +typedef struct usb_config_desc { + uint8_t bLength; + uint8_t bDescriptorType; + le16_t wTotalLength; + uint8_t bNumInterfaces; + uint8_t bConfigurationValue; + uint8_t iConfiguration; + uint8_t bmAttributes; + uint8_t bMaxPower; +} usb_config_desc_t; + +#define USB_CONFIG_ATTR_MUST_SET (1 << 7) /*!< Must always be set */ +#define USB_CONFIG_ATTR_BUS_POWERED (0 << 6) /*!< Bus-powered */ +#define USB_CONFIG_ATTR_SELF_POWERED (1 << 6) /*!< Self-powered */ +#define USB_CONFIG_ATTR_REMOTE_WAKEUP (1 << 5) /*!< remote wakeup supported */ + +#define USB_CONFIG_MAX_POWER(ma) (((ma) + 1) / 2) /*!< Max power in mA */ + +/** + * \brief Standard USB association descriptor structure + */ +typedef struct usb_iad_desc { + uint8_t bLength; /*!< Size of this descriptor in bytes */ + uint8_t bDescriptorType; /*!< Interface descriptor type */ + uint8_t bFirstInterface; /*!< Number of interface */ + uint8_t bInterfaceCount; /*!< value to select alternate setting */ + uint8_t bFunctionClass; /*!< Class code assigned by the USB */ + uint8_t bFunctionSubClass; /*!< Sub-class code assigned by the USB */ + uint8_t bFunctionProtocol; /*!< Protocol code assigned by the USB */ + uint8_t iFunction; /*!< Index of string descriptor */ +} usb_iad_desc_t; + +/** + * \brief Standard USB interface descriptor structure + */ +typedef struct usb_iface_desc { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bInterfaceNumber; + uint8_t bAlternateSetting; + uint8_t bNumEndpoints; + uint8_t bInterfaceClass; + uint8_t bInterfaceSubClass; + uint8_t bInterfaceProtocol; + uint8_t iInterface; +} usb_iface_desc_t; + +/** + * \brief Standard USB endpoint descriptor structure + */ +typedef struct usb_ep_desc { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bEndpointAddress; + uint8_t bmAttributes; + le16_t wMaxPacketSize; + uint8_t bInterval; +} usb_ep_desc_t; + +/** + * \brief SuperSpeed Endpoint Companion descriptor structure + */ +typedef struct usb_ss_ep_comp_desc { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bMaxBurst; + uint8_t bmAttributes; + le16_t wBytesPerInterval; +} usb_ss_ep_comp_desc_t; + +/** + * \brief LPM Token bmAttributes structure + */ +typedef struct usb_lpm_attributes { + uint8_t bLinkState : 4; + uint8_t HIRD : 4; + uint8_t bRemoteWake : 1; + uint8_t Reserved : 2; +} usb_lpm_attributes_t; + +/** + * \brief A standard USB string descriptor structure + */ +typedef struct usb_str_desc { + uint8_t bLength; + uint8_t bDescriptorType; +} usb_str_desc_t; + +typedef struct usb_str_langid_desc { + usb_str_desc_t desc; + le16_t string[1]; +} usb_str_langid_desc_t; + +COMPILER_PACK_RESET() + +/** \name Macros to build USB standard descriptors */ +/*@{*/ + +/** Build bytes for USB device descriptor. */ +#define USB_DEV_DESC_BYTES(bcdUSB, \ + bDeviceClass, \ + bDeviceSubClass, \ + bDeviceProtocol, \ + bMaxPacketSize0, \ + idVendor, \ + idProduct, \ + bcdDevice, \ + iManufacturer, \ + iProduct, \ + iSerialNumber, \ + bNumConfigurations) \ + 18, /* bLength */ \ + 0x01, /* bDescriptorType: DEVICE */ \ + LE_BYTE0(bcdUSB), LE_BYTE1(bcdUSB), bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0, \ + LE_BYTE0(idVendor), LE_BYTE1(idVendor), LE_BYTE0(idProduct), LE_BYTE1(idProduct), LE_BYTE0(bcdDevice), \ + LE_BYTE1(bcdDevice), iManufacturer, iProduct, iSerialNumber, bNumConfigurations + +#define USB_DEV_DESC_LEN 18 + +/** Build bytes for USB configuration descriptor. */ +#define USB_CONFIG_DESC_BYTES( \ + wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration, bmAttributes, bMaxPower) \ + 9, /* bLength */ \ + 0x02, /* bDescriptorType: CONFIGURATION */ \ + LE_BYTE0(wTotalLength), LE_BYTE1(wTotalLength), bNumInterfaces, bConfigurationValue, iConfiguration, \ + bmAttributes, bMaxPower + +#define USB_CONFIG_DESC_LEN 9 + +/** Build bytes for USB IAD descriptor. */ +#define USB_IAD_DESC_BYTES( \ + bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass, bFunctionProtocol, iFunction) \ + 8, /* bLength */ \ + USB_DT_IAD, /* bDescriptorType */ \ + bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass, bFunctionProtocol, iFunction + +#define USB_IAD_DESC_LEN 8 + +/** Build bytes for USB interface descriptor. */ +#define USB_IFACE_DESC_BYTES(bInterfaceNumber, \ + bAlternateSetting, \ + bNumEndpoints, \ + bInterfaceClass, \ + bInterfaceSubClass, \ + bInterfaceProtocol, \ + iInterface) \ + 9, /* bLength */ \ + 0x04, /* bDescriptorType: INTERFACE */ \ + bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass, bInterfaceSubClass, bInterfaceProtocol, \ + iInterface + +#define USB_IFACE_DESC_LEN 9 + +/** Build bytes for USB endpoint descriptor. */ +#define USB_ENDP_DESC_BYTES(bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval) \ + 7, /* bLength */ \ + 0x05, /* bDescriptorType: ENDPOINT */ \ + bEndpointAddress, bmAttributes, LE_BYTE0(wMaxPacketSize), LE_BYTE1(wMaxPacketSize), bInterval + +#define USB_ENDP_DESC_LEN 7 + +/*@}*/ + +/** \brief Get a word (calculate by little endian 16-bit data) + * \param[in] ptr Byte pointer to the address to get data + * \return a 16-bit word + */ +static inline uint16_t usb_get_u16(const uint8_t *ptr) +{ + return (ptr[0] + (ptr[1] << 8)); +} + +/** \brief Get a double word (calculate by little endian 32-bit data) + * \param[in] ptr Byte pointer to the address to get data + * \return a 32-bit word + */ +static inline uint32_t usb_get_u32(const uint8_t *ptr) +{ + return (ptr[0] + (ptr[1] << 8) + (ptr[2] << 16) + (ptr[3] << 24)); +} + +/** \brief Get descriptor length + * \param[in] desc Byte pointer to the descriptor start address + * \return descriptor length + */ +static inline uint8_t usb_desc_len(const uint8_t *desc) +{ + return desc[0]; +} + +/** \brief Get descriptor type + * \param[in] desc Byte pointer to the descriptor start address + * \return descriptor type + */ +static inline uint8_t usb_desc_type(const uint8_t *desc) +{ + return desc[1]; +} + +/** \brief Get next USB descriptor + * \param[in] desc Byte pointer to the descriptor start address + * \return Byte pointer to the next descriptor + */ +static inline uint8_t *usb_desc_next(uint8_t *desc) +{ + return (desc + usb_desc_len(desc)); +} + +/** \brief Get idVendor of USB Device Descriptor + * \param[in] dev_desc Byte pointer to the descriptor start address + * \return 16-bit idVendor value + */ +static inline uint16_t usb_dev_desc_vid(const uint8_t *dev_desc) +{ + return usb_get_u16(dev_desc + 8); +} + +/** \brief Get idProduct of USB Device Descriptor + * \param[in] dev_desc Byte pointer to the descriptor start address + * \return 16-bit idProduct value + */ +static inline uint16_t usb_dev_desc_pid(const uint8_t *dev_desc) +{ + return usb_get_u16(dev_desc + 10); +} + +/** \brief Get wTotalLength of USB Configuration Descriptor + * \param[in] cfg_desc Byte pointer to the descriptor start address + * \return 16-bit total length of configuration list + */ +static inline uint16_t usb_cfg_desc_total_len(const uint8_t *cfg_desc) +{ + return usb_get_u16(cfg_desc + 2); +} + +/** \brief Get Next USB Descriptor After the Configuration Descriptors list + * \param[in] cfg_desc Byte pointer to the descriptor start address + * \return Byte pointer to descriptor after configuration end + */ +static inline uint8_t *usb_cfg_desc_next(uint8_t *cfg_desc) +{ + return (cfg_desc + usb_cfg_desc_total_len(cfg_desc)); +} + +/** \brief Find specific USB Descriptor by its type + * \param[in] desc Byte pointer to the descriptor start address + * \param[in] eof Byte pointer to the descriptor end address + * \param[in] type The descriptor type expected + * \return Pointer to the descriptor + * \retval NULL if not found + */ +uint8_t *usb_find_desc(uint8_t *desc, uint8_t *eof, uint8_t type); + +/** Get interface descriptor next to the specified one (by interface number) + * \param[in] desc Byte pointer to the descriptor start address + * \param[in] eof Byte pointer to the descriptor end address + * \param[in] iface_n The interface number to check + * \return Pointer to the descriptor + * \retval >= eof if not found + */ +uint8_t *usb_find_iface_after(uint8_t *desc, uint8_t *eof, uint8_t iface_n); + +/** Find endpoint descriptor, breaks if interface descriptor detected + * \param[in] desc Byte pointer to the descriptor start address + * \param[in] eof Byte pointer to the descriptor end address + * \return Pointer to the descriptor + * \retval NULL if not found + */ +uint8_t *usb_find_ep_desc(uint8_t *desc, uint8_t *eof); + +/** Find configuration descriptor by its configuration number + * \param[in] desc Byte pointer to the descriptor start address + * \param[in] eof Byte pointer to the descriptor end address + * \param[in] cfg_value The configure value expected + * \return Pointer to the descriptor + * \retval NULL if not found + */ +uint8_t *usb_find_cfg_desc(uint8_t *desc, uint8_t *eof, uint8_t cfg_value); + +/** Find string descriptor by its index + * \param[in] desc Byte pointer to the descriptor start address + * \param[in] eof Byte pointer to the descriptor end address + * \param[in] str_index The string index expected + * \return Pointer to the descriptor + * \retval NULL if not found + */ +uint8_t *usb_find_str_desc(uint8_t *desc, uint8_t *eof, uint8_t str_index); + +#ifdef __cplusplus +} +#endif + +/*! @} */ + +#endif /* _USB_PROTOCOL_H_ */ |