ATA devices are now asynchronous. The ATA layer itself now performs the
authorMichael Brown <mcb30@etherboot.org>
Wed, 31 May 2006 18:57:11 +0000 (18:57 +0000)
committerMichael Brown <mcb30@etherboot.org>
Wed, 31 May 2006 18:57:11 +0000 (18:57 +0000)
async_wait(), though we may wish to move this higher up the stack, and
consider making the block device model asynchronous.  (There is only a
marginal cost for synchronous devices, since they can simply call
async_done() before returning; async_wait() will work seamlessly in this
situation).

src/drivers/ata/aoedev.c
src/drivers/block/ata.c
src/include/gpxe/aoe.h
src/include/gpxe/ata.h
src/net/aoe.c

index 9679fc1..4b4541f 100644 (file)
  *
  * @v ata              ATA device
  * @v command          ATA command
- * @ret rc             Return status code
+ * @ret aop            Asynchronous operation
  */
-static int aoe_command ( struct ata_device *ata,
-                        struct ata_command *command ) {
+static struct async_operation * aoe_command ( struct ata_device *ata,
+                                             struct ata_command *command ) {
        struct aoe_device *aoedev
                = container_of ( ata, struct aoe_device, ata );
 
-       aoe_issue ( &aoedev->aoe, command );
-       return async_wait ( &aoedev->aoe.aop );
+       return aoe_issue ( &aoedev->aoe, command );
 }
 
 /**
index e0df367..d2d77ae 100644 (file)
@@ -20,6 +20,7 @@
 #include <string.h>
 #include <assert.h>
 #include <byteswap.h>
+#include <gpxe/async.h>
 #include <gpxe/blockdev.h>
 #include <gpxe/ata.h>
 
@@ -48,7 +49,7 @@ ata_command ( struct ata_device *ata, struct ata_command *command ) {
              ( unsigned long long ) command->cb.lba.native,
              command->cb.count.native );
 
-       return ata->command ( ata, command );   
+       return async_wait ( ata->command ( ata, command ) );
 }
 
 /**
index fb69222..07aec03 100644 (file)
@@ -115,7 +115,8 @@ struct aoe_session {
 
 extern void aoe_open ( struct aoe_session *aoe );
 extern void aoe_close ( struct aoe_session *aoe );
-extern void aoe_issue ( struct aoe_session *aoe, struct ata_command *command );
+extern struct async_operation * aoe_issue ( struct aoe_session *aoe,
+                                           struct ata_command *command );
 
 /** An AoE device */
 struct aoe_device {
index e0fca7a..7b348d8 100644 (file)
@@ -11,6 +11,8 @@
  *
  */
 
+struct async_operation;
+
 /**
  * An ATA Logical Block Address
  *
@@ -191,10 +193,10 @@ struct ata_device {
         *
         * @v ata               ATA device
         * @v command           ATA command
-        * @ret rc              Return status code
+        * @ret aop             Asynchronous operation
         */
-       int ( * command ) ( struct ata_device *ata,
-                           struct ata_command *command );
+       struct async_operation * ( * command ) ( struct ata_device *ata,
+                                                struct ata_command *command );
 };
 
 extern int init_atadev ( struct ata_device *ata );
index a91e009..0d59a97 100644 (file)
@@ -274,14 +274,17 @@ void aoe_close ( struct aoe_session *aoe ) {
  *
  * @v aoe              AoE session
  * @v command          ATA command
+ * @ret aop            Asynchronous operation
  *
  * Only one command may be issued concurrently per session.  This call
  * is non-blocking; use async_wait() to wait for the command to
  * complete.
  */
-void aoe_issue ( struct aoe_session *aoe, struct ata_command *command ) {
+struct async_operation * aoe_issue ( struct aoe_session *aoe,
+                                    struct ata_command *command ) {
        aoe->command = command;
        aoe->status = 0;
        aoe->command_offset = 0;
        aoe_send_command ( aoe );
+       return &aoe->aop;
 }