iPXE
Macros | Functions | Variables
xhci.c File Reference

USB eXtensible Host Controller Interface (xHCI) driver. More...

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/malloc.h>
#include <ipxe/pci.h>
#include <ipxe/usb.h>
#include <ipxe/init.h>
#include <ipxe/profile.h>
#include "xhci.h"

Go to the source code of this file.

Macros

#define EIO_DATA   __einfo_error ( EINFO_EIO_DATA )
 
#define EINFO_EIO_DATA
 
#define EIO_BABBLE   __einfo_error ( EINFO_EIO_BABBLE )
 
#define EINFO_EIO_BABBLE
 
#define EIO_USB   __einfo_error ( EINFO_EIO_USB )
 
#define EINFO_EIO_USB
 
#define EIO_TRB   __einfo_error ( EINFO_EIO_TRB )
 
#define EINFO_EIO_TRB
 
#define EIO_STALL   __einfo_error ( EINFO_EIO_STALL )
 
#define EINFO_EIO_STALL
 
#define EIO_RESOURCE   __einfo_error ( EINFO_EIO_RESOURCE )
 
#define EINFO_EIO_RESOURCE
 
#define EIO_BANDWIDTH   __einfo_error ( EINFO_EIO_BANDWIDTH )
 
#define EINFO_EIO_BANDWIDTH
 
#define EIO_NO_SLOTS   __einfo_error ( EINFO_EIO_NO_SLOTS )
 
#define EINFO_EIO_NO_SLOTS
 
#define EIO_STREAM_TYPE   __einfo_error ( EINFO_EIO_STREAM_TYPE )
 
#define EINFO_EIO_STREAM_TYPE
 
#define EIO_SLOT   __einfo_error ( EINFO_EIO_SLOT )
 
#define EINFO_EIO_SLOT
 
#define EIO_ENDPOINT   __einfo_error ( EINFO_EIO_ENDPOINT )
 
#define EINFO_EIO_ENDPOINT
 
#define EIO_SHORT   __einfo_error ( EINFO_EIO_SHORT )
 
#define EINFO_EIO_SHORT
 
#define EIO_UNDERRUN   __einfo_error ( EINFO_EIO_UNDERRUN )
 
#define EINFO_EIO_UNDERRUN
 
#define EIO_OVERRUN   __einfo_error ( EINFO_EIO_OVERRUN )
 
#define EINFO_EIO_OVERRUN
 
#define EIO_VF_RING_FULL   __einfo_error ( EINFO_EIO_VF_RING_FULL )
 
#define EINFO_EIO_VF_RING_FULL
 
#define EIO_PARAMETER   __einfo_error ( EINFO_EIO_PARAMETER )
 
#define EINFO_EIO_PARAMETER
 
#define EIO_BANDWIDTH_OVERRUN   __einfo_error ( EINFO_EIO_BANDWIDTH_OVERRUN )
 
#define EINFO_EIO_BANDWIDTH_OVERRUN
 
#define EIO_CONTEXT   __einfo_error ( EINFO_EIO_CONTEXT )
 
#define EINFO_EIO_CONTEXT
 
#define EIO_NO_PING   __einfo_error ( EINFO_EIO_NO_PING )
 
#define EINFO_EIO_NO_PING
 
#define EIO_RING_FULL   __einfo_error ( EINFO_EIO_RING_FULL )
 
#define EINFO_EIO_RING_FULL
 
#define EIO_INCOMPATIBLE   __einfo_error ( EINFO_EIO_INCOMPATIBLE )
 
#define EINFO_EIO_INCOMPATIBLE
 
#define EIO_MISSED   __einfo_error ( EINFO_EIO_MISSED )
 
#define EINFO_EIO_MISSED
 
#define EIO_CMD_STOPPED   __einfo_error ( EINFO_EIO_CMD_STOPPED )
 
#define EINFO_EIO_CMD_STOPPED
 
#define EIO_CMD_ABORTED   __einfo_error ( EINFO_EIO_CMD_ABORTED )
 
#define EINFO_EIO_CMD_ABORTED
 
#define EIO_STOP   __einfo_error ( EINFO_EIO_STOP )
 
#define EINFO_EIO_STOP
 
#define EIO_STOP_LEN   __einfo_error ( EINFO_EIO_STOP_LEN )
 
#define EINFO_EIO_STOP_LEN
 
#define EIO_STOP_SHORT   __einfo_error ( EINFO_EIO_STOP_SHORT )
 
#define EINFO_EIO_STOP_SHORT
 
#define EIO_LATENCY   __einfo_error ( EINFO_EIO_LATENCY )
 
#define EINFO_EIO_LATENCY
 
#define EIO_ISOCH   __einfo_error ( EINFO_EIO_ISOCH )
 
#define EINFO_EIO_ISOCH
 
#define EPROTO_LOST   __einfo_error ( EINFO_EPROTO_LOST )
 
#define EINFO_EPROTO_LOST
 
#define EPROTO_UNDEFINED   __einfo_error ( EINFO_EPROTO_UNDEFINED )
 
#define EINFO_EPROTO_UNDEFINED
 
#define EPROTO_STREAM_ID   __einfo_error ( EINFO_EPROTO_STREAM_ID )
 
#define EINFO_EPROTO_STREAM_ID
 
#define EPROTO_SECONDARY   __einfo_error ( EINFO_EPROTO_SECONDARY )
 
#define EINFO_EPROTO_SECONDARY
 
#define EPROTO_SPLIT   __einfo_error ( EINFO_EPROTO_SPLIT )
 
#define EINFO_EPROTO_SPLIT
 
#define ECODE(code)
 

Functions

 FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
 
static void xhci_init (struct xhci_device *xhci, void *regs)
 Initialise device. More...
 
static unsigned int xhci_extended_capability (struct xhci_device *xhci, unsigned int id, unsigned int offset)
 Find extended capability. More...
 
static int xhci_writeq (struct xhci_device *xhci, physaddr_t value, void *reg)
 Write potentially 64-bit register. More...
 
static size_t xhci_align (size_t len)
 Calculate buffer alignment. More...
 
static size_t xhci_device_context_offset (struct xhci_device *xhci, unsigned int ctx)
 Calculate device context offset. More...
 
static size_t xhci_input_context_offset (struct xhci_device *xhci, unsigned int ctx)
 Calculate input context offset. More...
 
static void xhci_dump (struct xhci_device *xhci)
 Dump host controller registers. More...
 
static void xhci_dump_port (struct xhci_device *xhci, unsigned int port)
 Dump port registers. More...
 
static void xhci_legacy_init (struct xhci_device *xhci)
 Initialise USB legacy support. More...
 
static void xhci_legacy_claim (struct xhci_device *xhci)
 Claim ownership from BIOS. More...
 
static void xhci_legacy_release (struct xhci_device *xhci)
 Release ownership back to BIOS. More...
 
static const char * xhci_speed_name (uint32_t psi)
 Transcribe port speed (for debugging) More...
 
static unsigned int xhci_supported_protocol (struct xhci_device *xhci, unsigned int port)
 Find supported protocol extended capability for a port. More...
 
static unsigned int xhci_port_protocol (struct xhci_device *xhci, unsigned int port)
 Find port protocol. More...
 
static int xhci_port_slot_type (struct xhci_device *xhci, unsigned int port)
 Find port slot type. More...
 
static int xhci_port_speed (struct xhci_device *xhci, unsigned int port, unsigned int psiv)
 Find port speed. More...
 
static int xhci_port_psiv (struct xhci_device *xhci, unsigned int port, unsigned int speed)
 Find protocol speed ID value. More...
 
static int xhci_dcbaa_alloc (struct xhci_device *xhci)
 Allocate device context base address array. More...
 
static void xhci_dcbaa_free (struct xhci_device *xhci)
 Free device context base address array. More...
 
static int xhci_scratchpad_alloc (struct xhci_device *xhci)
 Allocate scratchpad buffers. More...
 
static void xhci_scratchpad_free (struct xhci_device *xhci)
 Free scratchpad buffers. More...
 
static void xhci_run (struct xhci_device *xhci)
 Start xHCI device. More...
 
static int xhci_stop (struct xhci_device *xhci)
 Stop xHCI device. More...
 
static int xhci_reset (struct xhci_device *xhci)
 Reset xHCI device. More...
 
static int xhci_fail (struct xhci_device *xhci)
 Mark xHCI device as permanently failed. More...
 
static int xhci_ring_alloc (struct xhci_device *xhci, struct xhci_trb_ring *ring, unsigned int shift, unsigned int slot, unsigned int target, unsigned int stream)
 Allocate transfer request block ring. More...
 
static void xhci_ring_reset (struct xhci_trb_ring *ring)
 Reset transfer request block ring. More...
 
static void xhci_ring_free (struct xhci_trb_ring *ring)
 Free transfer request block ring. More...
 
static int xhci_enqueue (struct xhci_trb_ring *ring, struct io_buffer *iobuf, const union xhci_trb *trb)
 Enqueue a transfer request block. More...
 
static struct io_bufferxhci_dequeue (struct xhci_trb_ring *ring)
 Dequeue a transfer request block. More...
 
static int xhci_enqueue_multi (struct xhci_trb_ring *ring, struct io_buffer *iobuf, const union xhci_trb *trbs, unsigned int count)
 Enqueue multiple transfer request blocks. More...
 
static struct io_bufferxhci_dequeue_multi (struct xhci_trb_ring *ring)
 Dequeue multiple transfer request blocks. More...
 
static void xhci_doorbell (struct xhci_trb_ring *ring)
 Ring doorbell register. More...
 
static int xhci_command_alloc (struct xhci_device *xhci)
 Allocate command ring. More...
 
static void xhci_command_free (struct xhci_device *xhci)
 Free command ring. More...
 
static int xhci_event_alloc (struct xhci_device *xhci)
 Allocate event ring. More...
 
static void xhci_event_free (struct xhci_device *xhci)
 Free event ring. More...
 
static void xhci_transfer (struct xhci_device *xhci, struct xhci_trb_transfer *trb)
 Handle transfer event. More...
 
static void xhci_complete (struct xhci_device *xhci, struct xhci_trb_complete *trb)
 Handle command completion event. More...
 
static void xhci_port_status (struct xhci_device *xhci, struct xhci_trb_port_status *trb)
 Handle port status event. More...
 
static void xhci_host_controller (struct xhci_device *xhci, struct xhci_trb_host_controller *trb)
 Handle host controller event. More...
 
static void xhci_event_poll (struct xhci_device *xhci)
 Poll event ring. More...
 
static void xhci_abort (struct xhci_device *xhci)
 Abort command. More...
 
static int xhci_command (struct xhci_device *xhci, union xhci_trb *trb)
 Issue command and wait for completion. More...
 
static int xhci_nop (struct xhci_device *xhci)
 Issue NOP and wait for completion. More...
 
static int xhci_enable_slot (struct xhci_device *xhci, unsigned int type)
 Enable slot. More...
 
static int xhci_disable_slot (struct xhci_device *xhci, unsigned int slot)
 Disable slot. More...
 
static int xhci_context (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, unsigned int type, void(*populate)(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input))
 Issue context-based command and wait for completion. More...
 
static void xhci_address_device_input (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input)
 Populate address device input context. More...
 
static int xhci_address_device (struct xhci_device *xhci, struct xhci_slot *slot)
 Address device. More...
 
static void xhci_configure_endpoint_input (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input)
 Populate configure endpoint input context. More...
 
static int xhci_configure_endpoint (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint)
 Configure endpoint. More...
 
static void xhci_deconfigure_endpoint_input (struct xhci_device *xhci __unused, struct xhci_slot *slot __unused, struct xhci_endpoint *endpoint, void *input)
 Populate deconfigure endpoint input context. More...
 
static int xhci_deconfigure_endpoint (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint)
 Deconfigure endpoint. More...
 
static void xhci_evaluate_context_input (struct xhci_device *xhci, struct xhci_slot *slot __unused, struct xhci_endpoint *endpoint, void *input)
 Populate evaluate context input context. More...
 
static int xhci_evaluate_context (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint)
 Evaluate context. More...
 
static int xhci_reset_endpoint (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint)
 Reset endpoint. More...
 
static int xhci_stop_endpoint (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint)
 Stop endpoint. More...
 
static int xhci_set_tr_dequeue_pointer (struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint)
 Set transfer ring dequeue pointer. More...
 
static int xhci_endpoint_open (struct usb_endpoint *ep)
 Open endpoint. More...
 
static void xhci_endpoint_close (struct usb_endpoint *ep)
 Close endpoint. More...
 
static int xhci_endpoint_reset (struct usb_endpoint *ep)
 Reset endpoint. More...
 
static int xhci_endpoint_mtu (struct usb_endpoint *ep)
 Update MTU. More...
 
static int xhci_endpoint_message (struct usb_endpoint *ep, struct io_buffer *iobuf)
 Enqueue message transfer. More...
 
static unsigned int xhci_endpoint_count (size_t len, int zlp)
 Calculate number of TRBs. More...
 
static int xhci_endpoint_stream (struct usb_endpoint *ep, struct io_buffer *iobuf, int zlp)
 Enqueue stream transfer. More...
 
static int xhci_device_open (struct usb_device *usb)
 Open device. More...
 
static void xhci_device_close (struct usb_device *usb)
 Close device. More...
 
static int xhci_device_address (struct usb_device *usb)
 Assign device address. More...
 
static int xhci_bus_open (struct usb_bus *bus)
 Open USB bus. More...
 
static void xhci_bus_close (struct usb_bus *bus)
 Close USB bus. More...
 
static void xhci_bus_poll (struct usb_bus *bus)
 Poll USB bus. More...
 
static int xhci_hub_open (struct usb_hub *hub)
 Open hub. More...
 
static void xhci_hub_close (struct usb_hub *hub __unused)
 Close hub. More...
 
static int xhci_root_open (struct usb_hub *hub)
 Open root hub. More...
 
static void xhci_root_close (struct usb_hub *hub __unused)
 Close root hub. More...
 
static int xhci_root_enable (struct usb_hub *hub, struct usb_port *port)
 Enable port. More...
 
static int xhci_root_disable (struct usb_hub *hub, struct usb_port *port)
 Disable port. More...
 
static int xhci_root_speed (struct usb_hub *hub, struct usb_port *port)
 Update root hub port speed. More...
 
static int xhci_root_clear_tt (struct usb_hub *hub, struct usb_port *port, struct usb_endpoint *ep)
 Clear transaction translator buffer. More...
 
static void xhci_pch_fix (struct xhci_device *xhci, struct pci_device *pci)
 Fix Intel PCH-specific quirks. More...
 
static void xhci_pch_undo (struct xhci_device *xhci, struct pci_device *pci)
 Undo Intel PCH-specific quirk fixes. More...
 
static int xhci_probe (struct pci_device *pci)
 Probe PCI device. More...
 
static void xhci_remove (struct pci_device *pci)
 Remove PCI device. More...
 
static void xhci_shutdown (int booting)
 Prepare for exit. More...
 
struct startup_fn xhci_startup __startup_fn (STARTUP_LATE)
 Startup/shutdown function. More...
 

Variables

static struct profiler xhci_message_profiler __profiler
 Message transfer profiler. More...
 
static int xhci_legacy_prevent_release
 Prevent the release of ownership back to BIOS. More...
 
static struct usb_host_operations xhci_operations
 USB host controller operations. More...
 
static struct pci_device_id xhci_ids []
 XHCI PCI device IDs. More...
 
struct pci_driver xhci_driver __pci_driver
 XHCI PCI driver. More...
 

Detailed Description

USB eXtensible Host Controller Interface (xHCI) driver.

Definition in file xhci.c.

Macro Definition Documentation

◆ EIO_DATA

#define EIO_DATA   __einfo_error ( EINFO_EIO_DATA )

Definition at line 63 of file xhci.c.

◆ EINFO_EIO_DATA

