xhci.c File Reference

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

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

Go to the source code of this file.

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

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	xhci_init (struct xhci_device *xhci, void *regs)
	Initialise device. More...
static unsigned int	xhci_extended_capability (struct xhci_device *xhci, unsigned int id, unsigned int offset)
	Find extended capability. More...
static int	xhci_writeq (struct xhci_device *xhci, physaddr_t value, void *reg)
	Write potentially 64-bit register. More...
static size_t	xhci_align (size_t len)
	Calculate buffer alignment. More...
static size_t	xhci_device_context_offset (struct xhci_device *xhci, unsigned int ctx)
	Calculate device context offset. More...
static size_t	xhci_input_context_offset (struct xhci_device *xhci, unsigned int ctx)
	Calculate input context offset. More...
static void	xhci_dump (struct xhci_device *xhci)
	Dump host controller registers. More...
static void	xhci_dump_port (struct xhci_device *xhci, unsigned int port)
	Dump port registers. More...
static void	xhci_legacy_init (struct xhci_device *xhci)
	Initialise USB legacy support. More...
static void	xhci_legacy_claim (struct xhci_device *xhci)
	Claim ownership from BIOS. More...
static void	xhci_legacy_release (struct xhci_device *xhci)
	Release ownership back to BIOS. More...
static const char *	xhci_speed_name (uint32_t psi)
	Transcribe port speed (for debugging) More...
static unsigned int	xhci_supported_protocol (struct xhci_device *xhci, unsigned int port)
	Find supported protocol extended capability for a port. More...
static unsigned int	xhci_port_protocol (struct xhci_device *xhci, unsigned int port)
	Find port protocol. More...
static int	xhci_port_slot_type (struct xhci_device *xhci, unsigned int port)
	Find port slot type. More...
static int	xhci_port_speed (struct xhci_device *xhci, unsigned int port, unsigned int psiv)
	Find port speed. More...
static int	xhci_port_psiv (struct xhci_device *xhci, unsigned int port, unsigned int speed)
	Find protocol speed ID value. More...
static int	xhci_dcbaa_alloc (struct xhci_device *xhci)
	Allocate device context base address array. More...
static void	xhci_dcbaa_free (struct xhci_device *xhci)
	Free device context base address array. More...
static int	xhci_scratchpad_alloc (struct xhci_device *xhci)
	Allocate scratchpad buffers. More...
static void	xhci_scratchpad_free (struct xhci_device *xhci)
	Free scratchpad buffers. More...
static void	xhci_run (struct xhci_device *xhci)
	Start xHCI device. More...
static int	xhci_stop (struct xhci_device *xhci)
	Stop xHCI device. More...
static int	xhci_reset (struct xhci_device *xhci)
	Reset xHCI device. More...
static int	xhci_fail (struct xhci_device *xhci)
	Mark xHCI device as permanently failed. More...
static int	xhci_ring_alloc (struct xhci_device *xhci, struct xhci_trb_ring *ring, unsigned int shift, unsigned int slot, unsigned int target, unsigned int stream)
	Allocate transfer request block ring. More...
static void	xhci_ring_reset (struct xhci_trb_ring *ring)
	Reset transfer request block ring. More...
static void	xhci_ring_free (struct xhci_trb_ring *ring)
	Free transfer request block ring. More...
static int	xhci_enqueue (struct xhci_trb_ring *ring, struct io_buffer *iobuf, const union xhci_trb *trb)
	Enqueue a transfer request block. More...
static struct io_buffer *	xhci_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_buffer *	xhci_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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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" )

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_USB, EIO_TRB, EIO_STALL, EIO_RESOURCE,            \
                  EIO_BANDWIDTH, EIO_NO_SLOTS, EIO_STREAM_TYPE,         \
                  EIO_SLOT, EIO_ENDPOINT, EIO_SHORT, EIO_UNDERRUN,      \
                  EIO_OVERRUN, EIO_VF_RING_FULL, EIO_PARAMETER,         \
                  EIO_BANDWIDTH_OVERRUN, EIO_CONTEXT, EIO_NO_PING,      \
                  EIO_RING_FULL, EIO_INCOMPATIBLE, EIO_MISSED,          \
                  EIO_CMD_STOPPED, EIO_CMD_ABORTED, EIO_STOP,           \
                  EIO_STOP_LEN, EIO_STOP_SHORT, EIO_LATENCY,            \
                  EIO_ISOCH ) :                                         \
          ( (code) < 64 ) ?                                             \
          EUNIQ ( EINFO_EPROTO, ( (code) & 31 ), EPROTO_LOST,           \
                  EPROTO_UNDEFINED, EPROTO_STREAM_ID,                   \
                  EPROTO_SECONDARY, EPROTO_SPLIT ) :                    \
          EFAULT )

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

xhci	xHCI device
regs	MMIO registers

Definition at line 264 of file xhci.c.

                                                               {
        uint32_t hcsparams1;
        uint32_t hcsparams2;
        uint32_t hccparams1;
        uint32_t pagesize;
        size_t caplength;
        size_t rtsoff;
        size_t dboff;

        /* Locate capability, operational, runtime, and doorbell registers */
        xhci->cap = regs;
        caplength = readb ( xhci->cap + XHCI_CAP_CAPLENGTH );
        rtsoff = readl ( xhci->cap + XHCI_CAP_RTSOFF );
        dboff = readl ( xhci->cap + XHCI_CAP_DBOFF );
        xhci->op = ( xhci->cap + caplength );
        xhci->run = ( xhci->cap + rtsoff );
        xhci->db = ( xhci->cap + dboff );
        DBGC2 ( xhci, "XHCI %s cap %08lx op %08lx run %08lx db %08lx\n",
                xhci->name, virt_to_phys ( xhci->cap ),
                virt_to_phys ( xhci->op ), virt_to_phys ( xhci->run ),
                virt_to_phys ( xhci->db ) );

        /* Read structural parameters 1 */
        hcsparams1 = readl ( xhci->cap + XHCI_CAP_HCSPARAMS1 );
        xhci->slots = XHCI_HCSPARAMS1_SLOTS ( hcsparams1 );
        xhci->intrs = XHCI_HCSPARAMS1_INTRS ( hcsparams1 );
        xhci->ports = XHCI_HCSPARAMS1_PORTS ( hcsparams1 );
        DBGC ( xhci, "XHCI %s has %d slots %d intrs %d ports\n",
               xhci->name, xhci->slots, xhci->intrs, xhci->ports );

        /* Read structural parameters 2 */
        hcsparams2 = readl ( xhci->cap + XHCI_CAP_HCSPARAMS2 );
        xhci->scratch.count = XHCI_HCSPARAMS2_SCRATCHPADS ( hcsparams2 );
        DBGC2 ( xhci, "XHCI %s needs %d scratchpads\n",
                xhci->name, xhci->scratch.count );

        /* Read capability parameters 1 */
        hccparams1 = readl ( xhci->cap + XHCI_CAP_HCCPARAMS1 );
        xhci->addr64 = XHCI_HCCPARAMS1_ADDR64 ( hccparams1 );
        xhci->csz_shift = XHCI_HCCPARAMS1_CSZ_SHIFT ( hccparams1 );
        xhci->xecp = XHCI_HCCPARAMS1_XECP ( hccparams1 );

        /* Read page size */
        pagesize = readl ( xhci->op + XHCI_OP_PAGESIZE );
        xhci->pagesize = XHCI_PAGESIZE ( pagesize );
        assert ( xhci->pagesize != 0 );
        assert ( ( ( xhci->pagesize ) & ( xhci->pagesize - 1 ) ) == 0 );
        DBGC2 ( xhci, "XHCI %s page size %zd bytes\n",
                xhci->name, xhci->pagesize );
}

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

xhci	xHCI device
id	Capability ID
offset	Offset to previous extended capability instance, or zero

Return values

offset

Offset to extended capability, or zero if not found

Definition at line 323 of file xhci.c.

                                                                     {
        uint32_t xecp;
        unsigned int next;

        /* Locate the extended capability */
        while ( 1 ) {

                /* Locate first or next capability as applicable */
                if ( offset ) {
                        xecp = readl ( xhci->cap + offset );
                        next = XHCI_XECP_NEXT ( xecp );
                } else {
                        next = xhci->xecp;
                }
                if ( ! next )
                        return 0;
                offset += next;

                /* Check if this is the requested capability */
                xecp = readl ( xhci->cap + offset );
                if ( XHCI_XECP_ID ( xecp ) == id )
                        return offset;
        }
}

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

