Changeset 8 for trunk/src/ahci.c

Timestamp:

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

Author:

markus

Message:

latest changes by Christian

File:

• trunk/src/ahci.c (modified) (23 diffs)

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