ata.c File Reference

ATA block device. More...

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/list.h>
#include <ipxe/interface.h>
#include <ipxe/blockdev.h>
#include <ipxe/edd.h>
#include <ipxe/ata.h>

Go to the source code of this file.

Data Structures
struct	ata_device
	An ATA device. More...
struct	ata_command
	An ATA command. More...
struct	ata_command_type
	An ATA command type. More...
struct	ata_identify_private
	ATA IDENTIFY private data. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
int	ata_command (struct interface *control, struct interface *data, struct ata_cmd *command)
	Issue ATA command. More...
static	LIST_HEAD (ata_commands)
	List of all ATA commands. More...
static	__attribute__ ((always_inline))
	Get reference to ATA device. More...
static void	atacmd_free (struct refcnt *refcnt)
	Free ATA command. More...
static void	atacmd_close (struct ata_command *atacmd, int rc)
	Close ATA command. More...
static void	atacmd_done (struct ata_command *atacmd, int rc)
	Handle ATA command completion. More...
static void	atacmd_data_buffer (struct ata_command *atacmd __unused, userptr_t buffer, size_t len, userptr_t *data, size_t *data_len)
	Use provided data buffer for ATA command. More...
static void	atacmd_data_none (struct ata_command *atacmd __unused, userptr_t buffer __unused, size_t len __unused, userptr_t *data __unused, size_t *data_len __unused)
	Use no data buffer for ATA command. More...
static void	atacmd_data_priv (struct ata_command *atacmd, userptr_t buffer __unused, size_t len __unused, userptr_t *data, size_t *data_len)
	Use private data buffer for ATA command. More...
static const char *	ata_model (struct ata_identity *identity)
	Return ATA model string (for debugging) More...
static void	atacmd_identify_done (struct ata_command *atacmd, int rc)
	Handle ATA IDENTIFY command completion. More...
static int	atadev_command (struct ata_device *atadev, struct interface *block, struct ata_command_type *type, uint64_t lba, unsigned int count, userptr_t buffer, size_t len)
	Create ATA command. More...
static int	atadev_read (struct ata_device *atadev, struct interface *block, uint64_t lba, unsigned int count, userptr_t buffer, size_t len)
	Issue ATA block read. More...
static int	atadev_write (struct ata_device *atadev, struct interface *block, uint64_t lba, unsigned int count, userptr_t buffer, size_t len)
	Issue ATA block write. More...
static int	atadev_read_capacity (struct ata_device *atadev, struct interface *block)
	Read ATA device capacity. More...
static void	atadev_close (struct ata_device *atadev, int rc)
	Close ATA device. More...
static int	atadev_edd_describe (struct ata_device *atadev, struct edd_interface_type *type, union edd_device_path *path)
	Describe ATA device using EDD. More...
int	ata_open (struct interface *block, struct interface *ata, unsigned int device, unsigned int max_count)
	Open ATA device. More...

Variables
static struct ata_command_type	atacmd_read
	ATA READ command type. More...
static struct ata_command_type	atacmd_write
	ATA WRITE command type. More...
static struct ata_command_type	atacmd_identify
	ATA IDENTITY command type. More...
static struct interface_operation	atacmd_block_op []
	ATA command block interface operations. More...
static struct interface_descriptor	atacmd_block_desc
	ATA command block interface descriptor. More...
static struct interface_operation	atacmd_ata_op []
	ATA command ATA interface operations. More...
static struct interface_descriptor	atacmd_ata_desc
	ATA command ATA interface descriptor. More...
static struct interface_operation	atadev_block_op []
	ATA device block interface operations. More...
static struct interface_descriptor	atadev_block_desc
	ATA device block interface descriptor. More...
static struct interface_operation	atadev_ata_op []
	ATA device ATA interface operations. More...
static struct interface_descriptor	atadev_ata_desc
	ATA device ATA interface descriptor. More...

Detailed Description

ATA block device.

Definition in file ata.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

ata_command()

int ata_command	(	struct interface *	control,
		struct interface *	data,
		struct ata_cmd *	command
	)

Issue ATA command.

