2 * Copyright 1997 Bruce Milner
3 * Copyright 1998 Andreas Mohr
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include <sys/types.h>
39 #include "wine/debug.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(aspi
);
44 * 1) Residual byte length reporting not handled
45 * 2) Make this code re-entrant for multithreading
46 * -- Added CriticalSection to OpenDevices function
47 * 3) Only linux supported so far
48 * 4) Leaves sg devices open. This may or may not be okay. A better solution
49 * would be to close the file descriptors when the thread/process using
50 * them no longer needs them.
55 static ASPI_DEVICE_INFO
*ASPI_open_devices
= NULL
;
57 static CRITICAL_SECTION ASPI_CritSection
;
58 static CRITICAL_SECTION_DEBUG critsect_debug
=
60 0, 0, &ASPI_CritSection
,
61 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
62 0, 0, { (DWORD_PTR
)(__FILE__
": ASPI_CritSection") }
64 static CRITICAL_SECTION ASPI_CritSection
= { &critsect_debug
, -1, 0, 0, 0, 0 };
66 #endif /* defined(linux) */
69 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID fImpLoad
)
74 case DLL_PROCESS_ATTACH
:
75 DisableThreadLibraryCalls(hInstDLL
);
78 case DLL_PROCESS_DETACH
:
80 DeleteCriticalSection( &ASPI_CritSection
);
83 #endif /* defined(linux) */
91 ASPI_OpenDevice(SRB_ExecSCSICmd
*prb
)
95 ASPI_DEVICE_INFO
*curr
;
97 /* search list of devices to see if we've opened it already.
98 * There is not an explicit open/close in ASPI land, so hopefully
99 * keeping a device open won't be a problem.
102 EnterCriticalSection(&ASPI_CritSection
);
103 for (curr
= ASPI_open_devices
; curr
; curr
= curr
->next
) {
104 if (curr
->hostId
== prb
->SRB_HaId
&&
105 curr
->target
== prb
->SRB_Target
&&
106 curr
->lun
== prb
->SRB_Lun
) {
107 LeaveCriticalSection(&ASPI_CritSection
);
111 LeaveCriticalSection(&ASPI_CritSection
);
113 if (prb
->SRB_HaId
>= ASPI_GetNumControllers())
116 hc
= ASPI_GetHCforController( prb
->SRB_HaId
);
117 fd
= SCSI_OpenDevice( HIWORD(hc
), LOWORD(hc
), prb
->SRB_Target
, prb
->SRB_Lun
);
122 /* device is now open */
123 /* FIXME: Let users specify SCSI timeout in registry */
124 SCSI_LinuxSetTimeout( fd
, SCSI_DEFAULT_TIMEOUT
);
126 curr
= HeapAlloc( GetProcessHeap(), 0, sizeof(ASPI_DEVICE_INFO
) );
128 curr
->hostId
= prb
->SRB_HaId
;
129 curr
->target
= prb
->SRB_Target
;
130 curr
->lun
= prb
->SRB_Lun
;
132 /* insert new record at beginning of open device list */
133 EnterCriticalSection(&ASPI_CritSection
);
134 curr
->next
= ASPI_open_devices
;
135 ASPI_open_devices
= curr
;
136 LeaveCriticalSection(&ASPI_CritSection
);
142 ASPI_DebugPrintCmd(SRB_ExecSCSICmd
*prb
)
147 switch (prb
->CDBByte
[0]) {
149 TRACE("INQUIRY {\n");
150 TRACE("\tEVPD: %d\n", prb
->CDBByte
[1] & 1);
151 TRACE("\tLUN: %d\n", (prb
->CDBByte
[1] & 0xc) >> 1);
152 TRACE("\tPAGE CODE: %d\n", prb
->CDBByte
[2]);
153 TRACE("\tALLOCATION LENGTH: %d\n", prb
->CDBByte
[4]);
154 TRACE("\tCONTROL: %d\n", prb
->CDBByte
[5]);
158 TRACE("Transfer Length: %d\n", prb
->CDBByte
[4]);
162 TRACE("Host Adapter: %d\n", prb
->SRB_HaId
);
163 TRACE("Flags: %d\n", prb
->SRB_Flags
);
164 if (TARGET_TO_HOST(prb
)) {
165 TRACE("\tData transfer: Target to host. Length checked.\n");
167 else if (HOST_TO_TARGET(prb
)) {
168 TRACE("\tData transfer: Host to target. Length checked.\n");
170 else if (NO_DATA_TRANSFERRED(prb
)) {
171 TRACE("\tData transfer: none\n");
174 WARN("\tTransfer by scsi cmd. Length not checked.\n");
177 TRACE("\tResidual byte length reporting %s\n", prb
->SRB_Flags
& 0x4 ? "enabled" : "disabled");
178 TRACE("\tLinking %s\n", prb
->SRB_Flags
& 0x2 ? "enabled" : "disabled");
179 TRACE("\tPosting %s\n", prb
->SRB_Flags
& 0x1 ? "enabled" : "disabled");
180 TRACE("Target: %d\n", prb
->SRB_Target
);
181 TRACE("Lun: %d\n", prb
->SRB_Lun
);
182 TRACE("BufLen: %d\n", prb
->SRB_BufLen
);
183 TRACE("SenseLen: %d\n", prb
->SRB_SenseLen
);
184 TRACE("BufPtr: %p\n", prb
->SRB_BufPointer
);
185 TRACE("CDB Length: %d\n", prb
->SRB_CDBLen
);
186 TRACE("POST Proc: %p\n", prb
->SRB_PostProc
);
187 cdb
= &prb
->CDBByte
[0];
188 if (TRACE_ON(aspi
)) {
189 TRACE("CDB buffer[");
190 for (i
= 0; i
< prb
->SRB_CDBLen
; i
++) {
191 if (i
!= 0) TRACE(",");
192 TRACE("%02x", *cdb
++);
199 ASPI_PrintCDBArea(SRB_ExecSCSICmd
*prb
)
205 for (i
= 0; i
< prb
->SRB_CDBLen
; i
++) {
207 TRACE("%02x", prb
->CDBByte
[i
]);
214 ASPI_PrintSenseArea(SRB_ExecSCSICmd
*prb
)
217 BYTE
*rqbuf
= prb
->SenseArea
;
221 TRACE("Request Sense reports:\n");
222 if ((rqbuf
[0]&0x7f)!=0x70) {
223 TRACE("\tInvalid sense header: 0x%02x instead of 0x70\n", rqbuf
[0]&0x7f);
226 TRACE("\tCurrent command read filemark: %s\n",(rqbuf
[2]&0x80)?"yes":"no");
227 TRACE("\tEarly warning passed: %s\n",(rqbuf
[2]&0x40)?"yes":"no");
228 TRACE("\tIncorrect blocklength: %s\n",(rqbuf
[2]&0x20)?"yes":"no");
229 TRACE("\tSense Key: %d\n",rqbuf
[2]&0xf);
231 TRACE("\tResidual Length: %d\n",rqbuf
[3]*0x1000000+rqbuf
[4]*0x10000+rqbuf
[5]*0x100+rqbuf
[6]);
232 TRACE("\tAdditional Sense Length: %d\n",rqbuf
[7]);
233 TRACE("\tAdditional Sense Code: %d\n",rqbuf
[12]);
234 TRACE("\tAdditional Sense Code Qualifier: %d\n",rqbuf
[13]);
235 if (rqbuf
[15]&0x80) {
236 TRACE("\tIllegal Param is in %s\n",(rqbuf
[15]&0x40)?"the CDB":"the Data Out Phase");
238 TRACE("Pointer at %d, bit %d\n",rqbuf
[16]*256+rqbuf
[17],rqbuf
[15]&0x7);
242 for (i
= 0; i
< prb
->SRB_SenseLen
; i
++) {
244 TRACE("%02x", *rqbuf
++);
251 ASPI_DebugPrintResult(SRB_ExecSCSICmd
*prb
)
254 TRACE("SRB_Status: %x\n", prb
->SRB_Status
);
255 TRACE("SRB_HaStat: %x\n", prb
->SRB_HaStat
);
256 TRACE("SRB_TargStat: %x\n", prb
->SRB_TargStat
);
257 switch (prb
->CDBByte
[0]) {
259 TRACE("Vendor: '%s'\n", prb
->SRB_BufPointer
+ INQUIRY_VENDOR
);
261 case CMD_TEST_UNIT_READY
:
262 ASPI_PrintSenseArea(prb
);
267 /* Posting must be done in such a way that as soon as the SRB_Status is set
268 * we don't touch the SRB anymore because it could possibly be freed
269 * if the app is doing ASPI polling
272 WNASPI32_DoPosting( SRB_ExecSCSICmd
*lpPRB
, DWORD status
)
274 void (*SRB_PostProc
)(SRB_ExecSCSICmd
*) = lpPRB
->SRB_PostProc
;
275 BYTE SRB_Flags
= lpPRB
->SRB_Flags
;
276 if( status
== SS_PENDING
)
278 WARN("Tried posting SS_PENDING\n");
281 lpPRB
->SRB_Status
= status
;
282 /* lpPRB is NOT safe, it could be freed in another thread */
288 TRACE("Post Routine (%p) called\n", SRB_PostProc
);
289 /* Even though lpPRB could have been freed by
290 * the program.. that's unlikely if it planned
291 * to use it in the PostProc
293 (*SRB_PostProc
)(lpPRB
);
295 else if (SRB_Flags
& SRB_EVENT_NOTIFY
) {
296 TRACE("Setting event %p\n", SRB_PostProc
);
297 SetEvent(SRB_PostProc
);
304 ASPI_ExecScsiCmd(SRB_ExecSCSICmd
*lpPRB
)
306 struct sg_header
*sg_hd
, *sg_reply_hdr
;
310 int num_controllers
= 0;
315 num_controllers
= ASPI_GetNumControllers();
316 if (lpPRB
->SRB_HaId
>= num_controllers
) {
317 WARN("Failed: Wanted hostadapter with index %d, but we have only %d.\n",
318 lpPRB
->SRB_HaId
, num_controllers
320 return WNASPI32_DoPosting( lpPRB
, SS_INVALID_HA
);
322 fd
= ASPI_OpenDevice(lpPRB
);
324 return WNASPI32_DoPosting( lpPRB
, SS_NO_DEVICE
);
327 /* FIXME: hackmode */
328 #define MAKE_TARGET_TO_HOST(lpPRB) \
329 if (!TARGET_TO_HOST(lpPRB)) { \
330 WARN("program was not sending target_to_host for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags); \
331 lpPRB->SRB_Flags |= 0x08; \
333 #define MAKE_HOST_TO_TARGET(lpPRB) \
334 if (!HOST_TO_TARGET(lpPRB)) { \
335 WARN("program was not sending host_to_target for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags); \
336 lpPRB->SRB_Flags |= 0x10; \
338 switch (lpPRB
->CDBByte
[0]) {
339 case 0x12: /* INQUIRY */
340 case 0x5a: /* MODE_SENSE_10 */
341 case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
342 case 0xad: /* READ DVD STRUCTURE MMC-2 */
343 MAKE_TARGET_TO_HOST(lpPRB
)
345 case 0xa3: /* SEND KEY (DVD) MMC-2 */
346 MAKE_HOST_TO_TARGET(lpPRB
)
349 if ((((lpPRB
->SRB_Flags
& 0x18) == 0x00) ||
350 ((lpPRB
->SRB_Flags
& 0x18) == 0x18)
351 ) && lpPRB
->SRB_BufLen
353 FIXME("command 0x%02x, no data transfer specified, but buflen is %d!!!\n",lpPRB
->CDBByte
[0],lpPRB
->SRB_BufLen
);
357 ASPI_DebugPrintCmd(lpPRB
);
362 lpPRB
->SRB_Status
= SS_PENDING
;
364 if (!lpPRB
->SRB_CDBLen
) {
365 ERR("Failed: lpPRB->SRB_CDBLen = 0.\n");
366 return WNASPI32_DoPosting( lpPRB
, SS_INVALID_SRB
);
369 /* build up sg_header + scsi cmd */
370 if (HOST_TO_TARGET(lpPRB
)) {
371 /* send header, command, and then data */
372 in_len
= SCSI_OFF
+ lpPRB
->SRB_CDBLen
+ lpPRB
->SRB_BufLen
;
373 sg_hd
= HeapAlloc(GetProcessHeap(), 0, in_len
);
374 memset(sg_hd
, 0, SCSI_OFF
);
375 memcpy(sg_hd
+ 1, &lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
376 if (lpPRB
->SRB_BufLen
) {
377 memcpy(((BYTE
*) sg_hd
) + SCSI_OFF
+ lpPRB
->SRB_CDBLen
, lpPRB
->SRB_BufPointer
, lpPRB
->SRB_BufLen
);
381 /* send header and command - no data */
382 in_len
= SCSI_OFF
+ lpPRB
->SRB_CDBLen
;
383 sg_hd
= HeapAlloc(GetProcessHeap(), 0, in_len
);
384 memset(sg_hd
, 0, SCSI_OFF
);
385 memcpy(sg_hd
+ 1, &lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
388 if (TARGET_TO_HOST(lpPRB
)) {
389 out_len
= SCSI_OFF
+ lpPRB
->SRB_BufLen
;
390 sg_reply_hdr
= HeapAlloc(GetProcessHeap(), 0, out_len
);
391 memset(sg_reply_hdr
, 0, SCSI_OFF
);
392 sg_hd
->reply_len
= out_len
;
396 sg_reply_hdr
= HeapAlloc(GetProcessHeap(), 0, out_len
);
397 memset(sg_reply_hdr
, 0, SCSI_OFF
);
398 sg_hd
->reply_len
= out_len
;
401 SCSI_Fix_CMD_LEN(fd
, lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
403 if(!SCSI_LinuxDeviceIo( fd
,
405 sg_reply_hdr
, out_len
,
411 if (sg_reply_hdr
->result
!= 0) {
412 error_code
= sg_reply_hdr
->result
;
413 WARN("reply header error (%d)\n", sg_reply_hdr
->result
);
417 if (TARGET_TO_HOST(lpPRB
) && lpPRB
->SRB_BufLen
) {
418 memcpy(lpPRB
->SRB_BufPointer
, sg_reply_hdr
+ 1, lpPRB
->SRB_BufLen
);
421 /* copy in sense buffer to amount that is available in client */
422 if (lpPRB
->SRB_SenseLen
) {
423 int sense_len
= lpPRB
->SRB_SenseLen
;
424 if (lpPRB
->SRB_SenseLen
> 16)
427 /* CDB is fixed in WNASPI32 */
428 memcpy(lpPRB
->SenseArea
, &sg_reply_hdr
->sense_buffer
[0], sense_len
);
430 ASPI_PrintCDBArea(lpPRB
);
431 ASPI_PrintSenseArea(lpPRB
);
434 SRB_Status
= SS_COMP
;
435 lpPRB
->SRB_HaStat
= HASTAT_OK
;
436 lpPRB
->SRB_TargStat
= sg_reply_hdr
->target_status
<< 1;
438 HeapFree(GetProcessHeap(), 0, sg_reply_hdr
);
439 HeapFree(GetProcessHeap(), 0, sg_hd
);
441 /* FIXME: Should this be != 0 maybe? */
442 if( lpPRB
->SRB_TargStat
== 2 ) {
444 switch (lpPRB
->CDBByte
[0]) {
445 case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
446 case 0xa3: /* SEND KEY (DVD) MMC-2 */
447 SRB_Status
= SS_COMP
;
448 lpPRB
->SRB_TargStat
= 0;
449 FIXME("Program wants to do DVD Region switching, but fails (non compliant DVD drive). Ignoring....\n");
454 ASPI_DebugPrintResult(lpPRB
);
456 ret
= WNASPI32_DoPosting( lpPRB
, SRB_Status
);
458 switch (lpPRB
->CDBByte
[0]) {
460 if (SRB_Status
== SS_COMP
)
461 return SS_COMP
; /* some junk expects ss_comp here. */
467 /* In real WNASPI32 stuff really is always pending because ASPI does things
468 in the background, but we are not doing that (yet) */
474 if (error_code
== EBUSY
) {
475 WNASPI32_DoPosting( lpPRB
, SS_ASPI_IS_BUSY
);
476 TRACE("Device busy\n");
480 /* I'm not sure exactly error codes work here
481 * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
483 WARN("error_exit\n");
484 HeapFree(GetProcessHeap(), 0, sg_reply_hdr
);
485 HeapFree(GetProcessHeap(), 0, sg_hd
);
486 WNASPI32_DoPosting( lpPRB
, SRB_Status
);
490 #endif /* defined(linux) */
493 /*******************************************************************
494 * GetASPI32SupportInfo [WNASPI32.1]
496 * Checks if the ASPI subsystem is initialized correctly.
500 * HIBYTE of LOWORD: status (SS_COMP or SS_FAILED_INIT)
501 * LOBYTE of LOWORD: # of host adapters.
503 DWORD __cdecl
GetASPI32SupportInfo(void)
505 DWORD controllers
= ASPI_GetNumControllers();
508 return SS_NO_ADAPTERS
<< 8;
509 return (SS_COMP
<< 8) | controllers
;
512 /***********************************************************************
513 * SendASPI32Command (WNASPI32.2)
515 DWORD __cdecl
SendASPI32Command(LPSRB lpSRB
)
518 static const char szId
[] = "ASPI for WIN32";
519 static const char szWh
[] = "Wine host";
520 switch (lpSRB
->common
.SRB_Cmd
) {
522 lpSRB
->inquiry
.SRB_Status
= SS_COMP
; /* completed successfully */
523 lpSRB
->inquiry
.HA_Count
= ASPI_GetNumControllers();
524 lpSRB
->inquiry
.HA_SCSI_ID
= 7; /* not always ID 7 */
525 memcpy(lpSRB
->inquiry
.HA_ManagerId
, szId
, sizeof szId
); /* max 15 chars, don't change */
526 memcpy(lpSRB
->inquiry
.HA_Identifier
, szWh
, sizeof szWh
); /* FIXME: return host adapter name */
527 memset(lpSRB
->inquiry
.HA_Unique
, 0, 16); /* default HA_Unique content */
528 lpSRB
->inquiry
.HA_Unique
[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
529 lpSRB
->inquiry
.HA_Unique
[3] = 0x08; /* Maximum number of SCSI targets */
530 FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB
->inquiry
.SRB_HaId
);
533 case SC_GET_DEV_TYPE
: {
534 /* FIXME: We should return SS_NO_DEVICE if the device is not configured */
535 /* FIXME: We should return SS_INVALID_HA if HostAdapter!=0 */
537 unsigned char inqbuf
[200];
540 memset(&tmpsrb
,0,sizeof(tmpsrb
));
543 tmpsrb
.common
= lpSRB
->common
;
545 tmpsrb
.cmd
.SRB_Flags
|= 8; /* target to host */
546 tmpsrb
.cmd
.SRB_Cmd
= SC_EXEC_SCSI_CMD
;
547 tmpsrb
.cmd
.SRB_Target
= lpSRB
->devtype
.SRB_Target
;
548 tmpsrb
.cmd
.SRB_Lun
= lpSRB
->devtype
.SRB_Lun
;
549 tmpsrb
.cmd
.SRB_BufLen
= sizeof(inqbuf
);
550 tmpsrb
.cmd
.SRB_BufPointer
= inqbuf
;
551 tmpsrb
.cmd
.CDBByte
[0] = 0x12; /* INQUIRY */
552 /* FIXME: handle lun */
553 tmpsrb
.cmd
.CDBByte
[4] = sizeof(inqbuf
);
554 tmpsrb
.cmd
.SRB_CDBLen
= 6;
556 ret
= ASPI_ExecScsiCmd(&tmpsrb
.cmd
);
558 lpSRB
->devtype
.SRB_Status
= tmpsrb
.cmd
.SRB_Status
;
559 lpSRB
->devtype
.SRB_DeviceType
= inqbuf
[0]&0x1f;
561 TRACE("returning devicetype %d for target %d\n",inqbuf
[0]&0x1f,tmpsrb
.cmd
.SRB_Target
);
562 if (ret
!=SS_PENDING
) /* Any error is passed down directly */
564 /* FIXME: knows that the command is finished already, pass final Status */
565 return tmpsrb
.cmd
.SRB_Status
;
567 case SC_EXEC_SCSI_CMD
:
568 return ASPI_ExecScsiCmd(&lpSRB
->cmd
);
570 FIXME("Not implemented SC_ABORT_SRB\n");
573 FIXME("Not implemented SC_RESET_DEV\n");
575 case SC_GET_DISK_INFO
:
576 /* here we have to find out the int13 / bios association.
577 * We just say we do not have any.
579 FIXME("SC_GET_DISK_INFO always return 'int13 unassociated disk'.\n");
580 lpSRB
->diskinfo
.SRB_DriveFlags
= 0; /* disk is not int13 served */
583 FIXME("Unknown command %d\n", lpSRB
->common
.SRB_Cmd
);
585 return SS_INVALID_SRB
;
587 return SS_INVALID_SRB
;
592 /***********************************************************************
593 * GetASPI32DLLVersion (WNASPI32.4)
595 DWORD __cdecl
GetASPI32DLLVersion(void)
598 TRACE("Returning version 1\n");
601 FIXME("Please add SCSI support for your operating system, returning 0\n");
606 /***********************************************************************
607 * GetASPI32Buffer (WNASPI32.8)
608 * Supposed to return a DMA capable large SCSI buffer.
609 * Our implementation does not use those at all, all buffer stuff is
610 * done in the kernel SG device layer. So we just heapalloc the buffer.
612 BOOL __cdecl
GetASPI32Buffer(PASPI32BUFF pab
)
614 pab
->AB_BufPointer
= HeapAlloc(GetProcessHeap(),
615 pab
->AB_ZeroFill
?HEAP_ZERO_MEMORY
:0,
618 if (!pab
->AB_BufPointer
) return FALSE
;
622 /***********************************************************************
623 * FreeASPI32Buffer (WNASPI32.14)
625 BOOL __cdecl
FreeASPI32Buffer(PASPI32BUFF pab
)
627 HeapFree(GetProcessHeap(),0,pab
->AB_BufPointer
);
631 /***********************************************************************
632 * TranslateASPI32Address (WNASPI32.7)
634 BOOL __cdecl
TranslateASPI32Address(LPDWORD pdwPath
, LPDWORD pdwDEVNODE
)
636 FIXME("(%p, %p), stub !\n", pdwPath
, pdwDEVNODE
);