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_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
uint8_t type
Type.
Definition: ena.h:16
#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
uint8_t type
Type.
Definition: ena.h:16
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_probe(), 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 1186 of file xhci.c.

1189  {
1190  struct xhci_trb_link *link;
1191  unsigned int count;
1192  int rc;
1193 
1194  /* Sanity check */
1195  assert ( shift > 0 );
1196 
1197  /* Initialise structure */
1198  memset ( ring, 0, sizeof ( *ring ) );
1199  ring->shift = shift;
1200  count = ( 1U << shift );
1201  ring->mask = ( count - 1 );
1202  ring->len = ( ( count + 1 /* Link TRB */ ) * sizeof ( ring->trb[0] ) );
1203  ring->db = ( xhci->db + ( slot * sizeof ( ring->dbval ) ) );
1204  ring->dbval = XHCI_DBVAL ( target, stream );
1205 
1206  /* Allocate I/O buffers */
1207  ring->iobuf = zalloc ( count * sizeof ( ring->iobuf[0] ) );
1208  if ( ! ring->iobuf ) {
1209  rc = -ENOMEM;
1210  goto err_alloc_iobuf;
1211  }
1212 
1213  /* Allocate TRBs */
1214  ring->trb = dma_alloc ( xhci->dma, &ring->map, ring->len,
1215  xhci_align ( ring->len ) );
1216  if ( ! ring->trb ) {
1217  rc = -ENOMEM;
1218  goto err_alloc_trb;
1219  }
1220  memset ( ring->trb, 0, ring->len );
1221 
1222  /* Initialise Link TRB */
1223  link = &ring->trb[count].link;
1224  link->next = cpu_to_le64 ( dma ( &ring->map, ring->trb ) );
1225  link->flags = XHCI_TRB_TC;
1226  link->type = XHCI_TRB_LINK;
1227  ring->link = link;
1228 
1229  return 0;
1230 
1231  dma_free ( &ring->map, ring->trb, ring->len );
1232  err_alloc_trb:
1233  free ( ring->iobuf );
1234  err_alloc_iobuf:
1235  return rc;
1236 }
#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 1243 of file xhci.c.

1243  {
1244  unsigned int count = ( 1U << ring->shift );
1245 
1246  /* Reset producer and consumer counters */
1247  ring->prod = 0;
1248  ring->cons = 0;
1249 
1250  /* Reset TRBs (except Link TRB) */
1251  memset ( ring->trb, 0, ( count * sizeof ( ring->trb[0] ) ) );
1252 }
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 1259 of file xhci.c.

1259  {
1260  unsigned int count = ( 1U << ring->shift );
1261  unsigned int i;
1262 
1263  /* Sanity checks */
1264  assert ( ring->cons == ring->prod );
1265  for ( i = 0 ; i < count ; i++ )
1266  assert ( ring->iobuf[i] == NULL );
1267 
1268  /* Free TRBs */
1269  dma_free ( &ring->map, ring->trb, ring->len );
1270 
1271  /* Free I/O buffers */
1272  free ( ring->iobuf );
1273 }
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 1285 of file xhci.c.

1286  {
1287  union xhci_trb *dest;
1288  unsigned int prod;
1289  unsigned int mask;
1290  unsigned int index;
1291  unsigned int cycle;
1292 
1293  /* Sanity check */
1294  assert ( ! ( trb->common.flags & XHCI_TRB_C ) );
1295 
1296  /* Fail if ring is full */
1297  if ( ! xhci_ring_remaining ( ring ) )
1298  return -ENOBUFS;
1299 
1300  /* Update producer counter (and link TRB, if applicable) */
1301  prod = ring->prod++;
1302  mask = ring->mask;
1303  cycle = ( ( ~( prod >> ring->shift ) ) & XHCI_TRB_C );
1304  index = ( prod & mask );
1305  if ( index == 0 )
1306  ring->link->flags = ( XHCI_TRB_TC | ( cycle ^ XHCI_TRB_C ) );
1307 
1308  /* Record I/O buffer */
1309  ring->iobuf[index] = iobuf;
1310 
1311  /* Enqueue TRB */
1312  dest = &ring->trb[index];
1313  dest->template.parameter = trb->template.parameter;
1314  dest->template.status = trb->template.status;
1315  wmb();
1316  dest->template.control = ( trb->template.control |
1317  cpu_to_le32 ( cycle ) );
1318 
1319  return 0;
1320 }
#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 1328 of file xhci.c.

1328  {
1329  struct io_buffer *iobuf;
1330  unsigned int cons;
1331  unsigned int mask;
1332  unsigned int index;
1333 
1334  /* Sanity check */
1335  assert ( xhci_ring_fill ( ring ) != 0 );
1336 
1337  /* Update consumer counter */
1338  cons = ring->cons++;
1339  mask = ring->mask;
1340  index = ( cons & mask );
1341 
1342  /* Retrieve I/O buffer */
1343  iobuf = ring->iobuf[index];
1344  ring->iobuf[index] = NULL;
1345 
1346  return iobuf;
1347 }
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 1360 of file xhci.c.