Parameters

control	ATA control interface
data	ATA data interface
command	ATA command

Return values

tag	Command tag, or negative error

Definition at line 59 of file ata.c.

                                            {
        struct interface *dest;
        ata_command_TYPE ( void * ) *op =
                intf_get_dest_op ( control, ata_command, &dest );
        void *object = intf_object ( dest );
        int tag;

        if ( op ) {
                tag = op ( object, data, command );
        } else {
                /* Default is to fail to issue the command */
                tag = -EOPNOTSUPP;
        }

        intf_put ( dest );
        return tag;
}

References ata_command_TYPE, control, data, dest, EOPNOTSUPP, intf_get_dest_op, intf_object(), intf_put(), op, and tag.

LIST_HEAD()

static LIST_HEAD ( ata_commands  )

static

List of all ATA commands.

__attribute__()

static __attribute__ ( (always_inline)  )

inlinestatic

Get reference to ATA device.

Get ATA command private data.

Drop reference to ATA command.

Get reference to ATA command.

Drop reference to ATA device.

Parameters

atadev

ATA device

Return values

atadev

ATA device

Parameters

atadev	ATA device
atacmd	ATA command

Return values

atacmd

ATA command

Parameters

atacmd	ATA command
atacmd	ATA command

Return values

priv	Private data

Definition at line 181 of file ata.c.

                                         {
        ref_get ( &atadev->refcnt );
        return atadev;
}

References ref_get, and ata_device::refcnt.

atacmd_free()

static void atacmd_free ( struct refcnt *  refcnt )

static

Free ATA command.

Parameters

refcnt

Reference count

Definition at line 235 of file ata.c.

                                                  {
        struct ata_command *atacmd =
                container_of ( refcnt, struct ata_command, refcnt );

        /* Remove from list of commands */
        list_del ( &atacmd->list );
        atadev_put ( atacmd->atadev );

        /* Free command */
        free ( atacmd );
}

References ata_command::atadev, container_of, free, ata_command::list, and list_del.

Referenced by atadev_command().

atacmd_close()

static void atacmd_close ( struct ata_command *  atacmd, int  rc  )

static

Close ATA command.

Parameters

atacmd	ATA command
rc	Reason for close

Definition at line 253 of file ata.c.

                                                                {
        struct ata_device *atadev = atacmd->atadev;

        if ( rc != 0 ) {
                DBGC ( atadev, "ATA %p tag %08x closed: %s\n",
                       atadev, atacmd->tag, strerror ( rc ) );
        }

        /* Shut down interfaces */
        intf_shutdown ( &atacmd->ata, rc );
        intf_shutdown ( &atacmd->block, rc );
}

References ata_command::ata, ata_command::atadev, ata_command::block, DBGC, intf_shutdown(), rc, strerror(), and ata_command::tag.

Referenced by atacmd_identify_done(), atadev_close(), and atadev_command().

atacmd_done()

static void atacmd_done ( struct ata_command *  atacmd, int  rc  )

static

Handle ATA command completion.

Parameters

atacmd	ATA command
rc	Reason for close

Definition at line 272 of file ata.c.

                                                               {

        /* Hand over to the command completion handler */
        atacmd->type->done ( atacmd, rc );
}

References ata_command_type::done, rc, and ata_command::type.

atacmd_data_buffer()

static void atacmd_data_buffer ( struct ata_command *atacmd  __unused, userptr_t  buffer, size_t  len, userptr_t *  data, size_t *  data_len  )

static

Use provided data buffer for ATA command.

Parameters

atacmd	ATA command
buffer	Available buffer
len	Available buffer length

Return values

data	Data buffer
data_len	Data buffer length

Definition at line 287 of file ata.c.

                                                                     {
        *data = buffer;
        *data_len = len;
}

References buffer, data, data_len, and len.

atacmd_data_none()

static void atacmd_data_none ( struct ata_command *atacmd  __unused, userptr_t buffer  __unused, size_t len  __unused, userptr_t *data  __unused, size_t *data_len  __unused  )

static

Use no data buffer for ATA command.

