Changeset 8 for trunk/src/ata.c

Timestamp:

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

Author:

markus

Message:

latest changes by Christian

File:

• trunk/src/ata.c (modified) (11 diffs)

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