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)
	FILE_SECBOOT (PERMITTED)
int	ata_command (struct interface *control, struct interface *data, struct ata_cmd *command)
	Issue ATA command.
static	LIST_HEAD (ata_commands)
	List of all ATA commands.
static struct ata_device *	atadev_get (struct ata_device *atadev)
	Get reference to ATA device.
static void	atadev_put (struct ata_device *atadev)
	Drop reference to ATA device.
static struct ata_command *	atacmd_get (struct ata_command *atacmd)
	Get reference to ATA command.
static void	atacmd_put (struct ata_command *atacmd)
	Drop reference to ATA command.
static void *	atacmd_priv (struct ata_command *atacmd)
	Get ATA command private data.
static void	atacmd_free (struct refcnt *refcnt)
	Free ATA command.
static void	atacmd_close (struct ata_command *atacmd, int rc)
	Close ATA command.
static void	atacmd_done (struct ata_command *atacmd, int rc)
	Handle ATA command completion.
static void	atacmd_data_buffer (struct ata_command *atacmd __unused, struct xfer_buffer *xferbuf, void *buffer, size_t len)
	Use provided data buffer for ATA command.
static void	atacmd_data_none (struct ata_command *atacmd __unused, struct xfer_buffer *xferbuf, void *buffer __unused, size_t len __unused)
	Use no data buffer for ATA command.
static void	atacmd_data_priv (struct ata_command *atacmd, struct xfer_buffer *xferbuf, void *buffer __unused, size_t len __unused)
	Use private data buffer for ATA command.
static const char *	ata_model (struct ata_identity *identity)
	Return ATA model string (for debugging).
static void	atacmd_identify_done (struct ata_command *atacmd, int rc)
	Handle ATA IDENTIFY command completion.
static int	atadev_command (struct ata_device *atadev, struct interface *block, struct ata_command_type *type, uint64_t lba, unsigned int count, void *buffer, size_t len)
	Create ATA command.
static int	atadev_read (struct ata_device *atadev, struct interface *block, uint64_t lba, unsigned int count, void *buffer, size_t len)
	Issue ATA block read.
static int	atadev_write (struct ata_device *atadev, struct interface *block, uint64_t lba, unsigned int count, void *buffer, size_t len)
	Issue ATA block write.
static int	atadev_read_capacity (struct ata_device *atadev, struct interface *block)
	Read ATA device capacity.
static void	atadev_close (struct ata_device *atadev, int rc)
	Close ATA device.
static int	atadev_edd_describe (struct ata_device *atadev, struct edd_interface_type *type, union edd_device_path *path)
	Describe ATA device using EDD.
int	ata_open (struct interface *block, struct interface *ata, unsigned int device, unsigned int max_count)
	Open ATA device.

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

Detailed Description

ATA block device.

Definition in file ata.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

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 60 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()

LIST_HEAD ( ata_commands )

static

List of all ATA commands.

atadev_get()

struct ata_device * atadev_get ( struct ata_device * atadev )

inlinestatic

Get reference to ATA device.

Parameters

atadev

ATA device

Return values

atadev

ATA device

Definition at line 180 of file ata.c.

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

References ref_get, and ata_device::refcnt.

Referenced by atadev_command().

atadev_put()

void atadev_put ( struct ata_device * atadev )

inlinestatic

Drop reference to ATA device.

Parameters

atadev

ATA device

Definition at line 191 of file ata.c.

                                         {
        ref_put ( &atadev->refcnt );
}

References ref_put, and ata_device::refcnt.

Referenced by atacmd_free().

atacmd_get()

struct ata_command * atacmd_get ( struct ata_command * atacmd )

inlinestatic

Get reference to ATA command.

Parameters

atacmd

ATA command

Return values

atacmd

ATA command

Definition at line 202 of file ata.c.

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

References ref_get, and ata_command::refcnt.

Referenced by atadev_close().

atacmd_put()

void atacmd_put ( struct ata_command * atacmd )

inlinestatic

Drop reference to ATA command.

Parameters

atacmd

ATA command

Definition at line 213 of file ata.c.

                                          {
        ref_put ( &atacmd->refcnt );
}

References ref_put, and ata_command::refcnt.

Referenced by atadev_close().

atacmd_priv()

void * atacmd_priv ( struct ata_command * atacmd )

inlinestatic

