- Slightly reworked include files (less messy, more straightforward).
- Moved DOS ASPI functionality to msdos/dosaspi.c.
- Got rid using PROFILE to get SCSI info from wine.conf.
- Read scsi info from /proc/scsi/scsi.
- Added setting of a reasonable timeout when opening a SCSI device (5
minutes, defined in winescsi.h).
- ExecScsiCommand now ALWAYS posts, even on error (which is the correct
behavior).
diff --git a/dlls/winaspi/.cvsignore b/dlls/winaspi/.cvsignore
index 227d839..0fb2dc0 100644
--- a/dlls/winaspi/.cvsignore
+++ b/dlls/winaspi/.cvsignore
@@ -1,3 +1,4 @@
-Makefile
*.spec.c
*.spec.glue.s
+Makefile
+libwnaspi32.so.1.0
diff --git a/dlls/winaspi/Makefile.in b/dlls/winaspi/Makefile.in
index c4c9c6a..0039878 100644
--- a/dlls/winaspi/Makefile.in
+++ b/dlls/winaspi/Makefile.in
@@ -1,17 +1,18 @@
-DEFS = @DLLFLAGS@ -D__WINE__
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
-MODULE = winaspi
+MODULE = wnaspi32
+SOVERSION = 1.0
+ALTNAMES = winaspi
-SPEC_SRCS = winaspi.spec
+SPEC_SRCS = wnaspi32.spec winaspi.spec
C_SRCS = \
- winaspi16.c
+ aspi.c \
+ winaspi16.c \
+ winaspi32.c
-all: $(MODULE).o
-
-@MAKE_RULES@
+@MAKE_DLL_RULES@
### Dependencies:
diff --git a/dlls/winaspi/aspi.c b/dlls/winaspi/aspi.c
new file mode 100644
index 0000000..dae42fa
--- /dev/null
+++ b/dlls/winaspi/aspi.c
@@ -0,0 +1,347 @@
+/**************************************************************************
+ASPI routines
+(C) 2000 David Elliott <dfe@netnitco.net>
+Licensed under the WINE (X11) license
+*/
+
+/* These routines are to be called from either WNASPI32 or WINASPI */
+
+/* FIXME:
+ * - Registry format is stupid for now.. fix that later
+ * - No way to override automatic /proc detection, maybe provide an
+ * HKEY_LOCAL_MACHINE\Software\Wine\Wine\Scsi regkey
+ * - Somewhat debating an #ifdef linux... technically all this code will
+ * run on another UNIX.. it will fail nicely.
+ * - Please add support for mapping multiple channels on host adapters to
+ * aspi controllers, e-mail me if you need help.
+ */
+
+/*
+Registry format is currently:
+HKEY_DYN_DATA
+ WineScsi
+ (default)=number of host adapters
+ hHHcCCtTTdDD=linux device name
+*/
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "debugtools.h"
+#include "winreg.h"
+#include "winerror.h"
+#include "winescsi.h"
+#include "file.h"
+
+DEFAULT_DEBUG_CHANNEL(aspi);
+
+/* Internal function prototypes */
+static void
+SCSI_GetProcinfo();
+
+/* Exported functions */
+void
+SCSI_Init()
+{
+ /* For now we just call SCSI_GetProcinfo */
+ SCSI_GetProcinfo();
+}
+
+int
+ASPI_GetNumControllers()
+{
+ HKEY hkeyScsi;
+ DWORD type = REG_DWORD;
+ DWORD num_ha = 0;
+ DWORD cbData = sizeof(num_ha);
+
+ if( RegOpenKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
+ {
+ ERR("Could not open HEKY_DYN_DATA\\%s\n",KEYNAME_SCSI);
+ return 0;
+ }
+
+ if( RegQueryValueExA(hkeyScsi, NULL, NULL, &type, (LPBYTE)&num_ha, &cbData ) != ERROR_SUCCESS )
+ {
+ ERR("Could not query value HEKY_DYN_DATA\\%s\n",KEYNAME_SCSI);
+ num_ha=0;
+ }
+ RegCloseKey(hkeyScsi);
+ FIXME("Please fix to return number of controllers\n");
+ TRACE("Returning %ld host adapters\n", num_ha );
+ return num_ha;
+}
+
+BOOL
+SCSI_GetDeviceName( int h, int c, int t, int d, LPSTR devstr, LPDWORD lpcbData )
+{
+
+ char idstr[20];
+ HKEY hkeyScsi;
+ DWORD type;
+
+ if( RegOpenKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
+ {
+ ERR("Could not open HEKY_DYN_DATA\\%s\n",KEYNAME_SCSI);
+ return FALSE;
+ }
+
+
+ sprintf(idstr, "h%02dc%02dt%02dd%02d", h, c, t, d);
+
+ if( RegQueryValueExA(hkeyScsi, idstr, NULL, &type, devstr, lpcbData) != ERROR_SUCCESS )
+ {
+ WARN("Could not query value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, idstr);
+ RegCloseKey(hkeyScsi);
+ return FALSE;
+ }
+ RegCloseKey(hkeyScsi);
+
+ TRACE("scsi %s: Device name: %s\n",idstr,devstr);
+ return TRUE;
+}
+
+/* SCSI_GetHCforController
+ * RETURNS
+ * HIWORD: Host Adapter
+ * LOWORD: Channel
+ */
+DWORD
+ASPI_GetHCforController( int controller )
+{
+ DWORD retval;
+ FIXME("Please fix to map each channel of each host adapter to the proper ASPI controller number!\n");
+ retval = (controller << 16);
+ return retval;
+};
+
+int
+SCSI_OpenDevice( int h, int c, int t, int d )
+{
+ char devstr[20];
+ DWORD cbData = 20;
+ int fd = -1;
+
+ if(!SCSI_GetDeviceName( h, c, t, d, devstr, &cbData ))
+ {
+ WARN("Could not get device name for h%02dc%02dt%02dd%02d\n", h, c, t, d);
+ return -1;
+ }
+
+ TRACE("Opening device %s mode O_RDWR\n",devstr);
+ fd = open(devstr, O_RDWR);
+
+ if( fd < 0 )
+ {
+ TRACE("open failed\n");
+ FILE_SetDosError(); /* SetLastError() to errno */
+ TRACE("GetLastError: %ld\n", GetLastError());
+ }
+ return fd;
+}
+
+int
+SCSI_LinuxSetTimeout( int fd, int timeout )
+{
+ int retval;
+ TRACE("Setting timeout to %d jiffies\n", timeout);
+ retval=ioctl(fd,SG_SET_TIMEOUT,&timeout);
+ if(retval)
+ {
+ WARN("Could not set timeout errno=%d!\n",errno);
+ }
+ return retval;
+
+}
+
+/* This function takes care of the write/read to the linux sg device.
+ * It returns TRUE or FALSE and uses FILE_SetDosError() to convert
+ * UNIX errno to Windows GetLastError(). The reason for that is that
+ * several programs will check that error and we might as well set
+ * it here. We also return the value of the read call in
+ * lpcbBytesReturned.
+ */
+BOOL /* NOTE: This function SHOULD BLOCK */
+SCSI_LinuxDeviceIo( int fd,
+ struct sg_header * lpInBuffer, DWORD cbInBuffer,
+ struct sg_header * lpOutBuffer, DWORD cbOutBuffer,
+ LPDWORD lpcbBytesReturned )
+{
+ DWORD dwBytes;
+ DWORD save_error;
+
+ TRACE("Writing to Liunx sg device\n");
+ dwBytes = write( fd, lpInBuffer, cbInBuffer );
+ if( dwBytes != cbInBuffer )
+ {
+ FILE_SetDosError();
+ save_error = GetLastError();
+ WARN("Not enough bytes written to scsi device. bytes=%ld .. %ld\n", cbInBuffer, dwBytes );
+ if( save_error == ERROR_NOT_ENOUGH_MEMORY )
+ MESSAGE("Your Linux kernel was not able to handle the amount of data sent to the scsi device. Try recompiling with a larger SG_BIG_BUFF value (kernel 2.0.x sg.h");
+ WARN("error= %ld\n", save_error );
+ *lpcbBytesReturned = 0;
+ return FALSE;
+ }
+
+ TRACE("Reading reply from Linux sg device\n");
+ *lpcbBytesReturned = read( fd, lpOutBuffer, cbOutBuffer );
+ if( *lpcbBytesReturned != cbOutBuffer )
+ {
+ FILE_SetDosError();
+ save_error = GetLastError();
+ WARN("Not enough bytes read from scsi device. bytes=%ld .. %ld\n", cbOutBuffer, *lpcbBytesReturned);
+ WARN("error= %ld\n", save_error );
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/* Internal functions */
+struct LinuxProcScsiDevice
+{
+ int host;
+ int channel;
+ int target;
+ int lun;
+ char vendor[9];
+ char model[17];
+ char rev[5];
+ char type[33];
+ int ansirev;
+};
+
+static int
+SCSI_getprocentry( FILE * procfile, struct LinuxProcScsiDevice * dev )
+{
+ int result;
+ result = fscanf( procfile,
+ "Host: scsi%d Channel: %d Id: %d Lun: %d\n",
+ &dev->host,
+ &dev->channel,
+ &dev->target,
+ &dev->lun );
+ if( result == EOF )
+ return EOF;
+ if( result != 4 )
+ return 0;
+ result = fscanf( procfile,
+ " Vendor: %8c Model: %16c Rev: %4c\n",
+ dev->vendor,
+ dev->model,
+ dev->rev );
+ if( result != 3 )
+ return 0;
+
+ result = fscanf( procfile,
+ " Type: %32c ANSI SCSI revision: %d\n",
+ dev->type,
+ &dev->ansirev );
+ if( result != 2 )
+ return 0;
+ /* Since we fscanf with %XXc instead of %s.. put a NULL at end */
+ dev->vendor[8] = 0;
+ dev->model[16] = 0;
+ dev->rev[4] = 0;
+ dev->type[32] = 0;
+
+ return 1;
+}
+
+static void
+SCSI_printprocentry( const struct LinuxProcScsiDevice * dev )
+{
+ TRACE( "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n",
+ dev->host,
+ dev->channel,
+ dev->target,
+ dev->lun );
+ TRACE( " Vendor: %s Model: %s Rev: %s\n",
+ dev->vendor,
+ dev->model,
+ dev->rev );
+ TRACE( " Type: %s ANSI SCSI revision: %02d\n",
+ dev->type,
+ dev->ansirev );
+}
+
+static void
+SCSI_GetProcinfo()
+/* I'll admit, this function is somewhat of a mess... it was originally
+ * designed to make some sort of linked list then I realized that
+ * HKEY_DYN_DATA would be a lot less messy
+ */
+{
+ FILE * procfile = NULL;
+
+ int result = 0;
+
+ struct LinuxProcScsiDevice dev;
+
+ char idstr[20];
+ char devstr[20];
+
+ int devnum=0;
+ int num_ha = 0;
+
+ HKEY hkeyScsi;
+ DWORD disposition;
+
+ procfile = fopen( "/proc/scsi/scsi", "r" );
+ if( !procfile )
+ {
+ ERR("Could not open /proc/scsi/scsi\n");
+ return;
+ }
+
+ result = fscanf( procfile, "Attached devices: \n");
+ if( result != 0 )
+ {
+ ERR("Incorrect /proc/scsi/scsi format");
+ return;
+ }
+
+ if( RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition ) != ERROR_SUCCESS )
+ {
+ ERR("Could not create HEKY_DYN_DATA\\%s\n",KEYNAME_SCSI);
+ return;
+ }
+
+ /* Read info for one device */
+ while( (result = SCSI_getprocentry(procfile, &dev)) > 0 )
+ {
+ /* Add to registry */
+
+ sprintf(idstr, "h%02dc%02dt%02dd%02d", dev.host, dev.channel, dev.target, dev.lun);
+ sprintf(devstr, "/dev/sg%c", 'a'+devnum);
+ if( RegSetValueExA(hkeyScsi, idstr, 0, REG_SZ, devstr, strlen(devstr)+1 ) != ERROR_SUCCESS )
+ {
+ ERR("Could not set value HEKY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, idstr);
+ }
+
+ /* Debug output */
+ SCSI_printprocentry( &dev );
+
+ /* FIXME: We *REALLY* need number of controllers.. not ha */
+ /* num of hostadapters is highest ha + 1 */
+ if( dev.host >= num_ha )
+ num_ha = dev.host+1;
+ devnum++;
+ } /* while(1) */
+ if( result != EOF )
+ {
+ ERR("Incorrect /proc/scsi/scsi format");
+ }
+ fclose( procfile );
+ if( RegSetValueExA(hkeyScsi, NULL, 0, REG_DWORD, (LPBYTE)&num_ha, sizeof(num_ha) ) != ERROR_SUCCESS )
+ {
+ ERR("Could not set value HEKY_DYN_DATA\\%s\n",KEYNAME_SCSI);
+ }
+ RegCloseKey(hkeyScsi);
+ return;
+}
+
diff --git a/dlls/winaspi/winaspi16.c b/dlls/winaspi/winaspi16.c
index 48f1d43..7bbae1f 100644
--- a/dlls/winaspi/winaspi16.c
+++ b/dlls/winaspi/winaspi16.c
@@ -12,7 +12,9 @@
#include "winbase.h"
#include "aspi.h"
+#include "winescsi.h"
#include "winaspi.h"
+#include "winescsi.h"
#include "options.h"
#include "heap.h"
#include "debugtools.h"
@@ -520,33 +522,3 @@
#endif
}
-
-void WINAPI ASPI_DOS_func(CONTEXT86 *context)
-{
- WORD *stack = CTX_SEG_OFF_TO_LIN(context, SS_reg(context), ESP_reg(context));
- DWORD ptrSRB = *(DWORD *)&stack[2];
-
- ASPI_SendASPICommand(ptrSRB, ASPI_DOS);
-
- /* simulate a normal RETF sequence as required by DPMI CallRMProcFar */
- EIP_reg(context) = *(stack++);
- CS_reg(context) = *(stack++);
- ESP_reg(context) += 2*sizeof(WORD);
-}
-
-
-/* returns the address of a real mode callback to ASPI_DOS_func() */
-void ASPI_DOS_HandleInt(CONTEXT86 *context)
-{
-#ifdef linux
- FARPROC16 *p = (FARPROC16 *)CTX_SEG_OFF_TO_LIN(context, DS_reg(context), EDX_reg(context));
- if ((CX_reg(context) == 4) || (CX_reg(context) == 5))
- {
- *p = DPMI_AllocInternalRMCB(ASPI_DOS_func);
- TRACE("allocated real mode proc %p\n", *p);
- AX_reg(context) = CX_reg(context);
- }
- else
-#endif
- SET_CFLAG(context);
-}
diff --git a/dlls/winaspi/winaspi32.c b/dlls/winaspi/winaspi32.c
new file mode 100644
index 0000000..f5243de
--- /dev/null
+++ b/dlls/winaspi/winaspi32.c
@@ -0,0 +1,486 @@
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <memory.h>
+#include <unistd.h>
+
+#include "winbase.h"
+#include "aspi.h"
+#include "wnaspi32.h"
+#include "winescsi.h"
+#include "options.h"
+#include "heap.h"
+#include "debugtools.h"
+#include "ldt.h"
+#include "callback.h"
+
+DEFAULT_DEBUG_CHANNEL(aspi);
+
+/* FIXME!
+ * 1) Residual byte length reporting not handled
+ * 2) Make this code re-entrant for multithreading
+ * -- Added CriticalSection to OpenDevices function
+ * 3) Only linux supported so far
+ * 4) Leaves sg devices open. This may or may not be okay. A better solution
+ * would be to close the file descriptors when the thread/process using
+ * them no longer needs them.
+ */
+
+#ifdef linux
+
+static ASPI_DEVICE_INFO *ASPI_open_devices = NULL;
+static CRITICAL_SECTION ASPI_CritSection;
+
+#endif /* defined(linux) */
+
+
+BOOL WINAPI WNASPI32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
+{
+#ifdef linux
+ static BOOL bInitDone=FALSE;
+#if 0
+ TRACE("0x%x 0x%1x %p\n", hInstDLL, fdwReason, fImpLoad);
+#endif
+ switch( fdwReason )
+ {
+ case DLL_PROCESS_ATTACH:
+ /* Create instance data */
+ if(!bInitDone)
+ {
+ /* Initialize global stuff just once */
+ InitializeCriticalSection(&ASPI_CritSection);
+ bInitDone=TRUE;
+ }
+ break;
+ case DLL_PROCESS_DETACH:
+ /* Destroy instance data */
+ break;
+ case DLL_THREAD_ATTACH:
+ case DLL_THREAD_DETACH:
+ break;
+ }
+ return TRUE;
+#else /* defined(linux) */
+ return TRUE;
+#endif /* defined(linux) */
+}
+
+#ifdef linux
+
+static int
+ASPI_OpenDevice(SRB_ExecSCSICmd *prb)
+{
+ int fd;
+ char idstr[20];
+ char device_str[50];
+ ASPI_DEVICE_INFO *curr;
+
+ /* search list of devices to see if we've opened it already.
+ * There is not an explicit open/close in ASPI land, so hopefully
+ * keeping a device open won't be a problem.
+ */
+
+ EnterCriticalSection(&ASPI_CritSection);
+ for (curr = ASPI_open_devices; curr; curr = curr->next) {
+ if (curr->hostId == prb->SRB_HaId &&
+ curr->target == prb->SRB_Target &&
+ curr->lun == prb->SRB_Lun) {
+ LeaveCriticalSection(&ASPI_CritSection);
+ return curr->fd;
+ }
+ }
+ LeaveCriticalSection(&ASPI_CritSection);
+
+ /* device wasn't cached, go ahead and open it */
+ sprintf(idstr, "scsi c%1dt%1dd%1d", prb->SRB_HaId, prb->SRB_Target, prb->SRB_Lun);
+
+ if (!PROFILE_GetWineIniString(idstr, "Device", "", device_str, sizeof(device_str))) {
+ TRACE("Trying to open unlisted scsi device %s\n", idstr);
+ return -1;
+ }
+
+ TRACE("Opening device %s=%s\n", idstr, device_str);
+
+ fd = open(device_str, O_RDWR);
+ if (fd == -1) {
+ int save_error = errno;
+#ifdef HAVE_STRERROR
+ ERR("Error opening device %s, error '%s'\n", device_str, strerror(save_error));
+#else
+ ERR("Error opening device %s, error %d\n", device_str, save_error);
+#endif
+ return -1;
+ }
+
+ /* device is now open */
+ curr = HeapAlloc( GetProcessHeap(), 0, sizeof(ASPI_DEVICE_INFO) );
+ curr->fd = fd;
+ curr->hostId = prb->SRB_HaId;
+ curr->target = prb->SRB_Target;
+ curr->lun = prb->SRB_Lun;
+
+ /* insert new record at beginning of open device list */
+ EnterCriticalSection(&ASPI_CritSection);
+ curr->next = ASPI_open_devices;
+ ASPI_open_devices = curr;
+ LeaveCriticalSection(&ASPI_CritSection);
+ return fd;
+}
+
+
+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[16];
+ 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)
+{
+
+ TRACE("SRB_Status: %x\n", prb->SRB_Status);
+ TRACE("SRB_HaStat: %x\n", prb->SRB_HaStat);
+ TRACE("SRB_TargStat: %x\n", prb->SRB_TargStat);
+ 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(SRB_ExecSCSICmd *lpPRB)
+{
+ struct sg_header *sg_hd, *sg_reply_hdr;
+ int status;
+ int in_len, out_len;
+ int error_code = 0;
+ int fd;
+
+ ASPI_DebugPrintCmd(lpPRB);
+
+ fd = ASPI_OpenDevice(lpPRB);
+ if (fd == -1) {
+ ERR("Failed: could not open device c%01dt%01dd%01d. Device permissions !?\n",
+ lpPRB->SRB_HaId,lpPRB->SRB_Target,lpPRB->SRB_Lun);
+ lpPRB->SRB_Status = SS_NO_DEVICE;
+ return SS_NO_DEVICE;
+ }
+
+ sg_hd = NULL;
+ sg_reply_hdr = NULL;
+
+ lpPRB->SRB_Status = SS_PENDING;
+
+ if (!lpPRB->SRB_CDBLen) {
+ WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
+ lpPRB->SRB_Status = SS_ERR;
+ return SS_ERR;
+ }
+
+ /* build up sg_header + scsi cmd */
+ if (HOST_TO_TARGET(lpPRB)) {
+ /* send header, command, and then data */
+ in_len = SCSI_OFF + lpPRB->SRB_CDBLen + lpPRB->SRB_BufLen;
+ sg_hd = (struct sg_header *) HeapAlloc(GetProcessHeap(), 0, in_len);
+ memset(sg_hd, 0, SCSI_OFF);
+ memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
+ if (lpPRB->SRB_BufLen) {
+ memcpy(((BYTE *) sg_hd) + SCSI_OFF + lpPRB->SRB_CDBLen, lpPRB->SRB_BufPointer, lpPRB->SRB_BufLen);
+ }
+ }
+ else {
+ /* send header and command - no data */
+ in_len = SCSI_OFF + lpPRB->SRB_CDBLen;
+ sg_hd = (struct sg_header *) HeapAlloc(GetProcessHeap(), 0, in_len);
+ memset(sg_hd, 0, SCSI_OFF);
+ memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
+ }
+
+ if (TARGET_TO_HOST(lpPRB)) {
+ out_len = SCSI_OFF + lpPRB->SRB_BufLen;
+ sg_reply_hdr = (struct sg_header *) HeapAlloc(GetProcessHeap(), 0, out_len);
+ memset(sg_reply_hdr, 0, SCSI_OFF);
+ sg_hd->reply_len = out_len;
+ }
+ else {
+ out_len = SCSI_OFF;
+ sg_reply_hdr = (struct sg_header *) HeapAlloc(GetProcessHeap(), 0, out_len);
+ memset(sg_reply_hdr, 0, SCSI_OFF);
+ sg_hd->reply_len = out_len;
+ }
+
+ status = write(fd, sg_hd, in_len);
+ if (status < 0 || status != in_len) {
+ int save_error = errno;
+
+ WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status);
+ if (status < 0) {
+ if (save_error == ENOMEM) {
+ MESSAGE("ASPI: Linux generic scsi driver\n You probably need to re-compile your kernel with a larger SG_BIG_BUFF value (sg.h)\n Suggest 130560\n");
+ }
+#ifdef HAVE_STRERROR
+ WARN("error:= '%s'\n", strerror(save_error));
+#else
+ WARN("error:= %d\n", save_error);
+#endif
+ }
+ goto error_exit;
+ }
+
+ status = read(fd, sg_reply_hdr, out_len);
+ if (status < 0 || status != out_len) {
+ WARN("not enough bytes read from scsi device%d\n", status);
+ goto error_exit;
+ }
+
+ if (sg_reply_hdr->result != 0) {
+ error_code = sg_reply_hdr->result;
+ WARN("reply header error (%d)\n", sg_reply_hdr->result);
+ goto error_exit;
+ }
+
+ if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) {
+ memcpy(lpPRB->SRB_BufPointer, sg_reply_hdr + 1, lpPRB->SRB_BufLen);
+ }
+
+ /* copy in sense buffer to amount that is available in client */
+ if (lpPRB->SRB_SenseLen) {
+ int sense_len = lpPRB->SRB_SenseLen;
+ if (lpPRB->SRB_SenseLen > 16)
+ sense_len = 16;
+
+ /* CDB is fixed in WNASPI32 */
+ memcpy(&lpPRB->CDBByte[16], &sg_reply_hdr->sense_buffer[0], sense_len);
+
+ TRACE("CDB is %d bytes long\n", lpPRB->SRB_CDBLen );
+ ASPI_PrintSenseArea(lpPRB);
+ }
+
+ lpPRB->SRB_Status = SS_COMP;
+ lpPRB->SRB_HaStat = HASTAT_OK;
+ lpPRB->SRB_TargStat = sg_reply_hdr->target_status << 1;
+
+ /* FIXME: Should this be != 0 maybe? */
+ if( lpPRB->SRB_TargStat == 2 )
+ lpPRB->SRB_Status = SS_ERR;
+
+ ASPI_DebugPrintResult(lpPRB);
+ /* now do posting */
+
+ if (lpPRB->SRB_PostProc) {
+ if (ASPI_POSTING(lpPRB)) {
+ TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
+ (*lpPRB->SRB_PostProc)(lpPRB);
+ }
+ else
+ if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY) {
+ TRACE("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc);
+ SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
+ }
+ }
+ HeapFree(GetProcessHeap(), 0, sg_reply_hdr);
+ HeapFree(GetProcessHeap(), 0, sg_hd);
+ return SS_PENDING;
+ /* In real WNASPI32 stuff really is always pending because ASPI does things
+ in the background, but we are not doing that (yet) */
+
+error_exit:
+ if (error_code == EBUSY) {
+ lpPRB->SRB_Status = SS_ASPI_IS_BUSY;
+ TRACE("Device busy\n");
+ }
+ else {
+ WARN("Failed\n");
+ lpPRB->SRB_Status = SS_ERR;
+ }
+
+ /* I'm not sure exactly error codes work here
+ * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
+ */
+ WARN("error_exit\n");
+ HeapFree(GetProcessHeap(), 0, sg_reply_hdr);
+ HeapFree(GetProcessHeap(), 0, sg_hd);
+ return lpPRB->SRB_Status;
+}
+
+#endif /* defined(linux) */
+
+
+/*******************************************************************
+ * GetASPI32SupportInfo32 [WNASPI32.0]
+ *
+ * Checks if the ASPI subsystem is initialized correctly.
+ *
+ * RETURNS
+ * HIWORD: 0.
+ * HIBYTE of LOWORD: status (SS_COMP or SS_FAILED_INIT)
+ * LOBYTE of LOWORD: # of host adapters.
+ */
+DWORD WINAPI GetASPI32SupportInfo()
+{
+ return ((SS_COMP << 8) | 1); /* FIXME: get # of host adapters installed */
+}
+
+
+/***********************************************************************
+ * SendASPI32Command32 (WNASPI32.1)
+ */
+DWORD __cdecl SendASPI32Command(LPSRB lpSRB)
+{
+#ifdef linux
+ switch (lpSRB->common.SRB_Cmd) {
+ case SC_HA_INQUIRY:
+ lpSRB->inquiry.SRB_Status = SS_COMP; /* completed successfully */
+ lpSRB->inquiry.HA_Count = 1; /* not always */
+ lpSRB->inquiry.HA_SCSI_ID = 7; /* not always ID 7 */
+ strcat(lpSRB->inquiry.HA_ManagerId, "ASPI for WIN32"); /* max 15 chars, don't change */
+ strcat(lpSRB->inquiry.HA_Identifier, "Wine host"); /* FIXME: return host adapter name */
+ memset(lpSRB->inquiry.HA_Unique, 0, 16); /* default HA_Unique content */
+ lpSRB->inquiry.HA_Unique[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
+ FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB->inquiry.SRB_HaId);
+ return SS_COMP;
+ case SC_GET_DEV_TYPE: {
+ /* FIXME: We should return SS_NO_DEVICE if the device is not configured */
+ /* FIXME: We should return SS_INVALID_HA if HostAdapter!=0 */
+ SRB tmpsrb;
+ char inqbuf[200];
+
+ memset(&tmpsrb,0,sizeof(tmpsrb));
+
+ tmpsrb.cmd.SRB_Cmd = SC_EXEC_SCSI_CMD;
+#define X(x) tmpsrb.cmd.SRB_##x = lpSRB->devtype.SRB_##x
+ X(Status);X(HaId);X(Flags);X(Target);X(Lun);
+#undef X
+ tmpsrb.cmd.SRB_BufLen = sizeof(inqbuf);
+ tmpsrb.cmd.SRB_Flags = 8;/*target->host data. FIXME: anything more?*/
+ tmpsrb.cmd.SRB_BufPointer = inqbuf;
+ tmpsrb.cmd.CDBByte[0] = 0x12; /* INQUIRY */
+ tmpsrb.cmd.CDBByte[4] = sizeof(inqbuf);
+ tmpsrb.cmd.SRB_CDBLen = 6;
+ ASPI_ExecScsiCmd(&tmpsrb.cmd);
+#define X(x) lpSRB->devtype.SRB_##x = tmpsrb.cmd.SRB_##x
+ X(Status);
+#undef X
+ lpSRB->devtype.SRB_DeviceType = inqbuf[0]&0x1f;
+ TRACE("returning devicetype %d for target %d\n",inqbuf[0]&0x1f,tmpsrb.cmd.SRB_Target);
+ break;
+ }
+ case SC_EXEC_SCSI_CMD:
+ return ASPI_ExecScsiCmd(&lpSRB->cmd);
+ break;
+ case SC_ABORT_SRB:
+ FIXME("Not implemented SC_ABORT_SRB\n");
+ break;
+ case SC_RESET_DEV:
+ FIXME("Not implemented SC_RESET_DEV\n");
+ break;
+#ifdef SC_GET_DISK_INFO
+ case SC_GET_DISK_INFO:
+ /* NT Doesn't implement this either.. so don't feel bad */
+ WARN("Not implemented SC_GET_DISK_INFO\n");
+ break;
+#endif
+ default:
+ WARN("Unknown command %d\n", lpSRB->common.SRB_Cmd);
+ }
+ return SS_INVALID_SRB;
+#else
+ return SS_INVALID_SRB;
+#endif
+}
+
+
+/***********************************************************************
+ * GetASPI32DLLVersion32 (WNASPI32.3)
+ */
+
+DWORD WINAPI GetASPI32DLLVersion()
+{
+#ifdef linux
+ return (DWORD)1;
+#else
+ return (DWORD)0;
+#endif
+}
+
diff --git a/dlls/winaspi/winescsi.h b/dlls/winaspi/winescsi.h
new file mode 100644
index 0000000..f2fa449
--- /dev/null
+++ b/dlls/winaspi/winescsi.h
@@ -0,0 +1,101 @@
+#ifndef __WINESCSI_H__
+#define __WINESCSI_H__
+
+#ifdef linux
+/* Copy of info from 2.2.x kernel */
+#define SG_MAX_SENSE 16 /* too little, unlikely to change in 2.2.x */
+
+struct sg_header
+{
+ int pack_len; /* [o] reply_len (ie useless), ignored as input */
+ int reply_len; /* [i] max length of expected reply (inc. sg_header) */
+ int pack_id; /* [io] id number of packet (use ints >= 0) */
+ int result; /* [o] 0==ok, else (+ve) Unix errno (best ignored) */
+ unsigned int twelve_byte:1;
+ /* [i] Force 12 byte command length for group 6 & 7 commands */
+ unsigned int target_status:5; /* [o] scsi status from target */
+ unsigned int host_status:8; /* [o] host status (see "DID" codes) */
+ unsigned int driver_status:8; /* [o] driver status+suggestion */
+ unsigned int other_flags:10; /* unused */
+ unsigned char sense_buffer[SG_MAX_SENSE]; /* [o] Output in 3 cases:
+ when target_status is CHECK_CONDITION or
+ when target_status is COMMAND_TERMINATED or
+ when (driver_status & DRIVER_SENSE) is true. */
+}; /* This structure is 36 bytes long on i386 */
+
+#define SCSI_OFF sizeof(struct sg_header)
+
+#define SG_SET_TIMEOUT 0x2201
+#define SG_GET_TIMEOUT 0x2202
+#define SCSI_DEFAULT_TIMEOUT 6000*5 /* 5 minutes */
+#endif
+
+
+/* RegKey used for SCSI info under HKEY_DYN_DATA */
+#define KEYNAME_SCSI "WineScsi"
+
+/* Function prototypes from dlls/wnaspi32/aspi.c */
+void
+SCSI_Init();
+
+int
+ASPI_GetNumControllers();
+
+int
+SCSI_OpenDevice( int h, int c, int t, int d );
+
+int
+SCSI_LinuxSetTimeout( int fd, int timeout );
+
+BOOL
+SCSI_LinuxDeviceIo( int fd,
+ struct sg_header * lpvInBuffer, DWORD cbInBuffer,
+ struct sg_header * lpvOutBuffer, DWORD cbOutBuffer,
+ LPDWORD lpcbBytesReturned );
+
+BOOL
+SCSI_GetDeviceName(int h, int c, int t, int d, LPSTR devstr, LPDWORD lpcbData);
+
+DWORD
+ASPI_GetHCforController( int controller );
+
+/*** This is where we throw some miscellaneous crap ***/
+
+#define ASPI_POSTING(prb) (prb->SRB_Flags & 0x1)
+
+/* WNASPI32/WINASPI defs */
+#define HOST_TO_TARGET(prb) (((prb->SRB_Flags>>3) & 0x3) == 0x2)
+#define TARGET_TO_HOST(prb) (((prb->SRB_Flags>>3) & 0x3) == 0x1)
+#define NO_DATA_TRANSFERED(prb) (((prb->SRB_Flags>>3) & 0x3) == 0x3)
+
+
+#define INQUIRY_VENDOR 8
+
+#define MUSTEK_SCSI_AREA_AND_WINDOWS 0x04
+#define MUSTEK_SCSI_READ_SCANNED_DATA 0x08
+#define MUSTEK_SCSI_GET_IMAGE_STATUS 0x0f
+#define MUSTEK_SCSI_ADF_AND_BACKTRACE 0x10
+#define MUSTEK_SCSI_CCD_DISTANCE 0x11
+#define MUSTEK_SCSI_START_STOP 0x1b
+
+
+#define INQURIY_CMDLEN 6
+#define INQURIY_REPLY_LEN 96
+#define INQUIRY_VENDOR 8
+
+#define SENSE_BUFFER(prb) (&prb->CDBByte[prb->SRB_CDBLen])
+
+/* Just a container for seeing what devices are open */
+struct ASPI_DEVICE_INFO {
+ struct ASPI_DEVICE_INFO * next;
+ int fd;
+ int hostId;
+ int target;
+ int lun;
+};
+
+typedef struct ASPI_DEVICE_INFO ASPI_DEVICE_INFO;
+
+/*** End Miscellaneous crap ***/
+
+#endif /* #ifndef __WINESCSI_H */
diff --git a/dlls/winaspi/wnaspi32.spec b/dlls/winaspi/wnaspi32.spec
new file mode 100644
index 0000000..043584b
--- /dev/null
+++ b/dlls/winaspi/wnaspi32.spec
@@ -0,0 +1,8 @@
+name wnaspi32
+type win32
+init WNASPI32_LibMain
+
+1 stdcall GetASPI32SupportInfo() GetASPI32SupportInfo
+2 cdecl SendASPI32Command(ptr) SendASPI32Command
+4 stdcall GetASPI32DLLVersion() GetASPI32DLLVersion
+7 stub OrdinalOnlyExport
