| // 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 <lib/fit/defer.h> |
| |
| #include "src/devices/usb/drivers/dwc3/dwc3-regs.h" |
| #include "src/devices/usb/drivers/dwc3/dwc3-types.h" |
| #include "src/devices/usb/drivers/dwc3/dwc3.h" |
| |
| namespace dwc3 { |
| |
| void Dwc3::HandleEpEvent(uint32_t event) { |
| const uint32_t type = DEPEVT_TYPE(event); |
| const uint8_t ep_num = DEPEVT_PHYS_EP(event); |
| const uint32_t status = DEPEVT_STATUS(event); |
| |
| switch (type) { |
| case DEPEVT_XFER_COMPLETE: |
| zxlogf(SERIAL, "ep[%u] DEPEVT_XFER_COMPLETE", ep_num); |
| HandleEpTransferCompleteEvent(ep_num); |
| break; |
| case DEPEVT_XFER_IN_PROGRESS: |
| zxlogf(SERIAL, "ep[%u] DEPEVT_XFER_IN_PROGRESS: status %u", ep_num, status); |
| break; |
| case DEPEVT_XFER_NOT_READY: |
| zxlogf(SERIAL, "ep[%u] DEPEVT_XFER_NOT_READY", ep_num); |
| HandleEpTransferNotReadyEvent(ep_num, DEPEVT_XFER_NOT_READY_STAGE(event)); |
| break; |
| case DEPEVT_STREAM_EVT: |
| zxlogf(SERIAL, "ep[%u] DEPEVT_STREAM_EVT ep_num: status %u", ep_num, status); |
| break; |
| case DEPEVT_CMD_CMPLT: { |
| uint32_t cmd_type = DEPEVT_CMD_CMPLT_CMD_TYPE(event); |
| uint32_t rsrc_id = DEPEVT_CMD_CMPLT_RSRC_ID(event); |
| zxlogf(SERIAL, "ep[%u] DEPEVT_CMD_COMPLETE: type %u rsrc_id %u", ep_num, cmd_type, rsrc_id); |
| if (cmd_type == DEPCMD::DEPSTRTXFER) { |
| HandleEpTransferStartedEvent(ep_num, rsrc_id); |
| } |
| break; |
| } |
| default: |
| zxlogf(ERROR, "dwc3_handle_ep_event: unknown event type %u", type); |
| break; |
| } |
| } |
| |
| void Dwc3::HandleEvent(uint32_t event) { |
| if (!(event & DEPEVT_NON_EP)) { |
| HandleEpEvent(event); |
| return; |
| } |
| |
| uint32_t type = DEVT_TYPE(event); |
| uint32_t info = DEVT_INFO(event); |
| |
| switch (type) { |
| case DEVT_DISCONNECT: |
| zxlogf(SERIAL, "DEVT_DISCONNECT"); |
| break; |
| case DEVT_USB_RESET: |
| zxlogf(SERIAL, "DEVT_USB_RESET"); |
| HandleResetEvent(); |
| break; |
| case DEVT_CONNECTION_DONE: |
| zxlogf(SERIAL, "DEVT_CONNECTION_DONE"); |
| HandleConnectionDoneEvent(); |
| break; |
| case DEVT_LINK_STATE_CHANGE: |
| zxlogf(SERIAL, "DEVT_LINK_STATE_CHANGE: "); |
| switch (info) { |
| case DSTS::USBLNKST_U0 | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS::USBLNKST_U0"); |
| break; |
| case DSTS::USBLNKST_U1 | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_U1"); |
| break; |
| case DSTS::USBLNKST_U2 | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_U2"); |
| break; |
| case DSTS::USBLNKST_U3 | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_U3"); |
| break; |
| case DSTS::USBLNKST_ESS_DIS | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_ESS_DIS"); |
| break; |
| case DSTS::USBLNKST_RX_DET | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_RX_DET"); |
| break; |
| case DSTS::USBLNKST_ESS_INACT | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_ESS_INACT"); |
| break; |
| case DSTS::USBLNKST_POLL | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_POLL"); |
| break; |
| case DSTS::USBLNKST_RECOV | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_RECOV"); |
| break; |
| case DSTS::USBLNKST_HRESET | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_HRESET"); |
| break; |
| case DSTS::USBLNKST_CMPLY | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_CMPLY"); |
| break; |
| case DSTS::USBLNKST_LPBK | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_LPBK"); |
| break; |
| case DSTS::USBLNKST_RESUME_RESET | DEVT_LINK_STATE_CHANGE_SS: |
| zxlogf(SERIAL, "DSTS_USBLNKST_RESUME_RESET"); |
| break; |
| case DSTS::USBLNKST_ON: |
| zxlogf(SERIAL, "DSTS_USBLNKST_ON"); |
| break; |
| case DSTS::USBLNKST_SLEEP: |
| zxlogf(SERIAL, "DSTS_USBLNKST_SLEEP"); |
| break; |
| case DSTS::USBLNKST_SUSPEND: |
| zxlogf(SERIAL, "DSTS_USBLNKST_SUSPEND"); |
| break; |
| case DSTS::USBLNKST_DISCONNECTED: |
| zxlogf(SERIAL, "DSTS_USBLNKST_DISCONNECTED"); |
| break; |
| case DSTS::USBLNKST_EARLY_SUSPEND: |
| zxlogf(SERIAL, "DSTS_USBLNKST_EARLY_SUSPEND"); |
| break; |
| case DSTS::USBLNKST_RESET: |
| zxlogf(SERIAL, "DSTS_USBLNKST_RESET"); |
| break; |
| case DSTS::USBLNKST_RESUME: |
| zxlogf(SERIAL, "DSTS_USBLNKST_RESUME"); |
| break; |
| default: |
| zxlogf(ERROR, "unknown state %d", info); |
| break; |
| } |
| break; |
| case DEVT_REMOTE_WAKEUP: |
| zxlogf(SERIAL, "DEVT_REMOTE_WAKEUP"); |
| break; |
| case DEVT_HIBERNATE_REQUEST: |
| zxlogf(SERIAL, "DEVT_HIBERNATE_REQUEST"); |
| break; |
| case DEVT_SUSPEND_ENTRY: |
| zxlogf(SERIAL, "DEVT_SUSPEND_ENTRY"); |
| // TODO(voydanoff) is this the best way to detect disconnect? |
| HandleDisconnectedEvent(); |
| break; |
| case DEVT_SOF: |
| zxlogf(SERIAL, "DEVT_SOF"); |
| break; |
| case DEVT_ERRATIC_ERROR: |
| zxlogf(SERIAL, "DEVT_ERRATIC_ERROR"); |
| break; |
| case DEVT_COMMAND_COMPLETE: |
| zxlogf(SERIAL, "DEVT_COMMAND_COMPLETE"); |
| break; |
| case DEVT_EVENT_BUF_OVERFLOW: |
| zxlogf(SERIAL, "DEVT_EVENT_BUF_OVERFLOW"); |
| break; |
| case DEVT_VENDOR_TEST_LMP: |
| zxlogf(SERIAL, "DEVT_VENDOR_TEST_LMP"); |
| break; |
| case DEVT_STOPPED_DISCONNECT: |
| zxlogf(SERIAL, "DEVT_STOPPED_DISCONNECT"); |
| break; |
| case DEVT_L1_RESUME_DETECT: |
| zxlogf(SERIAL, "DEVT_L1_RESUME_DETECT"); |
| break; |
| case DEVT_LDM_RESPONSE: |
| zxlogf(SERIAL, "DEVT_LDM_RESPONSE"); |
| break; |
| default: |
| zxlogf(ERROR, "dwc3_handle_event: unknown event type %u", type); |
| break; |
| } |
| } |
| |
| int Dwc3::IrqThread() { |
| auto* mmio = get_mmio(); |
| const uint32_t* const ring_start = static_cast<const uint32_t*>(event_buffer_.virt()); |
| const uint32_t* const ring_end = ring_start + (kEventBufferSize / sizeof(*ring_start)); |
| const uint32_t* ring_cur = ring_start; |
| bool shutdown_now = false; |
| |
| while (!shutdown_now) { |
| // Perform the callbacks for any requests which are pending completion. |
| for (auto req = pending_completions_.pop(); req; req = pending_completions_.pop()) { |
| const zx_status_t status = req->request()->response.status; |
| const zx_off_t actual = req->request()->response.actual; |
| req->Complete(status, actual); |
| } |
| |
| // Wait for a new interrupt. |
| zx_port_packet_t wakeup_pkt; |
| if (zx_status_t status = irq_port_.wait(zx::time::infinite(), &wakeup_pkt); status != ZX_OK) { |
| zxlogf(ERROR, "Dwc3::IrqThread: zx_port_wait returned %s", zx_status_get_string(status)); |
| shutdown_now = true; |
| continue; |
| } |
| |
| // Was this an actual HW interrupt? If so, process any new events in the |
| // event buffer. |
| if (wakeup_pkt.type == ZX_PKT_TYPE_INTERRUPT) { |
| // Our interrupt should be edge triggered, so go ahead and ack and re-enable |
| // it now so that we don't accidentally miss any new interrupts while |
| // process these. |
| irq_.ack(); |
| |
| uint32_t event_count; |
| while ((event_count = GEVNTCOUNT::Get(0).ReadFrom(mmio).EVNTCOUNT()) > 0) { |
| // invalidate cache so we can read fresh events |
| const zx_off_t offset = (ring_cur - ring_start) * sizeof(*ring_cur); |
| const size_t todo = std::min<size_t>(ring_end - ring_cur, event_count); |
| event_buffer_.CacheFlushInvalidate(offset, todo * sizeof(*ring_cur)); |
| if (event_count > todo) { |
| event_buffer_.CacheFlushInvalidate(0, (event_count - todo) * sizeof(*ring_cur)); |
| } |
| |
| for (uint32_t i = 0; i < event_count; i += sizeof(uint32_t)) { |
| uint32_t event = *ring_cur++; |
| if (ring_cur == ring_end) { |
| ring_cur = ring_start; |
| } |
| |
| HandleEvent(event); |
| } |
| |
| // acknowledge the events we have processed |
| GEVNTCOUNT::Get(0).FromValue(0).set_EVNTCOUNT(event_count).WriteTo(mmio); |
| } |
| } else if (wakeup_pkt.type == ZX_PKT_TYPE_USER) { |
| const IrqSignal signal = GetIrqSignal(wakeup_pkt); |
| switch (signal) { |
| case IrqSignal::Wakeup: |
| // Nothing to do here, just loop around and process the pending |
| // completion queue. |
| break; |
| case IrqSignal::Exit: |
| zxlogf(INFO, "Dwc3::IrqThread: shutting down"); |
| shutdown_now = true; |
| break; |
| default: |
| zxlogf(ERROR, "Dwc3::IrqThread: got invalid signal value %u", |
| static_cast<std::underlying_type_t<decltype(signal)>>(signal)); |
| shutdown_now = true; |
| break; |
| } |
| shutdown_now = true; |
| continue; |
| } else { |
| zxlogf(ERROR, "Dwc3::IrqThread: unrecognized packet type %u", wakeup_pkt.type); |
| shutdown_now = true; |
| continue; |
| } |
| } |
| return 0; |
| } |
| |
| void Dwc3::StartEvents() { |
| auto* mmio = get_mmio(); |
| |
| // set event buffer pointer and size |
| // keep interrupts masked until we are ready |
| zx_paddr_t paddr = event_buffer_.phys(); |
| ZX_DEBUG_ASSERT(paddr != 0); |
| |
| GEVNTADR::Get(0).FromValue(0).set_EVNTADR(paddr).WriteTo(mmio); |
| GEVNTSIZ::Get(0).FromValue(0).set_EVENTSIZ(kEventBufferSize).set_EVNTINTRPTMASK(0).WriteTo(mmio); |
| GEVNTCOUNT::Get(0).FromValue(0).set_EVNTCOUNT(0).WriteTo(mmio); |
| |
| // enable events |
| DEVTEN::Get() |
| .FromValue(0) |
| .set_L1SUSPEN(1) |
| .set_U3L2L1SuspEn(1) |
| .set_CONNECTDONEEVTEN(1) |
| .set_USBRSTEVTEN(1) |
| .set_DISSCONNEVTEN(1) |
| .WriteTo(mmio); |
| } |
| |
| } // namespace dwc3 |
