usbblk.c File Reference

USB mass storage driver. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/usb.h>
#include <ipxe/scsi.h>
#include <ipxe/xfer.h>
#include <ipxe/uri.h>
#include <ipxe/open.h>
#include <ipxe/efi/efi_path.h>
#include "usbblk.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	usbblk_stop (struct usbblk_device *usbblk, int rc)
	Stop SCSI command.
static	LIST_HEAD (usbblk_devices)
	List of USB block devices.
static int	usbblk_open (struct usbblk_device *usbblk)
	Open endpoints.
static void	usbblk_close (struct usbblk_device *usbblk)
	Close endpoints.
static int	usbblk_out_command (struct usbblk_device *usbblk)
	Issue bulk OUT command.
static int	usbblk_out_data (struct usbblk_device *usbblk)
	Send bulk OUT data block.
static int	usbblk_out_refill (struct usbblk_device *usbblk)
	Refill bulk OUT endpoint.
static void	usbblk_out_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete bulk OUT transfer.
static int	usbblk_in_data (struct usbblk_device *usbblk, const void *data, size_t len)
	Handle bulk IN data block.
static int	usbblk_in_status (struct usbblk_device *usbblk, const void *data, size_t len)
	Handle bulk IN status.
static int	usbblk_in_refill (struct usbblk_device *usbblk)
	Refill bulk IN endpoint.
