Changeset 69 for trunk/src/os2ahci/ahci.c

Timestamp:

Jan 7, 2011, 4:54:46 PM (15 years ago)

Author:

markus

Message:

fixed ATAPI packet commands; added cache flush in shutdown handler; allow write cache for NCQ commands

File:

• trunk/src/os2ahci/ahci.c (modified) (5 diffs)

trunk/src/os2ahci/ahci.c

@@ -38 +38 @@
 
 static void ahci_setup_device     (AD_INFO *ai, int p, int d, u16 *id_buf);
-static void _cdecl _far timeout_callback (ULONG timer_handle, ULONG p1, ULONG p2);
 
 /* ------------------------ global/static variables ------------------------ */
@@ -745 +744 @@
   int rc;
 
+  /* disable port interrupts */
+  writel(port_mmio + PORT_IRQ_MASK, PORT_IRQ_TF_ERR);
+
   /* disable FIS reception */
   if ((rc = ahci_stop_fis_rx(ai, p)) != 0) {
@@ -1035 +1037 @@
 
 /******************************************************************************
+ * 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);
+    timeout = 0;
+  }
+  if (((tmp = readl(port_mmio + PORT_TFDATA)) & 0x89) != 0) {
+    dprintf("TFDATA = 0x%08lx\n", tmp);
+    timeout = 0;
+  }
+
+  if (timeout <= 0) {
+    ahci_reset_port(ai, p, 0);
+    return(-1);
+  }
+  return(0);
+}
+
+/******************************************************************************
+ * Flush write cache of the specified device. Since there's no equivalent IORB
+ * command, we'll execute this command directly using polling. Otherwise, we
+ * would have to create a fake IORB, add it to the port's IORB queue, ...
+ *
+ * Besides, this function is only called when shutting down and the code there
+ * would have to wait for the flush cache command to complete as well, using
+ * polling just the same...
+ */
+int ahci_flush_cache(AD_INFO *ai, int p, int d)
+{
+  dprintf("flushing cache on %d.%d.%d\n", ad_no(ai), p, d);
+  return(ahci_exec_polled_cmd(ai, p, d, 30000,
+                              ai->ports[p].devs[d].lba48 ? ATA_CMD_FLUSH_EXT
+                                                         : ATA_CMD_FLUSH,
+                              AP_END));
+}
+
+/******************************************************************************
  * set device into IDLE mode (spin down); this was used during
  * debugging/testing and is still there since it does not hurt...
@@ -1040 +1116 @@
  * is turned off.
  */
-int ahci_set_dev_idle(AD_INFO *ai, int p, int idle)
+int ahci_set_dev_idle(AD_INFO *ai, int p, int d, int idle)
 {
   ddprintf("sending IDLE=%d command to port %d\n", idle, p);
-  return ahci_exec_polled_cmd(ai, p, 0, 500, ATA_CMD_IDLE, AP_COUNT,
+  return ahci_exec_polled_cmd(ai, p, d, 500, ATA_CMD_IDLE, AP_COUNT,
                               idle ? 1 : 0, AP_END);
-}
-
-/******************************************************************************
- * 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);
-    timeout = 0;
-  }
-  if (((tmp = readl(port_mmio + PORT_TFDATA)) & 0x89) != 0) {
-    dprintf("TFDATA = 0x%08lx\n", tmp);
-    timeout = 0;
-  }
-
-  if (timeout <= 0) {
-    ahci_reset_port(ai, p, 0);
-    return(-1);
-  }
-  return(0);
 }
 
@@ -1502 +1522 @@
     pci_hack_virtualbox();
   }
-
-
-}
-
-/******************************************************************************
- * Timeout handler for I/O commands. Since timeout handling can involve
- * lengthy operations like port resets, the main code is located in a
- * separate function which is invoked via a context hook.
- */
-static void _cdecl _far timeout_callback(ULONG timer_handle, ULONG p1,
-                                         ULONG p2)
-{
-  IORBH _far *iorb = (IORBH _far *) p1;
-  int a = iorb_unit_adapter(iorb);
-  int p = iorb_unit_port(iorb);
-
-  ADD_CancelTimer(timer_handle);
-  dprintf("timeout for IORB %Fp\n", iorb);
-
-  /* Move the timed-out IORB to the abort queue. Since it's possible that the
-   * IORB has completed after the timeout has expired but before we got to
-   * this line of code, we'll check the return code of iorb_queue_del(): If it
-   * returns an error, the IORB must have completed a few microseconds ago and
-   * there is no timeout.
-   */
-  spin_lock(drv_lock);
-  if (iorb_queue_del(&ad_infos[a].ports[p].iorb_queue, iorb) == 0) {
-    iorb_queue_add(&abort_queue, iorb);
-    iorb->ErrorCode = IOERR_ADAPTER_TIMEOUT;
-  }
-  spin_unlock(drv_lock);
-
-  /* Trigger abort processing function. We don't really care whether this
-   * succeeds because the only reason why it would fail should be multiple
-   * calls to DevHelp_ArmCtxHook() before the context hook had a chance to
-   * start executing, which leaves two scenarios:
-   *
-   *  - We succeded in arming the context hook. Fine.
-   *
-   *  - We armed the context hook a second time before it had a chance to
-   *    start executing. In this case, the already scheduled context hook
-   *    will process our IORB as well.
-   */
-  DevHelp_ArmCtxHook(0, reset_ctxhook_h);
-}
-
-
+}
+
+