Changeset 987 for trunk/src

Timestamp:

Sep 20, 1999, 12:21:58 PM (26 years ago)

Author:

phaller

Message:

Add: WinASPI32 support via ASPIROUT$-device driver

Location:

trunk/src/wnaspi32

Files:

• makefile (modified) (4 diffs)
• odinaspi.cpp (added)
• odinaspi.h (added)
• srbos2.h (added)
• winaspi32.cpp (modified) (6 diffs)

trunk/src/wnaspi32/makefile

@@ -1 @@
-# $Id: makefile,v 1.1 1999-09-15 11:25:04 phaller Exp $
+# $Id: makefile,v 1.2 1999-09-20 10:18:58 phaller Exp $
 
 #
@@ -21 +21 @@
 TARGET = wnaspi32
 
-OBJS =  winaspi32.obj initterm.obj
+OBJS =  odinaspi.obj winaspi32.obj initterm.obj
 
 all: $(TARGET).dll $(TARGET).lib
@@ -30 +30 @@
               $(PDWIN32_LIB)/pmwinx.lib $(PDWIN32_LIB)/kernel32.lib \
               $(PDWIN32_LIB)/odincrt.lib OS2386.LIB $(RTLLIB_O) \
-              $(PDWIN32_LIB)/ole32.lib $(PDWIN32_LIB)/msvfw32.lib
+              $(PDWIN32_LIB)/advapi32.lib
         $(CP) $@ $(PDWIN32_BIN)
 
@@ -40 +40 @@
 
 initterm.obj:  initterm.cpp
-ainaspi32.obj: wnaspi32.cpp
-
+ainaspi32.obj: wnaspi32.cpp odinaspi.h srbos2.h
+odinaspi.obj:  odinaspi.cpp odinaspi.h srbos2.h
 clean:
         $(RM) *.obj *.lib *.dll *~ *.map *.pch

trunk/src/wnaspi32/winaspi32.cpp

@@ -1 @@
-#include <odin.h>
-
+#include <os2win.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -9 +8 @@
 // #include <unistd.h>
 
-#include "winbase.h"
 #include "aspi.h"
 #include "wnaspi32.h"
+#include <winreg.h>
 #include "options.h"
-#include "heap.h"
 #include "debugtools.h"
-#include "ldt.h"
+
+#include "srbos2.h"
+#include "odinaspi.h"
 //#include "callback.h"
 
@@ -326 +326 @@
 #endif
 