1363  {
1364  const union xhci_trb *trb = trbs;
1365  int rc;
1366 
1367  /* Sanity check */
1368  assert ( iobuf != NULL );
1369 
1370  /* Fail if ring does not have sufficient space */
1371  if ( xhci_ring_remaining ( ring ) < count )
1372  return -ENOBUFS;
1373 
1374  /* Enqueue each TRB, recording the I/O buffer with the final TRB */
1375  while ( count-- ) {
1376  rc = xhci_enqueue ( ring, ( count ? NULL : iobuf ), trb++ );
1377  assert ( rc == 0 ); /* Should never be able to fail */
1378  }
1379 
1380  return 0;
1381 }
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:1285
#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 1389 of file xhci.c.

1389  {
1390  struct io_buffer *iobuf;
1391 
1392  /* Dequeue TRBs until we reach the final TRB for an I/O buffer */
1393  do {
1394  iobuf = xhci_dequeue ( ring );
1395  } while ( iobuf == NULL );
1396 
1397  return iobuf;
1398 }
static struct io_buffer * xhci_dequeue(struct xhci_trb_ring *ring)
Dequeue a transfer request block.
Definition: xhci.c:1328
#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 1406 of file xhci.c.

1406  {
1407 
1408  wmb();
1409  writel ( ring->dbval, ring->db );
1410 }
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 1425 of file xhci.c.

1425  {
1426  physaddr_t crp;
1427  int rc;
1428 
1429  /* Allocate TRB ring */
1430  if ( ( rc = xhci_ring_alloc ( xhci, &xhci->command, XHCI_CMD_TRBS_LOG2,
1431  0, 0, 0 ) ) != 0 )
1432  goto err_ring_alloc;
1433 
1434  /* Program command ring control register */
1435  crp = dma ( &xhci->command.map, xhci->command.trb );
1436  if ( ( rc = xhci_writeq ( xhci, ( crp | XHCI_CRCR_RCS ),
1437  xhci->op + XHCI_OP_CRCR ) ) != 0 )
1438  goto err_writeq;
1439 
1440  DBGC2 ( xhci, "XHCI %s CRCR at [%08lx,%08lx)\n", xhci->name,
1441  virt_to_phys ( xhci->command.trb ),
1442  ( virt_to_phys ( xhci->command.trb ) + xhci->command.len ) );
1443  return 0;
1444 
1445  err_writeq:
1446  xhci_ring_free ( &xhci->command );
1447  err_ring_alloc:
1448  return rc;
1449 }
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:1259
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:1186
#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 1456 of file xhci.c.

1456  {
1457 
1458  /* Sanity check */
1459  assert ( ( readl ( xhci->op + XHCI_OP_CRCR ) & XHCI_CRCR_CRR ) == 0 );
1460 
1461  /* Clear command ring control register */
1462  xhci_writeq ( xhci, 0, xhci->op + XHCI_OP_CRCR );
1463 
1464  /* Free TRB ring */
1465  xhci_ring_free ( &xhci->command );
1466 }
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:1259
#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 1474 of file xhci.c.

1474  {
1475  struct xhci_event_ring *event = &xhci->event;
1476  unsigned int count;
1477  size_t len;
1478  int rc;
1479 
1480  /* Allocate event ring */
1481  count = ( 1 << XHCI_EVENT_TRBS_LOG2 );
1482  len = ( count * sizeof ( event->trb[0] ) );
1483  event->trb = dma_alloc ( xhci->dma, &event->trb_map, len,
1484  xhci_align ( len ) );
1485  if ( ! event->trb ) {
1486  rc = -ENOMEM;
1487  goto err_alloc_trb;
1488  }
1489  memset ( event->trb, 0, len );
1490 
1491  /* Allocate event ring segment table */
1492  event->segment = dma_alloc ( xhci->dma, &event->segment_map,
1493  sizeof ( event->segment[0] ),
1494  xhci_align ( sizeof (event->segment[0])));
1495  if ( ! event->segment ) {
1496  rc = -ENOMEM;
1497  goto err_alloc_segment;
1498  }
1499  memset ( event->segment, 0, sizeof ( event->segment[0] ) );
1500  event->segment[0].base = cpu_to_le64 ( dma ( &event->trb_map,
1501  event->trb ) );
1502  event->segment[0].count = cpu_to_le32 ( count );
1503 
1504  /* Program event ring registers */
1505  writel ( 1, xhci->run + XHCI_RUN_ERSTSZ ( 0 ) );
1506  if ( ( rc = xhci_writeq ( xhci, dma ( &event->trb_map, event->trb ),
1507  xhci->run + XHCI_RUN_ERDP ( 0 ) ) ) != 0 )
1508  goto err_writeq_erdp;
1509  if ( ( rc = xhci_writeq ( xhci,
1510  dma ( &event->segment_map, event->segment ),
1511  xhci->run + XHCI_RUN_ERSTBA ( 0 ) ) ) != 0 )
1512  goto err_writeq_erstba;
1513 
1514  DBGC2 ( xhci, "XHCI %s event ring [%08lx,%08lx) table [%08lx,%08lx)\n",
1515  xhci->name, virt_to_phys ( event->trb ),
1516  ( virt_to_phys ( event->trb ) + len ),
1517  virt_to_phys ( event->segment ),
1518  ( virt_to_phys ( event->segment ) +
1519  sizeof ( event->segment[0] ) ) );
1520  return 0;
1521 
1522  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERSTBA ( 0 ) );
1523  err_writeq_erstba:
1524  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERDP ( 0 ) );
1525  err_writeq_erdp:
1526  dma_free ( &event->segment_map, event->segment,
1527  sizeof ( event->segment[0] ) );
1528  err_alloc_segment:
1529  dma_free ( &event->trb_map, event->trb, len );
1530  err_alloc_trb:
1531  return rc;
1532 }
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 1539 of file xhci.c.

