| // Copyright 2017 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 "src/connectivity/ethernet/drivers/usb-cdc-function/usb-cdc-function.h" | |
| #include <endian.h> | |
| #include <fidl/fuchsia.boot.metadata/cpp/fidl.h> | |
| #include <fidl/fuchsia.hardware.network/cpp/wire.h> | |
| #include <fidl/fuchsia.hardware.usb.endpoint/cpp/fidl.h> | |
| #include <fidl/fuchsia.hardware.usb.function/cpp/fidl.h> | |
| #include <lib/async/cpp/task.h> | |
| #include <lib/driver/compat/cpp/banjo_client.h> | |
| #include <lib/driver/component/cpp/driver_export2.h> | |
| #include <lib/driver/component/cpp/node_add_args.h> | |
| #include <lib/driver/metadata/cpp/metadata_server.h> | |
| #include <lib/fdf/cpp/dispatcher.h> | |
| #include <lib/fit/defer.h> | |
| #include <lib/trace/event.h> | |
| #include <cstdint> | |
| #include <cstring> | |
| #include <vector> | |
| #include <usb-endpoint/usb-endpoint-client.h> | |
| #include <usb/descriptors.h> | |
| #include <usb/request-fidl.h> | |
| namespace usb_cdc_function { | |
| namespace fendpoint = fuchsia_hardware_usb_endpoint; | |
| namespace ffunction = fuchsia_hardware_usb_function; | |
| namespace frequest = fuchsia_hardware_usb_request; | |
| namespace fdescriptor = fuchsia_hardware_usb_descriptor; | |
| namespace { | |
| // Returns true if the given FIDL error represents an expected transport teardown or | |
| // disconnection status (such as peer closure, cancellation, or device unplug) during | |
| // driver shutdown. | |
| // | |
| // Generically handles: | |
| // 1. Methods without domain errors (where error_value() is fidl::Error with .status()). | |
| // 2. Methods with domain errors (where error_value() is fidl::ErrorsIn<Method> with | |
| // .is_framework_error() and .is_domain_error()). | |
| // 3. Raw zx_status_t integer status codes. | |
| template <typename ErrorType> | |
| bool IsExpectedFidlDisconnect(const ErrorType &error) { | |
| constexpr auto is_disconnect_status = [](zx_status_t status) { | |
| return status == ZX_ERR_PEER_CLOSED || status == ZX_ERR_CANCELED || | |
| status == ZX_ERR_IO_NOT_PRESENT; | |
| }; | |
| if constexpr (requires { | |
| error.is_framework_error(); | |
| error.framework_error().status(); | |
| error.is_domain_error(); | |
| error.domain_error(); | |
| }) { | |
| if (error.is_framework_error()) { | |
| return is_disconnect_status(error.framework_error().status()); | |
| } | |
| if (error.is_domain_error()) { | |
| return is_disconnect_status(error.domain_error()); | |
| } | |
| return false; | |
| } else if constexpr (requires { | |
| error.is_framework_error(); | |
| error.framework_error().status(); | |
| }) { | |
| if (error.is_framework_error()) { | |
| return is_disconnect_status(error.framework_error().status()); | |
| } | |
| return false; | |
| } else if constexpr (requires { | |
| error.is_domain_error(); | |
| error.domain_error(); | |
| }) { | |
| if (error.is_domain_error()) { | |
| return is_disconnect_status(error.domain_error()); | |
| } | |
| return false; | |
| } else if constexpr (requires { error.status(); }) { | |
| return is_disconnect_status(error.status()); | |
| } else if constexpr (std::is_integral_v<ErrorType>) { | |
| return is_disconnect_status(error); | |
| } else { | |
| return false; | |
| } | |
| } | |
| } // namespace | |
| zx_status_t UsbCdcFunction::cdc_generate_mac_address() { | |
| zx::result result = | |
| fdf_metadata::GetMetadataIfExists<fuchsia_boot_metadata::MacAddressMetadata>(incoming()); | |
| if (result.is_error()) { | |
| fdf::error("Failed to get MAC address metadata: {}", result); | |
| return result.status_value(); | |
| } | |
| if (result.value().has_value()) { | |
| const auto &metadata = result.value().value(); | |
| if (!metadata.mac_address().has_value()) { | |
| fdf::error("MAC address metadata missing mac_address field"); | |
| return ZX_ERR_INTERNAL; | |
| } | |
| mac_addr_ = metadata.mac_address().value().octets(); | |
| } else { | |
| fdf::info("ethernet MAC metadata not found. Generating random address"); | |
| zx_cprng_draw(mac_addr_.data(), mac_addr_.size()); | |
| mac_addr_[0] = (mac_addr_[0] & 0xFC) | 0x02; | |
| } | |
| char buffer[sizeof(mac_addr_) * 3]; | |
| snprintf(buffer, sizeof(buffer), "%02X%02X%02X%02X%02X%02X", mac_addr_[0], mac_addr_[1], | |
| mac_addr_[2], mac_addr_[3], mac_addr_[4], mac_addr_[5]); | |
| mac_addr_string_ = buffer; | |
| // Make the host and device addresses different so packets are routed | |
| // correctly. | |
| mac_addr_[5] ^= 1; | |
| return ZX_OK; | |
| } | |
| void UsbCdcFunction::DiscardPendingTxBuffers(zx_status_t status) { | |
| if (tx_completion_queue_.empty()) { | |
| return; | |
| } | |
| if (!netdevice_ifc_.is_valid()) { | |
| for (auto &id : tx_completion_queue_) { | |
| id.reset(); | |
| } | |
| return; | |
| } | |
| fdf::Arena arena(kArenaTag); | |
| fidl::VectorView<fnetdev::wire::TxResult> results(arena, tx_completion_queue_.size()); | |
| size_t results_count = 0; | |
| for (auto &id : tx_completion_queue_) { | |
| if (id.has_value()) { | |
| results[results_count++] = {.id = *id, .status = status}; | |
| id.reset(); | |
| } | |
| } | |
| if (results_count == 0) { | |
| return; | |
| } | |
| fidl::OneWayStatus fidl_status = netdevice_ifc_.buffer(arena)->CompleteTx( | |
| fidl::VectorView<fnetdev::wire::TxResult>::FromExternal(results.data(), results_count)); | |
| if (!fidl_status.ok()) { | |
| fdf::error("Failed to complete tx: {}", fidl_status.FormatDescription()); | |
| } | |
| } | |
| void UsbCdcFunction::ReturnPendingRxSpace() { | |
| if (rx_space_buffers_.empty()) { | |
| return; | |
| } | |
| if (!netdevice_ifc_.is_valid()) { | |
| while (!rx_space_buffers_.empty()) { | |
| rx_space_buffers_.pop(); | |
| } | |
| return; | |
| } | |
| fdf::Arena arena(kArenaTag); | |
| const size_t count = rx_space_buffers_.size(); | |
| fidl::VectorView<fnetdev::wire::RxBuffer> rx_buffers(arena, count); | |
| fidl::VectorView<fnetdev::wire::RxBufferPart> rx_buffers_parts(arena, count); | |
| for (size_t i = 0; i < count; ++i) { | |
| rx_buffers_parts[i] = { | |
| .id = rx_space_buffers_.front().id, | |
| .offset = 0, | |
| .length = 0, | |
| }; | |
| rx_space_buffers_.pop(); | |
| rx_buffers[i] = { | |
| .meta = | |
| { | |
| .port = kPortId, | |
| .frame_type = fuchsia_hardware_network::FrameType::kEthernet, | |
| }, | |
| .data = | |
| fidl::VectorView<fnetdev::wire::RxBufferPart>::FromExternal(&rx_buffers_parts[i], 1), | |
| }; | |
| } | |
| fidl::OneWayStatus fidl_status = netdevice_ifc_.buffer(arena)->CompleteRx(rx_buffers); | |
| if (!fidl_status.ok()) { | |
| fdf::error("Failed to complete rx: {}", fidl_status.FormatDescription()); | |
| } | |
| } | |
| void UsbCdcFunction::CdcIntrComplete(std::vector<fendpoint::Completion> completions) { | |
| for (auto &completion : completions) { | |
| intr_ep_.PutRequest(usb::FidlRequest{std::move(completion.request().value())}); | |
| } | |
| if (unbound_.load()) { | |
| CheckStopComplete(); | |
| } else if (pending_notification_ && intr_ep_.GetInFlightCount() == 0) { | |
| pending_notification_ = false; | |
| CdcSendNotifications(); | |
| } | |
| CheckSetConfiguredDone(); | |
| } | |
| void UsbCdcFunction::CdcSendNotifications() { | |
| if (unbound_.load() || !configured_ || !intr_ep_.client().is_valid() || intr_endpoint_dead_) { | |
| return; | |
| } | |
| if (intr_ep_.GetInFlightCount() > 0) { | |
| pending_notification_ = true; | |
| return; | |
| } | |
| usb_cdc_notification_t network_notification = { | |
| .bmRequestType = kClassInterfaceIn, | |
| .bNotification = fidl::ToUnderlying(fdescriptor::CdcNotification::kNetworkConnection), | |
| .wValue = online_, | |
| .wIndex = descriptors_.cdc_intf_0.b_interface_number, | |
| .wLength = 0, | |
| }; | |
| usb_cdc_speed_change_notification_t speed_notification = { | |
| .notification = | |
| { | |
| .bmRequestType = kClassInterfaceIn, | |
| .bNotification = | |
| fidl::ToUnderlying(fdescriptor::CdcNotification::kConnectionSpeedChange), | |
| .wValue = 0, | |
| .wIndex = descriptors_.cdc_intf_0.b_interface_number, | |
| .wLength = 2 * sizeof(uint32_t), | |
| }, | |
| .downlink_br = 0, | |
| .uplink_br = 0, | |
| }; | |
| if (online_) { | |
| if (speed_ == fdescriptor::UsbSpeed::kSuper) { | |
| // Claim to be gigabit speed. | |
| speed_notification.downlink_br = speed_notification.uplink_br = 1000 * 1000 * 1000; | |
| } else { | |
| // Claim to be 100 megabit speed. | |
| speed_notification.downlink_br = speed_notification.uplink_br = 100 * 1000 * 1000; | |
| } | |
| } else { | |
| speed_notification.downlink_br = speed_notification.uplink_br = 0; | |
| } | |
| std::optional<usb::FidlRequest> req = intr_ep_.GetRequest(); | |
| if (!req.has_value()) { | |
| fdf::error("[bug] intr_ep_.GetRequest(): no request available"); | |
| return; | |
| } | |
| req->clear_buffers(); | |
| zx::result<std::vector<size_t>> actual = req->CachedCopyTo( | |
| 0, &network_notification, sizeof(network_notification), intr_ep_.GetMapped()); | |
| if (actual.is_error()) { | |
| fdf::error("CdcSendNotifications: CachedCopyTo failed: {}", actual.status_string()); | |
| intr_ep_.PutRequest(std::move(req.value())); | |
| return; | |
| } | |
| size_t actual_total = 0; | |
| for (size_t i = 0; i < actual->size(); i++) { | |
| req.value()->data()->at(i).size((*actual)[i]); | |
| actual_total += (*actual)[i]; | |
| } | |
| if (actual_total != sizeof(network_notification)) { | |
| fdf::error("CdcSendNotifications: incomplete copy for network_notification"); | |
| intr_ep_.PutRequest(std::move(req.value())); | |
| return; | |
| } | |
| std::optional<usb::FidlRequest> req2 = intr_ep_.GetRequest(); | |
| if (!req2.has_value()) { | |
| fdf::error("[bug] intr_ep_.GetRequest(): no request available"); | |
| intr_ep_.PutRequest(std::move(req.value())); | |
| return; | |
| } | |
| // Requests popped from `intr_ep_` are recycled across 8-byte network notifications and 16-byte | |
| // speed notifications and retain the `BufferRegion::size` assigned by their prior send; clear | |
| // stale buffer bounds so `CachedCopyTo()` can copy the full 16-byte speed payload. | |
| req2->clear_buffers(); | |
| actual = | |
| req2->CachedCopyTo(0, &speed_notification, sizeof(speed_notification), intr_ep_.GetMapped()); | |
| if (actual.is_error()) { | |
| fdf::error("CdcSendNotifications: CachedCopyTo failed: {}", actual.status_string()); | |
| intr_ep_.PutRequest(std::move(req.value())); | |
| intr_ep_.PutRequest(std::move(req2.value())); | |
| return; | |
| } | |
| actual_total = 0; | |
| for (size_t i = 0; i < actual->size(); i++) { | |
| req2.value()->data()->at(i).size((*actual)[i]); | |
| actual_total += (*actual)[i]; | |
| } | |
| if (actual_total != sizeof(speed_notification)) { | |
| fdf::error("CdcSendNotifications: incomplete copy for speed_notification"); | |
| intr_ep_.PutRequest(std::move(req.value())); | |
| intr_ep_.PutRequest(std::move(req2.value())); | |
| return; | |
| } | |
| fdf::Arena arena(kArenaTag); | |
| std::array<frequest::wire::Request, 2> reqs = { | |
| fidl::ToWire(arena, req->take_request()), | |
| fidl::ToWire(arena, req2->take_request()), | |
| }; | |
| fidl::OneWayStatus queue_status = intr_ep_.client().wire()->QueueRequests( | |
| fidl::VectorView<frequest::wire::Request>::FromExternal(reqs.data(), reqs.size())); | |
| if (!queue_status.ok()) { | |
| fdf::error("[bug] intr_ep_->QueueRequests(): {}", queue_status.FormatDescription()); | |
| for (auto &r : reqs) { | |
| intr_ep_.PutRequest(usb::FidlRequest(fidl::ToNatural(r))); | |
| } | |
| } | |
| } | |
| void UsbCdcFunction::CdcRxComplete(std::vector<fendpoint::Completion> completions) { | |
| if (unbound_.load()) { | |
| for (auto &completion : completions) { | |
| bulk_out_ep_.PutRequest(usb::FidlRequest{std::move(completion.request().value())}); | |
| } | |
| CheckStopComplete(); | |
| return; | |
| } | |
| ProcessRxCompletions(std::move(completions)); | |
| CheckSetConfiguredDone(); | |
| CheckSetInterfaceDone(); | |
| } | |
| void UsbCdcFunction::ProcessRxCompletions(std::vector<fendpoint::Completion> completions) { | |
| if (completions.empty()) { | |
| return; | |
| } | |
| fdf::Arena arena(kArenaTag); | |
| const size_t count = completions.size(); | |
| fidl::VectorView<frequest::wire::Request> reqs(arena, count); | |
| size_t reqs_count = 0; | |
| fidl::VectorView<fnetdev::wire::RxBuffer> rx_buffers(arena, count); | |
| fidl::VectorView<fnetdev::wire::RxBufferPart> rx_buffers_parts(arena, count); | |
| size_t rx_buffers_count = 0; | |
| auto reset_and_enqueue = [&](usb::FidlRequest req) { | |
| req.reset_buffers(bulk_out_ep_.GetMapped()); | |
| reqs[reqs_count++] = fidl::ToWire(arena, req.take_request()); | |
| }; | |
| for (auto &completion : completions) { | |
| zx_status_t status = *completion.status(); | |
| if (status == ZX_ERR_IO_NOT_PRESENT || status == ZX_ERR_CANCELED || | |
| status == ZX_ERR_BAD_STATE || !online_ || !configured_) { | |
| bulk_out_ep_.PutRequest(usb::FidlRequest{std::move(completion.request().value())}); | |
| continue; | |
| } | |
| if (status != ZX_OK) { | |
| fdf::error("[bug] rx_completion: {}", zx_status_get_string(status)); | |
| usb::FidlRequest req(std::move(completion.request().value())); | |
| bulk_out_inspect_.AddFailedRxBytes(req.length()); | |
| reset_and_enqueue(std::move(req)); | |
| continue; | |
| } | |
| if (rx_space_buffers_.empty()) { | |
| rx_completion_queue_.push_back(std::move(completion)); | |
| continue; | |
| } | |
| if (!completion.request().has_value()) { | |
| fdf::error("rx completion missing request"); | |
| continue; | |
| } | |
| usb::FidlRequest req(std::move(completion.request().value())); | |
| const size_t request_length = completion.transfer_size().value_or(0); | |
| bulk_out_inspect_.AddRxBytes(request_length); | |
| fnetdev::wire::RxSpaceBuffer space = rx_space_buffers_.front(); | |
| auto *stored_vmo = vmo_store_.GetVmo(space.region.vmo); | |
| if (!stored_vmo) { | |
| fdf::error("rx space with unknown vmo {}", space.region.vmo); | |
| reset_and_enqueue(std::move(req)); | |
| continue; | |
| } | |
| if (request_length > space.region.length || space.region.offset > stored_vmo->data().size() || | |
| request_length > stored_vmo->data().size() - space.region.offset) { | |
| fdf::error("rx buffer region out of bounds: offset {} length {} vmo size {}", | |
| space.region.offset, space.region.length, stored_vmo->data().size()); | |
| reset_and_enqueue(std::move(req)); | |
| continue; | |
| } | |
| if (zx::result<std::vector<size_t>> res = req.CachedCopyFrom( | |
| 0, reinterpret_cast<void *>(stored_vmo->data().data() + space.region.offset), | |
| request_length, bulk_out_ep_.GetMapped()); | |
| res.is_error()) { | |
| fdf::error("failed to copy rx data: {}", res.status_string()); | |
| reset_and_enqueue(std::move(req)); | |
| continue; | |
| } | |
| rx_buffers_parts[rx_buffers_count] = fnetdev::wire::RxBufferPart{ | |
| .id = space.id, | |
| .offset = 0, | |
| .length = static_cast<uint32_t>(request_length), | |
| }; | |
| rx_buffers[rx_buffers_count] = { | |
| .meta = | |
| { | |
| .port = kPortId, | |
| .frame_type = fuchsia_hardware_network::FrameType::kEthernet, | |
| }, | |
| .data = fidl::VectorView<fnetdev::wire::RxBufferPart>::FromExternal( | |
| &rx_buffers_parts[rx_buffers_count], 1), | |
| }; | |
| rx_buffers_count++; | |
| rx_space_buffers_.pop(); | |
| reset_and_enqueue(std::move(req)); | |
| } | |
| if (reqs_count > 0) { | |
| if (rx_endpoint_dead_ || !bulk_out_ep_.client().is_valid()) { | |
| for (size_t i = 0; i < reqs_count; ++i) { | |
| bulk_out_ep_.PutRequest(usb::FidlRequest(fidl::ToNatural(reqs[i]))); | |
| } | |
| } else { | |
| fidl::OneWayStatus queue_status = bulk_out_ep_.client().wire()->QueueRequests( | |
| fidl::VectorView<frequest::wire::Request>::FromExternal(reqs.data(), reqs_count)); | |
| if (!queue_status.ok()) { | |
| fdf::error("failed to queue rx requests: {}", queue_status.FormatDescription()); | |
| for (size_t i = 0; i < reqs_count; ++i) { | |
| bulk_out_ep_.PutRequest(usb::FidlRequest(fidl::ToNatural(reqs[i]))); | |
| } | |
| } | |
| } | |
| } | |
| if (rx_buffers_count > 0 && netdevice_ifc_.is_valid()) { | |
| fidl::OneWayStatus queue_status = netdevice_ifc_.buffer(arena)->CompleteRx( | |
| fidl::VectorView<fnetdev::wire::RxBuffer>::FromExternal(rx_buffers.data(), | |
| rx_buffers_count)); | |
| if (!queue_status.ok()) { | |
| fdf::error("failed to complete rx buffers: {}", queue_status.FormatDescription()); | |
| } | |
| } | |
| bulk_out_inspect_.UpdateRxQueue(bulk_out_ep_.GetInFlightCount()); | |
| } | |
| void UsbCdcFunction::CdcTxComplete(std::vector<fendpoint::Completion> completions) { | |
| if (unbound_.load()) { | |
| for (auto &completion : completions) { | |
| bulk_in_ep_.PutRequest(usb::FidlRequest{std::move(completion.request().value())}); | |
| if (!tx_completion_queue_.empty()) { | |
| tx_completion_queue_.pop_front(); | |
| } | |
| } | |
| CheckStopComplete(); | |
| return; | |
| } | |
| fdf::Arena arena(kArenaTag); | |
| const size_t count = completions.size(); | |
| fidl::VectorView<fnetdev::wire::TxResult> results(arena, count); | |
| size_t results_count = 0; | |
| for (auto &completion : completions) { | |
| zx_status_t status = *completion.status(); | |
| usb::FidlRequest req(std::move(completion.request().value())); | |
| size_t size = req.length(); | |
| bulk_in_ep_.PutRequest(std::move(req)); | |
| if (status != ZX_OK) { | |
| fdf::debug("tx completion error: {}", zx_status_get_string(status)); | |
| bulk_in_inspect_.AddFailedTxBytes(size); | |
| } else { | |
| bulk_in_inspect_.AddTxBytes(completion.transfer_size().value_or(0)); | |
| } | |
| if (tx_completion_queue_.empty()) { | |
| fdf::error("received tx completion without pending tx"); | |
| continue; | |
| } | |
| const std::optional<uint32_t> tx_id = tx_completion_queue_.front(); | |
| tx_completion_queue_.pop_front(); | |
| if (tx_id.has_value()) { | |
| results[results_count++] = {.id = *tx_id, .status = status}; | |
| } | |
| } | |
| if (results_count > 0 && netdevice_ifc_.is_valid()) { | |
| fidl::OneWayStatus status = netdevice_ifc_.buffer(arena)->CompleteTx( | |
| fidl::VectorView<fnetdev::wire::TxResult>::FromExternal(results.data(), results_count)); | |
| if (!status.ok()) { | |
| fdf::error("CompleteTx() failed: {}", status.FormatDescription()); | |
| } | |
| } | |
| bulk_in_inspect_.UpdateTxQueue(bulk_in_ep_.GetInFlightCount()); | |
| CheckSetConfiguredDone(); | |
| CheckSetInterfaceDone(); | |
| } | |
| void UsbCdcFunction::Control(ControlRequest &request, ControlCompleter::Sync &completer) { | |
| auto setup = request.setup(); | |
| uint16_t w_value = setup.w_value(); | |
| uint16_t w_index = setup.w_index(); | |
| uint16_t w_length = setup.w_length(); | |
| fdf::debug( | |
| "bmRequestType={:02x} bRequest={:02x} wValue={:04x} ({}) " | |
| "wIndex={:04x} ({}) wLength={:04x} ({})", | |
| setup.bm_request_type(), setup.b_request(), w_value, w_value, w_index, w_index, w_length, | |
| w_length); | |
| TRACE_DURATION("cdc_eth", __func__); | |
| if (setup.bm_request_type() == kClassInterfaceOut && | |
| setup.b_request() == fdescriptor::CdcRequest::kSetEthernetPacketFilter) { | |
| fdf::debug("setting packet filter not supported"); | |
| completer.Reply(zx::ok(std::vector<uint8_t>{})); | |
| return; | |
| } | |
| if (setup.bm_request_type() == kStandardEndpointOut && | |
| setup.b_request() == fdescriptor::StandardRequest::kClearFeature && | |
| setup.w_value() == fidl::ToUnderlying(fdescriptor::FeatureSelector::kEndpointHalt)) { | |
| fdf::debug("clearing endpoint-halt not supported"); | |
| completer.Reply(zx::ok(std::vector<uint8_t>{})); | |
| return; | |
| } | |
| completer.Reply(zx::error(ZX_ERR_NOT_SUPPORTED)); | |
| } | |
| struct UsbCdcFunction::SetConfiguredSharedState | |
| : public std::enable_shared_from_this<SetConfiguredSharedState> { | |
| bool intr_cancelled = false; | |
| bool bulk_in_cancelled = false; | |
| bool bulk_out_cancelled = false; | |
| bool target_configured = false; | |
| fdescriptor::UsbSpeed target_speed = fdescriptor::UsbSpeed::kUndefined; | |
| std::optional<UsbCdcFunction::SetConfiguredCompleter::Async> completer; | |
| UsbCdcFunction *self = nullptr; | |
| ~SetConfiguredSharedState() { | |
| if (completer.has_value()) { | |
| completer->Reply(zx::error(ZX_ERR_INTERNAL)); | |
| } | |
| } | |
| void Cancel() { | |
| self = nullptr; | |
| if (completer.has_value()) { | |
| auto c = std::move(*completer); | |
| completer.reset(); | |
| c.Reply(zx::error(ZX_ERR_CANCELED)); | |
| } | |
| } | |
| void CheckDone() { | |
| // CheckDone() is serialized on the driver dispatcher loop. | |
| if (!self || !completer.has_value()) { | |
| return; | |
| } | |
| if (self->unbound_.load()) { | |
| Cancel(); | |
| return; | |
| } | |
| self->DrainRxCompletionQueue(); | |
| bool intr_full = self->intr_ep_.RequestsFull() || self->intr_endpoint_dead_; | |
| bool bulk_in_full = self->bulk_in_ep_.RequestsFull() || self->tx_endpoint_dead_; | |
| bool bulk_out_full = self->bulk_out_ep_.RequestsFull() || self->rx_endpoint_dead_; | |
| if (!intr_cancelled || !intr_full) { | |
| return; | |
| } | |
| if (!bulk_in_cancelled || !bulk_in_full) { | |
| return; | |
| } | |
| if (!bulk_out_cancelled || !bulk_out_full) { | |
| return; | |
| } | |
| auto async_completer = std::move(*completer); | |
| completer.reset(); | |
| auto self_shared = shared_from_this(); | |
| if (!target_configured) { | |
| self->DisableAllEndpoints( | |
| [self_shared, completer = std::move(async_completer)](zx_status_t status) mutable { | |
| if (status != ZX_OK) { | |
| fdf::error("DisableAllEndpoints failed: {}", zx_status_get_string(status)); | |
| } | |
| if (!self_shared->self || self_shared->self->unbound_.load() || | |
| self_shared->self->set_configured_state_ != self_shared) { | |
| completer.Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| self_shared->self->DiscardPendingTxBuffers(ZX_ERR_CANCELED); | |
| self_shared->self->DrainRxCompletionQueue(); | |
| self_shared->self->speed_ = fuchsia_hardware_usb_descriptor::UsbSpeed::kUndefined; | |
| self_shared->self->configured_ = false; | |
| self_shared->self->function_inspect_.RecordEvent("DisableEndpoints complete"); | |
| self_shared->self->function_inspect_.OnUnconfigureComplete(); | |
| if (self_shared->self->set_configured_state_ == self_shared) { | |
| self_shared->self->set_configured_state_.reset(); | |
| } | |
| completer.Reply(zx::ok()); | |
| }); | |
| } else { | |
| // Host-initiated soft reset (true -> true): | |
| // All pending requests from the previous session have returned. Discard remaining buffers. | |
| self->DiscardPendingTxBuffers(ZX_ERR_CANCELED); | |
| self->DrainRxCompletionQueue(); | |
| if (!self->async_function_.is_valid()) { | |
| fdf::error("async_function_ is not valid during soft reset ConfigureEndpoint"); | |
| self->configured_ = false; | |
| self->function_inspect_.SetConfigured(false); | |
| self->speed_ = fuchsia_hardware_usb_descriptor::UsbSpeed::kUndefined; | |
| if (self->set_configured_state_ == self_shared) { | |
| self->set_configured_state_.reset(); | |
| } | |
| async_completer.Reply(zx::error(ZX_ERR_BAD_STATE)); | |
| return; | |
| } | |
| ffunction::EndpointConfiguration ep_config; | |
| ffunction::EndpointDescriptor desc; | |
| desc.bm_attributes(self->descriptors_.intr_ep.bm_attributes); | |
| desc.w_max_packet_size(le16toh(self->descriptors_.intr_ep.w_max_packet_size)); | |
| desc.b_interval(self->descriptors_.intr_ep.b_interval); | |
| ep_config.descriptor(std::move(desc)); | |
| self->async_function_ | |
| ->ConfigureEndpoint({self->descriptors_.intr_ep.b_endpoint_address, std::move(ep_config)}) | |
| .Then([self_shared, completer = std::move(async_completer)]( | |
| fidl::Result<fuchsia_hardware_usb_function::UsbFunction::ConfigureEndpoint> | |
| &result) mutable { | |
| if (!self_shared->self || self_shared->self->unbound_.load() || | |
| self_shared->self->set_configured_state_ != self_shared) { | |
| completer.Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| if (result.is_error()) { | |
| fdf::error("[bug] ConfigureEndpoint(intr): {}", | |
| result.error_value().FormatDescription()); | |
| self_shared->self->configured_ = false; | |
| self_shared->self->function_inspect_.SetConfigured(false); | |
| self_shared->self->speed_ = fuchsia_hardware_usb_descriptor::UsbSpeed::kUndefined; | |
| if (self_shared->self->set_configured_state_ == self_shared) { | |
| self_shared->self->set_configured_state_.reset(); | |
| } | |
| completer.Reply(zx::error(ZX_ERR_INTERNAL)); | |
| return; | |
| } | |
| self_shared->self->speed_ = self_shared->target_speed; | |
| self_shared->self->configured_ = true; | |
| self_shared->self->intr_inspect_.SetCancelled(false); | |
| self_shared->self->bulk_in_inspect_.SetCancelled(false); | |
| self_shared->self->bulk_out_inspect_.SetCancelled(false); | |
| self_shared->self->function_inspect_.OnConfigured(); | |
| self_shared->self->CdcSendNotifications(); | |
| if (self_shared->self->set_configured_state_ == self_shared) { | |
| self_shared->self->set_configured_state_.reset(); | |
| } | |
| completer.Reply(zx::ok()); | |
| }); | |
| } | |
| } | |
| }; | |
| void UsbCdcFunction::CheckSetConfiguredDone() { | |
| if (set_configured_state_) { | |
| set_configured_state_->CheckDone(); | |
| } | |
| } | |
| void UsbCdcFunction::SetConfigured(SetConfiguredRequest &request, | |
| SetConfiguredCompleter::Sync &completer) { | |
| bool configured = request.configured(); | |
| fdescriptor::UsbSpeed speed = request.speed(); | |
| TRACE_DURATION("cdc_eth", __func__, "configured", configured, "speed", | |
| static_cast<uint32_t>(speed)); | |
| // Prevent a race with teardown, don't do any work if we're going away. | |
| if (unbound_.load()) { | |
| completer.Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| // If already unconfigured and requesting unconfigured (false -> false), reply immediately. | |
| if (configured_ == configured && !configured && !set_configured_state_) { | |
| completer.Reply(zx::ok()); | |
| return; | |
| } | |
| // Cancel any prior in-flight SetConfigured and SetInterface transitions. | |
| if (set_configured_state_) { | |
| set_configured_state_->Cancel(); | |
| set_configured_state_.reset(); | |
| function_inspect_.ResetUnconfiguring(); | |
| } | |
| CancelSetInterface(); | |
| // Instantly isolate the data plane from new packets | |
| online_ = false; | |
| function_inspect_.SetOnline(false); | |
| UpdatePortStatus(); | |
| fdf::info("configured = {}", configured); | |
| // Fresh configuration (false -> true): endpoints are not active yet, configure interrupt ep. | |
| if (configured && !configured_) { | |
| if (!async_function_.is_valid()) { | |
| fdf::error("async_function_ is not valid in SetConfigured"); | |
| completer.Reply(zx::error(ZX_ERR_BAD_STATE)); | |
| return; | |
| } | |
| auto async_completer = completer.ToAsync(); | |
| auto state = std::make_shared<SetConfiguredSharedState>(); | |
| state->completer = std::move(async_completer); | |
| state->self = this; | |
| state->target_configured = true; | |
| state->target_speed = speed; | |
| set_configured_state_ = state; | |
| ffunction::EndpointConfiguration ep_config; | |
| ffunction::EndpointDescriptor desc; | |
| desc.bm_attributes(descriptors_.intr_ep.bm_attributes); | |
| desc.w_max_packet_size(le16toh(descriptors_.intr_ep.w_max_packet_size)); | |
| desc.b_interval(descriptors_.intr_ep.b_interval); | |
| ep_config.descriptor(std::move(desc)); | |
| async_function_ | |
| ->ConfigureEndpoint({descriptors_.intr_ep.b_endpoint_address, std::move(ep_config)}) | |
| .Then([state](fidl::Result<fuchsia_hardware_usb_function::UsbFunction::ConfigureEndpoint> | |
| &result) mutable { | |
| if (!state->self || state->self->unbound_.load() || | |
| state->self->set_configured_state_ != state) { | |
| state->Cancel(); | |
| return; | |
| } | |
| if (result.is_error()) { | |
| fdf::error("[bug] ConfigureEndpoint(intr): {}", | |
| result.error_value().FormatDescription()); | |
| if (state->self->set_configured_state_ == state) { | |
| state->self->set_configured_state_.reset(); | |
| } | |
| if (state->completer.has_value()) { | |
| auto c = std::move(*state->completer); | |
| state->completer.reset(); | |
| c.Reply(zx::error(ZX_ERR_INTERNAL)); | |
| } | |
| return; | |
| } | |
| state->self->speed_ = state->target_speed; | |
| state->self->configured_ = true; | |
| state->self->intr_inspect_.SetCancelled(false); | |
| state->self->bulk_in_inspect_.SetCancelled(false); | |
| state->self->bulk_out_inspect_.SetCancelled(false); | |
| state->self->function_inspect_.OnConfigured(); | |
| state->self->CdcSendNotifications(); | |
| if (state->self->set_configured_state_ == state) { | |
| state->self->set_configured_state_.reset(); | |
| } | |
| if (state->completer.has_value()) { | |
| auto c = std::move(*state->completer); | |
| state->completer.reset(); | |
| c.Reply(zx::ok()); | |
| } | |
| }); | |
| return; | |
| } | |
| // Either deconfiguring (true -> false) or host soft-reset (true -> true): | |
| // Endpoints were previously configured. Asynchronously cancel and drain active requests. | |
| if (!configured) { | |
| if (configured_ || function_inspect_.is_unconfiguring()) { | |
| function_inspect_.OnUnconfigureStart(); | |
| } | |
| } | |
| pending_notification_ = false; | |
| auto async_completer = completer.ToAsync(); | |
| auto state = std::make_shared<SetConfiguredSharedState>(); | |
| state->completer = std::move(async_completer); | |
| state->self = this; | |
| state->target_configured = configured; | |
| state->target_speed = speed; | |
| set_configured_state_ = state; | |
| if (!intr_ep_.client().is_valid() || intr_endpoint_dead_) { | |
| state->intr_cancelled = true; | |
| intr_inspect_.SetCancelled(true); | |
| } else { | |
| intr_ep_->CancelAll().Then( | |
| [state](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("intr ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| if (state->self) { | |
| state->self->intr_inspect_.OnCancelAllComplete(); | |
| } | |
| state->intr_cancelled = true; | |
| state->CheckDone(); | |
| }); | |
| } | |
| if (!bulk_out_ep_.client().is_valid() || rx_endpoint_dead_) { | |
| state->bulk_out_cancelled = true; | |
| bulk_out_inspect_.SetCancelled(true); | |
| } else { | |
| bulk_out_ep_->CancelAll().Then( | |
| [state](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("bulk out ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| if (state->self) { | |
| state->self->bulk_out_inspect_.OnCancelAllComplete(); | |
| } | |
| state->bulk_out_cancelled = true; | |
| state->CheckDone(); | |
| }); | |
| } | |
| if (!bulk_in_ep_.client().is_valid() || tx_endpoint_dead_) { | |
| state->bulk_in_cancelled = true; | |
| bulk_in_inspect_.SetCancelled(true); | |
| } else { | |
| bulk_in_ep_->CancelAll().Then( | |
| [state](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("bulk in ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| if (state->self) { | |
| state->self->bulk_in_inspect_.OnCancelAllComplete(); | |
| } | |
| state->bulk_in_cancelled = true; | |
| state->CheckDone(); | |
| }); | |
| } | |
| state->CheckDone(); | |
| } | |
| struct UsbCdcFunction::SetInterfaceSharedState | |
| : public std::enable_shared_from_this<SetInterfaceSharedState> { | |
| uint8_t target_alt_setting = 0; | |
| bool bulk_in_cancelled = false; | |
| bool bulk_out_cancelled = false; | |
| bool transition_started = false; | |
| std::optional<UsbCdcFunction::SetInterfaceCompleter::Async> completer; | |
| UsbCdcFunction *self = nullptr; | |
| ~SetInterfaceSharedState() { Reply(zx::error(ZX_ERR_INTERNAL)); } | |
| void Reply(zx::result<> result) { | |
| if (completer.has_value()) { | |
| auto c = std::move(*completer); | |
| completer.reset(); | |
| c.Reply(result); | |
| } | |
| } | |
| void Cancel() { | |
| self = nullptr; | |
| Reply(zx::error(ZX_ERR_CANCELED)); | |
| } | |
| bool IsActive() const { | |
| return self && !self->unbound_.load() && self->configured_ && !self->set_configured_state_ && | |
| self->set_interface_state_.get() == this; | |
| } | |
| void CheckDone() { | |
| // CheckDone() is serialized on the driver dispatcher loop. | |
| if (!self || !completer.has_value() || transition_started) { | |
| return; | |
| } | |
| if (!IsActive()) { | |
| Cancel(); | |
| return; | |
| } | |
| self->DrainRxCompletionQueue(); | |
| bool bulk_in_full = self->bulk_in_ep_.RequestsFull() || self->tx_endpoint_dead_; | |
| bool bulk_out_full = self->bulk_out_ep_.RequestsFull() || self->rx_endpoint_dead_; | |
| if (!bulk_in_cancelled || !bulk_in_full) { | |
| return; | |
| } | |
| if (!bulk_out_cancelled || !bulk_out_full) { | |
| return; | |
| } | |
| transition_started = true; | |
| auto self_shared = shared_from_this(); | |
| if (!self->async_function_.is_valid()) { | |
| fdf::error("async_function_ is not valid in SetInterface"); | |
| if (self->set_interface_state_ == self_shared) { | |
| self->set_interface_state_.reset(); | |
| } | |
| Reply(zx::error(ZX_ERR_BAD_STATE)); | |
| return; | |
| } | |
| if (target_alt_setting == 0) { | |
| struct DisableState { | |
| int pending_calls = 2; | |
| zx_status_t status = ZX_OK; | |
| }; | |
| auto disable_state = std::make_shared<DisableState>(); | |
| for (const uint8_t ep_addr : {self->BulkOutAddress(), self->BulkInAddress()}) { | |
| self->async_function_->DisableEndpoint({ep_addr}).Then( | |
| [ep_addr, disable_state, | |
| self_shared](fidl::Result<fuchsia_hardware_usb_function::UsbFunction::DisableEndpoint> | |
| &result) mutable { | |
| if (result.is_error()) { | |
| if (!IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("Failed to disable endpoint {}: {}", ep_addr, | |
| result.error_value().FormatDescription()); | |
| if (disable_state->status == ZX_OK) { | |
| disable_state->status = ZX_ERR_INTERNAL; | |
| } | |
| } | |
| } | |
| if (!self_shared->IsActive()) { | |
| self_shared->Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| disable_state->pending_calls--; | |
| if (disable_state->pending_calls == 0) { | |
| self_shared->self->DiscardPendingTxBuffers(ZX_ERR_CANCELED); | |
| self_shared->self->DrainRxCompletionQueue(); | |
| zx_status_t reply_status = disable_state->status; | |
| if (self_shared->self->set_interface_state_ == self_shared) { | |
| self_shared->self->set_interface_state_.reset(); | |
| } | |
| self_shared->Reply(zx::make_result(reply_status)); | |
| } | |
| }); | |
| } | |
| } else { | |
| self->DiscardPendingTxBuffers(ZX_ERR_CANCELED); | |
| self->DrainRxCompletionQueue(); | |
| StepDisableBulkOut(); | |
| } | |
| } | |
| void StepDisableBulkOut() { | |
| ffunction::EndpointConfiguration bulk_out_config; | |
| { | |
| ffunction::EndpointDescriptor desc; | |
| desc.bm_attributes(self->descriptors_.bulk_out_ep.bm_attributes); | |
| desc.w_max_packet_size(le16toh(self->descriptors_.bulk_out_ep.w_max_packet_size)); | |
| desc.b_interval(self->descriptors_.bulk_out_ep.b_interval); | |
| bulk_out_config.descriptor(std::move(desc)); | |
| } | |
| auto self_shared = shared_from_this(); | |
| self->async_function_->DisableEndpoint({self->BulkOutAddress()}) | |
| .Then([self_shared, bulk_out_config = std::move(bulk_out_config)]( | |
| fidl::Result<fuchsia_hardware_usb_function::UsbFunction::DisableEndpoint> | |
| &result) mutable { | |
| if (!self_shared->IsActive()) { | |
| self_shared->Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| if (result.is_error() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("Failed to disable endpoint {}: {}", self_shared->self->BulkOutAddress(), | |
| result.error_value().FormatDescription()); | |
| } | |
| self_shared->StepConfigureBulkOut(std::move(bulk_out_config)); | |
| }); | |
| } | |
| void StepConfigureBulkOut(ffunction::EndpointConfiguration bulk_out_config) { | |
| auto self_shared = shared_from_this(); | |
| self->async_function_->ConfigureEndpoint({self->BulkOutAddress(), std::move(bulk_out_config)}) | |
| .Then([self_shared]( | |
| fidl::Result<fuchsia_hardware_usb_function::UsbFunction::ConfigureEndpoint> | |
| &result) mutable { | |
| if (!self_shared->IsActive()) { | |
| self_shared->Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| if (result.is_error()) { | |
| if (!IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("[bug] ConfigureEndpoint(bulk_out) failed: {}", | |
| result.error_value().FormatDescription()); | |
| } | |
| if (self_shared->self->set_interface_state_ == self_shared) { | |
| self_shared->self->set_interface_state_.reset(); | |
| } | |
| self_shared->Reply(zx::error(ZX_ERR_INTERNAL)); | |
| return; | |
| } | |
| self_shared->self->bulk_out_inspect_.SetCancelled(false); | |
| self_shared->StepDisableBulkIn(); | |
| }); | |
| } | |
| void StepDisableBulkIn() { | |
| auto self_shared = shared_from_this(); | |
| self->async_function_->DisableEndpoint({self->BulkInAddress()}) | |
| .Then( | |
| [self_shared](fidl::Result<fuchsia_hardware_usb_function::UsbFunction::DisableEndpoint> | |
| &result) mutable { | |
| if (!self_shared->IsActive()) { | |
| self_shared->Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| if (result.is_error() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("Failed to disable endpoint {}: {}", self_shared->self->BulkInAddress(), | |
| result.error_value().FormatDescription()); | |
| } | |
| self_shared->StepConfigureBulkIn(); | |
| }); | |
| } | |
| void StepConfigureBulkIn() { | |
| ffunction::EndpointConfiguration bulk_in_config; | |
| { | |
| ffunction::EndpointDescriptor desc; | |
| desc.bm_attributes(self->descriptors_.bulk_in_ep.bm_attributes); | |
| desc.w_max_packet_size(le16toh(self->descriptors_.bulk_in_ep.w_max_packet_size)); | |
| desc.b_interval(self->descriptors_.bulk_in_ep.b_interval); | |
| bulk_in_config.descriptor(std::move(desc)); | |
| } | |
| auto self_shared = shared_from_this(); | |
| self->async_function_->ConfigureEndpoint({self->BulkInAddress(), std::move(bulk_in_config)}) | |
| .Then([self_shared]( | |
| fidl::Result<fuchsia_hardware_usb_function::UsbFunction::ConfigureEndpoint> | |
| &result) mutable { | |
| if (!self_shared->IsActive()) { | |
| self_shared->Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| if (result.is_error()) { | |
| if (!IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("[bug] ConfigureEndpoint(bulk_in) failed: {}", | |
| result.error_value().FormatDescription()); | |
| } | |
| if (self_shared->self->set_interface_state_ == self_shared) { | |
| self_shared->self->set_interface_state_.reset(); | |
| } | |
| self_shared->Reply(zx::error(ZX_ERR_INTERNAL)); | |
| return; | |
| } | |
| self_shared->self->bulk_in_inspect_.SetCancelled(false); | |
| self_shared->StepCompleteAltSetting1(); | |
| }); | |
| } | |
| void StepCompleteAltSetting1() { | |
| auto self_shared = shared_from_this(); | |
| if (self->rx_endpoint_dead_ || self->tx_endpoint_dead_ || | |
| !self->bulk_out_ep_.client().is_valid() || !self->bulk_in_ep_.client().is_valid()) { | |
| fdf::error("Bulk endpoint is invalid or dead when enabling data interface"); | |
| if (self->set_interface_state_ == self_shared) { | |
| self->set_interface_state_.reset(); | |
| } | |
| Reply(zx::error((self->rx_endpoint_dead_ || self->tx_endpoint_dead_) ? ZX_ERR_PEER_CLOSED | |
| : ZX_ERR_INTERNAL)); | |
| return; | |
| } | |
| // Set online and update port status BEFORE queueing rx requests so that any | |
| // completions that fire immediately are processed normally rather than dropped. | |
| self->online_ = true; | |
| self->function_inspect_.SetOnline(true); | |
| self->UpdatePortStatus(); | |
| self->CdcSendNotifications(); | |
| fdf::Arena arena(kArenaTag); | |
| std::vector<usb::FidlRequest> popped_reqs; | |
| popped_reqs.reserve(kRxDepth); | |
| while (!self->bulk_out_ep_.RequestsEmpty()) { | |
| auto req = self->bulk_out_ep_.GetRequest(); | |
| if (!req.has_value()) { | |
| fdf::error("Expected available bulk out request but none found"); | |
| break; | |
| } | |
| popped_reqs.push_back(std::move(*req)); | |
| } | |
| const size_t count = popped_reqs.size(); | |
| fidl::VectorView<frequest::wire::Request> reqs(arena, count); | |
| for (size_t i = 0; i < count; ++i) { | |
| popped_reqs[i].reset_buffers(self->bulk_out_ep_.GetMapped()); | |
| reqs[i] = fidl::ToWire(arena, popped_reqs[i].take_request()); | |
| } | |
| if (count > 0) { | |
| fidl::OneWayStatus queue_status = self->bulk_out_ep_.client().wire()->QueueRequests(reqs); | |
| if (!queue_status.ok()) { | |
| fdf::error("Failed to queue rx requests: {}", queue_status.FormatDescription()); | |
| for (size_t i = 0; i < count; ++i) { | |
| self->bulk_out_ep_.PutRequest(usb::FidlRequest(fidl::ToNatural(reqs[i]))); | |
| } | |
| if (self->set_interface_state_ == self_shared) { | |
| self->set_interface_state_.reset(); | |
| } | |
| Reply(zx::error(ZX_ERR_INTERNAL)); | |
| return; | |
| } | |
| } | |
| if (self->set_interface_state_ == self_shared) { | |
| self->set_interface_state_.reset(); | |
| } | |
| Reply(zx::ok()); | |
| } | |
| }; | |
| void UsbCdcFunction::CancelSetInterface() { | |
| if (set_interface_state_) { | |
| set_interface_state_->Cancel(); | |
| set_interface_state_.reset(); | |
| } | |
| } | |
| void UsbCdcFunction::CheckSetInterfaceDone() { | |
| if (set_interface_state_) { | |
| set_interface_state_->CheckDone(); | |
| } | |
| } | |
| void UsbCdcFunction::SetInterface(SetInterfaceRequest &request, | |
| SetInterfaceCompleter::Sync &completer) { | |
| uint8_t interface = request.interface(); | |
| uint8_t alt_setting = request.alt_setting(); | |
| if (unbound_.load()) { | |
| completer.Reply(zx::error(ZX_ERR_CANCELED)); | |
| return; | |
| } | |
| if (!configured_ || set_configured_state_) { | |
| completer.Reply(zx::error(ZX_ERR_BAD_STATE)); | |
| return; | |
| } | |
| // The communication interface only supports alternative setting 0. | |
| // No endpoint configuration is required for this interface. | |
| if (interface == descriptors_.comm_intf.b_interface_number) { | |
| if (alt_setting != 0) { | |
| completer.Reply(zx::error(ZX_ERR_NOT_SUPPORTED)); | |
| return; | |
| } | |
| completer.Reply(zx::ok()); | |
| return; | |
| } | |
| if (interface != descriptors_.cdc_intf_0.b_interface_number || alt_setting > 1) { | |
| completer.Reply(zx::error(ZX_ERR_NOT_SUPPORTED)); | |
| return; | |
| } | |
| // Cancel any prior in-flight SetInterface transition. | |
| CancelSetInterface(); | |
| // Instantly isolate the data plane from new packets! | |
| online_ = false; | |
| function_inspect_.SetOnline(false); | |
| UpdatePortStatus(); | |
| if (alt_setting == 0) { | |
| CdcSendNotifications(); | |
| } | |
| auto async_completer = completer.ToAsync(); | |
| auto state = std::make_shared<SetInterfaceSharedState>(); | |
| state->target_alt_setting = alt_setting; | |
| state->completer = std::move(async_completer); | |
| state->self = this; | |
| set_interface_state_ = state; | |
| if (!bulk_out_ep_.client().is_valid() || rx_endpoint_dead_) { | |
| state->bulk_out_cancelled = true; | |
| bulk_out_inspect_.SetCancelled(true); | |
| } else { | |
| bulk_out_ep_.client()->CancelAll().Then( | |
| [state](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("bulk out ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| if (state->self) { | |
| state->self->bulk_out_inspect_.OnCancelAllComplete(); | |
| } | |
| state->bulk_out_cancelled = true; | |
| state->CheckDone(); | |
| }); | |
| } | |
| if (!bulk_in_ep_.client().is_valid() || tx_endpoint_dead_) { | |
| state->bulk_in_cancelled = true; | |
| bulk_in_inspect_.SetCancelled(true); | |
| } else { | |
| bulk_in_ep_.client()->CancelAll().Then( | |
| [state](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("bulk in ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| if (state->self) { | |
| state->self->bulk_in_inspect_.OnCancelAllComplete(); | |
| } | |
| state->bulk_in_cancelled = true; | |
| state->CheckDone(); | |
| }); | |
| } | |
| state->CheckDone(); | |
| } | |
| void UsbCdcFunction::handle_unknown_method( | |
| fidl::UnknownMethodMetadata<ffunction::UsbFunctionInterface> metadata, | |
| fidl::UnknownMethodCompleter::Sync &completer) { | |
| fdf::error("Unknown method %ld", metadata.method_ordinal); | |
| } | |
| // NetworkDeviceImpl protocol: | |
| zx::result<> UsbCdcFunction::Start(fdf::DriverContext context) { | |
| unbound_.store(false); | |
| online_ = false; | |
| configured_ = false; | |
| pending_notification_ = false; | |
| deconfigure_called_ = false; | |
| deconfigure_completed_ = false; | |
| intr_cancelled_ = false; | |
| bulk_in_cancelled_ = false; | |
| bulk_out_cancelled_ = false; | |
| intr_endpoint_dead_ = false; | |
| rx_endpoint_dead_ = false; | |
| tx_endpoint_dead_ = false; | |
| set_configured_state_.reset(); | |
| set_interface_state_.reset(); | |
| stop_completer_.reset(); | |
| inspector_ = context.CreateInspector(this); | |
| incoming_ = std::shared_ptr<fdf::Namespace>(context.take_incoming()); | |
| zx::result result = incoming()->Connect<ffunction::UsbFunctionService::Device>(); | |
| if (result.is_error()) { | |
| fdf::error("could not connect to UsbFunctionService: {}", result.status_string()); | |
| return result.take_error(); | |
| } | |
| function_.Bind(std::move(*result)); | |
| zx::result async_client = incoming()->Connect<ffunction::UsbFunctionService::Device>(); | |
| if (async_client.is_error()) { | |
| fdf::error("could not connect async UsbFunctionService: {}", async_client.status_string()); | |
| return async_client.take_error(); | |
| } | |
| async_function_.Bind(std::move(*async_client), dispatcher()); | |
| zx_status_t status = cdc_generate_mac_address(); | |
| if (status != ZX_OK) { | |
| return zx::error(status); | |
| } | |
| zx::result intr_endpoints = fidl::CreateEndpoints<fuchsia_hardware_usb_endpoint::Endpoint>(); | |
| if (intr_endpoints.is_error()) { | |
| return intr_endpoints.take_error(); | |
| } | |
| std::vector<ffunction::EndpointResource> resources; | |
| resources.push_back(ffunction::EndpointResource( | |
| fdescriptor::EndpointDirection::kIn, std::move(intr_endpoints->server), | |
| fuchsia_hardware_usb_endpoint::EndpointInfo::WithInterrupt({}), INTR_MAX_PACKET)); | |
| zx::result bulk_in_endpoints = fidl::CreateEndpoints<fuchsia_hardware_usb_endpoint::Endpoint>(); | |
| if (bulk_in_endpoints.is_error()) { | |
| return bulk_in_endpoints.take_error(); | |
| } | |
| resources.push_back(ffunction::EndpointResource( | |
| fdescriptor::EndpointDirection::kIn, std::move(bulk_in_endpoints->server), | |
| fuchsia_hardware_usb_endpoint::EndpointInfo::WithBulk({}), BULK_MAX_PACKET)); | |
| zx::result bulk_out_endpoints = fidl::CreateEndpoints<fuchsia_hardware_usb_endpoint::Endpoint>(); | |
| if (bulk_out_endpoints.is_error()) { | |
| return bulk_out_endpoints.take_error(); | |
| } | |
| resources.push_back(ffunction::EndpointResource( | |
| fdescriptor::EndpointDirection::kOut, std::move(bulk_out_endpoints->server), | |
| fuchsia_hardware_usb_endpoint::EndpointInfo::WithBulk({}), BULK_MAX_PACKET)); | |
| fidl::Request<ffunction::UsbFunction::AllocResources> alloc_req; | |
| alloc_req.interface_count(2); | |
| alloc_req.endpoints(std::move(resources)); | |
| alloc_req.strings({{mac_addr_string_}}); | |
| fidl::Result alloc_result = function_->AllocResources(std::move(alloc_req)); | |
| if (alloc_result.is_error()) { | |
| fdf::error("AllocResources failed: {}", alloc_result.error_value().FormatDescription()); | |
| return zx::error(alloc_result.error_value().is_framework_error() | |
| ? alloc_result.error_value().framework_error().status() | |
| : alloc_result.error_value().domain_error()); | |
| } | |
| auto &response = alloc_result.value(); | |
| descriptors_.iad.b_first_interface = response.interface_nums()[0]; | |
| descriptors_.comm_intf.b_interface_number = response.interface_nums()[0]; | |
| descriptors_.cdc_intf_0.b_interface_number = response.interface_nums()[1]; | |
| descriptors_.cdc_intf_1.b_interface_number = descriptors_.cdc_intf_0.b_interface_number; | |
| descriptors_.cdc_union.bControlInterface = descriptors_.comm_intf.b_interface_number; | |
| descriptors_.cdc_union.bSubordinateInterface = descriptors_.cdc_intf_0.b_interface_number; | |
| descriptors_.intr_ep.b_endpoint_address = response.endpoint_addrs()[0]; | |
| descriptors_.bulk_in_ep.b_endpoint_address = response.endpoint_addrs()[1]; | |
| descriptors_.bulk_out_ep.b_endpoint_address = response.endpoint_addrs()[2]; | |
| descriptors_.cdc_eth.iMACAddress = response.string_indices()[0]; | |
| status = intr_ep_.Init(std::move(intr_endpoints->client), dispatcher()); | |
| if (status != ZX_OK) { | |
| fdf::error("[bug] intr_ep_.Init(): {}", zx_status_get_string(status)); | |
| return zx::error(status); | |
| } | |
| intr_ep_.SetOnUnbind([this]() { | |
| intr_endpoint_dead_ = true; | |
| CheckSetConfiguredDone(); | |
| CheckStopComplete(); | |
| }); | |
| size_t actual = intr_ep_.AddRequests(INTR_COUNT, BULK_REQ_SIZE, | |
| fuchsia_hardware_usb_request::Buffer::Tag::kVmoId); | |
| if (actual != INTR_COUNT) { | |
| fdf::error("[bug] intr_ep_.AddRequests(): want {}, got {}", INTR_COUNT, actual); | |
| return zx::error(ZX_ERR_INTERNAL); | |
| } | |
| status = bulk_in_ep_.Init(std::move(bulk_in_endpoints->client), dispatcher()); | |
| if (status != ZX_OK) { | |
| fdf::error("[bug] bulk_in_ep_.Init(): {}", zx_status_get_string(status)); | |
| return zx::error(status); | |
| } | |
| bulk_in_ep_.SetOnUnbind([this]() { | |
| tx_endpoint_dead_ = true; | |
| DiscardPendingTxBuffers(ZX_ERR_PEER_CLOSED); | |
| CheckSetConfiguredDone(); | |
| CheckSetInterfaceDone(); | |
| CheckStopComplete(); | |
| }); | |
| actual = bulk_in_ep_.AddRequests(kTxDepth, BULK_REQ_SIZE, | |
| fuchsia_hardware_usb_request::Buffer::Tag::kVmoId); | |
| if (actual != kTxDepth) { | |
| fdf::error("[bug] bulk_in_ep_.AddRequests(): want {}, got {}", kTxDepth, actual); | |
| return zx::error(ZX_ERR_INTERNAL); | |
| } | |
| status = bulk_out_ep_.Init(std::move(bulk_out_endpoints->client), dispatcher()); | |
| if (status != ZX_OK) { | |
| fdf::error("[bug] bulk_out_ep_.Init(): {}", zx_status_get_string(status)); | |
| return zx::error(status); | |
| } | |
| bulk_out_ep_.SetOnUnbind([this]() { | |
| rx_endpoint_dead_ = true; | |
| CheckSetConfiguredDone(); | |
| CheckSetInterfaceDone(); | |
| CheckStopComplete(); | |
| }); | |
| actual = bulk_out_ep_.AddRequests(kRxDepth, BULK_REQ_SIZE, | |
| fuchsia_hardware_usb_request::Buffer::Tag::kVmoId); | |
| if (actual != kRxDepth) { | |
| fdf::error("[bug] bulk_out_ep_.AddRequests(): want {}, got {}", kRxDepth, actual); | |
| return zx::error(ZX_ERR_INTERNAL); | |
| } | |
| zx::result iface_endpoints = fidl::CreateEndpoints<ffunction::UsbFunctionInterface>(); | |
| if (iface_endpoints.is_error()) { | |
| return iface_endpoints.take_error(); | |
| } | |
| fidl::BindServer(dispatcher(), std::move(iface_endpoints->server), this); | |
| std::vector<uint8_t> descriptors_buffer(sizeof(descriptors_)); | |
| memcpy(descriptors_buffer.data(), &descriptors_, sizeof(descriptors_)); | |
| fidl::Request<ffunction::UsbFunction::Configure> config_req; | |
| config_req.configuration(std::move(descriptors_buffer)); | |
| config_req.iface(std::move(iface_endpoints->client)); | |
| fidl::Result config_res = function_->Configure(std::move(config_req)); | |
| if (config_res.is_error()) { | |
| fdf::error("Configure failed: {}", config_res.error_value().FormatDescription()); | |
| return zx::error(config_res.error_value().is_framework_error() | |
| ? config_res.error_value().framework_error().status() | |
| : config_res.error_value().domain_error()); | |
| } | |
| if (zx_status_t status = vmo_store_.Reserve(fuchsia_hardware_network::wire::kMaxDataVmos); | |
| status != ZX_OK) { | |
| fdf::error("failed to initialize vmo store: {}", zx_status_get_string(status)); | |
| return zx::error(status); | |
| } | |
| inspect_node_ = inspector().root().CreateChild("usb-cdc-function"); | |
| function_inspect_.Init(inspect_node_); | |
| bulk_in_inspect_.Init(inspect_node_, "bulk_in"); | |
| bulk_in_inspect_.SetPoolCountsCallback([this]() { return bulk_in_ep_.GetPoolCounts(); }); | |
| bulk_out_inspect_.Init(inspect_node_, "bulk_out"); | |
| bulk_out_inspect_.SetPoolCountsCallback([this]() { return bulk_out_ep_.GetPoolCounts(); }); | |
| intr_inspect_.Init(inspect_node_, "intr"); | |
| intr_inspect_.SetPoolCountsCallback([this]() { return intr_ep_.GetPoolCounts(); }); | |
| throughput_tracker_.emplace(dispatcher(), [this](zx::duration delta) { | |
| bulk_in_inspect_.MeasureThroughput(delta); | |
| bulk_in_inspect_.UpdateTxQueue(bulk_in_ep_.GetInFlightCount()); | |
| bulk_out_inspect_.MeasureThroughput(delta); | |
| bulk_out_inspect_.UpdateRxQueue(bulk_out_ep_.GetInFlightCount()); | |
| }); | |
| throughput_tracker_->Start(); | |
| if (zx::result result = | |
| child_.Initialize(incoming(), outgoing(), context.node_name(), "usb-cdc-netdev"); | |
| result.is_error()) { | |
| fdf::error("Failed to initialize compat server: {}", result); | |
| return result.take_error(); | |
| } | |
| // NetworkDeviceImpl service handler | |
| auto protocol = [this](fdf::ServerEnd<fnetdev::NetworkDeviceImpl> server_end) mutable { | |
| fdf::BindServer(driver_dispatcher()->get(), std::move(server_end), this); | |
| }; | |
| fnetdev::Service::InstanceHandler handler({.network_device_impl = std::move(protocol)}); | |
| if (auto status = outgoing()->AddService<fnetdev::Service>(std::move(handler)); | |
| status.is_error()) { | |
| fdf::error("failed to add netdev service handler: {}", status.status_string()); | |
| return status.take_error(); | |
| } | |
| std::vector offers = child_.CreateOffers2(); | |
| offers.push_back(fdf::MakeOffer2<fnetdev::Service>()); | |
| zx::result controller = AddChild( | |
| "usb-cdc-netdev", cpp20::span<const fuchsia_driver_framework::NodeProperty2>{}, offers); | |
| if (controller.is_error()) { | |
| fdf::error("Failed to add child: {}", controller); | |
| return controller.take_error(); | |
| } | |
| child_controller_ = std::move(controller.value()); | |
| return zx::ok(); | |
| } | |
| void UsbCdcFunction::DrainRxCompletionQueue() { | |
| for (auto &completion : rx_completion_queue_) { | |
| if (completion.request().has_value()) { | |
| bulk_out_ep_.PutRequest(usb::FidlRequest{std::move(completion.request().value())}); | |
| } | |
| } | |
| rx_completion_queue_.clear(); | |
| } | |
| void UsbCdcFunction::Stop(fdf::StopCompleter completer) { | |
| if (stop_completer_.has_value()) { | |
| fdf::warn("Stop() called while teardown is already in progress"); | |
| completer(zx::ok()); | |
| return; | |
| } | |
| if (throughput_tracker_) { | |
| throughput_tracker_->Stop(); | |
| } | |
| unbound_.store(true); | |
| pending_notification_ = false; | |
| stop_completer_.emplace(std::move(completer)); | |
| if (set_configured_state_) { | |
| set_configured_state_->Cancel(); | |
| set_configured_state_.reset(); | |
| } | |
| CancelSetInterface(); | |
| // Reset cancellation and deconfigure flags | |
| intr_cancelled_ = false; | |
| bulk_in_cancelled_ = false; | |
| bulk_out_cancelled_ = false; | |
| deconfigure_called_ = false; | |
| deconfigure_completed_ = false; | |
| DrainRxCompletionQueue(); | |
| online_ = false; | |
| function_inspect_.SetOnline(false); | |
| netdevice_started_ = false; | |
| DiscardPendingTxBuffers(ZX_ERR_CANCELED); | |
| ReturnPendingRxSpace(); | |
| if (!intr_ep_.client().is_valid() || intr_endpoint_dead_) { | |
| intr_cancelled_ = true; | |
| intr_inspect_.SetCancelled(true); | |
| } else { | |
| intr_ep_->CancelAll().Then( | |
| [this](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("intr ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| intr_inspect_.OnCancelAllComplete(); | |
| intr_cancelled_ = true; | |
| CheckStopComplete(); | |
| }); | |
| } | |
| if (!bulk_out_ep_.client().is_valid() || rx_endpoint_dead_) { | |
| bulk_out_cancelled_ = true; | |
| bulk_out_inspect_.SetCancelled(true); | |
| } else { | |
| bulk_out_ep_->CancelAll().Then( | |
| [this](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("bulk out ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| bulk_out_inspect_.OnCancelAllComplete(); | |
| bulk_out_cancelled_ = true; | |
| CheckStopComplete(); | |
| }); | |
| } | |
| if (!bulk_in_ep_.client().is_valid() || tx_endpoint_dead_) { | |
| bulk_in_cancelled_ = true; | |
| bulk_in_inspect_.SetCancelled(true); | |
| } else { | |
| bulk_in_ep_->CancelAll().Then( | |
| [this](fidl::Result<fuchsia_hardware_usb_endpoint::Endpoint::CancelAll> &result) mutable { | |
| if (!result.is_ok() && !IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::warn("bulk in ep CancelAll failed: {}", result.error_value().FormatDescription()); | |
| } | |
| bulk_in_inspect_.OnCancelAllComplete(); | |
| bulk_in_cancelled_ = true; | |
| CheckStopComplete(); | |
| }); | |
| } | |
| CheckStopComplete(); | |
| } | |
| void UsbCdcFunction::CheckStopComplete() { | |
| // CheckStopComplete() is serialized on the driver dispatcher loop. | |
| if (!stop_completer_.has_value()) { | |
| return; | |
| } | |
| DrainRxCompletionQueue(); | |
| ReturnPendingRxSpace(); | |
| bool intr_full = intr_ep_.RequestsFull() || intr_endpoint_dead_; | |
| bool bulk_in_full = bulk_in_ep_.RequestsFull() || tx_endpoint_dead_; | |
| bool bulk_out_full = bulk_out_ep_.RequestsFull() || rx_endpoint_dead_; | |
| fdf::info( | |
| "CheckStopComplete state: intr(full:{}, canc:{}), bulk_in(full:{}, canc:{}), bulk_out(full:{}, canc:{})", | |
| intr_full, intr_cancelled_, bulk_in_full, bulk_in_cancelled_, bulk_out_full, | |
| bulk_out_cancelled_); | |
| if (!intr_full || !intr_cancelled_) { | |
| return; | |
| } | |
| if (!bulk_in_full || !bulk_in_cancelled_) { | |
| return; | |
| } | |
| if (!bulk_out_full || !bulk_out_cancelled_) { | |
| return; | |
| } | |
| if (!deconfigure_called_) { | |
| deconfigure_called_ = true; | |
| fdf::info("All endpoints quiet and cancelled. Disabling and deconfiguring..."); | |
| DisableAllEndpoints([this](zx_status_t status) { | |
| if (status != ZX_OK) { | |
| fdf::error("DisableAllEndpoints failed: {}", zx_status_get_string(status)); | |
| } | |
| if (configured_ || function_inspect_.is_unconfiguring()) { | |
| function_inspect_.RecordEvent("DisableEndpoints complete"); | |
| } | |
| if (async_function_.is_valid()) { | |
| async_function_->Deconfigure().Then( | |
| [this](fidl::Result<fuchsia_hardware_usb_function::UsbFunction::Deconfigure> | |
| &result) mutable { | |
| if (!result.is_ok()) { | |
| if (!IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("Deconfigure failed: {}", result.error_value().FormatDescription()); | |
| } | |
| } else { | |
| fdf::info("Deconfigure completed successfully."); | |
| } | |
| deconfigure_completed_ = true; | |
| CheckStopComplete(); | |
| }); | |
| } else { | |
| deconfigure_completed_ = true; | |
| CheckStopComplete(); | |
| } | |
| }); | |
| return; | |
| } | |
| if (!deconfigure_completed_) { | |
| fdf::info("Waiting for deconfigure to complete"); | |
| return; | |
| } | |
| fdf::info("Deconfigure complete. Invoking stop_completer_."); | |
| if (function_inspect_.is_unconfiguring()) { | |
| function_inspect_.OnUnconfigureComplete(); | |
| } else { | |
| function_inspect_.SetConfigured(false); | |
| } | |
| bulk_out_ep_.SetOnUnbind(nullptr); | |
| bulk_in_ep_.SetOnUnbind(nullptr); | |
| intr_ep_.SetOnUnbind(nullptr); | |
| if (bulk_out_ep_.client().is_valid()) { | |
| bulk_out_ep_.Close(); | |
| } | |
| if (bulk_in_ep_.client().is_valid()) { | |
| bulk_in_ep_.Close(); | |
| } | |
| if (intr_ep_.client().is_valid()) { | |
| intr_ep_.Close(); | |
| } | |
| // Reset all teardown flags so no stale state leaks if driver is reused or stopped again. | |
| deconfigure_called_ = false; | |
| deconfigure_completed_ = false; | |
| intr_cancelled_ = false; | |
| bulk_in_cancelled_ = false; | |
| bulk_out_cancelled_ = false; | |
| auto completer = std::move(*stop_completer_); | |
| stop_completer_.reset(); | |
| completer(zx::ok()); | |
| } | |
| void UsbCdcFunction::Init(fnetdev::wire::NetworkDeviceImplInitRequest *request, fdf::Arena &arena, | |
| InitCompleter::Sync &completer) { | |
| netdevice_ifc_.Bind(std::move(request->iface), driver_dispatcher()->get()); | |
| auto [client, server] = fdf::Endpoints<fnetdev::NetworkPort>::Create(); | |
| fdf::BindServer(driver_dispatcher()->get(), std::move(server), this); | |
| // Add port 1 | |
| netdevice_ifc_.buffer(arena) | |
| ->AddPort(kPortId, std::move(client)) | |
| // Then exactly once so we're sure to complete this transaction even if | |
| // the dispatcher is shut down. | |
| .ThenExactlyOnce( | |
| [completer = completer.ToAsync()]( | |
| fdf::WireUnownedResult<fnetdev::NetworkDeviceIfc::AddPort> &result) mutable { | |
| fdf::Arena arena(kArenaTag); | |
| if (!result.ok()) { | |
| fdf::error("AddPort failed: {}", result.FormatDescription()); | |
| completer.buffer(arena).Reply(result.status()); | |
| return; | |
| } | |
| completer.buffer(arena).Reply(result->status); | |
| }); | |
| } | |
| void UsbCdcFunction::Start(fdf::Arena &arena, StartCompleter::Sync &completer) { | |
| netdevice_started_ = true; | |
| UpdatePortStatus(); | |
| completer.buffer(arena).Reply(ZX_OK); | |
| } | |
| void UsbCdcFunction::Stop(fdf::Arena &arena, StopCompleter::Sync &completer) { | |
| netdevice_started_ = false; | |
| DiscardPendingTxBuffers(ZX_ERR_CANCELED); | |
| ReturnPendingRxSpace(); | |
| completer.buffer(arena).Reply(); | |
| } | |
| void UsbCdcFunction::GetInfo( | |
| fdf::Arena &arena, | |
| fdf::WireServer<fnetdev::NetworkDeviceImpl>::GetInfoCompleter::Sync &completer) { | |
| fnetdev::wire::DeviceImplInfo info = fnetdev::wire::DeviceImplInfo::Builder(arena) | |
| .tx_depth(kTxDepth) | |
| .rx_depth(kRxDepth) | |
| .rx_threshold(kRxDepth / 2) | |
| .max_buffer_parts(1) | |
| .max_buffer_length(BULK_REQ_SIZE) | |
| .buffer_alignment(1) | |
| .min_rx_buffer_length(ETH_MTU) | |
| .min_tx_buffer_length(0) | |
| .Build(); | |
| completer.buffer(arena).Reply(info); | |
| } | |
| void UsbCdcFunction::QueueTx(fnetdev::wire::NetworkDeviceImplQueueTxRequest *request, | |
| fdf::Arena &arena, QueueTxCompleter::Sync &completer) { | |
| const size_t count = request->buffers.size(); | |
| fidl::VectorView<frequest::wire::Request> reqs(arena, count); | |
| size_t reqs_count = 0; | |
| fidl::VectorView<fnetdev::wire::TxResult> results(arena, count); | |
| size_t results_count = 0; | |
| fidl::VectorView<uint32_t> queued_ids(arena, count); | |
| for (const auto &buffer : request->buffers) { | |
| if (unbound_.load() || !online_) { | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_BAD_STATE}; | |
| continue; | |
| } | |
| if (tx_endpoint_dead_) { | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_PEER_CLOSED}; | |
| continue; | |
| } | |
| if (buffer.data.size() != 1) { | |
| fdf::warn("Invalid buffer data size {} for id {}", buffer.data.size(), buffer.id); | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_INVALID_ARGS}; | |
| continue; | |
| } | |
| const auto ®ion = buffer.data[0]; | |
| std::optional<usb::FidlRequest> tx_req = bulk_in_ep_.GetRequest(); | |
| if (!tx_req.has_value()) { | |
| // Given we're matching our request depth to the netdevice depth, this | |
| // shouldn't happen. | |
| fdf::warn("No USB request available for id {}", buffer.id); | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_NO_RESOURCES}; | |
| continue; | |
| } | |
| auto return_request = fit::defer([&]() { bulk_in_ep_.PutRequest(std::move(tx_req.value())); }); | |
| auto *stored_vmo = vmo_store_.GetVmo(region.vmo); | |
| if (!stored_vmo) { | |
| fdf::warn("No VMO found for id {}", region.vmo); | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_INVALID_ARGS}; | |
| continue; | |
| } | |
| auto data = stored_vmo->data(); | |
| if (region.length == 0) { | |
| results[results_count++] = {.id = buffer.id, .status = ZX_OK}; | |
| continue; | |
| } | |
| if (region.length > data.size() || region.offset > data.size() - region.length) { | |
| fdf::warn("Invalid VMO region for id {}", region.vmo); | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_INVALID_ARGS}; | |
| continue; | |
| } | |
| tx_req->clear_buffers(); | |
| zx::result<std::vector<size_t>> actual = tx_req->CachedCopyTo( | |
| 0, data.data() + region.offset, region.length, bulk_in_ep_.GetMapped()); | |
| if (actual.is_error()) { | |
| fdf::warn("failed to copy data and flush cache: {}", actual.status_string()); | |
| results[results_count++] = {.id = buffer.id, .status = actual.error_value()}; | |
| continue; | |
| } | |
| size_t actual_total = 0; | |
| for (size_t i = 0; i < actual->size(); i++) { | |
| (*tx_req)->data()->at(i).size((*actual)[i]); | |
| actual_total += (*actual)[i]; | |
| } | |
| // CDC always needs a short packet to terminate the transfer. | |
| (*tx_req)->short_(true); | |
| if (actual_total != region.length) { | |
| fdf::warn("failed to copy all data {} {}", actual_total, region.length); | |
| results[results_count++] = {.id = buffer.id, .status = ZX_ERR_INTERNAL}; | |
| continue; | |
| } | |
| return_request.cancel(); | |
| queued_ids[reqs_count] = buffer.id; | |
| reqs[reqs_count++] = fidl::ToWire(arena, tx_req->take_request()); | |
| } | |
| if (results_count > 0 && netdevice_ifc_.is_valid()) { | |
| fidl::OneWayStatus status = netdevice_ifc_.buffer(arena)->CompleteTx( | |
| fidl::VectorView<fnetdev::wire::TxResult>::FromExternal(results.data(), results_count)); | |
| if (!status.ok()) { | |
| fdf::error("failed to complete tx: {}", status.FormatDescription()); | |
| } | |
| } | |
| if (reqs_count > 0) { | |
| fidl::OneWayStatus queue_status = bulk_in_ep_.client().wire()->QueueRequests( | |
| fidl::VectorView<frequest::wire::Request>::FromExternal(reqs.data(), reqs_count)); | |
| if (!queue_status.ok()) { | |
| fdf::error("failed to queue tx requests: {}", queue_status.FormatDescription()); | |
| for (size_t i = 0; i < reqs_count; ++i) { | |
| bulk_in_ep_.PutRequest(usb::FidlRequest(fidl::ToNatural(reqs[i]))); | |
| } | |
| fidl::VectorView<fnetdev::wire::TxResult> fail_results(arena, reqs_count); | |
| for (size_t i = 0; i < reqs_count; ++i) { | |
| fail_results[i] = {.id = queued_ids[i], .status = ZX_ERR_INTERNAL}; | |
| } | |
| if (netdevice_ifc_.is_valid()) { | |
| fidl::OneWayStatus fail_status = netdevice_ifc_.buffer(arena)->CompleteTx(fail_results); | |
| if (!fail_status.ok()) { | |
| fdf::error("failed to complete failed tx requests: {}", fail_status.FormatDescription()); | |
| } | |
| } | |
| } else { | |
| for (size_t i = 0; i < reqs_count; ++i) { | |
| tx_completion_queue_.push_back(queued_ids[i]); | |
| } | |
| } | |
| } | |
| bulk_in_inspect_.UpdateTxQueue(bulk_in_ep_.GetInFlightCount()); | |
| } | |
| void UsbCdcFunction::QueueRxSpace(fnetdev::wire::NetworkDeviceImplQueueRxSpaceRequest *request, | |
| fdf::Arena &arena, QueueRxSpaceCompleter::Sync &completer) { | |
| if (unbound_.load() || !netdevice_started_) { | |
| const size_t count = request->buffers.size(); | |
| fidl::VectorView<fnetdev::wire::RxBuffer> rx_buffers(arena, count); | |
| fidl::VectorView<fnetdev::wire::RxBufferPart> rx_buffers_parts(arena, count); | |
| for (size_t i = 0; i < count; ++i) { | |
| const auto &buffer = request->buffers[i]; | |
| rx_buffers_parts[i] = { | |
| .id = buffer.id, | |
| .offset = 0, | |
| .length = 0, | |
| }; | |
| rx_buffers[i] = { | |
| .meta = | |
| { | |
| .port = kPortId, | |
| .frame_type = fuchsia_hardware_network::FrameType::kEthernet, | |
| }, | |
| .data = | |
| fidl::VectorView<fnetdev::wire::RxBufferPart>::FromExternal(&rx_buffers_parts[i], 1), | |
| }; | |
| } | |
| if (count > 0 && netdevice_ifc_.is_valid()) { | |
| fidl::OneWayStatus fidl_status = netdevice_ifc_.buffer(arena)->CompleteRx(rx_buffers); | |
| if (!fidl_status.ok()) { | |
| fdf::error("Failed to complete rx: {}", fidl_status.FormatDescription()); | |
| } | |
| } | |
| return; | |
| } | |
| for (const auto &buffer : request->buffers) { | |
| rx_space_buffers_.push(buffer); | |
| } | |
| if (rx_completion_queue_.empty()) { | |
| return; | |
| } | |
| // Take over all pending completions and process them. We'll re-queue if | |
| // not enough space available. | |
| ProcessRxCompletions(std::move(rx_completion_queue_)); | |
| } | |
| void UsbCdcFunction::PrepareVmo(fnetdev::wire::NetworkDeviceImplPrepareVmoRequest *request, | |
| fdf::Arena &arena, PrepareVmoCompleter::Sync &completer) { | |
| zx_status_t status = vmo_store_.RegisterWithKey(request->id, std::move(request->vmo)); | |
| if (status != ZX_OK) { | |
| fdf::error("failed to register vmo {}: {}", request->id, zx_status_get_string(status)); | |
| } | |
| completer.buffer(arena).Reply(status); | |
| } | |
| void UsbCdcFunction::ReleaseVmo(fnetdev::wire::NetworkDeviceImplReleaseVmoRequest *request, | |
| fdf::Arena &arena, ReleaseVmoCompleter::Sync &completer) { | |
| zx::result status = vmo_store_.Unregister(request->id); | |
| if (!status.is_ok()) { | |
| fdf::error("failed to unregister vmo {}: {}", request->id, status.status_string()); | |
| } | |
| completer.buffer(arena).Reply(); | |
| } | |
| void UsbCdcFunction::GetInfo( | |
| fdf::Arena &arena, fdf::WireServer<fnetdev::NetworkPort>::GetInfoCompleter::Sync &completer) { | |
| static constexpr fuchsia_hardware_network::wire::FrameType kRxTypes[] = { | |
| fuchsia_hardware_network::wire::FrameType::kEthernet}; | |
| static constexpr fuchsia_hardware_network::wire::FrameTypeSupport kTxTypes[] = {{ | |
| .type = fuchsia_hardware_network::wire::FrameType::kEthernet, | |
| .features = fuchsia_hardware_network::wire::kFrameFeaturesRaw, | |
| }}; | |
| fuchsia_hardware_network::wire::PortBaseInfo info = | |
| fuchsia_hardware_network::wire::PortBaseInfo::Builder(arena) | |
| .port_class(fuchsia_hardware_network::wire::PortClass::kEthernet) | |
| .rx_types(fidl::VectorView<fuchsia_hardware_network::wire::FrameType>::FromExternal( | |
| const_cast<fuchsia_hardware_network::wire::FrameType *>(kRxTypes), 1)) | |
| .tx_types( | |
| fidl::VectorView<fuchsia_hardware_network::wire::FrameTypeSupport>::FromExternal( | |
| const_cast<fuchsia_hardware_network::wire::FrameTypeSupport *>(kTxTypes), 1)) | |
| .Build(); | |
| completer.buffer(arena).Reply(info); | |
| } | |
| void UsbCdcFunction::GetStatus(fdf::Arena &arena, GetStatusCompleter::Sync &completer) { | |
| completer.buffer(arena).Reply(fidl::ToWire(arena, ReadStatus())); | |
| } | |
| void UsbCdcFunction::SetActive(fnetdev::wire::NetworkPortSetActiveRequest *request, | |
| fdf::Arena &arena, SetActiveCompleter::Sync &completer) {} | |
| void UsbCdcFunction::GetMac(fdf::Arena &arena, GetMacCompleter::Sync &completer) { | |
| auto [client, server] = fdf::Endpoints<fnetdev::MacAddr>::Create(); | |
| fdf::BindServer(fdf::Dispatcher::GetCurrent()->get(), std::move(server), this); | |
| completer.buffer(arena).Reply(std::move(client)); | |
| } | |
| void UsbCdcFunction::Removed(fdf::Arena &arena, RemovedCompleter::Sync &completer) {} | |
| void UsbCdcFunction::GetPowerDependencyToken(fdf::Arena &arena, | |
| GetPowerDependencyTokenCompleter::Sync &completer) { | |
| completer.buffer(arena).Reply(zx::event{}); | |
| } | |
| void UsbCdcFunction::GetAddress(fdf::Arena &arena, GetAddressCompleter::Sync &completer) { | |
| fuchsia_net::wire::MacAddress mac; | |
| memcpy(mac.octets.data(), mac_addr_.data(), mac_addr_.size()); | |
| completer.buffer(arena).Reply(mac); | |
| } | |
| void UsbCdcFunction::GetFeatures(fdf::Arena &arena, GetFeaturesCompleter::Sync &completer) { | |
| fnetdev::wire::Features features = | |
| fnetdev::wire::Features::Builder(arena) | |
| .multicast_filter_count(0) | |
| .supported_modes(fnetdev::wire::SupportedMacFilterMode::kPromiscuous) | |
| .Build(); | |
| completer.buffer(arena).Reply(features); | |
| } | |
| void UsbCdcFunction::SetMode(fnetdev::wire::MacAddrSetModeRequest *request, fdf::Arena &arena, | |
| SetModeCompleter::Sync &completer) { | |
| completer.buffer(arena).Reply(); | |
| } | |
| fuchsia_hardware_network::PortStatus UsbCdcFunction::ReadStatus() const { | |
| fuchsia_hardware_network::PortStatus status; | |
| status.mtu(ETH_MTU); | |
| fuchsia_hardware_network::StatusFlags flags; | |
| if (online_) { | |
| flags |= fuchsia_hardware_network::StatusFlags::kOnline; | |
| } | |
| status.flags(flags); | |
| return status; | |
| } | |
| void UsbCdcFunction::UpdatePortStatus() { | |
| if (netdevice_ifc_.is_valid()) { | |
| fdf::Arena arena(kArenaTag); | |
| fidl::OneWayStatus status = | |
| netdevice_ifc_.buffer(arena)->PortStatusChanged(kPortId, fidl::ToWire(arena, ReadStatus())); | |
| if (!status.ok()) { | |
| fdf::error("Failed to notify port status: {}", status.FormatDescription()); | |
| } | |
| } | |
| } | |
| bool UsbCdcFunction::HasPendingRxCompletions() { return !rx_completion_queue_.empty(); } | |
| void UsbCdcFunction::DisableAllEndpoints(fit::callback<void(zx_status_t)> callback) { | |
| fdf::info("Disabling all endpoints asynchronously..."); | |
| if (!async_function_.is_valid()) { | |
| std::move(callback)(ZX_OK); | |
| return; | |
| } | |
| struct SharedState { | |
| size_t pending = 3; | |
| zx_status_t status = ZX_OK; | |
| fit::callback<void(zx_status_t)> callback; | |
| }; | |
| auto state = std::make_shared<SharedState>(); | |
| state->callback = std::move(callback); | |
| for (const uint8_t ep_addr : {InterruptAddress(), BulkOutAddress(), BulkInAddress()}) { | |
| async_function_->DisableEndpoint({ep_addr}).Then( | |
| [state, ep_addr]( | |
| fidl::Result<fuchsia_hardware_usb_function::UsbFunction::DisableEndpoint> &result) { | |
| if (result.is_error()) { | |
| if (!IsExpectedFidlDisconnect(result.error_value())) { | |
| fdf::error("Failed to disable endpoint {}: {}", ep_addr, | |
| result.error_value().FormatDescription()); | |
| if (state->status == ZX_OK) { | |
| state->status = ZX_ERR_INTERNAL; | |
| } | |
| } | |
| } | |
| state->pending--; | |
| if (state->pending == 0 && state->callback) { | |
| std::move(state->callback)(state->status); | |
| } | |
| }); | |
| } | |
| } | |
| } // namespace usb_cdc_function | |
| FUCHSIA_DRIVER_EXPORT2(usb_cdc_function::UsbCdcFunction); |