efi_usb.c File Reference

EFI USB I/O PROTOCOL. More...

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_path.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_null.h>
#include <ipxe/efi/efi_usb.h>
#include <ipxe/usb.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static const char *	efi_usb_direction_name (EFI_USB_DATA_DIRECTION direction)
	Transcribe data direction (for debugging)
static VOID EFIAPI	efi_usb_timer (EFI_EVENT event __unused, VOID *context)
	Poll USB bus (from endpoint event timer)
static int	efi_usb_mtu (struct efi_usb_interface *usbintf, unsigned int endpoint)
	Get endpoint MTU.
static int	efi_usb_is_open (struct efi_usb_interface *usbintf, unsigned int endpoint)
	Check if endpoint is open.
static int	efi_usb_open (struct efi_usb_interface *usbintf, unsigned int endpoint, unsigned int attributes, unsigned int interval, struct usb_endpoint_driver_operations *driver)
	Open endpoint.
static void	efi_usb_close (struct efi_usb_endpoint *usbep)
	Close endpoint.
static void	efi_usb_close_all (struct efi_usb_interface *usbintf)
	Close all endpoints.
static void	efi_usb_free_all (struct efi_usb_interface *usbintf)
	Free all endpoints.
static void	efi_usb_sync_complete (struct usb_endpoint *ep, struct io_buffer *iobuf __unused, int rc)
	Complete synchronous transfer.
static int	efi_usb_sync_transfer (struct efi_usb_interface *usbintf, unsigned int endpoint, unsigned int attributes, unsigned int timeout, void *data, size_t *len)
	Perform synchronous transfer.
static void	efi_usb_async_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete asynchronous transfer.
static int	efi_usb_async_start (struct efi_usb_interface *usbintf, unsigned int endpoint, unsigned int interval, size_t len, EFI_ASYNC_USB_TRANSFER_CALLBACK callback, void *context)
	Start asynchronous transfer.
static void	efi_usb_async_stop (struct efi_usb_interface *usbintf, unsigned int endpoint)
	Stop asynchronous transfer.
static EFI_STATUS EFIAPI	efi_usb_control_transfer (EFI_USB_IO_PROTOCOL *usbio, EFI_USB_DEVICE_REQUEST *packet, EFI_USB_DATA_DIRECTION direction, UINT32 timeout, VOID *data, UINTN len, UINT32 *status)
	Perform control transfer.
static EFI_STATUS EFIAPI	efi_usb_bulk_transfer (EFI_USB_IO_PROTOCOL *usbio, UINT8 endpoint, VOID *data, UINTN *len, UINTN timeout, UINT32 *status)
	Perform bulk transfer.
static EFI_STATUS EFIAPI	efi_usb_sync_interrupt_transfer (EFI_USB_IO_PROTOCOL *usbio, UINT8 endpoint, VOID *data, UINTN *len, UINTN timeout, UINT32 *status)
	Perform synchronous interrupt transfer.
static EFI_STATUS EFIAPI	efi_usb_async_interrupt_transfer (EFI_USB_IO_PROTOCOL *usbio, UINT8 endpoint, BOOLEAN start, UINTN interval, UINTN len, EFI_ASYNC_USB_TRANSFER_CALLBACK callback, VOID *context)
	Perform asynchronous interrupt transfer.
static EFI_STATUS EFIAPI	efi_usb_isochronous_transfer (EFI_USB_IO_PROTOCOL *usbio, UINT8 endpoint, VOID *data, UINTN len, UINT32 *status)
	Perform synchronous isochronous transfer.
static EFI_STATUS EFIAPI	efi_usb_async_isochronous_transfer (EFI_USB_IO_PROTOCOL *usbio, UINT8 endpoint, VOID *data, UINTN len, EFI_ASYNC_USB_TRANSFER_CALLBACK callback, VOID *context)
	Perform asynchronous isochronous transfers.
static EFI_STATUS EFIAPI	efi_usb_get_device_descriptor (EFI_USB_IO_PROTOCOL *usbio, EFI_USB_DEVICE_DESCRIPTOR *efidesc)
	Get device descriptor.
static EFI_STATUS EFIAPI	efi_usb_get_config_descriptor (EFI_USB_IO_PROTOCOL *usbio, EFI_USB_CONFIG_DESCRIPTOR *efidesc)
	Get configuration descriptor.
static EFI_STATUS EFIAPI	efi_usb_get_interface_descriptor (EFI_USB_IO_PROTOCOL *usbio, EFI_USB_INTERFACE_DESCRIPTOR *efidesc)
	Get interface descriptor.
static EFI_STATUS EFIAPI	efi_usb_get_endpoint_descriptor (EFI_USB_IO_PROTOCOL *usbio, UINT8 index, EFI_USB_ENDPOINT_DESCRIPTOR *efidesc)
	Get endpoint descriptor.
static EFI_STATUS EFIAPI	efi_usb_get_string_descriptor (EFI_USB_IO_PROTOCOL *usbio, UINT16 language, UINT8 index, CHAR16 **string)
	Get string descriptor.
static EFI_STATUS EFIAPI	efi_usb_get_supported_languages (EFI_USB_IO_PROTOCOL *usbio, UINT16 **languages, UINT16 *len)
	Get supported languages.
static EFI_STATUS EFIAPI	efi_usb_port_reset (EFI_USB_IO_PROTOCOL *usbio)
	Reset port.
static int	efi_usb_install (struct efi_usb_device *usbdev, unsigned int interface)
	Install interface.
static void	efi_usb_uninstall (struct efi_usb_interface *usbintf)
	Uninstall interface.
static void	efi_usb_uninstall_all (struct efi_usb_device *efiusb)
	Uninstall all interfaces.
static int	efi_usb_probe (struct usb_function *func, struct usb_configuration_descriptor *config)
	Probe device.
static void	efi_usb_remove (struct usb_function *func)
	Remove device.

Variables
static struct usb_endpoint_driver_operations	efi_usb_sync_driver
	Synchronous endpoint operations.
static struct usb_endpoint_driver_operations	efi_usb_async_driver
	Asynchronous endpoint operations.
static EFI_USB_IO_PROTOCOL	efi_usb_io_protocol
	USB I/O protocol.
static struct usb_device_id	efi_usb_ids []
	USB I/O protocol device IDs.
struct usb_driver usbio_driver	__usb_fallback_driver
	USB I/O protocol driver.

Detailed Description

EFI USB I/O PROTOCOL.

Definition in file efi_usb.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

efi_usb_direction_name()

const char * efi_usb_direction_name ( EFI_USB_DATA_DIRECTION direction )

static

Transcribe data direction (for debugging)

Parameters

direction

Data direction

Return values

text	Transcribed data direction

Definition at line 52 of file efi_usb.c.

                                                                               {
 
        switch ( direction ) {
        case EfiUsbDataIn:  return "in";
        case EfiUsbDataOut:        return "out";
        case EfiUsbNoData:  return "none";
        default:                return "<UNKNOWN>";
        }
}

References direction, EfiUsbDataIn, EfiUsbDataOut, and EfiUsbNoData.

Referenced by efi_usb_control_transfer().

efi_usb_timer()

VOID EFIAPI efi_usb_timer ( EFI_EVENT event __unused, VOID * context )

static

Poll USB bus (from endpoint event timer)

Parameters

event	EFI event
context	EFI USB endpoint

Definition at line 75 of file efi_usb.c.

                                                   {
        struct efi_usb_endpoint *usbep = context;
        struct usb_function *func = usbep->usbintf->usbdev->func;
 
        /* Poll bus */
        usb_poll ( func->usb->port->hub->bus );
 
        /* Refill endpoint */
        if ( usbep->ep.open )
                usb_refill ( &usbep->ep );
}

References __unused, usb_hub::bus, efi_usb_endpoint::context, EFI_EVENT, EFIAPI, efi_usb_endpoint::ep, efi_usb_device::func, usb_port::hub, usb_endpoint::open, usb_device::port, usb_function::usb, usb_poll(), usb_refill(), efi_usb_interface::usbdev, efi_usb_endpoint::usbintf, and VOID.

Referenced by efi_usb_open().

efi_usb_mtu()

int efi_usb_mtu ( struct efi_usb_interface * usbintf, unsigned int endpoint )