1539  {
1540  struct xhci_event_ring *event = &xhci->event;
1541  unsigned int count;
1542  size_t len;
1543 
1544  /* Clear event ring registers */
1545  writel ( 0, xhci->run + XHCI_RUN_ERSTSZ ( 0 ) );
1546  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERSTBA ( 0 ) );
1547  xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERDP ( 0 ) );
1548 
1549  /* Free event ring segment table */
1550  dma_free ( &event->segment_map, event->segment,
1551  sizeof ( event->segment[0] ) );
1552 
1553  /* Free event ring */
1554  count = ( 1 << XHCI_EVENT_TRBS_LOG2 );
1555  len = ( count * sizeof ( event->trb[0] ) );
1556  dma_free ( &event->trb_map, event->trb, len );
1557 }
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 1565 of file xhci.c.

1566  {
1567  struct xhci_slot *slot;
1568  struct xhci_endpoint *endpoint;
1569  struct io_buffer *iobuf;
1570  int rc;
1571 
1572  /* Profile transfer events */
1573  profile_start ( &xhci_transfer_profiler );
1574 
1575  /* Identify slot */
1576  if ( ( trb->slot > xhci->slots ) ||
1577  ( ( slot = xhci->slot[trb->slot] ) == NULL ) ) {
1578  DBGC ( xhci, "XHCI %s transfer event invalid slot %d:\n",
1579  xhci->name, trb->slot );
1580  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1581  return;
1582  }
1583 
1584  /* Identify endpoint */
1585  if ( ( trb->endpoint >= XHCI_CTX_END ) ||
1586  ( ( endpoint = slot->endpoint[trb->endpoint] ) == NULL ) ) {
1587  DBGC ( xhci, "XHCI %s slot %d transfer event invalid epid "
1588  "%d:\n", xhci->name, slot->id, trb->endpoint );
1589  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1590  return;
1591  }
1592 
1593  /* Dequeue TRB(s) */
1594  iobuf = xhci_dequeue_multi ( &endpoint->ring );
1595  assert ( iobuf != NULL );
1596 
1597  /* Unmap I/O buffer */
1598  iob_unmap ( iobuf );
1599 
1600  /* Check for errors */
1601  if ( ! ( ( trb->code == XHCI_CMPLT_SUCCESS ) ||
1602  ( trb->code == XHCI_CMPLT_SHORT ) ) ) {
1603 
1604  /* Construct error */
1605  rc = -ECODE ( trb->code );
1606  DBGC ( xhci, "XHCI %s slot %d ctx %d failed (code %d): %s\n",
1607  xhci->name, slot->id, endpoint->ctx, trb->code,
1608  strerror ( rc ) );
1609  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1610 
1611  /* Sanity check */
1612  assert ( ( endpoint->context->state & XHCI_ENDPOINT_STATE_MASK )
1613  != XHCI_ENDPOINT_RUNNING );
1614 
1615  /* Report failure to USB core */
1616  usb_complete_err ( endpoint->ep, iobuf, rc );
1617  return;
1618  }
1619 
1620  /* Record actual transfer size */
1621  iob_unput ( iobuf, le16_to_cpu ( trb->residual ) );
1622 
1623  /* Sanity check (for successful completions only) */
1624  assert ( xhci_ring_consumed ( &endpoint->ring ) ==
1625  le64_to_cpu ( trb->transfer ) );
1626 
1627  /* Report completion to USB core */
1628  usb_complete ( endpoint->ep, iobuf );
1629  profile_stop ( &xhci_transfer_profiler );
1630 }
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:1158
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:1166
#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:1172
An xHCI device slot.
Definition: xhci.h:1130
#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:1389
struct usb_endpoint * ep
USB endpoint.
Definition: xhci.h:1164
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:1174
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:1120
#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 1638 of file xhci.c.

