Changeset 8 for trunk

Timestamp:

Sep 10, 2010, 11:30:39 AM (15 years ago)

Author:

markus

Message:

latest changes by Christian

Location:

trunk/src

Files:

• ahci.c (modified) (23 diffs)
• ahci.h (modified) (1 diff)
• ata.c (modified) (11 diffs)
• ata.h (modified) (3 diffs)
• ctxhook.c (modified) (9 diffs)
• libc.i (deleted)
• os2ahci.c (modified) (2 diffs)
• os2ahci.h (modified) (3 diffs)
• os2ahci.i (deleted)

trunk/src/ahci.c

@@ -37 +37 @@
 /* -------------------------- function prototypes -------------------------- */
 
-static int  exec_polled_cmd       (AD_INFO *ai, int p, int d, int timeout,
-                                   int cmd, ...);
 static void ahci_setup_device     (AD_INFO *ai, int p, int d, u16 *id_buf);
 static void _far timeout_callback (ULONG timer_handle, ULONG p1, ULONG p2);
@@ -265 +263 @@
 
   /* set maximum command slot number */
-  ai->cmd_max = (u16) ((ai->cap >> 8) & 31);
+  ai->cmd_max = (u16) ((ai->cap >> 8) & 0x1f);
 
   return(0);
@@ -404 +402 @@
  *  - This function is expected to be called with the spinlock released but
  *    the corresponding adapter's busy flag set. It will aquire the spinlock
- *    temporarily to allocate/free memory for ATA identify buffer.
+ *    temporarily to allocate/free memory for the ATA identify buffer.
  */
 int ahci_scan_ports(AD_INFO *ai)
@@ -457 +455 @@
       /* this port has a device attached and is ready to accept commands */
       ddprintf("port #%d seems to be attached to a device; probing...\n", p);
-      rc = exec_polled_cmd(ai, p, 0, 500, ATA_CMD_ID_ATA, 
-                           AP_VADDR, (void _far *) id_buf, 512,
-                           AP_END);
+      rc = ahci_exec_polled_cmd(ai, p, 0, 500, ATA_CMD_ID_ATA, 
+                                AP_VADDR, (void _far *) id_buf, 512,
+                                AP_END);
 
       if (rc != 0 || id_buf[ATA_ID_CONFIG] & (1U << 15)) {
         /* this might be an ATAPI device; run IDENTIFY_PACKET_DEVICE */
-        rc = exec_polled_cmd(ai, p, 0, 500, ATA_CMD_ID_ATAPI,
-                             AP_VADDR, (void _far *) id_buf, 512,
-                             AP_END);
+        rc = ahci_exec_polled_cmd(ai, p, 0, 500, ATA_CMD_ID_ATAPI,
+                                  AP_VADDR, (void _far *) id_buf, 512,
+                                  AP_END);
       }
 