xhci	xHCI device
value	Value
reg	Register address

Return values

rc	Return status code

Definition at line 359 of file xhci.c.

                                                                      {

        /* If this is a 32-bit build, then this can never fail
         * (allowing the compiler to optimise out the error path).
         */
        if ( sizeof ( value ) <= sizeof ( uint32_t ) ) {
                writel ( value, reg );
                writel ( 0, ( reg + sizeof ( uint32_t ) ) );
                return 0;
        }

        /* If the device does not support 64-bit addresses and this
         * address is outside the 32-bit address space, then fail.
         */
        if ( ( value & ~0xffffffffULL ) && ! xhci->addr64 ) {
                DBGC ( xhci, "XHCI %s cannot access address %lx\n",
                       xhci->name, value );
                return -ENOTSUP;
        }

        /* If this is a 64-bit build, then writeq() is available */
        writeq ( value, reg );
        return 0;
}

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

len

Length

Return values

align

Buffer 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.

                                               {
        size_t align;

        /* Align to own length (rounded up to a power of two) */
        align = ( 1 << fls ( len - 1 ) );

        /* Round up to XHCI_MIN_ALIGN if needed */
        if ( align < XHCI_MIN_ALIGN )
                align = XHCI_MIN_ALIGN;

        return align;
}

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

xhci	xHCI device
ctx	Context index

Definition at line 412 of file xhci.c.

                                                                     {

        return ( XHCI_DCI ( ctx ) << xhci->csz_shift );
}

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

xhci	xHCI device
ctx	Context index

Definition at line 424 of file xhci.c.

                                                                    {

        return ( XHCI_ICI ( ctx ) << xhci->csz_shift );
}

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

xhci	xHCI device

Definition at line 442 of file xhci.c.

                                                          {
        uint32_t usbcmd;
        uint32_t usbsts;
        uint32_t pagesize;
        uint32_t dnctrl;
        uint32_t config;

        /* Do nothing unless debugging is enabled */
        if ( ! DBG_LOG )
                return;

        /* Dump USBCMD */
        usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
        DBGC ( xhci, "XHCI %s USBCMD %08x%s%s\n", xhci->name, usbcmd,
               ( ( usbcmd & XHCI_USBCMD_RUN ) ? " run" : "" ),
               ( ( usbcmd & XHCI_USBCMD_HCRST ) ? " hcrst" : "" ) );

        /* Dump USBSTS */
        usbsts = readl ( xhci->op + XHCI_OP_USBSTS );
        DBGC ( xhci, "XHCI %s USBSTS %08x%s\n", xhci->name, usbsts,
               ( ( usbsts & XHCI_USBSTS_HCH ) ? " hch" : "" ) );

        /* Dump PAGESIZE */
        pagesize = readl ( xhci->op + XHCI_OP_PAGESIZE );
        DBGC ( xhci, "XHCI %s PAGESIZE %08x\n", xhci->name, pagesize );

        /* Dump DNCTRL */
        dnctrl = readl ( xhci->op + XHCI_OP_DNCTRL );
        DBGC ( xhci, "XHCI %s DNCTRL %08x\n", xhci->name, dnctrl );

        /* Dump CONFIG */
        config = readl ( xhci->op + XHCI_OP_CONFIG );
        DBGC ( xhci, "XHCI %s CONFIG %08x\n", xhci->name, config );
}

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

xhci	xHCI device
port	Port number

Definition at line 483 of file xhci.c.

                                                        {
        uint32_t portsc;
        uint32_t portpmsc;
        uint32_t portli;
        uint32_t porthlpmc;

        /* Do nothing unless debugging is enabled */
        if ( ! DBG_LOG )
                return;

        /* Dump PORTSC */
        portsc = readl ( xhci->op + XHCI_OP_PORTSC ( port ) );
        DBGC ( xhci, "XHCI %s-%d PORTSC %08x%s%s%s%s psiv=%d\n",
               xhci->name, port, portsc,
               ( ( portsc & XHCI_PORTSC_CCS ) ? " ccs" : "" ),
               ( ( portsc & XHCI_PORTSC_PED ) ? " ped" : "" ),
               ( ( portsc & XHCI_PORTSC_PR ) ? " pr" : "" ),
               ( ( portsc & XHCI_PORTSC_PP ) ? " pp" : "" ),
               XHCI_PORTSC_PSIV ( portsc ) );

        /* Dump PORTPMSC */
        portpmsc = readl ( xhci->op + XHCI_OP_PORTPMSC ( port ) );
        DBGC ( xhci, "XHCI %s-%d PORTPMSC %08x\n", xhci->name, port, portpmsc );

        /* Dump PORTLI */
        portli = readl ( xhci->op + XHCI_OP_PORTLI ( port ) );
        DBGC ( xhci, "XHCI %s-%d PORTLI %08x\n", xhci->name, port, portli );

        /* Dump PORTHLPMC */
        porthlpmc = readl ( xhci->op + XHCI_OP_PORTHLPMC ( port ) );
        DBGC ( xhci, "XHCI %s-%d PORTHLPMC %08x\n",
               xhci->name, port, porthlpmc );
}

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

xhci	xHCI device

Definition at line 533 of file xhci.c.

                                                          {
        unsigned int legacy;
        uint8_t bios;

        /* Locate USB legacy support capability (if present) */
        legacy = xhci_extended_capability ( xhci, XHCI_XECP_ID_LEGACY, 0 );
        if ( ! legacy ) {
                /* Not an error; capability may not be present */
                DBGC ( xhci, "XHCI %s has no USB legacy support capability\n",
                       xhci->name );
                return;
        }

        /* Check if legacy USB support is enabled */
        bios = readb ( xhci->cap + legacy + XHCI_USBLEGSUP_BIOS );
        if ( ! ( bios & XHCI_USBLEGSUP_BIOS_OWNED ) ) {
                /* Not an error; already owned by OS */
                DBGC ( xhci, "XHCI %s USB legacy support already disabled\n",
                       xhci->name );
                return;
        }

        /* Record presence of USB legacy support capability */
        xhci->legacy = legacy;
}

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

xhci	xHCI device

Definition at line 564 of file xhci.c.

                                                           {
        uint32_t ctlsts;
        uint8_t bios;
        unsigned int i;

        /* Do nothing unless legacy support capability is present */
        if ( ! xhci->legacy )
                return;

        /* Claim ownership */
        writeb ( XHCI_USBLEGSUP_OS_OWNED,
                 xhci->cap + xhci->legacy + XHCI_USBLEGSUP_OS );

        /* Wait for BIOS to release ownership */
        for ( i = 0 ; i < XHCI_USBLEGSUP_MAX_WAIT_MS ; i++ ) {

                /* Check if BIOS has released ownership */
                bios = readb ( xhci->cap + xhci->legacy + XHCI_USBLEGSUP_BIOS );
                if ( ! ( bios & XHCI_USBLEGSUP_BIOS_OWNED ) ) {
                        DBGC ( xhci, "XHCI %s claimed ownership from BIOS\n",
                               xhci->name );
                        ctlsts = readl ( xhci->cap + xhci->legacy +
                                         XHCI_USBLEGSUP_CTLSTS );
                        if ( ctlsts ) {
                                DBGC ( xhci, "XHCI %s warning: BIOS retained "
                                       "SMIs: %08x\n", xhci->name, ctlsts );
                        }
                        return;
                }

                /* Delay */
                mdelay ( 1 );
        }

        /* BIOS did not release ownership.  Claim it forcibly by
         * disabling all SMIs.
         */
        DBGC ( xhci, "XHCI %s could not claim ownership from BIOS: forcibly "
               "disabling SMIs\n", xhci->name );
        writel ( 0, xhci->cap + xhci->legacy + XHCI_USBLEGSUP_CTLSTS );
}

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

xhci	xHCI device

Definition at line 611 of file xhci.c.

                                                             {

        /* Do nothing unless legacy support capability is present */
        if ( ! xhci->legacy )
                return;

        /* Do nothing if releasing ownership is prevented */
        if ( xhci_legacy_prevent_release ) {
                DBGC ( xhci, "XHCI %s not releasing ownership to BIOS\n",
                       xhci->name );
                return;
        }

        /* Release ownership */
        writeb ( 0, xhci->cap + xhci->legacy + XHCI_USBLEGSUP_OS );
        DBGC ( xhci, "XHCI %s released ownership to BIOS\n", xhci->name );
}

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

psi	Protocol speed ID

Return values

speed

Transcribed speed

