Changeset 69 for trunk

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

Location:

trunk/src/os2ahci

Files:

• ahci.c (modified) (5 diffs)
• ata.c (modified) (4 diffs)
• atapi.c (modified) (4 diffs)
• ctxhook.c (modified) (1 diff)
• init.asm (modified) (1 diff)
• os2ahci.c (modified) (3 diffs)
• os2ahci.def (modified) (1 diff)
• os2ahci.h (modified) (3 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);
-}
-
-
+}
+
+

trunk/src/os2ahci/ata.c

@@ -107 +107 @@
     case AP_FEATURES:
       /* ATA features word */
-      ata_cmd.features = va_arg(va, u16);
+      ata_cmd.features |= va_arg(va, u16);
       break;
 
@@ -118 +118 @@
       /* 28-bit sector address */
       ata_cmd.lba_l = va_arg(va, u32);
-      dprintf("LBA28: 0x%08lx\n", ata_cmd.lba_l);
       if (ata_cmd.lba_l & 0xf0000000UL) {
         dprintf("error: LBA-28 address %ld has more than 28 bits\n", ata_cmd.lba_l);
@@ -133 +132 @@
       ata_cmd.lba_l = va_arg(va, u32);
       ata_cmd.lba_h = va_arg(va, u16);
-      dprintf("LBA48: 0x%08lx\n", ata_cmd.lba_l);
       break;
 
@@ -703 +701 @@
                      AP_COUNT,     (u16) (slot << 3), /* tag = slot */
                      AP_SGLIST,    io->pSGList + sg_indx, (u16) sg_cnt,
-                     AP_DEVICE,    0xc000,   /* force unit access (FUA) */
+                     AP_DEVICE,    0x4000,
+                     AP_DEVICE,    (io->Flags & XIO_DISABLE_HW_WRITE_CACHE) ?
+                                   0x8000 : 0, /* force unit access */
                      AP_WRITE,     1,
                      AP_END);

trunk/src/os2ahci/atapi.c

@@ -75 +75 @@
   /* translate read command to SCSI/ATAPI READ12 command.
    * READ12 seems to be the most supported READ variant - according to MMC,
-   * and its enough even for BluRay.
+   * and it's enough even for BluRay.
    */
   memset(&cdb, 0x00, sizeof(cdb));
@@ -167 +167 @@
                AP_SGLIST, pt->pSGList, pt->cSGList,
                AP_WRITE, !(pt->Flags & PT_DIRECTION_IN),
-               /* TODO: do we have to clear DMA_TO_HOST bit for
-                * write, mode select etc. commands?
-                */
-               AP_FEATURES,  ATAPI_FEAT_DMA | ATAPI_FEAT_DMA_TO_HOST,
+               AP_FEATURES, ATAPI_FEAT_DMA,
+               AP_FEATURES, (pt->Flags & PT_DIRECTION_IN) ? ATAPI_FEAT_DMA_TO_HOST : 0,
                AP_END);
 
@@ -224 +222 @@
     iorb_seterr(iorb, IOERR_CMD_SGLIST_BAD);
 