Get ATA command private data.

Parameters

atacmd

ATA command

Return values

priv	Private data

Definition at line 224 of file ata.c.

                                           {
        return atacmd->priv;
}

References ata_command::priv.

Referenced by atacmd_data_priv(), and atacmd_identify_done().

atacmd_free()

void atacmd_free ( struct refcnt * refcnt )

static

Free ATA command.

Parameters

refcnt

Reference count

Definition at line 233 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, atadev_put(), container_of, free, ata_command::list, and list_del.

Referenced by atadev_command().

atacmd_close()

void atacmd_close ( struct ata_command * atacmd, int rc )

static

Close ATA command.

Parameters

atacmd	ATA command
rc	Reason for close

Definition at line 251 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()

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 270 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()

void atacmd_data_buffer ( struct ata_command *atacmd __unused, struct xfer_buffer * xferbuf, void * buffer, size_t len )

static

Use provided data buffer for ATA command.

Parameters

atacmd	ATA command
xferbuf	Data transfer buffer
buffer	Available buffer
len	Available buffer length

Definition at line 284 of file ata.c.

                                                            {
        xferbuf_fixed_init ( xferbuf, buffer, len );
}

References __unused, buffer, len, and xferbuf_fixed_init().

atacmd_data_none()

void atacmd_data_none ( struct ata_command *atacmd __unused, struct xfer_buffer * xferbuf, void *buffer __unused, size_t len __unused )

static

Use no data buffer for ATA command.

Parameters

atacmd	ATA command
xferbuf	Data transfer buffer
buffer	Available buffer
len	Available buffer length

Definition at line 298 of file ata.c.

                                                                            {
        xferbuf_void_init ( xferbuf );
}

References __unused, buffer, len, and xferbuf_void_init().

atacmd_data_priv()

void atacmd_data_priv ( struct ata_command * atacmd, struct xfer_buffer * xferbuf, void *buffer __unused, size_t len __unused )

static

Use private data buffer for ATA command.

Parameters

atacmd	ATA command
xferbuf	Data transfer buffer
buffer	Available buffer
len	Available buffer length

Definition at line 312 of file ata.c.

                                                                            {
 
        xferbuf_fixed_init ( xferbuf, atacmd_priv ( atacmd ),
                             atacmd->type->priv_len );
}

References __unused, atacmd_priv(), buffer, len, ata_command_type::priv_len, ata_command::type, and xferbuf_fixed_init().

ata_model()

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 352 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()

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 371 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(), atacmd_priv(), 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, ata_device::max_count, block_device_capacity::max_count, priv, rc, and ata_identity::supports_lba48.

atadev_command()

int atadev_command ( struct ata_device * atadev, struct interface * block, struct ata_command_type * type, uint64_t lba, unsigned int count, void * 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 448 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, &command.data_in, buffer, len );
        type->data_out ( atacmd, &command.data_out, buffer, 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, atadev_get(), ata_command::block, 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(), ata_command::tag, tag, ata_command::type, type, and zalloc().

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

atadev_read()

int atadev_read ( struct ata_device * atadev, struct interface * block, uint64_t lba, unsigned int count, void * 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 535 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()

int atadev_write ( struct ata_device * atadev, struct interface * block, uint64_t lba, unsigned int count, void * 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 554 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()

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 569 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, NULL, ATA_SECTOR_SIZE );
}

References assert, ATA_SECTOR_SIZE, atacmd_identify, atadev_command(), block, and NULL.

atadev_close()

void atadev_close ( struct ata_device * atadev, int rc )

static

Close ATA device.

Parameters

atadev	ATA device
rc	Reason for close

Definition at line 585 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(), atacmd_get(), atacmd_put(), ata_command::atadev, ata_device::block, intf_shutdown(), ata_command::list, list_for_each_entry_safe, rc, and tmp.

atadev_edd_describe()

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 611 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 654 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, ata_device::block, block, 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 321 of file ata.c.

                                           {
        .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,
};

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 331 of file ata.c.

                                            {
        .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,
};

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 406 of file ata.c.

                                               {
        .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,
};

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 417 of file ata.c.

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

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 422 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 427 of file ata.c.

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

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 432 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 621 of file ata.c.

                                                    {
        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 ),
};

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 631 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 636 of file ata.c.

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

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 641 of file ata.c.

Referenced by ata_open().