Definition at line 642 of file xhci.c.

                                                            {
        static const char *exponents[4] = { "", "k", "M", "G" };
        static char buf[ 10 /* "xxxxxXbps" + NUL */ ];
        unsigned int mantissa;
        unsigned int exponent;

        /* Extract mantissa and exponent */
        mantissa = XHCI_SUPPORTED_PSI_MANTISSA ( psi );
        exponent = XHCI_SUPPORTED_PSI_EXPONENT ( psi );

        /* Transcribe speed */
        snprintf ( buf, sizeof ( buf ), "%d%sbps",
                   mantissa, exponents[exponent] );
        return buf;
}

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

xhci	xHCI device
port	Port number

Return values

supported

Offset to extended capability, or zero if not found

Definition at line 665 of file xhci.c.

                                                                  {
        unsigned int supported = 0;
        unsigned int offset;
        unsigned int count;
        uint32_t ports;

        /* Iterate over all supported protocol structures */
        while ( ( supported = xhci_extended_capability ( xhci,
                                                         XHCI_XECP_ID_SUPPORTED,
                                                         supported ) ) ) {

                /* Determine port range */
                ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
                offset = XHCI_SUPPORTED_PORTS_OFFSET ( ports );
                count = XHCI_SUPPORTED_PORTS_COUNT ( ports );

                /* Check if port lies within this range */
                if ( ( port - offset ) < count )
                        return supported;
        }

        DBGC ( xhci, "XHCI %s-%d has no supported protocol\n",
               xhci->name, port );
        return 0;
}

References xhci_device::cap, count, DBGC, xhci_device::name, offset, port, readl(), supported, 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

xhci	xHCI device
port	Port number

Return values

protocol

USB protocol, or zero if not found

Definition at line 699 of file xhci.c.

                                                             {
        unsigned int supported = xhci_supported_protocol ( xhci, port );
        union {
                uint32_t raw;
                char text[5];
        } name;
        unsigned int protocol;
        unsigned int type;
        unsigned int psic;
        unsigned int psiv;
        unsigned int i;
        uint32_t revision;
        uint32_t ports;
        uint32_t slot;
        uint32_t psi;

        /* Fail if there is no supported protocol */
        if ( ! supported )
                return 0;

        /* Determine protocol version */
        revision = readl ( xhci->cap + supported + XHCI_SUPPORTED_REVISION );
        protocol = XHCI_SUPPORTED_REVISION_VER ( revision );

        /* Describe port protocol */
        if ( DBG_EXTRA ) {
                name.raw = cpu_to_le32 ( readl ( xhci->cap + supported +
                                                 XHCI_SUPPORTED_NAME ) );
                name.text[4] = '\0';
                slot = readl ( xhci->cap + supported + XHCI_SUPPORTED_SLOT );
                type = XHCI_SUPPORTED_SLOT_TYPE ( slot );
                DBGC2 ( xhci, "XHCI %s-%d %sv%04x type %d",
                        xhci->name, port, name.text, protocol, type );
                ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
                psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );
                if ( psic ) {
                        DBGC2 ( xhci, " speeds" );
                        for ( i = 0 ; i < psic ; i++ ) {
                                psi = readl ( xhci->cap + supported +
                                              XHCI_SUPPORTED_PSI ( i ) );
                                psiv = XHCI_SUPPORTED_PSI_VALUE ( psi );
                                DBGC2 ( xhci, " %d:%s", psiv,
                                        xhci_speed_name ( psi ) );
                        }
                }
                if ( xhci->quirks & XHCI_BAD_PSIV )
                        DBGC2 ( xhci, " (ignored)" );
                DBGC2 ( xhci, "\n" );
        }

        return protocol;
}

References xhci_device::cap, cpu_to_le32, DBG_EXTRA, DBGC2, xhci_device::name, name, port, protocol, xhci_device::quirks, raw, readl(), revision, slot, supported, 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

xhci	xHCI device
port	Port number

Return values

type	Slot type, or negative error

Definition at line 760 of file xhci.c.

                                                                               {
        unsigned int supported = xhci_supported_protocol ( xhci, port );
        unsigned int type;
        uint32_t slot;

        /* Fail if there is no supported protocol */
        if ( ! supported )
                return -ENOTSUP;

        /* Get slot type */
        slot = readl ( xhci->cap + supported + XHCI_SUPPORTED_SLOT );
        type = XHCI_SUPPORTED_SLOT_TYPE ( slot );

        return type;
}

References xhci_device::cap, ENOTSUP, port, readl(), slot, supported, 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

xhci	xHCI device
port	Port number
psiv	Protocol speed ID value

Return values

speed

Port speed, or negative error

Definition at line 784 of file xhci.c.

                                                 {
        unsigned int supported = xhci_supported_protocol ( xhci, port );
        unsigned int psic;
        unsigned int mantissa;
        unsigned int exponent;
        unsigned int speed;
        unsigned int i;
        uint32_t ports;
        uint32_t psi;

        /* Fail if there is no supported protocol */
        if ( ! supported )
                return -ENOTSUP;

        /* Get protocol speed ID count */
        ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
        psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );

        /* Use protocol speed ID table unless device is known to be faulty */
        if ( ! ( xhci->quirks & XHCI_BAD_PSIV ) ) {

                /* Iterate over PSI dwords looking for a match */
                for ( i = 0 ; i < psic ; i++ ) {
                        psi = readl ( xhci->cap + supported +
                                      XHCI_SUPPORTED_PSI ( i ) );
                        if ( psiv == XHCI_SUPPORTED_PSI_VALUE ( psi ) ) {
                                mantissa = XHCI_SUPPORTED_PSI_MANTISSA ( psi );
                                exponent = XHCI_SUPPORTED_PSI_EXPONENT ( psi );
                                speed = USB_SPEED ( mantissa, exponent );
                                return speed;
                        }
                }

                /* Record device as faulty if no match is found */
                if ( psic != 0 ) {
                        DBGC ( xhci, "XHCI %s-%d spurious PSI value %d: "
                               "assuming PSI table is invalid\n",
                               xhci->name, port, psiv );
                        xhci->quirks |= XHCI_BAD_PSIV;
                }
        }

        /* Use the default mappings */
        switch ( psiv ) {
        case XHCI_SPEED_LOW :   return USB_SPEED_LOW;
        case XHCI_SPEED_FULL :  return USB_SPEED_FULL;
        case XHCI_SPEED_HIGH :  return USB_SPEED_HIGH;
        case XHCI_SPEED_SUPER : return USB_SPEED_SUPER;
        default:
                DBGC ( xhci, "XHCI %s-%d unrecognised PSI value %d\n",
                       xhci->name, port, psiv );
                return -ENOTSUP;
        }
}

References xhci_device::cap, DBGC, ENOTSUP, xhci_device::name, port, xhci_device::quirks, readl(), supported, 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

xhci	xHCI device
port	Port number
speed	USB speed

Return values

psiv	Protocol speed ID value, or negative error

Definition at line 848 of file xhci.c.

                                                 {
        unsigned int supported = xhci_supported_protocol ( xhci, port );
        unsigned int psic;
        unsigned int mantissa;
        unsigned int exponent;
        unsigned int psiv;
        unsigned int i;
        uint32_t ports;
        uint32_t psi;

        /* Fail if there is no supported protocol */
        if ( ! supported )
                return -ENOTSUP;

        /* Get protocol speed ID count */
        ports = readl ( xhci->cap + supported + XHCI_SUPPORTED_PORTS );
        psic = XHCI_SUPPORTED_PORTS_PSIC ( ports );

        /* Use the default mappings if applicable */
        if ( ( psic == 0 ) || ( xhci->quirks & XHCI_BAD_PSIV ) ) {
                switch ( speed ) {
                case USB_SPEED_LOW :    return XHCI_SPEED_LOW;
                case USB_SPEED_FULL :   return XHCI_SPEED_FULL;
                case USB_SPEED_HIGH :   return XHCI_SPEED_HIGH;
                case USB_SPEED_SUPER :  return XHCI_SPEED_SUPER;
                default:
                        DBGC ( xhci, "XHCI %s-%d non-standard speed %d\n",
                               xhci->name, port, speed );
                        return -ENOTSUP;
                }
        }

        /* Iterate over PSI dwords looking for a match */
        for ( i = 0 ; i < psic ; i++ ) {
                psi = readl ( xhci->cap + supported + XHCI_SUPPORTED_PSI ( i ));
                mantissa = XHCI_SUPPORTED_PSI_MANTISSA ( psi );
                exponent = XHCI_SUPPORTED_PSI_EXPONENT ( psi );
                if ( speed == USB_SPEED ( mantissa, exponent ) ) {
                        psiv = XHCI_SUPPORTED_PSI_VALUE ( psi );
                        return psiv;
                }
        }

        DBGC ( xhci, "XHCI %s-%d unrepresentable speed %#x\n",
               xhci->name, port, speed );
        return -ENOENT;
}