1639  {
1640  int rc;
1641 
1642  /* Ignore "command ring stopped" notifications */
1643  if ( trb->code == XHCI_CMPLT_CMD_STOPPED ) {
1644  DBGC2 ( xhci, "XHCI %s command ring stopped\n", xhci->name );
1645  return;
1646  }
1647 
1648  /* Ignore unexpected completions */
1649  if ( ! xhci->pending ) {
1650  rc = -ECODE ( trb->code );
1651  DBGC ( xhci, "XHCI %s unexpected completion (code %d): %s\n",
1652  xhci->name, trb->code, strerror ( rc ) );
1653  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1654  return;
1655  }
1656 
1657  /* Dequeue command TRB */
1658  xhci_dequeue ( &xhci->command );
1659 
1660  /* Sanity check */
1661  assert ( xhci_ring_consumed ( &xhci->command ) ==
1662  le64_to_cpu ( trb->command ) );
1663 
1664  /* Record completion */
1665  memcpy ( xhci->pending, trb, sizeof ( *xhci->pending ) );
1666  xhci->pending = NULL;
1667 }
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:1328
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 1675 of file xhci.c.

1676  {
1677  struct usb_port *port = usb_port ( xhci->bus->hub, trb->port );
1678  uint32_t portsc;
1679 
1680  /* Sanity check */
1681  assert ( ( trb->port > 0 ) && ( trb->port <= xhci->ports ) );
1682 
1683  /* Record disconnections and clear changes */
1684  portsc = readl ( xhci->op + XHCI_OP_PORTSC ( trb->port ) );
1685  port->disconnected |= ( portsc & XHCI_PORTSC_CSC );
1686  portsc &= ( XHCI_PORTSC_PRESERVE | XHCI_PORTSC_CHANGE );
1687  writel ( portsc, xhci->op + XHCI_OP_PORTSC ( trb->port ) );
1688 
1689  /* Report port status change */
1690  usb_port_changed ( port );
1691 }
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:1123
#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 1699 of file xhci.c.

1700  {
1701  int rc;
1702 
1703  /* Construct error */
1704  rc = -ECODE ( trb->code );
1705  DBGC ( xhci, "XHCI %s host controller event (code %d): %s\n",
1706  xhci->name, trb->code, strerror ( rc ) );
1707 }
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 1714 of file xhci.c.

1714  {
1715  struct xhci_event_ring *event = &xhci->event;
1716  union xhci_trb *trb;
1717  unsigned int shift = XHCI_EVENT_TRBS_LOG2;
1718  unsigned int count = ( 1 << shift );
1719  unsigned int mask = ( count - 1 );
1720  unsigned int consumed;
1721  unsigned int type;
1722 
1723  /* Poll for events */
1724  profile_start ( &xhci_event_profiler );
1725  for ( consumed = 0 ; ; consumed++ ) {
1726 
1727  /* Stop if we reach an empty TRB */
1728  rmb();
1729  trb = &event->trb[ event->cons & mask ];
1730  if ( ! ( ( trb->common.flags ^
1731  ( event->cons >> shift ) ) & XHCI_TRB_C ) )
1732  break;
1733 
1734  /* Consume this TRB */
1735  event->cons++;
1736 
1737  /* Handle TRB */
1738  type = ( trb->common.type & XHCI_TRB_TYPE_MASK );
1739  switch ( type ) {
1740 
1741  case XHCI_TRB_TRANSFER :
1742  xhci_transfer ( xhci, &trb->transfer );
1743  break;
1744 
1745  case XHCI_TRB_COMPLETE :
1746  xhci_complete ( xhci, &trb->complete );
1747  break;
1748 
1749  case XHCI_TRB_PORT_STATUS:
1750  xhci_port_status ( xhci, &trb->port );
1751  break;
1752 
1754  xhci_host_controller ( xhci, &trb->host );
1755  break;
1756 
1757  default:
1758  DBGC ( xhci, "XHCI %s unrecognised event %#x\n:",
1759  xhci->name, ( event->cons - 1 ) );
1760  DBGC_HDA ( xhci, virt_to_phys ( trb ),
1761  trb, sizeof ( *trb ) );
1762  break;
1763  }
1764  }
1765 
1766  /* Update dequeue pointer if applicable */
1767  if ( consumed ) {
1768  xhci_writeq ( xhci, dma ( &event->trb_map, trb ),
1769  xhci->run + XHCI_RUN_ERDP ( 0 ) );
1770  profile_stop ( &xhci_event_profiler );
1771  }
1772 }
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
uint8_t type
Type.
Definition: ena.h:16
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:1565
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
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:1699
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:1638
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:1675

