| // Copyright 2021 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/devices/usb/drivers/xhci/xhci-device-state.h" |
| |
| #include "src/devices/usb/drivers/xhci/usb-xhci.h" |
| |
| namespace usb_xhci { |
| |
| DeviceState::~DeviceState() { |
| // Each DeviceState corresponds to one slot. When the device is removed, we should call |
| // DisableSlotCommand on the corresponding slot. |
| if (hci_) { |
| auto status = |
| hci_->RunSynchronously(kPrimaryInterrupter, hci_->DisableSlotCommand(*this).box()); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Could not DisableSlot for %u on DeviceState destruction %d", GetSlot(), |
| status); |
| } |
| } |
| |
| fbl::AutoLock _(&transaction_lock_); |
| disconnecting_ = true; |
| input_context_.reset(); |
| device_context_.reset(); |
| slot_ = 0; |
| hub_.reset(); |
| } |
| |
| zx_status_t DeviceState::InitEndpoint(uint8_t ep_addr, EventRing* event_ring, fdf::MmioBuffer* mmio) |
| __TA_REQUIRES(transaction_lock_) { |
| return GetEndpoint(XhciEndpointIndex(ep_addr) - 1).Init(event_ring, mmio); |
| } |
| |
| zx_status_t DeviceState::InitializeSlotBuffer(const UsbXhci& hci, uint8_t slot_id, uint8_t port_id, |
| const std::optional<HubInfo>& hub_info, |
| std::unique_ptr<dma_buffer::PagedBuffer>* out) { |
| // Section 4.3.3 |
| // 6.2.5 (Input Context initialization) |
| std::unique_ptr<dma_buffer::PagedBuffer> buffer; |
| zx_status_t status = |
| hci.buffer_factory().CreatePaged(hci.bti(), zx_system_get_page_size(), false, &buffer); |
| if (status != ZX_OK) { |
| return status; |
| } |
| if (hci.Is32BitController() && (buffer->phys()[0] >= UINT32_MAX)) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| // 6.2.5.1 -- Initialize input control context |
| // NOTE: Input Control Context consumes 64 bytes if CSZ is 1 |
| // Enable bit starts at offset 2 |
| auto control = static_cast<uint32_t*>(buffer->virt()); |
| control[1] = 0x3; // Enable both slot and endpoint context. |
| size_t slot_size = hci.slot_size_bytes(); |
| // Initialize input slot context data structure (6.2.2) with 1 context entry |
| // Set root hub port number to port number and context entries to 1 |
| auto slot_context = |
| reinterpret_cast<SlotContext*>(reinterpret_cast<unsigned char*>(control) + slot_size); |
| if (hub_info) { |
| slot_context->set_CONTEXT_ENTRIES(1) |
| .set_ROUTE_STRING(hub_info->route_string) |
| .set_PORTNO(hub_info->rh_port) |
| .set_SPEED(hub_info->speed) |
| .set_INTERRUPTER_TARGET(interrupter_target_); |
| } else { |
| slot_context->set_CONTEXT_ENTRIES(1).set_PORTNO(port_id).set_SPEED(hci.GetPortSpeed(port_id)); |
| } |
| *out = std::move(buffer); |
| return ZX_OK; |
| } |
| |
| zx_status_t DeviceState::InitializeEndpointContext(const UsbXhci& hci, uint8_t slot_id, |
| uint8_t port_id, |
| std::optional<HubInfo>& hub_info, |
| dma_buffer::PagedBuffer* slot_context_buffer) { |
| CRCR trb_phys = tr_.transfer_ring().phys(hci.CapLength()); |
| auto* control = static_cast<uint32_t*>(slot_context_buffer->virt()); |
| size_t slot_size = hci.slot_size_bytes(); |
| auto slot_context = |
| reinterpret_cast<SlotContext*>(reinterpret_cast<unsigned char*>(control) + slot_size); |
| // Initialize endpoint context 0 |
| // Set CERR to 3, TR dequeue pointer, max packet size, EP type = control, DCS = 1 |
| auto endpoint_context = reinterpret_cast<EndpointContext*>( |
| reinterpret_cast<unsigned char*>(control) + (slot_size * 2)); |
| uint16_t mps = 8; |
| usb_speed_t speed; |
| if (hub_info) { |
| speed = static_cast<uint8_t>(hub_info->speed); |
| // TODO(https://fxbug.dev/42109653): USB 3.1 support. Section 6.2.2 |
| if (((speed == USB_SPEED_LOW) || (speed == USB_SPEED_FULL)) && |
| (hub_info->hub_speed == USB_SPEED_HIGH)) { |
| hub_info->tt_info.emplace( |
| tt_info_t{.tt_slot_id = hub_info->hub_state->GetSlot(), .tt_port_number = port_id}); |
| } |
| if (hub_info->tt_info) { |
| slot_context->set_PARENT_HUB_SLOT_ID(hub_info->tt_info->tt_slot_id) |
| .set_PARENT_PORT_NUMBER(hub_info->tt_info->tt_port_number); |
| } |
| } else { |
| speed = hci.GetPortSpeed(port_id); |
| } |
| switch (speed) { |
| case USB_SPEED_SUPER: |
| mps = 512; |
| break; |
| case USB_SPEED_FULL: |
| case USB_SPEED_HIGH: |
| mps = 64; |
| break; |
| case USB_SPEED_LOW: |
| default: |
| mps = 8; |
| break; |
| } |
| endpoint_context->Init(EndpointContext::Control, trb_phys, mps); |
| return ZX_OK; |
| } |
| |
| zx_status_t DeviceState::InitializeOutputContextBuffer( |
| const UsbXhci& hci, uint8_t slot_id, uint8_t port_id, const std::optional<HubInfo>& hub_info, |
| uint64_t* dcbaa, std::unique_ptr<dma_buffer::PagedBuffer>* out) { |
| // Allocate an output device context data structure (6.2.1) |
| // Update the DCBAA entry for this slot. |
| std::unique_ptr<dma_buffer::PagedBuffer> output_context_buffer; |
| zx_status_t status = hci.buffer_factory().CreatePaged(hci.bti(), zx_system_get_page_size(), false, |
| &output_context_buffer); |
| if (status != ZX_OK) { |
| return status; |
| } |
| if (hci.Is32BitController() && (output_context_buffer->phys()[0] >= UINT32_MAX)) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| dcbaa[slot_id] = output_context_buffer->phys()[0]; |
| if (!hub_info) { |
| slot_id = static_cast<uint8_t>(slot_id); |
| } |
| hub_ = hub_info; |
| hw_mb(); |
| *out = std::move(output_context_buffer); |
| return ZX_OK; |
| } |
| |
| TRBPromise DeviceState::AddressDeviceCommand(UsbXhci* hci, uint8_t slot, uint8_t port, |
| std::optional<HubInfo> hub_info, uint64_t* dcbaa, |
| uint16_t interrupter_target, CommandRing* command_ring, |
| fdf::MmioBuffer* mmio, bool bsr) { |
| if (!hub_info.has_value()) { |
| hci->GetPortState()[port - 1].slot_id = slot; |
| } |
| interrupter_target_ = interrupter_target; |
| std::unique_ptr<dma_buffer::PagedBuffer> slot_context_buffer; |
| std::unique_ptr<dma_buffer::PagedBuffer> output_context_buffer; |
| zx_status_t status = InitializeSlotBuffer(*hci, slot, port, hub_info, &slot_context_buffer); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Failed to initialize slot buffer: %s", zx_status_get_string(status)); |
| return fpromise::make_error_promise(status); |
| } |
| |
| // Allocate the transfer ring (see section 4.9) |
| fbl::AutoLock _(&transaction_lock_); |
| status = tr_.Init(&hci->interrupter(interrupter_target).ring(), mmio); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Failed to allocate the transfer ring: %s", zx_status_get_string(status)); |
| return fpromise::make_result_promise( |
| fpromise::result<TRB*, zx_status_t>(fpromise::error(status))) |
| .box(); |
| } |
| |
| status = InitializeEndpointContext(*hci, slot, port, hub_info, slot_context_buffer.get()); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Failed to initialize endpoint context: %s", zx_status_get_string(status)); |
| return fpromise::make_result_promise( |
| fpromise::result<TRB*, zx_status_t>(fpromise::error(status))) |
| .box(); |
| } |
| |
| status = InitializeOutputContextBuffer(*hci, slot, port, hub_info, dcbaa, &output_context_buffer); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Failed to initialize output context buffer: %s", zx_status_get_string(status)); |
| return fpromise::make_result_promise( |
| fpromise::result<TRB*, zx_status_t>(fpromise::error(status))) |
| .box(); |
| } |
| |
| // Issue an address device command for the device slot |
| // See sections 3.3.4 and 6.4.3.4 |
| usb_xhci::AddressDeviceStruct command; |
| command.ptr = slot_context_buffer->phys()[0]; |
| command.set_SlotID(slot); |
| command.set_BSR(bsr); |
| auto command_context = command_ring->AllocateContext(); |
| if (!command_context) { |
| zxlogf(ERROR, "No memory."); |
| return fpromise::make_result_promise( |
| fpromise::result<TRB*, zx_status_t>(fpromise::error(ZX_ERR_NO_MEMORY))) |
| .box(); |
| } |
| command_context->port_number = port; |
| hw_mb(); |
| input_context_ = std::move(slot_context_buffer); |
| device_context_ = std::move(output_context_buffer); |
| return hci->SubmitCommand(command, std::move(command_context)); |
| } |
| |
| void DeviceState::CreateInspectNode(inspect::Node node, uint16_t vendor_id, uint16_t product_id) { |
| inspect_node_ = std::move(node); |
| |
| char vendor_id_string[5]; |
| snprintf(vendor_id_string, sizeof(vendor_id_string), "%04x", vendor_id); |
| vendor_id_ = inspect_node_.CreateString("Vendor ID", vendor_id_string); |
| |
| char product_id_string[5]; |
| snprintf(product_id_string, sizeof(product_id_string), "%04x", product_id); |
| product_id_ = inspect_node_.CreateString("Product ID", product_id_string); |
| } |
| |
| } // namespace usb_xhci |