References xhci_device::cap, DBGC, ENOENT, ENOTSUP, xhci_device::name, port, xhci_device::quirks, readl(), supported, 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

xhci	xHCI device

Return values

rc	Return status code

Definition at line 910 of file xhci.c.

                                                         {
        size_t len;
        physaddr_t dcbaap;
        int rc;

        /* Allocate and initialise structure.  Must be at least
         * 64-byte aligned and must not cross a page boundary, so
         * align on its own size (rounded up to a power of two and
         * with a minimum of 64 bytes).
         */
        len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa.context[0] ) );
        xhci->dcbaa.context = dma_alloc ( xhci->dma, &xhci->dcbaa.map, len,
                                          xhci_align ( len ) );
        if ( ! xhci->dcbaa.context ) {
                DBGC ( xhci, "XHCI %s could not allocate DCBAA\n", xhci->name );
                rc = -ENOMEM;
                goto err_alloc;
        }
        memset ( xhci->dcbaa.context, 0, len );

        /* Program DCBAA pointer */
        dcbaap = dma ( &xhci->dcbaa.map, xhci->dcbaa.context );
        if ( ( rc = xhci_writeq ( xhci, dcbaap,
                                  xhci->op + XHCI_OP_DCBAAP ) ) != 0 )
                goto err_writeq;

        DBGC2 ( xhci, "XHCI %s DCBAA at [%08lx,%08lx)\n", xhci->name,
                virt_to_phys ( xhci->dcbaa.context ),
                ( virt_to_phys ( xhci->dcbaa.context ) + len ) );
        return 0;

 err_writeq:
        dma_free ( &xhci->dcbaa.map, xhci->dcbaa.context, len );
 err_alloc:
        return rc;
}

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

xhci	xHCI device

Definition at line 952 of file xhci.c.

                                                         {
        size_t len;
        unsigned int i;

        /* Sanity check */
        for ( i = 0 ; i <= xhci->slots ; i++ )
                assert ( xhci->dcbaa.context[i] == 0 );

        /* Clear DCBAA pointer */
        xhci_writeq ( xhci, 0, xhci->op + XHCI_OP_DCBAAP );

        /* Free DCBAA */
        len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa.context[0] ) );
        dma_free ( &xhci->dcbaa.map, xhci->dcbaa.context, len );
}

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

xhci	xHCI device

Return values

rc	Return status code

Definition at line 981 of file xhci.c.

                                                              {
        struct xhci_scratchpad *scratch = &xhci->scratch;
        size_t buffer_len;
        size_t array_len;
        physaddr_t addr;
        unsigned int i;
        int rc;

        /* Do nothing if no scratchpad buffers are used */
        if ( ! scratch->count )
                return 0;

        /* Allocate scratchpad buffers */
        buffer_len = ( scratch->count * xhci->pagesize );
        scratch->buffer = dma_umalloc ( xhci->dma, &scratch->buffer_map,
                                        buffer_len, xhci->pagesize );
        if ( ! scratch->buffer ) {
                DBGC ( xhci, "XHCI %s could not allocate scratchpad buffers\n",
                       xhci->name );
                rc = -ENOMEM;
                goto err_alloc;
        }
        memset_user ( scratch->buffer, 0, 0, buffer_len );

        /* Allocate scratchpad array */
        array_len = ( scratch->count * sizeof ( scratch->array[0] ) );
        scratch->array = dma_alloc ( xhci->dma, &scratch->array_map,
                                     array_len, xhci_align ( array_len ) );
        if ( ! scratch->array ) {
                DBGC ( xhci, "XHCI %s could not allocate scratchpad buffer "
                       "array\n", xhci->name );
                rc = -ENOMEM;
                goto err_alloc_array;
        }

        /* Populate scratchpad array */
        addr = dma_phys ( &scratch->buffer_map,
                          user_to_phys ( scratch->buffer, 0 ) );
        for ( i = 0 ; i < scratch->count ; i++ ) {
                scratch->array[i] = cpu_to_le64 ( addr );
                addr += xhci->pagesize;
        }

        /* Set scratchpad array pointer */
        assert ( xhci->dcbaa.context != NULL );
        xhci->dcbaa.context[0] = cpu_to_le64 ( dma ( &scratch->array_map,
                                                     scratch->array ) );

        DBGC2 ( xhci, "XHCI %s scratchpad [%08lx,%08lx) array [%08lx,%08lx)\n",
                xhci->name, user_to_phys ( scratch->buffer, 0 ),
                user_to_phys ( scratch->buffer, buffer_len ),
                virt_to_phys ( scratch->array ),
                ( virt_to_phys ( scratch->array ) + array_len ) );
        return 0;

        dma_free ( &scratch->array_map, scratch->array, array_len );
 err_alloc_array:
        dma_ufree ( &scratch->buffer_map, scratch->buffer, buffer_len );
 err_alloc:
        return rc;
}

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

xhci	xHCI device

Definition at line 1048 of file xhci.c.

                                                              {
        struct xhci_scratchpad *scratch = &xhci->scratch;
        size_t array_len;
        size_t buffer_len;

        /* Do nothing if no scratchpad buffers are used */
        if ( ! scratch->count )
                return;

        /* Clear scratchpad array pointer */
        assert ( xhci->dcbaa.context != NULL );
        xhci->dcbaa.context[0] = 0;

        /* Free scratchpad array */
        array_len = ( scratch->count * sizeof ( scratch->array[0] ) );
        dma_free ( &scratch->array_map, scratch->array, array_len );

        /* Free scratchpad buffers */
        buffer_len = ( scratch->count * xhci->pagesize );
        dma_ufree ( &scratch->buffer_map, scratch->buffer, buffer_len );
}

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

xhci	xHCI device

Definition at line 1082 of file xhci.c.

                                                  {
        uint32_t config;
        uint32_t usbcmd;

        /* Configure number of device slots */
        config = readl ( xhci->op + XHCI_OP_CONFIG );
        config &= ~XHCI_CONFIG_MAX_SLOTS_EN_MASK;
        config |= XHCI_CONFIG_MAX_SLOTS_EN ( xhci->slots );
        writel ( config, xhci->op + XHCI_OP_CONFIG );

        /* Set run/stop bit */
        usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
        usbcmd |= XHCI_USBCMD_RUN;
        writel ( usbcmd, xhci->op + XHCI_OP_USBCMD );
}

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

xhci	xHCI device

Return values

rc	Return status code

Definition at line 1104 of file xhci.c.

                                                  {
        uint32_t usbcmd;
        uint32_t usbsts;
        unsigned int i;

        /* Clear run/stop bit */
        usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
        usbcmd &= ~XHCI_USBCMD_RUN;
        writel ( usbcmd, xhci->op + XHCI_OP_USBCMD );

        /* Wait for device to stop */
        for ( i = 0 ; i < XHCI_STOP_MAX_WAIT_MS ; i++ ) {

                /* Check if device is stopped */
                usbsts = readl ( xhci->op + XHCI_OP_USBSTS );
                if ( usbsts & XHCI_USBSTS_HCH )
                        return 0;

                /* Delay */
                mdelay ( 1 );
        }

        DBGC ( xhci, "XHCI %s timed out waiting for stop\n", xhci->name );
        return -ETIMEDOUT;
}

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

xhci	xHCI device

Return values

rc	Return status code

Definition at line 1136 of file xhci.c.

                                                   {
        uint32_t usbcmd;
        unsigned int i;
        int rc;

        /* The xHCI specification states that resetting a running
         * device may result in undefined behaviour, so try stopping
         * it first.
         */
        if ( ( rc = xhci_stop ( xhci ) ) != 0 ) {
                /* Ignore errors and attempt to reset the device anyway */
        }

        /* Reset device */
        writel ( XHCI_USBCMD_HCRST, xhci->op + XHCI_OP_USBCMD );

        /* Wait for reset to complete */
        for ( i = 0 ; i < XHCI_RESET_MAX_WAIT_MS ; i++ ) {

                /* Check if reset is complete */
                usbcmd = readl ( xhci->op + XHCI_OP_USBCMD );
                if ( ! ( usbcmd & XHCI_USBCMD_HCRST ) )
                        return 0;

                /* Delay */
                mdelay ( 1 );
        }

        DBGC ( xhci, "XHCI %s timed out waiting for reset\n", xhci->name );
        return -ETIMEDOUT;
}

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

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