References xhci_trb::common, xhci_trb::complete, count, DBGC, DBGC_HDA, dma(), xhci_device::event, 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 1779 of file xhci.c.

1779  {
1780  physaddr_t crp;
1781 
1782  /* Abort the command */
1783  DBGC2 ( xhci, "XHCI %s aborting command\n", xhci->name );
1784  xhci_writeq ( xhci, XHCI_CRCR_CA, xhci->op + XHCI_OP_CRCR );
1785 
1786  /* Allow time for command to abort */
1788 
1789  /* Sanity check */
1790  assert ( ( readl ( xhci->op + XHCI_OP_CRCR ) & XHCI_CRCR_CRR ) == 0 );
1791 
1792  /* Consume (and ignore) any final command status */
1793  xhci_event_poll ( xhci );
1794 
1795  /* Reset the command ring control register */
1796  xhci_ring_reset ( &xhci->command );
1797  crp = dma ( &xhci->command.map, xhci->command.trb );
1798  xhci_writeq ( xhci, ( crp | XHCI_CRCR_RCS ), xhci->op + XHCI_OP_CRCR );
1799 }
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.
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:1243
#define XHCI_OP_CRCR
Command ring control register.
Definition: xhci.h:179
union xhci_trb * trb
Transfer request blocks.
Definition: xhci.h:854
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
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
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:1714
#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 assert(), xhci_device::command, 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_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 1811 of file xhci.c.

1811  {
1812  struct xhci_trb_complete *complete = &trb->complete;
1813  unsigned int i;
1814  int rc;
1815 
1816  /* Sanity check */
1817  if ( xhci->pending ) {
1818  DBGC ( xhci, "XHCI %s command ring busy\n", xhci->name );
1819  rc = -EBUSY;
1820  goto err_pending;
1821  }
1822 
1823  /* Record the pending command */
1824  xhci->pending = trb;
1825 
1826  /* Enqueue the command */
1827  if ( ( rc = xhci_enqueue ( &xhci->command, NULL, trb ) ) != 0 )
1828  goto err_enqueue;
1829 
1830  /* Ring the command doorbell */
1831  xhci_doorbell ( &xhci->command );
1832 
1833  /* Wait for the command to complete */
1834  for ( i = 0 ; i < XHCI_COMMAND_MAX_WAIT_MS ; i++ ) {
1835 
1836  /* Poll event ring */
1837  xhci_event_poll ( xhci );
1838 
1839  /* Check for completion */
1840  if ( ! xhci->pending ) {
1841  if ( complete->code != XHCI_CMPLT_SUCCESS ) {
1842  rc = -ECODE ( complete->code );
1843  DBGC ( xhci, "XHCI %s command failed (code "
1844  "%d): %s\n", xhci->name, complete->code,
1845  strerror ( rc ) );
1846  DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
1847  return rc;
1848  }
1849  return 0;
1850  }
1851 
1852  /* Delay */
1853  mdelay ( 1 );
1854  }
1855 
1856  /* Timeout */
1857  DBGC ( xhci, "XHCI %s timed out waiting for completion\n", xhci->name );
1858  rc = -ETIMEDOUT;
1859 
1860  /* Abort command */
1861  xhci_abort ( xhci );
1862 
1863  err_enqueue:
1864  xhci->pending = NULL;
1865  err_pending:
1866  return rc;
1867 }
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
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
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:1779
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:1714
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:1285
static void xhci_doorbell(struct xhci_trb_ring *ring)
Ring doorbell register.
Definition: xhci.c:1406
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, ETIMEDOUT, 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 1875 of file xhci.c.

1875  {
1876  union xhci_trb trb;
1877  struct xhci_trb_common *nop = &trb.common;
1878  int rc;
1879 
1880  /* Construct command */
1881  memset ( nop, 0, sizeof ( *nop ) );
1882  nop->flags = XHCI_TRB_IOC;
1883  nop->type = XHCI_TRB_NOP_CMD;
1884 
1885  /* Issue command and wait for completion */
1886  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
1887  DBGC ( xhci, "XHCI %s NOP failed: %s\n",
1888  xhci->name, strerror ( rc ) );
1889  return rc;
1890  }
1891 
1892  DBGC2 ( xhci, "XHCI %s NOP completed successfully\n", xhci->name );
1893  return 0;
1894 }
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:1811
#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 1903 of file xhci.c.