+// OS/2 ODIN implemetation code
+#ifdef _ODIN_H_
+
+static void
+ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
+{
+  BYTE  cmd;
+  int   i;
+  BYTE *cdb;
+
+  switch (prb->CDBByte[0]) {
+  case CMD_INQUIRY:
+    TRACE("{\n");
+    TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
+    TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
+    TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
+    TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
+    TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
+    TRACE("}\n");
+    break;
+  case CMD_SCAN_SCAN:
+    TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
+    break;
+  }
+
+  TRACE("Host Adapter: %d\n", prb->SRB_HaId);
+  TRACE("Flags: %d\n", prb->SRB_Flags);
+  if (TARGET_TO_HOST(prb)) {
+    TRACE("\tData transfer: Target to host. Length checked.\n");
+  }
+  else if (HOST_TO_TARGET(prb)) {
+    TRACE("\tData transfer: Host to target. Length checked.\n");
+  }
+  else if (NO_DATA_TRANSFERED(prb)) {
+    TRACE("\tData transfer: none\n");
+  }
+  else {
+    WARN("\tTransfer by scsi cmd. Length not checked.\n");
+  }
+
+  TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
+  TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
+  TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
+  TRACE("Target: %d\n", prb->SRB_Target);
+  TRACE("Lun: %d\n", prb->SRB_Lun);
+  TRACE("BufLen: %ld\n", prb->SRB_BufLen);
+  TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
+  TRACE("BufPtr: %p\n", prb->SRB_BufPointer);
+  TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
+  TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
+  cdb = &prb->CDBByte[0];
+  cmd = prb->CDBByte[0];
+  if (TRACE_ON(aspi))
+  {
+      DPRINTF("CDB buffer[");
+      for (i = 0; i < prb->SRB_CDBLen; i++) {
+          if (i != 0) DPRINTF(",");
+          DPRINTF("%02x", *cdb++);
+      }
+      DPRINTF("]\n");
+  }
+}
+
+static void
+ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
+{
+  int   i;
+  BYTE *cdb;
+
+  if (TRACE_ON(aspi))
+  {
+      cdb = &prb->CDBByte[0];
+      DPRINTF("SenseArea[");
+      for (i = 0; i < prb->SRB_SenseLen; i++) {
+          if (i) DPRINTF(",");
+          DPRINTF("%02x", *cdb++);
+      }
+      DPRINTF("]\n");
+  }
+}
+
+static void
+ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
+{
+
+  switch (prb->CDBByte[0]) {
+  case CMD_INQUIRY:
+    TRACE("Vendor: '%s'\n", prb->SRB_BufPointer + INQUIRY_VENDOR);
+    break;
+  case CMD_TEST_UNIT_READY:
+    ASPI_PrintSenseArea(prb);
+    break;
+  }
+}
+
+
+static WORD
+ASPI_ExecScsiCmd( PODINASPIDATA pData,
+                  SRB_ExecSCSICmd *lpPRB)
+{
+  int   status;
+  int   error_code = 0;
+  SRBOS2 SRBlock;
+  LONG rc;
+
+  ASPI_DebugPrintCmd(lpPRB);
+
+  lpPRB->SRB_Status = SS_PENDING;
+
+  if (!lpPRB->SRB_CDBLen)
+  {
+      WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
+      lpPRB->SRB_Status = SS_ERR;
+      return SS_ERR;
+  }
+
+  if(MaxCDBStatus<lpPRB->SRB_CDBLen)
+  {
+    WARN("Failed: lpPRB->SRB_CDBLen > 64.\n");
+    lpPRB->SRB_Status = SS_ERR;
+    return SS_ERR;
+  }
+
+  if(lpPRB->SRB_BufLen>65536)    // Check Max 64k!!
+  {
+    WARN("Failed: lpPRB->SRB_BufLen > 65536.\n");
+    lpPRB->SRB_Status = SS_BUFFER_TO_BIG;
+    return SS_BUFFER_TO_BIG;
+  }
+
+  // copy up to LUN SRBOS2 has no WORD for padding like in WINE
+  memcpy( &SRBlock,
+          lpPRB,
+          6* sizeof(BYTE) + sizeof(DWORD));
+  SRBlock.flags |= SRB_Post;
+  SRBlock.u.cmd.sense_len = 32;                    // length of sense buffer
+  SRBlock.u.cmd.data_ptr  = NULL;                  // pointer to data buffer
+  SRBlock.u.cmd.link_ptr  = NULL;                  // pointer to next SRB
+  SRBlock.u.cmd.cdb_len   = lpPRB->SRB_CDBLen;     // SCSI command length
+  memcpy( &SRBlock.u.cmd.cdb_st[0],
+          &lpPRB->CDBByte[0],
+          lpPRB->SRB_CDBLen);
+
+  if (HOST_TO_TARGET(lpPRB))
+  {
+    // Write: Copy all Data to Communication Buffer
+    if (lpPRB->SRB_BufLen)
+    {
+      memcpy( pData->pvBuffer,
+              lpPRB->SRB_BufPointer,
+              lpPRB->SRB_BufLen);
+    }
+  }
+
+  rc = lSendSRBlock( pData->hfDriver,
+                     &SRBlock,
+                     &SRBlock);
+
+  if(!rc)
+  {
+    if( fWaitPost(pData->hevPost))
+    {
+      if (TARGET_TO_HOST(lpPRB))
+      {
+        // Was Read : Copy all Data from Communication Buffer
+        if (lpPRB->SRB_BufLen)
+        {
+          memcpy( lpPRB->SRB_BufPointer,
+                  pData->pvBuffer,
+                  lpPRB->SRB_BufLen);
+        }
+      }
+
+      if (lpPRB->SRB_SenseLen)
+      {
+        int sense_len = lpPRB->SRB_SenseLen;
+        if (lpPRB->SRB_SenseLen > 32)
+          sense_len = 32;
+        memcpy( SENSE_BUFFER(lpPRB),
+                &SRBlock.u.cmd.cdb_st[SRBlock.u.cmd.cdb_len],
+                sense_len);
+      }
+
+      /* now do posting */
+
+      if (lpPRB->SRB_PostProc)
+      {
+        if (ASPI_POSTING(lpPRB))
+        {
+          TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
+          (*lpPRB->SRB_PostProc)();
+        }
+        else
+        if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY)
+        {
+          TRACE("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc);
+          SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
+        }
+      }
+    }
+    lpPRB->SRB_Status = SRBlock.status;
+    lpPRB->SRB_HaStat = SRBlock.u.cmd.ha_status;
+    lpPRB->SRB_TargStat = SRBlock.u.cmd.target_status;
+  }
+  else
+    lpPRB->SRB_Status = SS_ERR;
+
+
+  ASPI_DebugPrintResult(lpPRB);
+
+  return lpPRB->SRB_Status;
+
+}
+#endif
 
 /*******************************************************************
@@ -337 +551 @@
  *    LOBYTE of LOWORD: # of host adapters.
  */