#define EINFO_EIO_DATA
Value:
__einfo_uniqify ( EINFO_EIO, ( 2 - 0 ), \
"Data buffer error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 65 of file xhci.c.

◆ EIO_BABBLE

#define EIO_BABBLE   __einfo_error ( EINFO_EIO_BABBLE )

Definition at line 68 of file xhci.c.

◆ EINFO_EIO_BABBLE

#define EINFO_EIO_BABBLE
Value:
__einfo_uniqify ( EINFO_EIO, ( 3 - 0 ), \
"Babble detected" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 70 of file xhci.c.

◆ EIO_USB

#define EIO_USB   __einfo_error ( EINFO_EIO_USB )

Definition at line 73 of file xhci.c.

◆ EINFO_EIO_USB

#define EINFO_EIO_USB
Value:
__einfo_uniqify ( EINFO_EIO, ( 4 - 0 ), \
"USB transaction error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 75 of file xhci.c.

◆ EIO_TRB

#define EIO_TRB   __einfo_error ( EINFO_EIO_TRB )

Definition at line 78 of file xhci.c.

◆ EINFO_EIO_TRB

#define EINFO_EIO_TRB
Value:
__einfo_uniqify ( EINFO_EIO, ( 5 - 0 ), \
"TRB error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 80 of file xhci.c.

◆ EIO_STALL

#define EIO_STALL   __einfo_error ( EINFO_EIO_STALL )

Definition at line 83 of file xhci.c.

◆ EINFO_EIO_STALL

#define EINFO_EIO_STALL
Value:
__einfo_uniqify ( EINFO_EIO, ( 6 - 0 ), \
"Stall error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 85 of file xhci.c.

◆ EIO_RESOURCE

#define EIO_RESOURCE   __einfo_error ( EINFO_EIO_RESOURCE )

Definition at line 88 of file xhci.c.

◆ EINFO_EIO_RESOURCE

#define EINFO_EIO_RESOURCE
Value:
__einfo_uniqify ( EINFO_EIO, ( 7 - 0 ), \
"Resource error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 90 of file xhci.c.

◆ EIO_BANDWIDTH

#define EIO_BANDWIDTH   __einfo_error ( EINFO_EIO_BANDWIDTH )

Definition at line 93 of file xhci.c.

◆ EINFO_EIO_BANDWIDTH

#define EINFO_EIO_BANDWIDTH
Value:
__einfo_uniqify ( EINFO_EIO, ( 8 - 0 ), \
"Bandwidth error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 95 of file xhci.c.

◆ EIO_NO_SLOTS

#define EIO_NO_SLOTS   __einfo_error ( EINFO_EIO_NO_SLOTS )

Definition at line 98 of file xhci.c.

◆ EINFO_EIO_NO_SLOTS

#define EINFO_EIO_NO_SLOTS
Value:
__einfo_uniqify ( EINFO_EIO, ( 9 - 0 ), \
"No slots available" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 100 of file xhci.c.

◆ EIO_STREAM_TYPE

#define EIO_STREAM_TYPE   __einfo_error ( EINFO_EIO_STREAM_TYPE )

Definition at line 103 of file xhci.c.

◆ EINFO_EIO_STREAM_TYPE

#define EINFO_EIO_STREAM_TYPE
Value:
__einfo_uniqify ( EINFO_EIO, ( 10 - 0 ), \
"Invalid stream type" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 105 of file xhci.c.

◆ EIO_SLOT

#define EIO_SLOT   __einfo_error ( EINFO_EIO_SLOT )

Definition at line 108 of file xhci.c.

◆ EINFO_EIO_SLOT

#define EINFO_EIO_SLOT
Value:
__einfo_uniqify ( EINFO_EIO, ( 11 - 0 ), \
"Slot not enabled" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 110 of file xhci.c.

◆ EIO_ENDPOINT

#define EIO_ENDPOINT   __einfo_error ( EINFO_EIO_ENDPOINT )

Definition at line 113 of file xhci.c.

◆ EINFO_EIO_ENDPOINT

#define EINFO_EIO_ENDPOINT
Value:
__einfo_uniqify ( EINFO_EIO, ( 12 - 0 ), \
"Endpoint not enabled" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 115 of file xhci.c.

◆ EIO_SHORT

#define EIO_SHORT   __einfo_error ( EINFO_EIO_SHORT )

Definition at line 118 of file xhci.c.

◆ EINFO_EIO_SHORT

#define EINFO_EIO_SHORT
Value:
__einfo_uniqify ( EINFO_EIO, ( 13 - 0 ), \
"Short packet" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 120 of file xhci.c.

◆ EIO_UNDERRUN

#define EIO_UNDERRUN   __einfo_error ( EINFO_EIO_UNDERRUN )

Definition at line 123 of file xhci.c.

◆ EINFO_EIO_UNDERRUN

#define EINFO_EIO_UNDERRUN
Value:
__einfo_uniqify ( EINFO_EIO, ( 14 - 0 ), \
"Ring underrun" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 125 of file xhci.c.

◆ EIO_OVERRUN

#define EIO_OVERRUN   __einfo_error ( EINFO_EIO_OVERRUN )

Definition at line 128 of file xhci.c.

◆ EINFO_EIO_OVERRUN

#define EINFO_EIO_OVERRUN
Value:
__einfo_uniqify ( EINFO_EIO, ( 15 - 0 ), \
"Ring overrun" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 130 of file xhci.c.

◆ EIO_VF_RING_FULL

#define EIO_VF_RING_FULL   __einfo_error ( EINFO_EIO_VF_RING_FULL )

Definition at line 133 of file xhci.c.

◆ EINFO_EIO_VF_RING_FULL

#define EINFO_EIO_VF_RING_FULL
Value:
__einfo_uniqify ( EINFO_EIO, ( 16 - 0 ), \
"Virtual function event ring full" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 135 of file xhci.c.

◆ EIO_PARAMETER

#define EIO_PARAMETER   __einfo_error ( EINFO_EIO_PARAMETER )

Definition at line 138 of file xhci.c.

◆ EINFO_EIO_PARAMETER

#define EINFO_EIO_PARAMETER
Value:
__einfo_uniqify ( EINFO_EIO, ( 17 - 0 ), \
"Parameter error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 140 of file xhci.c.

◆ EIO_BANDWIDTH_OVERRUN

#define EIO_BANDWIDTH_OVERRUN   __einfo_error ( EINFO_EIO_BANDWIDTH_OVERRUN )

Definition at line 143 of file xhci.c.

◆ EINFO_EIO_BANDWIDTH_OVERRUN

#define EINFO_EIO_BANDWIDTH_OVERRUN
Value:
__einfo_uniqify ( EINFO_EIO, ( 18 - 0 ), \
"Bandwidth overrun" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 145 of file xhci.c.

◆ EIO_CONTEXT

#define EIO_CONTEXT   __einfo_error ( EINFO_EIO_CONTEXT )

Definition at line 148 of file xhci.c.

◆ EINFO_EIO_CONTEXT

#define EINFO_EIO_CONTEXT
Value:
__einfo_uniqify ( EINFO_EIO, ( 19 - 0 ), \
"Context state error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 150 of file xhci.c.

◆ EIO_NO_PING

#define EIO_NO_PING   __einfo_error ( EINFO_EIO_NO_PING )

Definition at line 153 of file xhci.c.

◆ EINFO_EIO_NO_PING

#define EINFO_EIO_NO_PING
Value:
__einfo_uniqify ( EINFO_EIO, ( 20 - 0 ), \
"No ping response" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 155 of file xhci.c.

◆ EIO_RING_FULL

#define EIO_RING_FULL   __einfo_error ( EINFO_EIO_RING_FULL )

Definition at line 158 of file xhci.c.

◆ EINFO_EIO_RING_FULL

#define EINFO_EIO_RING_FULL
Value:
__einfo_uniqify ( EINFO_EIO, ( 21 - 0 ), \
"Event ring full" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 160 of file xhci.c.

◆ EIO_INCOMPATIBLE

#define EIO_INCOMPATIBLE   __einfo_error ( EINFO_EIO_INCOMPATIBLE )

Definition at line 163 of file xhci.c.

◆ EINFO_EIO_INCOMPATIBLE

#define EINFO_EIO_INCOMPATIBLE
Value:
__einfo_uniqify ( EINFO_EIO, ( 22 - 0 ), \
"Incompatible device" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 165 of file xhci.c.

◆ EIO_MISSED

#define EIO_MISSED   __einfo_error ( EINFO_EIO_MISSED )

Definition at line 168 of file xhci.c.

◆ EINFO_EIO_MISSED

#define EINFO_EIO_MISSED
Value:
__einfo_uniqify ( EINFO_EIO, ( 23 - 0 ), \
"Missed service error" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 170 of file xhci.c.

◆ EIO_CMD_STOPPED

#define EIO_CMD_STOPPED   __einfo_error ( EINFO_EIO_CMD_STOPPED )

Definition at line 173 of file xhci.c.

◆ EINFO_EIO_CMD_STOPPED

#define EINFO_EIO_CMD_STOPPED
Value:
__einfo_uniqify ( EINFO_EIO, ( 24 - 0 ), \
"Command ring stopped" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 175 of file xhci.c.

◆ EIO_CMD_ABORTED

#define EIO_CMD_ABORTED   __einfo_error ( EINFO_EIO_CMD_ABORTED )

Definition at line 178 of file xhci.c.

◆ EINFO_EIO_CMD_ABORTED

#define EINFO_EIO_CMD_ABORTED
Value:
__einfo_uniqify ( EINFO_EIO, ( 25 - 0 ), \
"Command aborted" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 180 of file xhci.c.

◆ EIO_STOP

#define EIO_STOP   __einfo_error ( EINFO_EIO_STOP )

Definition at line 183 of file xhci.c.

◆ EINFO_EIO_STOP

#define EINFO_EIO_STOP
Value:
__einfo_uniqify ( EINFO_EIO, ( 26 - 0 ), \
"Stopped" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 185 of file xhci.c.

◆ EIO_STOP_LEN

#define EIO_STOP_LEN   __einfo_error ( EINFO_EIO_STOP_LEN )

Definition at line 188 of file xhci.c.

◆ EINFO_EIO_STOP_LEN

#define EINFO_EIO_STOP_LEN
Value:
__einfo_uniqify ( EINFO_EIO, ( 27 - 0 ), \
"Stopped - length invalid" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 190 of file xhci.c.

◆ EIO_STOP_SHORT

#define EIO_STOP_SHORT   __einfo_error ( EINFO_EIO_STOP_SHORT )

Definition at line 193 of file xhci.c.

◆ EINFO_EIO_STOP_SHORT

#define EINFO_EIO_STOP_SHORT
Value:
__einfo_uniqify ( EINFO_EIO, ( 28 - 0 ), \
"Stopped - short packet" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 195 of file xhci.c.

◆ EIO_LATENCY

#define EIO_LATENCY   __einfo_error ( EINFO_EIO_LATENCY )

Definition at line 198 of file xhci.c.

◆ EINFO_EIO_LATENCY

#define EINFO_EIO_LATENCY
Value:
__einfo_uniqify ( EINFO_EIO, ( 29 - 0 ), \
"Maximum exit latency too large" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 200 of file xhci.c.

◆ EIO_ISOCH

#define EIO_ISOCH   __einfo_error ( EINFO_EIO_ISOCH )

Definition at line 203 of file xhci.c.

◆ EINFO_EIO_ISOCH

#define EINFO_EIO_ISOCH
Value:
__einfo_uniqify ( EINFO_EIO, ( 31 - 0 ), \
"Isochronous buffer overrun" )
#define EINFO_EIO
Definition: errno.h:434
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180

Definition at line 205 of file xhci.c.

◆ EPROTO_LOST

#define EPROTO_LOST   __einfo_error ( EINFO_EPROTO_LOST )

Definition at line 208 of file xhci.c.

◆ EINFO_EPROTO_LOST

#define EINFO_EPROTO_LOST
Value:
__einfo_uniqify ( EINFO_EPROTO, ( 32 - 32 ), \
"Event lost" )
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180
#define EINFO_EPROTO
Definition: errno.h:625

Definition at line 210 of file xhci.c.

◆ EPROTO_UNDEFINED

#define EPROTO_UNDEFINED   __einfo_error ( EINFO_EPROTO_UNDEFINED )

Definition at line 213 of file xhci.c.

◆ EINFO_EPROTO_UNDEFINED

#define EINFO_EPROTO_UNDEFINED
Value:
__einfo_uniqify ( EINFO_EPROTO, ( 33 - 32 ), \
"Undefined error" )
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180
#define EINFO_EPROTO
Definition: errno.h:625

Definition at line 215 of file xhci.c.

◆ EPROTO_STREAM_ID

#define EPROTO_STREAM_ID   __einfo_error ( EINFO_EPROTO_STREAM_ID )

Definition at line 218 of file xhci.c.

◆ EINFO_EPROTO_STREAM_ID

#define EINFO_EPROTO_STREAM_ID
Value:
__einfo_uniqify ( EINFO_EPROTO, ( 34 - 32 ), \
"Invalid stream ID" )
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180
#define EINFO_EPROTO
Definition: errno.h:625

Definition at line 220 of file xhci.c.

◆ EPROTO_SECONDARY

#define EPROTO_SECONDARY   __einfo_error ( EINFO_EPROTO_SECONDARY )

Definition at line 223 of file xhci.c.

◆ EINFO_EPROTO_SECONDARY

#define EINFO_EPROTO_SECONDARY
Value:
__einfo_uniqify ( EINFO_EPROTO, ( 35 - 32 ), \
"Secondary bandwidth error" )
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180
#define EINFO_EPROTO
Definition: errno.h:625

Definition at line 225 of file xhci.c.

◆ EPROTO_SPLIT

#define EPROTO_SPLIT   __einfo_error ( EINFO_EPROTO_SPLIT )

Definition at line 228 of file xhci.c.

◆ EINFO_EPROTO_SPLIT

#define EINFO_EPROTO_SPLIT
Value:
__einfo_uniqify ( EINFO_EPROTO, ( 36 - 32 ), \
"Split transaction error" )
#define __einfo_uniqify(einfo_base, uniq, desc)
Declare disambiguated error.
Definition: errno.h:180
#define EINFO_EPROTO
Definition: errno.h:625

Definition at line 230 of file xhci.c.

◆ ECODE

#define ECODE (   code)
Value:
( ( (code) < 32 ) ? \
EUNIQ ( EINFO_EIO, ( (code) & 31 ), EIO_DATA, EIO_BABBLE, \
EIO_ISOCH ) : \
( (code) < 64 ) ? \
EUNIQ ( EINFO_EPROTO, ( (code) & 31 ), EPROTO_LOST, \
#define EIO_STOP_LEN
Definition: xhci.c:188
#define EIO_STOP
Definition: xhci.c:183
#define EIO_LATENCY
Definition: xhci.c:198
#define EIO_BANDWIDTH_OVERRUN
Definition: xhci.c:143
#define EIO_USB
Definition: xhci.c:73
#define EIO_BANDWIDTH
Definition: xhci.c:93
#define EPROTO_LOST
Definition: xhci.c:208
#define EIO_RESOURCE
Definition: xhci.c:88
#define EIO_DATA
Definition: xhci.c:63
#define EIO_SHORT
Definition: xhci.c:118
#define EIO_INCOMPATIBLE
Definition: xhci.c:163
#define EIO_STOP_SHORT
Definition: xhci.c:193
#define EPROTO_STREAM_ID
Definition: xhci.c:218
#define EINFO_EIO
Definition: errno.h:434
#define EIO_CMD_ABORTED
Definition: xhci.c:178
#define EFAULT
Bad address.
Definition: errno.h:393
#define EIO_CMD_STOPPED
Definition: xhci.c:173
#define EIO_PARAMETER
Definition: xhci.c:138
#define EIO_TRB
Definition: xhci.c:78
#define EIO_CONTEXT
Definition: xhci.c:148
#define EIO_STALL
Definition: xhci.c:83
#define EIO_NO_SLOTS
Definition: xhci.c:98
#define EIO_SLOT
Definition: xhci.c:108
#define EIO_BABBLE
Definition: xhci.c:68
#define EIO_ISOCH
Definition: xhci.c:203
#define EIO_ENDPOINT
Definition: xhci.c:113
#define EPROTO_UNDEFINED
Definition: xhci.c:213
#define EIO_RING_FULL
Definition: xhci.c:158
#define EIO_VF_RING_FULL
Definition: xhci.c:133
uint8_t code
Response code.
Definition: scsi.h:16
#define EIO_OVERRUN
Definition: xhci.c:128
#define EIO_MISSED
Definition: xhci.c:168
#define EUNIQ(einfo_base, uniq,...)
Disambiguate a base error based on non-constant information.
Definition: errno.h:225
#define EIO_UNDERRUN
Definition: xhci.c:123
#define EIO_STREAM_TYPE
Definition: xhci.c:103
#define EIO_NO_PING
Definition: xhci.c:153
#define EPROTO_SPLIT
Definition: xhci.c:228
#define EPROTO_SECONDARY
Definition: xhci.c:223
#define EINFO_EPROTO
Definition: errno.h:625

Definition at line 233 of file xhci.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )

◆ xhci_init()

static void xhci_init ( struct xhci_device xhci,
void *  regs 
)
static

Initialise device.

Parameters
xhcixHCI device
regsMMIO registers

Definition at line 264 of file xhci.c.

264  {
265  uint32_t hcsparams1;
266  uint32_t hcsparams2;
267  uint32_t hccparams1;
268  uint32_t pagesize;
269  size_t caplength;
270  size_t rtsoff;
271  size_t dboff;
272 
273  /* Locate capability, operational, runtime, and doorbell registers */
274  xhci->cap = regs;
275  caplength = readb ( xhci->cap + XHCI_CAP_CAPLENGTH );
276  rtsoff = readl ( xhci->cap + XHCI_CAP_RTSOFF );
277  dboff = readl ( xhci->cap + XHCI_CAP_DBOFF );
278  xhci->op = ( xhci->cap + caplength );
279  xhci->run = ( xhci->cap + rtsoff );
280  xhci->db = ( xhci->cap + dboff );
281  DBGC2 ( xhci, "XHCI %s cap %08lx op %08lx run %08lx db %08lx\n",
282  xhci->name, virt_to_phys ( xhci->cap ),
283  virt_to_phys ( xhci->op ), virt_to_phys ( xhci->run ),
284  virt_to_phys ( xhci->db ) );
285 
286  /* Read structural parameters 1 */
287  hcsparams1 = readl ( xhci->cap + XHCI_CAP_HCSPARAMS1 );
288  xhci->slots = XHCI_HCSPARAMS1_SLOTS ( hcsparams1 );
289  xhci->intrs = XHCI_HCSPARAMS1_INTRS ( hcsparams1 );
290  xhci->ports = XHCI_HCSPARAMS1_PORTS ( hcsparams1 );
291  DBGC ( xhci, "XHCI %s has %d slots %d intrs %d ports\n",
292  xhci->name, xhci->slots, xhci->intrs, xhci->ports );
293 
294  /* Read structural parameters 2 */
295  hcsparams2 = readl ( xhci->cap + XHCI_CAP_HCSPARAMS2 );
296  xhci->scratch.count = XHCI_HCSPARAMS2_SCRATCHPADS ( hcsparams2 );
297  DBGC2 ( xhci, "XHCI %s needs %d scratchpads\n",
298  xhci->name, xhci->scratch.count );
299 
300  /* Read capability parameters 1 */
301  hccparams1 = readl ( xhci->cap + XHCI_CAP_HCCPARAMS1 );
302  xhci->addr64 = XHCI_HCCPARAMS1_ADDR64 ( hccparams1 );
303  xhci->csz_shift = XHCI_HCCPARAMS1_CSZ_SHIFT ( hccparams1 );
304  xhci->xecp = XHCI_HCCPARAMS1_XECP ( hccparams1 );
305 
306  /* Read page size */
307  pagesize = readl ( xhci->op + XHCI_OP_PAGESIZE );
308  xhci->pagesize = XHCI_PAGESIZE ( pagesize );
309  assert ( xhci->pagesize != 0 );
310  assert ( ( ( xhci->pagesize ) & ( xhci->pagesize - 1 ) ) == 0 );
311  DBGC2 ( xhci, "XHCI %s page size %zd bytes\n",
312  xhci->name, xhci->pagesize );
313 }
uint8_t readb(volatile uint8_t *io_addr)
Read byte from memory-mapped device.
unsigned int ports
Number of ports.
Definition: xhci.h:1091
void * run
Runtime registers.
Definition: xhci.h:1082
#define XHCI_HCSPARAMS1_PORTS(params)
Number of ports.
Definition: xhci.h:49
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_HCSPARAMS1_INTRS(params)
Number of interrupters.
Definition: xhci.h:46
unsigned int count
Number of page-sized scratchpad buffers.
Definition: xhci.h:1055
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
unsigned int slots
Number of device slots.
Definition: xhci.h:1087
struct xhci_scratchpad scratch
Scratchpad buffer.
Definition: xhci.h:1110
#define XHCI_CAP_RTSOFF
Runtime register space offset.
Definition: xhci.h:74
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
const char * name
Name.
Definition: xhci.h:1073
#define XHCI_HCCPARAMS1_XECP(params)
xHCI extended capabilities pointer
Definition: xhci.h:68
#define XHCI_HCCPARAMS1_ADDR64(params)
64-bit addressing capability
Definition: xhci.h:62
#define XHCI_CAP_CAPLENGTH
Capability register length.
Definition: xhci.h:34
unsigned int intrs
Number of interrupters.
Definition: xhci.h:1089
#define XHCI_HCSPARAMS1_SLOTS(params)
Number of device slots.
Definition: xhci.h:43
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
unsigned int xecp
xHCI extended capabilities offset
Definition: xhci.h:1098
#define XHCI_OP_PAGESIZE
Page size register.
Definition: xhci.h:170
struct i386_regs regs
Definition: registers.h:15
int addr64
64-bit addressing capability
Definition: xhci.h:1094
#define XHCI_PAGESIZE(pagesize)
Page size.
Definition: xhci.h:173
#define DBGC2(...)
Definition: compiler.h:522
size_t pagesize
Page size.
Definition: xhci.h:1101
#define XHCI_CAP_DBOFF
Doorbell offset.
Definition: xhci.h:71
#define XHCI_HCCPARAMS1_CSZ_SHIFT(params)
Context size shift.
Definition: xhci.h:65
#define XHCI_CAP_HCSPARAMS1
Structural parameters 1.
Definition: xhci.h:40
#define XHCI_CAP_HCCPARAMS1
Capability parameters.
Definition: xhci.h:59
unsigned int csz_shift
Context size shift.
Definition: xhci.h:1096
void * db
Doorbell registers.
Definition: xhci.h:1084
#define XHCI_HCSPARAMS2_SCRATCHPADS(params)
Number of page-sized scratchpad buffers.
Definition: xhci.h:55
#define XHCI_CAP_HCSPARAMS2
Structural parameters 2.
Definition: xhci.h:52
void * op
Operational registers.
Definition: xhci.h:1080

References xhci_device::addr64, assert(), xhci_device::cap, xhci_scratchpad::count, xhci_device::csz_shift, xhci_device::db, DBGC, DBGC2, xhci_device::intrs, xhci_device::name, xhci_device::op, xhci_device::pagesize, xhci_device::ports, readb(), readl(), regs, xhci_device::run, xhci_device::scratch, xhci_device::slots, virt_to_phys(), xhci_device::xecp, XHCI_CAP_CAPLENGTH, XHCI_CAP_DBOFF, XHCI_CAP_HCCPARAMS1, XHCI_CAP_HCSPARAMS1, XHCI_CAP_HCSPARAMS2, XHCI_CAP_RTSOFF, XHCI_HCCPARAMS1_ADDR64, XHCI_HCCPARAMS1_CSZ_SHIFT, XHCI_HCCPARAMS1_XECP, XHCI_HCSPARAMS1_INTRS, XHCI_HCSPARAMS1_PORTS, XHCI_HCSPARAMS1_SLOTS, XHCI_HCSPARAMS2_SCRATCHPADS, XHCI_OP_PAGESIZE, and XHCI_PAGESIZE.

Referenced by xhci_probe().

◆ xhci_extended_capability()

static unsigned int xhci_extended_capability ( struct xhci_device xhci,
unsigned int  id,
unsigned int  offset 
)
static

Find extended capability.

Parameters
xhcixHCI device
idCapability ID
offsetOffset to previous extended capability instance, or zero
Return values
offsetOffset to extended capability, or zero if not found

Definition at line 323 of file xhci.c.

325  {
326  uint32_t xecp;
327  unsigned int next;
328 
329  /* Locate the extended capability */
330  while ( 1 ) {
331 
332  /* Locate first or next capability as applicable */
333  if ( offset ) {
334  xecp = readl ( xhci->cap + offset );
335  next = XHCI_XECP_NEXT ( xecp );
336  } else {
337  next = xhci->xecp;
338  }
339  if ( ! next )
340  return 0;
341  offset += next;
342 
343  /* Check if this is the requested capability */
344  xecp = readl ( xhci->cap + offset );
345  if ( XHCI_XECP_ID ( xecp ) == id )
346  return offset;
347  }
348 }
#define XHCI_XECP_NEXT(xecp)
Next xHCI extended capability pointer.
Definition: xhci.h:80
uint32_t next
Next descriptor address.
Definition: myson.h:18
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
static userptr_t size_t offset
Offset of the first segment within the content.
Definition: deflate.h:259
#define XHCI_XECP_ID(xecp)
xHCI extended capability ID
Definition: xhci.h:77
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
unsigned int xecp
xHCI extended capabilities offset
Definition: xhci.h:1098

References xhci_device::cap, next, offset, readl(), xhci_device::xecp, XHCI_XECP_ID, and XHCI_XECP_NEXT.

Referenced by xhci_legacy_init(), and xhci_supported_protocol().

◆ xhci_writeq()

static int xhci_writeq ( struct xhci_device xhci,
physaddr_t  value,
void *  reg 
)
inlinestatic

Write potentially 64-bit register.

Parameters
xhcixHCI device
valueValue
regRegister address
Return values
rcReturn status code

Definition at line 359 of file xhci.c.

359  {
360 
361  /* If this is a 32-bit build, then this can never fail
362  * (allowing the compiler to optimise out the error path).
363  */
364  if ( sizeof ( value ) <= sizeof ( uint32_t ) ) {
365  writel ( value, reg );
366  writel ( 0, ( reg + sizeof ( uint32_t ) ) );
367  return 0;
368  }
369 
370  /* If the device does not support 64-bit addresses and this
371  * address is outside the 32-bit address space, then fail.
372  */
373  if ( ( value & ~0xffffffffULL ) && ! xhci->addr64 ) {
374  DBGC ( xhci, "XHCI %s cannot access address %lx\n",
375  xhci->name, value );
376  return -ENOTSUP;
377  }
378 
379  /* If this is a 64-bit build, then writeq() is available */
380  writeq ( value, reg );
381  return 0;
382 }
static unsigned int unsigned int reg
Definition: myson.h:162
#define DBGC(...)
Definition: compiler.h:505
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
const char * name
Name.
Definition: xhci.h:1073
unsigned int uint32_t
Definition: stdint.h:12
int addr64
64-bit addressing capability
Definition: xhci.h:1094
void writeq(uint64_t data, volatile uint64_t *io_addr)
Write 64-bit qword to memory-mapped device.

References xhci_device::addr64, DBGC, ENOTSUP, xhci_device::name, reg, value, writel(), and writeq().

Referenced by xhci_abort(), xhci_command_alloc(), xhci_command_free(), xhci_dcbaa_alloc(), xhci_dcbaa_free(), xhci_event_alloc(), xhci_event_free(), and xhci_event_poll().

◆ xhci_align()

static size_t xhci_align ( size_t  len)
inlinestatic

Calculate buffer alignment.

Parameters
lenLength
Return values
alignBuffer alignment

Determine alignment required for a buffer which must be aligned to at least XHCI_MIN_ALIGN and which must not cross a page boundary.

Definition at line 393 of file xhci.c.

393  {
394  size_t align;
395 
396  /* Align to own length (rounded up to a power of two) */
397  align = ( 1 << fls ( len - 1 ) );
398 
399  /* Round up to XHCI_MIN_ALIGN if needed */
400  if ( align < XHCI_MIN_ALIGN )
402 
403  return align;
404 }
static __always_inline void struct dma_mapping size_t size_t align
Definition: dma.h:222
uint32_t len
Length.
Definition: ena.h:14
#define XHCI_MIN_ALIGN
Minimum alignment required for data structures.
Definition: xhci.h:25
#define fls(x)
Find last (i.e.
Definition: strings.h:166

References align, fls, len, and XHCI_MIN_ALIGN.

Referenced by xhci_context(), xhci_dcbaa_alloc(), xhci_device_open(), xhci_event_alloc(), xhci_ring_alloc(), and xhci_scratchpad_alloc().

◆ xhci_device_context_offset()

static size_t xhci_device_context_offset ( struct xhci_device xhci,
unsigned int  ctx 
)
inlinestatic

Calculate device context offset.

Parameters
xhcixHCI device
ctxContext index

Definition at line 412 of file xhci.c.

413  {
414 
415  return ( XHCI_DCI ( ctx ) << xhci->csz_shift );
416 }
struct golan_eq_context ctx
Definition: CIB_PRM.h:28
#define XHCI_DCI(ctx)
Device context index.
Definition: xhci.h:957
unsigned int csz_shift
Context size shift.
Definition: xhci.h:1096

References xhci_device::csz_shift, ctx, and XHCI_DCI.

Referenced by xhci_address_device(), xhci_device_close(), xhci_device_open(), and xhci_endpoint_open().

◆ xhci_input_context_offset()

static size_t xhci_input_context_offset ( struct xhci_device xhci,
unsigned int  ctx 
)
inlinestatic

Calculate input context offset.

Parameters
xhcixHCI device
ctxContext index

Definition at line 424 of file xhci.c.

425  {
426 
427  return ( XHCI_ICI ( ctx ) << xhci->csz_shift );
428 }
#define XHCI_ICI(ctx)
Input context index.
Definition: xhci.h:960
struct golan_eq_context ctx
Definition: CIB_PRM.h:28
unsigned int csz_shift
Context size shift.
Definition: xhci.h:1096

References xhci_device::csz_shift, ctx, and XHCI_ICI.

Referenced by xhci_address_device_input(), xhci_configure_endpoint_input(), xhci_context(), xhci_deconfigure_endpoint_input(), and xhci_evaluate_context_input().

◆ xhci_dump()

static void xhci_dump ( struct xhci_device xhci)
inlinestatic

Dump host controller registers.

Parameters
xhcixHCI device

Definition at line 442 of file xhci.c.

442  {
443  uint32_t usbcmd;
444  uint32_t usbsts;
445  uint32_t pagesize;
446  uint32_t dnctrl;
447  uint32_t config;
448 
449  /* Do nothing unless debugging is enabled */
450  if ( ! DBG_LOG )
451  return;
452 
453  /* Dump USBCMD */
454  usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
455  DBGC ( xhci, "XHCI %s USBCMD %08x%s%s\n", xhci->name, usbcmd,
456  ( ( usbcmd & XHCI_USBCMD_RUN ) ? " run" : "" ),
457  ( ( usbcmd & XHCI_USBCMD_HCRST ) ? " hcrst" : "" ) );
458 
459  /* Dump USBSTS */
460  usbsts = readl ( xhci->op + XHCI_OP_USBSTS );
461  DBGC ( xhci, "XHCI %s USBSTS %08x%s\n", xhci->name, usbsts,
462  ( ( usbsts & XHCI_USBSTS_HCH ) ? " hch" : "" ) );
463 
464  /* Dump PAGESIZE */
465  pagesize = readl ( xhci->op + XHCI_OP_PAGESIZE );
466  DBGC ( xhci, "XHCI %s PAGESIZE %08x\n", xhci->name, pagesize );
467 
468  /* Dump DNCTRL */
469  dnctrl = readl ( xhci->op + XHCI_OP_DNCTRL );
470  DBGC ( xhci, "XHCI %s DNCTRL %08x\n", xhci->name, dnctrl );
471 
472  /* Dump CONFIG */
473  config = readl ( xhci->op + XHCI_OP_CONFIG );
474  DBGC ( xhci, "XHCI %s CONFIG %08x\n", xhci->name, config );
475 }
#define XHCI_OP_USBSTS
USB status register.
Definition: xhci.h:164
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
const char * name
Name.
Definition: xhci.h:1073
unsigned int uint32_t
Definition: stdint.h:12
#define XHCI_OP_PAGESIZE
Page size register.
Definition: xhci.h:170
#define XHCI_USBCMD_HCRST
Host controller reset.
Definition: xhci.h:161
#define XHCI_OP_CONFIG
Configure register.
Definition: xhci.h:194
#define XHCI_USBCMD_RUN
Run/stop.
Definition: xhci.h:158
#define XHCI_OP_USBCMD
USB command register.
Definition: xhci.h:155
#define XHCI_USBSTS_HCH
Host controller halted.
Definition: xhci.h:167
#define DBG_LOG
Definition: compiler.h:317
#define XHCI_OP_DNCTRL
Device notifcation control register.
Definition: xhci.h:176
void * op
Operational registers.
Definition: xhci.h:1080

References DBG_LOG, DBGC, xhci_device::name, xhci_device::op, readl(), XHCI_OP_CONFIG, XHCI_OP_DNCTRL, XHCI_OP_PAGESIZE, XHCI_OP_USBCMD, XHCI_OP_USBSTS, XHCI_USBCMD_HCRST, XHCI_USBCMD_RUN, and XHCI_USBSTS_HCH.

◆ xhci_dump_port()

static void xhci_dump_port ( struct xhci_device xhci,
unsigned int  port 
)
inlinestatic

Dump port registers.

Parameters
xhcixHCI device
portPort number

Definition at line 483 of file xhci.c.

484  {
485  uint32_t portsc;
486  uint32_t portpmsc;
487  uint32_t portli;
488  uint32_t porthlpmc;
489 
490  /* Do nothing unless debugging is enabled */
491  if ( ! DBG_LOG )
492  return;
493 
494  /* Dump PORTSC */
495  portsc = readl ( xhci->op + XHCI_OP_PORTSC ( port ) );
496  DBGC ( xhci, "XHCI %s-%d PORTSC %08x%s%s%s%s psiv=%d\n",
497  xhci->name, port, portsc,
498  ( ( portsc & XHCI_PORTSC_CCS ) ? " ccs" : "" ),
499  ( ( portsc & XHCI_PORTSC_PED ) ? " ped" : "" ),
500  ( ( portsc & XHCI_PORTSC_PR ) ? " pr" : "" ),
501  ( ( portsc & XHCI_PORTSC_PP ) ? " pp" : "" ),
502  XHCI_PORTSC_PSIV ( portsc ) );
503 
504  /* Dump PORTPMSC */
505  portpmsc = readl ( xhci->op + XHCI_OP_PORTPMSC ( port ) );
506  DBGC ( xhci, "XHCI %s-%d PORTPMSC %08x\n", xhci->name, port, portpmsc );
507 
508  /* Dump PORTLI */
509  portli = readl ( xhci->op + XHCI_OP_PORTLI ( port ) );
510  DBGC ( xhci, "XHCI %s-%d PORTLI %08x\n", xhci->name, port, portli );
511 
512  /* Dump PORTHLPMC */
513  porthlpmc = readl ( xhci->op + XHCI_OP_PORTHLPMC ( port ) );
514  DBGC ( xhci, "XHCI %s-%d PORTHLPMC %08x\n",
515  xhci->name, port, porthlpmc );
516 }
#define XHCI_PORTSC_PSIV(portsc)
Port speed ID value.
Definition: xhci.h:234
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_OP_PORTHLPMC(port)
Port hardware link power management control register.
Definition: xhci.h:293
#define XHCI_OP_PORTLI(port)
Port link info register.
Definition: xhci.h:290
#define XHCI_PORTSC_PP
Port power.
Definition: xhci.h:228
#define XHCI_PORTSC_CCS
Current connect status.
Definition: xhci.h:207
u8 port
Port number.
Definition: CIB_PRM.h:31
const char * name
Name.
Definition: xhci.h:1073
#define XHCI_OP_PORTPMSC(port)
Port power management status and control register.
Definition: xhci.h:287
unsigned int uint32_t
Definition: stdint.h:12
#define XHCI_OP_PORTSC(port)
Port status and control register.
Definition: xhci.h:204
#define XHCI_PORTSC_PR
Port reset.
Definition: xhci.h:213
#define XHCI_PORTSC_PED
Port enabled.
Definition: xhci.h:210
#define DBG_LOG
Definition: compiler.h:317
void * op
Operational registers.
Definition: xhci.h:1080

References DBG_LOG, DBGC, xhci_device::name, xhci_device::op, port, readl(), XHCI_OP_PORTHLPMC, XHCI_OP_PORTLI, XHCI_OP_PORTPMSC, XHCI_OP_PORTSC, XHCI_PORTSC_CCS, XHCI_PORTSC_PED, XHCI_PORTSC_PP, XHCI_PORTSC_PR, and XHCI_PORTSC_PSIV.

◆ xhci_legacy_init()

static void xhci_legacy_init ( struct xhci_device xhci)
static

Initialise USB legacy support.

Parameters
xhcixHCI device

Definition at line 533 of file xhci.c.

533  {
534  unsigned int legacy;
535  uint8_t bios;
536 
537  /* Locate USB legacy support capability (if present) */
538  legacy = xhci_extended_capability ( xhci, XHCI_XECP_ID_LEGACY, 0 );
539  if ( ! legacy ) {
540  /* Not an error; capability may not be present */
541  DBGC ( xhci, "XHCI %s has no USB legacy support capability\n",
542  xhci->name );
543  return;
544  }
545 
546  /* Check if legacy USB support is enabled */
547  bios = readb ( xhci->cap + legacy + XHCI_USBLEGSUP_BIOS );
548  if ( ! ( bios & XHCI_USBLEGSUP_BIOS_OWNED ) ) {
549  /* Not an error; already owned by OS */
550  DBGC ( xhci, "XHCI %s USB legacy support already disabled\n",
551  xhci->name );
552  return;
553  }
554 
555  /* Record presence of USB legacy support capability */
556  xhci->legacy = legacy;
557 }
uint8_t readb(volatile uint8_t *io_addr)
Read byte from memory-mapped device.
#define XHCI_USBLEGSUP_BIOS_OWNED
USB legacy support BIOS ownership flag.
Definition: xhci.h:89
static unsigned int xhci_extended_capability(struct xhci_device *xhci, unsigned int id, unsigned int offset)
Find extended capability.
Definition: xhci.c:323
#define DBGC(...)
Definition: compiler.h:505
const char * name
Name.
Definition: xhci.h:1073
#define XHCI_USBLEGSUP_BIOS
USB legacy support BIOS owned semaphore.
Definition: xhci.h:86
unsigned char uint8_t
Definition: stdint.h:10
void * cap
Capability registers.
Definition: xhci.h:1078
#define XHCI_XECP_ID_LEGACY
USB legacy support extended capability.
Definition: xhci.h:83
unsigned int legacy
USB legacy support capability (if present and enabled)
Definition: xhci.h:1104

References xhci_device::cap, DBGC, xhci_device::legacy, xhci_device::name, readb(), xhci_extended_capability(), XHCI_USBLEGSUP_BIOS, XHCI_USBLEGSUP_BIOS_OWNED, and XHCI_XECP_ID_LEGACY.

Referenced by xhci_probe().

◆ xhci_legacy_claim()

static void xhci_legacy_claim ( struct xhci_device xhci)
static

Claim ownership from BIOS.

Parameters
xhcixHCI device

Definition at line 564 of file xhci.c.

564  {
565  uint32_t ctlsts;
566  uint8_t bios;
567  unsigned int i;
568 
569  /* Do nothing unless legacy support capability is present */
570  if ( ! xhci->legacy )
571  return;
572 
573  /* Claim ownership */
575  xhci->cap + xhci->legacy + XHCI_USBLEGSUP_OS );
576 
577  /* Wait for BIOS to release ownership */
578  for ( i = 0 ; i < XHCI_USBLEGSUP_MAX_WAIT_MS ; i++ ) {
579 
580  /* Check if BIOS has released ownership */
581  bios = readb ( xhci->cap + xhci->legacy + XHCI_USBLEGSUP_BIOS );
582  if ( ! ( bios & XHCI_USBLEGSUP_BIOS_OWNED ) ) {
583  DBGC ( xhci, "XHCI %s claimed ownership from BIOS\n",
584  xhci->name );
585  ctlsts = readl ( xhci->cap + xhci->legacy +
587  if ( ctlsts ) {
588  DBGC ( xhci, "XHCI %s warning: BIOS retained "
589  "SMIs: %08x\n", xhci->name, ctlsts );
590  }
591  return;
592  }
593 
594  /* Delay */
595  mdelay ( 1 );
596  }
597 
598  /* BIOS did not release ownership. Claim it forcibly by
599  * disabling all SMIs.
600  */
601  DBGC ( xhci, "XHCI %s could not claim ownership from BIOS: forcibly "
602  "disabling SMIs\n", xhci->name );
603  writel ( 0, xhci->cap + xhci->legacy + XHCI_USBLEGSUP_CTLSTS );
604 }
#define XHCI_USBLEGSUP_MAX_WAIT_MS
Maximum time to wait for BIOS to release ownership.
Definition: xhci.h:984
uint8_t readb(volatile uint8_t *io_addr)
Read byte from memory-mapped device.
#define XHCI_USBLEGSUP_BIOS_OWNED
USB legacy support BIOS ownership flag.
Definition: xhci.h:89
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_USBLEGSUP_OS
USB legacy support OS owned semaphore.
Definition: xhci.h:92
void writeb(uint8_t data, volatile uint8_t *io_addr)
Write byte to memory-mapped device.
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
#define XHCI_USBLEGSUP_CTLSTS
USB legacy support control/status.
Definition: xhci.h:98
const char * name
Name.
Definition: xhci.h:1073
#define XHCI_USBLEGSUP_BIOS
USB legacy support BIOS owned semaphore.
Definition: xhci.h:86
#define XHCI_USBLEGSUP_OS_OWNED
USB legacy support OS ownership flag.
Definition: xhci.h:95
unsigned char uint8_t
Definition: stdint.h:10
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
unsigned int legacy
USB legacy support capability (if present and enabled)
Definition: xhci.h:1104

References xhci_device::cap, DBGC, xhci_device::legacy, mdelay(), xhci_device::name, readb(), readl(), writeb(), writel(), XHCI_USBLEGSUP_BIOS, XHCI_USBLEGSUP_BIOS_OWNED, XHCI_USBLEGSUP_CTLSTS, XHCI_USBLEGSUP_MAX_WAIT_MS, XHCI_USBLEGSUP_OS, and XHCI_USBLEGSUP_OS_OWNED.

Referenced by xhci_probe().

◆ xhci_legacy_release()

static void xhci_legacy_release ( struct xhci_device xhci)
static

Release ownership back to BIOS.

Parameters
xhcixHCI device

Definition at line 611 of file xhci.c.

611  {
612 
613  /* Do nothing unless legacy support capability is present */
614  if ( ! xhci->legacy )
615  return;
616 
617  /* Do nothing if releasing ownership is prevented */
619  DBGC ( xhci, "XHCI %s not releasing ownership to BIOS\n",
620  xhci->name );
621  return;
622  }
623 
624  /* Release ownership */
625  writeb ( 0, xhci->cap + xhci->legacy + XHCI_USBLEGSUP_OS );
626  DBGC ( xhci, "XHCI %s released ownership to BIOS\n", xhci->name );
627 }
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_USBLEGSUP_OS
USB legacy support OS owned semaphore.
Definition: xhci.h:92
void writeb(uint8_t data, volatile uint8_t *io_addr)
Write byte to memory-mapped device.
const char * name
Name.
Definition: xhci.h:1073
void * cap
Capability registers.
Definition: xhci.h:1078
unsigned int legacy
USB legacy support capability (if present and enabled)
Definition: xhci.h:1104
static int xhci_legacy_prevent_release
Prevent the release of ownership back to BIOS.
Definition: xhci.c:526

References xhci_device::cap, DBGC, xhci_device::legacy, xhci_device::name, writeb(), xhci_legacy_prevent_release, and XHCI_USBLEGSUP_OS.

Referenced by xhci_probe(), and xhci_remove().

◆ xhci_speed_name()

static const char* xhci_speed_name ( uint32_t  psi)
inlinestatic

Transcribe port speed (for debugging)

Parameters
psiProtocol speed ID
Return values
speedTranscribed speed

Definition at line 642 of file xhci.c.

642  {
643  static const char *exponents[4] = { "", "k", "M", "G" };
644  static char buf[ 10 /* "xxxxxXbps" + NUL */ ];
645  unsigned int mantissa;
646  unsigned int exponent;
647 
648  /* Extract mantissa and exponent */
649  mantissa = XHCI_SUPPORTED_PSI_MANTISSA ( psi );
650  exponent = XHCI_SUPPORTED_PSI_EXPONENT ( psi );
651 
652  /* Transcribe speed */
653  snprintf ( buf, sizeof ( buf ), "%d%sbps",
654  mantissa, exponents[exponent] );
655  return buf;
656 }
int snprintf(char *buf, size_t size, const char *fmt,...)
Write a formatted string to a buffer.
Definition: vsprintf.c:382
#define XHCI_SUPPORTED_PSI_MANTISSA(psi)
Supported protocol PSI mantissa.
Definition: xhci.h:137
#define XHCI_SUPPORTED_PSI_EXPONENT(psi)
Supported protocol PSI exponent.
Definition: xhci.h:140

References snprintf(), XHCI_SUPPORTED_PSI_EXPONENT, and XHCI_SUPPORTED_PSI_MANTISSA.

Referenced by xhci_port_protocol().

◆ xhci_supported_protocol()

static unsigned int xhci_supported_protocol ( struct xhci_device xhci,
unsigned int  port 
)
static

Find supported protocol extended capability for a port.

Parameters
xhcixHCI device
portPort number
Return values
supportedOffset to extended capability, or zero if not found

Definition at line 665 of file xhci.c.

666  {
667  unsigned int supported = 0;
668  unsigned int offset;
669  unsigned int count;
670  uint32_t ports;
671 
672  /* Iterate over all supported protocol structures */
673  while ( ( supported = xhci_extended_capability ( xhci,
675  supported ) ) ) {
676 
677  /* Determine port range */
678  ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
680  count = XHCI_SUPPORTED_PORTS_COUNT ( ports );
681 
682  /* Check if port lies within this range */
683  if ( ( port - offset ) < count )
684  return supported;
685  }
686 
687  DBGC ( xhci, "XHCI %s-%d has no supported protocol\n",
688  xhci->name, port );
689  return 0;
690 }
#define XHCI_SUPPORTED_PORTS
Supported protocol ports.
Definition: xhci.h:113
static unsigned int xhci_extended_capability(struct xhci_device *xhci, unsigned int id, unsigned int offset)
Find extended capability.
Definition: xhci.c:323
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define XHCI_XECP_ID_SUPPORTED
Supported protocol extended capability.
Definition: xhci.h:101
#define DBGC(...)
Definition: compiler.h:505
u8 port
Port number.
Definition: CIB_PRM.h:31
static userptr_t size_t offset
Offset of the first segment within the content.
Definition: deflate.h:259
const char * name
Name.
Definition: xhci.h:1073
#define XHCI_SUPPORTED_PORTS_COUNT(ports)
Supported protocol port count.
Definition: xhci.h:119
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
#define XHCI_SUPPORTED_PORTS_OFFSET(ports)
Supported protocol port offset.
Definition: xhci.h:116
uint16_t count
Number of entries.
Definition: ena.h:22

References xhci_device::cap, count, DBGC, xhci_device::name, offset, port, readl(), xhci_extended_capability(), XHCI_SUPPORTED_PORTS, XHCI_SUPPORTED_PORTS_COUNT, XHCI_SUPPORTED_PORTS_OFFSET, and XHCI_XECP_ID_SUPPORTED.

Referenced by xhci_port_protocol(), xhci_port_psiv(), xhci_port_slot_type(), and xhci_port_speed().

◆ xhci_port_protocol()

static unsigned int xhci_port_protocol ( struct xhci_device xhci,
unsigned int  port 
)
static

Find port protocol.

Parameters
xhcixHCI device
portPort number
Return values
protocolUSB protocol, or zero if not found

Definition at line 699 of file xhci.c.

700  {
701  unsigned int supported = xhci_supported_protocol ( xhci, port );
702  union {
703  uint32_t raw;
704  char text[5];
705  } name;
706  unsigned int protocol;
707  unsigned int type;
708  unsigned int psic;
709  unsigned int psiv;
710  unsigned int i;
712  uint32_t ports;
713  uint32_t slot;
714  uint32_t psi;
715 
716  /* Fail if there is no supported protocol */
717  if ( ! supported )
718  return 0;
719 
720  /* Determine protocol version */
721  revision = readl ( xhci->cap + supported + XHCI_SUPPORTED_REVISION );
723 
724  /* Describe port protocol */
725  if ( DBG_EXTRA ) {
726  name.raw = cpu_to_le32 ( readl ( xhci->cap + supported +
728  name.text[4] = '\0';
729  slot = readl ( xhci->cap + supported + XHCI_SUPPORTED_SLOT );
731  DBGC2 ( xhci, "XHCI %s-%d %sv%04x type %d",
732  xhci->name, port, name.text, protocol, type );
733  ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
734  psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );
735  if ( psic ) {
736  DBGC2 ( xhci, " speeds" );
737  for ( i = 0 ; i < psic ; i++ ) {
738  psi = readl ( xhci->cap + supported +
739  XHCI_SUPPORTED_PSI ( i ) );
740  psiv = XHCI_SUPPORTED_PSI_VALUE ( psi );
741  DBGC2 ( xhci, " %d:%s", psiv,
742  xhci_speed_name ( psi ) );
743  }
744  }
745  if ( xhci->quirks & XHCI_BAD_PSIV )
746  DBGC2 ( xhci, " (ignored)" );
747  DBGC2 ( xhci, "\n" );
748  }
749 
750  return protocol;
751 }
#define XHCI_BAD_PSIV
Invalid protocol speed ID values quirk.
Definition: xhci.h:1042
#define XHCI_SUPPORTED_PORTS
Supported protocol ports.
Definition: xhci.h:113
#define XHCI_SUPPORTED_SLOT_TYPE(slot)
Supported protocol slot type.
Definition: xhci.h:128
const char * name
Definition: ath9k_hw.c:1984
#define XHCI_SUPPORTED_SLOT
Supported protocol slot.
Definition: xhci.h:125
uint32_t type
Operating system type.
Definition: ena.h:12
#define XHCI_SUPPORTED_PSI_VALUE(psi)
Supported protocol PSI value.
Definition: xhci.h:134
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
static const char * xhci_speed_name(uint32_t psi)
Transcribe port speed (for debugging)
Definition: xhci.c:642
u8 port
Port number.
Definition: CIB_PRM.h:31
#define XHCI_SUPPORTED_PORTS_PSIC(ports)
Supported protocol PSI count.
Definition: xhci.h:122
#define cpu_to_le32(value)
Definition: byteswap.h:107
uint32_t revision
Entry point revision.
Definition: ib_mad.h:20
#define XHCI_SUPPORTED_PSI(index)
Supported protocol PSI.
Definition: xhci.h:131
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
#define XHCI_SUPPORTED_REVISION
Supported protocol revision.
Definition: xhci.h:104
static unsigned int xhci_supported_protocol(struct xhci_device *xhci, unsigned int port)
Find supported protocol extended capability for a port.
Definition: xhci.c:665
#define DBGC2(...)
Definition: compiler.h:522
__be32 raw[7]
Definition: CIB_PRM.h:28
uint16_t protocol
Protocol ID.
Definition: stp.h:18
#define DBG_EXTRA
Definition: compiler.h:319
#define XHCI_SUPPORTED_REVISION_VER(revision)
Supported protocol minor revision.
Definition: xhci.h:107
unsigned int quirks
Quirks.
Definition: xhci.h:1075
#define XHCI_SUPPORTED_NAME
Supported protocol name.
Definition: xhci.h:110

References xhci_device::cap, cpu_to_le32, DBG_EXTRA, DBGC2, xhci_device::name, name, port, protocol, xhci_device::quirks, raw, readl(), revision, slot, type, XHCI_BAD_PSIV, xhci_speed_name(), XHCI_SUPPORTED_NAME, XHCI_SUPPORTED_PORTS, XHCI_SUPPORTED_PORTS_PSIC, xhci_supported_protocol(), XHCI_SUPPORTED_PSI, XHCI_SUPPORTED_PSI_VALUE, XHCI_SUPPORTED_REVISION, XHCI_SUPPORTED_REVISION_VER, XHCI_SUPPORTED_SLOT, and XHCI_SUPPORTED_SLOT_TYPE.

Referenced by xhci_probe().

◆ xhci_port_slot_type()

static int xhci_port_slot_type ( struct xhci_device xhci,
unsigned int  port 
)
static

Find port slot type.

Parameters
xhcixHCI device
portPort number
Return values
typeSlot type, or negative error

Definition at line 760 of file xhci.c.

760  {
761  unsigned int supported = xhci_supported_protocol ( xhci, port );
762  unsigned int type;
763  uint32_t slot;
764 
765  /* Fail if there is no supported protocol */
766  if ( ! supported )
767  return -ENOTSUP;
768 
769  /* Get slot type */
770  slot = readl ( xhci->cap + supported + XHCI_SUPPORTED_SLOT );
772 
773  return type;
774 }
#define XHCI_SUPPORTED_SLOT_TYPE(slot)
Supported protocol slot type.
Definition: xhci.h:128
#define XHCI_SUPPORTED_SLOT
Supported protocol slot.
Definition: xhci.h:125
uint32_t type
Operating system type.
Definition: ena.h:12
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
u8 port
Port number.
Definition: CIB_PRM.h:31
uint8_t slot
Slot.
Definition: edd.h:16
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
static unsigned int xhci_supported_protocol(struct xhci_device *xhci, unsigned int port)
Find supported protocol extended capability for a port.
Definition: xhci.c:665

References xhci_device::cap, ENOTSUP, port, readl(), slot, type, xhci_supported_protocol(), XHCI_SUPPORTED_SLOT, and XHCI_SUPPORTED_SLOT_TYPE.

Referenced by xhci_device_open().

◆ xhci_port_speed()

static int xhci_port_speed ( struct xhci_device xhci,
unsigned int  port,
unsigned int  psiv 
)
static

Find port speed.

Parameters
xhcixHCI device
portPort number
psivProtocol speed ID value
Return values
speedPort speed, or negative error

Definition at line 784 of file xhci.c.

785  {
786  unsigned int supported = xhci_supported_protocol ( xhci, port );
787  unsigned int psic;
788  unsigned int mantissa;
789  unsigned int exponent;
790  unsigned int speed;
791  unsigned int i;
792  uint32_t ports;
793  uint32_t psi;
794 
795  /* Fail if there is no supported protocol */
796  if ( ! supported )
797  return -ENOTSUP;
798 
799  /* Get protocol speed ID count */
800  ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
801  psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );
802 
803  /* Use protocol speed ID table unless device is known to be faulty */
804  if ( ! ( xhci->quirks & XHCI_BAD_PSIV ) ) {
805 
806  /* Iterate over PSI dwords looking for a match */
807  for ( i = 0 ; i < psic ; i++ ) {
808  psi = readl ( xhci->cap + supported +
809  XHCI_SUPPORTED_PSI ( i ) );
810  if ( psiv == XHCI_SUPPORTED_PSI_VALUE ( psi ) ) {
811  mantissa = XHCI_SUPPORTED_PSI_MANTISSA ( psi );
812  exponent = XHCI_SUPPORTED_PSI_EXPONENT ( psi );
813  speed = USB_SPEED ( mantissa, exponent );
814  return speed;
815  }
816  }
817 
818  /* Record device as faulty if no match is found */
819  if ( psic != 0 ) {
820  DBGC ( xhci, "XHCI %s-%d spurious PSI value %d: "
821  "assuming PSI table is invalid\n",
822  xhci->name, port, psiv );
823  xhci->quirks |= XHCI_BAD_PSIV;
824  }
825  }
826 
827  /* Use the default mappings */
828  switch ( psiv ) {
829  case XHCI_SPEED_LOW : return USB_SPEED_LOW;
830  case XHCI_SPEED_FULL : return USB_SPEED_FULL;
831  case XHCI_SPEED_HIGH : return USB_SPEED_HIGH;
832  case XHCI_SPEED_SUPER : return USB_SPEED_SUPER;
833  default:
834  DBGC ( xhci, "XHCI %s-%d unrecognised PSI value %d\n",
835  xhci->name, port, psiv );
836  return -ENOTSUP;
837  }
838 }
#define XHCI_BAD_PSIV
Invalid protocol speed ID values quirk.
Definition: xhci.h:1042
#define XHCI_SUPPORTED_PORTS
Supported protocol ports.
Definition: xhci.h:113
Low speed (1.5Mbps)
Definition: usb.h:48
#define XHCI_SUPPORTED_PSI_VALUE(psi)
Supported protocol PSI value.
Definition: xhci.h:134
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
Full speed (12Mbps)
Definition: xhci.h:145
Super speed (5Gbps)
Definition: usb.h:54
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
u8 port
Port number.
Definition: CIB_PRM.h:31
#define USB_SPEED(mantissa, exponent)
Define a USB speed.
Definition: usb.h:35
#define XHCI_SUPPORTED_PORTS_PSIC(ports)
Supported protocol PSI count.
Definition: xhci.h:122
#define XHCI_SUPPORTED_PSI(index)
Supported protocol PSI.
Definition: xhci.h:131
const char * name
Name.
Definition: xhci.h:1073
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
static unsigned int xhci_supported_protocol(struct xhci_device *xhci, unsigned int port)
Find supported protocol extended capability for a port.
Definition: xhci.c:665
High speed (480Mbps)
Definition: usb.h:52
Super speed.
Definition: xhci.h:151
Low speed (1.5Mbps)
Definition: xhci.h:147
#define XHCI_SUPPORTED_PSI_MANTISSA(psi)
Supported protocol PSI mantissa.
Definition: xhci.h:137
High speed (480Mbps)
Definition: xhci.h:149
unsigned int quirks
Quirks.
Definition: xhci.h:1075
#define XHCI_SUPPORTED_PSI_EXPONENT(psi)
Supported protocol PSI exponent.
Definition: xhci.h:140
Full speed (12Mbps)
Definition: usb.h:50

References xhci_device::cap, DBGC, ENOTSUP, xhci_device::name, port, xhci_device::quirks, readl(), USB_SPEED, USB_SPEED_FULL, USB_SPEED_HIGH, USB_SPEED_LOW, USB_SPEED_SUPER, XHCI_BAD_PSIV, XHCI_SPEED_FULL, XHCI_SPEED_HIGH, XHCI_SPEED_LOW, XHCI_SPEED_SUPER, XHCI_SUPPORTED_PORTS, XHCI_SUPPORTED_PORTS_PSIC, xhci_supported_protocol(), XHCI_SUPPORTED_PSI, XHCI_SUPPORTED_PSI_EXPONENT, XHCI_SUPPORTED_PSI_MANTISSA, and XHCI_SUPPORTED_PSI_VALUE.

Referenced by xhci_root_speed().

◆ xhci_port_psiv()

static int xhci_port_psiv ( struct xhci_device xhci,
unsigned int  port,
unsigned int  speed 
)
static

Find protocol speed ID value.

Parameters
xhcixHCI device
portPort number
speedUSB speed
Return values
psivProtocol speed ID value, or negative error

Definition at line 848 of file xhci.c.

849  {
850  unsigned int supported = xhci_supported_protocol ( xhci, port );
851  unsigned int psic;
852  unsigned int mantissa;
853  unsigned int exponent;
854  unsigned int psiv;
855  unsigned int i;
856  uint32_t ports;
857  uint32_t psi;
858 
859  /* Fail if there is no supported protocol */
860  if ( ! supported )
861  return -ENOTSUP;
862 
863  /* Get protocol speed ID count */
864  ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
865  psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );
866 
867  /* Use the default mappings if applicable */
868  if ( ( psic == 0 ) || ( xhci->quirks & XHCI_BAD_PSIV ) ) {
869  switch ( speed ) {
870  case USB_SPEED_LOW : return XHCI_SPEED_LOW;
871  case USB_SPEED_FULL : return XHCI_SPEED_FULL;
872  case USB_SPEED_HIGH : return XHCI_SPEED_HIGH;
873  case USB_SPEED_SUPER : return XHCI_SPEED_SUPER;
874  default:
875  DBGC ( xhci, "XHCI %s-%d non-standard speed %d\n",
876  xhci->name, port, speed );
877  return -ENOTSUP;
878  }
879  }
880 
881  /* Iterate over PSI dwords looking for a match */
882  for ( i = 0 ; i < psic ; i++ ) {
883  psi = readl ( xhci->cap + supported + XHCI_SUPPORTED_PSI ( i ));
884  mantissa = XHCI_SUPPORTED_PSI_MANTISSA ( psi );
885  exponent = XHCI_SUPPORTED_PSI_EXPONENT ( psi );
886  if ( speed == USB_SPEED ( mantissa, exponent ) ) {
887  psiv = XHCI_SUPPORTED_PSI_VALUE ( psi );
888  return psiv;
889  }
890  }
891 
892  DBGC ( xhci, "XHCI %s-%d unrepresentable speed %#x\n",
893  xhci->name, port, speed );
894  return -ENOENT;
895 }
#define XHCI_BAD_PSIV
Invalid protocol speed ID values quirk.
Definition: xhci.h:1042
#define XHCI_SUPPORTED_PORTS
Supported protocol ports.
Definition: xhci.h:113
Low speed (1.5Mbps)
Definition: usb.h:48
#define XHCI_SUPPORTED_PSI_VALUE(psi)
Supported protocol PSI value.
Definition: xhci.h:134
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
#define ENOENT
No such file or directory.
Definition: errno.h:514
Full speed (12Mbps)
Definition: xhci.h:145
Super speed (5Gbps)
Definition: usb.h:54
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
u8 port
Port number.
Definition: CIB_PRM.h:31
#define USB_SPEED(mantissa, exponent)
Define a USB speed.
Definition: usb.h:35
#define XHCI_SUPPORTED_PORTS_PSIC(ports)
Supported protocol PSI count.
Definition: xhci.h:122
#define XHCI_SUPPORTED_PSI(index)
Supported protocol PSI.
Definition: xhci.h:131
const char * name
Name.
Definition: xhci.h:1073
unsigned int uint32_t
Definition: stdint.h:12
void * cap
Capability registers.
Definition: xhci.h:1078
static unsigned int xhci_supported_protocol(struct xhci_device *xhci, unsigned int port)
Find supported protocol extended capability for a port.
Definition: xhci.c:665
High speed (480Mbps)
Definition: usb.h:52
Super speed.
Definition: xhci.h:151
Low speed (1.5Mbps)
Definition: xhci.h:147
#define XHCI_SUPPORTED_PSI_MANTISSA(psi)
Supported protocol PSI mantissa.
Definition: xhci.h:137
High speed (480Mbps)
Definition: xhci.h:149
unsigned int quirks
Quirks.
Definition: xhci.h:1075
#define XHCI_SUPPORTED_PSI_EXPONENT(psi)
Supported protocol PSI exponent.
Definition: xhci.h:140
Full speed (12Mbps)
Definition: usb.h:50

References xhci_device::cap, DBGC, ENOENT, ENOTSUP, xhci_device::name, port, xhci_device::quirks, readl(), USB_SPEED, USB_SPEED_FULL, USB_SPEED_HIGH, USB_SPEED_LOW, USB_SPEED_SUPER, XHCI_BAD_PSIV, XHCI_SPEED_FULL, XHCI_SPEED_HIGH, XHCI_SPEED_LOW, XHCI_SPEED_SUPER, XHCI_SUPPORTED_PORTS, XHCI_SUPPORTED_PORTS_PSIC, xhci_supported_protocol(), XHCI_SUPPORTED_PSI, XHCI_SUPPORTED_PSI_EXPONENT, XHCI_SUPPORTED_PSI_MANTISSA, and XHCI_SUPPORTED_PSI_VALUE.

Referenced by xhci_device_address().

◆ xhci_dcbaa_alloc()

static int xhci_dcbaa_alloc ( struct xhci_device xhci)
static

Allocate device context base address array.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 910 of file xhci.c.

910  {
911  size_t len;
912  physaddr_t dcbaap;
913  int rc;
914 
915  /* Allocate and initialise structure. Must be at least
916  * 64-byte aligned and must not cross a page boundary, so
917  * align on its own size (rounded up to a power of two and
918  * with a minimum of 64 bytes).
919  */
920  len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa.context[0] ) );
921  xhci->dcbaa.context = dma_alloc ( xhci->dma, &xhci->dcbaa.map, len,
922  xhci_align ( len ) );
923  if ( ! xhci->dcbaa.context ) {
924  DBGC ( xhci, "XHCI %s could not allocate DCBAA\n", xhci->name );
925  rc = -ENOMEM;
926  goto err_alloc;
927  }
928  memset ( xhci->dcbaa.context, 0, len );
929 
930  /* Program DCBAA pointer */
931  dcbaap = dma ( &xhci->dcbaa.map, xhci->dcbaa.context );
932  if ( ( rc = xhci_writeq ( xhci, dcbaap,
933  xhci->op + XHCI_OP_DCBAAP ) ) != 0 )
934  goto err_writeq;
935 
936  DBGC2 ( xhci, "XHCI %s DCBAA at [%08lx,%08lx)\n", xhci->name,
937  virt_to_phys ( xhci->dcbaa.context ),
938  ( virt_to_phys ( xhci->dcbaa.context ) + len ) );
939  return 0;
940 
941  err_writeq:
942  dma_free ( &xhci->dcbaa.map, xhci->dcbaa.context, len );
943  err_alloc:
944  return rc;
945 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct xhci_dcbaa dcbaa
Device context base address array.
Definition: xhci.h:1107
static size_t xhci_align(size_t len)
Calculate buffer alignment.
Definition: xhci.c:393
#define DBGC(...)
Definition: compiler.h:505
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
unsigned int slots
Number of device slots.
Definition: xhci.h:1087
#define ENOMEM
Not enough space.
Definition: errno.h:534
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
#define XHCI_OP_DCBAAP
Device context base address array pointer.
Definition: xhci.h:191
const char * name
Name.
Definition: xhci.h:1073
uint64_t * context
Context base addresses.
Definition: xhci.h:1047
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
void * dma_alloc(struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
Allocate and map DMA-coherent buffer.
unsigned long physaddr_t
Definition: stdint.h:20
uint32_t len
Length.
Definition: ena.h:14
#define DBGC2(...)
Definition: compiler.h:522
struct dma_mapping map
DMA mapping.
Definition: xhci.h:1049
struct dma_device * dma
DMA device.
Definition: xhci.h:1071
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
void * op
Operational registers.
Definition: xhci.h:1080
void * memset(void *dest, int character, size_t len) __nonnull

References xhci_dcbaa::context, DBGC, DBGC2, xhci_device::dcbaa, dma(), xhci_device::dma, dma_alloc(), dma_free(), ENOMEM, len, xhci_dcbaa::map, memset(), xhci_device::name, xhci_device::op, rc, xhci_device::slots, virt_to_phys(), xhci_align(), XHCI_OP_DCBAAP, and xhci_writeq().

Referenced by xhci_bus_open().

◆ xhci_dcbaa_free()

static void xhci_dcbaa_free ( struct xhci_device xhci)
static

Free device context base address array.

Parameters
xhcixHCI device

Definition at line 952 of file xhci.c.

952  {
953  size_t len;
954  unsigned int i;
955 
956  /* Sanity check */
957  for ( i = 0 ; i <= xhci->slots ; i++ )
958  assert ( xhci->dcbaa.context[i] == 0 );
959 
960  /* Clear DCBAA pointer */
961  xhci_writeq ( xhci, 0, xhci->op + XHCI_OP_DCBAAP );
962 
963  /* Free DCBAA */
964  len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa.context[0] ) );
965  dma_free ( &xhci->dcbaa.map, xhci->dcbaa.context, len );
966 }
struct xhci_dcbaa dcbaa
Device context base address array.
Definition: xhci.h:1107
unsigned int slots
Number of device slots.
Definition: xhci.h:1087
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define XHCI_OP_DCBAAP
Device context base address array pointer.
Definition: xhci.h:191
uint64_t * context
Context base addresses.
Definition: xhci.h:1047
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
uint32_t len
Length.
Definition: ena.h:14
struct dma_mapping map
DMA mapping.
Definition: xhci.h:1049
void * op
Operational registers.
Definition: xhci.h:1080

References assert(), xhci_dcbaa::context, xhci_device::dcbaa, dma_free(), len, xhci_dcbaa::map, xhci_device::op, xhci_device::slots, XHCI_OP_DCBAAP, and xhci_writeq().

Referenced by xhci_bus_close(), and xhci_bus_open().

◆ xhci_scratchpad_alloc()

static int xhci_scratchpad_alloc ( struct xhci_device xhci)
static

Allocate scratchpad buffers.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 981 of file xhci.c.

981  {
982  struct xhci_scratchpad *scratch = &xhci->scratch;
983  size_t buffer_len;
984  size_t array_len;
986  unsigned int i;
987  int rc;
988 
989  /* Do nothing if no scratchpad buffers are used */
990  if ( ! scratch->count )
991  return 0;
992 
993  /* Allocate scratchpad buffers */
994  buffer_len = ( scratch->count * xhci->pagesize );
995  scratch->buffer = dma_umalloc ( xhci->dma, &scratch->buffer_map,
996  buffer_len, xhci->pagesize );
997  if ( ! scratch->buffer ) {
998  DBGC ( xhci, "XHCI %s could not allocate scratchpad buffers\n",
999  xhci->name );
1000  rc = -ENOMEM;
1001  goto err_alloc;
1002  }
1003  memset_user ( scratch->buffer, 0, 0, buffer_len );
1004 
1005  /* Allocate scratchpad array */
1006  array_len = ( scratch->count * sizeof ( scratch->array[0] ) );
1007  scratch->array = dma_alloc ( xhci->dma, &scratch->array_map,
1008  array_len, xhci_align ( array_len ) );
1009  if ( ! scratch->array ) {
1010  DBGC ( xhci, "XHCI %s could not allocate scratchpad buffer "
1011  "array\n", xhci->name );
1012  rc = -ENOMEM;
1013  goto err_alloc_array;
1014  }
1015 
1016  /* Populate scratchpad array */
1017  addr = dma_phys ( &scratch->buffer_map,
1018  user_to_phys ( scratch->buffer, 0 ) );
1019  for ( i = 0 ; i < scratch->count ; i++ ) {
1020  scratch->array[i] = cpu_to_le64 ( addr );
1021  addr += xhci->pagesize;
1022  }
1023 
1024  /* Set scratchpad array pointer */
1025  assert ( xhci->dcbaa.context != NULL );
1026  xhci->dcbaa.context[0] = cpu_to_le64 ( dma ( &scratch->array_map,
1027  scratch->array ) );
1028 
1029  DBGC2 ( xhci, "XHCI %s scratchpad [%08lx,%08lx) array [%08lx,%08lx)\n",
1030  xhci->name, user_to_phys ( scratch->buffer, 0 ),
1031  user_to_phys ( scratch->buffer, buffer_len ),
1032  virt_to_phys ( scratch->array ),
1033  ( virt_to_phys ( scratch->array ) + array_len ) );
1034  return 0;
1035 
1036  dma_free ( &scratch->array_map, scratch->array, array_len );
1037  err_alloc_array:
1038  dma_ufree ( &scratch->buffer_map, scratch->buffer, buffer_len );
1039  err_alloc:
1040  return rc;
1041 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct xhci_dcbaa dcbaa
Device context base address array.
Definition: xhci.h:1107
static size_t xhci_align(size_t len)
Calculate buffer alignment.
Definition: xhci.c:393
physaddr_t dma_phys(struct dma_mapping *map, physaddr_t addr)
Get DMA address from physical address.
unsigned long user_to_phys(userptr_t userptr, off_t offset)
Convert user pointer to physical address.
#define DBGC(...)
Definition: compiler.h:505
struct dma_mapping buffer_map
Buffer DMA mapping.
Definition: xhci.h:1059
#define cpu_to_le64(value)
Definition: byteswap.h:108
unsigned int count
Number of page-sized scratchpad buffers.
Definition: xhci.h:1055
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
struct xhci_scratchpad scratch
Scratchpad buffer.
Definition: xhci.h:1110
uint64_t * array
Scratchpad array.
Definition: xhci.h:1061
void memset_user(userptr_t userptr, off_t offset, int c, size_t len)
Fill user buffer with a constant byte.
#define ENOMEM
Not enough space.
Definition: errno.h:534
struct dma_mapping array_map
Array DMA mapping.
Definition: xhci.h:1063
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
const char * name
Name.
Definition: xhci.h:1073
uint64_t * context
Context base addresses.
Definition: xhci.h:1047
u32 addr
Definition: sky2.h:8
Scratchpad buffer.
Definition: xhci.h:1053
void * dma_alloc(struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
Allocate and map DMA-coherent buffer.
userptr_t buffer
Scratchpad buffer area.
Definition: xhci.h:1057
unsigned long physaddr_t
Definition: stdint.h:20
void dma_ufree(struct dma_mapping *map, userptr_t addr, size_t len)
Unmap and free DMA-coherent buffer from external (user) memory.
#define DBGC2(...)
Definition: compiler.h:522
size_t pagesize
Page size.
Definition: xhci.h:1101
struct dma_device * dma
DMA device.
Definition: xhci.h:1071
userptr_t dma_umalloc(struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
Allocate and map DMA-coherent buffer from external (user) memory.
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References addr, xhci_scratchpad::array, xhci_scratchpad::array_map, assert(), xhci_scratchpad::buffer, xhci_scratchpad::buffer_map, xhci_dcbaa::context, xhci_scratchpad::count, cpu_to_le64, DBGC, DBGC2, xhci_device::dcbaa, dma(), xhci_device::dma, dma_alloc(), dma_free(), dma_phys(), dma_ufree(), dma_umalloc(), ENOMEM, memset_user(), xhci_device::name, NULL, xhci_device::pagesize, rc, xhci_device::scratch, user_to_phys(), virt_to_phys(), and xhci_align().

Referenced by xhci_bus_open().

◆ xhci_scratchpad_free()

static void xhci_scratchpad_free ( struct xhci_device xhci)
static

Free scratchpad buffers.

Parameters
xhcixHCI device

Definition at line 1048 of file xhci.c.

1048  {
1049  struct xhci_scratchpad *scratch = &xhci->scratch;
1050  size_t array_len;
1051  size_t buffer_len;
1052 
1053  /* Do nothing if no scratchpad buffers are used */
1054  if ( ! scratch->count )
1055  return;
1056 
1057  /* Clear scratchpad array pointer */
1058  assert ( xhci->dcbaa.context != NULL );
1059  xhci->dcbaa.context[0] = 0;
1060 
1061  /* Free scratchpad array */
1062  array_len = ( scratch->count * sizeof ( scratch->array[0] ) );
1063  dma_free ( &scratch->array_map, scratch->array, array_len );
1064 
1065  /* Free scratchpad buffers */
1066  buffer_len = ( scratch->count * xhci->pagesize );
1067  dma_ufree ( &scratch->buffer_map, scratch->buffer, buffer_len );
1068 }
struct xhci_dcbaa dcbaa
Device context base address array.
Definition: xhci.h:1107
struct dma_mapping buffer_map
Buffer DMA mapping.
Definition: xhci.h:1059
unsigned int count
Number of page-sized scratchpad buffers.
Definition: xhci.h:1055
struct xhci_scratchpad scratch
Scratchpad buffer.
Definition: xhci.h:1110
uint64_t * array
Scratchpad array.
Definition: xhci.h:1061
struct dma_mapping array_map
Array DMA mapping.
Definition: xhci.h:1063
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
uint64_t * context
Context base addresses.
Definition: xhci.h:1047
Scratchpad buffer.
Definition: xhci.h:1053
userptr_t buffer
Scratchpad buffer area.
Definition: xhci.h:1057
void dma_ufree(struct dma_mapping *map, userptr_t addr, size_t len)
Unmap and free DMA-coherent buffer from external (user) memory.
size_t pagesize
Page size.
Definition: xhci.h:1101
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References xhci_scratchpad::array, xhci_scratchpad::array_map, assert(), xhci_scratchpad::buffer, xhci_scratchpad::buffer_map, xhci_dcbaa::context, xhci_scratchpad::count, xhci_device::dcbaa, dma_free(), dma_ufree(), NULL, xhci_device::pagesize, and xhci_device::scratch.

Referenced by xhci_bus_close(), and xhci_bus_open().

◆ xhci_run()

static void xhci_run ( struct xhci_device xhci)
static

Start xHCI device.

Parameters
xhcixHCI device

Definition at line 1082 of file xhci.c.

1082  {
1083  uint32_t config;
1084  uint32_t usbcmd;
1085 
1086  /* Configure number of device slots */
1087  config = readl ( xhci->op + XHCI_OP_CONFIG );
1088  config &= ~XHCI_CONFIG_MAX_SLOTS_EN_MASK;
1089  config |= XHCI_CONFIG_MAX_SLOTS_EN ( xhci->slots );
1090  writel ( config, xhci->op + XHCI_OP_CONFIG );
1091 
1092  /* Set run/stop bit */
1093  usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
1094  usbcmd |= XHCI_USBCMD_RUN;
1095  writel ( usbcmd, xhci->op + XHCI_OP_USBCMD );
1096 }
#define XHCI_CONFIG_MAX_SLOTS_EN(slots)
Maximum device slots enabled.
Definition: xhci.h:197
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
unsigned int slots
Number of device slots.
Definition: xhci.h:1087
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
unsigned int uint32_t
Definition: stdint.h:12
#define XHCI_OP_CONFIG
Configure register.
Definition: xhci.h:194
#define XHCI_USBCMD_RUN
Run/stop.
Definition: xhci.h:158
#define XHCI_CONFIG_MAX_SLOTS_EN_MASK
Maximum device slots enabled mask.
Definition: xhci.h:200
#define XHCI_OP_USBCMD
USB command register.
Definition: xhci.h:155
void * op
Operational registers.
Definition: xhci.h:1080

References xhci_device::op, readl(), xhci_device::slots, writel(), XHCI_CONFIG_MAX_SLOTS_EN, XHCI_CONFIG_MAX_SLOTS_EN_MASK, XHCI_OP_CONFIG, XHCI_OP_USBCMD, and XHCI_USBCMD_RUN.

Referenced by xhci_bus_open().

◆ xhci_stop()

static int xhci_stop ( struct xhci_device xhci)
static

Stop xHCI device.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 1104 of file xhci.c.

1104  {
1105  uint32_t usbcmd;
1106  uint32_t usbsts;
1107  unsigned int i;
1108 
1109  /* Clear run/stop bit */
1110  usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
1111  usbcmd &= ~XHCI_USBCMD_RUN;
1112  writel ( usbcmd, xhci->op + XHCI_OP_USBCMD );
1113 
1114  /* Wait for device to stop */
1115  for ( i = 0 ; i < XHCI_STOP_MAX_WAIT_MS ; i++ ) {
1116 
1117  /* Check if device is stopped */
1118  usbsts = readl ( xhci->op + XHCI_OP_USBSTS );
1119  if ( usbsts & XHCI_USBSTS_HCH )
1120  return 0;
1121 
1122  /* Delay */
1123  mdelay ( 1 );
1124  }
1125 
1126  DBGC ( xhci, "XHCI %s timed out waiting for stop\n", xhci->name );
1127  return -ETIMEDOUT;
1128 }
#define XHCI_OP_USBSTS
USB status register.
Definition: xhci.h:164
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
const char * name
Name.
Definition: xhci.h:1073
unsigned int uint32_t
Definition: stdint.h:12
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
#define XHCI_STOP_MAX_WAIT_MS
Maximum time to wait for host controller to stop.
Definition: xhci.h:990
#define XHCI_USBCMD_RUN
Run/stop.
Definition: xhci.h:158
#define XHCI_OP_USBCMD
USB command register.
Definition: xhci.h:155
#define XHCI_USBSTS_HCH
Host controller halted.
Definition: xhci.h:167
#define ETIMEDOUT
Connection timed out.
Definition: errno.h:669
void * op
Operational registers.
Definition: xhci.h:1080

References DBGC, ETIMEDOUT, mdelay(), xhci_device::name, xhci_device::op, readl(), writel(), XHCI_OP_USBCMD, XHCI_OP_USBSTS, XHCI_STOP_MAX_WAIT_MS, XHCI_USBCMD_RUN, and XHCI_USBSTS_HCH.

Referenced by xhci_bus_close(), xhci_bus_open(), and xhci_reset().

◆ xhci_reset()

static int xhci_reset ( struct xhci_device xhci)
static

Reset xHCI device.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 1136 of file xhci.c.

1136  {
1137  uint32_t usbcmd;
1138  unsigned int i;
1139  int rc;
1140 
1141  /* The xHCI specification states that resetting a running
1142  * device may result in undefined behaviour, so try stopping
1143  * it first.
1144  */
1145  if ( ( rc = xhci_stop ( xhci ) ) != 0 ) {
1146  /* Ignore errors and attempt to reset the device anyway */
1147  }
1148 
1149  /* Reset device */
1151 
1152  /* Wait for reset to complete */
1153  for ( i = 0 ; i < XHCI_RESET_MAX_WAIT_MS ; i++ ) {
1154 
1155  /* Check if reset is complete */
1156  usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
1157  if ( ! ( usbcmd & XHCI_USBCMD_HCRST ) )
1158  return 0;
1159 
1160  /* Delay */
1161  mdelay ( 1 );
1162  }
1163 
1164  DBGC ( xhci, "XHCI %s timed out waiting for reset\n", xhci->name );
1165  return -ETIMEDOUT;
1166 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
static int xhci_stop(struct xhci_device *xhci)
Stop xHCI device.
Definition: xhci.c:1104
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_RESET_MAX_WAIT_MS
Maximum time to wait for reset to complete.
Definition: xhci.h:996
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
const char * name
Name.
Definition: xhci.h:1073
unsigned int uint32_t
Definition: stdint.h:12
#define XHCI_USBCMD_HCRST
Host controller reset.
Definition: xhci.h:161
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
#define XHCI_OP_USBCMD
USB command register.
Definition: xhci.h:155
#define ETIMEDOUT
Connection timed out.
Definition: errno.h:669
void * op
Operational registers.
Definition: xhci.h:1080

References DBGC, ETIMEDOUT, mdelay(), xhci_device::name, xhci_device::op, rc, readl(), writel(), XHCI_OP_USBCMD, XHCI_RESET_MAX_WAIT_MS, xhci_stop(), and XHCI_USBCMD_HCRST.

Referenced by xhci_fail(), xhci_probe(), and xhci_remove().

◆ xhci_fail()

static int xhci_fail ( struct xhci_device xhci)
static

Mark xHCI device as permanently failed.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 1174 of file xhci.c.

1174  {
1175  size_t len;
1176  int rc;
1177 
1178  /* Mark command mechanism as permanently failed */
1179  xhci->failed = 1;
1180 
1181  /* Reset device */
1182  if ( ( rc = xhci_reset ( xhci ) ) != 0 )
1183  return rc;
1184 
1185  /* Discard DCBAA entries since DCBAAP has been cleared */
1186  assert ( xhci->dcbaa.context != NULL );
1187  len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa.context[0] ) );
1188  memset ( xhci->dcbaa.context, 0, len );
1189 
1190  return 0;
1191 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct xhci_dcbaa dcbaa
Device context base address array.
Definition: xhci.h:1107
unsigned int slots
Number of device slots.
Definition: xhci.h:1087
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
int failed
Command mechanism has permanently failed.
Definition: xhci.h:1119
uint64_t * context
Context base addresses.
Definition: xhci.h:1047
static int xhci_reset(struct xhci_device *xhci)
Reset xHCI device.
Definition: xhci.c:1136
uint32_t len
Length.
Definition: ena.h:14
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
void * memset(void *dest, int character, size_t len) __nonnull

References assert(), xhci_dcbaa::context, xhci_device::dcbaa, xhci_device::failed, len, memset(), NULL, rc, xhci_device::slots, and xhci_reset().

Referenced by xhci_abort(), and xhci_remove().

◆ xhci_ring_alloc()

static int xhci_ring_alloc ( struct xhci_device xhci,
struct xhci_trb_ring ring,
unsigned int  shift,
unsigned int  slot,
unsigned int  target,
unsigned int  stream 
)
static

Allocate transfer request block ring.

Parameters
xhcixHCI device
ringTRB ring
shiftRing size (log2)
slotDevice slot
targetDoorbell target
streamDoorbell stream ID
Return values
rcReturn status code

Definition at line 1211 of file xhci.c.

1214  {
1215  struct xhci_trb_link *link;
1216  unsigned int count;
1217  int rc;
1218 
1219  /* Sanity check */
1220  assert ( shift > 0 );
1221 
1222  /* Initialise structure */
1223  memset ( ring, 0, sizeof ( *ring ) );
1224  ring->shift = shift;
1225  count = ( 1U << shift );
1226  ring->mask = ( count - 1 );
1227  ring->len = ( ( count + 1 /* Link TRB */ ) * sizeof ( ring->trb[0] ) );
1228  ring->db = ( xhci->db + ( slot * sizeof ( ring->dbval ) ) );
1229  ring->dbval = XHCI_DBVAL ( target, stream );
1230 
1231  /* Allocate I/O buffers */
1232  ring->iobuf = zalloc ( count * sizeof ( ring->iobuf[0] ) );
1233  if ( ! ring->iobuf ) {
1234  rc = -ENOMEM;
1235  goto err_alloc_iobuf;
1236  }
1237 
1238  /* Allocate TRBs */
1239  ring->trb = dma_alloc ( xhci->dma, &ring->map, ring->len,
1240  xhci_align ( ring->len ) );
1241  if ( ! ring->trb ) {
1242  rc = -ENOMEM;
1243  goto err_alloc_trb;
1244  }
1245  memset ( ring->trb, 0, ring->len );
1246 
1247  /* Initialise Link TRB */
1248  link = &ring->trb[count].link;
1249  link->next = cpu_to_le64 ( dma ( &ring->map, ring->trb ) );
1250  link->flags = XHCI_TRB_TC;
1251  link->type = XHCI_TRB_LINK;
1252  ring->link = link;
1253 
1254  return 0;
1255 
1256  dma_free ( &ring->map, ring->trb, ring->len );
1257  err_alloc_trb:
1258  free ( ring->iobuf );
1259  err_alloc_iobuf:
1260  return rc;
1261 }
#define XHCI_TRB_TC
Transfer request block toggle cycle bit flag.
Definition: xhci.h:332
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
uint32_t dbval
Doorbell register value.
Definition: xhci.h:865
size_t len
Length of transfer request blocks.
Definition: xhci.h:856
static size_t xhci_align(size_t len)
Calculate buffer alignment.
Definition: xhci.c:393
struct dma_mapping map
DMA mapping.
Definition: xhci.h:858
#define cpu_to_le64(value)
Definition: byteswap.h:108
void * db
Doorbell register.
Definition: xhci.h:863
#define ENOMEM
Not enough space.
Definition: errno.h:534
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
u32 link
Link to next descriptor.
Definition: ar9003_mac.h:68
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
uint8_t slot
Slot.
Definition: edd.h:16
void * dma_alloc(struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
Allocate and map DMA-coherent buffer.
#define XHCI_DBVAL(target, stream)
Calculate doorbell register value.
Definition: xhci.h:889
unsigned int mask
Ring counter mask.
Definition: xhci.h:848
struct io_buffer ** iobuf
I/O buffers.
Definition: xhci.h:851
uint16_t count
Number of entries.
Definition: ena.h:22
struct dma_device * dma
DMA device.
Definition: xhci.h:1071
struct xhci_trb_link * link
Link TRB (if applicable)
Definition: xhci.h:860
unsigned int shift
Ring size (log2)
Definition: xhci.h:846
void * db
Doorbell registers.
Definition: xhci.h:1084
#define XHCI_TRB_LINK
A link transfer request block.
Definition: xhci.h:460
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
struct xhci_trb_link link
Link TRB.
Definition: xhci.h:697
void * memset(void *dest, int character, size_t len) __nonnull

References assert(), count, cpu_to_le64, xhci_trb_ring::db, xhci_device::db, xhci_trb_ring::dbval, dma(), xhci_device::dma, dma_alloc(), dma_free(), ENOMEM, free, xhci_trb_ring::iobuf, xhci_trb_ring::len, link, xhci_trb::link, xhci_trb_ring::link, xhci_trb_ring::map, xhci_trb_ring::mask, memset(), rc, xhci_trb_ring::shift, slot, xhci_trb_ring::trb, xhci_align(), XHCI_DBVAL, XHCI_TRB_LINK, XHCI_TRB_TC, and zalloc().

Referenced by xhci_command_alloc(), and xhci_endpoint_open().

◆ xhci_ring_reset()

static void xhci_ring_reset ( struct xhci_trb_ring ring)
static

Reset transfer request block ring.

Parameters
ringTRB ring

Definition at line 1268 of file xhci.c.

1268  {
1269  unsigned int count = ( 1U << ring->shift );
1270 
1271  /* Reset producer and consumer counters */
1272  ring->prod = 0;
1273  ring->cons = 0;
1274 
1275  /* Reset TRBs (except Link TRB) */
1276  memset ( ring->trb, 0, ( count * sizeof ( ring->trb[0] ) ) );
1277 }
unsigned int cons
Consumer counter.
Definition: xhci.h:844
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
unsigned int prod
Producer counter.
Definition: xhci.h:842
uint16_t count
Number of entries.
Definition: ena.h:22
unsigned int shift
Ring size (log2)
Definition: xhci.h:846
void * memset(void *dest, int character, size_t len) __nonnull

References xhci_trb_ring::cons, count, memset(), xhci_trb_ring::prod, xhci_trb_ring::shift, and xhci_trb_ring::trb.

Referenced by xhci_abort().

◆ xhci_ring_free()

static void xhci_ring_free ( struct xhci_trb_ring ring)
static

Free transfer request block ring.

Parameters
ringTRB ring

Definition at line 1284 of file xhci.c.

1284  {
1285  unsigned int count = ( 1U << ring->shift );
1286  unsigned int i;
1287 
1288  /* Sanity checks */
1289  assert ( ring->cons == ring->prod );
1290  for ( i = 0 ; i < count ; i++ )
1291  assert ( ring->iobuf[i] == NULL );
1292 
1293  /* Free TRBs */
1294  dma_free ( &ring->map, ring->trb, ring->len );
1295 
1296  /* Free I/O buffers */
1297  free ( ring->iobuf );
1298 }
unsigned int cons
Consumer counter.
Definition: xhci.h:844
size_t len
Length of transfer request blocks.
Definition: xhci.h:856
struct dma_mapping map
DMA mapping.
Definition: xhci.h:858
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
unsigned int prod
Producer counter.
Definition: xhci.h:842
struct io_buffer ** iobuf
I/O buffers.
Definition: xhci.h:851
uint16_t count
Number of entries.
Definition: ena.h:22
unsigned int shift
Ring size (log2)
Definition: xhci.h:846
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References assert(), xhci_trb_ring::cons, count, dma_free(), free, xhci_trb_ring::iobuf, xhci_trb_ring::len, xhci_trb_ring::map, NULL, xhci_trb_ring::prod, xhci_trb_ring::shift, and xhci_trb_ring::trb.

Referenced by xhci_command_alloc(), xhci_command_free(), xhci_endpoint_close(), and xhci_endpoint_open().

◆ xhci_enqueue()

static int xhci_enqueue ( struct xhci_trb_ring ring,
struct io_buffer iobuf,
const union xhci_trb trb 
)
static

Enqueue a transfer request block.

Parameters
ringTRB ring
iobufI/O buffer (if any)
trbTransfer request block (with empty Cycle flag)
Return values
rcReturn status code

This operation does not implicitly ring the doorbell register.

Definition at line 1310 of file xhci.c.

1311  {
1312  union xhci_trb *dest;
1313  unsigned int prod;
1314  unsigned int mask;
1315  unsigned int index;
1316  unsigned int cycle;
1317 
1318  /* Sanity check */
1319  assert ( ! ( trb->common.flags & XHCI_TRB_C ) );
1320 
1321  /* Fail if ring is full */
1322  if ( ! xhci_ring_remaining ( ring ) )
1323  return -ENOBUFS;
1324 
1325  /* Update producer counter (and link TRB, if applicable) */
1326  prod = ring->prod++;
1327  mask = ring->mask;
1328  cycle = ( ( ~( prod >> ring->shift ) ) & XHCI_TRB_C );
1329  index = ( prod & mask );
1330  if ( index == 0 )
1331  ring->link->flags = ( XHCI_TRB_TC | ( cycle ^ XHCI_TRB_C ) );
1332 
1333  /* Record I/O buffer */
1334  ring->iobuf[index] = iobuf;
1335 
1336  /* Enqueue TRB */
1337  dest = &ring->trb[index];
1338  dest->template.parameter = trb->template.parameter;
1339  dest->template.status = trb->template.status;
1340  wmb();
1341  dest->template.control = ( trb->template.control |
1342  cpu_to_le32 ( cycle ) );
1343 
1344  return 0;
1345 }
#define XHCI_TRB_TC
Transfer request block toggle cycle bit flag.
Definition: xhci.h:332
wmb()
struct xhci_trb_common common
Common fields.
Definition: xhci.h:687
uint8_t flags
Flags.
Definition: xhci.h:321
static unsigned int xhci_ring_remaining(struct xhci_trb_ring *ring)
Calculate space remaining in TRB ring.
Definition: xhci.h:913
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
struct xhci_trb_template template
Template.
Definition: xhci.h:685
static void * dest
Definition: strings.h:176
#define cpu_to_le32(value)
Definition: byteswap.h:107
uint32_t status
Status.
Definition: xhci.h:309
A transfer request block.
Definition: xhci.h:683
unsigned int prod
Producer counter.
Definition: xhci.h:842
uint32_t control
Control.
Definition: xhci.h:311
#define ENOBUFS
No buffer space available.
Definition: errno.h:498
unsigned int mask
Ring counter mask.
Definition: xhci.h:848
struct io_buffer ** iobuf
I/O buffers.
Definition: xhci.h:851
struct xhci_trb_link * link
Link TRB (if applicable)
Definition: xhci.h:860
unsigned int shift
Ring size (log2)
Definition: xhci.h:846
uint64_t index
Index of the first segment within the content.
Definition: pccrc.h:21
#define XHCI_TRB_C
Transfer request block cycle bit flag.
Definition: xhci.h:329
uint64_t parameter
Parameter.
Definition: xhci.h:307

References assert(), xhci_trb::common, xhci_trb_template::control, cpu_to_le32, dest, ENOBUFS, xhci_trb_common::flags, xhci_trb_link::flags, index, xhci_trb_ring::iobuf, xhci_trb_ring::link, xhci_trb_ring::mask, xhci_trb_template::parameter, xhci_trb_ring::prod, xhci_trb_ring::shift, xhci_trb_template::status, xhci_trb::template, xhci_trb_ring::trb, wmb(), xhci_ring_remaining(), XHCI_TRB_C, and XHCI_TRB_TC.

Referenced by xhci_command(), and xhci_enqueue_multi().

◆ xhci_dequeue()

static struct io_buffer* xhci_dequeue ( struct xhci_trb_ring ring)
static

Dequeue a transfer request block.

Parameters
ringTRB ring
Return values
iobufI/O buffer

Definition at line 1353 of file xhci.c.

1353  {
1354  struct io_buffer *iobuf;
1355  unsigned int cons;
1356  unsigned int mask;
1357  unsigned int index;
1358 
1359  /* Sanity check */
1360  assert ( xhci_ring_fill ( ring ) != 0 );
1361 
1362  /* Update consumer counter */
1363  cons = ring->cons++;
1364  mask = ring->mask;
1365  index = ( cons & mask );
1366 
1367  /* Retrieve I/O buffer */
1368  iobuf = ring->iobuf[index];
1369  ring->iobuf[index] = NULL;
1370 
1371  return iobuf;
1372 }
unsigned int cons
Consumer counter.
Definition: xhci.h:844
static unsigned int xhci_ring_fill(struct xhci_trb_ring *ring)
Calculate space used in TRB ring.
Definition: xhci.h:898
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
uint16_t cons
Consumer index.
Definition: ena.h:22
unsigned int mask
Ring counter mask.
Definition: xhci.h:848
struct io_buffer ** iobuf
I/O buffers.
Definition: xhci.h:851
uint64_t index
Index of the first segment within the content.
Definition: pccrc.h:21
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
A persistent I/O buffer.
Definition: iobuf.h:33

References assert(), cons, xhci_trb_ring::cons, index, xhci_trb_ring::iobuf, xhci_trb_ring::mask, NULL, and xhci_ring_fill().

Referenced by xhci_complete(), and xhci_dequeue_multi().

◆ xhci_enqueue_multi()

static int xhci_enqueue_multi ( struct xhci_trb_ring ring,
struct io_buffer iobuf,
const union xhci_trb trbs,
unsigned int  count 
)
static

Enqueue multiple transfer request blocks.

Parameters
ringTRB ring
iobufI/O buffer
trbsTransfer request blocks (with empty Cycle flag)
countNumber of transfer request blocks
Return values
rcReturn status code

This operation does not implicitly ring the doorbell register.

Definition at line 1385 of file xhci.c.

1388  {
1389  const union xhci_trb *trb = trbs;
1390  int rc;
1391 
1392  /* Sanity check */
1393  assert ( iobuf != NULL );
1394 
1395  /* Fail if ring does not have sufficient space */
1396  if ( xhci_ring_remaining ( ring ) < count )
1397  return -ENOBUFS;
1398 
1399  /* Enqueue each TRB, recording the I/O buffer with the final TRB */
1400  while ( count-- ) {
1401  rc = xhci_enqueue ( ring, ( count ? NULL : iobuf ), trb++ );
1402  assert ( rc == 0 ); /* Should never be able to fail */
1403  }
1404 
1405  return 0;
1406 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
static unsigned int xhci_ring_remaining(struct xhci_trb_ring *ring)
Calculate space remaining in TRB ring.
Definition: xhci.h:913
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
A transfer request block.
Definition: xhci.h:683
#define ENOBUFS
No buffer space available.
Definition: errno.h:498
uint16_t count
Number of entries.
Definition: ena.h:22
static int xhci_enqueue(struct xhci_trb_ring *ring, struct io_buffer *iobuf, const union xhci_trb *trb)
Enqueue a transfer request block.
Definition: xhci.c:1310
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References assert(), count, ENOBUFS, NULL, rc, xhci_enqueue(), and xhci_ring_remaining().

Referenced by xhci_endpoint_message(), and xhci_endpoint_stream().

◆ xhci_dequeue_multi()

static struct io_buffer* xhci_dequeue_multi ( struct xhci_trb_ring ring)
static

Dequeue multiple transfer request blocks.

Parameters
ringTRB ring
Return values
iobufI/O buffer

Definition at line 1414 of file xhci.c.

1414  {
1415  struct io_buffer *iobuf;
1416 
1417  /* Dequeue TRBs until we reach the final TRB for an I/O buffer */
1418  do {
1419  iobuf = xhci_dequeue ( ring );
1420  } while ( iobuf == NULL );
1421 
1422  return iobuf;
1423 }
static struct io_buffer * xhci_dequeue(struct xhci_trb_ring *ring)
Dequeue a transfer request block.
Definition: xhci.c:1353
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
A persistent I/O buffer.
Definition: iobuf.h:33

References NULL, and xhci_dequeue().

Referenced by xhci_endpoint_close(), and xhci_transfer().

◆ xhci_doorbell()

static void xhci_doorbell ( struct xhci_trb_ring ring)
inlinestatic

Ring doorbell register.

Parameters
ringTRB ring

Definition at line 1431 of file xhci.c.

1431  {
1432 
1433  wmb();
1434  writel ( ring->dbval, ring->db );
1435 }
wmb()
uint32_t dbval
Doorbell register value.
Definition: xhci.h:865
void * db
Doorbell register.
Definition: xhci.h:863
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.

References xhci_trb_ring::db, xhci_trb_ring::dbval, wmb(), and writel().

Referenced by xhci_command(), xhci_endpoint_message(), xhci_endpoint_reset(), and xhci_endpoint_stream().

◆ xhci_command_alloc()

static int xhci_command_alloc ( struct xhci_device xhci)
static

Allocate command ring.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 1450 of file xhci.c.

1450  {
1451  physaddr_t crp;
1452  int rc;
1453 
1454  /* Allocate TRB ring */
1455  if ( ( rc = xhci_ring_alloc ( xhci, &xhci->command, XHCI_CMD_TRBS_LOG2,
1456  0, 0, 0 ) ) != 0 )
1457  goto err_ring_alloc;
1458 
1459  /* Program command ring control register */
1460  crp = dma ( &xhci->command.map, xhci->command.trb );
1461  if ( ( rc = xhci_writeq ( xhci, ( crp | XHCI_CRCR_RCS ),
1462  xhci->op + XHCI_OP_CRCR ) ) != 0 )
1463  goto err_writeq;
1464 
1465  DBGC2 ( xhci, "XHCI %s CRCR at [%08lx,%08lx)\n", xhci->name,
1466  virt_to_phys ( xhci->command.trb ),
1467  ( virt_to_phys ( xhci->command.trb ) + xhci->command.len ) );
1468  return 0;
1469 
1470  err_writeq:
1471  xhci_ring_free ( &xhci->command );
1472  err_ring_alloc:
1473  return rc;
1474 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
size_t len
Length of transfer request blocks.
Definition: xhci.h:856
struct xhci_trb_ring command
Command ring.
Definition: xhci.h:1113
struct dma_mapping map
DMA mapping.
Definition: xhci.h:858
static void xhci_ring_free(struct xhci_trb_ring *ring)
Free transfer request block ring.
Definition: xhci.c:1284
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
#define XHCI_OP_CRCR
Command ring control register.
Definition: xhci.h:179
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
const char * name
Name.
Definition: xhci.h:1073
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
unsigned long physaddr_t
Definition: stdint.h:20
#define DBGC2(...)
Definition: compiler.h:522
#define XHCI_CRCR_RCS
Command ring cycle state.
Definition: xhci.h:182
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
void * op
Operational registers.
Definition: xhci.h:1080
static int xhci_ring_alloc(struct xhci_device *xhci, struct xhci_trb_ring *ring, unsigned int shift, unsigned int slot, unsigned int target, unsigned int stream)
Allocate transfer request block ring.
Definition: xhci.c:1211
#define XHCI_CMD_TRBS_LOG2
Number of TRBs (excluding Link TRB) in the command ring.
Definition: xhci.h:966

References xhci_device::command, DBGC2, dma(), xhci_trb_ring::len, xhci_trb_ring::map, xhci_device::name, xhci_device::op, rc, xhci_trb_ring::trb, virt_to_phys(), XHCI_CMD_TRBS_LOG2, XHCI_CRCR_RCS, XHCI_OP_CRCR, xhci_ring_alloc(), xhci_ring_free(), and xhci_writeq().

Referenced by xhci_bus_open().

◆ xhci_command_free()

static void xhci_command_free ( struct xhci_device xhci)
static

Free command ring.

Parameters
xhcixHCI device

Definition at line 1481 of file xhci.c.

1481  {
1482 
1483  /* Sanity check */
1484  assert ( ( readl ( xhci->op + XHCI_OP_CRCR ) & XHCI_CRCR_CRR ) == 0 );
1485 
1486  /* Clear command ring control register */
1487  xhci_writeq ( xhci, 0, xhci->op + XHCI_OP_CRCR );
1488 
1489  /* Free TRB ring */
1490  xhci_ring_free ( &xhci->command );
1491 }
struct xhci_trb_ring command
Command ring.
Definition: xhci.h:1113
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
static void xhci_ring_free(struct xhci_trb_ring *ring)
Free transfer request block ring.
Definition: xhci.c:1284
#define XHCI_OP_CRCR
Command ring control register.
Definition: xhci.h:179
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
#define XHCI_CRCR_CRR
Command ring running.
Definition: xhci.h:188
void * op
Operational registers.
Definition: xhci.h:1080

References assert(), xhci_device::command, xhci_device::op, readl(), XHCI_CRCR_CRR, XHCI_OP_CRCR, xhci_ring_free(), and xhci_writeq().

Referenced by xhci_bus_close(), and xhci_bus_open().

◆ xhci_event_alloc()

static int xhci_event_alloc ( struct xhci_device xhci)
static

Allocate event ring.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 1499 of file xhci.c.

1499  {
1500  struct xhci_event_ring *event = &xhci->event;
1501  unsigned int count;
1502  size_t len;
1503  int rc;
1504 
1505  /* Allocate event ring */
1506  count = ( 1 << XHCI_EVENT_TRBS_LOG2 );
1507  len = ( count * sizeof ( event->trb[0] ) );
1508  event->trb = dma_alloc ( xhci->dma, &event->trb_map, len,
1509  xhci_align ( len ) );
1510  if ( ! event->trb ) {
1511  rc = -ENOMEM;
1512  goto err_alloc_trb;
1513  }
1514  memset ( event->trb, 0, len );
1515 
1516  /* Allocate event ring segment table */
1517  event->segment = dma_alloc ( xhci->dma, &event->segment_map,
1518  sizeof ( event->segment[0] ),
1519  xhci_align ( sizeof (event->segment[0])));
1520  if ( ! event->segment ) {
1521  rc = -ENOMEM;
1522  goto err_alloc_segment;
1523  }
1524  memset ( event->segment, 0, sizeof ( event->segment[0] ) );
1525  event->segment[0].base = cpu_to_le64 ( dma ( &event->trb_map,
1526  event->trb ) );
1527  event->segment[0].count = cpu_to_le32 ( count );
1528 
1529  /* Program event ring registers */
1530  writel ( 1, xhci->run + XHCI_RUN_ERSTSZ ( 0 ) );
1531  if ( ( rc = xhci_writeq ( xhci, dma ( &event->trb_map, event->trb ),
1532  xhci->run + XHCI_RUN_ERDP ( 0 ) ) ) != 0 )
1533  goto err_writeq_erdp;
1534  if ( ( rc = xhci_writeq ( xhci,
1535  dma ( &event->segment_map, event->segment ),
1536  xhci->run + XHCI_RUN_ERSTBA ( 0 ) ) ) != 0 )
1537  goto err_writeq_erstba;
1538 
1539  DBGC2 ( xhci, "XHCI %s event ring [%08lx,%08lx) table [%08lx,%08lx)\n",
1540  xhci->name, virt_to_phys ( event->trb ),
1541  ( virt_to_phys ( event->trb ) + len ),
1542  virt_to_phys ( event->segment ),
1543  ( virt_to_phys ( event->segment ) +
1544  sizeof ( event->segment[0] ) ) );
1545  return 0;
1546 
1547  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERSTBA ( 0 ) );
1548  err_writeq_erstba:
1549  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERDP ( 0 ) );
1550  err_writeq_erdp:
1551  dma_free ( &event->segment_map, event->segment,
1552  sizeof ( event->segment[0] ) );
1553  err_alloc_segment:
1554  dma_free ( &event->trb_map, event->trb, len );
1555  err_alloc_trb:
1556  return rc;
1557 }
An event ring.
Definition: xhci.h:869
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
void * run
Runtime registers.
Definition: xhci.h:1082
static size_t xhci_align(size_t len)
Calculate buffer alignment.
Definition: xhci.c:393
#define cpu_to_le64(value)
Definition: byteswap.h:108
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
#define ENOMEM
Not enough space.
Definition: errno.h:534
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
#define cpu_to_le32(value)
Definition: byteswap.h:107
const char * name
Name.
Definition: xhci.h:1073
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
#define XHCI_RUN_ERSTBA(intr)
Event ring segment table base address register.
Definition: xhci.h:299
void * dma_alloc(struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
Allocate and map DMA-coherent buffer.
uint32_t len
Length.
Definition: ena.h:14
#define DBGC2(...)
Definition: compiler.h:522
uint16_t count
Number of entries.
Definition: ena.h:22
struct dma_device * dma
DMA device.
Definition: xhci.h:1071
#define XHCI_EVENT_TRBS_LOG2
Number of TRBs in the event ring.
Definition: xhci.h:972
#define XHCI_RUN_ERSTSZ(intr)
Event ring segment table size register.
Definition: xhci.h:296
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
struct xhci_event_ring event
Event ring.
Definition: xhci.h:1115
#define XHCI_RUN_ERDP(intr)
Event ring dequeue pointer register.
Definition: xhci.h:302
void * memset(void *dest, int character, size_t len) __nonnull

References count, cpu_to_le32, cpu_to_le64, DBGC2, dma(), xhci_device::dma, dma_alloc(), dma_free(), ENOMEM, xhci_device::event, len, memset(), xhci_device::name, rc, xhci_device::run, virt_to_phys(), writel(), xhci_align(), XHCI_EVENT_TRBS_LOG2, XHCI_RUN_ERDP, XHCI_RUN_ERSTBA, XHCI_RUN_ERSTSZ, and xhci_writeq().

Referenced by xhci_bus_open().

◆ xhci_event_free()

static void xhci_event_free ( struct xhci_device xhci)
static

Free event ring.

Parameters
xhcixHCI device

Definition at line 1564 of file xhci.c.

1564  {
1565  struct xhci_event_ring *event = &xhci->event;
1566  unsigned int count;
1567  size_t len;
1568 
1569  /* Clear event ring registers */
1570  writel ( 0, xhci->run + XHCI_RUN_ERSTSZ ( 0 ) );
1571  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERSTBA ( 0 ) );
1572  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERDP ( 0 ) );
1573 
1574  /* Free event ring segment table */
1575  dma_free ( &event->segment_map, event->segment,
1576  sizeof ( event->segment[0] ) );
1577 
1578  /* Free event ring */
1579  count = ( 1 << XHCI_EVENT_TRBS_LOG2 );
1580  len = ( count * sizeof ( event->trb[0] ) );
1581  dma_free ( &event->trb_map, event->trb, len );
1582 }
An event ring.
Definition: xhci.h:869
void * run
Runtime registers.
Definition: xhci.h:1082
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
#define XHCI_RUN_ERSTBA(intr)
Event ring segment table base address register.
Definition: xhci.h:299
uint32_t len
Length.
Definition: ena.h:14
uint16_t count
Number of entries.
Definition: ena.h:22
#define XHCI_EVENT_TRBS_LOG2
Number of TRBs in the event ring.
Definition: xhci.h:972
#define XHCI_RUN_ERSTSZ(intr)
Event ring segment table size register.
Definition: xhci.h:296
struct xhci_event_ring event
Event ring.
Definition: xhci.h:1115
#define XHCI_RUN_ERDP(intr)
Event ring dequeue pointer register.
Definition: xhci.h:302

References count, dma_free(), xhci_device::event, len, xhci_device::run, writel(), XHCI_EVENT_TRBS_LOG2, XHCI_RUN_ERDP, XHCI_RUN_ERSTBA, XHCI_RUN_ERSTSZ, and xhci_writeq().

Referenced by xhci_bus_close(), and xhci_bus_open().

◆ xhci_transfer()

static void xhci_transfer ( struct xhci_device xhci,
struct xhci_trb_transfer trb 
)
static

Handle transfer event.

Parameters
xhcixHCI device
trbTransfer event TRB

Definition at line 1590 of file xhci.c.

1591  {
1592  struct xhci_slot *slot;
1593  struct xhci_endpoint *endpoint;
1594  struct io_buffer *iobuf;
1595  int rc;
1596 
1597  /* Profile transfer events */
1598  profile_start ( &xhci_transfer_profiler );
1599 
1600  /* Identify slot */
1601  if ( ( trb->slot > xhci->slots ) ||
1602  ( ( slot = xhci->slot[trb->slot] ) == NULL ) ) {
1603  DBGC ( xhci, "XHCI %s transfer event invalid slot %d:\n",
1604  xhci->name, trb->slot );
1605  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1606  return;
1607  }
1608 
1609  /* Identify endpoint */
1610  if ( ( trb->endpoint >= XHCI_CTX_END ) ||
1611  ( ( endpoint = slot->endpoint[trb->endpoint] ) == NULL ) ) {
1612  DBGC ( xhci, "XHCI %s slot %d transfer event invalid epid "
1613  "%d:\n", xhci->name, slot->id, trb->endpoint );
1614  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1615  return;
1616  }
1617 
1618  /* Dequeue TRB(s) */
1619  iobuf = xhci_dequeue_multi ( &endpoint->ring );
1620  assert ( iobuf != NULL );
1621 
1622  /* Unmap I/O buffer */
1623  iob_unmap ( iobuf );
1624 
1625  /* Check for errors */
1626  if ( ! ( ( trb->code == XHCI_CMPLT_SUCCESS ) ||
1627  ( trb->code == XHCI_CMPLT_SHORT ) ) ) {
1628 
1629  /* Construct error */
1630  rc = -ECODE ( trb->code );
1631  DBGC ( xhci, "XHCI %s slot %d ctx %d failed (code %d): %s\n",
1632  xhci->name, slot->id, endpoint->ctx, trb->code,
1633  strerror ( rc ) );
1634  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1635 
1636  /* Sanity check */
1637  assert ( ( endpoint->context->state & XHCI_ENDPOINT_STATE_MASK )
1638  != XHCI_ENDPOINT_RUNNING );
1639 
1640  /* Report failure to USB core */
1641  usb_complete_err ( endpoint->ep, iobuf, rc );
1642  return;
1643  }
1644 
1645  /* Record actual transfer size */
1646  iob_unput ( iobuf, le16_to_cpu ( trb->residual ) );
1647 
1648  /* Sanity check (for successful completions only) */
1649  assert ( xhci_ring_consumed ( &endpoint->ring ) ==
1650  le64_to_cpu ( trb->transfer ) );
1651 
1652  /* Report completion to USB core */
1653  usb_complete ( endpoint->ep, iobuf );
1654  profile_stop ( &xhci_transfer_profiler );
1655 }
Short packet.
Definition: xhci.h:637
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
static physaddr_t xhci_ring_consumed(struct xhci_trb_ring *ring)
Calculate physical address of most recently consumed TRB.
Definition: xhci.h:936
#define XHCI_CTX_END
End of contexts.
Definition: xhci.h:954
uint8_t state
Endpoint state.
Definition: xhci.h:771
#define DBGC(...)
Definition: compiler.h:505
uint8_t code
Completion code.
Definition: xhci.h:597
An xHCI endpoint.
Definition: xhci.h:1160
Success.
Definition: xhci.h:635
static void profile_stop(struct profiler *profiler)
Stop profiling.
Definition: profile.h:171
uint8_t endpoint
Endpoint ID.
Definition: xhci.h:603
unsigned int slots
Number of device slots.
Definition: xhci.h:1087
#define ECODE(code)
Definition: xhci.c:233
uint8_t slot
Slot ID.
Definition: xhci.h:605
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
unsigned int ctx
Context index.
Definition: xhci.h:1168
#define DBGC_HDA(...)
Definition: compiler.h:506
static __always_inline void iob_unmap(struct io_buffer *iobuf)
Unmap I/O buffer for DMA.
Definition: iobuf.h:275
static void profile_start(struct profiler *profiler)
Start profiling.
Definition: profile.h:158
struct xhci_endpoint_context * context
Endpoint context.
Definition: xhci.h:1174
An xHCI device slot.
Definition: xhci.h:1132
#define iob_unput(iobuf, len)
Definition: iobuf.h:135
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
#define le16_to_cpu(value)
Definition: byteswap.h:112
Endpoint is running.
Definition: xhci.h:799
static struct io_buffer * xhci_dequeue_multi(struct xhci_trb_ring *ring)
Dequeue multiple transfer request blocks.
Definition: xhci.c:1414
struct usb_endpoint * ep
USB endpoint.
Definition: xhci.h:1166
static void usb_complete(struct usb_endpoint *ep, struct io_buffer *iobuf)
Complete transfer (without error)
Definition: usb.h:1066
struct xhci_trb_ring ring
Transfer ring.
Definition: xhci.h:1176
uint16_t residual
Residual transfer length.
Definition: xhci.h:593
uint64_t transfer
Transfer TRB pointer.
Definition: xhci.h:591
#define le64_to_cpu(value)
Definition: byteswap.h:114
struct xhci_slot ** slot
Device slots, indexed by slot ID.
Definition: xhci.h:1122
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
void usb_complete_err(struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
Complete transfer (possibly with error)
Definition: usb.c:586
#define XHCI_ENDPOINT_STATE_MASK
Endpoint state mask.
Definition: xhci.h:809
A persistent I/O buffer.
Definition: iobuf.h:33

References assert(), xhci_trb_transfer::code, xhci_endpoint::context, xhci_endpoint::ctx, DBGC, DBGC_HDA, ECODE, xhci_trb_transfer::endpoint, xhci_endpoint::ep, iob_unmap(), iob_unput, le16_to_cpu, le64_to_cpu, xhci_device::name, NULL, profile_start(), profile_stop(), rc, xhci_trb_transfer::residual, xhci_endpoint::ring, slot, xhci_trb_transfer::slot, xhci_device::slot, xhci_device::slots, xhci_endpoint_context::state, strerror(), xhci_trb_transfer::transfer, usb_complete(), usb_complete_err(), XHCI_CMPLT_SHORT, XHCI_CMPLT_SUCCESS, XHCI_CTX_END, xhci_dequeue_multi(), XHCI_ENDPOINT_RUNNING, XHCI_ENDPOINT_STATE_MASK, and xhci_ring_consumed().

Referenced by xhci_event_poll().

◆ xhci_complete()

static void xhci_complete ( struct xhci_device xhci,
struct xhci_trb_complete trb 
)
static

Handle command completion event.

Parameters
xhcixHCI device
trbCommand completion event

Definition at line 1663 of file xhci.c.

1664  {
1665  int rc;
1666 
1667  /* Ignore "command ring stopped" notifications */
1668  if ( trb->code == XHCI_CMPLT_CMD_STOPPED ) {
1669  DBGC2 ( xhci, "XHCI %s command ring stopped\n", xhci->name );
1670  return;
1671  }
1672 
1673  /* Ignore unexpected completions */
1674  if ( ! xhci->pending ) {
1675  rc = -ECODE ( trb->code );
1676  DBGC ( xhci, "XHCI %s unexpected completion (code %d): %s\n",
1677  xhci->name, trb->code, strerror ( rc ) );
1678  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1679  return;
1680  }
1681 
1682  /* Dequeue command TRB */
1683  xhci_dequeue ( &xhci->command );
1684 
1685  /* Sanity check */
1686  assert ( xhci_ring_consumed ( &xhci->command ) ==
1687  le64_to_cpu ( trb->command ) );
1688 
1689  /* Record completion */
1690  memcpy ( xhci->pending, trb, sizeof ( *xhci->pending ) );
1691  xhci->pending = NULL;
1692 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
uint64_t command
Command TRB pointer.
Definition: xhci.h:614
static struct io_buffer * xhci_dequeue(struct xhci_trb_ring *ring)
Dequeue a transfer request block.
Definition: xhci.c:1353
static physaddr_t xhci_ring_consumed(struct xhci_trb_ring *ring)
Calculate physical address of most recently consumed TRB.
Definition: xhci.h:936
struct xhci_trb_ring command
Command ring.
Definition: xhci.h:1113
union xhci_trb * pending
Current command (if any)
Definition: xhci.h:1117
#define DBGC(...)
Definition: compiler.h:505
#define ECODE(code)
Definition: xhci.c:233
void * memcpy(void *dest, const void *src, size_t len) __nonnull
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define DBGC_HDA(...)
Definition: compiler.h:506
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073
Command ring stopped.
Definition: xhci.h:639
#define DBGC2(...)
Definition: compiler.h:522
uint8_t code
Completion code.
Definition: xhci.h:618
#define le64_to_cpu(value)
Definition: byteswap.h:114
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References assert(), xhci_trb_complete::code, xhci_trb_complete::command, xhci_device::command, DBGC, DBGC2, DBGC_HDA, ECODE, le64_to_cpu, memcpy(), xhci_device::name, NULL, xhci_device::pending, rc, strerror(), XHCI_CMPLT_CMD_STOPPED, xhci_dequeue(), and xhci_ring_consumed().

Referenced by xhci_event_poll().

◆ xhci_port_status()

static void xhci_port_status ( struct xhci_device xhci,
struct xhci_trb_port_status trb 
)
static

Handle port status event.

Parameters
xhcixHCI device
trbPort status event

Definition at line 1700 of file xhci.c.

1701  {
1702  struct usb_port *port = usb_port ( xhci->bus->hub, trb->port );
1703  uint32_t portsc;
1704 
1705  /* Sanity check */
1706  assert ( ( trb->port > 0 ) && ( trb->port <= xhci->ports ) );
1707 
1708  /* Record disconnections and clear changes */
1709  portsc = readl ( xhci->op + XHCI_OP_PORTSC ( trb->port ) );
1710  port->disconnected |= ( portsc & XHCI_PORTSC_CSC );
1711  portsc &= ( XHCI_PORTSC_PRESERVE | XHCI_PORTSC_CHANGE );
1712  writel ( portsc, xhci->op + XHCI_OP_PORTSC ( trb->port ) );
1713 
1714  /* Report port status change */
1715  usb_port_changed ( port );
1716 }
unsigned int ports
Number of ports.
Definition: xhci.h:1091
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
struct usb_bus * bus
USB bus.
Definition: xhci.h:1125
#define XHCI_PORTSC_CSC
Connect status change.
Definition: xhci.h:249
#define XHCI_PORTSC_PRESERVE
Port status and control bits which should be preserved.
Definition: xhci.h:284
void usb_port_changed(struct usb_port *port)
Report port status change.
Definition: usb.c:1839
A USB port.
Definition: usb.h:798
u8 port
Port number.
Definition: CIB_PRM.h:31
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define XHCI_PORTSC_CHANGE
Port status change mask.
Definition: xhci.h:270
void writel(uint32_t data, volatile uint32_t *io_addr)
Write 32-bit dword to memory-mapped device.
unsigned int uint32_t
Definition: stdint.h:12
uint8_t port
Port ID.
Definition: xhci.h:647
#define XHCI_OP_PORTSC(port)
Port status and control register.
Definition: xhci.h:204
struct usb_hub * hub
Root hub.
Definition: usb.h:974
static struct usb_port * usb_port(struct usb_hub *hub, unsigned int address)
Get USB port.
Definition: usb.h:945
void * op
Operational registers.
Definition: xhci.h:1080

References assert(), xhci_device::bus, usb_bus::hub, xhci_device::op, port, xhci_trb_port_status::port, xhci_device::ports, readl(), usb_port(), usb_port_changed(), writel(), XHCI_OP_PORTSC, XHCI_PORTSC_CHANGE, XHCI_PORTSC_CSC, and XHCI_PORTSC_PRESERVE.

Referenced by xhci_event_poll().

◆ xhci_host_controller()

static void xhci_host_controller ( struct xhci_device xhci,
struct xhci_trb_host_controller trb 
)
static

Handle host controller event.

Parameters
xhcixHCI device
trbHost controller event

Definition at line 1724 of file xhci.c.

1725  {
1726  int rc;
1727 
1728  /* Construct error */
1729  rc = -ECODE ( trb->code );
1730  DBGC ( xhci, "XHCI %s host controller event (code %d): %s\n",
1731  xhci->name, trb->code, strerror ( rc ) );
1732 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define DBGC(...)
Definition: compiler.h:505
uint8_t code
Completion code.
Definition: xhci.h:670
#define ECODE(code)
Definition: xhci.c:233
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073

References xhci_trb_host_controller::code, DBGC, ECODE, xhci_device::name, rc, and strerror().

Referenced by xhci_event_poll().

◆ xhci_event_poll()

static void xhci_event_poll ( struct xhci_device xhci)
static

Poll event ring.

Parameters
xhcixHCI device

Definition at line 1739 of file xhci.c.

1739  {
1740  struct xhci_event_ring *event = &xhci->event;
1741  union xhci_trb *trb;
1742  unsigned int shift = XHCI_EVENT_TRBS_LOG2;
1743  unsigned int count = ( 1 << shift );
1744  unsigned int mask = ( count - 1 );
1745  unsigned int consumed;
1746  unsigned int type;
1747 
1748  /* Do nothing if device has permanently failed */
1749  if ( xhci->failed )
1750  return;
1751 
1752  /* Poll for events */
1753  profile_start ( &xhci_event_profiler );
1754  for ( consumed = 0 ; ; consumed++ ) {
1755 
1756  /* Stop if we reach an empty TRB */
1757  rmb();
1758  trb = &event->trb[ event->cons & mask ];
1759  if ( ! ( ( trb->common.flags ^
1760  ( event->cons >> shift ) ) & XHCI_TRB_C ) )
1761  break;
1762 
1763  /* Consume this TRB */
1764  event->cons++;
1765 
1766  /* Handle TRB */
1767  type = ( trb->common.type & XHCI_TRB_TYPE_MASK );
1768  switch ( type ) {
1769 
1770  case XHCI_TRB_TRANSFER :
1771  xhci_transfer ( xhci, &trb->transfer );
1772  break;
1773 
1774  case XHCI_TRB_COMPLETE :
1775  xhci_complete ( xhci, &trb->complete );
1776  break;
1777 
1778  case XHCI_TRB_PORT_STATUS:
1779  xhci_port_status ( xhci, &trb->port );
1780  break;
1781 
1783  xhci_host_controller ( xhci, &trb->host );
1784  break;
1785 
1786  default:
1787  DBGC ( xhci, "XHCI %s unrecognised event %#x\n:",
1788  xhci->name, ( event->cons - 1 ) );
1789  DBGC_HDA ( xhci, virt_to_phys ( trb ),
1790  trb, sizeof ( *trb ) );
1791  break;
1792  }
1793  }
1794 
1795  /* Update dequeue pointer if applicable */
1796  if ( consumed ) {
1797  xhci_writeq ( xhci, dma ( &event->trb_map, trb ),
1798  xhci->run + XHCI_RUN_ERDP ( 0 ) );
1799  profile_stop ( &xhci_event_profiler );
1800  }
1801 }
An event ring.
Definition: xhci.h:869
struct xhci_trb_common common
Common fields.
Definition: xhci.h:687
void * run
Runtime registers.
Definition: xhci.h:1082
uint32_t type
Operating system type.
Definition: ena.h:12
struct xhci_trb_transfer transfer
Transfer event.
Definition: xhci.h:711
#define DBGC(...)
Definition: compiler.h:505
uint8_t type
Type.
Definition: xhci.h:323
uint8_t flags
Flags.
Definition: xhci.h:321
#define XHCI_TRB_PORT_STATUS
A port status change transfer request block.
Definition: xhci.h:661
static void profile_stop(struct profiler *profiler)
Stop profiling.
Definition: profile.h:171
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
static void xhci_transfer(struct xhci_device *xhci, struct xhci_trb_transfer *trb)
Handle transfer event.
Definition: xhci.c:1590
struct xhci_trb_host_controller host
Host controller event.
Definition: xhci.h:717
#define rmb()
Definition: io.h:484
#define XHCI_TRB_COMPLETE
A command completion event transfer request block.
Definition: xhci.h:630
#define DBGC_HDA(...)
Definition: compiler.h:506
#define XHCI_TRB_TRANSFER
A transfer event transfer request block.
Definition: xhci.h:609
static void profile_start(struct profiler *profiler)
Start profiling.
Definition: profile.h:158
#define XHCI_TRB_HOST_CONTROLLER
A port status change transfer request block.
Definition: xhci.h:680
int failed
Command mechanism has permanently failed.
Definition: xhci.h:1119
A transfer request block.
Definition: xhci.h:683
const char * name
Name.
Definition: xhci.h:1073
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
struct xhci_trb_complete complete
Command completion event.
Definition: xhci.h:713
#define XHCI_TRB_TYPE_MASK
Transfer request block type mask.
Definition: xhci.h:347
static void xhci_host_controller(struct xhci_device *xhci, struct xhci_trb_host_controller *trb)
Handle host controller event.
Definition: xhci.c:1724
uint16_t count
Number of entries.
Definition: ena.h:22
static void xhci_complete(struct xhci_device *xhci, struct xhci_trb_complete *trb)
Handle command completion event.
Definition: xhci.c:1663
struct xhci_trb_port_status port
Port status changed event.
Definition: xhci.h:715
#define XHCI_EVENT_TRBS_LOG2
Number of TRBs in the event ring.
Definition: xhci.h:972
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
#define XHCI_TRB_C
Transfer request block cycle bit flag.
Definition: xhci.h:329
struct xhci_event_ring event
Event ring.
Definition: xhci.h:1115
#define XHCI_RUN_ERDP(intr)
Event ring dequeue pointer register.
Definition: xhci.h:302
static void xhci_port_status(struct xhci_device *xhci, struct xhci_trb_port_status *trb)
Handle port status event.
Definition: xhci.c:1700

References xhci_trb::common, xhci_trb::complete, count, DBGC, DBGC_HDA, dma(), xhci_device::event, xhci_device::failed, xhci_trb_common::flags, xhci_trb::host, xhci_device::name, xhci_trb::port, profile_start(), profile_stop(), rmb, xhci_device::run, xhci_trb::transfer, type, xhci_trb_common::type, virt_to_phys(), xhci_complete(), XHCI_EVENT_TRBS_LOG2, xhci_host_controller(), xhci_port_status(), XHCI_RUN_ERDP, xhci_transfer(), XHCI_TRB_C, XHCI_TRB_COMPLETE, XHCI_TRB_HOST_CONTROLLER, XHCI_TRB_PORT_STATUS, XHCI_TRB_TRANSFER, XHCI_TRB_TYPE_MASK, and xhci_writeq().

Referenced by xhci_abort(), xhci_bus_poll(), and xhci_command().

◆ xhci_abort()

static void xhci_abort ( struct xhci_device xhci)
static

Abort command.

Parameters
xhcixHCI device

Definition at line 1808 of file xhci.c.

1808  {
1809  physaddr_t crp;
1810  uint32_t crcr;
1811 
1812  /* Abort the command */
1813  DBGC2 ( xhci, "XHCI %s aborting command\n", xhci->name );
1814  xhci_writeq ( xhci, XHCI_CRCR_CA, xhci->op + XHCI_OP_CRCR );
1815 
1816  /* Allow time for command to abort */
1818 
1819  /* Check for failure to abort */
1820  crcr = readl ( xhci->op + XHCI_OP_CRCR );
1821  if ( crcr & XHCI_CRCR_CRR ) {
1822 
1823  /* Device has failed to abort a command and is almost
1824  * certainly beyond repair. Reset device, abandoning
1825  * all state, and mark device as failed to avoid
1826  * delays on any future command attempts.
1827  */
1828  DBGC ( xhci, "XHCI %s failed to abort command\n", xhci->name );
1829  xhci_fail ( xhci );
1830  }
1831 
1832  /* Consume (and ignore) any final command status */
1833  xhci_event_poll ( xhci );
1834 
1835  /* Reset the command ring control register */
1836  xhci_ring_reset ( &xhci->command );
1837  crp = dma ( &xhci->command.map, xhci->command.trb );
1838  xhci_writeq ( xhci, ( crp | XHCI_CRCR_RCS ), xhci->op + XHCI_OP_CRCR );
1839 }
struct xhci_trb_ring command
Command ring.
Definition: xhci.h:1113
uint32_t readl(volatile uint32_t *io_addr)
Read 32-bit dword from memory-mapped device.
#define DBGC(...)
Definition: compiler.h:505
struct dma_mapping map
DMA mapping.
Definition: xhci.h:858
#define XHCI_COMMAND_ABORT_DELAY_MS
Time to delay after aborting a command.
Definition: xhci.h:1010
static void xhci_ring_reset(struct xhci_trb_ring *ring)
Reset transfer request block ring.
Definition: xhci.c:1268
#define XHCI_OP_CRCR
Command ring control register.
Definition: xhci.h:179
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
static int xhci_fail(struct xhci_device *xhci)
Mark xHCI device as permanently failed.
Definition: xhci.c:1174
const char * name
Name.
Definition: xhci.h:1073
static int xhci_writeq(struct xhci_device *xhci, physaddr_t value, void *reg)
Write potentially 64-bit register.
Definition: xhci.c:359
unsigned int uint32_t
Definition: stdint.h:12
unsigned long physaddr_t
Definition: stdint.h:20
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
#define DBGC2(...)
Definition: compiler.h:522
static void xhci_event_poll(struct xhci_device *xhci)
Poll event ring.
Definition: xhci.c:1739
#define XHCI_CRCR_RCS
Command ring cycle state.
Definition: xhci.h:182
#define XHCI_CRCR_CA
Command abort.
Definition: xhci.h:185
#define XHCI_CRCR_CRR
Command ring running.
Definition: xhci.h:188
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
void * op
Operational registers.
Definition: xhci.h:1080

References xhci_device::command, DBGC, DBGC2, dma(), xhci_trb_ring::map, mdelay(), xhci_device::name, xhci_device::op, readl(), xhci_trb_ring::trb, XHCI_COMMAND_ABORT_DELAY_MS, XHCI_CRCR_CA, XHCI_CRCR_CRR, XHCI_CRCR_RCS, xhci_event_poll(), xhci_fail(), XHCI_OP_CRCR, xhci_ring_reset(), and xhci_writeq().

Referenced by xhci_command().

◆ xhci_command()

static int xhci_command ( struct xhci_device xhci,
union xhci_trb trb 
)
static

Issue command and wait for completion.

Parameters
xhcixHCI device
trbTransfer request block (with empty Cycle flag)
Return values
rcReturn status code

On a successful completion, the TRB will be overwritten with the completion.

Definition at line 1851 of file xhci.c.

1851  {
1852  struct xhci_trb_complete *complete = &trb->complete;
1853  unsigned int i;
1854  int rc;
1855 
1856  /* Immediately fail all commands if command mechanism has failed */
1857  if ( xhci->failed ) {
1858  rc = -EPIPE;
1859  goto err_failed;
1860  }
1861 
1862  /* Sanity check */
1863  if ( xhci->pending ) {
1864  DBGC ( xhci, "XHCI %s command ring busy\n", xhci->name );
1865  rc = -EBUSY;
1866  goto err_pending;
1867  }
1868 
1869  /* Record the pending command */
1870  xhci->pending = trb;
1871 
1872  /* Enqueue the command */
1873  if ( ( rc = xhci_enqueue ( &xhci->command, NULL, trb ) ) != 0 )
1874  goto err_enqueue;
1875 
1876  /* Ring the command doorbell */
1877  xhci_doorbell ( &xhci->command );
1878 
1879  /* Wait for the command to complete */
1880  for ( i = 0 ; i < XHCI_COMMAND_MAX_WAIT_MS ; i++ ) {
1881 
1882  /* Poll event ring */
1883  xhci_event_poll ( xhci );
1884 
1885  /* Check for completion */
1886  if ( ! xhci->pending ) {
1887  if ( complete->code != XHCI_CMPLT_SUCCESS ) {
1888  rc = -ECODE ( complete->code );
1889  DBGC ( xhci, "XHCI %s command failed (code "
1890  "%d): %s\n", xhci->name, complete->code,
1891  strerror ( rc ) );
1892  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1893  return rc;
1894  }
1895  return 0;
1896  }
1897 
1898  /* Delay */
1899  mdelay ( 1 );
1900  }
1901 
1902  /* Timeout */
1903  DBGC ( xhci, "XHCI %s timed out waiting for completion\n", xhci->name );
1904  rc = -ETIMEDOUT;
1905 
1906  /* Abort command */
1907  xhci_abort ( xhci );
1908 
1909  err_enqueue:
1910  xhci->pending = NULL;
1911  err_pending:
1912  err_failed:
1913  return rc;
1914 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define EBUSY
Device or resource busy.
Definition: errno.h:338
struct xhci_trb_ring command
Command ring.
Definition: xhci.h:1113
A command completion event transfer request block.
Definition: xhci.h:612
#define EPIPE
Broken pipe.
Definition: errno.h:619
union xhci_trb * pending
Current command (if any)
Definition: xhci.h:1117
#define DBGC(...)
Definition: compiler.h:505
Success.
Definition: xhci.h:635
#define ECODE(code)
Definition: xhci.c:233
#define XHCI_COMMAND_MAX_WAIT_MS
Maximum time to wait for a command to complete.
Definition: xhci.h:1004
#define DBGC_HDA(...)
Definition: compiler.h:506
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
int failed
Command mechanism has permanently failed.
Definition: xhci.h:1119
const char * name
Name.
Definition: xhci.h:1073
struct xhci_trb_complete complete
Command completion event.
Definition: xhci.h:713
static void xhci_abort(struct xhci_device *xhci)
Abort command.
Definition: xhci.c:1808
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
static void xhci_event_poll(struct xhci_device *xhci)
Poll event ring.
Definition: xhci.c:1739
static int xhci_enqueue(struct xhci_trb_ring *ring, struct io_buffer *iobuf, const union xhci_trb *trb)
Enqueue a transfer request block.
Definition: xhci.c:1310
static void xhci_doorbell(struct xhci_trb_ring *ring)
Ring doorbell register.
Definition: xhci.c:1431
uint8_t code
Completion code.
Definition: xhci.h:618
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
#define ETIMEDOUT
Connection timed out.
Definition: errno.h:669

References xhci_trb_complete::code, xhci_device::command, xhci_trb::complete, DBGC, DBGC_HDA, EBUSY, ECODE, EPIPE, ETIMEDOUT, xhci_device::failed, mdelay(), xhci_device::name, NULL, xhci_device::pending, rc, strerror(), xhci_abort(), XHCI_CMPLT_SUCCESS, XHCI_COMMAND_MAX_WAIT_MS, xhci_doorbell(), xhci_enqueue(), and xhci_event_poll().

Referenced by xhci_context(), xhci_disable_slot(), xhci_enable_slot(), xhci_nop(), xhci_reset_endpoint(), xhci_set_tr_dequeue_pointer(), and xhci_stop_endpoint().

◆ xhci_nop()

static int xhci_nop ( struct xhci_device xhci)
inlinestatic

Issue NOP and wait for completion.

Parameters
xhcixHCI device
Return values
rcReturn status code

Definition at line 1922 of file xhci.c.

1922  {
1923  union xhci_trb trb;
1924  struct xhci_trb_common *nop = &trb.common;
1925  int rc;
1926 
1927  /* Construct command */
1928  memset ( nop, 0, sizeof ( *nop ) );
1929  nop->flags = XHCI_TRB_IOC;
1930  nop->type = XHCI_TRB_NOP_CMD;
1931 
1932  /* Issue command and wait for completion */
1933  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
1934  DBGC ( xhci, "XHCI %s NOP failed: %s\n",
1935  xhci->name, strerror ( rc ) );
1936  return rc;
1937  }
1938 
1939  DBGC2 ( xhci, "XHCI %s NOP completed successfully\n", xhci->name );
1940  return 0;
1941 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
A transfer request block.
Definition: xhci.h:315
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_TRB_NOP_CMD
A no-op command transfer request block.
Definition: xhci.h:586
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
A transfer request block.
Definition: xhci.h:683
const char * name
Name.
Definition: xhci.h:1073
uint8_t nop
Definition: tcp.h:13
#define DBGC2(...)
Definition: compiler.h:522
static int xhci_command(struct xhci_device *xhci, union xhci_trb *trb)
Issue command and wait for completion.
Definition: xhci.c:1851
#define XHCI_TRB_IOC
Transfer request block interrupt on completion flag.
Definition: xhci.h:338
void * memset(void *dest, int character, size_t len) __nonnull

References xhci_trb::common, DBGC, DBGC2, memset(), xhci_device::name, nop, rc, strerror(), xhci_command(), XHCI_TRB_IOC, and XHCI_TRB_NOP_CMD.

◆ xhci_enable_slot()

static int xhci_enable_slot ( struct xhci_device xhci,
unsigned int  type 
)
inlinestatic

Enable slot.

Parameters
xhcixHCI device
typeSlot type
Return values
slotDevice slot ID, or negative error

Definition at line 1950 of file xhci.c.

1951  {
1952  union xhci_trb trb;
1953  struct xhci_trb_enable_slot *enable = &trb.enable;
1954  struct xhci_trb_complete *enabled = &trb.complete;
1955  unsigned int slot;
1956  int rc;
1957 
1958  /* Construct command */
1959  memset ( enable, 0, sizeof ( *enable ) );
1960  enable->slot = type;
1961  enable->type = XHCI_TRB_ENABLE_SLOT;
1962 
1963  /* Issue command and wait for completion */
1964  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
1965  DBGC ( xhci, "XHCI %s could not enable new slot: %s\n",
1966  xhci->name, strerror ( rc ) );
1967  return rc;
1968  }
1969 
1970  /* Extract slot number */
1971  slot = enabled->slot;
1972 
1973  DBGC2 ( xhci, "XHCI %s slot %d enabled\n", xhci->name, slot );
1974  return slot;
1975 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define XHCI_TRB_ENABLE_SLOT
An enable slot transfer request block.
Definition: xhci.h:482
uint8_t slot
Slot type.
Definition: xhci.h:476
A command completion event transfer request block.
Definition: xhci.h:612
uint32_t type
Operating system type.
Definition: ena.h:12
#define DBGC(...)
Definition: compiler.h:505
An enable slot transfer request block.
Definition: xhci.h:466
uint8_t slot
Slot ID.
Definition: xhci.h:626
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
A transfer request block.
Definition: xhci.h:683
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
#define DBGC2(...)
Definition: compiler.h:522
static int xhci_command(struct xhci_device *xhci, union xhci_trb *trb)
Issue command and wait for completion.
Definition: xhci.c:1851
uint8_t type
Type.
Definition: xhci.h:474
void * memset(void *dest, int character, size_t len) __nonnull

References xhci_trb::complete, DBGC, DBGC2, xhci_trb::enable, memset(), xhci_device::name, rc, slot, xhci_trb_enable_slot::slot, xhci_trb_complete::slot, strerror(), type, xhci_trb_enable_slot::type, xhci_command(), and XHCI_TRB_ENABLE_SLOT.

Referenced by xhci_device_open().

◆ xhci_disable_slot()

static int xhci_disable_slot ( struct xhci_device xhci,
unsigned int  slot 
)
inlinestatic

Disable slot.

Parameters
xhcixHCI device
slotDevice slot
Return values
rcReturn status code

Definition at line 1984 of file xhci.c.

1985  {
1986  union xhci_trb trb;
1987  struct xhci_trb_disable_slot *disable = &trb.disable;
1988  int rc;
1989 
1990  /* Construct command */
1991  memset ( disable, 0, sizeof ( *disable ) );
1992  disable->type = XHCI_TRB_DISABLE_SLOT;
1993  disable->slot = slot;
1994 
1995  /* Issue command and wait for completion */
1996  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
1997  DBGC ( xhci, "XHCI %s could not disable slot %d: %s\n",
1998  xhci->name, slot, strerror ( rc ) );
1999  return rc;
2000  }
2001 
2002  DBGC2 ( xhci, "XHCI %s slot %d disabled\n", xhci->name, slot );
2003  return 0;
2004 }
A disable slot transfer request block.
Definition: xhci.h:485
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define XHCI_TRB_DISABLE_SLOT
A disable slot transfer request block.
Definition: xhci.h:501
#define DBGC(...)
Definition: compiler.h:505
uint8_t slot
Slot ID.
Definition: xhci.h:497
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
A transfer request block.
Definition: xhci.h:683
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
uint8_t type
Type.
Definition: xhci.h:493
#define DBGC2(...)
Definition: compiler.h:522
static int xhci_command(struct xhci_device *xhci, union xhci_trb *trb)
Issue command and wait for completion.
Definition: xhci.c:1851
void * memset(void *dest, int character, size_t len) __nonnull

References DBGC, DBGC2, xhci_trb::disable, memset(), xhci_device::name, rc, slot, xhci_trb_disable_slot::slot, strerror(), xhci_trb_disable_slot::type, xhci_command(), and XHCI_TRB_DISABLE_SLOT.

Referenced by xhci_device_close(), and xhci_device_open().

◆ xhci_context()

static int xhci_context ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint,
unsigned int  type,
void(*)(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input populate 
)
static

Issue context-based command and wait for completion.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
typeTRB type
populateInput context populater
Return values
rcReturn status code

Definition at line 2016 of file xhci.c.

2021  {
2022  union xhci_trb trb;
2023  struct xhci_trb_context *context = &trb.context;
2024  struct dma_mapping map;
2025  size_t len;
2026  void *input;
2027  int rc;
2028 
2029  /* Allocate an input context */
2030  memset ( &map, 0, sizeof ( map ) );
2032  input = dma_alloc ( xhci->dma, &map, len, xhci_align ( len ) );
2033  if ( ! input ) {
2034  rc = -ENOMEM;
2035  goto err_alloc;
2036  }
2037  memset ( input, 0, len );
2038 
2039  /* Populate input context */
2040  populate ( xhci, slot, endpoint, input );
2041 
2042  /* Construct command */
2043  memset ( context, 0, sizeof ( *context ) );
2044  context->type = type;
2045  context->input = cpu_to_le64 ( dma ( &map, input ) );
2046  context->slot = slot->id;
2047 
2048  /* Issue command and wait for completion */
2049  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 )
2050  goto err_command;
2051 
2052  err_command:
2053  dma_free ( &map, input, len );
2054  err_alloc:
2055  return rc;
2056 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define XHCI_CTX_END
End of contexts.
Definition: xhci.h:954
static size_t xhci_align(size_t len)
Calculate buffer alignment.
Definition: xhci.c:393
uint32_t type
Operating system type.
Definition: ena.h:12
Definition: bnxt_hsi.h:68
#define cpu_to_le64(value)
Definition: byteswap.h:108
uint64_t input
Input context.
Definition: xhci.h:506
#define ENOMEM
Not enough space.
Definition: errno.h:534
void dma_free(struct dma_mapping *map, void *addr, size_t len)
Unmap and free DMA-coherent buffer.
A context transfer request block.
Definition: xhci.h:504
A transfer request block.
Definition: xhci.h:683
uint8_t slot
Slot.
Definition: edd.h:16
static __always_inline int struct dma_mapping * map
Definition: dma.h:181
void * dma_alloc(struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
Allocate and map DMA-coherent buffer.
uint32_t len
Length.
Definition: ena.h:14
static size_t xhci_input_context_offset(struct xhci_device *xhci, unsigned int ctx)
Calculate input context offset.
Definition: xhci.c:424
struct dma_device * dma
DMA device.
Definition: xhci.h:1071
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
A DMA mapping.
Definition: dma.h:32
static int xhci_command(struct xhci_device *xhci, union xhci_trb *trb)
Issue command and wait for completion.
Definition: xhci.c:1851
uint8_t type
Type.
Definition: xhci.h:512
uint8_t slot
Slot ID.
Definition: xhci.h:516
void * memset(void *dest, int character, size_t len) __nonnull

References xhci_trb::context, cpu_to_le64, dma(), xhci_device::dma, dma_alloc(), dma_free(), ENOMEM, xhci_trb_context::input, len, map, memset(), rc, slot, xhci_trb_context::slot, type, xhci_trb_context::type, xhci_align(), xhci_command(), XHCI_CTX_END, and xhci_input_context_offset().

Referenced by xhci_address_device(), xhci_configure_endpoint(), xhci_deconfigure_endpoint(), and xhci_evaluate_context().

◆ xhci_address_device_input()

static void xhci_address_device_input ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint,
void *  input 
)
static

Populate address device input context.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
inputInput context

Definition at line 2066 of file xhci.c.

2069  {
2070  struct xhci_trb_ring *ring = &endpoint->ring;
2071  struct xhci_control_context *control_ctx;
2072  struct xhci_slot_context *slot_ctx;
2073  struct xhci_endpoint_context *ep_ctx;
2074 
2075  /* Sanity checks */
2076  assert ( endpoint->ctx == XHCI_CTX_EP0 );
2077 
2078  /* Populate control context */
2079  control_ctx = input;
2080  control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
2081  ( 1 << XHCI_CTX_EP0 ) );
2082 
2083  /* Populate slot context */
2084  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2085  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( 1, 0, slot->psiv,
2086  slot->route ) );
2087  slot_ctx->port = slot->port;
2088  slot_ctx->tt_id = slot->tt_id;
2089  slot_ctx->tt_port = slot->tt_port;
2090 
2091  /* Populate control endpoint context */
2092  ep_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_EP0 ) );
2093  ep_ctx->type = XHCI_EP_TYPE_CONTROL;
2094  ep_ctx->burst = endpoint->ep->burst;
2095  ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
2096  ep_ctx->dequeue = cpu_to_le64 ( dma ( &ring->map, ring->trb ) |
2097  XHCI_EP_DCS );
2098  ep_ctx->trb_len = cpu_to_le16 ( XHCI_EP0_TRB_LEN );
2099 }
An endpoint context.
Definition: xhci.h:769
uint8_t burst
Maximum burst size.
Definition: xhci.h:781
uint8_t type
Endpoint type.
Definition: xhci.h:779
An input control context.
Definition: xhci.h:721
uint16_t trb_len
Average TRB length.
Definition: xhci.h:787
struct dma_mapping map
DMA mapping.
Definition: xhci.h:858
#define XHCI_EP_TYPE_CONTROL
Control endpoint type.
Definition: xhci.h:815
Definition: bnxt_hsi.h:68
#define cpu_to_le64(value)
Definition: byteswap.h:108
uint32_t add
Add context flags.
Definition: xhci.h:725
uint64_t dequeue
Transfer ring dequeue pointer.
Definition: xhci.h:785
#define XHCI_EP_DCS
Endpoint dequeue cycle state.
Definition: xhci.h:824
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
unsigned int ctx
Context index.
Definition: xhci.h:1168
uint8_t port
Root hub port number.
Definition: xhci.h:745
#define XHCI_SLOT_INFO(entries, hub, speed, route)
Construct slot context device info.
Definition: xhci.h:765
uint16_t mtu
Maximum packet size.
Definition: xhci.h:783
unsigned int burst
Maximum burst size.
Definition: usb.h:399
uint32_t info
Device info.
Definition: xhci.h:741
#define cpu_to_le32(value)
Definition: byteswap.h:107
uint8_t slot
Slot.
Definition: edd.h:16
#define XHCI_EP0_TRB_LEN
Control endpoint average TRB length.
Definition: xhci.h:827
size_t mtu
Maximum transfer size.
Definition: usb.h:397
uint8_t tt_id
TT hub slot ID.
Definition: xhci.h:749
struct usb_endpoint * ep
USB endpoint.
Definition: xhci.h:1166
uint8_t tt_port
TT port number.
Definition: xhci.h:751
struct xhci_trb_ring ring
Transfer ring.
Definition: xhci.h:1176
static size_t xhci_input_context_offset(struct xhci_device *xhci, unsigned int ctx)
Calculate input context offset.
Definition: xhci.c:424
#define cpu_to_le16(value)
Definition: byteswap.h:106
A transfer request block command/transfer ring.
Definition: xhci.h:840
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
#define XHCI_CTX_EP0
Endpoint zero context index.
Definition: xhci.h:951
A slot context.
Definition: xhci.h:739
#define XHCI_CTX_SLOT
Slot context index.
Definition: xhci.h:943

References xhci_control_context::add, assert(), usb_endpoint::burst, xhci_endpoint_context::burst, cpu_to_le16, cpu_to_le32, cpu_to_le64, xhci_endpoint::ctx, xhci_endpoint_context::dequeue, dma(), xhci_endpoint::ep, xhci_slot_context::info, xhci_trb_ring::map, usb_endpoint::mtu, xhci_endpoint_context::mtu, xhci_slot_context::port, xhci_endpoint::ring, slot, xhci_trb_ring::trb, xhci_endpoint_context::trb_len, xhci_slot_context::tt_id, xhci_slot_context::tt_port, xhci_endpoint_context::type, XHCI_CTX_EP0, XHCI_CTX_SLOT, XHCI_EP0_TRB_LEN, XHCI_EP_DCS, XHCI_EP_TYPE_CONTROL, xhci_input_context_offset(), and XHCI_SLOT_INFO.

Referenced by xhci_address_device().

◆ xhci_address_device()

static int xhci_address_device ( struct xhci_device xhci,
struct xhci_slot slot 
)
inlinestatic

Address device.

Parameters
xhcixHCI device
slotDevice slot
Return values
rcReturn status code

Definition at line 2108 of file xhci.c.

2109  {
2110  struct usb_device *usb = slot->usb;
2111  struct xhci_slot_context *slot_ctx;
2112  int rc;
2113 
2114  /* Assign device address */
2115  if ( ( rc = xhci_context ( xhci, slot, slot->endpoint[XHCI_CTX_EP0],
2117  xhci_address_device_input ) ) != 0 ) {
2118  DBGC ( xhci, "XHCI %s slot %d could not assign address: %s\n",
2119  xhci->name, slot->id, strerror ( rc ) );
2120  return rc;
2121  }
2122 
2123  /* Get assigned address */
2124  slot_ctx = ( slot->context +
2126  usb->address = slot_ctx->address;
2127  DBGC2 ( xhci, "XHCI %s slot %d assigned address %d to %s\n",
2128  xhci->name, slot->id, usb->address, usb->name );
2129 
2130  return 0;
2131 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
static size_t xhci_device_context_offset(struct xhci_device *xhci, unsigned int ctx)
Calculate device context offset.
Definition: xhci.c:412
#define DBGC(...)
Definition: compiler.h:505
static int xhci_context(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, unsigned int type, void(*populate)(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input))
Issue context-based command and wait for completion.
Definition: xhci.c:2016
unsigned int address
Device address, if assigned.
Definition: usb.h:718
uint8_t address
USB address.
Definition: xhci.h:755
#define XHCI_TRB_ADDRESS_DEVICE
An address device transfer request block.
Definition: xhci.h:520
char name[32]
Name.
Definition: usb.h:710
A USB device.
Definition: usb.h:708
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
#define DBGC2(...)
Definition: compiler.h:522
static void xhci_address_device_input(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input)
Populate address device input context.
Definition: xhci.c:2066
#define XHCI_CTX_EP0
Endpoint zero context index.
Definition: xhci.h:951
A slot context.
Definition: xhci.h:739
#define XHCI_CTX_SLOT
Slot context index.
Definition: xhci.h:943

References usb_device::address, xhci_slot_context::address, DBGC, DBGC2, usb_device::name, xhci_device::name, rc, slot, strerror(), xhci_address_device_input(), xhci_context(), XHCI_CTX_EP0, XHCI_CTX_SLOT, xhci_device_context_offset(), and XHCI_TRB_ADDRESS_DEVICE.

Referenced by xhci_device_address().

◆ xhci_configure_endpoint_input()

static void xhci_configure_endpoint_input ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint,
void *  input 
)
static

Populate configure endpoint input context.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
inputInput context

Definition at line 2141 of file xhci.c.

2144  {
2145  struct xhci_trb_ring *ring = &endpoint->ring;
2146  struct xhci_control_context *control_ctx;
2147  struct xhci_slot_context *slot_ctx;
2148  struct xhci_endpoint_context *ep_ctx;
2149 
2150  /* Populate control context */
2151  control_ctx = input;
2152  control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
2153  ( 1 << endpoint->ctx ) );
2154 
2155  /* Populate slot context */
2156  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2157  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
2158  ( slot->ports ? 1 : 0 ),
2159  slot->psiv, 0 ) );
2160  slot_ctx->ports = slot->ports;
2161 
2162  /* Populate endpoint context */
2163  ep_ctx = ( input + xhci_input_context_offset ( xhci, endpoint->ctx ) );
2164  ep_ctx->interval = endpoint->interval;
2165  ep_ctx->type = endpoint->type;
2166  ep_ctx->burst = endpoint->ep->burst;
2167  ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
2168  ep_ctx->dequeue = cpu_to_le64 ( dma ( &ring->map, ring->trb ) |
2169  XHCI_EP_DCS );
2170  ep_ctx->trb_len = cpu_to_le16 ( endpoint->ep->mtu ); /* best guess */
2171 }
An endpoint context.
Definition: xhci.h:769
uint8_t burst
Maximum burst size.
Definition: xhci.h:781
uint8_t type
Endpoint type.
Definition: xhci.h:779
#define XHCI_CTX_END
End of contexts.
Definition: xhci.h:954
An input control context.
Definition: xhci.h:721
uint16_t trb_len
Average TRB length.
Definition: xhci.h:787
struct dma_mapping map
DMA mapping.
Definition: xhci.h:858
Definition: bnxt_hsi.h:68
#define cpu_to_le64(value)
Definition: byteswap.h:108
uint32_t add
Add context flags.
Definition: xhci.h:725
uint64_t dequeue
Transfer ring dequeue pointer.
Definition: xhci.h:785
uint8_t ports
Number of downstream ports.
Definition: xhci.h:747
unsigned int type
Endpoint type.
Definition: xhci.h:1170
#define XHCI_EP_DCS
Endpoint dequeue cycle state.
Definition: xhci.h:824
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
unsigned int ctx
Context index.
Definition: xhci.h:1168
#define XHCI_SLOT_INFO(entries, hub, speed, route)
Construct slot context device info.
Definition: xhci.h:765
uint16_t mtu
Maximum packet size.
Definition: xhci.h:783
unsigned int burst
Maximum burst size.
Definition: usb.h:399
uint32_t info
Device info.
Definition: xhci.h:741
#define cpu_to_le32(value)
Definition: byteswap.h:107
uint8_t slot
Slot.
Definition: edd.h:16
size_t mtu
Maximum transfer size.
Definition: usb.h:397
struct usb_endpoint * ep
USB endpoint.
Definition: xhci.h:1166
uint8_t interval
Polling interval.
Definition: xhci.h:775
struct xhci_trb_ring ring
Transfer ring.
Definition: xhci.h:1176
static size_t xhci_input_context_offset(struct xhci_device *xhci, unsigned int ctx)
Calculate input context offset.
Definition: xhci.c:424
#define cpu_to_le16(value)
Definition: byteswap.h:106
A transfer request block command/transfer ring.
Definition: xhci.h:840
unsigned int interval
Endpoint interval.
Definition: xhci.h:1172
static __always_inline physaddr_t dma(struct dma_mapping *map, void *addr)
Get DMA address from virtual address.
Definition: dma.h:436
A slot context.
Definition: xhci.h:739
#define XHCI_CTX_SLOT
Slot context index.
Definition: xhci.h:943

References xhci_control_context::add, usb_endpoint::burst, xhci_endpoint_context::burst, cpu_to_le16, cpu_to_le32, cpu_to_le64, xhci_endpoint::ctx, xhci_endpoint_context::dequeue, dma(), xhci_endpoint::ep, xhci_slot_context::info, xhci_endpoint_context::interval, xhci_endpoint::interval, xhci_trb_ring::map, usb_endpoint::mtu, xhci_endpoint_context::mtu, xhci_slot_context::ports, xhci_endpoint::ring, slot, xhci_trb_ring::trb, xhci_endpoint_context::trb_len, xhci_endpoint_context::type, xhci_endpoint::type, XHCI_CTX_END, XHCI_CTX_SLOT, XHCI_EP_DCS, xhci_input_context_offset(), and XHCI_SLOT_INFO.

Referenced by xhci_configure_endpoint().

◆ xhci_configure_endpoint()

static int xhci_configure_endpoint ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint 
)
inlinestatic

Configure endpoint.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
Return values
rcReturn status code

Definition at line 2181 of file xhci.c.

2183  {
2184  int rc;
2185 
2186  /* Configure endpoint */
2187  if ( ( rc = xhci_context ( xhci, slot, endpoint,
2189  xhci_configure_endpoint_input ) ) != 0 ) {
2190  DBGC ( xhci, "XHCI %s slot %d ctx %d could not configure: %s\n",
2191  xhci->name, slot->id, endpoint->ctx, strerror ( rc ) );
2192  return rc;
2193  }
2194 
2195  DBGC2 ( xhci, "XHCI %s slot %d ctx %d configured\n",
2196  xhci->name, slot->id, endpoint->ctx );
2197  return 0;
2198 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define DBGC(...)
Definition: compiler.h:505
static int xhci_context(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, unsigned int type, void(*populate)(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input))
Issue context-based command and wait for completion.
Definition: xhci.c:2016
unsigned int ctx
Context index.
Definition: xhci.h:1168
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
static void xhci_configure_endpoint_input(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input)
Populate configure endpoint input context.
Definition: xhci.c:2141
#define XHCI_TRB_CONFIGURE_ENDPOINT
A configure endpoint transfer request block.
Definition: xhci.h:523
#define DBGC2(...)
Definition: compiler.h:522

References xhci_endpoint::ctx, DBGC, DBGC2, xhci_device::name, rc, slot, strerror(), xhci_configure_endpoint_input(), xhci_context(), and XHCI_TRB_CONFIGURE_ENDPOINT.

Referenced by xhci_endpoint_open().

◆ xhci_deconfigure_endpoint_input()

static void xhci_deconfigure_endpoint_input ( struct xhci_device *xhci  __unused,
struct xhci_slot *slot  __unused,
struct xhci_endpoint endpoint,
void *  input 
)
static

Populate deconfigure endpoint input context.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
inputInput context

Definition at line 2209 of file xhci.c.

2212  {
2213  struct xhci_control_context *control_ctx;
2214  struct xhci_slot_context *slot_ctx;
2215 
2216  /* Populate control context */
2217  control_ctx = input;
2218  control_ctx->add = cpu_to_le32 ( 1 << XHCI_CTX_SLOT );
2219  control_ctx->drop = cpu_to_le32 ( 1 << endpoint->ctx );
2220 
2221  /* Populate slot context */
2222  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2223  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
2224  0, 0, 0 ) );
2225 }
#define XHCI_CTX_END
End of contexts.
Definition: xhci.h:954
An input control context.
Definition: xhci.h:721
Definition: bnxt_hsi.h:68
uint32_t add
Add context flags.
Definition: xhci.h:725
uint32_t drop
Drop context flags.
Definition: xhci.h:723
unsigned int ctx
Context index.
Definition: xhci.h:1168
#define XHCI_SLOT_INFO(entries, hub, speed, route)
Construct slot context device info.
Definition: xhci.h:765
uint32_t info
Device info.
Definition: xhci.h:741
#define cpu_to_le32(value)
Definition: byteswap.h:107
static size_t xhci_input_context_offset(struct xhci_device *xhci, unsigned int ctx)
Calculate input context offset.
Definition: xhci.c:424
A slot context.
Definition: xhci.h:739
#define XHCI_CTX_SLOT
Slot context index.
Definition: xhci.h:943

References xhci_control_context::add, cpu_to_le32, xhci_endpoint::ctx, xhci_control_context::drop, xhci_slot_context::info, XHCI_CTX_END, XHCI_CTX_SLOT, xhci_input_context_offset(), and XHCI_SLOT_INFO.

Referenced by xhci_deconfigure_endpoint().

◆ xhci_deconfigure_endpoint()

static int xhci_deconfigure_endpoint ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint 
)
inlinestatic

Deconfigure endpoint.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
Return values
rcReturn status code

Definition at line 2235 of file xhci.c.

2237  {
2238  int rc;
2239 
2240  /* Deconfigure endpoint */
2241  if ( ( rc = xhci_context ( xhci, slot, endpoint,
2243  xhci_deconfigure_endpoint_input ) ) != 0 ) {
2244  DBGC ( xhci, "XHCI %s slot %d ctx %d could not deconfigure: "
2245  "%s\n", xhci->name, slot->id, endpoint->ctx,
2246  strerror ( rc ) );
2247  return rc;
2248  }
2249 
2250  DBGC2 ( xhci, "XHCI %s slot %d ctx %d deconfigured\n",
2251  xhci->name, slot->id, endpoint->ctx );
2252  return 0;
2253 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define DBGC(...)
Definition: compiler.h:505
static int xhci_context(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, unsigned int type, void(*populate)(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input))
Issue context-based command and wait for completion.
Definition: xhci.c:2016
static void xhci_deconfigure_endpoint_input(struct xhci_device *xhci __unused, struct xhci_slot *slot __unused, struct xhci_endpoint *endpoint, void *input)
Populate deconfigure endpoint input context.
Definition: xhci.c:2209
unsigned int ctx
Context index.
Definition: xhci.h:1168
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
#define XHCI_TRB_CONFIGURE_ENDPOINT
A configure endpoint transfer request block.
Definition: xhci.h:523
#define DBGC2(...)
Definition: compiler.h:522

References xhci_endpoint::ctx, DBGC, DBGC2, xhci_device::name, rc, slot, strerror(), xhci_context(), xhci_deconfigure_endpoint_input(), and XHCI_TRB_CONFIGURE_ENDPOINT.

Referenced by xhci_endpoint_close(), and xhci_endpoint_open().

◆ xhci_evaluate_context_input()

static void xhci_evaluate_context_input ( struct xhci_device xhci,
struct xhci_slot *slot  __unused,
struct xhci_endpoint endpoint,
void *  input 
)
static

Populate evaluate context input context.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
inputInput context

Definition at line 2263 of file xhci.c.

2266  {
2267  struct xhci_control_context *control_ctx;
2268  struct xhci_slot_context *slot_ctx;
2269  struct xhci_endpoint_context *ep_ctx;
2270 
2271  /* Populate control context */
2272  control_ctx = input;
2273  control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
2274  ( 1 << endpoint->ctx ) );
2275 
2276  /* Populate slot context */
2277  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2278  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
2279  0, 0, 0 ) );
2280 
2281  /* Populate endpoint context */
2282  ep_ctx = ( input + xhci_input_context_offset ( xhci, endpoint->ctx ) );
2283  ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
2284 }
An endpoint context.
Definition: xhci.h:769
#define XHCI_CTX_END
End of contexts.
Definition: xhci.h:954
An input control context.
Definition: xhci.h:721
Definition: bnxt_hsi.h:68
uint32_t add
Add context flags.
Definition: xhci.h:725
unsigned int ctx
Context index.
Definition: xhci.h:1168
#define XHCI_SLOT_INFO(entries, hub, speed, route)
Construct slot context device info.
Definition: xhci.h:765
uint16_t mtu
Maximum packet size.
Definition: xhci.h:783
uint32_t info
Device info.
Definition: xhci.h:741
#define cpu_to_le32(value)
Definition: byteswap.h:107
size_t mtu
Maximum transfer size.
Definition: usb.h:397
struct usb_endpoint * ep
USB endpoint.
Definition: xhci.h:1166
static size_t xhci_input_context_offset(struct xhci_device *xhci, unsigned int ctx)
Calculate input context offset.
Definition: xhci.c:424
#define cpu_to_le16(value)
Definition: byteswap.h:106
A slot context.
Definition: xhci.h:739
#define XHCI_CTX_SLOT
Slot context index.
Definition: xhci.h:943

References xhci_control_context::add, cpu_to_le16, cpu_to_le32, xhci_endpoint::ctx, xhci_endpoint::ep, xhci_slot_context::info, usb_endpoint::mtu, xhci_endpoint_context::mtu, XHCI_CTX_END, XHCI_CTX_SLOT, xhci_input_context_offset(), and XHCI_SLOT_INFO.

Referenced by xhci_evaluate_context().

◆ xhci_evaluate_context()

static int xhci_evaluate_context ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint 
)
inlinestatic

Evaluate context.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
Return values
rcReturn status code

Definition at line 2294 of file xhci.c.

2296  {
2297  int rc;
2298 
2299  /* Configure endpoint */
2300  if ( ( rc = xhci_context ( xhci, slot, endpoint,
2302  xhci_evaluate_context_input ) ) != 0 ) {
2303  DBGC ( xhci, "XHCI %s slot %d ctx %d could not (re-)evaluate: "
2304  "%s\n", xhci->name, slot->id, endpoint->ctx,
2305  strerror ( rc ) );
2306  return rc;
2307  }
2308 
2309  DBGC2 ( xhci, "XHCI %s slot %d ctx %d (re-)evaluated\n",
2310  xhci->name, slot->id, endpoint->ctx );
2311  return 0;
2312 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
static void xhci_evaluate_context_input(struct xhci_device *xhci, struct xhci_slot *slot __unused, struct xhci_endpoint *endpoint, void *input)
Populate evaluate context input context.
Definition: xhci.c:2263
#define DBGC(...)
Definition: compiler.h:505
static int xhci_context(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, unsigned int type, void(*populate)(struct xhci_device *xhci, struct xhci_slot *slot, struct xhci_endpoint *endpoint, void *input))
Issue context-based command and wait for completion.
Definition: xhci.c:2016
unsigned int ctx
Context index.
Definition: xhci.h:1168
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
#define DBGC2(...)
Definition: compiler.h:522
#define XHCI_TRB_EVALUATE_CONTEXT
An evaluate context transfer request block.
Definition: xhci.h:526

References xhci_endpoint::ctx, DBGC, DBGC2, xhci_device::name, rc, slot, strerror(), xhci_context(), xhci_evaluate_context_input(), and XHCI_TRB_EVALUATE_CONTEXT.

Referenced by xhci_endpoint_mtu().

◆ xhci_reset_endpoint()

static int xhci_reset_endpoint ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint 
)
inlinestatic

Reset endpoint.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
Return values
rcReturn status code

Definition at line 2322 of file xhci.c.

2324  {
2325  union xhci_trb trb;
2326  struct xhci_trb_reset_endpoint *reset = &trb.reset;
2327  int rc;
2328 
2329  /* Construct command */
2330  memset ( reset, 0, sizeof ( *reset ) );
2331  reset->slot = slot->id;
2332  reset->endpoint = endpoint->ctx;
2333  reset->type = XHCI_TRB_RESET_ENDPOINT;
2334 
2335  /* Issue command and wait for completion */
2336  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
2337  DBGC ( xhci, "XHCI %s slot %d ctx %d could not reset endpoint "
2338  "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
2339  endpoint->context->state, strerror ( rc ) );
2340  return rc;
2341  }
2342 
2343  return 0;
2344 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define DBGC(...)
Definition: compiler.h:505
#define XHCI_TRB_RESET_ENDPOINT
A reset endpoint transfer request block.
Definition: xhci.h:545
uint8_t type
Type.
Definition: xhci.h:537
uint8_t slot
Slot ID.
Definition: xhci.h:541
A reset endpoint transfer request block.
Definition: xhci.h:529
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
A transfer request block.
Definition: xhci.h:683
const char * name
Name.
Definition: xhci.h:1073
uint8_t slot
Slot.
Definition: edd.h:16
uint8_t endpoint
Endpoint ID.
Definition: xhci.h:539
static int xhci_command(struct xhci_device *xhci, union xhci_trb *trb)
Issue command and wait for completion.
Definition: xhci.c:1851
void * memset(void *dest, int character, size_t len) __nonnull

References DBGC, xhci_trb_reset_endpoint::endpoint, memset(), xhci_device::name, rc, xhci_trb::reset, slot, xhci_trb_reset_endpoint::slot, strerror(), xhci_trb_reset_endpoint::type, xhci_command(), and XHCI_TRB_RESET_ENDPOINT.

Referenced by xhci_endpoint_reset().

◆ xhci_stop_endpoint()

static int xhci_stop_endpoint ( struct xhci_device xhci,
struct xhci_slot slot,
struct xhci_endpoint endpoint 
)
inlinestatic

Stop endpoint.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
Return values
rcReturn status code

Definition at line 2354 of file xhci.c.

2356  {
2357  union xhci_trb trb;
2358  struct xhci_trb_stop_endpoint *stop = &trb.stop;
2359  int rc;
2360 
2361  /* Construct command */
2362  memset ( stop, 0, sizeof ( *stop ) );
2363  stop->slot = slot->id;
2364  stop->endpoint = endpoint->ctx;
2365  stop->type = XHCI_TRB_STOP_ENDPOINT;
2366 
2367  /* Issue command and wait for completion */
2368  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
2369  DBGC ( xhci, "XHCI %s slot %d ctx %d could not stop endpoint "
2370  "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
2371  endpoint->context->state, strerror ( rc ) );
2372  return rc;
2373  }
2374 
2375  return 0;
2376 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define DBGC(...)
Definition: compiler.h:505
uint8_t endpoint
Endpoint ID.
Definition: xhci.h:558
uint8_t slot
Slot ID.
Definition: xhci.h:560
#define XHCI_TRB_STOP_ENDPOINT
A stop endpoint transfer request block.