1904  {
1905  union xhci_trb trb;
1906  struct xhci_trb_enable_slot *enable = &trb.enable;
1907  struct xhci_trb_complete *enabled = &trb.complete;
1908  unsigned int slot;
1909  int rc;
1910 
1911  /* Construct command */
1912  memset ( enable, 0, sizeof ( *enable ) );
1913  enable->slot = type;
1914  enable->type = XHCI_TRB_ENABLE_SLOT;
1915 
1916  /* Issue command and wait for completion */
1917  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
1918  DBGC ( xhci, "XHCI %s could not enable new slot: %s\n",
1919  xhci->name, strerror ( rc ) );
1920  return rc;
1921  }
1922 
1923  /* Extract slot number */
1924  slot = enabled->slot;
1925 
1926  DBGC2 ( xhci, "XHCI %s slot %d enabled\n", xhci->name, slot );
1927  return slot;
1928 }
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
uint8_t type
Type.
Definition: ena.h:16
#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:1811
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 1937 of file xhci.c.

1938  {
1939  union xhci_trb trb;
1940  struct xhci_trb_disable_slot *disable = &trb.disable;
1941  int rc;
1942 
1943  /* Construct command */
1944  memset ( disable, 0, sizeof ( *disable ) );
1945  disable->type = XHCI_TRB_DISABLE_SLOT;
1946  disable->slot = slot;
1947 
1948  /* Issue command and wait for completion */
1949  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
1950  DBGC ( xhci, "XHCI %s could not disable slot %d: %s\n",
1951  xhci->name, slot, strerror ( rc ) );
1952  return rc;
1953  }
1954 
1955  DBGC2 ( xhci, "XHCI %s slot %d disabled\n", xhci->name, slot );
1956  return 0;
1957 }
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:1811
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 1969 of file xhci.c.

1974  {
1975  union xhci_trb trb;
1976  struct xhci_trb_context *context = &trb.context;
1977  struct dma_mapping map;
1978  size_t len;
1979  void *input;
1980  int rc;
1981 
1982  /* Allocate an input context */
1983  memset ( &map, 0, sizeof ( map ) );
1985  input = dma_alloc ( xhci->dma, &map, len, xhci_align ( len ) );
1986  if ( ! input ) {
1987  rc = -ENOMEM;
1988  goto err_alloc;
1989  }
1990  memset ( input, 0, len );
1991 
1992  /* Populate input context */
1993  populate ( xhci, slot, endpoint, input );
1994 
1995  /* Construct command */
1996  memset ( context, 0, sizeof ( *context ) );
1997  context->type = type;
1998  context->input = cpu_to_le64 ( dma ( &map, input ) );
1999  context->slot = slot->id;
2000 
2001  /* Issue command and wait for completion */
2002  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 )
2003  goto err_command;
2004 
2005  err_command:
2006  dma_free ( &map, input, len );
2007  err_alloc:
2008  return rc;
2009 }
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
uint8_t type
Type.
Definition: ena.h:16
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:1811
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 2019 of file xhci.c.

2022  {
2023  struct xhci_trb_ring *ring = &endpoint->ring;
2024  struct xhci_control_context *control_ctx;
2025  struct xhci_slot_context *slot_ctx;
2026  struct xhci_endpoint_context *ep_ctx;
2027 
2028  /* Sanity checks */
2029  assert ( endpoint->ctx == XHCI_CTX_EP0 );
2030 
2031  /* Populate control context */
2032  control_ctx = input;
2033  control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
2034  ( 1 << XHCI_CTX_EP0 ) );
2035 
2036  /* Populate slot context */
2037  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2038  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( 1, 0, slot->psiv,
2039  slot->route ) );
2040  slot_ctx->port = slot->port;
2041  slot_ctx->tt_id = slot->tt_id;
2042  slot_ctx->tt_port = slot->tt_port;
2043 
2044  /* Populate control endpoint context */
2045  ep_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_EP0 ) );
2046  ep_ctx->type = XHCI_EP_TYPE_CONTROL;
2047  ep_ctx->burst = endpoint->ep->burst;
2048  ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
2049  ep_ctx->dequeue = cpu_to_le64 ( dma ( &ring->map, ring->trb ) |
2050  XHCI_EP_DCS );
2051  ep_ctx->trb_len = cpu_to_le16 ( XHCI_EP0_TRB_LEN );
2052 }
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:1166
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:1164
uint8_t tt_port
TT port number.
Definition: xhci.h:751
struct xhci_trb_ring ring
Transfer ring.
Definition: xhci.h:1174
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 2061 of file xhci.c.

