14 #include "wine/windef16.h"
18 #include "wine/winaspi.h"
20 #include "debugtools.h"
21 #include "selectors.h"
25 DEFAULT_DEBUG_CHANNEL(aspi
);
29 * 1) Residual byte length reporting not handled
30 * 2) Make this code re-entrant for multithreading
31 * 3) Only linux supported so far
34 /* ### start build ### */
35 extern LONG CALLBACK
ASPI_CallTo16_long_l(FARPROC16
,SEGPTR
);
36 /* ### stop build ### */
40 static ASPI_DEVICE_INFO
*ASPI_open_devices
= NULL
;
42 static FARPROC16 ASPIChainFunc
= NULL
;
43 static WORD HA_Count
= 1; /* host adapter count; FIXME: detect it */
46 ASPI_OpenDevice16(SRB_ExecSCSICmd16
*prb
)
52 ASPI_DEVICE_INFO
*curr
;
54 /* search list of devices to see if we've opened it already.
55 * There is not an explicit open/close in ASPI land, so hopefully
56 * keeping a device open won't be a problem.
59 for (curr
= ASPI_open_devices
; curr
; curr
= curr
->next
) {
60 if (curr
->hostId
== prb
->SRB_HaId
&&
61 curr
->target
== prb
->SRB_Target
&&
62 curr
->lun
== prb
->SRB_Lun
) {
67 /* device wasn't cached, go ahead and open it */
68 sprintf( idstr
, "Software\\Wine\\Wine\\Config\\scsi c%1dt%1dd%1d",
69 prb
->SRB_HaId
, prb
->SRB_Target
, prb
->SRB_Lun
);
72 if (!RegOpenKeyExA( HKEY_LOCAL_MACHINE
, idstr
, 0, KEY_ALL_ACCESS
, &hkey
))
74 DWORD type
, count
= sizeof(device_str
);
75 if (RegQueryValueExA( hkey
, "Device", 0, &type
, device_str
, &count
)) device_str
[0] = 0;
81 TRACE("Trying to open unlisted scsi device %s\n", idstr
);
85 TRACE("Opening device %s=%s\n", idstr
, device_str
);
87 fd
= open(device_str
, O_RDWR
);
89 int save_error
= errno
;
90 ERR("Error opening device %s, error '%s'\n", device_str
, strerror(save_error
));
94 /* device is now open */
95 curr
= HeapAlloc( GetProcessHeap(), 0, sizeof(ASPI_DEVICE_INFO
) );
97 curr
->hostId
= prb
->SRB_HaId
;
98 curr
->target
= prb
->SRB_Target
;
99 curr
->lun
= prb
->SRB_Lun
;
101 /* insert new record at beginning of open device list */
102 curr
->next
= ASPI_open_devices
;
103 ASPI_open_devices
= curr
;
109 ASPI_DebugPrintCmd(SRB_ExecSCSICmd16
*prb
, UINT16 mode
)
119 /* translate real mode address */
120 if (prb
->SRB_BufPointer
)
121 lpBuf
= PTR_REAL_TO_LIN( SELECTOROF(prb
->SRB_BufPointer
), OFFSETOF(prb
->SRB_BufPointer
));
124 lpBuf
= PTR_SEG_TO_LIN(prb
->SRB_BufPointer
);
128 switch (prb
->CDBByte
[0]) {
131 TRACE("\tEVPD: %d\n", prb
->CDBByte
[1] & 1);
132 TRACE("\tLUN: %d\n", (prb
->CDBByte
[1] & 0xc) >> 1);
133 TRACE("\tPAGE CODE: %d\n", prb
->CDBByte
[2]);
134 TRACE("\tALLOCATION LENGTH: %d\n", prb
->CDBByte
[4]);
135 TRACE("\tCONTROL: %d\n", prb
->CDBByte
[5]);
139 TRACE("Transfer Length: %d\n", prb
->CDBByte
[4]);
143 TRACE("Host Adapter: %d\n", prb
->SRB_HaId
);
144 TRACE("Flags: %d\n", prb
->SRB_Flags
);
145 if (TARGET_TO_HOST(prb
)) {
146 TRACE("\tData transfer: Target to host. Length checked.\n");
148 else if (HOST_TO_TARGET(prb
)) {
149 TRACE("\tData transfer: Host to target. Length checked.\n");
151 else if (NO_DATA_TRANSFERED(prb
)) {
152 TRACE("\tData transfer: none\n");
155 WARN("\tTransfer by scsi cmd. Length not checked\n");
158 TRACE("\tResidual byte length reporting %s\n", prb
->SRB_Flags
& 0x4 ? "enabled" : "disabled");
159 TRACE("\tLinking %s\n", prb
->SRB_Flags
& 0x2 ? "enabled" : "disabled");
160 TRACE("\tPosting %s\n", prb
->SRB_Flags
& 0x1 ? "enabled" : "disabled");
161 TRACE("Target: %d\n", prb
->SRB_Target
);
162 TRACE("Lun: %d\n", prb
->SRB_Lun
);
163 TRACE("BufLen: %ld\n", prb
->SRB_BufLen
);
164 TRACE("SenseLen: %d\n", prb
->SRB_SenseLen
);
165 TRACE("BufPtr: %lx (%p)\n", prb
->SRB_BufPointer
, lpBuf
);
166 TRACE("LinkPointer %lx\n", prb
->SRB_Rsvd1
);
167 TRACE("CDB Length: %d\n", prb
->SRB_CDBLen
);
168 TRACE("POST Proc: %lx\n", (DWORD
) prb
->SRB_PostProc
);
169 cdb
= &prb
->CDBByte
[0];
170 cmd
= prb
->CDBByte
[0];
173 DPRINTF("CDB buffer[");
174 for (i
= 0; i
< prb
->SRB_CDBLen
; i
++) {
175 if (i
!= 0) DPRINTF(",");
176 DPRINTF("%02x", *cdb
++);
183 ASPI_PrintSenseArea16(SRB_ExecSCSICmd16
*prb
)
190 cdb
= &prb
->CDBByte
[0];
191 DPRINTF("SenseArea[");
192 for (i
= 0; i
< prb
->SRB_SenseLen
; i
++) {
194 DPRINTF("%02x", *cdb
++);
201 ASPI_DebugPrintResult(SRB_ExecSCSICmd16
*prb
, UINT16 mode
)
208 /* translate real mode address */
209 if (prb
->SRB_BufPointer
)
210 lpBuf
= PTR_REAL_TO_LIN( SELECTOROF(prb
->SRB_BufPointer
), OFFSETOF(prb
->SRB_BufPointer
));
213 lpBuf
= PTR_SEG_TO_LIN(prb
->SRB_BufPointer
);
217 switch (prb
->CDBByte
[0]) {
219 TRACE("Vendor: '%s'\n", lpBuf
+ INQUIRY_VENDOR
);
221 case CMD_TEST_UNIT_READY
:
222 ASPI_PrintSenseArea16(prb
);
228 ASPI_ExecScsiCmd(DWORD ptrPRB
, UINT16 mode
)
230 SRB_ExecSCSICmd16
*lpPRB
= 0;
231 struct sg_header
*sg_hd
, *sg_reply_hdr
;
242 lpPRB
= PTR_REAL_TO_LIN( SELECTOROF(ptrPRB
), OFFSETOF(ptrPRB
));
245 lpPRB
= PTR_SEG_TO_LIN(ptrPRB
);
249 ASPI_DebugPrintCmd(lpPRB
, mode
);
251 fd
= ASPI_OpenDevice16(lpPRB
);
253 WARN("Failed: could not open device. Device permissions !?\n");
254 lpPRB
->SRB_Status
= SS_ERR
;
261 lpPRB
->SRB_Status
= SS_PENDING
;
266 /* translate real mode address */
268 lpBuf
= PTR_REAL_TO_LIN( SELECTOROF(lpPRB
->SRB_BufPointer
),
269 OFFSETOF(lpPRB
->SRB_BufPointer
));
272 lpBuf
= PTR_SEG_TO_LIN(lpPRB
->SRB_BufPointer
);
276 if (!lpPRB
->SRB_CDBLen
) {
277 WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
278 lpPRB
->SRB_Status
= SS_ERR
;
282 /* build up sg_header + scsi cmd */
283 if (HOST_TO_TARGET(lpPRB
)) {
284 /* send header, command, and then data */
285 in_len
= SCSI_OFF
+ lpPRB
->SRB_CDBLen
+ lpPRB
->SRB_BufLen
;
286 sg_hd
= (struct sg_header
*) malloc(in_len
);
287 memset(sg_hd
, 0, SCSI_OFF
);
288 memcpy(sg_hd
+ 1, &lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
289 if (lpPRB
->SRB_BufLen
) {
290 memcpy(((BYTE
*) sg_hd
) + SCSI_OFF
+ lpPRB
->SRB_CDBLen
, lpBuf
, lpPRB
->SRB_BufLen
);
294 /* send header and command - no data */
295 in_len
= SCSI_OFF
+ lpPRB
->SRB_CDBLen
;
296 sg_hd
= (struct sg_header
*) malloc(in_len
);
297 memset(sg_hd
, 0, SCSI_OFF
);
298 memcpy(sg_hd
+ 1, &lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
301 if (TARGET_TO_HOST(lpPRB
)) {
302 out_len
= SCSI_OFF
+ lpPRB
->SRB_BufLen
;
303 sg_reply_hdr
= (struct sg_header
*) malloc(out_len
);
304 memset(sg_reply_hdr
, 0, SCSI_OFF
);
305 sg_hd
->reply_len
= out_len
;
309 sg_reply_hdr
= (struct sg_header
*) malloc(out_len
);
310 memset(sg_reply_hdr
, 0, SCSI_OFF
);
311 sg_hd
->reply_len
= out_len
;
314 status
= write(fd
, sg_hd
, in_len
);
315 if (status
< 0 || status
!= in_len
) {
316 int save_error
= errno
;
318 WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len
, status
);
320 if (save_error
== ENOMEM
) {
321 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");
323 WARN("error:= '%s'\n", strerror(save_error
));
328 status
= read(fd
, sg_reply_hdr
, out_len
);
329 if (status
< 0 || status
!= out_len
) {
330 WARN("not enough bytes read from scsi device%d\n", status
);
334 if (sg_reply_hdr
->result
!= 0) {
335 error_code
= sg_reply_hdr
->result
;
336 WARN("reply header error (%d)\n", sg_reply_hdr
->result
);
340 if (TARGET_TO_HOST(lpPRB
) && lpPRB
->SRB_BufLen
) {
341 memcpy(lpBuf
, sg_reply_hdr
+ 1, lpPRB
->SRB_BufLen
);
344 /* copy in sense buffer to amount that is available in client */
345 if (lpPRB
->SRB_SenseLen
) {
346 int sense_len
= lpPRB
->SRB_SenseLen
;
347 if (lpPRB
->SRB_SenseLen
> 16)
349 memcpy(SENSE_BUFFER(lpPRB
), &sg_reply_hdr
->sense_buffer
[0], sense_len
);
353 lpPRB
->SRB_Status
= SS_COMP
;
354 lpPRB
->SRB_HaStat
= HASTAT_OK
;
355 lpPRB
->SRB_TargStat
= STATUS_GOOD
;
359 if (ASPI_POSTING(lpPRB
) && lpPRB
->SRB_PostProc
) {
360 TRACE("Post Routine (%lx) called\n", (DWORD
) lpPRB
->SRB_PostProc
);
365 SEGPTR spPRB
= MapLS(lpPRB
);
367 ASPI_CallTo16_long_l(lpPRB
->SRB_PostProc
, spPRB
);
372 ASPI_CallTo16_long_l(lpPRB
->SRB_PostProc
, ptrPRB
);
379 ASPI_DebugPrintResult(lpPRB
, mode
);
383 if (error_code
== EBUSY
) {
384 lpPRB
->SRB_Status
= SS_ASPI_IS_BUSY
;
385 TRACE("Device busy\n");
389 lpPRB
->SRB_Status
= SS_ERR
;
392 /* I'm not sure exactly error codes work here
393 * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
395 WARN("error_exit\n");
398 return lpPRB
->SRB_Status
;
403 /***********************************************************************
404 * GetASPISupportInfo16 (WINASPI.1)
407 WORD WINAPI
GetASPISupportInfo16(void)
410 TRACE("GETASPISupportInfo16\n");
411 /* high byte SS_COMP - low byte number of host adapters */
412 return ((SS_COMP
<< 8) | HA_Count
);
414 return ((SS_NO_ASPI
<< 8) | 0);
419 DWORD
ASPI_SendASPICommand(DWORD ptrSRB
, UINT16 mode
)
428 lpSRB
= PTR_REAL_TO_LIN( SELECTOROF(ptrSRB
), OFFSETOF(ptrSRB
));
431 lpSRB
= PTR_SEG_TO_LIN(ptrSRB
);
434 /* This is not the post proc, it's the chain proc this time */
435 DWORD ret
= ASPI_CallTo16_long_l(ASPIChainFunc
, ptrSRB
);
438 lpSRB
->inquiry
.SRB_Status
= SS_INVALID_SRB
;
445 switch (lpSRB
->common
.SRB_Cmd
) {
447 lpSRB
->inquiry
.SRB_Status
= SS_COMP
; /* completed successfully */
448 if (lpSRB
->inquiry
.SRB_55AASignature
== 0x55aa) {
449 TRACE("Extended request detected (Adaptec's ASPIxDOS).\nWe don't support it at the moment.\n");
451 lpSRB
->inquiry
.SRB_ExtBufferSize
= 0x2000; /* bogus value */
452 lpSRB
->inquiry
.HA_Count
= HA_Count
;
453 lpSRB
->inquiry
.HA_SCSI_ID
= 7; /* not always ID 7 */
454 strcat(lpSRB
->inquiry
.HA_ManagerId
, "Wine ASPI16"); /* max 15 chars */
455 strcat(lpSRB
->inquiry
.HA_Identifier
, "Wine host"); /* FIXME: return host
457 memset(lpSRB
->inquiry
.HA_Unique
, 0, 16); /* default HA_Unique content */
458 lpSRB
->inquiry
.HA_Unique
[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
459 FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB
->inquiry
.SRB_HaId
);
461 case SC_GET_DEV_TYPE
:
462 FIXME("Not implemented SC_GET_DEV_TYPE\n");
464 case SC_EXEC_SCSI_CMD
:
465 return ASPI_ExecScsiCmd((DWORD
)ptrSRB
, mode
);
468 FIXME("Not implemented SC_RESET_DEV\n");
471 FIXME("Unknown command %d\n", lpSRB
->common
.SRB_Cmd
);
474 return SS_INVALID_SRB
;
478 /***********************************************************************
479 * SendASPICommand16 (WINASPI.2)
481 WORD WINAPI
SendASPICommand16(SEGPTR segptr_srb
)
484 return ASPI_SendASPICommand(segptr_srb
, ASPI_WIN16
);
491 /***********************************************************************
492 * InsertInASPIChain16 (WINASPI.3)
494 WORD WINAPI
InsertInASPIChain16(BOOL16 remove
, FARPROC16 pASPIChainFunc
)
497 if (remove
== TRUE
) /* Remove */
499 if (ASPIChainFunc
== pASPIChainFunc
)
501 ASPIChainFunc
= NULL
;
506 if (remove
== FALSE
) /* Insert */
508 if (ASPIChainFunc
== NULL
)
510 ASPIChainFunc
= pASPIChainFunc
;
519 /***********************************************************************
520 * GetASPIDLLVersion16 (WINASPI.4)
523 DWORD WINAPI
GetASPIDLLVersion16()