xhci_fail()

static int xhci_fail ( struct xhci_device *  xhci )

static

Mark xHCI device as permanently failed.

Parameters

xhci	xHCI device

Return values

rc	Return status code

Definition at line 1174 of file xhci.c.

                                                  {
        size_t len;
        int rc;

        /* Mark command mechanism as permanently failed */
        xhci->failed = 1;

        /* Reset device */
        if ( ( rc = xhci_reset ( xhci ) ) != 0 )
                return rc;

        /* Discard DCBAA entries since DCBAAP has been cleared */
        assert ( xhci->dcbaa.context != NULL );
        len = ( ( xhci->slots + 1 ) * sizeof ( xhci->dcbaa.context[0] ) );
        memset ( xhci->dcbaa.context, 0, len );

        return 0;
}

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

Referenced by xhci_abort(), and xhci_remove().

xhci_ring_alloc()

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

static

Allocate transfer request block ring.

Parameters

xhci	xHCI device
ring	TRB ring
shift	Ring size (log2)
slot	Device slot
target	Doorbell target
stream	Doorbell stream ID

Return values

rc	Return status code

Definition at line 1211 of file xhci.c.

                                                                        {
        struct xhci_trb_link *link;
        unsigned int count;
        int rc;

        /* Sanity check */
        assert ( shift > 0 );

        /* Initialise structure */
        memset ( ring, 0, sizeof ( *ring ) );
        ring->shift = shift;
        count = ( 1U << shift );
        ring->mask = ( count - 1 );
        ring->len = ( ( count + 1 /* Link TRB */ ) * sizeof ( ring->trb[0] ) );
        ring->db = ( xhci->db + ( slot * sizeof ( ring->dbval ) ) );
        ring->dbval = XHCI_DBVAL ( target, stream );

        /* Allocate I/O buffers */
        ring->iobuf = zalloc ( count * sizeof ( ring->iobuf[0] ) );
        if ( ! ring->iobuf ) {
                rc = -ENOMEM;
                goto err_alloc_iobuf;
        }

        /* Allocate TRBs */
        ring->trb = dma_alloc ( xhci->dma, &ring->map, ring->len,
                                xhci_align ( ring->len ) );
        if ( ! ring->trb ) {
                rc = -ENOMEM;
                goto err_alloc_trb;
        }
        memset ( ring->trb, 0, ring->len );

        /* Initialise Link TRB */
        link = &ring->trb[count].link;
        link->next = cpu_to_le64 ( dma ( &ring->map, ring->trb ) );
        link->flags = XHCI_TRB_TC;
        link->type = XHCI_TRB_LINK;
        ring->link = link;

        return 0;

        dma_free ( &ring->map, ring->trb, ring->len );
 err_alloc_trb:
        free ( ring->iobuf );
 err_alloc_iobuf:
        return rc;
}

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

ring

TRB ring

Definition at line 1268 of file xhci.c.

                                                           {
        unsigned int count = ( 1U << ring->shift );

        /* Reset producer and consumer counters */
        ring->prod = 0;
        ring->cons = 0;

        /* Reset TRBs (except Link TRB) */
        memset ( ring->trb, 0, ( count * sizeof ( ring->trb[0] ) ) );
}

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

ring

TRB ring

Definition at line 1284 of file xhci.c.

                                                          {
        unsigned int count = ( 1U << ring->shift );
        unsigned int i;

        /* Sanity checks */
        assert ( ring->cons == ring->prod );
        for ( i = 0 ; i < count ; i++ )
                assert ( ring->iobuf[i] == NULL );

        /* Free TRBs */
        dma_free ( &ring->map, ring->trb, ring->len );

        /* Free I/O buffers */
        free ( ring->iobuf );
}

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

ring	TRB ring
iobuf	I/O buffer (if any)
trb	Transfer request block (with empty Cycle flag)

Return values

rc	Return status code

This operation does not implicitly ring the doorbell register.

Definition at line 1310 of file xhci.c.

                                                      {
        union xhci_trb *dest;
        unsigned int prod;
        unsigned int mask;
        unsigned int index;
        unsigned int cycle;

        /* Sanity check */
        assert ( ! ( trb->common.flags & XHCI_TRB_C ) );

        /* Fail if ring is full */
        if ( ! xhci_ring_remaining ( ring ) )
                return -ENOBUFS;

        /* Update producer counter (and link TRB, if applicable) */
        prod = ring->prod++;
        mask = ring->mask;
        cycle = ( ( ~( prod >> ring->shift ) ) & XHCI_TRB_C );
        index = ( prod & mask );
        if ( index == 0 )
                ring->link->flags = ( XHCI_TRB_TC | ( cycle ^ XHCI_TRB_C ) );

        /* Record I/O buffer */
        ring->iobuf[index] = iobuf;

        /* Enqueue TRB */
        dest = &ring->trb[index];
        dest->template.parameter = trb->template.parameter;
        dest->template.status = trb->template.status;
        wmb();
        dest->template.control = ( trb->template.control |
                                   cpu_to_le32 ( cycle ) );

        return 0;
}

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

ring

TRB ring

Return values

iobuf

I/O buffer

Definition at line 1353 of file xhci.c.

                                                                      {
        struct io_buffer *iobuf;
        unsigned int cons;
        unsigned int mask;
        unsigned int index;

        /* Sanity check */
        assert ( xhci_ring_fill ( ring ) != 0 );

        /* Update consumer counter */
        cons = ring->cons++;
        mask = ring->mask;
        index = ( cons & mask );

        /* Retrieve I/O buffer */
        iobuf = ring->iobuf[index];
        ring->iobuf[index] = NULL;

        return iobuf;
}

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

ring	TRB ring
iobuf	I/O buffer
trbs	Transfer request blocks (with empty Cycle flag)
count	Number of transfer request blocks

Return values

rc	Return status code

This operation does not implicitly ring the doorbell register.

Definition at line 1385 of file xhci.c.

                                                     {
        const union xhci_trb *trb = trbs;
        int rc;

        /* Sanity check */
        assert ( iobuf != NULL );

        /* Fail if ring does not have sufficient space */
        if ( xhci_ring_remaining ( ring ) < count )
                return -ENOBUFS;

        /* Enqueue each TRB, recording the I/O buffer with the final TRB */
        while ( count-- ) {
                rc = xhci_enqueue ( ring, ( count ? NULL : iobuf ), trb++ );
                assert ( rc == 0 ); /* Should never be able to fail */
        }

        return 0;
}

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

ring

TRB ring

Return values

iobuf

I/O buffer

Definition at line 1414 of file xhci.c.

                                                                            {
        struct io_buffer *iobuf;

        /* Dequeue TRBs until we reach the final TRB for an I/O buffer */
        do {
                iobuf = xhci_dequeue ( ring );
        } while ( iobuf == NULL );

        return iobuf;
}

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

ring

TRB ring

Definition at line 1431 of file xhci.c.

                                             {

        wmb();
        writel ( ring->dbval, ring->db );
}

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

xhci	xHCI device

Return values

rc	Return status code

Definition at line 1450 of file xhci.c.

                                                           {
        physaddr_t crp;
        int rc;

        /* Allocate TRB ring */
        if ( ( rc = xhci_ring_alloc ( xhci, &xhci->command, XHCI_CMD_TRBS_LOG2,
                                      0, 0, 0 ) ) != 0 )
                goto err_ring_alloc;

        /* Program command ring control register */
        crp = dma ( &xhci->command.map, xhci->command.trb );
        if ( ( rc = xhci_writeq ( xhci, ( crp | XHCI_CRCR_RCS ),
                                  xhci->op + XHCI_OP_CRCR ) ) != 0 )
                goto err_writeq;

        DBGC2 ( xhci, "XHCI %s CRCR at [%08lx,%08lx)\n", xhci->name,
                virt_to_phys ( xhci->command.trb ),
                ( virt_to_phys ( xhci->command.trb ) + xhci->command.len ) );
        return 0;

 err_writeq:
        xhci_ring_free ( &xhci->command );
 err_ring_alloc:
        return rc;
}

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

xhci	xHCI device

Definition at line 1481 of file xhci.c.

                                                           {

        /* Sanity check */
        assert ( ( readl ( xhci->op + XHCI_OP_CRCR ) & XHCI_CRCR_CRR ) == 0 );

        /* Clear command ring control register */
        xhci_writeq ( xhci, 0, xhci->op + XHCI_OP_CRCR );

        /* Free TRB ring */
        xhci_ring_free ( &xhci->command );
}

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