static void	usbblk_in_complete (struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
	Complete bulk IN transfer.
static void	usbblk_step (struct usbblk_device *usbblk)
	Refill endpoints.
static int	usbblk_start (struct usbblk_device *usbblk, struct scsi_cmd *scsicmd)
	Start new SCSI command.
static size_t	usbblk_scsi_window (struct usbblk_device *usbblk)
	Check SCSI command flow-control window.
static int	usbblk_scsi_command (struct usbblk_device *usbblk, struct interface *data, struct scsi_cmd *scsicmd)
	Issue SCSI command.
static void	usbblk_scsi_close (struct usbblk_device *usbblk, int rc)
	Close SCSI interface.
static EFI_DEVICE_PATH_PROTOCOL *	usbblk_efi_describe (struct usbblk_device *usbblk)
	Describe as an EFI device path.
static struct usbblk_device *	usbblk_find (const char *name)
	Find USB block device.
static int	usbblk_open_uri (struct interface *parent, struct uri *uri)
	Open USB block device URI.
static int	usbblk_probe (struct usb_function *func, struct usb_configuration_descriptor *config)
	Probe device.
static void	usbblk_remove (struct usb_function *func)
	Remove device.

Variables
static struct usb_endpoint_driver_operations	usbblk_out_operations
	Bulk OUT endpoint operations.
static struct usb_endpoint_driver_operations	usbblk_in_operations
	Bulk IN endpoint operations.
static struct process_descriptor	usbblk_process_desc
	Refill process descriptor.
static uint16_t	usbblk_tag
	Next command tag.
static struct interface_operation	usbblk_data_operations []
	SCSI data interface operations.
static struct interface_descriptor	usbblk_data_desc
	SCSI data interface descriptor.
static struct interface_operation	usbblk_scsi_operations []
	SCSI command interface operations.
static struct interface_descriptor	usbblk_scsi_desc
	SCSI command interface descriptor.
struct uri_opener usbblk_uri_opener	__uri_opener
	USB block device URI opener.
static struct usb_device_id	usbblk_ids []
	Mass storage class device IDs.
struct usb_driver usbblk_driver	__usb_driver
	Mass storage driver.

Detailed Description

USB mass storage driver.

Definition in file usbblk.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

References rc.

usbblk_stop()

void usbblk_stop ( struct usbblk_device * usbblk, int rc )

static

Stop SCSI command.

Parameters

usbblk	USB block device
rc	Reason for stop

Definition at line 559 of file usbblk.c.

                                                                 {
 
        /* Stop process */
        process_del ( &usbblk->process );
 
        /* Reset command */
        memset ( &usbblk->cmd, 0, sizeof ( usbblk->cmd ) );
 
        /* Close endpoints if an error occurred */
        if ( rc != 0 ) {
                DBGC ( usbblk, "USBBLK %s closing for error recovery\n",
                       usbblk->func->name );
                usbblk_close ( usbblk );
        }
 
        /* Terminate command */
        intf_restart ( &usbblk->data, rc );
}

References usbblk_device::cmd, usbblk_device::data, DBGC, usbblk_device::func, intf_restart(), memset(), usb_function::name, usbblk_device::process, process_del(), rc, and usbblk_close().

Referenced by usbblk_in_complete(), usbblk_in_status(), usbblk_out_complete(), usbblk_scsi_close(), and usbblk_scsi_command().

LIST_HEAD()

LIST_HEAD ( usbblk_devices )

static

List of USB block devices.

usbblk_open()

int usbblk_open ( struct usbblk_device * usbblk )

static

Open endpoints.

Parameters

usbblk

USB block device

Return values

rc	Return status code

Definition at line 63 of file usbblk.c.

                                                        {
        struct usb_device *usb = usbblk->func->usb;
        unsigned int interface = usbblk->func->interface[0];
        int rc;
 
        /* Sanity checks */
        assert ( ! usbblk->in.open );
        assert ( ! usbblk->out.open );
 
        /* Issue reset */
        if ( ( rc = usb_control ( usb, USBBLK_RESET, 0, interface,
                                  NULL, 0 ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not issue reset: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_reset;
        }
 
        /* Open bulk OUT endpoint */
        if ( ( rc = usb_endpoint_open ( &usbblk->out ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not open bulk OUT: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_open_out;
        }
 
        /* Clear any bulk OUT halt condition */
        if ( ( rc = usb_endpoint_clear_halt ( &usbblk->out ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not reset bulk OUT: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_clear_out;
        }
 
        /* Open bulk IN endpoint */
        if ( ( rc = usb_endpoint_open ( &usbblk->in ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not open bulk IN: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_open_in;
        }
 
        /* Clear any bulk IN halt condition */
        if ( ( rc = usb_endpoint_clear_halt ( &usbblk->in ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not reset bulk IN: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_clear_in;
        }
 
        return 0;
 
 err_clear_in:
        usb_endpoint_close ( &usbblk->in );
 err_open_in:
 err_clear_out:
        usb_endpoint_close ( &usbblk->out );
 err_open_out:
 err_reset:
        return rc;
}

References assert, DBGC, usbblk_device::func, usbblk_device::in, usb_function::name, NULL, usb_endpoint::open, usbblk_device::out, rc, strerror(), usb_function::usb, usb_control(), usb_endpoint_clear_halt(), usb_endpoint_close(), usb_endpoint_open(), and USBBLK_RESET.

Referenced by usbblk_scsi_command().

usbblk_close()

void usbblk_close ( struct usbblk_device * usbblk )

static

Close endpoints.

Parameters

usbblk

USB block device

Definition at line 125 of file usbblk.c.

                                                          {
 
        /* Close bulk OUT endpoint */
        if ( usbblk->out.open )
                usb_endpoint_close ( &usbblk->out );
 
        /* Close bulk IN endpoint */
        if ( usbblk->in.open )
                usb_endpoint_close ( &usbblk->in );
}

References usbblk_device::in, usb_endpoint::open, usbblk_device::out, and usb_endpoint_close().

Referenced by usbblk_scsi_close(), usbblk_scsi_command(), and usbblk_stop().

usbblk_out_command()

int usbblk_out_command ( struct usbblk_device * usbblk )

static

Issue bulk OUT command.

Parameters

usbblk

USB block device

Return values

rc	Return status code

Definition at line 149 of file usbblk.c.

                                                               {
        struct usbblk_command *cmd = &usbblk->cmd;
        struct usbblk_command_wrapper *wrapper;
        struct io_buffer *iobuf;
        int rc;
 
        /* Sanity checks */
        assert ( cmd->tag );
        assert ( ! ( cmd->scsi.data_in.len && cmd->scsi.data_out.len ) );
 
        /* Allocate I/O buffer */
        iobuf = alloc_iob ( sizeof ( *wrapper ) );
        if ( ! iobuf ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Populate command */
        wrapper = iob_put ( iobuf, sizeof ( *wrapper ) );
        memset ( wrapper, 0, sizeof ( *wrapper ) );
        wrapper->signature = cpu_to_le32 ( USBBLK_COMMAND_SIGNATURE );
        wrapper->tag = cmd->tag; /* non-endian */
        if ( cmd->scsi.data_out.len ) {
                wrapper->len = cpu_to_le32 ( cmd->scsi.data_out.len );
        } else {
                wrapper->len = cpu_to_le32 ( cmd->scsi.data_in.len );
                wrapper->flags = USB_DIR_IN;
        }
        wrapper->lun = ntohs ( cmd->scsi.lun.u16[0] );
        wrapper->cblen = sizeof ( wrapper->cb );
        memcpy ( wrapper->cb, &cmd->scsi.cdb, sizeof ( wrapper->cb ) );
 
        /* Issue command */
        if ( ( rc = usb_stream ( &usbblk->out, iobuf, 0 ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s bulk OUT could not issue command: "
                       "%s\n", usbblk->func->name, strerror ( rc ) );
                goto err_stream;
        }
 
        return 0;
 
 err_stream:
        free_iob ( iobuf );
 err_alloc:
        return rc;
}

References alloc_iob(), assert, usbblk_command_wrapper::cb, usbblk_command_wrapper::cblen, cmd, usbblk_device::cmd, cpu_to_le32, DBGC, ENOMEM, usbblk_command_wrapper::flags, free_iob(), usbblk_device::func, iob_put, usbblk_command_wrapper::len, usbblk_command_wrapper::lun, memcpy(), memset(), usb_function::name, ntohs, usbblk_device::out, rc, usbblk_command_wrapper::signature, strerror(), usbblk_command_wrapper::tag, USB_DIR_IN, usb_stream(), and USBBLK_COMMAND_SIGNATURE.

Referenced by usbblk_start().

usbblk_out_data()

int usbblk_out_data ( struct usbblk_device * usbblk )

static

Send bulk OUT data block.

Parameters

usbblk

USB block device

Return values

rc	Return status code

Definition at line 202 of file usbblk.c.

                                                            {
        struct usbblk_command *cmd = &usbblk->cmd;
        struct io_buffer *iobuf;
        size_t len;
        int rc;
 
        /* Calculate length */
        assert ( cmd->tag );
        assert ( cmd->scsi.data_out.len != 0 );
        assert ( cmd->offset < cmd->scsi.data_out.len );
        len = ( cmd->scsi.data_out.len - cmd->offset );
        if ( len > USBBLK_MAX_LEN )
                len = USBBLK_MAX_LEN;
        assert ( ( len % usbblk->out.mtu ) == 0 );
 
        /* Allocate I/O buffer */
        iobuf = alloc_iob ( len );
        if ( ! iobuf ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Populate I/O buffer */
        if ( ( rc = xferbuf_read ( &cmd->scsi.data_out, cmd->offset,
                                   iob_put ( iobuf, len ), len ) ) != 0 )
                goto err_read;
 
        /* Send data */
        if ( ( rc = usb_stream ( &usbblk->out, iobuf, 0 ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s bulk OUT could not send data: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_stream;
        }
 
        /* Consume data */
        cmd->offset += len;
 
        return 0;
 
 err_stream:
 err_read:
        free_iob ( iobuf );
 err_alloc:
        return rc;
}

References alloc_iob(), assert, cmd, usbblk_device::cmd, DBGC, ENOMEM, free_iob(), usbblk_device::func, iob_put, len, usb_endpoint::mtu, usb_function::name, usbblk_device::out, rc, strerror(), usb_stream(), USBBLK_MAX_LEN, and xferbuf_read().

Referenced by usbblk_out_refill().

usbblk_out_refill()

int usbblk_out_refill ( struct usbblk_device * usbblk )

static

Refill bulk OUT endpoint.

Parameters

usbblk

USB block device

Return values

rc	Return status code

Definition at line 254 of file usbblk.c.

                                                              {
        struct usbblk_command *cmd = &usbblk->cmd;
        int rc;
 
        /* Sanity checks */
        assert ( cmd->tag );
 
        /* Refill endpoint */
        while ( ( cmd->offset < cmd->scsi.data_out.len ) &&
                ( usbblk->out.fill < USBBLK_MAX_FILL ) ) {
                if ( ( rc = usbblk_out_data ( usbblk ) ) != 0 )
                        return rc;
        }
 
        return 0;
}

References assert, cmd, usbblk_device::cmd, usb_endpoint::fill, usbblk_device::out, rc, USBBLK_MAX_FILL, and usbblk_out_data().

Referenced by usbblk_step().

usbblk_out_complete()

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

static

Complete bulk OUT transfer.

Parameters

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

Definition at line 278 of file usbblk.c.

                                                                    {
        struct usbblk_device *usbblk =
                container_of ( ep, struct usbblk_device, out );
        struct usbblk_command *cmd = &usbblk->cmd;
 
        /* Ignore cancellations after closing endpoint */
        if ( ! ep->open )
                goto drop;
 
        /* Sanity check */
        assert ( cmd->tag );
 
        /* Check for failures */
        if ( rc != 0 ) {
                DBGC ( usbblk, "USBBLK %s bulk OUT failed: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err;
        }
 
        /* Trigger refill process, if applicable */
        if ( cmd->offset < cmd->scsi.data_out.len )
                process_add ( &usbblk->process );
 
 drop:
        /* Free I/O buffer */
        free_iob ( iobuf );
 
        return;
 
 err:
        free_iob ( iobuf );
        usbblk_stop ( usbblk, rc );
}

References assert, cmd, usbblk_device::cmd, container_of, DBGC, free_iob(), usbblk_device::func, usb_function::name, usb_endpoint::open, out, usbblk_device::process, process_add(), rc, strerror(), and usbblk_stop().

usbblk_in_data()

int usbblk_in_data ( struct usbblk_device * usbblk, const void * data, size_t len )

static

Handle bulk IN data block.

Parameters

usbblk	USB block device
data	Data block
len	Length of data

Return values

rc	Return status code

Definition at line 333 of file usbblk.c.

                                         {
        struct usbblk_command *cmd = &usbblk->cmd;
        int rc;
 
        /* Sanity checks */
        assert ( cmd->tag );
        assert ( cmd->scsi.data_in.len != 0 );
        assert ( cmd->offset <= cmd->scsi.data_in.len );
        assert ( len <= ( cmd->scsi.data_in.len - cmd->offset ) );
 
        /* Store data */
        if ( ( rc = xferbuf_write ( &cmd->scsi.data_in, cmd->offset,
                                    data, len ) ) != 0 )
                return rc;
        cmd->offset += len;
 
        return 0;
}

References assert, cmd, usbblk_device::cmd, data, len, rc, and xferbuf_write().

Referenced by usbblk_in_complete().

usbblk_in_status()

int usbblk_in_status ( struct usbblk_device * usbblk, const void * data, size_t len )

static

Handle bulk IN status.

Parameters

usbblk	USB block device
data	Status data
len	Length of status data

Return values

rc	Return status code

Definition at line 361 of file usbblk.c.

                                           {
        struct usbblk_command *cmd = &usbblk->cmd;
        const struct usbblk_status_wrapper *stat;
 
        /* Sanity checks */
        assert ( cmd->tag );
 
        /* Validate length */
        if ( len < sizeof ( *stat ) ) {
                DBGC ( usbblk, "USBBLK %s bulk IN malformed status:\n",
                       usbblk->func->name );
                DBGC_HDA ( usbblk, 0, data, len );
                return -EIO;
        }
        stat = data;
 
        /* Validate signature */
        if ( stat->signature != cpu_to_le32 ( USBBLK_STATUS_SIGNATURE ) ) {
                DBGC ( usbblk, "USBBLK %s bulk IN invalid signature %08x:\n",
                       usbblk->func->name, le32_to_cpu ( stat->signature ) );
                DBGC_HDA ( usbblk, 0, stat, sizeof ( *stat ) );
                return -EIO;
        }
 
        /* Validate tag */
        if ( stat->tag != cmd->tag ) {
                DBGC ( usbblk, "USBBLK %s bulk IN tag mismatch (got %08x, "
                       "expected %08x):\n",
                       usbblk->func->name, stat->tag, cmd->tag );
                DBGC_HDA ( usbblk, 0, stat, sizeof ( *stat ) );
                return -EIO;
        }
 
        /* Check status */
        if ( stat->status ) {
                DBGC ( usbblk, "USBBLK %s bulk IN status %02x:\n",
                       usbblk->func->name, stat->status );
                DBGC_HDA ( usbblk, 0, stat, sizeof ( *stat ) );
                return -EIO;
        }
 
        /* Check for residual data */
        if ( stat->residue ) {
                DBGC ( usbblk, "USBBLK %s bulk IN residue %#x:\n",
                       usbblk->func->name, le32_to_cpu ( stat->residue ) );
                return -EIO;
        }
 
        /* Mark command as complete */
        usbblk_stop ( usbblk, 0 );
 
        return 0;
}

References assert, cmd, usbblk_device::cmd, cpu_to_le32, data, DBGC, DBGC_HDA, EIO, usbblk_device::func, le32_to_cpu, len, usb_function::name, stat, USBBLK_STATUS_SIGNATURE, and usbblk_stop().

Referenced by usbblk_in_complete().

usbblk_in_refill()

int usbblk_in_refill ( struct usbblk_device * usbblk )

static

Refill bulk IN endpoint.

Parameters

usbblk

USB block device

Return values

rc	Return status code

Definition at line 422 of file usbblk.c.

                                                             {
        struct usbblk_command *cmd = &usbblk->cmd;
        struct usbblk_status_wrapper *stat;
        size_t remaining;
        unsigned int max;
        int rc;
 
        /* Sanity checks */
        assert ( cmd->tag );
 
        /* Calculate maximum required refill */
        remaining = sizeof ( *stat );
        if ( cmd->scsi.data_in.len ) {
                assert ( cmd->offset <= cmd->scsi.data_in.len );
                remaining += ( cmd->scsi.data_in.len - cmd->offset );
        }
        max = ( ( remaining + USBBLK_MAX_LEN - 1 ) / USBBLK_MAX_LEN );
 
        /* Refill bulk IN endpoint */
        if ( ( rc = usb_refill_limit ( &usbblk->in, max ) ) != 0 )
                return rc;
 
        return 0;
}

References assert, cmd, usbblk_device::cmd, usbblk_device::in, max, rc, stat, usb_refill_limit(), and USBBLK_MAX_LEN.

Referenced by usbblk_step().

usbblk_in_complete()

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

static

Complete bulk IN transfer.

Parameters

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

Definition at line 454 of file usbblk.c.

                                                                   {
        struct usbblk_device *usbblk =
                container_of ( ep, struct usbblk_device, in );
        struct usbblk_command *cmd = &usbblk->cmd;
        size_t remaining;
        size_t len;
 
        /* Ignore cancellations after closing endpoint */
        if ( ! ep->open )
                goto drop;
 
        /* Sanity check */
        assert ( cmd->tag );
 
        /* Handle errors */
        if ( rc != 0 ) {
                DBGC ( usbblk, "USBBLK %s bulk IN failed: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err;
        }
 
        /* Trigger refill process */
        process_add ( &usbblk->process );
 
        /* Handle data portion, if any */
        if ( cmd->scsi.data_in.len ) {
                assert ( cmd->offset <= cmd->scsi.data_in.len );
                remaining = ( cmd->scsi.data_in.len - cmd->offset );
                len = iob_len ( iobuf );
                if ( len > remaining )
                        len = remaining;
                if ( len ) {
                        if ( ( rc = usbblk_in_data ( usbblk, iobuf->data,
                                                     len ) ) != 0 )
                                goto err;
                        iob_pull ( iobuf, len );
                }
        }
 
        /* Handle status portion, if any */
        len = iob_len ( iobuf );
        if ( len ) {
                if ( ( rc = usbblk_in_status ( usbblk, iobuf->data,
                                               len ) ) != 0 )
                        goto err;
        }
 
 drop:
        /* Free I/O buffer */
        free_iob ( iobuf );
 
        return;
 
 err:
        free_iob ( iobuf );
        usbblk_stop ( usbblk, rc );
}

References assert, cmd, usbblk_device::cmd, container_of, io_buffer::data, DBGC, free_iob(), usbblk_device::func, in, iob_len(), iob_pull, len, usb_function::name, usb_endpoint::open, usbblk_device::process, process_add(), rc, strerror(), usbblk_in_data(), usbblk_in_status(), and usbblk_stop().

usbblk_step()

void usbblk_step ( struct usbblk_device * usbblk )

static

Refill endpoints.

Parameters

usbblk

USB block device

Definition at line 530 of file usbblk.c.

                                                         {
 
        /* Refill bulk OUT endpoint */
        usbblk_out_refill ( usbblk );
 
        /* Refill bulk IN endpoint */
        usbblk_in_refill ( usbblk );
}

References usbblk_in_refill(), and usbblk_out_refill().

usbblk_start()

int usbblk_start ( struct usbblk_device * usbblk, struct scsi_cmd * scsicmd )

static

Start new SCSI command.

Parameters

usbblk	USB block device
scsicmd	SCSI command

Return values

rc	Return status code

Definition at line 585 of file usbblk.c.

                                                     {
        struct usbblk_command *cmd = &usbblk->cmd;
        int rc;
 
        /* Fail if command is in progress */
        if ( cmd->tag ) {
                rc = -EBUSY;
                DBGC ( usbblk, "USBBLK %s cannot support multiple commands\n",
                       usbblk->func->name );
                goto err_busy;
        }
 
        /* Refuse bidirectional commands */
        if ( scsicmd->data_in.len && scsicmd->data_out.len ) {
                rc = -EOPNOTSUPP;
                DBGC ( usbblk, "USBBLK %s cannot support bidirectional "
                       "commands\n", usbblk->func->name );
                goto err_bidirectional;
        }
 
        /* Sanity checks */
        assert ( ! process_running ( &usbblk->process ) );
        assert ( cmd->offset == 0 );
 
        /* Initialise command */
        memcpy ( &cmd->scsi, scsicmd, sizeof ( cmd->scsi ) );
        cmd->tag = ( USBBLK_TAG_MAGIC | ++usbblk_tag );
 
        /* Issue bulk OUT command */
        if ( ( rc = usbblk_out_command ( usbblk ) ) != 0 )
                goto err_command;
 
        /* Start refill process */
        process_add ( &usbblk->process );
 
        return 0;
 
 err_command:
        memset ( &usbblk->cmd, 0, sizeof ( usbblk->cmd ) );
 err_bidirectional:
 err_busy:
        return rc;
}

References assert, cmd, usbblk_device::cmd, scsi_cmd::data_in, scsi_cmd::data_out, DBGC, EBUSY, EOPNOTSUPP, usbblk_device::func, xfer_buffer::len, memcpy(), memset(), usb_function::name, usbblk_device::process, process_add(), process_running(), rc, usbblk_out_command(), usbblk_tag, and USBBLK_TAG_MAGIC.

Referenced by usbblk_scsi_command().

usbblk_scsi_window()

size_t usbblk_scsi_window ( struct usbblk_device * usbblk )

static

Check SCSI command flow-control window.

Parameters

usbblk

USB block device

Return values

len	Length of window

Definition at line 652 of file usbblk.c.

                                                                  {
        struct usbblk_command *cmd = &usbblk->cmd;
 
        /* Allow a single command if no command is currently in progress */
        return ( cmd->tag ? 0 : 1 );
}

References cmd, and usbblk_device::cmd.

usbblk_scsi_command()

int usbblk_scsi_command ( struct usbblk_device * usbblk, struct interface * data, struct scsi_cmd * scsicmd )

static

Issue SCSI command.

Parameters

usbblk	USB block device
data	SCSI data interface
scsicmd	SCSI command

Return values

tag	Command tag, or negative error

Definition at line 667 of file usbblk.c.

                                                            {
        struct usbblk_command *cmd = &usbblk->cmd;
        int rc;
 
        /* (Re)open endpoints if needed */
        if ( ( ! usbblk->in.open ) && ( ( rc = usbblk_open ( usbblk ) ) != 0 ) )
                goto err_open;
 
        /* Start new command */
        if ( ( rc = usbblk_start ( usbblk, scsicmd ) ) != 0 )
                goto err_start;
 
        /* Attach to parent interface and return */
        intf_plug_plug ( &usbblk->data, data );
        return cmd->tag;
 
        usbblk_stop ( usbblk, rc );
 err_start:
        usbblk_close ( usbblk );
 err_open:
        return rc;
}

References cmd, usbblk_device::cmd, data, usbblk_device::data, usbblk_device::in, intf_plug_plug(), usb_endpoint::open, rc, usbblk_close(), usbblk_open(), usbblk_start(), and usbblk_stop().

usbblk_scsi_close()

void usbblk_scsi_close ( struct usbblk_device * usbblk, int rc )

static

Close SCSI interface.

Parameters

usbblk	USB block device
rc	Reason for close

Definition at line 698 of file usbblk.c.

                                                                       {
 
        /* Restart interfaces */
        intfs_restart ( rc, &usbblk->scsi, &usbblk->data, NULL );
 
        /* Stop any in-progress command */
        usbblk_stop ( usbblk, rc );
 
        /* Close endpoints */
        usbblk_close ( usbblk );
 
        /* Flag as closed */
        usbblk->opened = 0;
}

References usbblk_device::data, intfs_restart(), NULL, usbblk_device::opened, rc, usbblk_device::scsi, usbblk_close(), and usbblk_stop().

Referenced by usbblk_remove().

usbblk_efi_describe()

EFI_DEVICE_PATH_PROTOCOL * usbblk_efi_describe ( struct usbblk_device * usbblk )

static

Describe as an EFI device path.

Parameters

usbblk

USB block device

Return values

path	EFI device path, or NULL on error

Definition at line 720 of file usbblk.c.

                                                     {
 
        return efi_usb_path ( usbblk->func );
}

References efi_usb_path(), and usbblk_device::func.

usbblk_find()

struct usbblk_device * usbblk_find ( const char * name )

static

Find USB block device.

Parameters

name	USB block device name

Return values

usbblk

USB block device, or NULL

Definition at line 751 of file usbblk.c.

                                                               {
        struct usbblk_device *usbblk;
 
        /* Look for matching device */
        list_for_each_entry ( usbblk, &usbblk_devices, list ) {
                if ( strcmp ( usbblk->func->name, name ) == 0 )
                        return usbblk;
        }
 
        return NULL;
}

References usbblk_device::func, usbblk_device::list, list_for_each_entry, name, usb_function::name, NULL, and strcmp().

Referenced by usbblk_open_uri().

usbblk_open_uri()

int usbblk_open_uri ( struct interface * parent, struct uri * uri )

static

Open USB block device URI.

Parameters

parent	Parent interface
uri	URI

Return values

rc	Return status code

Definition at line 770 of file usbblk.c.

                                                                         {
        static struct scsi_lun lun;
        struct usbblk_device *usbblk;
        int rc;
 
        /* Sanity check */
        if ( ! uri->opaque )
                return -EINVAL;
 
        /* Find matching device */
        usbblk = usbblk_find ( uri->opaque );
        if ( ! usbblk )
                return -ENOENT;
 
        /* Fail if device is already open */
        if ( usbblk->opened )
                return -EBUSY;
 
        /* Open SCSI device */
        if ( ( rc = scsi_open ( parent, &usbblk->scsi, &lun ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not open SCSI device: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                return rc;
        }
 
        /* Mark as opened */
        usbblk->opened = 1;
 
        return 0;
}

References DBGC, EBUSY, EINVAL, ENOENT, usbblk_device::func, lun, usb_function::name, uri::opaque, usbblk_device::opened, rc, usbblk_device::scsi, scsi_open(), strerror(), and usbblk_find().

usbblk_probe()

int usbblk_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 821 of file usbblk.c.

                                                                        {
        struct usb_device *usb = func->usb;
        struct usbblk_device *usbblk;
        struct usb_interface_descriptor *desc;
        int rc;
 
        /* Allocate and initialise structure */
        usbblk = zalloc ( sizeof ( *usbblk ) );
        if ( ! usbblk ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        usbblk->func = func;
        usb_endpoint_init ( &usbblk->out, usb, &usbblk_out_operations );
        usb_endpoint_init ( &usbblk->in, usb, &usbblk_in_operations );
        usb_refill_init ( &usbblk->in, 0, USBBLK_MAX_LEN, USBBLK_MAX_FILL );
        intf_init ( &usbblk->scsi, &usbblk_scsi_desc, &usbblk->refcnt );
        intf_init ( &usbblk->data, &usbblk_data_desc, &usbblk->refcnt );
        process_init_stopped ( &usbblk->process, &usbblk_process_desc,
                               &usbblk->refcnt );
 
        /* Locate interface descriptor */
        desc = usb_interface_descriptor ( config, func->interface[0], 0 );
        if ( ! desc ) {
                DBGC ( usbblk, "USBBLK %s missing interface descriptor\n",
                       usbblk->func->name );
                rc = -ENOENT;
                goto err_desc;
        }
 
        /* Describe endpoints */
        if ( ( rc = usb_endpoint_described ( &usbblk->out, config, desc,
                                             USB_BULK_OUT, 0 ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not describe bulk OUT: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_out;
        }
        if ( ( rc = usb_endpoint_described ( &usbblk->in, config, desc,
                                             USB_BULK_IN, 0 ) ) != 0 ) {
                DBGC ( usbblk, "USBBLK %s could not describe bulk IN: %s\n",
                       usbblk->func->name, strerror ( rc ) );
                goto err_in;
        }
 
        /* Add to list of devices */
        list_add_tail ( &usbblk->list, &usbblk_devices );
 
        usb_func_set_drvdata ( func, usbblk );
        return 0;
 
 err_in:
 err_out:
 err_desc:
        ref_put ( &usbblk->refcnt );
 err_alloc:
        return rc;
}

References usbblk_device::data, DBGC, desc, ENOENT, ENOMEM, usbblk_device::func, usbblk_device::in, usb_function::interface, intf_init(), usbblk_device::list, list_add_tail, usb_function::name, usbblk_device::out, usbblk_device::process, process_init_stopped(), rc, ref_put, usbblk_device::refcnt, usbblk_device::scsi, strerror(), usb_function::usb, USB_BULK_IN, USB_BULK_OUT, usb_endpoint_described(), usb_endpoint_init(), usb_func_set_drvdata(), usb_interface_descriptor(), usb_refill_init(), usbblk_data_desc, usbblk_in_operations, USBBLK_MAX_FILL, USBBLK_MAX_LEN, usbblk_out_operations, usbblk_process_desc, usbblk_scsi_desc, and zalloc().

usbblk_remove()

void usbblk_remove ( struct usb_function * func )

static

Remove device.

Parameters

func	USB function

Definition at line 885 of file usbblk.c.

                                                        {
        struct usbblk_device *usbblk = usb_func_get_drvdata ( func );
 
        /* Remove from list of devices */
        list_del ( &usbblk->list );
 
        /* Close all interfaces */
        usbblk_scsi_close ( usbblk, -ENODEV );
 
        /* Shut down interfaces */
        intfs_shutdown ( -ENODEV, &usbblk->scsi, &usbblk->data, NULL );
 
        /* Drop reference */
        ref_put ( &usbblk->refcnt );
}

References usbblk_device::data, ENODEV, usbblk_device::func, intfs_shutdown(), usbblk_device::list, list_del, NULL, ref_put, usbblk_device::refcnt, usbblk_device::scsi, usb_func_get_drvdata(), and usbblk_scsi_close().

Variable Documentation

usbblk_out_operations

struct usb_endpoint_driver_operations usbblk_out_operations

static

Initial value:

                                           = {
        .complete = usbblk_out_complete,
}

Bulk OUT endpoint operations.

Definition at line 314 of file usbblk.c.

                                                                   {
        .complete = usbblk_out_complete,
};

Referenced by usbblk_probe().

usbblk_in_operations

struct usb_endpoint_driver_operations usbblk_in_operations

static

Initial value:

                                           = {
        .complete = usbblk_in_complete,
}

Bulk IN endpoint operations.

Definition at line 514 of file usbblk.c.

                                                                  {
        .complete = usbblk_in_complete,
};

Referenced by usbblk_probe().

usbblk_process_desc

struct process_descriptor usbblk_process_desc

static

Initial value:

                       =
PROC_DESC ( struct usbblk_device, process, usbblk_step )

Refill process descriptor.

Definition at line 540 of file usbblk.c.

Referenced by usbblk_probe().

usbblk_tag

uint16_t usbblk_tag

static

Next command tag.

Definition at line 551 of file usbblk.c.

Referenced by usbblk_start().

usbblk_data_operations

struct interface_operation usbblk_data_operations[]

static

Initial value:

                                 = {
        INTF_OP ( intf_close, struct usbblk_device *, usbblk_stop ),
}

SCSI data interface operations.

Definition at line 638 of file usbblk.c.

                                                           {
        INTF_OP ( intf_close, struct usbblk_device *, usbblk_stop ),
};

usbblk_data_desc

struct interface_descriptor usbblk_data_desc

static

Initial value:

                         =
INTF_DESC ( struct usbblk_device, data, usbblk_data_operations )

SCSI data interface descriptor.

Definition at line 643 of file usbblk.c.

Referenced by usbblk_probe().

usbblk_scsi_operations

struct interface_operation usbblk_scsi_operations[]

static

Initial value:

                                 = {
        INTF_OP ( scsi_command, struct usbblk_device *, usbblk_scsi_command ),
        INTF_OP ( xfer_window, struct usbblk_device *, usbblk_scsi_window ),
        INTF_OP ( intf_close, struct usbblk_device *, usbblk_scsi_close ),
        EFI_INTF_OP ( efi_describe, struct usbblk_device *,
                      usbblk_efi_describe ),
}

SCSI command interface operations.

Definition at line 726 of file usbblk.c.

                                                           {
        INTF_OP ( scsi_command, struct usbblk_device *, usbblk_scsi_command ),
        INTF_OP ( xfer_window, struct usbblk_device *, usbblk_scsi_window ),
        INTF_OP ( intf_close, struct usbblk_device *, usbblk_scsi_close ),
        EFI_INTF_OP ( efi_describe, struct usbblk_device *,
                      usbblk_efi_describe ),
};

usbblk_scsi_desc

struct interface_descriptor usbblk_scsi_desc

static

Initial value:

                         =
INTF_DESC ( struct usbblk_device, scsi, usbblk_scsi_operations )

SCSI command interface descriptor.

Definition at line 735 of file usbblk.c.

Referenced by usbblk_probe().

__uri_opener

struct uri_opener usbblk_uri_opener __uri_opener

Initial value:

                = {
        .scheme = "usb",
        .open = usbblk_open_uri,
}

USB block device URI opener.

Definition at line 802 of file usbblk.c.

                                                 {
        .scheme = "usb",
        .open = usbblk_open_uri,
};

usbblk_ids

struct usb_device_id usbblk_ids[]

static

Initial value:

                           = {
        USB_ID ( 0xffff, 0xffff, "usbblk", "USB block device", 0 ),
}

Mass storage class device IDs.

Definition at line 902 of file usbblk.c.

                                         {
        USB_ID ( 0xffff, 0xffff, "usbblk", "USB block device", 0 ),
};

__usb_driver

struct usb_driver usbblk_driver __usb_driver

Initial value:

                = {
        .ids = usbblk_ids,
        .id_count = ( sizeof ( usbblk_ids ) / sizeof ( usbblk_ids[0] ) ),
        .class = USB_CLASS_ID ( USB_CLASS_MSC, USB_SUBCLASS_MSC_SCSI,
                                USB_PROTOCOL_MSC_BULK ),
        .score = USB_SCORE_NORMAL,
        .probe = usbblk_probe,
        .remove = usbblk_remove,
}

Mass storage driver.

Definition at line 907 of file usbblk.c.

                                             {
        .ids = usbblk_ids,
        .id_count = ( sizeof ( usbblk_ids ) / sizeof ( usbblk_ids[0] ) ),
        .class = USB_CLASS_ID ( USB_CLASS_MSC, USB_SUBCLASS_MSC_SCSI,
                                USB_PROTOCOL_MSC_BULK ),
        .score = USB_SCORE_NORMAL,
        .probe = usbblk_probe,
        .remove = usbblk_remove,
};