Parameters

atacmd	ATA command
buffer	Available buffer
len	Available buffer length

Return values

data	Data buffer
data_len	Data buffer length

Definition at line 303 of file ata.c.

                                                           {
        /* Nothing to do */
}

atacmd_data_priv()

static void atacmd_data_priv ( struct ata_command *  atacmd, userptr_t buffer  __unused, size_t len  __unused, userptr_t *  data, size_t *  data_len  )

static

Use private data buffer for ATA command.

Parameters

atacmd	ATA command
buffer	Available buffer
len	Available buffer length

Return values

data	Data buffer
data_len	Data buffer length

Definition at line 319 of file ata.c.

                                                                   {
        *data = virt_to_user ( atacmd_priv ( atacmd ) );
        *data_len = atacmd->type->priv_len;
}

References data, data_len, ata_command_type::priv_len, ata_command::type, and virt_to_user().

ata_model()

static const char* ata_model ( struct ata_identity *  identity )

static

Return ATA model string (for debugging)

Parameters

identify

ATA identity data

Return values

model

Model string

Definition at line 358 of file ata.c.

                                                                {
        static union {
                uint16_t words[ sizeof ( identity->model ) / 2 ];
                char text[ sizeof ( identity->model ) + 1 /* NUL */ ];
        } buf;
        unsigned int i;

        for ( i = 0 ; i < ( sizeof ( identity->model ) / 2 ) ; i++ )
                buf.words[i] = bswap_16 ( identity->model[i] );

        return buf.text;
}

References bswap_16, and ata_identity::model.

Referenced by atacmd_identify_done().

atacmd_identify_done()

static void atacmd_identify_done ( struct ata_command *  atacmd, int  rc  )

static

Handle ATA IDENTIFY command completion.

Parameters

atacmd	ATA command
rc	Reason for completion

Definition at line 377 of file ata.c.

                                                                        {
        struct ata_device *atadev = atacmd->atadev;
        struct ata_identify_private *priv = atacmd_priv ( atacmd );
        struct ata_identity *identity = &priv->identity;
        struct block_device_capacity capacity;

        /* Close if command failed */
        if ( rc != 0 ) {
                atacmd_close ( atacmd, rc );
                return;
        }

        /* Extract capacity */
        if ( identity->supports_lba48 & cpu_to_le16 ( ATA_SUPPORTS_LBA48 ) ) {
                atadev->lba48 = 1;
                capacity.blocks = le64_to_cpu ( identity->lba48_sectors );
        } else {
                capacity.blocks = le32_to_cpu ( identity->lba_sectors );
        }
        capacity.blksize = ATA_SECTOR_SIZE;
        capacity.max_count = atadev->max_count;
        DBGC ( atadev, "ATA %p is a %s\n", atadev, ata_model ( identity ) );
        DBGC ( atadev, "ATA %p has %#llx blocks (%ld MB) and uses %s\n",
               atadev, capacity.blocks,
               ( ( signed long ) ( capacity.blocks >> 11 ) ),
               ( atadev->lba48 ? "LBA48" : "LBA" ) );

        /* Return capacity to caller */
        block_capacity ( &atacmd->block, &capacity );

        /* Close command */
        atacmd_close ( atacmd, 0 );
}

References ata_model(), ATA_SECTOR_SIZE, ATA_SUPPORTS_LBA48, atacmd_close(), ata_command::atadev, block_device_capacity::blksize, ata_command::block, block_capacity(), block_device_capacity::blocks, cpu_to_le16, DBGC, ata_device::lba48, ata_identity::lba48_sectors, ata_identity::lba_sectors, le32_to_cpu, le64_to_cpu, block_device_capacity::max_count, ata_device::max_count, priv, rc, and ata_identity::supports_lba48.

atadev_command()

static int atadev_command ( struct ata_device *  atadev, struct interface *  block, struct ata_command_type *  type, uint64_t  lba, unsigned int  count, userptr_t  buffer, size_t  len  )

static

Create ATA command.

Parameters