xhci	xHCI device

Return values

rc	Return status code

Definition at line 1499 of file xhci.c.

                                                         {
        struct xhci_event_ring *event = &xhci->event;
        unsigned int count;
        size_t len;
        int rc;

        /* Allocate event ring */
        count = ( 1 << XHCI_EVENT_TRBS_LOG2 );
        len = ( count * sizeof ( event->trb[0] ) );
        event->trb = dma_alloc ( xhci->dma, &event->trb_map, len,
                                 xhci_align ( len ) );
        if ( ! event->trb ) {
                rc = -ENOMEM;
                goto err_alloc_trb;
        }
        memset ( event->trb, 0, len );

        /* Allocate event ring segment table */
        event->segment = dma_alloc ( xhci->dma, &event->segment_map,
                                     sizeof ( event->segment[0] ),
                                     xhci_align ( sizeof (event->segment[0])));
        if ( ! event->segment ) {
                rc = -ENOMEM;
                goto err_alloc_segment;
        }
        memset ( event->segment, 0, sizeof ( event->segment[0] ) );
        event->segment[0].base = cpu_to_le64 ( dma ( &event->trb_map,
                                                     event->trb ) );
        event->segment[0].count = cpu_to_le32 ( count );

        /* Program event ring registers */
        writel ( 1, xhci->run + XHCI_RUN_ERSTSZ ( 0 ) );
        if ( ( rc = xhci_writeq ( xhci, dma ( &event->trb_map, event->trb ),
                                  xhci->run + XHCI_RUN_ERDP ( 0 ) ) ) != 0 )
                goto err_writeq_erdp;
        if ( ( rc = xhci_writeq ( xhci,
                                  dma ( &event->segment_map, event->segment ),
                                  xhci->run + XHCI_RUN_ERSTBA ( 0 ) ) ) != 0 )
                goto err_writeq_erstba;

        DBGC2 ( xhci, "XHCI %s event ring [%08lx,%08lx) table [%08lx,%08lx)\n",
                xhci->name, virt_to_phys ( event->trb ),
                ( virt_to_phys ( event->trb ) + len ),
                virt_to_phys ( event->segment ),
                ( virt_to_phys ( event->segment ) +
                  sizeof ( event->segment[0] ) ) );
        return 0;

        xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERSTBA ( 0 ) );
 err_writeq_erstba:
        xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERDP ( 0 ) );
 err_writeq_erdp:
        dma_free ( &event->segment_map, event->segment,
                   sizeof ( event->segment[0] ) );
 err_alloc_segment:
        dma_free ( &event->trb_map, event->trb, len );
 err_alloc_trb:
        return rc;
}

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

xhci	xHCI device

Definition at line 1564 of file xhci.c.

                                                         {
        struct xhci_event_ring *event = &xhci->event;
        unsigned int count;
        size_t len;

        /* Clear event ring registers */
        writel ( 0, xhci->run + XHCI_RUN_ERSTSZ ( 0 ) );
        xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERSTBA ( 0 ) );
        xhci_writeq ( xhci, 0, xhci->run + XHCI_RUN_ERDP ( 0 ) );

        /* Free event ring segment table */
        dma_free ( &event->segment_map, event->segment,
                   sizeof ( event->segment[0] ) );

        /* Free event ring */
        count = ( 1 << XHCI_EVENT_TRBS_LOG2 );
        len = ( count * sizeof ( event->trb[0] ) );
        dma_free ( &event->trb_map, event->trb, len );
}

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

xhci	xHCI device
trb	Transfer event TRB

Definition at line 1590 of file xhci.c.

                                                            {
        struct xhci_slot *slot;
        struct xhci_endpoint *endpoint;
        struct io_buffer *iobuf;
        int rc;

        /* Profile transfer events */
        profile_start ( &xhci_transfer_profiler );

        /* Identify slot */
        if ( ( trb->slot > xhci->slots ) ||
             ( ( slot = xhci->slot[trb->slot] ) == NULL ) ) {
                DBGC ( xhci, "XHCI %s transfer event invalid slot %d:\n",
                       xhci->name, trb->slot );
                DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
                return;
        }

        /* Identify endpoint */
        if ( ( trb->endpoint >= XHCI_CTX_END ) ||
             ( ( endpoint = slot->endpoint[trb->endpoint] ) == NULL ) ) {
                DBGC ( xhci, "XHCI %s slot %d transfer event invalid epid "
                       "%d:\n", xhci->name, slot->id, trb->endpoint );
                DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
                return;
        }

        /* Dequeue TRB(s) */
        iobuf = xhci_dequeue_multi ( &endpoint->ring );
        assert ( iobuf != NULL );

        /* Unmap I/O buffer */
        iob_unmap ( iobuf );

        /* Check for errors */
        if ( ! ( ( trb->code == XHCI_CMPLT_SUCCESS ) ||
                 ( trb->code == XHCI_CMPLT_SHORT ) ) ) {

                /* Construct error */
                rc = -ECODE ( trb->code );
                DBGC ( xhci, "XHCI %s slot %d ctx %d failed (code %d): %s\n",
                       xhci->name, slot->id, endpoint->ctx, trb->code,
                       strerror ( rc ) );
                DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );

                /* Sanity check */
                assert ( ( endpoint->context->state & XHCI_ENDPOINT_STATE_MASK )
                         != XHCI_ENDPOINT_RUNNING );

                /* Report failure to USB core */
                usb_complete_err ( endpoint->ep, iobuf, rc );
                return;
        }

        /* Record actual transfer size */
        iob_unput ( iobuf, le16_to_cpu ( trb->residual ) );

        /* Sanity check (for successful completions only) */
        assert ( xhci_ring_consumed ( &endpoint->ring ) ==
                 le64_to_cpu ( trb->transfer ) );

        /* Report completion to USB core */
        usb_complete ( endpoint->ep, iobuf );
        profile_stop ( &xhci_transfer_profiler );
}

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

xhci	xHCI device
trb	Command completion event

Definition at line 1663 of file xhci.c.

                                                            {
        int rc;

        /* Ignore "command ring stopped" notifications */
        if ( trb->code == XHCI_CMPLT_CMD_STOPPED ) {
                DBGC2 ( xhci, "XHCI %s command ring stopped\n", xhci->name );
                return;
        }

        /* Ignore unexpected completions */
        if ( ! xhci->pending ) {
                rc = -ECODE ( trb->code );
                DBGC ( xhci, "XHCI %s unexpected completion (code %d): %s\n",
                       xhci->name, trb->code, strerror ( rc ) );
                DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
                return;
        }

        /* Dequeue command TRB */
        xhci_dequeue ( &xhci->command );

        /* Sanity check */
        assert ( xhci_ring_consumed ( &xhci->command ) ==
                 le64_to_cpu ( trb->command ) );

        /* Record completion */
        memcpy ( xhci->pending, trb, sizeof ( *xhci->pending ) );
        xhci->pending = NULL;
}

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

xhci	xHCI device
trb	Port status event

Definition at line 1700 of file xhci.c.

                                                                  {
        struct usb_port *port = usb_port ( xhci->bus->hub, trb->port );
        uint32_t portsc;

        /* Sanity check */
        assert ( ( trb->port > 0 ) && ( trb->port <= xhci->ports ) );

        /* Record disconnections and clear changes */
        portsc = readl ( xhci->op + XHCI_OP_PORTSC ( trb->port ) );
        port->disconnected |= ( portsc & XHCI_PORTSC_CSC );
        portsc &= ( XHCI_PORTSC_PRESERVE | XHCI_PORTSC_CHANGE );
        writel ( portsc, xhci->op + XHCI_OP_PORTSC ( trb->port ) );

        /* Report port status change */
        usb_port_changed ( port );
}

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

xhci	xHCI device
trb	Host controller event

Definition at line 1724 of file xhci.c.

                                                                          {
        int rc;

        /* Construct error */
        rc = -ECODE ( trb->code );
        DBGC ( xhci, "XHCI %s host controller event (code %d): %s\n",
               xhci->name, trb->code, strerror ( rc ) );
}

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

xhci	xHCI device

