Changeset 125 for trunk/src/os2ahci/ioctl.c

Timestamp:

Oct 8, 2011, 10:28:48 PM (14 years ago)

Author:

cjm

Message:

Version 1.21

---

• Triggered by reports of performance loss with NCQ
• New command line flag "/F" to force using write buffers even when upstream I/O requested non-buffered I/O; the primary purpose of this flag is to debug the NCQ performance drop but the flag may or may not remain.

File:

• trunk/src/os2ahci/ioctl.c (modified) (8 diffs)

trunk/src/os2ahci/ioctl.c

@@ -27 +27 @@
 #include "os2ahci.h"
 #include "atapi.h"
+#include "ata.h"
 #include "ioctl.h"
 
@@ -42 +43 @@
  * we'll need to define a union to cover all IORB types in question.
  */
+#define CMDLEN sizeof(((OS2AHCI_PASSTHROUGH *) 0)->cmd)
 typedef struct {
   IORB_ADAPTER_PASSTHRU iorb;                  /* IORB */
   SCSI_STATUS_BLOCK   ssb;                     /* SCSI status block */
+  UCHAR               cmd[CMDLEN];             /* copy of passthrough cmd
+                                                * (need to fill ATA return
+                                                * registers at interrupt time)
+                                                */
   UCHAR               sense[ATAPI_SENSE_LEN];  /* sense buffer */
   SCATGATENTRY        sg_lst[AHCI_MAX_SG / 2]; /* scatter/gather list */
@@ -53 +59 @@
 /* -------------------------- function prototypes -------------------------- */
 
-static LIN lin(void _far *p);
+static USHORT do_smart  (BYTE unit, BYTE sub_func, BYTE parm, void _far *buf);
+static int    map_unit  (BYTE unit, USHORT _far *a, USHORT _far *p,
+                         USHORT _far *d);
+static LIN    lin       (void _far *p);
 
 IORBH _far * _far _cdecl ioctl_wakeup(IORBH _far *iorb);
@@ -171 +180 @@
     return(STDON | STERR | ERROR_I24_BAD_UNIT);
   }
-  if ((req->buflen + 4095) / 4096 + 1 > AHCI_MAX_SG / 2) {
+  if ((req->buflen + 4095) / 4096 + 1 > AHCI_MAX_SG / 2 ||
+      req->cmdlen < 6 || req->cmdlen > sizeof(req->cmd)) {
     return(STDON | STERR | ERROR_I24_INVALID_PARAMETER);
   }
@@ -206 +216 @@
   ic->iorb.ppSGLIST         = virt_to_phys(ic->sg_lst);
 
+  memcpy(ic->cmd, req->cmd.cdb, sizeof(ic->cmd));
   ic->iorb.ControllerCmdLen = req->cmdlen;
-  ic->iorb.pControllerCmd   = req->cmd.cdb;
+  ic->iorb.pControllerCmd   = ic->cmd;
   ic->iorb.Flags            = (req->flags & PT_WRITE) ? 0 : PT_DIRECTION_IN;
 
@@ -236 +247 @@
   spin_lock(drv_lock);
   while (!(ic->iorb.iorbh.Status & IORB_DONE)) {
+
 #   ifndef OS2AHCI_SMP
       drv_lock = 0;
 #   endif
+
     DevHelp_ProcBlock((ULONG) (void _far *) &ic->iorb.iorbh, 30000, 1);
     spin_lock(drv_lock);
@@ -306 +319 @@
              min(ic->ssb.ReqSenseLen, req->sense_len));
     }
+
+  } else if ((req->flags & PT_ATAPI) == 0) {
+    /* Copy ATA cmd back to IOCTL request (ATA commands are effectively
+     * registers which are sometimes used to indicate return conditions,
+     * e.g. when requesting the smart status)
+     */
+    memcpy(&req->cmd.ata, ic->cmd, sizeof(req->cmd.ata));
   }
 