atadev	ATA device
block	Block data interface
type	ATA command type
lba	Starting logical block address
count	Number of blocks to transfer
buffer	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 454 of file ata.c.

                                                           {
        struct ata_command *atacmd;
        struct ata_cmd command;
        int tag;
        int rc;

        /* Allocate and initialise structure */
        atacmd = zalloc ( sizeof ( *atacmd ) + type->priv_len );
        if ( ! atacmd ) {
                rc = -ENOMEM;
                goto err_zalloc;
        }
        ref_init ( &atacmd->refcnt, atacmd_free );
        intf_init ( &atacmd->block, &atacmd_block_desc, &atacmd->refcnt );
        intf_init ( &atacmd->ata, &atacmd_ata_desc,
                    &atacmd->refcnt );
        atacmd->atadev = atadev_get ( atadev );
        list_add ( &atacmd->list, &ata_commands );
        atacmd->type = type;

        /* Sanity check */
        if ( len != ( count * ATA_SECTOR_SIZE ) ) {
                DBGC ( atadev, "ATA %p tag %08x buffer length mismatch (count "
                       "%d len %zd)\n", atadev, atacmd->tag, count, len );
                rc = -EINVAL;
                goto err_len;
        }

        /* Construct command */
        memset ( &command, 0, sizeof ( command ) );
        command.cb.lba.native = lba;
        command.cb.count.native = count;
        command.cb.device = ( atadev->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
        command.cb.lba48 = atadev->lba48;
        if ( ! atadev->lba48 )
                command.cb.device |= command.cb.lba.bytes.low_prev;
        command.cb.cmd_stat =
                ( atadev->lba48 ? type->cmd_lba48 : type->cmd_lba );
        type->data_in ( atacmd, buffer, len,
                        &command.data_in, &command.data_in_len );
        type->data_out ( atacmd, buffer, len,
                         &command.data_out, &command.data_out_len );

        /* Issue command */
        if ( ( tag = ata_command ( &atadev->ata, &atacmd->ata,
                                   &command ) ) < 0 ) {
                rc = tag;
                DBGC ( atadev, "ATA %p tag %08x could not issue command: %s\n",
                       atadev, atacmd->tag, strerror ( rc ) );
                goto err_command;
        }
        atacmd->tag = tag;

        DBGC2 ( atadev, "ATA %p tag %08x %s cmd %02x dev %02x LBA%s %08llx "
                "count %04x\n", atadev, atacmd->tag, atacmd->type->name,
                command.cb.cmd_stat, command.cb.device,
                ( command.cb.lba48 ? "48" : "" ),
                ( unsigned long long ) command.cb.lba.native,
                command.cb.count.native );

        /* Attach to parent interface, mortalise self, and return */
        intf_plug_plug ( &atacmd->block, block );
        ref_put ( &atacmd->refcnt );
        return 0;

 err_command:
 err_len:
        atacmd_close ( atacmd, rc );
        ref_put ( &atacmd->refcnt );
 err_zalloc:
        return rc;
}

References ata_command::ata, ata_device::ata, ATA_DEV_LBA, ATA_DEV_OBSOLETE, ATA_SECTOR_SIZE, atacmd_ata_desc, atacmd_block_desc, atacmd_close(), atacmd_free(), ata_command::atadev, block, ata_command::block, buffer, count, DBGC, DBGC2, ata_device::device, EINVAL, ENOMEM, intf_init(), intf_plug_plug(), lba, ata_device::lba48, len, ata_command::list, list_add, memset(), ata_command_type::name, rc, ref_init, ref_put, ata_command::refcnt, strerror(), tag, ata_command::tag, type, ata_command::type, and zalloc().

Referenced by atadev_read(), atadev_read_capacity(), and atadev_write().

atadev_read()

static int atadev_read ( struct ata_device *  atadev, struct interface *  block, uint64_t  lba, unsigned int  count, userptr_t  buffer, size_t  len  )

static

Issue ATA block read.

Parameters

atadev	ATA device
block	Block data interface
lba	Starting logical block address
count	Number of blocks to transfer
buffer	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 543 of file ata.c.

                                                        {
        return atadev_command ( atadev, block, &atacmd_read,
                                lba, count, buffer, len );
}

References atacmd_read, atadev_command(), block, buffer, count, lba, and len.

atadev_write()

static int atadev_write ( struct ata_device *  atadev, struct interface *  block, uint64_t  lba, unsigned int  count, userptr_t  buffer, size_t  len  )

static

Issue ATA block write.

Parameters

atadev	ATA device
block	Block data interface
lba	Starting logical block address
count	Number of blocks to transfer
buffer	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 562 of file ata.c.

                                                         {
        return atadev_command ( atadev, block, &atacmd_write,
                                lba, count, buffer, len );
}

References atacmd_write, atadev_command(), block, buffer, count, lba, and len.

atadev_read_capacity()

static int atadev_read_capacity ( struct ata_device *  atadev, struct interface *  block  )

static

Read ATA device capacity.

Parameters

atadev	ATA device
block	Block data interface

Return values

rc	Return status code

Definition at line 577 of file ata.c.

                                                            {
        struct ata_identity *identity;

        assert ( atacmd_identify.priv_len == sizeof ( *identity ) );
        assert ( atacmd_identify.priv_len == ATA_SECTOR_SIZE );
        return atadev_command ( atadev, block, &atacmd_identify,
                                0, 1, UNULL, ATA_SECTOR_SIZE );
}

References assert(), ATA_SECTOR_SIZE, atacmd_identify, atadev_command(), block, ata_command_type::priv_len, and UNULL.

atadev_close()

static void atadev_close ( struct ata_device *  atadev, int  rc  )

static

Close ATA device.

Parameters

atadev	ATA device
rc	Reason for close

Definition at line 593 of file ata.c.

                                                               {
        struct ata_command *atacmd;
        struct ata_command *tmp;

        /* Shut down interfaces */
        intf_shutdown ( &atadev->block, rc );
        intf_shutdown ( &atadev->ata, rc );

        /* Shut down any remaining commands */
        list_for_each_entry_safe ( atacmd, tmp, &ata_commands, list ) {
                if ( atacmd->atadev != atadev )
                        continue;
                atacmd_get ( atacmd );
                atacmd_close ( atacmd, rc );
                atacmd_put ( atacmd );
        }
}

References ata_device::ata, atacmd_close(), ata_command::atadev, ata_device::block, intf_shutdown(), ata_command::list, list_for_each_entry_safe, rc, and tmp.

atadev_edd_describe()

static int atadev_edd_describe ( struct ata_device *  atadev, struct edd_interface_type *  type, union edd_device_path *  path  )

static

Describe ATA device using EDD.

Parameters

atadev	ATA device
type	EDD interface type
path	EDD device path

Return values

rc	Return status code

Definition at line 619 of file ata.c.

                                                               {

        type->type = cpu_to_le64 ( EDD_INTF_TYPE_ATA );
        path->ata.slave = ( ( atadev->device == ATA_DEV_SLAVE ) ? 0x01 : 0x00 );
        return 0;
}

References ATA_DEV_SLAVE, ata_command::atadev, cpu_to_le64, ata_device::device, EDD_INTF_TYPE_ATA, edd_device_path::slave, and type.

ata_open()

int ata_open	(	struct interface *	block,
		struct interface *	ata,
		unsigned int	device,
		unsigned int	max_count
	)

Open ATA device.

Parameters

block	Block control interface
ata	ATA control interface
device	ATA device number
max_count	Maximum number of blocks per single transfer

Return values

rc	Return status code

Definition at line 662 of file ata.c.

                                                             {
        struct ata_device *atadev;

        /* Allocate and initialise structure */
        atadev = zalloc ( sizeof ( *atadev ) );
        if ( ! atadev )
                return -ENOMEM;
        ref_init ( &atadev->refcnt, NULL );
        intf_init ( &atadev->block, &atadev_block_desc, &atadev->refcnt );
        intf_init ( &atadev->ata, &atadev_ata_desc, &atadev->refcnt );
        atadev->device = device;
        atadev->max_count = max_count;

        /* Attach to ATA and parent and interfaces, mortalise self,
         * and return
         */
        intf_plug_plug ( &atadev->ata, ata );
        intf_plug_plug ( &atadev->block, block );
        ref_put ( &atadev->refcnt );
        return 0;
}

References ata_device::ata, atadev_ata_desc, atadev_block_desc, block, ata_device::block, device, ata_device::device, ENOMEM, intf_init(), intf_plug_plug(), ata_device::max_count, NULL, ref_init, ref_put, ata_device::refcnt, and zalloc().

Referenced by aoedev_open().

Variable Documentation

atacmd_read

struct ata_command_type atacmd_read

static

Initial value:

= {
        .name = "READ",
        .cmd_lba = ATA_CMD_READ,
        .cmd_lba48 = ATA_CMD_READ_EXT,
        .data_in = atacmd_data_buffer,
        .data_out = atacmd_data_none,
        .done = atacmd_close,
}

ATA READ command type.

Definition at line 327 of file ata.c.

Referenced by atadev_read().

atacmd_write

struct ata_command_type atacmd_write

static

Initial value:

= {
        .name = "WRITE",
        .cmd_lba = ATA_CMD_WRITE,
        .cmd_lba48 = ATA_CMD_WRITE_EXT,
        .data_in = atacmd_data_none,
        .data_out = atacmd_data_buffer,
        .done = atacmd_close,
}

ATA WRITE command type.

Definition at line 337 of file ata.c.

Referenced by atadev_write().

atacmd_identify

struct ata_command_type atacmd_identify

static

Initial value:

= {
        .name = "IDENTIFY",
        .priv_len = sizeof ( struct ata_identify_private ),
        .cmd_lba = ATA_CMD_IDENTIFY,
        .cmd_lba48 = ATA_CMD_IDENTIFY,
        .data_in = atacmd_data_priv,
        .data_out = atacmd_data_none,
        .done = atacmd_identify_done,
}

ATA IDENTITY command type.

Definition at line 412 of file ata.c.

Referenced by atadev_read_capacity().

atacmd_block_op

struct interface_operation atacmd_block_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct ata_command *, atacmd_close ),
}