-  } else {
+  } else if (rc < 0) {
     /* we failed to get info about an error -> return
      * non specific device error
@@ -242 +240 @@
   ADD_WORKSPACE _far *aws = add_workspace(iorb);
   ATAPI_SENSE_DATA *psd = (ATAPI_SENSE_DATA *) aws->buf;
+
+  ddphex(psd, sizeof(psd), "sense buffer:\n");
 
   /* map sense data to some IOERR_ value */

trunk/src/os2ahci/ctxhook.c

@@ -191 +191 @@
             if (req_sense(problem_iorb, 0) == 0) {
               /* execute request sense on slot #0 before anything else comes along */
+              ADD_StartTimerMS(&aws->timer, 5000, (PFN) timeout_callback, iorb, 0);
+              aws->cmd_slot = 0;
               ai->ports[p].reg_cmds = 1;
               writel(port_mmio + PORT_CMD_ISSUE, 1);

trunk/src/os2ahci/init.asm

@@ -34 +34 @@
                 db      "OS2AHCI$"              ; name of character device
                 dq      0                       ; 8 reserved bytes
-                dd      DEV_ADAPTER_DD + DEV_INITCOMPLETE + 20h ; ADD flags
+                dd      DEV_IOCTL2 + DEV_ADAPTER_DD + DEV_INITCOMPLETE + 20h ; ADD flags
                 dw      0
 DEVHDR          ENDS

trunk/src/os2ahci/os2ahci.c

@@ -107 +107 @@
     break;
 
+  case CMDShutdown:
+    rc = exit_drv(((RPSAVERESTORE _far *) req)->FuncCode);
+    break;
+
   default:
     rc = STDON | STATUS_ERR_UNKCMD;
@@ -284 +288 @@
   cprintf(exit_msg);
   return(STDON | ERROR_I24_QUIET_INIT_FAIL);
+}
+
+/******************************************************************************
+ * Device driver exit handler. This handler is called when OS/2 shuts down and
+ * flushes the write caches of all attached devices.
+ *
+ * NOTE: Errors are ignored because there's no way we could stop the shutdown
+ *       or do something about the error, unless retrying endlessly is
+ *       considered an option.
+ */
+USHORT exit_drv(int func)
+{
+  int a;
+  int p;
+  int d;
+
+  dprintf("exit_drv(%d) called\n", func);
+
+  if (func == 0) {
+    /* we're only interested in the second phase of the shutdown */
+    return(STDON);
+  }
+
+  for (a = 0; a < ad_info_cnt; a++) {
+    AD_INFO *ai = ad_infos + a;
+
+    for (p = 0; p <= ai->port_max; p++) {
+      for (d = 0; d <= ai->ports[p].dev_max; d++) {
+        if (ai->ports[p].devs[d].present) {
+          ahci_flush_cache(ai, p, d);
+        }
+      }
+    }
+  }
+
+  return(STDON);
 }
 
@@ -1035 +1075 @@
 
 /******************************************************************************
+ * 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.
+ */
+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);
+}
+
+/******************************************************************************
  * small_code_ - this dummy func resolves the undefined reference linker
  * error that occurrs when linking WATCOM objects with DDK's link.exe

trunk/src/os2ahci/os2ahci.def

@@ -1 +1 @@
 library os2ahci
-Description '$@#thi.guten (www.thiguten.de):1.00.20101227#@OS/2 AHCI Adapter Device Driver'
+Description '$@#thi.guten (www.thiguten.de):1.00.20110107#@OS/2 AHCI Adapter Device Driver'
 protmode
 

trunk/src/os2ahci/os2ahci.h

@@ -368 +368 @@
 /* os2ahci.c */
 extern USHORT  init_drv               (RPINITIN _far *req);
+extern USHORT  exit_drv               (int func);
 extern void _cdecl _far _loadds add_entry    (IORBH _far *iorb);
 extern void    trigger_engine         (void);
@@ -385 +386 @@
 extern void    iorb_done              (IORBH _far *iorb);
 extern void    iorb_requeue           (IORBH _far *iorb);
+extern void _cdecl _far timeout_callback    (ULONG timer_handle, ULONG p1, ULONG p2);
 
 /* ahci.c */
@@ -410 +412 @@
 extern int     ahci_exec_polled_cmd         (AD_INFO *ai, int p, int d,
                                              int timeout, int cmd, ...);
-extern int     ahci_set_dev_idle            (AD_INFO *ai, int p, int idle);
+extern int     ahci_set_dev_idle            (AD_INFO *ai, int p, int d, int idle);
+extern int     ahci_flush_cache             (AD_INFO *ai, int p, int d);
 
 extern int     ahci_intr                    (u16 irq);