#include <stdint.h>
#include <gpxe/list.h>
#include <gpxe/if_ether.h>
+#include <gpxe/retry.h>
+#include <gpxe/async.h>
#include <gpxe/ata.h>
/** An AoE ATA command */
/** Target MAC address */
uint8_t target[ETH_ALEN];
- /** Tag for current command */
+ /** Tag for current AoE command */
uint32_t tag;
+
/** Current ATA command */
struct ata_command *command;
- /** Status of the command */
- int status;
+ /** Overall status of current ATA command */
+ unsigned int status;
/** Byte offset within command's data buffer */
unsigned int command_offset;
+ /** Asynchronous operation for this command */
+ struct async_operation aop;
+
+ /** Retransmission timer */
+ struct retry_timer timer;
};
#define AOE_STATUS_ERR_MASK 0x0f /**< Error portion of status code */
#define AOE_STATUS_PENDING 0x80 /**< Command pending */
-#define AOE_STATUS_UNDERRUN 0x40 /**< Buffer overrun */
-#define AOE_STATUS_OVERRUN 0x20 /**< Buffer underrun */
/** Maximum number of sectors per packet */
#define AOE_MAX_COUNT 2
extern void aoe_open ( struct aoe_session *aoe );
extern void aoe_close ( struct aoe_session *aoe );
-extern int aoe_issue ( struct aoe_session *aoe, struct ata_command *command );
-extern int aoe_issue_split ( struct aoe_session *aoe,
- struct ata_command *command );
+extern void aoe_issue ( struct aoe_session *aoe, struct ata_command *command );
/** An AoE device */
struct aoe_device {
--- /dev/null
+#ifndef _GPXE_ASYNC_H
+#define _GPXE_ASYNC_H
+
+/** @file
+ *
+ * Asynchronous operations
+ *
+ */
+
+#include <errno.h>
+#include <assert.h>
+
+/** An asynchronous operation */
+struct async_operation {
+ /** Operation status
+ *
+ * This is an error code as defined in errno.h, plus an offset
+ * of EINPROGRESS. This means that a status value of 0
+ * corresponds to a return status code of -EINPROGRESS,
+ * i.e. that the default state of an asynchronous operation is
+ * "not yet completed".
+ */
+ int status;
+};
+
+/**
+ * Set asynchronous operation status
+ *
+ * @v aop Asynchronous operation
+ * @v rc Return status code
+ */
+static inline __attribute__ (( always_inline )) void
+async_set_status ( struct async_operation *aop, int rc ) {
+ aop->status = ( rc + EINPROGRESS );
+}
+
+/**
+ * Get asynchronous operation status
+ *
+ * @v aop Asynchronous operation
+ * @ret rc Return status code
+ */
+static inline __attribute__ (( always_inline )) int
+async_status ( struct async_operation *aop ) {
+ return ( aop->status - EINPROGRESS );
+}
+
+/**
+ * Flag asynchronous operation as complete
+ *
+ * @v aop Asynchronous operation
+ * @v rc Return status code
+ */
+static inline __attribute__ (( always_inline )) void
+async_done ( struct async_operation *aop, int rc ) {
+ assert ( rc != -EINPROGRESS );
+ async_set_status ( aop, rc );
+}
+
+extern int async_wait ( struct async_operation *aop );
+
+#endif /* _GPXE_ASYNC_H */
#include <gpxe/uaccess.h>
#include <gpxe/ata.h>
#include <gpxe/netdevice.h>
-#include <gpxe/process.h>
+#include <gpxe/async.h>
#include <gpxe/aoe.h>
/** @file
/** List of all AoE sessions */
static LIST_HEAD ( aoe_sessions );
+/**
+ * Mark current AoE command complete
+ *
+ * @v aoe AoE session
+ * @v rc Return status code
+ */
+static void aoe_done ( struct aoe_session *aoe, int rc ) {
+
+ /* Record overall command status */
+ aoe->command->cb.cmd_stat = aoe->status;
+ aoe->command = NULL;
+
+ /* Mark async operation as complete */
+ async_done ( &aoe->aop, rc );
+}
+
/**
* Send AoE command
*
struct pk_buff *pkb;
struct aoehdr *aoehdr;
struct aoecmd *aoecmd;
+ unsigned int count;
+ unsigned int data_out_len;
+
+ /* Calculate count and data_out_len for this subcommand */
+ count = command->cb.count.native;
+ if ( count > AOE_MAX_COUNT )
+ count = AOE_MAX_COUNT;
+ data_out_len = ( command->data_out ? ( count * ATA_SECTOR_SIZE ) : 0 );
/* Create outgoing packet buffer */
pkb = alloc_pkb ( ETH_HLEN + sizeof ( *aoehdr ) + sizeof ( *aoecmd ) +
- command->data_out_len );
+ data_out_len );
if ( ! pkb )
return -ENOMEM;
pkb->net_protocol = &aoe_protocol;
linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE, __fix_ata_h__ );
aoecmd->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 ) |
( command->cb.device & ATA_DEV_SLAVE ) |
- ( command->data_out_len ? AOE_FL_WRITE : 0 ) );
+ ( data_out_len ? AOE_FL_WRITE : 0 ) );
aoecmd->err_feat = command->cb.err_feat.bytes.cur;
- aoecmd->count = command->cb.count.bytes.cur;
+ aoecmd->count = count;
aoecmd->cmd_stat = command->cb.cmd_stat;
aoecmd->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
if ( ! command->cb.lba48 )
aoecmd->lba.bytes[3] |= ( command->cb.device & ATA_DEV_MASK );
/* Fill data payload */
- copy_from_user ( pkb_put ( pkb, command->data_out_len ),
- command->data_out, aoe->command_offset,
- command->data_out_len );
+ copy_from_user ( pkb_put ( pkb, data_out_len ), command->data_out,
+ aoe->command_offset, data_out_len );
/* Send packet */
return net_transmit_via ( pkb, aoe->netdev );
unsigned int len ) {
struct aoecmd *aoecmd = aoehdr->arg.command;
struct ata_command *command = aoe->command;
- unsigned int data_in_len;
+ unsigned int rx_data_len;
+ unsigned int count;
+ unsigned int data_len;
/* Sanity check */
if ( len < ( sizeof ( *aoehdr ) + sizeof ( *aoecmd ) ) )
return -EINVAL;
+ rx_data_len = ( len - sizeof ( *aoehdr ) - sizeof ( *aoecmd ) );
- /* Set overall status code */
- aoe->status = ( ( aoehdr->ver_flags & AOE_FL_ERROR ) ?
- aoehdr->error : 0 );
+ /* Check for fatal errors */
+ if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
+ aoe_done ( aoe, -EIO );
+ return 0;
+ }
+
+ /* Calculate count and data_len for this subcommand */
+ count = command->cb.count.native;
+ if ( count > AOE_MAX_COUNT )
+ count = AOE_MAX_COUNT;
+ data_len = count * ATA_SECTOR_SIZE;
+
+ /* Merge into overall ATA status */
+ aoe->status |= aoecmd->cmd_stat;
- /* Copy ATA results */
- command->cb.err_feat.bytes.cur = aoecmd->err_feat;
- command->cb.count.bytes.cur = aoecmd->count;
- command->cb.cmd_stat = aoecmd->cmd_stat;
- command->cb.lba.native = le64_to_cpu ( aoecmd->lba.u64 );
- command->cb.lba.bytes.pad = 0;
-
/* Copy data payload */
- data_in_len = ( len - sizeof ( *aoehdr ) - sizeof ( *aoecmd ) );
- if ( data_in_len > command->data_in_len ) {
- data_in_len = command->data_in_len;
- aoe->status |= AOE_STATUS_OVERRUN;
- } else if ( data_in_len < command->data_in_len ) {
- aoe->status |= AOE_STATUS_UNDERRUN;
+ if ( command->data_in ) {
+ if ( rx_data_len > data_len )
+ rx_data_len = data_len;
+ copy_to_user ( command->data_in, aoe->command_offset,
+ aoecmd->data, rx_data_len );
}
- copy_to_user ( command->data_in, aoe->command_offset,
- aoecmd->data, data_in_len );
+
+ /* Update ATA command and offset */
+ aoe->command_offset += data_len;
+ command->cb.lba.native += count;
+ command->cb.count.native -= count;
+
+ /* Check for operation complete */
+ if ( ! command->cb.count.native ) {
+ aoe_done ( aoe, 0 );
+ return 0;
+ }
+
+ /* Transmit next portion of request */
+ aoe_send_command ( aoe );
return 0;
}
list_del ( &aoe->list );
}
-/**
- * Kick an AoE session into life
- *
- * @v aoe AoE session
- *
- * Transmits an AoE request. Call this function to issue a new
- * command, or when a retransmission timer expires.
- */
-void aoe_kick ( struct aoe_session *aoe ) {
- aoe_send_command ( aoe );
-}
-
/**
* Issue ATA command via an open AoE session
*
* @v aoe AoE session
* @v command ATA command
- * @ret rc Return status code
*
- * The ATA command must fit within a single AoE frame (i.e. the sector
- * count must not exceed AOE_MAX_COUNT).
+ * Only one command may be issued concurrently per session. This call
+ * is non-blocking; use async_wait() to wait for the command to
+ * complete.
*/
-int aoe_issue ( struct aoe_session *aoe, struct ata_command *command ) {
+void aoe_issue ( struct aoe_session *aoe, struct ata_command *command ) {
aoe->command = command;
- aoe->status = AOE_STATUS_PENDING;
-
- aoe_kick ( aoe );
- while ( aoe->status & AOE_STATUS_PENDING ) {
- step();
- }
- aoe->command = NULL;
-
- return ( ( aoe->status & AOE_STATUS_ERR_MASK ) ? -EIO : 0 );
-}
-
-/**
- * Issue ATA command via an open AoE session
- *
- * @v aoe AoE session
- * @v command ATA command
- * @ret rc Return status code
- *
- * The ATA command will be split into several smaller ATA commands,
- * each with a sector count no larger than AOE_MAX_COUNT.
- */
-int aoe_issue_split ( struct aoe_session *aoe, struct ata_command *command ) {
- struct ata_command subcommand;
- unsigned int offset;
- unsigned int count;
- unsigned int data_len;
- unsigned int status = 0;
- int rc = 0;
-
- /* Split ATA command into AoE-sized subcommands */
- for ( offset = 0; offset < command->cb.count.native; offset += count ){
- memcpy ( &subcommand, command, sizeof ( subcommand ) );
- count = ( command->cb.count.native - offset );
- if ( count > AOE_MAX_COUNT )
- count = AOE_MAX_COUNT;
- data_len = count * ATA_SECTOR_SIZE;
- if ( subcommand.data_in_len )
- subcommand.data_in_len = data_len;
- if ( subcommand.data_out_len )
- subcommand.data_out_len = data_len;
- aoe->command_offset = ( offset * ATA_SECTOR_SIZE );
- subcommand.cb.lba.native += offset;
- subcommand.cb.count.native = count;
- if ( ( rc = aoe_issue ( aoe, &subcommand ) ) != 0 )
- goto done;
- status |= subcommand.cb.cmd_stat;
- }
- command->cb.cmd_stat = status;
-
- done:
+ aoe->status = 0;
aoe->command_offset = 0;
- return rc;
+ aoe_send_command ( aoe );
}
projects / thirdparty / ipxe.git / commitdiff