Definition at line 1739 of file xhci.c.

                                                         {
        struct xhci_event_ring *event = &xhci->event;
        union xhci_trb *trb;
        unsigned int shift = XHCI_EVENT_TRBS_LOG2;
        unsigned int count = ( 1 << shift );
        unsigned int mask = ( count - 1 );
        unsigned int consumed;
        unsigned int type;

        /* Do nothing if device has permanently failed */
        if ( xhci->failed )
                return;

        /* Poll for events */
        profile_start ( &xhci_event_profiler );
        for ( consumed = 0 ; ; consumed++ ) {

                /* Stop if we reach an empty TRB */
                rmb();
                trb = &event->trb[ event->cons & mask ];
                if ( ! ( ( trb->common.flags ^
                           ( event->cons >> shift ) ) & XHCI_TRB_C ) )
                        break;

                /* Consume this TRB */
                event->cons++;

                /* Handle TRB */
                type = ( trb->common.type & XHCI_TRB_TYPE_MASK );
                switch ( type ) {

                case XHCI_TRB_TRANSFER :
                        xhci_transfer ( xhci, &trb->transfer );
                        break;

                case XHCI_TRB_COMPLETE :
                        xhci_complete ( xhci, &trb->complete );
                        break;

                case XHCI_TRB_PORT_STATUS:
                        xhci_port_status ( xhci, &trb->port );
                        break;

                case XHCI_TRB_HOST_CONTROLLER:
                        xhci_host_controller ( xhci, &trb->host );
                        break;

                default:
                        DBGC ( xhci, "XHCI %s unrecognised event %#x\n:",
                               xhci->name, ( event->cons - 1 ) );
                        DBGC_HDA ( xhci, virt_to_phys ( trb ),
                                   trb, sizeof ( *trb ) );
                        break;
                }
        }

        /* Update dequeue pointer if applicable */
        if ( consumed ) {
                xhci_writeq ( xhci, dma ( &event->trb_map, trb ),
                              xhci->run + XHCI_RUN_ERDP ( 0 ) );
                profile_stop ( &xhci_event_profiler );
        }
}

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

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

xhci_abort()

static void xhci_abort ( struct xhci_device *  xhci )

static

Abort command.

Parameters

xhci	xHCI device

Definition at line 1808 of file xhci.c.

                                                    {
        physaddr_t crp;
        uint32_t crcr;

        /* Abort the command */
        DBGC2 ( xhci, "XHCI %s aborting command\n", xhci->name );
        xhci_writeq ( xhci, XHCI_CRCR_CA, xhci->op + XHCI_OP_CRCR );

        /* Allow time for command to abort */
        mdelay ( XHCI_COMMAND_ABORT_DELAY_MS );

        /* Check for failure to abort */
        crcr = readl ( xhci->op + XHCI_OP_CRCR );
        if ( crcr & XHCI_CRCR_CRR ) {

                /* Device has failed to abort a command and is almost
                 * certainly beyond repair.  Reset device, abandoning
                 * all state, and mark device as failed to avoid
                 * delays on any future command attempts.
                 */
                DBGC ( xhci, "XHCI %s failed to abort command\n", xhci->name );
                xhci_fail ( xhci );
        }

        /* Consume (and ignore) any final command status */
        xhci_event_poll ( xhci );

        /* Reset the command ring control register */
        xhci_ring_reset ( &xhci->command );
        crp = dma ( &xhci->command.map, xhci->command.trb );
        xhci_writeq ( xhci, ( crp | XHCI_CRCR_RCS ), xhci->op + XHCI_OP_CRCR );
}

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

Referenced by xhci_command().

xhci_command()

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

static

Issue command and wait for completion.

Parameters

xhci	xHCI device
trb	Transfer request block (with empty Cycle flag)

Return values

rc	Return status code

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

Definition at line 1851 of file xhci.c.

                                                                          {
        struct xhci_trb_complete *complete = &trb->complete;
        unsigned int i;
        int rc;

        /* Immediately fail all commands if command mechanism has failed */
        if ( xhci->failed ) {
                rc = -EPIPE;
                goto err_failed;
        }

        /* Sanity check */
        if ( xhci->pending ) {
                DBGC ( xhci, "XHCI %s command ring busy\n", xhci->name );
                rc = -EBUSY;
                goto err_pending;
        }

        /* Record the pending command */
        xhci->pending = trb;

        /* Enqueue the command */
        if ( ( rc = xhci_enqueue ( &xhci->command, NULL, trb ) ) != 0 )
                goto err_enqueue;

        /* Ring the command doorbell */
        xhci_doorbell ( &xhci->command );

        /* Wait for the command to complete */
        for ( i = 0 ; i < XHCI_COMMAND_MAX_WAIT_MS ; i++ ) {

                /* Poll event ring */
                xhci_event_poll ( xhci );

                /* Check for completion */
                if ( ! xhci->pending ) {
                        if ( complete->code != XHCI_CMPLT_SUCCESS ) {
                                rc = -ECODE ( complete->code );
                                DBGC ( xhci, "XHCI %s command failed (code "
                                       "%d): %s\n", xhci->name, complete->code,
                                       strerror ( rc ) );
                                DBGC_HDA ( xhci, 0, trb, sizeof ( *trb ) );
                                return rc;
                        }
                        return 0;
                }

                /* Delay */
                mdelay ( 1 );
        }

        /* Timeout */
        DBGC ( xhci, "XHCI %s timed out waiting for completion\n", xhci->name );
        rc = -ETIMEDOUT;

        /* Abort command */
        xhci_abort ( xhci );

 err_enqueue:
        xhci->pending = NULL;
 err_pending:
 err_failed:
        return rc;
}

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

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

xhci_nop()

static int xhci_nop ( struct xhci_device *  xhci )

inlinestatic

Issue NOP and wait for completion.

Parameters

xhci	xHCI device

Return values

rc	Return status code

Definition at line 1922 of file xhci.c.

                                                        {
        union xhci_trb trb;
        struct xhci_trb_common *nop = &trb.common;
        int rc;

        /* Construct command */
        memset ( nop, 0, sizeof ( *nop ) );
        nop->flags = XHCI_TRB_IOC;
        nop->type = XHCI_TRB_NOP_CMD;

        /* Issue command and wait for completion */
        if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s NOP failed: %s\n",
                       xhci->name, strerror ( rc ) );
                return rc;
        }

        DBGC2 ( xhci, "XHCI %s NOP completed successfully\n", xhci->name );
        return 0;
}

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

xhci	xHCI device
type	Slot type

Return values

slot	Device slot ID, or negative error

Definition at line 1950 of file xhci.c.

                                                         {
        union xhci_trb trb;
        struct xhci_trb_enable_slot *enable = &trb.enable;
        struct xhci_trb_complete *enabled = &trb.complete;
        unsigned int slot;
        int rc;

        /* Construct command */
        memset ( enable, 0, sizeof ( *enable ) );
        enable->slot = type;
        enable->type = XHCI_TRB_ENABLE_SLOT;

        /* Issue command and wait for completion */
        if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s could not enable new slot: %s\n",
                       xhci->name, strerror ( rc ) );
                return rc;
        }

        /* Extract slot number */
        slot = enabled->slot;

        DBGC2 ( xhci, "XHCI %s slot %d enabled\n", xhci->name, slot );
        return slot;
}

References xhci_trb::complete, DBGC, DBGC2, xhci_trb::enable, enabled, memset(), xhci_device::name, rc, slot, xhci_trb_enable_slot::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

xhci	xHCI device
slot	Device slot

Return values

rc	Return status code

Definition at line 1984 of file xhci.c.

                                                          {
        union xhci_trb trb;
        struct xhci_trb_disable_slot *disable = &trb.disable;
        int rc;

        /* Construct command */
        memset ( disable, 0, sizeof ( *disable ) );
        disable->type = XHCI_TRB_DISABLE_SLOT;
        disable->slot = slot;

        /* Issue command and wait for completion */
        if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s could not disable slot %d: %s\n",
                       xhci->name, slot, strerror ( rc ) );
                return rc;
        }

        DBGC2 ( xhci, "XHCI %s slot %d disabled\n", xhci->name, slot );
        return 0;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint
type	TRB type
populate	Input context populater

Return values

rc	Return status code