2062  {
2063  struct usb_device *usb = slot->usb;
2064  struct xhci_slot_context *slot_ctx;
2065  int rc;
2066 
2067  /* Assign device address */
2068  if ( ( rc = xhci_context ( xhci, slot, slot->endpoint[XHCI_CTX_EP0],
2070  xhci_address_device_input ) ) != 0 ) {
2071  DBGC ( xhci, "XHCI %s slot %d could not assign address: %s\n",
2072  xhci->name, slot->id, strerror ( rc ) );
2073  return rc;
2074  }
2075 
2076  /* Get assigned address */
2077  slot_ctx = ( slot->context +
2079  usb->address = slot_ctx->address;
2080  DBGC2 ( xhci, "XHCI %s slot %d assigned address %d to %s\n",
2081  xhci->name, slot->id, usb->address, usb->name );
2082 
2083  return 0;
2084 }
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:1969
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:2019
#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 2094 of file xhci.c.

2097  {
2098  struct xhci_trb_ring *ring = &endpoint->ring;
2099  struct xhci_control_context *control_ctx;
2100  struct xhci_slot_context *slot_ctx;
2101  struct xhci_endpoint_context *ep_ctx;
2102 
2103  /* Populate control context */
2104  control_ctx = input;
2105  control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
2106  ( 1 << endpoint->ctx ) );
2107 
2108  /* Populate slot context */
2109  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2110  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
2111  ( slot->ports ? 1 : 0 ),
2112  slot->psiv, 0 ) );
2113  slot_ctx->ports = slot->ports;
2114 
2115  /* Populate endpoint context */
2116  ep_ctx = ( input + xhci_input_context_offset ( xhci, endpoint->ctx ) );
2117  ep_ctx->interval = endpoint->interval;
2118  ep_ctx->type = endpoint->type;
2119  ep_ctx->burst = endpoint->ep->burst;
2120  ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
2121  ep_ctx->dequeue = cpu_to_le64 ( dma ( &ring->map, ring->trb ) |
2122  XHCI_EP_DCS );
2123  ep_ctx->trb_len = cpu_to_le16 ( endpoint->ep->mtu ); /* best guess */
2124 }
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:1168
#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:1166
#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:1164
uint8_t interval
Polling interval.
Definition: xhci.h:775
struct xhci_trb_ring ring
Transfer ring.
Definition: xhci.h:1174
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:1170
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 2134 of file xhci.c.

2136  {
2137  int rc;
2138 
2139  /* Configure endpoint */
2140  if ( ( rc = xhci_context ( xhci, slot, endpoint,
2142  xhci_configure_endpoint_input ) ) != 0 ) {
2143  DBGC ( xhci, "XHCI %s slot %d ctx %d could not configure: %s\n",
2144  xhci->name, slot->id, endpoint->ctx, strerror ( rc ) );
2145  return rc;
2146  }
2147 
2148  DBGC2 ( xhci, "XHCI %s slot %d ctx %d configured\n",
2149  xhci->name, slot->id, endpoint->ctx );
2150  return 0;
2151 }
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:1969
unsigned int ctx
Context index.
Definition: xhci.h:1166
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:2094
#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 2162 of file xhci.c.

2165  {
2166  struct xhci_control_context *control_ctx;
2167  struct xhci_slot_context *slot_ctx;
2168 
2169  /* Populate control context */
2170  control_ctx = input;
2171  control_ctx->add = cpu_to_le32 ( 1 << XHCI_CTX_SLOT );
2172  control_ctx->drop = cpu_to_le32 ( 1 << endpoint->ctx );
2173 
2174  /* Populate slot context */
2175  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2176  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
2177  0, 0, 0 ) );
2178 }
#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:1166
#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 2188 of file xhci.c.

2190  {
2191  int rc;
2192 
2193  /* Deconfigure endpoint */
2194  if ( ( rc = xhci_context ( xhci, slot, endpoint,
2196  xhci_deconfigure_endpoint_input ) ) != 0 ) {
2197  DBGC ( xhci, "XHCI %s slot %d ctx %d could not deconfigure: "
2198  "%s\n", xhci->name, slot->id, endpoint->ctx,
2199  strerror ( rc ) );
2200  return rc;
2201  }
2202 
2203  DBGC2 ( xhci, "XHCI %s slot %d ctx %d deconfigured\n",
2204  xhci->name, slot->id, endpoint->ctx );
2205  return 0;
2206 }
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:1969
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:2162
unsigned int ctx
Context index.
Definition: xhci.h:1166
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 2216 of file xhci.c.

2219  {
2220  struct xhci_control_context *control_ctx;
2221  struct xhci_slot_context *slot_ctx;
2222  struct xhci_endpoint_context *ep_ctx;
2223 
2224  /* Populate control context */
2225  control_ctx = input;
2226  control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
2227  ( 1 << endpoint->ctx ) );
2228 
2229  /* Populate slot context */
2230  slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
2231  slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
2232  0, 0, 0 ) );
2233 
2234  /* Populate endpoint context */
2235  ep_ctx = ( input + xhci_input_context_offset ( xhci, endpoint->ctx ) );
2236  ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
2237 }
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:1166
#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:1164
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 2247 of file xhci.c.

