| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "usb-cdc-ecm-lib.h" |
| |
| #include <usb/usb.h> |
| |
| const char* module_name = "usb-cdc-ecm"; |
| |
| static bool parse_cdc_header(usb_cs_header_interface_descriptor_t* header_desc) { |
| // Check for supported CDC version |
| zxlogf(DEBUG, "%s: device reports CDC version as 0x%x", module_name, header_desc->bcdCDC); |
| return header_desc->bcdCDC >= CDC_SUPPORTED_VERSION; |
| } |
| |
| static bool parse_cdc_ethernet_descriptor(ecm_ctx_t* ctx, |
| usb_cs_ethernet_interface_descriptor_t* desc) { |
| ctx->mtu = desc->wMaxSegmentSize; |
| |
| // MAC address is stored in a string descriptor in UTF-16 format, so we get one byte of |
| // address for each 32 bits of text. |
| const size_t expected_str_size = sizeof(usb_string_descriptor_t) + ETH_MAC_SIZE * 4; |
| char str_desc_buf[expected_str_size]; |
| |
| // Read string descriptor for MAC address (string index is in iMACAddress field) |
| size_t out_length; |
| zx_status_t result = |
| usb_get_descriptor(&ctx->usb, 0, USB_DT_STRING, desc->iMACAddress, (uint8_t*)str_desc_buf, |
| sizeof(str_desc_buf), ZX_TIME_INFINITE, &out_length); |
| if (result < 0) { |
| zxlogf(ERROR, "%s: error reading MAC address", module_name); |
| return false; |
| } |
| if (out_length != expected_str_size) { |
| zxlogf(ERROR, "%s: MAC address string incorrect length (saw %zd, expected %zd)", module_name, |
| out_length, expected_str_size); |
| return false; |
| } |
| |
| // Convert MAC address to something more machine-friendly |
| usb_string_descriptor_t* str_desc = (usb_string_descriptor_t*)str_desc_buf; |
| uint8_t* str = str_desc->bString; |
| size_t ndx; |
| for (ndx = 0; ndx < ETH_MAC_SIZE * 4; ndx++) { |
| if (ndx % 2 == 1) { |
| if (str[ndx] != 0) { |
| zxlogf(ERROR, "%s: MAC address contains invalid characters", module_name); |
| return false; |
| } |
| continue; |
| } |
| uint8_t value; |
| if (str[ndx] >= '0' && str[ndx] <= '9') { |
| value = str[ndx] - '0'; |
| } else if (str[ndx] >= 'A' && str[ndx] <= 'F') { |
| value = (str[ndx] - 'A') + 0xa; |
| } else { |
| zxlogf(ERROR, "%s: MAC address contains invalid characters", module_name); |
| return false; |
| } |
| if (ndx % 4 == 0) { |
| ctx->mac_addr[ndx / 4] = (uint8_t)(value << 4); |
| } else { |
| ctx->mac_addr[ndx / 4] |= value; |
| } |
| } |
| |
| zxlogf(INFO, "%s: MAC address is %02X:%02X:%02X:%02X:%02X:%02X", module_name, ctx->mac_addr[0], |
| ctx->mac_addr[1], ctx->mac_addr[2], ctx->mac_addr[3], ctx->mac_addr[4], ctx->mac_addr[5]); |
| return true; |
| } |
| |
| zx_status_t parse_usb_descriptor(usb_desc_iter_t* iter, usb_endpoint_descriptor_t** int_ep, |
| usb_endpoint_descriptor_t** tx_ep, |
| usb_endpoint_descriptor_t** rx_ep, |
| usb_interface_descriptor_t** default_ifc, |
| usb_interface_descriptor_t** data_ifc, ecm_ctx_t* ecm_ctx) { |
| zx_status_t result = ZX_ERR_NOT_SUPPORTED; |
| usb_descriptor_header_t* desc; |
| usb_cs_header_interface_descriptor_t* cdc_header_desc = NULL; |
| usb_cs_ethernet_interface_descriptor_t* cdc_eth_desc = NULL; |
| *int_ep = NULL; |
| *tx_ep = NULL; |
| *rx_ep = NULL; |
| *default_ifc = NULL; |
| *data_ifc = NULL; |
| while ((desc = usb_desc_iter_peek(iter)) != NULL) { |
| if (desc->bDescriptorType == USB_DT_INTERFACE) { |
| usb_interface_descriptor_t* ifc_desc = |
| usb_desc_iter_get_structure(iter, sizeof(usb_interface_descriptor_t)); |
| if (ifc_desc == NULL) { |
| goto fail; |
| } |
| if (ifc_desc->b_interface_class == USB_CLASS_CDC) { |
| if (ifc_desc->b_num_endpoints == 0) { |
| if (*default_ifc) { |
| zxlogf(ERROR, "%s: multiple default interfaces found", module_name); |
| goto fail; |
| } |
| *default_ifc = ifc_desc; |
| } else if (ifc_desc->b_num_endpoints == 2) { |
| if (*data_ifc) { |
| zxlogf(ERROR, "%s: multiple data interfaces found", module_name); |
| goto fail; |
| } |
| *data_ifc = ifc_desc; |
| } |
| } |
| } else if (desc->bDescriptorType == USB_DT_CS_INTERFACE) { |
| usb_cs_interface_descriptor_t* cs_ifc_desc = |
| usb_desc_iter_get_structure(iter, sizeof(usb_cs_interface_descriptor_t)); |
| if (cs_ifc_desc == NULL) { |
| goto fail; |
| } |
| if (cs_ifc_desc->bDescriptorSubType == USB_CDC_DST_HEADER) { |
| if (cdc_header_desc != NULL) { |
| zxlogf(ERROR, "%s: multiple CDC headers", module_name); |
| goto fail; |
| } |
| cdc_header_desc = |
| usb_desc_iter_get_structure(iter, sizeof(usb_cs_header_interface_descriptor_t)); |
| } else if (cs_ifc_desc->bDescriptorSubType == USB_CDC_DST_ETHERNET) { |
| if (cdc_eth_desc != NULL) { |
| zxlogf(ERROR, "%s: multiple CDC ethernet descriptors", module_name); |
| goto fail; |
| } |
| cdc_eth_desc = |
| usb_desc_iter_get_structure(iter, sizeof(usb_cs_ethernet_interface_descriptor_t)); |
| } |
| } else if (desc->bDescriptorType == USB_DT_ENDPOINT) { |
| usb_endpoint_descriptor_t* endpoint_desc = |
| usb_desc_iter_get_structure(iter, sizeof(usb_endpoint_descriptor_t)); |
| if (endpoint_desc == NULL) { |
| goto fail; |
| } |
| if (usb_ep_direction(endpoint_desc) == USB_ENDPOINT_IN && |
| usb_ep_type(endpoint_desc) == USB_ENDPOINT_INTERRUPT) { |
| if (*int_ep != NULL) { |
| zxlogf(ERROR, "%s: multiple interrupt endpoint descriptors", module_name); |
| goto fail; |
| } |
| *int_ep = endpoint_desc; |
| } else if (usb_ep_direction(endpoint_desc) == USB_ENDPOINT_OUT && |
| usb_ep_type(endpoint_desc) == USB_ENDPOINT_BULK) { |
| if (*tx_ep != NULL) { |
| zxlogf(ERROR, "%s: multiple tx endpoint descriptors", module_name); |
| goto fail; |
| } |
| *tx_ep = endpoint_desc; |
| } else if (usb_ep_direction(endpoint_desc) == USB_ENDPOINT_IN && |
| usb_ep_type(endpoint_desc) == USB_ENDPOINT_BULK) { |
| if (*rx_ep != NULL) { |
| zxlogf(ERROR, "%s: multiple rx endpoint descriptors", module_name); |
| goto fail; |
| } |
| *rx_ep = endpoint_desc; |
| } else { |
| zxlogf(ERROR, "%s: unrecognized endpoint", module_name); |
| goto fail; |
| } |
| } |
| usb_desc_iter_advance(iter); |
| } |
| if (cdc_header_desc == NULL || cdc_eth_desc == NULL) { |
| zxlogf(ERROR, "%s: CDC %s descriptor(s) not found", module_name, |
| cdc_header_desc ? "ethernet" |
| : cdc_eth_desc ? "header" |
| : "ethernet and header"); |
| goto fail; |
| } |
| if (*int_ep == NULL || *tx_ep == NULL || *rx_ep == NULL) { |
| zxlogf(ERROR, "%s: missing one or more required endpoints", module_name); |
| goto fail; |
| } |
| if (*default_ifc == NULL) { |
| zxlogf(ERROR, "%s: unable to find CDC default interface", module_name); |
| goto fail; |
| } |
| if (*data_ifc == NULL) { |
| zxlogf(ERROR, "%s: unable to find CDC data interface", module_name); |
| goto fail; |
| } |
| |
| // Parse the information in the CDC descriptors |
| if (!parse_cdc_header(cdc_header_desc)) { |
| zxlogf(ERROR, "%s: unable to parse cdc header", module_name); |
| goto fail; |
| } |
| if (!parse_cdc_ethernet_descriptor(ecm_ctx, cdc_eth_desc)) { |
| zxlogf(ERROR, "%s: unable to parse cdc ethernet descriptor", module_name); |
| goto fail; |
| } |
| result = ZX_OK; |
| fail: |
| return result; |
| } |