+#ifdef _ODIN_H_
 DWORD WINAPI GetASPI32SupportInfo()
 {
-    return ((SS_COMP << 8) | 1); /* FIXME: get # of host adapters installed */
-}
-
+  LONG rc;
+  ODINASPIDATA aspi;
+  ULONG hmtxDriver;
+  BYTE bNumDrv;
+  HKEY hkeyDrvInfo;
+  DWORD dwType;
+  DWORD dwData;
+  DWORD dwSize;
+  SRBOS2 SRBlock;
+  ULONG ulParam, ulReturn;
+  BYTE brc;
+
+  bNumDrv = 0;
+
+  if( fGainDrvAccess( FALSE, &hmtxDriver) ) // Do nonblocking call for info
+  {
+    brc = bOpenASPI(&aspi);
+    if(SS_COMP==brc  )
+    {
+      SRBlock.cmd=SRB_Inquiry;                      // host adapter inquiry
+      SRBlock.ha_num=0;                             // host adapter number
+      SRBlock.flags=0;                              // no flags set
+
+      rc = lSendSRBlock( aspi.hfDriver,
+                         &SRBlock,
+                         &SRBlock);
+
+      if (!rc)
+      {
+        bNumDrv = SRBlock.u.inq.num_ha;
+
+        rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
+                           "Software\\ODIN\\ASPIROUT",
+                           &hkeyDrvInfo);
+        if(ERROR_SUCCESS==rc)
+        {
+          dwData = bNumDrv;
+          RegSetValueExA( hkeyDrvInfo,
+                          "NumAdapers",
+                          NULL,
+                          REG_DWORD,
+                          (LPBYTE)&dwData,
+                          sizeof(DWORD));
+          RegCloseKey( hkeyDrvInfo);
+        }
+      }
+
+      fCloseASPI(&aspi);
+    }
+    else
+      brc = SS_FAILED_INIT;
+
+    fReleaseDrvAccess( hmtxDriver);
+  }
+  else
+  {
+    // Driver is used by other process/thread
+    // so try get value form registry
+
+    brc = SS_FAILED_INIT;
+    rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
+                       "Software\\ODIN\\ASPIROUT",
+                       &hkeyDrvInfo);
+
+    if(ERROR_SUCCESS!=rc)
+      return ((SS_FAILED_INIT << 8) | bNumDrv);
+
+    dwSize = sizeof(DWORD);
+    rc = RegQueryValueExA( hkeyDrvInfo,
+                           "NumAdapers",
+                           NULL,
+                           &dwType,
+                           (BYTE*)&dwData,
+                           &dwSize);
+
+    RegCloseKey( hkeyDrvInfo);
+
+    if( (ERROR_SUCCESS==rc) &&
+        (REG_DWORD != dwType) )
+    {
+      bNumDrv = 0xFF & dwData;
+      brc = SS_COMP;
+    }
+  }
+
+  return ((brc << 8) | bNumDrv); /* FIXME: get # of host adapters installed */
+}
+#else
+DWORD WINAPI GetASPI32SupportInfo()
+{
+  return ((SS_COMP << 8) | 1); /* FIXME: get # of host adapters installed */
+}
+#endif
 
 /***********************************************************************
@@ -374 +679 @@
   return SS_INVALID_SRB;
 #else
-  return SS_INVALID_SRB;
+  #ifdef _ODIN_H_
+
+    SRBOS2 SRBlock;
+    DWORD dwRC;
+    ULONG ulParam, ulReturn;
+    BYTE  bRC;
+    ODINASPIDATA aspi;
+    ULONG hmtxDriver;
+    LONG rc;
+
+    if(NULL==lpSRB)
+      return SS_INVALID_SRB;  // Not sure what to return here but that is an error
+
+    // test first for a valid command
+    if( (SC_HA_INQUIRY!=lpSRB->common.SRB_Cmd) &&
+        (SC_GET_DEV_TYPE!=lpSRB->common.SRB_Cmd) &&
+        (SC_EXEC_SCSI_CMD!=lpSRB->common.SRB_Cmd) &&
+        (SC_ABORT_SRB!=lpSRB->common.SRB_Cmd) &&
+        (SC_RESET_DEV!=lpSRB->common.SRB_Cmd) )
+      return SS_INVALID_SRB; // shoud be invalid command
+
+    dwRC = SS_ERR;
+
+    if( fGainDrvAccess( TRUE, &hmtxDriver) ) // Block if a SRB is pending
+    {
+      bRC = bOpenASPI( &aspi);
+      if(SS_COMP==bRC)
+      {
+        switch (lpSRB->common.SRB_Cmd)
+        {
+          case SC_HA_INQUIRY:
+            SRBlock.cmd=SRB_Inquiry;                      // host adapter inquiry
+            SRBlock.ha_num=lpSRB->inquiry.SRB_HaId;           // host adapter number
+            SRBlock.flags=0;                              // no flags set
+
+            rc = lSendSRBlock( aspi.hfDriver,
+                               &SRBlock,
+                               &SRBlock);
+            if (!rc)
+            {
+              memcpy( lpSRB,
+                      &SRBlock,
+                      sizeof(SRB_HaInquiry) );
+              dwRC = SRBlock.status;
+            }
+            break;
+          case SC_GET_DEV_TYPE:
+            memcpy( &SRBlock,
+                    lpSRB,
+                    sizeof(SRB_GDEVBlock));
+            SRBlock.flags = 0;
+
+            rc = lSendSRBlock( aspi.hfDriver,
+                               &SRBlock,
+                               &SRBlock);
+
+            if (!rc)
+            {
+              memcpy( lpSRB,
+                      &SRBlock,
+                      sizeof(SRB_GDEVBlock) );
+              lpSRB->devtype.SRB_Rsvd1 = 0x00;
+              dwRC = SRBlock.status;
+            }
+
+            break;
+          case SC_EXEC_SCSI_CMD:
+            dwRC = ASPI_ExecScsiCmd( &aspi,
+                                     &lpSRB->cmd);
+            break;
+          case SC_ABORT_SRB:
+            dwRC = SS_INVALID_SRB; // We don't do async ASPI so no way to abort
+            break;
+          case SC_RESET_DEV:
+            memset( &SRBlock,
+                    0,
+                    sizeof(SRBOS2) );
+            SRBlock.cmd = lpSRB->reset.SRB_Cmd;       /* ASPI command code = SC_RESET_DEV */
+            SRBlock.status = lpSRB->reset.SRB_Status; /* ASPI command status byte */
+            SRBlock.ha_num = lpSRB->reset.SRB_HaId;   /* ASPI host adapter number */
+            SRBlock.flags =  SRB_Post;
+            SRBlock.u.res.target = lpSRB->reset.SRB_Target; /* Target's SCSI ID */
+            SRBlock.u.res.lun    = lpSRB->reset.SRB_Lun;    /* Target's LUN number */
+
+            rc = lSendSRBlock( aspi.hfDriver,
+                               &SRBlock,
+                               &SRBlock);
+
+            if (!rc)
+            {
+              fWaitPost( aspi.hevPost );
+              lpSRB->reset.SRB_Status   = SRBlock.status;
+              lpSRB->reset.SRB_Flags    = SRBlock.flags;
+              lpSRB->reset.SRB_Hdr_Rsvd = 0;
+              memset( lpSRB->reset.SRB_Rsvd1,
+                      0,
+                      12 );
+              lpSRB->reset.SRB_HaStat   = SRBlock.u.res.ha_status;     /* Host Adapter Status */
+              lpSRB->reset.SRB_TargStat = SRBlock.u.res.target_status; /* Target Status */
+              lpSRB->reset.SRB_PostProc = NULL;                  /* Post routine */
+              lpSRB->reset.SRB_Rsvd2    = NULL;                  /* Reserved */
+              memset( lpSRB->reset.SRB_Rsvd3,
+                      0,
+                      32);            /* Reserved */
+              dwRC = SRBlock.status;
+            }
+            break;
+          } // end switch (lpSRB->common.SRB_Cmd)
+
+        fCloseASPI(&aspi);
+      }
+      else
+      {
+        dwRC = bRC;
+      }
+
+      fReleaseDrvAccess( hmtxDriver);
+    }
+    else
+    {
+      dwRC = SS_NO_ASPI;
+    }
+
+    return dwRC;
+
+  #else
+    return SS_INVALID_SRB;
+  #endif
 #endif
 }
@@ -386 +818 @@
 {
 #ifdef linux
-        return (DWORD)1;
+  return (DWORD)1;
 #else
-        return (DWORD)0;
+  #ifdef _ODIN_H_
+    return (DWORD)1;
+  #else
+    return (DWORD)0;
+  #endif
 #endif
 }