2249  {
2250  int rc;
2251 
2252  /* Configure endpoint */
2253  if ( ( rc = xhci_context ( xhci, slot, endpoint,
2255  xhci_evaluate_context_input ) ) != 0 ) {
2256  DBGC ( xhci, "XHCI %s slot %d ctx %d could not (re-)evaluate: "
2257  "%s\n", xhci->name, slot->id, endpoint->ctx,
2258  strerror ( rc ) );
2259  return rc;
2260  }
2261 
2262  DBGC2 ( xhci, "XHCI %s slot %d ctx %d (re-)evaluated\n",
2263  xhci->name, slot->id, endpoint->ctx );
2264  return 0;
2265 }
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:2216
#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:1969
unsigned int ctx
Context index.
Definition: xhci.h:1166
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 2275 of file xhci.c.

2277  {
2278  union xhci_trb trb;
2279  struct xhci_trb_reset_endpoint *reset = &trb.reset;
2280  int rc;
2281 
2282  /* Construct command */
2283  memset ( reset, 0, sizeof ( *reset ) );
2284  reset->slot = slot->id;
2285  reset->endpoint = endpoint->ctx;
2286  reset->type = XHCI_TRB_RESET_ENDPOINT;
2287 
2288  /* Issue command and wait for completion */
2289  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
2290  DBGC ( xhci, "XHCI %s slot %d ctx %d could not reset endpoint "
2291  "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
2292  endpoint->context->state, strerror ( rc ) );
2293  return rc;
2294  }
2295 
2296  return 0;
2297 }
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:1811
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 2307 of file xhci.c.

2309  {
2310  union xhci_trb trb;
2311  struct xhci_trb_stop_endpoint *stop = &trb.stop;
2312  int rc;
2313 
2314  /* Construct command */
2315  memset ( stop, 0, sizeof ( *stop ) );
2316  stop->slot = slot->id;
2317  stop->endpoint = endpoint->ctx;
2318  stop->type = XHCI_TRB_STOP_ENDPOINT;
2319 
2320  /* Issue command and wait for completion */
2321  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
2322  DBGC ( xhci, "XHCI %s slot %d ctx %d could not stop endpoint "
2323  "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
2324  endpoint->context->state, strerror ( rc ) );
2325  return rc;
2326  }
2327 
2328  return 0;
2329 }
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.
Definition: xhci.h:564
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:556
A stop endpoint transfer request block.
Definition: xhci.h:548
static int xhci_command(struct xhci_device *xhci, union xhci_trb *trb)
Issue command and wait for completion.
Definition: xhci.c:1811
void * memset(void *dest, int character, size_t len) __nonnull

References DBGC, xhci_trb_stop_endpoint::endpoint, memset(), xhci_device::name, rc, slot, xhci_trb_stop_endpoint::slot, xhci_trb::stop, strerror(), xhci_trb_stop_endpoint::type, xhci_command(), and XHCI_TRB_STOP_ENDPOINT.

◆ xhci_set_tr_dequeue_pointer()

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

Set transfer ring dequeue pointer.

Parameters
xhcixHCI device
slotDevice slot
endpointEndpoint
Return values
rcReturn status code

Definition at line 2340 of file xhci.c.

2342  {
2343  union xhci_trb trb;
2344  struct xhci_trb_set_tr_dequeue_pointer *dequeue = &trb.dequeue;
2345  struct xhci_trb_ring *ring = &endpoint->ring;
2346  unsigned int cons;
2347  unsigned int mask;
2348  unsigned int index;
2349  unsigned int dcs;
2350  physaddr_t addr;
2351  int rc;
2352 
2353  /* Construct command */
2354  memset ( dequeue, 0, sizeof ( *dequeue ) );
2355  cons = ring->cons;
2356  mask = ring->mask;
2357  dcs = ( ( ~( cons >> ring->shift ) ) & XHCI_EP_DCS );
2358  index = ( cons & mask );
2359  addr = dma ( &ring->map, &ring->trb[index] );
2360  dequeue->dequeue = cpu_to_le64 ( addr | dcs );
2361  dequeue->slot = slot->id;
2362  dequeue->endpoint = endpoint->ctx;
2364 
2365  /* Issue command and wait for completion */
2366  if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
2367  DBGC ( xhci, "XHCI %s slot %d ctx %d could not set TR dequeue "
2368  "pointer in state %d: %s\n", xhci->name, slot->id,
2369  endpoint->ctx, endpoint->context->state, strerror ( rc));
2370  return rc;
2371  }
2372 
2373  return 0;
2374 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
#define XHCI_TRB_SET_TR_DEQUEUE_POINTER
A set transfer ring dequeue pointer transfer request block.
Definition: xhci.h:583
unsigned int cons
Consumer counter.
Definition: xhci.h:844
A set transfer ring dequeue pointer transfer request block.
Definition: xhci.h:567