static

Get endpoint MTU.

Parameters

usbintf	EFI USB interface
endpoint	Endpoint address

Return values

mtu	Endpoint MTU, or negative error

Definition at line 95 of file efi_usb.c.

                                                 {
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct usb_interface_descriptor *interface;
        struct usb_endpoint_descriptor *desc;
 
        /* Locate cached interface descriptor */
        interface = usb_interface_descriptor ( usbdev->config,
                                               usbintf->interface,
                                               usbintf->alternate );
        if ( ! interface ) {
                DBGC ( usbdev, "USBDEV %s alt %d has no interface descriptor\n",
                       usbintf->name, usbintf->alternate );
                return -ENOENT;
        }
 
        /* Locate and copy cached endpoint descriptor */
        for_each_interface_descriptor ( desc, usbdev->config, interface ) {
                if ( ( desc->header.type == USB_ENDPOINT_DESCRIPTOR ) &&
                     ( desc->endpoint == endpoint ) )
                        return USB_ENDPOINT_MTU ( le16_to_cpu ( desc->sizes ) );
        }
 
        DBGC ( usbdev, "USBDEV %s alt %d ep %02x has no descriptor\n",
               usbintf->name, usbintf->alternate, endpoint );
        return -ENOENT;
}

References alternate, efi_usb_interface::alternate, efi_usb_device::config, DBGC, desc, ENOENT, for_each_interface_descriptor, le16_to_cpu, efi_usb_interface::name, USB_ENDPOINT_DESCRIPTOR, USB_ENDPOINT_MTU, and efi_usb_interface::usbdev.

Referenced by efi_usb_open().

efi_usb_is_open()

int efi_usb_is_open ( struct efi_usb_interface * usbintf, unsigned int endpoint )

static

Check if endpoint is open.

Parameters

usbintf	EFI USB interface
endpoint	Endpoint address

Return values

is_open

Endpoint is open

Definition at line 130 of file efi_usb.c.

                                                     {
        unsigned int index = USB_ENDPOINT_IDX ( endpoint );
        struct efi_usb_endpoint *usbep = usbintf->endpoint[index];
 
        return ( usbep && usbep->ep.open );
}

References efi_usb_interface::endpoint, efi_usb_endpoint::ep, index, usb_endpoint::open, USB_ENDPOINT_IDX, and efi_usb_endpoint::usbintf.

Referenced by efi_usb_async_start(), efi_usb_async_stop(), and efi_usb_sync_transfer().

efi_usb_open()

int efi_usb_open ( struct efi_usb_interface * usbintf, unsigned int endpoint, unsigned int attributes, unsigned int interval, struct usb_endpoint_driver_operations * driver )

static

Open endpoint.

Parameters

usbintf	EFI USB interface
endpoint	Endpoint address
attributes	Endpoint attributes
interval	Interval (in milliseconds)
driver	Driver operations

Return values

rc	Return status code

