| // Copyright 2022 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 <lib/fit/defer.h> |
| #include <zircon/errors.h> |
| |
| #include "fuchsia/hardware/usb/descriptor/c/banjo.h" |
| #include "usb/usb.h" |
| |
| namespace usb_cdc_ecm { |
| |
| zx::result<MacAddress> UsbCdcDescriptorParser::ParseMacAddress( |
| usb::UsbDevice& usb, const usb_cs_ethernet_interface_descriptor_t* desc) { |
| // Read string descriptor for MAC address (string index is in iMACAddress field) |
| size_t out_length; |
| uint8_t str_desc_buf[kExpectedStringSize]; |
| zx_status_t status = usb.GetDescriptor(0, USB_DT_STRING, desc->iMACAddress, str_desc_buf, |
| sizeof(str_desc_buf), ZX_TIME_INFINITE, &out_length); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Error reading MAC address"); |
| return zx::error(status); |
| } |
| if (out_length != kExpectedStringSize) { |
| zxlogf(ERROR, "MAC address string incorrect length (saw %zd, expected %zd)", out_length, |
| kExpectedStringSize); |
| return zx::error(ZX_ERR_IO); |
| } |
| |
| // Convert MAC address to something more machine-friendly |
| auto str_desc = reinterpret_cast<usb_string_descriptor_t*>(str_desc_buf); |
| uint8_t* str = str_desc->b_string; |
| size_t ndx; |
| MacAddress mac_addr; |
| for (ndx = 0; ndx < ETH_MAC_SIZE * 4; ndx++) { |
| if (ndx % 2 == 1) { |
| if (str[ndx] != 0) { |
| zxlogf(ERROR, "MAC address contains invalid characters"); |
| return zx::error(ZX_ERR_IO); |
| } |
| 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, "MAC address contains invalid characters"); |
| return zx::error(ZX_ERR_IO); |
| } |
| if (ndx % 4 == 0) { |
| mac_addr[ndx / 4] = (uint8_t)(value << 4); |
| } else { |
| mac_addr[ndx / 4] |= value; |
| } |
| } |
| |
| zxlogf(INFO, "MAC address is %02X:%02X:%02X:%02X:%02X:%02X", mac_addr[0], mac_addr[1], |
| mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); |
| return zx::ok(mac_addr); |
| } |
| |
| zx::result<UsbCdcDescriptorParser> UsbCdcDescriptorParser::Parse(usb::UsbDevice& usb) { |
| std::optional<usb::InterfaceList> interfaces; |
| zx_status_t status = usb::InterfaceList::Create(usb, false, &interfaces); |
| if (status != ZX_OK) { |
| return zx::error(status); |
| } |
| |
| std::optional<EcmEndpoint> int_ep; |
| std::optional<EcmEndpoint> tx_ep; |
| std::optional<EcmEndpoint> rx_ep; |
| std::optional<EcmInterface> default_ifc; |
| std::optional<EcmInterface> data_ifc; |
| |
| // Find default interface. |
| for (const usb::Interface& interface : *interfaces) { |
| const usb_interface_descriptor_t* desc = interface.descriptor(); |
| if (desc->b_interface_class != USB_CLASS_CDC) { |
| continue; |
| } |
| if (desc->b_num_endpoints != 0) { |
| continue; |
| } |
| if (default_ifc.has_value()) { |
| zxlogf(ERROR, "Multiple default interfaces found"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| default_ifc = EcmInterface(desc); |
| } |
| |
| // Find data interface. |
| for (const usb::Interface& interface : *interfaces) { |
| const usb_interface_descriptor_t* desc = interface.descriptor(); |
| if (desc->b_interface_class != USB_CLASS_CDC) { |
| continue; |
| } |
| if (desc->b_num_endpoints != 2) { |
| continue; |
| } |
| if (data_ifc.has_value()) { |
| zxlogf(ERROR, "Multiple data interfaces found"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| data_ifc = EcmInterface(desc); |
| |
| for (const auto& endpoint : interface.GetEndpointList()) { |
| const usb_endpoint_descriptor_t* endpoint_desc = endpoint.descriptor(); |
| if (usb_ep_direction(endpoint_desc) == USB_ENDPOINT_OUT && |
| usb_ep_type(endpoint_desc) == USB_ENDPOINT_BULK) { |
| if (tx_ep.has_value()) { |
| zxlogf(ERROR, "Multiple tx endpoint descriptors"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| tx_ep = EcmEndpoint(endpoint_desc); |
| } else if (usb_ep_direction(endpoint_desc) == USB_ENDPOINT_IN && |
| usb_ep_type(endpoint_desc) == USB_ENDPOINT_BULK) { |
| if (rx_ep.has_value()) { |
| zxlogf(ERROR, "Multiple rx endpoint descriptors"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| rx_ep = EcmEndpoint(endpoint_desc); |
| } else { |
| zxlogf(ERROR, "Unrecognized endpoint"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| } |
| } |
| |
| // Find communications interface, which has CDC headers and interrupt endpoint. |
| const usb_cs_header_interface_descriptor_t* cdc_header_desc = nullptr; |
| const usb_cs_ethernet_interface_descriptor_t* cdc_eth_desc = nullptr; |
| for (const usb::Interface& interface : *interfaces) { |
| if (interface.descriptor()->b_interface_class != USB_CLASS_COMM) { |
| continue; |
| } |
| |
| for (auto& descriptor : interface.GetDescriptorList()) { |
| if (descriptor.b_descriptor_type != USB_DT_CS_INTERFACE) { |
| continue; |
| } |
| if (descriptor.b_length < sizeof(usb_cs_interface_descriptor_t)) { |
| zxlogf(WARNING, "Malformed class specific descriptor"); |
| continue; |
| } |
| |
| const usb_cs_interface_descriptor_t* cs_ifc_desc = |
| reinterpret_cast<const usb_cs_interface_descriptor_t*>(&descriptor); |
| |
| if (cs_ifc_desc->b_descriptor_sub_type == USB_CDC_DST_HEADER) { |
| if (cdc_header_desc != nullptr) { |
| zxlogf(ERROR, "Multiple CDC headers"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| if (descriptor.b_length < sizeof(usb_cs_header_interface_descriptor_t)) { |
| zxlogf(WARNING, "Malformed CDC header descriptor"); |
| continue; |
| } |
| cdc_header_desc = |
| reinterpret_cast<const usb_cs_header_interface_descriptor_t*>(&descriptor); |
| } else if (cs_ifc_desc->b_descriptor_sub_type == USB_CDC_DST_ETHERNET) { |
| if (cdc_eth_desc != nullptr) { |
| zxlogf(ERROR, "Multiple CDC ethernet descriptors"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| if (descriptor.b_length < sizeof(usb_cs_ethernet_interface_descriptor_t)) { |
| zxlogf(WARNING, "Malformed CDC ethernet descriptor"); |
| continue; |
| } |
| cdc_eth_desc = reinterpret_cast<const usb_cs_ethernet_interface_descriptor_t*>(&descriptor); |
| } |
| } |
| |
| for (const auto& endpoint : interface.GetEndpointList()) { |
| const usb_endpoint_descriptor_t* endpoint_desc = endpoint.descriptor(); |
| if (usb_ep_direction(endpoint_desc) == USB_ENDPOINT_IN && |
| usb_ep_type(endpoint_desc) == USB_ENDPOINT_INTERRUPT) { |
| if (int_ep.has_value()) { |
| zxlogf(ERROR, "Multiple interrupt endpoint descriptors"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| int_ep = EcmEndpoint(endpoint_desc); |
| } |
| } |
| } |
| |
| if (cdc_header_desc == nullptr || cdc_eth_desc == nullptr) { |
| zxlogf(ERROR, "CDC %s descriptor(s) not found", |
| cdc_header_desc ? "ethernet" |
| : cdc_eth_desc ? "header" |
| : "ethernet and header"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| if (!int_ep.has_value() || !tx_ep.has_value() || !rx_ep.has_value()) { |
| zxlogf(ERROR, "Missing one or more required endpoints"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| if (!default_ifc.has_value()) { |
| zxlogf(ERROR, "Unable to find CDC default interface"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| if (!data_ifc.has_value()) { |
| zxlogf(ERROR, "Unable to find CDC data interface"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| |
| // Parse the information in the CDC descriptors |
| zxlogf(DEBUG, "Device reports CDC version as 0x%x", cdc_header_desc->bcdCDC); |
| if (cdc_header_desc->bcdCDC < kCdcSupportedVersion) { |
| zxlogf(ERROR, "Unable to parse cdc header"); |
| return zx::error(ZX_ERR_NOT_SUPPORTED); |
| } |
| |
| const uint16_t mtu = cdc_eth_desc->wMaxSegmentSize; |
| |
| auto mac_addr = UsbCdcDescriptorParser::ParseMacAddress(usb, cdc_eth_desc); |
| if (mac_addr.is_error()) { |
| zxlogf(ERROR, "Unable to parse cdc ethernet descriptor"); |
| return mac_addr.take_error(); |
| } |
| |
| return zx::ok(UsbCdcDescriptorParser(int_ep.value(), tx_ep.value(), rx_ep.value(), |
| default_ifc.value(), data_ifc.value(), mtu, |
| mac_addr.value())); |
| } |
| |
| } // namespace usb_cdc_ecm |