@@ -826 +824 @@
 {
   volatile u32 *cmds;
+  ADD_WORKSPACE _far *aws = add_workspace(iorb);
   AD_INFO *ai = ad_infos + iorb_unit_adapter(iorb);
   P_INFO *port = ai->ports + iorb_unit_port(iorb);
   ULONG timeout = (iorb->Timeout > 0) ? iorb->Timeout : DEFAULT_TIMEOUT;
   u8 _far *port_mmio = port_base(ai, iorb_unit_port(iorb));
-  int is_ncq = ((ai->cap & HOST_CAP_NCQ) &&
-                ncq_capable &&
-                !add_workspace(iorb)->no_ncq);
   int i;
 
-  /* NCQ disabled temporarily until non-NCQ commands are working fine */
-  is_ncq = 0;
+  /* determine whether this will be an NCQ request */
+  aws->is_ncq = ((ai->cap & HOST_CAP_NCQ) && ncq_capable && !aws->no_ncq);
+
+  /* NCQ disabled temporarily until non-NCQ commands are fully working */
+  aws->is_ncq = 0;
 
   /* check whether adapter is available */
@@ -851 +850 @@
 
     /* prevent NCQ/regular command mix */
-    if (is_ncq && port->reg_cmds == 0 || !is_ncq && port->ncq_cmds == 0) {
+    if (aws->is_ncq && port->reg_cmds == 0 ||
+        !aws->is_ncq && port->ncq_cmds == 0) {
 
       /* Find next available command slot. We use a simple round-robin 
@@ -857 +857 @@
        * from stalling when new commands are coming in frequently.
        */
-      cmds = (is_ncq) ? &port->ncq_cmds : &port->reg_cmds;
+      cmds = (aws->is_ncq) ? &port->ncq_cmds : &port->reg_cmds;
       for (i = 0; i <= ai->cmd_max; i++) {
         if ((*cmds & (1UL << port->cmd_slot)) == 0) {
           break;
         }
-        if (++(port->cmd_slot) >= ai->cmd_max) {
+        if (++(port->cmd_slot) > ai->cmd_max) {
           port->cmd_slot = 0;
         }
@@ -879 +879 @@
 
         /* start timer for this IORB */
-        ADD_StartTimerMS(&add_workspace(iorb)->timer, timeout,
-                         (PFN) timeout_callback, iorb, 0);
-
-        /* update IORB and increment next command index */
-        add_workspace(iorb)->queued_hw = 1;
-        add_workspace(iorb)->cmd_slot = port->cmd_slot;
-        if (++(port->cmd_slot) >= ai->cmd_max) {
-          port->cmd_slot = 0;
-        }
+        ADD_StartTimerMS(&aws->timer, timeout, (PFN) timeout_callback, iorb, 0);
+
+        /* update IORB */
+        aws->queued_hw = 1;
+        aws->cmd_slot = port->cmd_slot;
 
         /* issue command to hardware */
-        dprintf("issuing command on slot %d\n", port->cmd_slot);
+        ddprintf("issuing command on slot %d\n", port->cmd_slot);
         *cmds |= (1UL << port->cmd_slot);
-        if (is_ncq) {
+        if (aws->is_ncq) {
           writel(port_mmio + PORT_SCR_ACT, (1UL << port->cmd_slot));
           readl(port_mmio + PORT_SCR_ACT); /* flush */
@@ -899 +895 @@
         readl(port_mmio + PORT_CMD_ISSUE); /* flush */
 
+        /* make sure next cmd won't use the same slot to prevent starvation */
+        if (++(port->cmd_slot) > ai->cmd_max) {
+          port->cmd_slot = 0;
+        }
         spin_unlock(drv_lock);
         return;
@@ -906 +906 @@
 
   /* requeue this IORB; it will be picked up again in trigger_engine() */
-  add_workspace(iorb)->processing = 0;
+  aws->processing = 0;
   spin_unlock(drv_lock);
 }
@@ -916 +916 @@
  *
  *  - We need to restore the BIOS configuration after we're done with this
- *    command because we might still need the BIOS to load additional drivers.
+ *    command because someone might still call int 13 routines; sending
+ *    asynchronous commands and waiting for interrupts to indicate completion
+ *    won't work in such a scenario.
  *  - Our context hooks won't work while the device managers are initializing
  *    (they can't yield at init time).
@@ -951 +953 @@
   }
 
-  /* restart port (includes the necessary port configuration */
+  /* restart port (includes the necessary port configuration) */
   if (ahci_stop_port(ai, p) || ahci_start_port(ai, p, 0)) {
     iorb_seterr(iorb, IOERR_ADAPTER_NONSPECIFIC);
@@ -983 +985 @@
       if (add_workspace(iorb)->ppfunc != NULL) {
         add_workspace(iorb)->ppfunc(iorb);
+      } else {
+        add_workspace(iorb)->complete = 1;
       }
     }
@@ -994 +998 @@
   ahci_restore_bios_config(ai);
 
-  iorb_done(iorb);
+  if (add_workspace(iorb)->complete | (iorb->Status | IORB_ERROR)) {
+    aws_free(add_workspace(iorb));
+    iorb_done(iorb);
+  }
   return;
+}
+
+/******************************************************************************
+ * Execute polled ATA/ATAPI command. This function will block until the command
+ * has completed or the timeout has expired, thus it should only be used during
+ * initialization. Furthermore, it will always use command slot zero.
+ *
+ * The difference to ahci_exec_polled_iorb() is that this function executes
+ * arbitrary ATA/ATAPI commands outside the context of an IORB. It's typically
+ * used when scanning for devices during initialization.
+ */
+int ahci_exec_polled_cmd(AD_INFO *ai, int p, int d, int timeout, int cmd, ...)
+{
+  va_list va;
+  u8 _far *port_mmio = port_base(ai, p);
+  u32 tmp;
+  int rc;
+
+  /* verify that command slot 0 is idle */
+  if (readl(port_mmio + PORT_CMD_ISSUE) & 1) {
+    ddprintf("port %d slot 0 is not idle; not executing polled cmd\n", p);
+    return(-1);
+  }
+
+  /* fill in command slot 0 */
+  va_start(va, cmd);
+  if ((rc = v_ata_cmd(ai, p, d, 0, cmd, va)) != 0) {
+    return(rc);
+  }
+
+  /* start command execution for slot 0 */
+  ddprintf("executing polled cmd...");
+  writel(port_mmio + PORT_CMD_ISSUE, 1);
+
+  /* wait until command has completed */
+  while (timeout > 0 && (readl(port_mmio + PORT_CMD_ISSUE) & 1)) {
+    mdelay(10);
+    timeout -= 10;
+  }
+  ddprintf(" done (time left = %d)\n", timeout);
+
+  /* check error condition */
+  if ((tmp = readl(port_mmio + PORT_SCR_ERR)) != 0) {
+    dprintf("SERR = 0x%08lx\n", tmp);
+    return(-1);
+  }
+  if (((tmp = readl(port_mmio + PORT_TFDATA)) & 0x89) != 0) {
+    dprintf("TFDATA = 0x%08lx\n", tmp);
+    return(-1);
+  }
+
+  return((timeout <= 0) ? -1 : 0);
 }
 
@@ -1119 +1178 @@
       if (aws->ppfunc != NULL) {
         aws->ppfunc(iorb);
+      } else {
+        aws->complete = 1;
       }
-      aws_free(aws);
-
-      /* move IORB to our temporary done queue */
-      iorb_queue_del(&ai->ports[p].iorb_queue, iorb);
-      iorb_queue_add(&done_queue, iorb);
+
+      if (aws->complete) {
+        /* this IORB is complete */
+        aws_free(aws);
+
+        /* move IORB to our temporary done queue */
+        iorb_queue_del(&ai->ports[p].iorb_queue, iorb);
+        iorb_queue_add(&done_queue, iorb);
+      }
 
       /* clear corresponding bit in issued command bitmaps */
@@ -1205 +1270 @@
 void ahci_get_geometry(IORBH _far *iorb)
 {
+  dprintf("ahci_get_geometry(%d.%d.%d)\n", (int) iorb_unit_adapter(iorb),
+          (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb));
+
   ahci_exec_iorb(iorb, 0, cmd_func(iorb, get_geometry));
 }
@@ -1213 +1281 @@
 void ahci_unit_ready(IORBH _far *iorb)
 {
+  dprintf("ahci_unit_ready(%d.%d.%d)\n", (int) iorb_unit_adapter(iorb),
+          (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb));
+
   ahci_exec_iorb(iorb, 0, cmd_func(iorb, unit_ready));
 }
@@ -1221 +1292 @@
 void ahci_read(IORBH _far *iorb)
 {
+  dprintf("ahci_read(%d.%d.%d, %ld, %ld)\n", (int) iorb_unit_adapter(iorb),
+          (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb),
+          (long) ((IORB_EXECUTEIO _far *) iorb)->RBA,
+          (long) ((IORB_EXECUTEIO _far *) iorb)->BlockCount);
+
   ahci_exec_iorb(iorb, 1, cmd_func(iorb, read));
 }  
@@ -1229 +1305 @@
 void ahci_verify(IORBH _far *iorb)
 {
+  dprintf("ahci_verify(%d.%d.%d, %ld, %ld)\n", (int) iorb_unit_adapter(iorb),
+          (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb),
+          (long) ((IORB_EXECUTEIO _far *) iorb)->RBA,
+          (long) ((IORB_EXECUTEIO _far *) iorb)->BlockCount);
+
   ahci_exec_iorb(iorb, 0, cmd_func(iorb, verify));
 }
@@ -1237 +1318 @@
 void ahci_write(IORBH _far *iorb)
 {
+  dprintf("ahci_write(%d.%d.%d, %ld, %ld)\n", (int) iorb_unit_adapter(iorb),
+          (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb),
+          (long) ((IORB_EXECUTEIO _far *) iorb)->RBA,
+          (long) ((IORB_EXECUTEIO _far *) iorb)->BlockCount);
+
   ahci_exec_iorb(iorb, 1, cmd_func(iorb, write));
 }
@@ -1248 +1334 @@
   int p = iorb_unit_port(iorb);
   int d = iorb_unit_device(iorb);
+
+  dphex(((IORB_ADAPTER_PASSTHRU _far *) iorb)->pControllerCmd,
+        ((IORB_ADAPTER_PASSTHRU _far *) iorb)->ControllerCmdLen,
+        "ahci_execute_cdb(%d.%d.%d)", (int) iorb_unit_adapter(iorb),
+        (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb));
   
   if (ad_infos[a].ports[p].devs[d].atapi) {
@@ -1266 +1357 @@
   int d = iorb_unit_device(iorb);
   
+  dphex(((IORB_ADAPTER_PASSTHRU _far *) iorb)->pControllerCmd,
+        ((IORB_ADAPTER_PASSTHRU _far *) iorb)->ControllerCmdLen,
+        "ahci_execute_cdb(%d.%d.%d)", (int) iorb_unit_adapter(iorb),
+        (int) iorb_unit_port(iorb), (int) iorb_unit_device(iorb));
+  
   if (ad_infos[a].ports[p].devs[d].atapi) {
     iorb_seterr(iorb, IOERR_CMD_NOT_SUPPORTED);
@@ -1272 +1368 @@
     ahci_exec_iorb(iorb, 0, ata_execute_ata);
   }
-}
-
-/******************************************************************************
- * Execute polled ATA/ATAPI command. This function will block until the command
- * has completed or the timeout has expired, thus it should only be used during
- * initialization. Furthermore, it will always use command slot zero...
- */
-static int exec_polled_cmd(AD_INFO *ai, int p, int d, int timeout, int cmd, ...)
-{
-  va_list va;
-  u8 _far *port_mmio = port_base(ai, p);
-  u32 tmp;
-  int rc;
-
-  /* verify that command slot 0 is idle */
-  if (readl(port_mmio + PORT_CMD_ISSUE) & 1) {
-    ddprintf("port %d slot 0 is not idle; not executing polled cmd\n", p);
-    return(-1);
-  }
-
-  /* fill in command slot 0 */
-  va_start(va, cmd);
-  if ((rc = v_ata_cmd(ai, p, d, 0, cmd, va)) != 0) {
-    return(rc);
-  }
-
-  /* start command execution for slot 0 */
-  ddprintf("executing polled cmd...");
-  writel(port_mmio + PORT_CMD_ISSUE, 1);
-
-  /* wait until command has completed */
-  while (timeout > 0 && (readl(port_mmio + PORT_CMD_ISSUE) & 1)) {
-    mdelay(10);
-    timeout -= 10;
-  }
-  ddprintf(" done (time left = %d)\n", timeout);
-
-  /* check error condition */
-  if ((tmp = readl(port_mmio + PORT_SCR_ERR)) != 0) {
-    dprintf("SERR = 0x%08lx\n", tmp);
-    return(-1);
-  }
-  if (((tmp = readl(port_mmio + PORT_TFDATA)) & 0x89) != 0) {
-    dprintf("TFDATA = 0x%08lx\n", tmp);
-    return(-1);
-  }
-
-  return((timeout <= 0) ? -1 : 0);
 }
 

trunk/src/ahci.h

@@ -209 +209 @@
  *       interface it's developed for, is based on x86 design patterns, we're
  *       not even going to start making a difference between little and big
- *       endian architectures. PCI is little endoian, AHCI is little endian,
+ *       endian architectures. PCI is little endian, AHCI is little endian,
  *       x86 is little endian, and that's it.
  */

trunk/src/ata.c

@@ -98 +98 @@
       break;
 
-    case AP_H2D:
+    case AP_WRITE:
       ahci_flags |= AHCI_CMD_WRITE;
       break;
@@ -221 +221 @@
    *    than AHCI_MAX_SG entries. In order to help the caller, the return value
    *    of this function will indicate how many OS/2 S/G entries were
-   *    successfully be mapped.
+   *    successfully mapped.
    *
    */
@@ -306 +306 @@
 
 /******************************************************************************
+ * Get index in S/G list for the number of transferred sectors in the IORB.
+ *
+ * Returning io->cSGList indicates an error.
+ *
+ * NOTE: OS/2 makes sure S/G lists are set up such that entries at the HW
+ *       limit will never cross sector boundaries. This means that splitting
+ *       S/G lists into multiple commands can be done without editing the S/G
+ *       lists.
+ */
+u16 ata_get_sg_indx(IORB_EXECUTEIO _far *io)
+{
+  ULONG offset = io->BlocksXferred * io->BlockSize;
+  USHORT i;
+
+  for (i = 0; i < io->cSGList && offset > 0; i++) {
+    offset -= io->pSGList[i].XferBufLen;
+  }
+
+  return(i);
+}
+
+/******************************************************************************
+ * Get max S/G count which will fit into our HW S/G buffers. This function is
+ * called when the S/G list is too long and we need to split the IORB into
+ * multiple commands. It returns both the number of sectors and S/G list
+ * elements that we can handle in a single command.
+ *
+ * The parameter 'sg_indx' indicates the current start index in the S/G list
+ * (0 if this is the first command iteration).
+ *
+ * The parameter 'sg_max' is the return value of v_ata_cmd() and indicates
+ * how many S/G elements were successfully mapped. Whatever we return needs to
+ * be less or equal to this value.
+ *
+ * Returning 0 in *sg_cnt indicates an error.
+ *
+ * NOTE: OS/2 makes sure S/G lists are set up such that entries at HW limits
+ *       will never cross sector boundaries. This means that splitting S/G
+ *       lists into multiple commands can be done without editing S/G list
+ *       elements. Since AHCI only allows 22 bits for each S/G element, the
+ *       hardware limits are reported as AHCI_MAX_SG / 2 but will vary based
+ *       on the actual length of S/G elements. This function looks for the
+ *       maximum number of S/G elements that can be mapped on sector
+ *       boundaries which will still fit into our HW S/G list.
+ */
+void ata_max_sg_cnt(IORB_EXECUTEIO _far *io, USHORT sg_indx, USHORT sg_max,
+                    USHORT _far *sg_cnt, USHORT _far *sector_cnt)
+{
+  ULONG max_sector_cnt = 0;
+  USHORT max_sg_cnt = 0;
+  ULONG offset = 0;
+  USHORT i;
+
+  for (i = sg_indx; i < io->cSGList; i++) {
+    if (i - sg_indx >= sg_max) {
+      /* we're beyond the number of S/G elements we can map */
+      break;
+    }
+
+    offset += io->pSGList[i].XferBufLen;
+    if (offset % io->BlockSize == 0) {
+      /* this S/G element ends on a sector boundary */
+      max_sector_cnt = offset / io->BlockSize;
+      max_sg_cnt = i + 1;
+    }
+  }
+
+  /* return the best match we found so far (0 indicating failure) */
+  *sector_cnt = max_sector_cnt;
+  *sg_cnt = max_sg_cnt;
+}
+
+
+/******************************************************************************
  * Get device or media geometry. Device and media geometry are expected to be
  * the same for non-removable devices, which will always be the case for the
@@ -334 +408 @@
   if (rc != 0) {
     free(aws->buf);
-    aws->buf = NULL;
     iorb_seterr(iorb, IOERR_CMD_ADD_SOFTWARE_FAILURE);
   }
@@ -404 +477 @@
                                ((u32) geometry->NumHeads *
                                 (u32) geometry->SectorsPerTrack);
+
+  /* tell interrupt handler that this IORB is complete */
+  add_workspace(iorb)->complete = 1;
 }
 
@@ -426 +502 @@
   IORB_EXECUTEIO _far *io = (IORB_EXECUTEIO _far *) iorb;
   AD_INFO *ai = ad_infos + iorb_unit_adapter(iorb);
+  ULONG sector = io->RBA + io->BlocksXferred;
+  USHORT count = io->BlockCount - io->BlocksXferred;
+  USHORT sg_indx;
+  USHORT sg_cnt;
   int p = iorb_unit_port(iorb);
   int d = iorb_unit_device(iorb);
   int rc;
 
-  /* prepare read command */
-  if (io->RBA >= (1UL << 28) || io->BlockCount > 256) {
-    /* need LBA48 for this command */
-    if (!ai->ports[p].devs[d].lba48) {
-      iorb_seterr(iorb, IOERR_RBA_LIMIT);
-      return(-1);
-    }
-    rc = ata_cmd(ai, p, d, slot, ATA_CMD_READ_EXT,
-                 AP_SECTOR_48, (u32) io->RBA, (u16) 0,
-                 AP_COUNT,     (u16) io->BlockCount,
-                 AP_SGLIST,    io->pSGList, (u16) io->cSGList,
-                 AP_DEVICE,    0x4000,
-                 AP_END);
+  /* prepare read command while keeping an eye on S/G count limitations */
+  do {
+    sg_indx = ata_get_sg_indx(io);
+    sg_cnt = io->cSGList - sg_indx;
+
+    if (sector >= (1UL << 28) || count > 256) {
+      /* need LBA48 for this command */
+      if (!ai->ports[p].devs[d].lba48) {
+        iorb_seterr(iorb, IOERR_RBA_LIMIT);
+        return(-1);
+      }
+      rc = ata_cmd(ai, p, d, slot, ATA_CMD_READ_EXT,
+                   AP_SECTOR_48, (u32) sector, (u16) 0,
+                   AP_COUNT,     (u16) count,
+                   AP_SGLIST,    io->pSGList + sg_indx, (u16) sg_cnt,
+                   AP_DEVICE,    0x4000,
+                   AP_END);
+    } else {
+      rc = ata_cmd(ai, p, d, slot, ATA_CMD_READ,
+                   AP_SECTOR_28, (u32) sector,
+                   AP_COUNT,     (u16) count & 0xffU,
+                   AP_SGLIST,    io->pSGList + sg_indx, (u16) sg_cnt,
+                   AP_DEVICE,    0x4000,
+                   AP_END);
+    }
+
+    if (rc > 0) {
+      /* couldn't map all S/G elements */
+      ata_max_sg_cnt(io, sg_indx, (USHORT) rc, &sg_cnt, &count);
+    }
+  } while (rc > 0 && sg_cnt > 0);
+
+  if (rc == 0) {
+    add_workspace(iorb)->blocks = count;
+    add_workspace(iorb)->ppfunc = ata_read_pp;
+
+  } else if (rc > 0) {
+    iorb_seterr(iorb, IOERR_CMD_SGLIST_BAD);
+
   } else {
-    rc = ata_cmd(ai, p, d, slot, ATA_CMD_READ,
-                 AP_SECTOR_28, (u32) io->RBA,
-                 AP_COUNT,     (u16) io->BlockCount & 0xffU,
-                 AP_SGLIST,    io->pSGList, (u16) io->cSGList,
-                 AP_DEVICE,    0x4000,
-                 AP_END);
+    iorb_seterr(iorb, IOERR_CMD_ADD_SOFTWARE_FAILURE);
   }
 
@@ -456 +557 @@
 
 /******************************************************************************
- * Verify readability of sectors on AHCI device.
+ * Post processing function for ata_read(); this function updates the
+ * BlocksXferred counter in the IORB and, if not all blocks have been
+ * transferred, requeues the IORB to process the remaining sectors.
+ */
+void ata_read_pp(IORBH _far *iorb)
+{
+  IORB_EXECUTEIO _far *io = (IORB_EXECUTEIO _far *) iorb;
+
+  io->BlocksXferred += add_workspace(iorb)->blocks;
+  ddprintf("ata_read_pp(): blocks transferred = %d\n", (int) io->BlocksXferred);
+
+  if (io->BlocksXferred >= io->BlockCount) {
+    /* we're done; tell IRQ handler the IORB is complete */
+    add_workspace(iorb)->complete = 1;
+  } else {
+    /* requeue this IORB for next iteration */
+    iorb_requeue(iorb);
+  }
+}
+
+/******************************************************************************
+ * Verify readability of sectors on ATA device.
  */
 int ata_verify(IORBH _far *iorb, int slot)
@@ -476 +598 @@
                  AP_SECTOR_48, (u32) io->RBA, (u16) 0,
                  AP_COUNT,     (u16) io->BlockCount,
-                 AP_SGLIST,    io->pSGList, (u16) io->cSGList,
                  AP_DEVICE,    0x4000,
                  AP_END);
@@ -483 +604 @@
                  AP_SECTOR_28, (u32) io->RBA,
                  AP_COUNT,     (u16) io->BlockCount & 0xffU,
-                 AP_SGLIST,    io->pSGList, (u16) io->cSGList,
                  AP_END);
   }
@@ -497 +617 @@
   IORB_EXECUTEIO _far *io = (IORB_EXECUTEIO _far *) iorb;
   AD_INFO *ai = ad_infos + iorb_unit_adapter(iorb);
+  ULONG sector = io->RBA + io->BlocksXferred;
+  USHORT count = io->BlockCount - io->BlocksXferred;
+  USHORT sg_indx;
+  USHORT sg_cnt;
   int p = iorb_unit_port(iorb);
   int d = iorb_unit_device(iorb);
   int rc;
 
-  /* prepare write command */
-  if (io->RBA >= (1UL << 28) || io->BlockCount > 256) {
-    /* need LBA48 for this command */
-    if (!ai->ports[p].devs[d].lba48) {
-      iorb_seterr(iorb, IOERR_RBA_LIMIT);
-      return(-1);
-    }
-    rc = ata_cmd(ai, p, d, slot, ATA_CMD_WRITE_EXT,
-                 AP_SECTOR_48, (u32) io->RBA, (u16) 0,
-                 AP_COUNT,     (u16) io->BlockCount,
-                 AP_SGLIST,    io->pSGList, (u16) io->cSGList,
-                 AP_DEVICE,    0x4000,
-                 AP_END);
+  /* prepare write command while keeping an eye on S/G count limitations */
+  do {
+    sg_indx = ata_get_sg_indx(io);
+    sg_cnt = io->cSGList - sg_indx;
+
+    if (sector >= (1UL << 28) || count > 256) {
+      /* need LBA48 for this command */
+      if (!ai->ports[p].devs[d].lba48) {
+        iorb_seterr(iorb, IOERR_RBA_LIMIT);
+        return(-1);
+      }
+      rc = ata_cmd(ai, p, d, slot, ATA_CMD_WRITE_EXT,
+                   AP_SECTOR_48, (u32) sector, (u16) 0,
+                   AP_COUNT,     (u16) count,
+                   AP_SGLIST,    io->pSGList + sg_indx, (u16) sg_cnt,
+                   AP_DEVICE,    0x4000,
+                   AP_WRITE,
+                   AP_END);
+    } else {
+      rc = ata_cmd(ai, p, d, slot, ATA_CMD_WRITE,
+                   AP_SECTOR_28, (u32) sector,
+                   AP_COUNT,     (u16) count & 0xffU,
+                   AP_SGLIST,    io->pSGList + sg_indx, (u16) sg_cnt,
+                   AP_DEVICE,    0x4000,
+                   AP_WRITE,
+                   AP_END);
+    }
+
+    if (rc > 0) {
+      /* couldn't map all S/G elements */
+      ata_max_sg_cnt(io, sg_indx, (USHORT) rc, &sg_cnt, &count);
+    }
+  } while (rc > 0 && sg_cnt > 0);
+
+  if (rc == 0) {
+    add_workspace(iorb)->blocks = count;
+    add_workspace(iorb)->ppfunc = ata_write_pp;
+
+  } else if (rc > 0) {
+    iorb_seterr(iorb, IOERR_CMD_SGLIST_BAD);
+
   } else {
-    rc = ata_cmd(ai, p, d, slot, ATA_CMD_WRITE,
-                 AP_SECTOR_28, (u32) io->RBA,
-                 AP_COUNT,     (u16) io->BlockCount & 0xffU,
-                 AP_SGLIST,    io->pSGList, (u16) io->cSGList,
-                 AP_DEVICE,    0x4000,
-                 AP_END);
+    iorb_seterr(iorb, IOERR_CMD_ADD_SOFTWARE_FAILURE);
   }
 
   return(rc);
+}
+
+/******************************************************************************
+ * Post processing function for ata_write(); this function updates the
+ * BlocksXferred counter in the IORB and, if not all blocks have been
+ * transferred, requeues the IORB to process the remaining sectors.
+ */
+void ata_write_pp(IORBH _far *iorb)
+{
+  IORB_EXECUTEIO _far *io = (IORB_EXECUTEIO _far *) iorb;
+
+  io->BlocksXferred += add_workspace(iorb)->blocks;
+  ddprintf("ata_write_pp(): blocks transferred = %d\n", (int) io->BlocksXferred);
+
+  if (io->BlocksXferred >= io->BlockCount) {
+    /* we're done; tell IRQ handler the IORB is complete */
+    add_workspace(iorb)->complete = 1;
+  } else {
+    /* requeue this IORB for next iteration */
+    iorb_requeue(iorb);
+  }
 }
 
@@ -536 +704 @@
 
 /******************************************************************************
- * Request sense information (which means "read ATA log page" for ATA devices)
+ * Request sense information for a failed command. Since there is no "request
+ * sense" command for ATA devices, we need to read the current error code from
+ * the AHCI task file register and fabricate the sense information.
+ *
+ * NOTES:
+ *
+ *   - This function must be called right after an ATA command has failed and
+ *     before any other commands are queued on the corresponding port. This
+ *     function is typically called in the port restart context hook which is
+ *     triggered by an AHCI error interrupt.
+ *
+ *   - The ATA error bits are a complete mess. We'll try and catch the most
+ *     interesting error codes (such as medium errors) and report everything
+ *     else with a generic error code.
  */
 int ata_req_sense(IORBH _far *iorb, int slot)
 {
-  iorb_seterr(iorb, IOERR_CMD_NOT_SUPPORTED);
+  AD_INFO *ai = ad_infos + iorb_unit_adapter(iorb);
+  u8 _far *port_mmio = port_base(ai, iorb_unit_port(iorb));
+  u32 tf_data = readl(port_mmio + PORT_TFDATA);
+  u8 err = (u8) (tf_data >> 8);
+  u8 sts = (u8) (tf_data);
+
+  if (sts & ATA_ERR) {
+    if (sts & ATA_DF) {
+      /* there is a device-specific error condition */
+      if (err & ATA_ICRC) {
+        iorb_seterr(iorb, IOERR_ADAPTER_DEVICEBUSCHECK);
+      } else if (err & ATA_UNC) {
+        iorb_seterr(iorb, IOERR_MEDIA);
+      } else if (err & ATA_IDNF) {
+        iorb_seterr(iorb, IOERR_RBA_ADDRESSING_ERROR);
+      } else {
+        iorb_seterr(iorb, IOERR_DEVICE_NONSPECIFIC);
+      }
+    
+    } else {
+      iorb_seterr(iorb, IOERR_DEVICE_NONSPECIFIC);
+    }
+  }
+
+  /* TBD: fill in SCSI sense buffer in IORB */
+
+  /* Return an error to indicate there's no HW command to be submitted and
+   * that the IORB can be completed "as is" (the upstream code expects the
+   * IORB error code, if any, to be set when this happens and this is exactly
+   * what this function is all about).
+   */
   return(-1);
 }

trunk/src/ata.h

@@ -396 +396 @@
   AP_SGLIST,       /* [void _far *, u16] buffer S/G (SCATGATENTRY/count)    */
   AP_VADDR,        /* [void _far *, u16] buffer virtual address (buf/len)   */
-  AP_H2D,          /* []                 host-to-device direction           */
+  AP_WRITE,        /* []                 indicates a DMA write operation    */
   AP_AHCI_FLAGS,   /* [u16]              AHCI command header flags          */
   AP_ATAPI_CMD,    /* [void _far *, u16] ATAPI command (CDB) and length     */
@@ -442 +442 @@
 extern void      ata_cmd_to_fis      (u8 _far *fis, ATA_CMD _far *cmd,
                                       int device);
+extern USHORT    ata_get_sg_indx     (IORB_EXECUTEIO _far *io);
+extern void      ata_max_sg_cnt      (IORB_EXECUTEIO _far *io, USHORT sg_indx,
+                                      USHORT sg_max, USHORT _far *sg_cnt,
+                                      USHORT _far *sector_cnt);
 
 extern int       ata_get_geometry    (IORBH _far *iorb, int slot);
@@ -447 +451 @@
 extern int       ata_unit_ready      (IORBH _far *iorb, int slot);
 extern int       ata_read            (IORBH _far *iorb, int slot);
+extern void      ata_read_pp         (IORBH _far *iorb);
 extern int       ata_verify          (IORBH _far *iorb, int slot);
 extern int       ata_write           (IORBH _far *iorb, int slot);
+extern void      ata_write_pp        (IORBH _far *iorb);
 extern int       ata_execute_ata     (IORBH _far *iorb, int slot);
 extern int       ata_req_sense       (IORBH _far *iorb, int slot);
+
 extern char     *ata_dev_name        (u16 *id_buf);
+

trunk/src/ctxhook.c

@@ -82 +82 @@
 void restart_ctxhook(ULONG parm)
 {
+  IORB_QUEUE done_queue;
   AD_INFO *ai;
   IORBH _far *problem_iorb;
@@ -92 +93 @@
   int a;
   int p;
-  int d;
 
   dprintf("restart_ctxhook() started\n");
+  memset(&done_queue, 0x00, sizeof(done_queue));
+
   spin_lock(drv_lock);
 
@@ -108 +110 @@
     for (p = 0; p <= ai->port_max; p++) {
       if (ports_to_restart[a] & (1UL << p)) {
+        ports_to_restart[a] &= ~(1UL << p);
 
         /* restart this port */
-        ports_to_restart[a] &= ~(1UL << p);
         port_mmio = port_base(ai, p);
         problem_iorb = NULL;
@@ -124 +126 @@
           if (aws->queued_hw) {
             if (ai->ports[p].ncq_cmds != 0) {
+              /* NCQ commands active; force non-NCQ mode and trigger port reset */
+              aws->no_ncq = 1;
               need_reset = 1;
             } else if (aws->cmd_slot == ccs) {
@@ -129 +133 @@
               problem_iorb = iorb;
             }
-
-            /* requeue this command with the 'no_ncq' flag set */
-            aws_free(aws);
-            memset(&iorb->ADDWorkSpace, sizeof(iorb->ADDWorkSpace), 0x00);
-            aws->no_ncq = 1;
+            iorb_requeue(iorb);
 
             /* remove requeued command from the issued command bitmaps */
@@ -166 +166 @@
         ai->busy = 0;
 
-        /* reset port status */
-        ai->ports[p].cmd_slot = 0;
+        /* reset internal port status */
         ai->ports[p].ncq_cmds = 0;
         ai->ports[p].reg_cmds = 0;
-
-        if (!need_reset && problem_iorb != NULL) {
-          /* request sense data for the failing command in cmd slot #0 */
-          ADD_WORKSPACE _far *aws = add_workspace(problem_iorb);
-          aws->processing = 1;
-          aws->queued_hw = 1;
-          d = iorb_unit_device(problem_iorb);
-          if (ai->ports[p].devs[d].atapi) {
-            atapi_req_sense(problem_iorb, 0);
+        ai->ports[p].cmd_slot = 0;
+
+        if (problem_iorb != NULL) {
+          /* get details about the error that caused this IORB to fail */
+          if (need_reset) {
+            /* no way to retrieve error details after a reset */
+            iorb_seterr(problem_iorb, IOERR_DEVICE_NONSPECIFIC);
+            iorb_queue_del(&ai->ports[p].iorb_queue, problem_iorb);
+            iorb_queue_add(&done_queue, problem_iorb);
+
           } else {
-            ata_req_sense(problem_iorb, 0);
+            /* get sense information */
+            ADD_WORKSPACE _far *aws = add_workspace(problem_iorb);
+            int d = iorb_unit_device(problem_iorb);
+            int (*req_sense)(IORBH _far *, int) = 
+              (ai->ports[p].devs[d].atapi) ? atapi_req_sense : ata_req_sense;
+
+            aws->processing = 1;
+            aws->queued_hw = 1;
+
+            if (req_sense(problem_iorb, 0) == 0) {
+              /* execute request sense on slot #0 before anything else comes along */
+              ai->ports[p].reg_cmds = 1;
+              writel(port_mmio + PORT_CMD_ISSUE, 1);
+              readl(port_mmio); /* flush */
+
+            } else {
+              /* IORB is expected to contain the error code; just move to done queue */
+              iorb_queue_del(&ai->ports[p].iorb_queue, problem_iorb);
+              iorb_queue_add(&done_queue, problem_iorb);
+            }
           }
-          ai->ports[p].reg_cmds = 1;
-          writel(port_mmio + PORT_CMD_ISSUE, 1);
-          readl(port_mmio); /* flush */
         }
       }
@@ -190 +206 @@
   }
 
+  spin_unlock(drv_lock);
+
+  /* call notification routine on all IORBs which have completed */
+  for (iorb = done_queue.root; iorb != NULL; iorb = next) {
+    next = iorb->pNxtIORB;
+    if (iorb->RequestControl & IORB_ASYNC_POST) {
+      iorb->NotifyAddress(iorb);
+    }
+  }
+
   /* restart engine to resume IORB processing */
+  spin_lock(drv_lock);
   trigger_engine();
   spin_unlock(drv_lock);
@@ -283 +310 @@
     for (p = 0; p <= ai->port_max; p++) {
       if (ports_to_reset[a] & (1UL << p)) {
+        ports_to_reset[a] &= ~(1UL << p);
+
         /* Reset this port. Since this is a rather slow operation, we'll
          * release the spinlock while doing so. The adapter is marked as
@@ -288 +317 @@
          * interfering. 
          */
-        ports_to_reset[a] &= ~(1UL << p);
         ai->busy = 1;
         spin_unlock(drv_lock);

trunk/src/os2ahci.c

@@ -700 +700 @@
     ptr->AdapterHostBus  = AI_HOSTBUS_OTHER | AI_BUSWIDTH_32BIT;
     ptr->AdapterFlags    = AF_16M | AF_HW_SCATGAT;
-    ptr->MaxHWSGList     = AHCI_MAX_SG;
+
+    /* AHCI limits S/G elements to 22 bits, thus we'll report only half of
+     * our S/G list buffers to reduce complexity. The command preparation code
+     * will always try to map as many S/G elements as possible so the physical
+     * S/G list capacity is not really wasted except in rare conditions where
+     * we need to split commands with long S/G lists without any suitable split
+     * points except those at the reported MaxHWSGList.
+     */
+    ptr->MaxHWSGList     = AHCI_MAX_SG / 2;
 
     if (!ad_info->port_scan_done) {
@@ -978 +986 @@
 }
 
+/******************************************************************************
+ * Requeue the specified IORB such that it will be sent downstream for
+ * processing again. This includes freeing all resources currently allocated
+ * (timer, buffer, ...) and resetting the flags to 0.
+ *
+ * The following flags are preserved:
+ *  - no_ncq
+ */
+void iorb_requeue(IORBH _far *iorb)
+{
+  ADD_WORKSPACE _far *aws = add_workspace(iorb);
+  u16 no_ncq = aws->no_ncq;
+
+  aws_free(aws);
+  memset(aws, 0x00, sizeof(*aws));
+  aws->no_ncq = no_ncq;
+}
+

trunk/src/os2ahci.h

@@ -317 +317 @@
 /* ADD workspace in IORB (must not exceed 16 bytes) */
 typedef struct {
-  IORBH _far   *next;                  /* link to next IORB in our own queues */
   void (*ppfunc)(IORBH _far *iorb);    /* post-processing function */
   void         *buf;                   /* response buffer (e.g. for identify cmds) */
   ULONG         timer;                 /* timer for timeout procesing */
+  USHORT        blocks;                /* number of blocks to be transferred */
   unsigned      processing    : 1;     /* IORB is being processd */
   unsigned      idempotent    : 1;     /* IORB is idempotent (can be retried) */
   unsigned      queued_hw     : 1;     /* IORB has been queued to hardware */
-  unsigned      no_ncq        : 1;     /* don't use native command queuing */
+  unsigned      no_ncq        : 1;     /* must not use native command queuing */
+  unsigned      is_ncq        : 1;     /* should use native command queueing */
+  unsigned      complete      : 1;     /* IORB has completed processing */
   unsigned      cmd_slot      : 4;     /* AHCI command slot for this IORB */
 } ADD_WORKSPACE;
@@ -357 +359 @@
 extern void    iorb_seterr            (IORBH _far *iorb, USHORT error_code);
 extern void    iorb_done              (IORBH _far *iorb);
+extern void    iorb_requeue           (IORBH _far *iorb);
 
 /* ahci.c */
@@ -380 +383 @@
                                              int (*func)(IORBH _far *, int),
                                              ULONG timeout);
+extern int     ahci_exec_polled_cmd         (AD_INFO *ai, int p, int d,
+                                             int timeout, int cmd, ...);
 
 extern int     ahci_intr                    (u16 irq);