Definition at line 148 of file efi_usb.c.

                                                                          {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct efi_usb_endpoint *usbep;
        unsigned int index = USB_ENDPOINT_IDX ( endpoint );
        int mtu;
        EFI_STATUS efirc;
        int rc;
 
        /* Allocate structure, if needed.  Once allocated, we leave
         * the endpoint structure in place until the device is
         * removed, to work around external UEFI code that closes the
         * endpoint at illegal times.
         */
        usbep = usbintf->endpoint[index];
        if ( ! usbep ) {
                usbep = zalloc ( sizeof ( *usbep ) );
                if ( ! usbep ) {
                        rc = -ENOMEM;
                        goto err_alloc;
                }
                usbep->usbintf = usbintf;
                usbintf->endpoint[index] = usbep;
        }
 
        /* Get endpoint MTU */
        mtu = efi_usb_mtu ( usbintf, endpoint );
        if ( mtu < 0 ) {
                rc = mtu;
                goto err_mtu;
        }
 
        /* Allocate and initialise structure */
        usb_endpoint_init ( &usbep->ep, usbdev->func->usb, driver );
        usb_endpoint_describe ( &usbep->ep, endpoint, attributes, mtu, 0,
                                ( interval << 3 /* microframes */ ) );
 
        /* Open endpoint */
        if ( ( rc = usb_endpoint_open ( &usbep->ep ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s %s could not open: %s\n",
                       usbintf->name, usb_endpoint_name ( &usbep->ep ),
                       strerror ( rc ) );
                goto err_open;
        }
        DBGC ( usbdev, "USBDEV %s %s opened\n",
               usbintf->name, usb_endpoint_name ( &usbep->ep ) );
 
        /* Create event */
        if ( ( efirc = bs->CreateEvent ( ( EVT_TIMER | EVT_NOTIFY_SIGNAL ),
                                         TPL_CALLBACK, efi_usb_timer, usbep,
                                         &usbep->event ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( usbdev, "USBDEV %s %s could not create event: %s\n",
                       usbintf->name, usb_endpoint_name ( &usbep->ep ),
                       strerror ( rc ) );
                goto err_event;
        }
 
        return 0;
 
        bs->CloseEvent ( usbep->event );
 err_event:
        usb_endpoint_close ( &usbep->ep );
 err_open:
 err_mtu:
 err_alloc:
        return rc;
}

References EFI_BOOT_SERVICES::CloseEvent, EFI_BOOT_SERVICES::CreateEvent, DBGC, EEFI, efi_systab, efi_usb_mtu(), efi_usb_timer(), efi_usb_interface::endpoint, ENOMEM, efi_usb_endpoint::ep, efi_usb_endpoint::event, EVT_NOTIFY_SIGNAL, EVT_TIMER, efi_usb_device::func, index, mtu, efi_usb_interface::name, rc, strerror(), TPL_CALLBACK, usb_function::usb, usb_endpoint_close(), usb_endpoint_describe(), USB_ENDPOINT_IDX, usb_endpoint_init(), usb_endpoint_name(), usb_endpoint_open(), efi_usb_interface::usbdev, efi_usb_endpoint::usbintf, and zalloc().

Referenced by efi_usb_async_start(), and efi_usb_sync_transfer().

efi_usb_close()

void efi_usb_close ( struct efi_usb_endpoint * usbep )

static

Close endpoint.

Parameters

usbep

EFI USB endpoint

Definition at line 225 of file efi_usb.c.

                                                             {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_usb_interface *usbintf = usbep->usbintf;
        struct efi_usb_device *usbdev = usbintf->usbdev;
        unsigned int index = USB_ENDPOINT_IDX ( usbep->ep.address );
 
        /* Sanity check */
        assert ( usbintf->endpoint[index] == usbep );
 
        /* Cancel timer (if applicable) and close event */
        bs->SetTimer ( usbep->event, TimerCancel, 0 );
        bs->CloseEvent ( usbep->event );
 
        /* Close endpoint */
        usb_endpoint_close ( &usbep->ep );
        DBGC ( usbdev, "USBDEV %s %s closed\n",
               usbintf->name, usb_endpoint_name ( &usbep->ep ) );
}

References usb_endpoint::address, assert, EFI_BOOT_SERVICES::CloseEvent, DBGC, efi_systab, efi_usb_interface::endpoint, efi_usb_endpoint::ep, efi_usb_endpoint::event, index, efi_usb_interface::name, EFI_BOOT_SERVICES::SetTimer, TimerCancel, usb_endpoint_close(), USB_ENDPOINT_IDX, usb_endpoint_name(), efi_usb_interface::usbdev, and efi_usb_endpoint::usbintf.

Referenced by efi_usb_async_start(), efi_usb_close_all(), and efi_usb_sync_transfer().

efi_usb_close_all()

void efi_usb_close_all ( struct efi_usb_interface * usbintf )

static

Close all endpoints.

Parameters

usbintf

EFI USB interface

Definition at line 249 of file efi_usb.c.

                                                                    {
        struct efi_usb_endpoint *usbep;
        unsigned int i;
 
        for ( i = 0 ; i < ( sizeof ( usbintf->endpoint ) /
                            sizeof ( usbintf->endpoint[0] ) ) ; i++ ) {
                usbep = usbintf->endpoint[i];
                if ( usbep && usbep->ep.open )
                        efi_usb_close ( usbep );
        }
}

References efi_usb_close(), efi_usb_interface::endpoint, efi_usb_endpoint::ep, usb_endpoint::open, and efi_usb_endpoint::usbintf.

Referenced by efi_usb_control_transfer(), efi_usb_install(), and efi_usb_uninstall().

efi_usb_free_all()

void efi_usb_free_all ( struct efi_usb_interface * usbintf )

static

Free all endpoints.

Parameters

usbintf

EFI USB interface

Definition at line 266 of file efi_usb.c.

                                                                   {
        struct efi_usb_endpoint *usbep;
        unsigned int i;
 
        for ( i = 0 ; i < ( sizeof ( usbintf->endpoint ) /
                            sizeof ( usbintf->endpoint[0] ) ) ; i++ ) {
                usbep = usbintf->endpoint[i];
                if ( usbep ) {
                        assert ( ! usbep->ep.open );
                        free ( usbep );
                        usbintf->endpoint[i] = NULL;
                }
        }
}

References assert, efi_usb_interface::endpoint, efi_usb_endpoint::ep, free, NULL, usb_endpoint::open, and efi_usb_endpoint::usbintf.

Referenced by efi_usb_install(), and efi_usb_uninstall().

efi_usb_sync_complete()

void efi_usb_sync_complete ( struct usb_endpoint * ep, struct io_buffer *iobuf __unused, int rc )

static

Complete synchronous transfer.

Parameters

ep	USB endpoint
iobuf	I/O buffer
rc	Completion status code

Definition at line 288 of file efi_usb.c.

                                                                               {
        struct efi_usb_endpoint *usbep =
                container_of ( ep, struct efi_usb_endpoint, ep );
 
        /* Record completion status */
        usbep->rc = rc;
}

References __unused, container_of, efi_usb_endpoint::ep, efi_usb_endpoint::rc, and rc.

efi_usb_sync_transfer()

int efi_usb_sync_transfer ( struct efi_usb_interface * usbintf, unsigned int endpoint, unsigned int attributes, unsigned int timeout, void * data, size_t * len )

static

Perform synchronous transfer.

Parameters

usbintf	USB endpoint
endpoint	Endpoint address
attributes	Endpoint attributes
timeout	Timeout (in milliseconds)
data	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 313 of file efi_usb.c.

                                                             {
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct efi_usb_endpoint *usbep;
        struct io_buffer *iobuf;
        unsigned int index = USB_ENDPOINT_IDX ( endpoint );
        unsigned int i;
        int rc;
 
        /* Open endpoint, if applicable */
        if ( ( ! efi_usb_is_open ( usbintf, endpoint ) ) &&
             ( ( rc = efi_usb_open ( usbintf, endpoint, attributes, 0,
                                     &efi_usb_sync_driver ) ) != 0 ) ) {
                goto err_open;
        }
        usbep = usbintf->endpoint[index];
 
        /* Allocate and construct I/O buffer */
        iobuf = alloc_iob ( *len );
        if ( ! iobuf ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        iob_put ( iobuf, *len );
        if ( ! ( endpoint & USB_ENDPOINT_IN ) )
                memcpy ( iobuf->data, data, *len );
 
        /* Initialise completion status */
        usbep->rc = -EINPROGRESS;
 
        /* Enqueue transfer */
        if ( ( rc = usb_stream ( &usbep->ep, iobuf, 0 ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s %s could not enqueue: %s\n",
                       usbintf->name, usb_endpoint_name ( &usbep->ep ),
                       strerror ( rc ) );
                goto err_stream;
        }
 
        /* Wait for completion */
        rc = -ETIMEDOUT;
        for ( i = 0 ; ( ( timeout == 0 ) || ( i < timeout ) ) ; i++ ) {
 
                /* Poll bus */
                usb_poll ( usbdev->func->usb->port->hub->bus );
 
                /* Check for completion */
                if ( usbep->rc != -EINPROGRESS ) {
                        rc = usbep->rc;
                        break;
                }
 
                /* Delay */
                mdelay ( 1 );
        }
 
        /* Check for errors */
        if ( rc != 0 ) {
                DBGC ( usbdev, "USBDEV %s %s failed: %s\n", usbintf->name,
                       usb_endpoint_name ( &usbep->ep ), strerror ( rc ) );
                goto err_completion;
        }
 
        /* Copy completion to data buffer, if applicable */
        assert ( iob_len ( iobuf ) <= *len );
        if ( endpoint & USB_ENDPOINT_IN )
                memcpy ( data, iobuf->data, iob_len ( iobuf ) );
        *len = iob_len ( iobuf );
 
        /* Free I/O buffer */
        free_iob ( iobuf );
 
        /* Leave endpoint open */
        return 0;
 
 err_completion:
 err_stream:
        free_iob ( iobuf );
 err_alloc:
        efi_usb_close ( usbep );
 err_open:
        return EFIRC ( rc );
}

References alloc_iob(), assert, usb_hub::bus, data, io_buffer::data, DBGC, efi_usb_close(), efi_usb_is_open(), efi_usb_open(), efi_usb_sync_driver, EFIRC, EINPROGRESS, efi_usb_interface::endpoint, ENOMEM, efi_usb_endpoint::ep, ETIMEDOUT, free_iob(), efi_usb_device::func, usb_port::hub, index, iob_len(), iob_put, len, mdelay(), memcpy(), efi_usb_interface::name, usb_device::port, efi_usb_endpoint::rc, rc, strerror(), timeout(), usb_function::usb, USB_ENDPOINT_IDX, USB_ENDPOINT_IN, usb_endpoint_name(), usb_poll(), usb_stream(), and efi_usb_interface::usbdev.

Referenced by efi_usb_bulk_transfer(), and efi_usb_sync_interrupt_transfer().

efi_usb_async_complete()

void efi_usb_async_complete ( struct usb_endpoint * ep, struct io_buffer * iobuf, int rc )

static

Complete asynchronous transfer.

Parameters

ep	USB endpoint
iobuf	I/O buffer
rc	Completion status code

Definition at line 406 of file efi_usb.c.

                                                                       {
        struct efi_usb_endpoint *usbep =
                container_of ( ep, struct efi_usb_endpoint, ep );
        UINT32 status;
 
        /* Ignore packets cancelled when the endpoint closes */
        if ( ! ep->open )
                goto drop;
 
        /* Construct status */
        status = ( ( rc == 0 ) ? 0 : EFI_USB_ERR_SYSTEM );
 
        /* Report completion, if applicable */
        if ( usbep->callback ) {
                usbep->callback ( iobuf->data, iob_len ( iobuf ),
                                  usbep->context, status );
        }
 
 drop:
        /* Recycle or free I/O buffer */
        if ( usbep->ep.open ) {
                usb_recycle ( &usbep->ep, iobuf );
        } else {
                free_iob ( iobuf );
        }
}

References efi_usb_endpoint::callback, container_of, efi_usb_endpoint::context, io_buffer::data, EFI_USB_ERR_SYSTEM, efi_usb_endpoint::ep, free_iob(), iob_len(), usb_endpoint::open, rc, status, and usb_recycle().

efi_usb_async_start()

int efi_usb_async_start ( struct efi_usb_interface * usbintf, unsigned int endpoint, unsigned int interval, size_t len, EFI_ASYNC_USB_TRANSFER_CALLBACK callback, void * context )

static

Start asynchronous transfer.

Parameters

usbintf	EFI USB interface
endpoint	Endpoint address
interval	Interval (in milliseconds)
len	Transfer length
callback	Callback function
context	Context for callback function

Return values

rc	Return status code

Definition at line 450 of file efi_usb.c.

                                                 {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct efi_usb_endpoint *usbep;
        unsigned int index = USB_ENDPOINT_IDX ( endpoint );
        EFI_STATUS efirc;
        int rc;
 
        /* Close endpoint, if applicable */
        if ( efi_usb_is_open ( usbintf, endpoint ) )
                efi_usb_close ( usbintf->endpoint[index] );
 
        /* Open endpoint */
        if ( ( rc = efi_usb_open ( usbintf, endpoint,
                                   USB_ENDPOINT_ATTR_INTERRUPT, interval,
                                   &efi_usb_async_driver ) ) != 0 )
                goto err_open;
        usbep = usbintf->endpoint[index];
 
        /* Record callback parameters */
        usbep->callback = callback;
        usbep->context = context;
 
        /* Prefill endpoint */
        usb_refill_init ( &usbep->ep, 0, len, EFI_USB_ASYNC_FILL );
        if ( ( rc = usb_prefill ( &usbep->ep ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s %s could not prefill: %s\n",
                       usbintf->name, usb_endpoint_name ( &usbep->ep ),
                       strerror ( rc ) );
                goto err_prefill;
        }
 
        /* Start timer */
        if ( ( efirc = bs->SetTimer ( usbep->event, TimerPeriodic,
                                      ( interval * 10000 ) ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( usbdev, "USBDEV %s %s could not set timer: %s\n",
                       usbintf->name, usb_endpoint_name ( &usbep->ep ),
                       strerror ( rc ) );
                goto err_timer;
        }
 
        return 0;
 
        bs->SetTimer ( usbep->event, TimerCancel, 0 );
 err_timer:
 err_prefill:
        usbep->callback = NULL;
        usbep->context = NULL;
        efi_usb_close ( usbep );
 err_open:
        return rc;
}

References efi_usb_endpoint::callback, efi_usb_endpoint::context, DBGC, EEFI, efi_systab, efi_usb_async_driver, EFI_USB_ASYNC_FILL, efi_usb_close(), efi_usb_is_open(), efi_usb_open(), efi_usb_interface::endpoint, efi_usb_endpoint::ep, efi_usb_endpoint::event, index, len, efi_usb_interface::name, NULL, rc, EFI_BOOT_SERVICES::SetTimer, strerror(), TimerCancel, TimerPeriodic, USB_ENDPOINT_ATTR_INTERRUPT, USB_ENDPOINT_IDX, usb_endpoint_name(), usb_prefill(), usb_refill_init(), efi_usb_interface::usbdev, and efi_usb_endpoint::usbintf.

Referenced by efi_usb_async_interrupt_transfer().

efi_usb_async_stop()

void efi_usb_async_stop ( struct efi_usb_interface * usbintf, unsigned int endpoint )

static

Stop asynchronous transfer.

Parameters

usbintf	EFI USB interface
endpoint	Endpoint address

Definition at line 514 of file efi_usb.c.

                                                         {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_usb_endpoint *usbep;
        unsigned int index = USB_ENDPOINT_IDX ( endpoint );
 
        /* Do nothing if endpoint is already closed */
        if ( ! efi_usb_is_open ( usbintf, endpoint ) )
                return;
        usbep = usbintf->endpoint[index];
 
        /* Stop timer */
        bs->SetTimer ( usbep->event, TimerCancel, 0 );
 
        /* Clear callback parameters */
        usbep->callback = NULL;
        usbep->context = NULL;
}

References efi_usb_endpoint::callback, efi_usb_endpoint::context, efi_systab, efi_usb_is_open(), efi_usb_interface::endpoint, efi_usb_endpoint::event, index, NULL, EFI_BOOT_SERVICES::SetTimer, TimerCancel, USB_ENDPOINT_IDX, and efi_usb_endpoint::usbintf.

Referenced by efi_usb_async_interrupt_transfer().

efi_usb_control_transfer()

EFI_STATUS EFIAPI efi_usb_control_transfer ( EFI_USB_IO_PROTOCOL * usbio, EFI_USB_DEVICE_REQUEST * packet, EFI_USB_DATA_DIRECTION direction, UINT32 timeout, VOID * data, UINTN len, UINT32 * status )

static

Perform control transfer.

Parameters

usbio	USB I/O protocol
packet	Setup packet
direction	Data direction
timeout	Timeout (in milliseconds)
data	Data buffer
len	Length of data

Return values

status	Transfer status
efirc	EFI status code

Definition at line 553 of file efi_usb.c.

                                            {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        unsigned int request = ( packet->RequestType |
                                 USB_REQUEST_TYPE ( packet->Request ) );
        unsigned int value = le16_to_cpu ( packet->Value );
        unsigned int index = le16_to_cpu ( packet->Index );
        struct efi_saved_tpl tpl;
        int rc;
 
        DBGC2 ( usbdev, "USBDEV %s control %04x:%04x:%04x:%04x %s %dms "
                "%p+%zx\n", usbintf->name, request, value, index,
                le16_to_cpu ( packet->Length ),
                efi_usb_direction_name ( direction ), timeout, data,
                ( ( size_t ) len ) );
 
        /* Raise TPL */
        efi_raise_tpl ( &tpl );
 
        /* Clear status */
        *status = 0;
 
        /* Block attempts to change the device configuration, since
         * this is logically impossible to do given the constraints of
         * the EFI_USB_IO_PROTOCOL design.
         */
        if ( ( request == USB_SET_CONFIGURATION ) &&
             ( value != usbdev->config->config ) ) {
                DBGC ( usbdev, "USBDEV %s cannot set configuration %d: not "
                       "logically possible\n", usbintf->name, index );
                rc = -ENOTSUP;
                goto err_change_config;
        }
 
        /* If we are selecting a new alternate setting then close all
         * open endpoints.
         */
        if ( ( request == USB_SET_INTERFACE ) &&
             ( value != usbintf->alternate ) )
                efi_usb_close_all ( usbintf );
 
        /* Issue control transfer */
        if ( ( rc = usb_control ( usbdev->func->usb, request, value, index,
                                  data, len ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s control %04x:%04x:%04x:%04x %p+%zx "
                       "failed: %s\n", usbintf->name, request, value, index,
                       le16_to_cpu ( packet->Length ), data, ( ( size_t ) len ),
                       strerror ( rc ) );
                *status = EFI_USB_ERR_SYSTEM;
                goto err_control;
        }
 
        /* Update alternate setting, if applicable */
        if ( request == USB_SET_INTERFACE ) {
                usbintf->alternate = value;
                DBGC ( usbdev, "USBDEV %s alt %d selected\n",
                       usbintf->name, usbintf->alternate );
        }
 
 err_control:
 err_change_config:
        efi_restore_tpl ( &tpl );
        return EFIRC ( rc );
}

References efi_usb_interface::alternate, efi_usb_device::config, usb_configuration_descriptor::config, container_of, data, DBGC, DBGC2, direction, efi_raise_tpl(), efi_restore_tpl(), efi_usb_close_all(), efi_usb_direction_name(), EFI_USB_ERR_SYSTEM, EFIRC, ENOTSUP, efi_usb_device::func, USB_DEVICE_REQUEST::Index, index, le16_to_cpu, len, USB_DEVICE_REQUEST::Length, efi_usb_interface::name, rc, USB_DEVICE_REQUEST::Request, request, USB_DEVICE_REQUEST::RequestType, status, strerror(), timeout(), usb_function::usb, usb_control(), USB_REQUEST_TYPE, USB_SET_CONFIGURATION, USB_SET_INTERFACE, efi_usb_interface::usbdev, efi_usb_interface::usbio, USB_DEVICE_REQUEST::Value, value, and VOID.

efi_usb_bulk_transfer()

EFI_STATUS EFIAPI efi_usb_bulk_transfer ( EFI_USB_IO_PROTOCOL * usbio, UINT8 endpoint, VOID * data, UINTN * len, UINTN timeout, UINT32 * status )

static

Perform bulk transfer.

Parameters

usbio	USB I/O protocol
endpoint	Endpoint address
data	Data buffer
len	Length of data
timeout	Timeout (in milliseconds)

Return values

status	Transfer status
efirc	EFI status code

Definition at line 635 of file efi_usb.c.

                                                                    {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        size_t actual = *len;
        struct efi_saved_tpl tpl;
        int rc;
 
        DBGC2 ( usbdev, "USBDEV %s bulk %s %p+%zx %dms\n", usbintf->name,
                ( ( endpoint & USB_ENDPOINT_IN ) ? "IN" : "OUT" ), data,
                ( ( size_t ) *len ), ( ( unsigned int ) timeout ) );
 
        /* Raise TPL */
        efi_raise_tpl ( &tpl );
 
        /* Clear status */
        *status = 0;
 
        /* Perform synchronous transfer */
        if ( ( rc = efi_usb_sync_transfer ( usbintf, endpoint,
                                            USB_ENDPOINT_ATTR_BULK, timeout,
                                            data, &actual ) ) != 0 ) {
                /* Assume that any error represents a timeout */
                *status = EFI_USB_ERR_TIMEOUT;
                goto err_transfer;
        }
 
 err_transfer:
        efi_restore_tpl ( &tpl );
        return EFIRC ( rc );
}

References container_of, data, DBGC2, efi_raise_tpl(), efi_restore_tpl(), EFI_USB_ERR_TIMEOUT, efi_usb_sync_transfer(), EFIRC, len, efi_usb_interface::name, rc, status, timeout(), USB_ENDPOINT_ATTR_BULK, USB_ENDPOINT_IN, efi_usb_interface::usbdev, efi_usb_interface::usbio, and VOID.

efi_usb_sync_interrupt_transfer()

EFI_STATUS EFIAPI efi_usb_sync_interrupt_transfer ( EFI_USB_IO_PROTOCOL * usbio, UINT8 endpoint, VOID * data, UINTN * len, UINTN timeout, UINT32 * status )

static

Perform synchronous interrupt transfer.

Parameters

usbio	USB I/O protocol
endpoint	Endpoint address
data	Data buffer
len	Length of data
timeout	Timeout (in milliseconds)

Return values

status	Transfer status
efirc	EFI status code

Definition at line 680 of file efi_usb.c.

                                                   {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        size_t actual = *len;
        struct efi_saved_tpl tpl;
        int rc;
 
        DBGC2 ( usbdev, "USBDEV %s sync intr %s %p+%zx %dms\n", usbintf->name,
                ( ( endpoint & USB_ENDPOINT_IN ) ? "IN" : "OUT" ), data,
                ( ( size_t ) *len ), ( ( unsigned int ) timeout ) );
 
        /* Raise TPL */
        efi_raise_tpl ( &tpl );
 
        /* Clear status */
        *status = 0;
 
        /* Perform synchronous transfer */
        if ( ( rc = efi_usb_sync_transfer ( usbintf, endpoint,
                                            USB_ENDPOINT_ATTR_INTERRUPT,
                                            timeout, data, &actual ) ) != 0 ) {
                /* Assume that any error represents a timeout */
                *status = EFI_USB_ERR_TIMEOUT;
                goto err_transfer;
        }
 
 err_transfer:
        efi_restore_tpl ( &tpl );
        return EFIRC ( rc );
}

References container_of, data, DBGC2, efi_raise_tpl(), efi_restore_tpl(), EFI_USB_ERR_TIMEOUT, efi_usb_sync_transfer(), EFIRC, len, efi_usb_interface::name, rc, status, timeout(), USB_ENDPOINT_ATTR_INTERRUPT, USB_ENDPOINT_IN, efi_usb_interface::usbdev, efi_usb_interface::usbio, and VOID.

efi_usb_async_interrupt_transfer()

EFI_STATUS EFIAPI efi_usb_async_interrupt_transfer ( EFI_USB_IO_PROTOCOL * usbio, UINT8 endpoint, BOOLEAN start, UINTN interval, UINTN len, EFI_ASYNC_USB_TRANSFER_CALLBACK callback, VOID * context )

static

Perform asynchronous interrupt transfer.

Parameters

usbio	USB I/O protocol
endpoint	Endpoint address
start	Start (rather than stop) transfer
interval	Polling interval (in milliseconds)
len	Data length
callback	Callback function
context	Context for callback function

Return values

efirc

EFI status code

Definition at line 727 of file efi_usb.c.

                                                   {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct efi_saved_tpl tpl;
        int rc;
 
        DBGC2 ( usbdev, "USBDEV %s async intr %s len %#zx int %d %p/%p\n",
                usbintf->name,
                ( ( endpoint & USB_ENDPOINT_IN ) ? "IN" : "OUT" ),
                ( ( size_t ) len ), ( ( unsigned int ) interval ),
                callback, context );
 
        /* Raise TPL */
        efi_raise_tpl ( &tpl );
 
        /* Start/stop transfer as applicable */
        if ( start ) {
 
                /* Start new transfer */
                if ( ( rc = efi_usb_async_start ( usbintf, endpoint, interval,
                                                  len, callback,
                                                  context ) ) != 0 )
                        goto err_start;
 
        } else {
 
                /* Stop transfer */
                efi_usb_async_stop ( usbintf, endpoint );
 
                /* Success */
                rc = 0;
 
        }
 
 err_start:
        efi_restore_tpl ( &tpl );
        return EFIRC ( rc );
}

References container_of, DBGC2, efi_raise_tpl(), efi_restore_tpl(), efi_usb_async_start(), efi_usb_async_stop(), EFIRC, len, efi_usb_interface::name, rc, start, USB_ENDPOINT_IN, efi_usb_interface::usbdev, efi_usb_interface::usbio, and VOID.

efi_usb_isochronous_transfer()

EFI_STATUS EFIAPI efi_usb_isochronous_transfer ( EFI_USB_IO_PROTOCOL * usbio, UINT8 endpoint, VOID * data, UINTN len, UINT32 * status )

static

Perform synchronous isochronous transfer.

Parameters

usbio	USB I/O protocol
endpoint	Endpoint address
data	Data buffer
len	Length of data

Return values

status	Transfer status
efirc	EFI status code

Definition at line 781 of file efi_usb.c.

                                                                       {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
 
        DBGC2 ( usbdev, "USBDEV %s sync iso %s %p+%zx\n", usbintf->name,
                ( ( endpoint & USB_ENDPOINT_IN ) ? "IN" : "OUT" ), data,
                ( ( size_t ) len ) );
 
        /* Clear status */
        *status = 0;
 
        /* Not supported */
        return EFI_UNSUPPORTED;
}

References container_of, data, DBGC2, EFI_UNSUPPORTED, len, efi_usb_interface::name, status, USB_ENDPOINT_IN, efi_usb_interface::usbdev, efi_usb_interface::usbio, and VOID.

efi_usb_async_isochronous_transfer()

EFI_STATUS EFIAPI efi_usb_async_isochronous_transfer ( EFI_USB_IO_PROTOCOL * usbio, UINT8 endpoint, VOID * data, UINTN len, EFI_ASYNC_USB_TRANSFER_CALLBACK callback, VOID * context )

static

Perform asynchronous isochronous transfers.

Parameters

usbio	USB I/O protocol
endpoint	Endpoint address
data	Data buffer
len	Length of data
callback	Callback function
context	Context for callback function

Return values

status	Transfer status
efirc	EFI status code

Definition at line 811 of file efi_usb.c.

                                                     {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
 
        DBGC2 ( usbdev, "USBDEV %s async iso %s %p+%zx %p/%p\n", usbintf->name,
                ( ( endpoint & USB_ENDPOINT_IN ) ? "IN" : "OUT" ), data,
                ( ( size_t ) len ), callback, context );
 
        /* Not supported */
        return EFI_UNSUPPORTED;
}

References container_of, data, DBGC2, EFI_UNSUPPORTED, len, efi_usb_interface::name, USB_ENDPOINT_IN, efi_usb_interface::usbdev, efi_usb_interface::usbio, and VOID.

efi_usb_get_device_descriptor()

EFI_STATUS EFIAPI efi_usb_get_device_descriptor ( EFI_USB_IO_PROTOCOL * usbio, EFI_USB_DEVICE_DESCRIPTOR * efidesc )

static

Get device descriptor.

Parameters

usbio

USB I/O protocol

Return values

efidesc	EFI device descriptor
efirc	EFI status code

Definition at line 835 of file efi_usb.c.

                                                                     {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
 
        DBGC2 ( usbdev, "USBDEV %s get device descriptor\n", usbintf->name );
 
        /* Copy cached device descriptor */
        memcpy ( efidesc, &usbdev->func->usb->device, sizeof ( *efidesc ) );
 
        return 0;
}

References container_of, DBGC2, usb_device::device, efi_usb_device::func, memcpy(), efi_usb_interface::name, usb_function::usb, efi_usb_interface::usbdev, and efi_usb_interface::usbio.

efi_usb_get_config_descriptor()

EFI_STATUS EFIAPI efi_usb_get_config_descriptor ( EFI_USB_IO_PROTOCOL * usbio, EFI_USB_CONFIG_DESCRIPTOR * efidesc )

static

Get configuration descriptor.

Parameters

usbio

USB I/O protocol

Return values

efidesc	EFI interface descriptor
efirc	EFI status code

Definition at line 857 of file efi_usb.c.

                                                                     {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
 
        DBGC2 ( usbdev, "USBDEV %s get configuration descriptor\n",
                usbintf->name );
 
        /* Copy cached configuration descriptor */
        memcpy ( efidesc, usbdev->config, sizeof ( *efidesc ) );
 
        return 0;
}

References efi_usb_device::config, container_of, DBGC2, memcpy(), efi_usb_interface::name, efi_usb_interface::usbdev, and efi_usb_interface::usbio.

efi_usb_get_interface_descriptor()

EFI_STATUS EFIAPI efi_usb_get_interface_descriptor ( EFI_USB_IO_PROTOCOL * usbio, EFI_USB_INTERFACE_DESCRIPTOR * efidesc )

static

Get interface descriptor.

Parameters

usbio

USB I/O protocol

Return values

efidesc	EFI interface descriptor
efirc	EFI status code

Definition at line 880 of file efi_usb.c.

                                                                           {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct usb_interface_descriptor *desc;
 
        DBGC2 ( usbdev, "USBDEV %s get interface descriptor\n", usbintf->name );
 
        /* Locate cached interface descriptor */
        desc = usb_interface_descriptor ( usbdev->config, usbintf->interface,
                                          usbintf->alternate );
        if ( ! desc ) {
                DBGC ( usbdev, "USBDEV %s alt %d has no interface descriptor\n",
                       usbintf->name, usbintf->alternate );
                return -ENOENT;
        }
 
        /* Copy cached interface descriptor */
        memcpy ( efidesc, desc, sizeof ( *efidesc ) );
 
        return 0;
}

References efi_usb_interface::alternate, efi_usb_device::config, container_of, DBGC, DBGC2, desc, ENOENT, efi_usb_interface::interface, memcpy(), efi_usb_interface::name, usb_interface_descriptor(), efi_usb_interface::usbdev, and efi_usb_interface::usbio.

efi_usb_get_endpoint_descriptor()

EFI_STATUS EFIAPI efi_usb_get_endpoint_descriptor ( EFI_USB_IO_PROTOCOL * usbio, UINT8 index, EFI_USB_ENDPOINT_DESCRIPTOR * efidesc )

static

Get endpoint descriptor.

Parameters

usbio	USB I/O protocol
address	Endpoint index

Return values

efidesc	EFI interface descriptor
efirc	EFI status code

Definition at line 913 of file efi_usb.c.

                                                                         {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct usb_interface_descriptor *interface;
        struct usb_endpoint_descriptor *desc;
 
        DBGC2 ( usbdev, "USBDEV %s get endpoint %d descriptor\n",
                usbintf->name, index );
 
        /* Locate cached interface descriptor */
        interface = usb_interface_descriptor ( usbdev->config,
                                               usbintf->interface,
                                               usbintf->alternate );
        if ( ! interface ) {
                DBGC ( usbdev, "USBDEV %s alt %d has no interface descriptor\n",
                       usbintf->name, usbintf->alternate );
                return -ENOENT;
        }
 
        /* Locate and copy cached endpoint descriptor */
        for_each_interface_descriptor ( desc, usbdev->config, interface ) {
                if ( ( desc->header.type == USB_ENDPOINT_DESCRIPTOR ) &&
                     ( index-- == 0 ) ) {
                        memcpy ( efidesc, desc, sizeof ( *efidesc ) );
                        return 0;
                }
        }
        return -ENOENT;
}

References alternate, efi_usb_interface::alternate, efi_usb_device::config, container_of, DBGC, DBGC2, desc, ENOENT, for_each_interface_descriptor, index, memcpy(), efi_usb_interface::name, USB_ENDPOINT_DESCRIPTOR, efi_usb_interface::usbdev, and efi_usb_interface::usbio.

efi_usb_get_string_descriptor()

EFI_STATUS EFIAPI efi_usb_get_string_descriptor ( EFI_USB_IO_PROTOCOL * usbio, UINT16 language, UINT8 index, CHAR16 ** string )

static

Get string descriptor.

Parameters

usbio	USB I/O protocol
language	Language ID
index	String index

Return values

string	String
efirc	EFI status code

Definition at line 955 of file efi_usb.c.

                                                               {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
        struct usb_descriptor_header header;
        struct efi_saved_tpl tpl;
        VOID *buffer;
        size_t len;
        EFI_STATUS efirc;
        int rc;
 
        DBGC2 ( usbdev, "USBDEV %s get string %d:%d descriptor\n",
                usbintf->name, language, index );
 
        /* Raise TPL */
        efi_raise_tpl ( &tpl );
 
        /* Read descriptor header */
        if ( ( rc = usb_get_descriptor ( usbdev->func->usb, 0,
                                         USB_STRING_DESCRIPTOR, index,
                                         language, &header,
                                         sizeof ( header ) ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s could not get string %d:%d "
                       "descriptor header: %s\n", usbintf->name, language,
                       index, strerror ( rc ) );
                goto err_get_header;
        }
        len = header.len;
        if ( len < sizeof ( header ) ) {
                DBGC ( usbdev, "USBDEV %s underlength string %d:%d\n",
                       usbintf->name, language, index );
                rc = -EINVAL;
                goto err_len;
        }
 
        /* Allocate buffer */
        if ( ( efirc = bs->AllocatePool ( EfiBootServicesData, len,
                                          &buffer ) ) != 0 ) {
                rc = -EEFI ( efirc );
                goto err_alloc;
        }
 
        /* Read whole descriptor */
        if ( ( rc = usb_get_descriptor ( usbdev->func->usb, 0,
                                         USB_STRING_DESCRIPTOR, index,
                                         language, buffer, len ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s could not get string %d:%d "
                       "descriptor: %s\n", usbintf->name, language,
                       index, strerror ( rc ) );
                goto err_get_descriptor;
        }
 
        /* Shuffle down and terminate string */
        memmove ( buffer, ( buffer + sizeof ( header ) ),
                  ( len - sizeof ( header ) ) );
        memset ( ( buffer + len - sizeof ( header ) ), 0, sizeof ( **string ) );
 
        /* Restore TPL */
        efi_restore_tpl ( &tpl );
 
        /* Return allocated string */
        *string = buffer;
        return 0;
 
 err_get_descriptor:
        bs->FreePool ( buffer );
 err_alloc:
 err_len:
 err_get_header:
        efi_restore_tpl ( &tpl );
        return EFIRC ( rc );
}

References EFI_BOOT_SERVICES::AllocatePool, buffer, container_of, DBGC, DBGC2, EEFI, efi_raise_tpl(), efi_restore_tpl(), efi_systab, EfiBootServicesData, EFIRC, EINVAL, EFI_BOOT_SERVICES::FreePool, efi_usb_device::func, header, index, len, memmove(), memset(), efi_usb_interface::name, rc, strerror(), usb_function::usb, usb_get_descriptor(), USB_STRING_DESCRIPTOR, efi_usb_interface::usbdev, efi_usb_interface::usbio, and VOID.

efi_usb_get_supported_languages()

EFI_STATUS EFIAPI efi_usb_get_supported_languages ( EFI_USB_IO_PROTOCOL * usbio, UINT16 ** languages, UINT16 * len )

static

Get supported languages.

Parameters

usbio

USB I/O protocol

Return values

languages	Language ID table
len	Length of language ID table
efirc	EFI status code

Definition at line 1039 of file efi_usb.c.

                                                                    {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
 
        DBGC2 ( usbdev, "USBDEV %s get supported languages\n", usbintf->name );
 
        /* Return cached supported languages */
        *languages = usbdev->lang;
        *len = usbdev->lang_len;
 
        return 0;
}

References container_of, DBGC2, efi_usb_device::lang, efi_usb_device::lang_len, len, efi_usb_interface::name, efi_usb_interface::usbdev, and efi_usb_interface::usbio.

efi_usb_port_reset()

EFI_STATUS EFIAPI efi_usb_port_reset ( EFI_USB_IO_PROTOCOL * usbio )

static

Reset port.

Parameters

usbio

USB I/O protocol

Return values

efirc

EFI status code

Definition at line 1061 of file efi_usb.c.

                                                  {
        struct efi_usb_interface *usbintf =
                container_of ( usbio, struct efi_usb_interface, usbio );
        struct efi_usb_device *usbdev = usbintf->usbdev;
 
        DBGC2 ( usbdev, "USBDEV %s reset port\n", usbintf->name );
 
        /* This is logically impossible to do, since resetting the
         * port may destroy state belonging to other
         * EFI_USB_IO_PROTOCOL instances belonging to the same USB
         * device.  (This is yet another artifact of the incredibly
         * poor design of the EFI_USB_IO_PROTOCOL.)
         */
        return EFI_INVALID_PARAMETER;
}

References container_of, DBGC2, EFI_INVALID_PARAMETER, efi_usb_interface::name, efi_usb_interface::usbdev, and efi_usb_interface::usbio.

efi_usb_install()

int efi_usb_install ( struct efi_usb_device * usbdev, unsigned int interface )

static

Install interface.

Parameters

usbdev	EFI USB device
interface	Interface number

Return values

rc	Return status code

Definition at line 1108 of file efi_usb.c.

                                                      {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct usb_function *func = usbdev->func;
        struct efi_usb_interface *usbintf;
        int leak = 0;
        EFI_STATUS efirc;
        int rc;
 
        /* Allocate and initialise structure */
        usbintf = zalloc ( sizeof ( *usbintf ) );
        if ( ! usbintf ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        snprintf ( usbintf->name, sizeof ( usbintf->name ), "%s[%d]",
                   usbdev->name, interface );
        usbintf->usbdev = usbdev;
        usbintf->interface = interface;
        memcpy ( &usbintf->usbio, &efi_usb_io_protocol,
                 sizeof ( usbintf->usbio ) );
 
        /* Construct device path */
        usbintf->path = efi_usb_path ( func );
        if ( ! usbintf->path ) {
                rc = -ENODEV;
                goto err_path;
        }
 
        /* Add to list of interfaces */
        list_add_tail ( &usbintf->list, &usbdev->interfaces );
 
        /* Install protocols */
        if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
                        &usbintf->handle,
                        &efi_usb_io_protocol_guid, &usbintf->usbio,
                        &efi_device_path_protocol_guid, usbintf->path,
                        NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( usbdev, "USBDEV %s could not install protocols: %s\n",
                       usbintf->name, strerror ( rc ) );
                goto err_install_protocol;
        }
 
        DBGC ( usbdev, "USBDEV %s installed as %s\n",
               usbintf->name, efi_handle_name ( usbintf->handle ) );
        return 0;
 
        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                        usbintf->handle,
                        &efi_usb_io_protocol_guid, &usbintf->usbio,
                        &efi_device_path_protocol_guid, usbintf->path,
                        NULL ) ) != 0 ) {
                DBGC ( usbdev, "USBDEV %s could not uninstall: %s\n",
                       usbintf->name, strerror ( -EEFI ( efirc ) ) );
                leak = 1;
        }
        efi_nullify_usbio ( &usbintf->usbio );
 err_install_protocol:
        efi_usb_close_all ( usbintf );
        efi_usb_free_all ( usbintf );
        list_del ( &usbintf->list );
        if ( ! leak )
                free ( usbintf->path );
 err_path:
        if ( ! leak )
                free ( usbintf );
 err_alloc:
        if ( leak ) {
                DBGC ( usbdev, "USBDEV %s nullified and leaked\n",
                       usbintf->name );
        }
        return rc;
}

References DBGC, EEFI, efi_device_path_protocol_guid, efi_handle_name(), efi_nullify_usbio(), efi_systab, efi_usb_close_all(), efi_usb_free_all(), efi_usb_io_protocol, efi_usb_io_protocol_guid, efi_usb_path(), ENODEV, ENOMEM, free, efi_usb_device::func, efi_usb_interface::handle, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, efi_usb_interface::interface, efi_usb_device::interfaces, efi_usb_interface::list, list_add_tail, list_del, memcpy(), efi_usb_device::name, efi_usb_interface::name, NULL, efi_usb_interface::path, rc, snprintf(), strerror(), EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces, efi_usb_interface::usbdev, efi_usb_interface::usbio, and zalloc().

Referenced by efi_usb_probe().

efi_usb_uninstall()

void efi_usb_uninstall ( struct efi_usb_interface * usbintf )

static

Uninstall interface.

Parameters

usbintf

EFI USB interface

Definition at line 1188 of file efi_usb.c.

                                                                    {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_usb_device *usbdev = usbintf->usbdev;
        int leak = efi_shutdown_in_progress;
        EFI_STATUS efirc;
 
        DBGC ( usbdev, "USBDEV %s uninstalling %s\n",
               usbintf->name, efi_handle_name ( usbintf->handle ) );
 
        /* Disconnect controllers.  This should not be necessary, but
         * seems to be required on some platforms to avoid failures
         * when uninstalling protocols.
         */
        if ( ! efi_shutdown_in_progress )
                efi_disconnect ( usbintf->handle, NULL );
 
        /* Uninstall protocols */
        if ( ( ! efi_shutdown_in_progress ) &&
             ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                        usbintf->handle,
                        &efi_usb_io_protocol_guid, &usbintf->usbio,
                        &efi_device_path_protocol_guid, usbintf->path,
                        NULL ) ) != 0 ) ) {
                DBGC ( usbdev, "USBDEV %s could not uninstall: %s\n",
                       usbintf->name, strerror ( -EEFI ( efirc ) ) );
                leak = 1;
        }
        efi_nullify_usbio ( &usbintf->usbio );
 
        /* Close and free all endpoints */
        efi_usb_close_all ( usbintf );
        efi_usb_free_all ( usbintf );
 
        /* Remove from list of interfaces */
        list_del ( &usbintf->list );
 
        /* Free device path */
        if ( ! leak )
                free ( usbintf->path );
 
        /* Free interface */
        if ( ! leak )
                free ( usbintf );
 
        /* Report leakage, if applicable */
        if ( leak && ( ! efi_shutdown_in_progress ) ) {
                DBGC ( usbdev, "USBDEV %s nullified and leaked\n",
                       usbintf->name );
        }
}

References DBGC, EEFI, efi_device_path_protocol_guid, efi_disconnect(), efi_handle_name(), efi_nullify_usbio(), efi_shutdown_in_progress, efi_systab, efi_usb_close_all(), efi_usb_free_all(), efi_usb_io_protocol_guid, free, efi_usb_interface::handle, efi_usb_interface::list, list_del, efi_usb_interface::name, NULL, efi_usb_interface::path, strerror(), EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces, efi_usb_interface::usbdev, and efi_usb_interface::usbio.

Referenced by efi_usb_uninstall_all().

efi_usb_uninstall_all()

void efi_usb_uninstall_all ( struct efi_usb_device * efiusb )

static

Uninstall all interfaces.

Parameters

usbdev

EFI USB device

Definition at line 1244 of file efi_usb.c.

                                                                    {
        struct efi_usb_interface *usbintf;
 
        /* Uninstall all interfaces */
        while ( ( usbintf = list_first_entry ( &efiusb->interfaces,
                                               struct efi_usb_interface,
                                               list ) ) ) {
                efi_usb_uninstall ( usbintf );
        }
}

References efi_usb_uninstall(), efi_usb_device::interfaces, efi_usb_interface::list, and list_first_entry.

Referenced by efi_usb_probe(), and efi_usb_remove().

efi_usb_probe()

int efi_usb_probe ( struct usb_function * func, struct usb_configuration_descriptor * config )

static

Probe device.

Parameters

func	USB function
config	Configuration descriptor

Return values

rc	Return status code

Definition at line 1262 of file efi_usb.c.

                                                                         {
        struct usb_device *usb = func->usb;
        struct efi_usb_device *usbdev;
        struct efi_usb_interface *usbintf;
        struct usb_descriptor_header header;
        struct usb_descriptor_header *lang;
        size_t config_len;
        size_t lang_len;
        unsigned int i;
        int rc;
 
        /* Get configuration length */
        config_len = le16_to_cpu ( config->len );
 
        /* Get supported languages descriptor header */
        if ( ( rc = usb_get_descriptor ( usb, 0, USB_STRING_DESCRIPTOR, 0, 0,
                                         &header, sizeof ( header ) ) ) != 0 ) {
                /* Assume no strings are present */
                header.len = 0;
        }
        lang_len = ( ( header.len >= sizeof ( header ) ) ?
                     ( header.len - sizeof ( header ) ) : 0 );
 
        /* Allocate and initialise structure */
        usbdev = zalloc ( sizeof ( *usbdev ) + config_len +
                          sizeof ( *lang ) + lang_len );
        if ( ! usbdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        usb_func_set_drvdata ( func, usbdev );
        usbdev->name = func->name;
        usbdev->func = func;
        usbdev->config = ( ( ( void * ) usbdev ) + sizeof ( *usbdev ) );
        memcpy ( usbdev->config, config, config_len );
        lang = ( ( ( void * ) usbdev->config ) + config_len );
        usbdev->lang = ( ( ( void * ) lang ) + sizeof ( *lang ) );
        usbdev->lang_len = lang_len;
        INIT_LIST_HEAD ( &usbdev->interfaces );
 
        /* Get supported languages descriptor, if applicable */
        if ( lang_len &&
             ( ( rc = usb_get_descriptor ( usb, 0, USB_STRING_DESCRIPTOR,
                                           0, 0, lang, header.len ) ) != 0 ) ) {
                DBGC ( usbdev, "USBDEV %s could not get supported languages: "
                       "%s\n", usbdev->name, strerror ( rc ) );
                goto err_get_languages;
        }
 
        /* Install interfaces */
        for ( i = 0 ; i < func->desc.count ; i++ ) {
                if ( ( rc = efi_usb_install ( usbdev,
                                              func->interface[i] ) ) != 0 )
                        goto err_install;
        }
 
        /* Connect any external drivers */
        list_for_each_entry ( usbintf, &usbdev->interfaces, list )
                efi_connect ( usbintf->handle, NULL );
 
        return 0;
 
 err_install:
        efi_usb_uninstall_all ( usbdev );
        assert ( list_empty ( &usbdev->interfaces ) );
 err_get_languages:
        free ( usbdev );
 err_alloc:
        return rc;
}

References assert, efi_usb_device::config, usb_function_descriptor::count, DBGC, usb_function::desc, efi_connect(), efi_usb_install(), efi_usb_uninstall_all(), ENOMEM, free, efi_usb_device::func, efi_usb_interface::handle, header, INIT_LIST_HEAD, usb_function::interface, efi_usb_device::interfaces, efi_usb_device::lang, efi_usb_device::lang_len, le16_to_cpu, usb_configuration_descriptor::len, list_empty, list_for_each_entry, memcpy(), efi_usb_device::name, usb_function::name, NULL, rc, strerror(), usb_function::usb, usb_func_set_drvdata(), usb_get_descriptor(), USB_STRING_DESCRIPTOR, and zalloc().

efi_usb_remove()

void efi_usb_remove ( struct usb_function * func )

static

Remove device.

Parameters

func	USB function

Definition at line 1339 of file efi_usb.c.

                                                         {
        struct efi_usb_device *usbdev = usb_func_get_drvdata ( func );
 
        /* Uninstall all interfaces */
        efi_usb_uninstall_all ( usbdev );
        assert ( list_empty ( &usbdev->interfaces ) );
 
        /* Free device */
        free ( usbdev );
}

References assert, efi_usb_uninstall_all(), free, efi_usb_device::func, efi_usb_device::interfaces, list_empty, and usb_func_get_drvdata().

Variable Documentation

efi_usb_sync_driver

struct usb_endpoint_driver_operations efi_usb_sync_driver

static

Initial value:

= {
        .complete = efi_usb_sync_complete,
}

Synchronous endpoint operations.

Definition at line 298 of file efi_usb.c.

                                                                   {
        .complete = efi_usb_sync_complete,
};

Referenced by efi_usb_sync_transfer().

efi_usb_async_driver

struct usb_endpoint_driver_operations efi_usb_async_driver

static

Initial value:

= {
        .complete = efi_usb_async_complete,
}

Asynchronous endpoint operations.

Definition at line 435 of file efi_usb.c.

                                                                    {
        .complete = efi_usb_async_complete,
};

Referenced by efi_usb_async_start().

efi_usb_io_protocol

EFI_USB_IO_PROTOCOL efi_usb_io_protocol

static

Initial value:

= {
        .UsbControlTransfer             = efi_usb_control_transfer,
        .UsbBulkTransfer                = efi_usb_bulk_transfer,
        .UsbAsyncInterruptTransfer      = efi_usb_async_interrupt_transfer,
        .UsbSyncInterruptTransfer       = efi_usb_sync_interrupt_transfer,
        .UsbIsochronousTransfer         = efi_usb_isochronous_transfer,
        .UsbAsyncIsochronousTransfer    = efi_usb_async_isochronous_transfer,
        .UsbGetDeviceDescriptor         = efi_usb_get_device_descriptor,
        .UsbGetConfigDescriptor         = efi_usb_get_config_descriptor,
        .UsbGetInterfaceDescriptor      = efi_usb_get_interface_descriptor,
        .UsbGetEndpointDescriptor       = efi_usb_get_endpoint_descriptor,
        .UsbGetStringDescriptor         = efi_usb_get_string_descriptor,
        .UsbGetSupportedLanguages       = efi_usb_get_supported_languages,
        .UsbPortReset                   = efi_usb_port_reset,
}

USB I/O protocol.

Definition at line 1078 of file efi_usb.c.

                                                 {
        .UsbControlTransfer             = efi_usb_control_transfer,
        .UsbBulkTransfer                = efi_usb_bulk_transfer,
        .UsbAsyncInterruptTransfer      = efi_usb_async_interrupt_transfer,
        .UsbSyncInterruptTransfer       = efi_usb_sync_interrupt_transfer,
        .UsbIsochronousTransfer         = efi_usb_isochronous_transfer,
        .UsbAsyncIsochronousTransfer    = efi_usb_async_isochronous_transfer,
        .UsbGetDeviceDescriptor         = efi_usb_get_device_descriptor,
        .UsbGetConfigDescriptor         = efi_usb_get_config_descriptor,
        .UsbGetInterfaceDescriptor      = efi_usb_get_interface_descriptor,
        .UsbGetEndpointDescriptor       = efi_usb_get_endpoint_descriptor,
        .UsbGetStringDescriptor         = efi_usb_get_string_descriptor,
        .UsbGetSupportedLanguages       = efi_usb_get_supported_languages,
        .UsbPortReset                   = efi_usb_port_reset,
};

Referenced by efi_usb_install().

efi_usb_ids

struct usb_device_id efi_usb_ids[]

static

Initial value:

= {
        USB_ID ( 0xffff, 0xffff, "usbio", "USB passthrough", 0 ),
}

USB I/O protocol device IDs.

Definition at line 1351 of file efi_usb.c.

                                            {
        USB_ID ( 0xffff, 0xffff, "usbio", "USB passthrough", 0 ),
};

__usb_fallback_driver

struct usb_driver usbio_driver __usb_fallback_driver

Initial value:

= {
        .ids = efi_usb_ids,
        .id_count = ( sizeof ( efi_usb_ids ) / sizeof ( efi_usb_ids[0] ) ),
        .class = USB_CLASS_ID ( USB_ANY_ID, USB_ANY_ID, USB_ANY_ID ),
        .score = USB_SCORE_FALLBACK,
        .probe = efi_usb_probe,
        .remove = efi_usb_remove,
}

USB I/O protocol driver.

Definition at line 1356 of file efi_usb.c.

                                                       {
        .ids = efi_usb_ids,
        .id_count = ( sizeof ( efi_usb_ids ) / sizeof ( efi_usb_ids[0] ) ),
        .class = USB_CLASS_ID ( USB_ANY_ID, USB_ANY_ID, USB_ANY_ID ),
        .score = USB_SCORE_FALLBACK,
        .probe = efi_usb_probe,
        .remove = efi_usb_remove,
};