Definition at line 2016 of file xhci.c.

                                                                {
        union xhci_trb trb;
        struct xhci_trb_context *context = &trb.context;
        struct dma_mapping map;
        size_t len;
        void *input;
        int rc;

        /* Allocate an input context */
        memset ( &map, 0, sizeof ( map ) );
        len = xhci_input_context_offset ( xhci, XHCI_CTX_END );
        input = dma_alloc ( xhci->dma, &map, len, xhci_align ( len ) );
        if ( ! input ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        memset ( input, 0, len );

        /* Populate input context */
        populate ( xhci, slot, endpoint, input );

        /* Construct command */
        memset ( context, 0, sizeof ( *context ) );
        context->type = type;
        context->input = cpu_to_le64 ( dma ( &map, input ) );
        context->slot = slot->id;

        /* Issue command and wait for completion */
        if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 )
                goto err_command;

 err_command:
        dma_free ( &map, input, len );
 err_alloc:
        return rc;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint
input	Input context

Definition at line 2066 of file xhci.c.

                                                      {
        struct xhci_trb_ring *ring = &endpoint->ring;
        struct xhci_control_context *control_ctx;
        struct xhci_slot_context *slot_ctx;
        struct xhci_endpoint_context *ep_ctx;

        /* Sanity checks */
        assert ( endpoint->ctx == XHCI_CTX_EP0 );

        /* Populate control context */
        control_ctx = input;
        control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
                                         ( 1 << XHCI_CTX_EP0 ) );

        /* Populate slot context */
        slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
        slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( 1, 0, slot->psiv,
                                                        slot->route ) );
        slot_ctx->port = slot->port;
        slot_ctx->tt_id = slot->tt_id;
        slot_ctx->tt_port = slot->tt_port;

        /* Populate control endpoint context */
        ep_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_EP0 ) );
        ep_ctx->type = XHCI_EP_TYPE_CONTROL;
        ep_ctx->burst = endpoint->ep->burst;
        ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
        ep_ctx->dequeue = cpu_to_le64 ( dma ( &ring->map, ring->trb ) |
                                        XHCI_EP_DCS );
        ep_ctx->trb_len = cpu_to_le16 ( XHCI_EP0_TRB_LEN );
}

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

xhci	xHCI device
slot	Device slot

Return values

rc	Return status code

Definition at line 2108 of file xhci.c.

                                                                 {
        struct usb_device *usb = slot->usb;
        struct xhci_slot_context *slot_ctx;
        int rc;

        /* Assign device address */
        if ( ( rc = xhci_context ( xhci, slot, slot->endpoint[XHCI_CTX_EP0],
                                   XHCI_TRB_ADDRESS_DEVICE,
                                   xhci_address_device_input ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s slot %d could not assign address: %s\n",
                       xhci->name, slot->id, strerror ( rc ) );
                return rc;
        }

        /* Get assigned address */
        slot_ctx = ( slot->context +
                     xhci_device_context_offset ( xhci, XHCI_CTX_SLOT ) );
        usb->address = slot_ctx->address;
        DBGC2 ( xhci, "XHCI %s slot %d assigned address %d to %s\n",
                xhci->name, slot->id, usb->address, usb->name );

        return 0;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint
input	Input context

Definition at line 2141 of file xhci.c.

                                                          {
        struct xhci_trb_ring *ring = &endpoint->ring;
        struct xhci_control_context *control_ctx;
        struct xhci_slot_context *slot_ctx;
        struct xhci_endpoint_context *ep_ctx;

        /* Populate control context */
        control_ctx = input;
        control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
                                         ( 1 << endpoint->ctx ) );

        /* Populate slot context */
        slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
        slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
                                                        ( slot->ports ? 1 : 0 ),
                                                        slot->psiv, 0 ) );
        slot_ctx->ports = slot->ports;

        /* Populate endpoint context */
        ep_ctx = ( input + xhci_input_context_offset ( xhci, endpoint->ctx ) );
        ep_ctx->interval = endpoint->interval;
        ep_ctx->type = endpoint->type;
        ep_ctx->burst = endpoint->ep->burst;
        ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
        ep_ctx->dequeue = cpu_to_le64 ( dma ( &ring->map, ring->trb ) |
                                        XHCI_EP_DCS );
        ep_ctx->trb_len = cpu_to_le16 ( endpoint->ep->mtu ); /* best guess */
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint

Return values

rc	Return status code

Definition at line 2181 of file xhci.c.

                                                                             {
        int rc;

        /* Configure endpoint */
        if ( ( rc = xhci_context ( xhci, slot, endpoint,
                                   XHCI_TRB_CONFIGURE_ENDPOINT,
                                   xhci_configure_endpoint_input ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s slot %d ctx %d could not configure: %s\n",
                       xhci->name, slot->id, endpoint->ctx, strerror ( rc ) );
                return rc;
        }

        DBGC2 ( xhci, "XHCI %s slot %d ctx %d configured\n",
                xhci->name, slot->id, endpoint->ctx );
        return 0;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint
input	Input context

Definition at line 2209 of file xhci.c.

                                                {
        struct xhci_control_context *control_ctx;
        struct xhci_slot_context *slot_ctx;

        /* Populate control context */
        control_ctx = input;
        control_ctx->add = cpu_to_le32 ( 1 << XHCI_CTX_SLOT );
        control_ctx->drop = cpu_to_le32 ( 1 << endpoint->ctx );

        /* Populate slot context */
        slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
        slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
                                                        0, 0, 0 ) );
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint

Return values

rc	Return status code

Definition at line 2235 of file xhci.c.

                                                                               {
        int rc;

        /* Deconfigure endpoint */
        if ( ( rc = xhci_context ( xhci, slot, endpoint,
                                   XHCI_TRB_CONFIGURE_ENDPOINT,
                                   xhci_deconfigure_endpoint_input ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s slot %d ctx %d could not deconfigure: "
                       "%s\n", xhci->name, slot->id, endpoint->ctx,
                       strerror ( rc ) );
                return rc;
        }

        DBGC2 ( xhci, "XHCI %s slot %d ctx %d deconfigured\n",
                xhci->name, slot->id, endpoint->ctx );
        return 0;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint
input	Input context

Definition at line 2263 of file xhci.c.

                                                        {
        struct xhci_control_context *control_ctx;
        struct xhci_slot_context *slot_ctx;
        struct xhci_endpoint_context *ep_ctx;

        /* Populate control context */
        control_ctx = input;
        control_ctx->add = cpu_to_le32 ( ( 1 << XHCI_CTX_SLOT ) |
                                         ( 1 << endpoint->ctx ) );

        /* Populate slot context */
        slot_ctx = ( input + xhci_input_context_offset ( xhci, XHCI_CTX_SLOT ));
        slot_ctx->info = cpu_to_le32 ( XHCI_SLOT_INFO ( ( XHCI_CTX_END - 1 ),
                                                        0, 0, 0 ) );

        /* Populate endpoint context */
        ep_ctx = ( input + xhci_input_context_offset ( xhci, endpoint->ctx ) );
        ep_ctx->mtu = cpu_to_le16 ( endpoint->ep->mtu );
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint

Return values

rc	Return status code

Definition at line 2294 of file xhci.c.

                                                                           {
        int rc;

        /* Configure endpoint */
        if ( ( rc = xhci_context ( xhci, slot, endpoint,
                                   XHCI_TRB_EVALUATE_CONTEXT,
                                   xhci_evaluate_context_input ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s slot %d ctx %d could not (re-)evaluate: "
                       "%s\n", xhci->name, slot->id, endpoint->ctx,
                       strerror ( rc ) );
                return rc;
        }

        DBGC2 ( xhci, "XHCI %s slot %d ctx %d (re-)evaluated\n",
                xhci->name, slot->id, endpoint->ctx );
        return 0;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint

Return values

rc	Return status code

Definition at line 2322 of file xhci.c.

                                                                         {
        union xhci_trb trb;
        struct xhci_trb_reset_endpoint *reset = &trb.reset;
        int rc;

        /* Construct command */
        memset ( reset, 0, sizeof ( *reset ) );
        reset->slot = slot->id;
        reset->endpoint = endpoint->ctx;
        reset->type = XHCI_TRB_RESET_ENDPOINT;

        /* Issue command and wait for completion */
        if ( ( rc = xhci_command ( xhci, &trb ) ) != 0 ) {
                DBGC ( xhci, "XHCI %s slot %d ctx %d could not reset endpoint "
                       "in state %d: %s\n", xhci->name, slot->id, endpoint->ctx,
                       endpoint->context->state, strerror ( rc ) );
                return rc;
        }

        return 0;
}

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

xhci	xHCI device
slot	Device slot
endpoint	Endpoint

Return values

rc	Return status code

Definition at line 2354 of file xhci.c.

                                                                        {
        union xhci_trb trb;
        struct xhci_trb_stop_endpoint *stop = &trb.stop;
        int rc;

        /* Construct command */
        memset ( stop, 0, sizeof ( *stop ) );
        stop->slot =