| // Copyright 2019 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. |
| |
| #pragma once |
| |
| #include <ddk/device.h> |
| #include <ddktl/device.h> |
| #include <ddktl/protocol/usb/bus.h> |
| #include <ddktl/protocol/usb/dci.h> |
| #include <ddktl/protocol/usb/hci.h> |
| #include <fbl/condition_variable.h> |
| #include <fbl/mutex.h> |
| #include <fbl/unique_ptr.h> |
| #include <lib/sync/completion.h> |
| #include <usb/request-cpp.h> |
| |
| #include <threads.h> |
| |
| #include "usb-virtual-device.h" |
| #include "usb-virtual-host.h" |
| |
| namespace usb_virtual_bus { |
| |
| class UsbVirtualBus; |
| class UsbVirtualDevice; |
| class UsbVirtualHost; |
| using UsbVirtualBusType = ddk::Device<UsbVirtualBus, ddk::Unbindable, ddk::Messageable>; |
| |
| // This is the main class for the USB virtual bus. |
| class UsbVirtualBus : public UsbVirtualBusType { |
| public: |
| explicit UsbVirtualBus(zx_device_t* parent) |
| : UsbVirtualBusType(parent) {} |
| |
| static zx_status_t Create(zx_device_t* parent); |
| |
| // Device protocol implementation. |
| zx_status_t DdkMessage(fidl_msg_t* msg, fidl_txn_t* txn); |
| void DdkUnbind(); |
| void DdkRelease(); |
| |
| // USB device controller protocol implementation. |
| void UsbDciRequestQueue(usb_request_t* usb_request, const usb_request_complete_t* complete_cb); |
| zx_status_t UsbDciSetInterface(const usb_dci_interface_protocol_t* interface); |
| zx_status_t UsbDciConfigEp(const usb_endpoint_descriptor_t* ep_desc, |
| const usb_ss_ep_comp_descriptor_t* ss_comp_desc); |
| zx_status_t UsbDciDisableEp(uint8_t ep_address); |
| zx_status_t UsbDciEpSetStall(uint8_t ep_address); |
| zx_status_t UsbDciEpClearStall(uint8_t ep_address); |
| zx_status_t UsbDciCancelAll(uint8_t endpoint); |
| size_t UsbDciGetRequestSize(); |
| |
| // USB host controller protocol implementation. |
| void UsbHciRequestQueue(usb_request_t* usb_request, const usb_request_complete_t* complete_cb); |
| void UsbHciSetBusInterface(const usb_bus_interface_protocol_t* bus_intf); |
| size_t UsbHciGetMaxDeviceCount(); |
| zx_status_t UsbHciEnableEndpoint(uint32_t device_id, const usb_endpoint_descriptor_t* ep_desc, |
| const usb_ss_ep_comp_descriptor_t* ss_com_desc, bool enable); |
| uint64_t UsbHciGetCurrentFrame(); |
| zx_status_t UsbHciConfigureHub(uint32_t device_id, usb_speed_t speed, |
| const usb_hub_descriptor_t* desc, bool multi_tt); |
| zx_status_t UsbHciHubDeviceAdded(uint32_t device_id, uint32_t port, usb_speed_t speed); |
| zx_status_t UsbHciHubDeviceRemoved(uint32_t device_id, uint32_t port); |
| zx_status_t UsbHciHubDeviceReset(uint32_t device_id, uint32_t port); |
| zx_status_t UsbHciResetEndpoint(uint32_t device_id, uint8_t ep_address); |
| zx_status_t UsbHciResetDevice(uint32_t hub_address, uint32_t device_id); |
| size_t UsbHciGetMaxTransferSize(uint32_t device_id, uint8_t ep_address); |
| zx_status_t UsbHciCancelAll(uint32_t device_id, uint8_t ep_address); |
| size_t UsbHciGetRequestSize(); |
| |
| // FIDL messages |
| zx_status_t MsgEnable(fidl_txn_t* txn); |
| zx_status_t MsgDisable(fidl_txn_t* txn); |
| zx_status_t MsgConnect(fidl_txn_t* txn); |
| zx_status_t MsgDisconnect(fidl_txn_t* txn); |
| |
| private: |
| DISALLOW_COPY_ASSIGN_AND_MOVE(UsbVirtualBus); |
| |
| using Request = usb::UnownedRequest<void>; |
| using RequestQueue = usb::UnownedRequestQueue<void>; |
| |
| // This struct represents an endpoint on the virtual device. |
| struct usb_virtual_ep_t { |
| RequestQueue host_reqs; |
| RequestQueue device_reqs; |
| uint16_t max_packet_size = 0; |
| // Offset into current host req, for dealing with host reqs that are bigger than |
| // their matching device req. |
| zx_off_t req_offset = 0; |
| bool stalled = false; |
| }; |
| |
| zx_status_t Init(); |
| zx_status_t CreateDevice(); |
| zx_status_t CreateHost(); |
| void SetConnected(bool connected); |
| int DeviceThread(); |
| void HandleControl(Request req); |
| zx_status_t SetStall(uint8_t ep_address, bool stall); |
| |
| // Reference to class that implements the virtual device controller protocol. |
| fbl::unique_ptr<UsbVirtualDevice> device_; |
| // Reference to class that implements the virtual host controller protocol. |
| fbl::unique_ptr<UsbVirtualHost> host_; |
| |
| // Callbacks to the USB peripheral driver. |
| ddk::UsbDciInterfaceProtocolClient dci_intf_; |
| // Callbacks to the USB bus driver. |
| ddk::UsbBusInterfaceProtocolClient bus_intf_; |
| |
| usb_virtual_ep_t eps_[USB_MAX_EPS]; |
| |
| thrd_t device_thread_; |
| // Host-side lock |
| fbl::Mutex lock_; |
| fbl::ConditionVariable thread_signal_ __TA_GUARDED(lock_); |
| |
| // Device-side lock |
| fbl::Mutex device_lock_ __TA_ACQUIRED_AFTER(lock_); |
| fbl::ConditionVariable device_signal_ __TA_GUARDED(device_lock_); |
| fbl::Mutex connection_lock_ __TA_ACQUIRED_BEFORE(device_lock_); |
| // True when the virtual bus is connected. |
| bool connected_ __TA_GUARDED(connection_lock_) = false; |
| // Used to shut down our thread when this driver is unbinding. |
| bool unbinding_ __TA_GUARDED(device_lock_) = false; |
| }; |
| |
| } // namespace usb_virtual_bus |