@@ -316 +336 @@
 
 /******************************************************************************
+ * Generic disk IOCTL handler; this IOCTL category has originally been defined
+ * in IBM1S506; the code has been more or less copied from DANIS506.
+ *
+ * NOTE: Only a subset of the IOCTL calls are implemented in OS2AHCI at this
+ *       point, basically those calls required to get HDMON working.
+ */
+USHORT ioctl_gen_dsk(RP_GENIOCTL _far *ioctl)
+{
+  DSKSP_CommandParameters _far *cp = (DSKSP_CommandParameters _far *) ioctl->ParmPacket;
+  UnitInformationData _far *ui;
+  OS2AHCI_PASSTHROUGH pt;
+  RP_GENIOCTL tmp_ioctl;
+  USHORT size = 0;
+  USHORT ret;
+  USHORT a;
+  USHORT p;
+  USHORT d;
+  UCHAR unit;
+  
+  /* verify addressability of parm buffer (DSKSP_CommandParameters) */
+  if (DevHelp_VerifyAccess((SEL) ((ULONG) cp >> 16),
+                            sizeof(DSKSP_CommandParameters),
+                            (USHORT) (ULONG) cp,
+                            VERIFY_READONLY) != 0) {
+    return(STDON | STERR | 0x05);
+  }
+  unit = cp->byPhysicalUnit;
+
+  /* verify addressability of data buffer (depends on function code) */
+  switch (ioctl->Function) {
+
+  case DSKSP_GEN_GET_COUNTERS:
+    size = sizeof(DeviceCountersData);
+    break;
+
+  case DSKSP_GET_UNIT_INFORMATION:
+    size = sizeof(UnitInformationData);
+    break;
+
+  case DSKSP_GET_INQUIRY_DATA:
+    size = ATA_ID_WORDS * sizeof(u16);
+    break;
+  }
+
+  if (size > 0) {
+    if (DevHelp_VerifyAccess((SEL) ((ULONG) ioctl->DataPacket >> 16),
+                             size, (USHORT) (ULONG) ioctl->DataPacket,
+                             VERIFY_READWRITE) != 0) {
+      return(STDON | STERR | 0x05);
+    }
+  }
+
+  if (map_unit(unit, &a, &p, &d)) {
+    return(STDON | STERR | ERROR_I24_BAD_UNIT);
+  }
+
+  /* execute generic disk request */
+  switch (ioctl->Function) {
+
+  case DSKSP_GEN_GET_COUNTERS:
+    /* Not supported, yet; we would need dynamically allocated device
+     * structures to cope with the memory requirements of the corresponding
+     * statistics buffer. For the time being, we'll return an empty buffer.
+     */
+    memset(ioctl->DataPacket, 0x00, sizeof(DeviceCountersData));
+    ret = STDON;
+    break;
+
+  case DSKSP_GET_UNIT_INFORMATION:
+    /* get unit information; things like port addresses won't fit so we don't
+     * even bother returning those.
+     */
+    ui = (UnitInformationData _far *) ioctl->DataPacket;
+    memset(ui, 0x00, sizeof(*ui));
+
+    ui->wRevisionNumber = 1;
+    ui->wIRQ            = ad_infos[a].irq;
+    ui->wFlags          = UIF_VALID;
+    ui->wFlags         |= UIF_RUNNING_BMDMA;
+    ui->wFlags         |= (unit & 0x0001) ? UIF_SLAVE : 0;
+    ui->wFlags         |= (ad_infos[a].ports[p].devs[d].atapi) ? UIF_ATAPI : 0;
+    ui->wFlags         |= UIF_SATA;
+
+    ret = STDON;
+    break;
+
+  case DSKSP_GET_INQUIRY_DATA:
+    /* return ATA ID buffer */
+    memset(&tmp_ioctl, 0x00, sizeof(tmp_ioctl));
+    tmp_ioctl.Category   = OS2AHCI_IOCTL_CATEGORY;
+    tmp_ioctl.Function   = OS2AHCI_IOCTL_PASSTHROUGH;
+    tmp_ioctl.ParmPacket = (void _far *) &pt;
+
+    memset(&pt, 0x00, sizeof(pt));
+    pt.adapter          = a;
+    pt.port             = p;
+    pt.device           = d;
+    pt.cmdlen           = sizeof(pt.cmd.ata);
+    pt.cmd.ata.cmd      = (ad_infos[a].ports[p].devs[d].atapi) ?
+                           ATA_CMD_ID_ATAPI : ATA_CMD_ID_ATA;
+    pt.buflen           = size;
+    pt.buf              = lin(ioctl->DataPacket);
+
+    ret = gen_ioctl(&tmp_ioctl);
+    break;
+
+  default:
+    ret = STDON | STATUS_ERR_UNKCMD;
+    break;
+  }
+
+  return(ret);
+}
+
+/******************************************************************************
+ * SMART IOCTL handler; this IOCTL category has originally been defined in
+ * IBM1S506; the code has been more or less copied from DANIS506.
+ */
+USHORT ioctl_smart(RP_GENIOCTL _far *ioctl)
+{
+  DSKSP_CommandParameters _far *cp = (DSKSP_CommandParameters _far *) ioctl->ParmPacket;
+  USHORT size = 0;
+  USHORT ret;
+  UCHAR unit;
+  UCHAR parm;
+
+  /* verify addressability of parm buffer (DSKSP_CommandParameters) */
+  if (DevHelp_VerifyAccess((SEL) ((ULONG) cp >> 16),
+                            sizeof(DSKSP_CommandParameters),
+                            (USHORT) (ULONG) cp,
+                            VERIFY_READONLY) != 0) {
+    return(STDON | STERR | 0x05);
+  }
+  unit = cp->byPhysicalUnit;
+
+  /* verify addressability of data buffer (depends on SMART function) */
+  switch (ioctl->Function) {
+
+  case DSKSP_SMART_GETSTATUS:
+    size = sizeof(ULONG);
+    break;
+
+  case DSKSP_SMART_GET_ATTRIBUTES:
+  case DSKSP_SMART_GET_THRESHOLDS:
+  case DSKSP_SMART_GET_LOG:
+    size = 512;
+    break;
+  }
+
+  if (size > 0) {
+    if (DevHelp_VerifyAccess((SEL) ((ULONG) ioctl->DataPacket >> 16),
+                             size, (USHORT) (ULONG) ioctl->DataPacket,
+                             VERIFY_READWRITE) != 0) {
+      return(STDON | STERR | 0x05);
+    }
+    parm = ioctl->DataPacket[0];
+  }
+
+  /* execute SMART request */
+  switch (ioctl->Function) {
+
+  case DSKSP_SMART_ONOFF:
+    ret = do_smart(unit,
+                   (BYTE) ((parm) ? ATA_SMART_ENABLE
+                                  : ATA_SMART_DISABLE),
+                   0, NULL);
+    break;
+
+  case DSKSP_SMART_AUTOSAVE_ONOFF:
+    ret = do_smart(unit, ATA_SMART_AUTOSAVE,
+                   (BYTE) ((parm) ? (BYTE) 0xf1 : 0),
+                   NULL);
+    break;
+
+  case DSKSP_SMART_AUTO_OFFLINE:
+    ret = do_smart(unit, ATA_SMART_AUTO_OFFLINE, parm, NULL);
+    break;
+
+  case DSKSP_SMART_EXEC_OFFLINE:
+    ret = do_smart(unit, ATA_SMART_IMMEDIATE_OFFLINE, parm, NULL);
+    break;
+
+  case DSKSP_SMART_SAVE:
+    ret = do_smart(unit, ATA_SMART_SAVE, 0, NULL);
+    break;
+
+  case DSKSP_SMART_GETSTATUS:
+    ret = do_smart(unit, ATA_SMART_STATUS, 0, ioctl->DataPacket);
+    break;
+
+  case DSKSP_SMART_GET_ATTRIBUTES:
+    ret = do_smart(unit, ATA_SMART_READ_VALUES, 0, ioctl->DataPacket);
+    break;
+
+  case DSKSP_SMART_GET_THRESHOLDS:
+    ret = do_smart(unit, ATA_SMART_READ_THRESHOLDS, 0, ioctl->DataPacket);
+    break;
+
+  case DSKSP_SMART_GET_LOG:
+    ret = do_smart(unit, ATA_SMART_READ_LOG, parm, ioctl->DataPacket);
+    break;
+
+  default:
+    ret = STDON | STATUS_ERR_UNKCMD;
+  }
+
+  return(ret);
+}
+
+/******************************************************************************
+ * Perform SMART request. The code has been more or less copied from DANIS506.
+ */
+static USHORT do_smart(BYTE unit, BYTE sub_func, BYTE parm, void _far *buf)
+{
+  OS2AHCI_PASSTHROUGH pt;
+  RP_GENIOCTL ioctl;
+  USHORT ret;
+  USHORT a;
+  USHORT p;
+  USHORT d;
+
+  if (map_unit(unit, &a, &p, &d)) {
+    return(STDON | STERR | ERROR_I24_BAD_UNIT);
+  }
+
+  /* Perform SMART request using the existing OS2AHCI_IOTCL_PASSTHROUGH IOCTL
+   * interface which already takes care of allocating an IORB, s/g lists, etc.
+   */
+  memset(&ioctl, 0x00, sizeof(ioctl));
+  ioctl.Category   = OS2AHCI_IOCTL_CATEGORY;
+  ioctl.Function   = OS2AHCI_IOCTL_PASSTHROUGH;
+  ioctl.ParmPacket = (void _far *) &pt;
+
+  memset(&pt, 0x00, sizeof(pt));
+  pt.adapter          = a;
+  pt.port             = p;
+  pt.device           = d;
+  pt.cmdlen           = sizeof(pt.cmd.ata);
+  pt.cmd.ata.features = sub_func;
+  pt.cmd.ata.count    = parm;
+  pt.cmd.ata.lba_l    = (0xc24fL << 8) | parm;
+  pt.cmd.ata.cmd      = ATA_CMD_SMART;
+
+  if (buf != NULL && sub_func != ATA_SMART_STATUS) {
+    pt.buflen         = 512;
+    pt.buf            = lin(buf);
+  }
+
+  if (((ret = gen_ioctl(&ioctl)) & STERR) == 0 &&
+      sub_func == ATA_SMART_STATUS) {
+
+    /* ATA_SMART_STATUS doesn't transfer anything but instead relies on the
+     * returned D2H FIS, mapped to the ATA CMD, to have a certain value
+     * (0xf42c); the IOCTL result is expected to be returned as a ULONG in
+     * the data buffer.
+     */
+    if (((pt.cmd.ata.lba_l >> 8) & 0xffff) == 0xf42c) {
+      *((ULONG _far *) buf) = 1;
+    } else {
+      *((ULONG _far *) buf) = 0;
+    }
+  }
+
+  return(ret);
+}
+
+/******************************************************************************
+ * Map DSKSP unit number to corresponding adapter/port/device number. Units
+ * are identified by an 8-bit adapter/device number with the lowest bit
+ * selecting between master (0) and slave (1). This number is mapped to our
+ * ATA/ATAPI units sequentially.
+ */
+static int map_unit(BYTE unit, USHORT _far *a, USHORT _far *p, USHORT _far *d)
+{
+  USHORT _a;
+  USHORT _p;
+  USHORT _d;
+
+  /* map unit to adapter/port/device */
+  for (_a = 0; _a < ad_info_cnt; _a++) {
+    AD_INFO *ai = ad_infos + _a;
+
+    for (_p = 0; _p <= ai->port_max; _p++) {
+      P_INFO *pi = ai->ports + _p;
+
+      for (_d = 0; _d <= pi->dev_max; _d++) {
+        if (pi->devs[_d].present) {
+          if (--unit == 0) {
+            /* found the device */
+            *a = _a;
+            *p = _p;
+            *d = _d;
+            return(0);
+          }
+        }
+      }
+    }
+  }
+
+  /* unit not found */
+  return(-1);
+}
+
+/******************************************************************************
  * Get linear address for specified virtual address.
  */