ATA command block interface operations.

Definition at line 423 of file ata.c.

atacmd_block_desc

struct interface_descriptor atacmd_block_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct ata_command, block,
                             atacmd_block_op, ata )

ATA command block interface descriptor.

Definition at line 428 of file ata.c.

Referenced by atadev_command().

atacmd_ata_op

struct interface_operation atacmd_ata_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct ata_command *, atacmd_done ),
}

ATA command ATA interface operations.

Definition at line 433 of file ata.c.

atacmd_ata_desc

struct interface_descriptor atacmd_ata_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct ata_command, ata,
                             atacmd_ata_op, block )

ATA command ATA interface descriptor.

Definition at line 438 of file ata.c.

Referenced by atadev_command().

atadev_block_op

struct interface_operation atadev_block_op[]

static

Initial value:

= {
        INTF_OP ( block_read, struct ata_device *, atadev_read ),
        INTF_OP ( block_write, struct ata_device *, atadev_write ),
        INTF_OP ( block_read_capacity, struct ata_device *,
                  atadev_read_capacity ),
        INTF_OP ( intf_close, struct ata_device *, atadev_close ),
        INTF_OP ( edd_describe, struct ata_device *, atadev_edd_describe ),
}

ATA device block interface operations.

Definition at line 629 of file ata.c.

atadev_block_desc

struct interface_descriptor atadev_block_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct ata_device, block,
                             atadev_block_op, ata )

ATA device block interface descriptor.

Definition at line 639 of file ata.c.

Referenced by ata_open().

atadev_ata_op

struct interface_operation atadev_ata_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct ata_device *, atadev_close ),
}

ATA device ATA interface operations.

Definition at line 644 of file ata.c.

atadev_ata_desc

struct interface_descriptor atadev_ata_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct ata_device, ata,
                             atadev_ata_op, block )

ATA device ATA interface descriptor.

Definition at line 649 of file ata.c.

Referenced by ata_open().