13 #include "wine/windef16.h"
17 #include "wine/winaspi.h"
18 #include "debugtools.h"
21 DEFAULT_DEBUG_CHANNEL(aspi
);
25 * 1) Residual byte length reporting not handled
26 * 2) Make this code re-entrant for multithreading
27 * 3) Only linux supported so far
30 /* ### start build ### */
31 extern LONG CALLBACK
ASPI_CallTo16_long_l(FARPROC16
,SEGPTR
);
32 /* ### stop build ### */
36 static ASPI_DEVICE_INFO
*ASPI_open_devices
= NULL
;
38 static FARPROC16 ASPIChainFunc
= NULL
;
39 static WORD HA_Count
= 1; /* host adapter count; FIXME: detect it */
42 ASPI_OpenDevice16(SRB_ExecSCSICmd16
*prb
)
48 ASPI_DEVICE_INFO
*curr
;
50 /* search list of devices to see if we've opened it already.
51 * There is not an explicit open/close in ASPI land, so hopefully
52 * keeping a device open won't be a problem.
55 for (curr
= ASPI_open_devices
; curr
; curr
= curr
->next
) {
56 if (curr
->hostId
== prb
->SRB_HaId
&&
57 curr
->target
== prb
->SRB_Target
&&
58 curr
->lun
== prb
->SRB_Lun
) {
63 /* device wasn't cached, go ahead and open it */
64 sprintf( idstr
, "Software\\Wine\\Wine\\Config\\scsi c%1dt%1dd%1d",
65 prb
->SRB_HaId
, prb
->SRB_Target
, prb
->SRB_Lun
);
68 if (!RegOpenKeyExA( HKEY_LOCAL_MACHINE
, idstr
, 0, KEY_ALL_ACCESS
, &hkey
))
70 DWORD type
, count
= sizeof(device_str
);
71 if (RegQueryValueExA( hkey
, "Device", 0, &type
, device_str
, &count
)) device_str
[0] = 0;
77 TRACE("Trying to open unlisted scsi device %s\n", idstr
);
81 TRACE("Opening device %s=%s\n", idstr
, device_str
);
83 fd
= open(device_str
, O_RDWR
);
85 int save_error
= errno
;
86 ERR("Error opening device %s, error '%s'\n", device_str
, strerror(save_error
));
90 /* device is now open */
91 curr
= HeapAlloc( GetProcessHeap(), 0, sizeof(ASPI_DEVICE_INFO
) );
93 curr
->hostId
= prb
->SRB_HaId
;
94 curr
->target
= prb
->SRB_Target
;
95 curr
->lun
= prb
->SRB_Lun
;
97 /* insert new record at beginning of open device list */
98 curr
->next
= ASPI_open_devices
;
99 ASPI_open_devices
= curr
;
105 ASPI_DebugPrintCmd(SRB_ExecSCSICmd16
*prb
, UINT16 mode
)
115 /* translate real mode address */
116 if (prb
->SRB_BufPointer
)
117 lpBuf
= PTR_REAL_TO_LIN( SELECTOROF(prb
->SRB_BufPointer
), OFFSETOF(prb
->SRB_BufPointer
));
120 lpBuf
= MapSL(prb
->SRB_BufPointer
);
124 switch (prb
->CDBByte
[0]) {
127 TRACE("\tEVPD: %d\n", prb
->CDBByte
[1] & 1);
128 TRACE("\tLUN: %d\n", (prb
->CDBByte
[1] & 0xc) >> 1);
129 TRACE("\tPAGE CODE: %d\n", prb
->CDBByte
[2]);
130 TRACE("\tALLOCATION LENGTH: %d\n", prb
->CDBByte
[4]);
131 TRACE("\tCONTROL: %d\n", prb
->CDBByte
[5]);
135 TRACE("Transfer Length: %d\n", prb
->CDBByte
[4]);
139 TRACE("Host Adapter: %d\n", prb
->SRB_HaId
);
140 TRACE("Flags: %d\n", prb
->SRB_Flags
);
141 if (TARGET_TO_HOST(prb
)) {
142 TRACE("\tData transfer: Target to host. Length checked.\n");
144 else if (HOST_TO_TARGET(prb
)) {
145 TRACE("\tData transfer: Host to target. Length checked.\n");
147 else if (NO_DATA_TRANSFERED(prb
)) {
148 TRACE("\tData transfer: none\n");
151 WARN("\tTransfer by scsi cmd. Length not checked\n");
154 TRACE("\tResidual byte length reporting %s\n", prb
->SRB_Flags
& 0x4 ? "enabled" : "disabled");
155 TRACE("\tLinking %s\n", prb
->SRB_Flags
& 0x2 ? "enabled" : "disabled");
156 TRACE("\tPosting %s\n", prb
->SRB_Flags
& 0x1 ? "enabled" : "disabled");
157 TRACE("Target: %d\n", prb
->SRB_Target
);
158 TRACE("Lun: %d\n", prb
->SRB_Lun
);
159 TRACE("BufLen: %ld\n", prb
->SRB_BufLen
);
160 TRACE("SenseLen: %d\n", prb
->SRB_SenseLen
);
161 TRACE("BufPtr: %lx (%p)\n", prb
->SRB_BufPointer
, lpBuf
);
162 TRACE("LinkPointer %lx\n", prb
->SRB_Rsvd1
);
163 TRACE("CDB Length: %d\n", prb
->SRB_CDBLen
);
164 TRACE("POST Proc: %lx\n", (DWORD
) prb
->SRB_PostProc
);
165 cdb
= &prb
->CDBByte
[0];
166 cmd
= prb
->CDBByte
[0];
169 DPRINTF("CDB buffer[");
170 for (i
= 0; i
< prb
->SRB_CDBLen
; i
++) {
171 if (i
!= 0) DPRINTF(",");
172 DPRINTF("%02x", *cdb
++);
179 ASPI_PrintSenseArea16(SRB_ExecSCSICmd16
*prb
)
186 cdb
= &prb
->CDBByte
[0];
187 DPRINTF("SenseArea[");
188 for (i
= 0; i
< prb
->SRB_SenseLen
; i
++) {
190 DPRINTF("%02x", *cdb
++);
197 ASPI_DebugPrintResult(SRB_ExecSCSICmd16
*prb
, UINT16 mode
)
204 /* translate real mode address */
205 if (prb
->SRB_BufPointer
)
206 lpBuf
= PTR_REAL_TO_LIN( SELECTOROF(prb
->SRB_BufPointer
), OFFSETOF(prb
->SRB_BufPointer
));
209 lpBuf
= MapSL(prb
->SRB_BufPointer
);
213 switch (prb
->CDBByte
[0]) {
215 TRACE("Vendor: '%s'\n", lpBuf
+ INQUIRY_VENDOR
);
217 case CMD_TEST_UNIT_READY
:
218 ASPI_PrintSenseArea16(prb
);
224 ASPI_ExecScsiCmd(DWORD ptrPRB
, UINT16 mode
)
226 SRB_ExecSCSICmd16
*lpPRB
= 0;
227 struct sg_header
*sg_hd
, *sg_reply_hdr
;
238 lpPRB
= PTR_REAL_TO_LIN( SELECTOROF(ptrPRB
), OFFSETOF(ptrPRB
));
241 lpPRB
= MapSL(ptrPRB
);
245 ASPI_DebugPrintCmd(lpPRB
, mode
);
247 fd
= ASPI_OpenDevice16(lpPRB
);
249 WARN("Failed: could not open device. Device permissions !?\n");
250 lpPRB
->SRB_Status
= SS_ERR
;
257 lpPRB
->SRB_Status
= SS_PENDING
;
262 /* translate real mode address */
264 lpBuf
= PTR_REAL_TO_LIN( SELECTOROF(lpPRB
->SRB_BufPointer
),
265 OFFSETOF(lpPRB
->SRB_BufPointer
));
268 lpBuf
= MapSL(lpPRB
->SRB_BufPointer
);
272 if (!lpPRB
->SRB_CDBLen
) {
273 WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
274 lpPRB
->SRB_Status
= SS_ERR
;
278 /* build up sg_header + scsi cmd */
279 if (HOST_TO_TARGET(lpPRB
)) {
280 /* send header, command, and then data */
281 in_len
= SCSI_OFF
+ lpPRB
->SRB_CDBLen
+ lpPRB
->SRB_BufLen
;
282 sg_hd
= (struct sg_header
*) malloc(in_len
);
283 memset(sg_hd
, 0, SCSI_OFF
);
284 memcpy(sg_hd
+ 1, &lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
285 if (lpPRB
->SRB_BufLen
) {
286 memcpy(((BYTE
*) sg_hd
) + SCSI_OFF
+ lpPRB
->SRB_CDBLen
, lpBuf
, lpPRB
->SRB_BufLen
);
290 /* send header and command - no data */
291 in_len
= SCSI_OFF
+ lpPRB
->SRB_CDBLen
;
292 sg_hd
= (struct sg_header
*) malloc(in_len
);
293 memset(sg_hd
, 0, SCSI_OFF
);
294 memcpy(sg_hd
+ 1, &lpPRB
->CDBByte
[0], lpPRB
->SRB_CDBLen
);
297 if (TARGET_TO_HOST(lpPRB
)) {
298 out_len
= SCSI_OFF
+ lpPRB
->SRB_BufLen
;
299 sg_reply_hdr
= (struct sg_header
*) malloc(out_len
);
300 memset(sg_reply_hdr
, 0, SCSI_OFF
);
301 sg_hd
->reply_len
= out_len
;
305 sg_reply_hdr
= (struct sg_header
*) malloc(out_len
);
306 memset(sg_reply_hdr
, 0, SCSI_OFF
);
307 sg_hd
->reply_len
= out_len
;
310 status
= write(fd
, sg_hd
, in_len
);
311 if (status
< 0 || status
!= in_len
) {
312 int save_error
= errno
;
314 WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len
, status
);
316 if (save_error
== ENOMEM
) {
317 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");
319 WARN("error:= '%s'\n", strerror(save_error
));
324 status
= read(fd
, sg_reply_hdr
, out_len
);
325 if (status
< 0 || status
!= out_len
) {
326 WARN("not enough bytes read from scsi device%d\n", status
);
330 if (sg_reply_hdr
->result
!= 0) {
331 error_code
= sg_reply_hdr
->result
;
332 WARN("reply header error (%d)\n", sg_reply_hdr
->result
);
336 if (TARGET_TO_HOST(lpPRB
) && lpPRB
->SRB_BufLen
) {
337 memcpy(lpBuf
, sg_reply_hdr
+ 1, lpPRB
->SRB_BufLen
);
340 /* copy in sense buffer to amount that is available in client */
341 if (lpPRB
->SRB_SenseLen
) {
342 int sense_len
= lpPRB
->SRB_SenseLen
;
343 if (lpPRB
->SRB_SenseLen
> 16)
345 memcpy(SENSE_BUFFER(lpPRB
), &sg_reply_hdr
->sense_buffer
[0], sense_len
);
349 lpPRB
->SRB_Status
= SS_COMP
;
350 lpPRB
->SRB_HaStat
= HASTAT_OK
;
351 lpPRB
->SRB_TargStat
= STATUS_GOOD
;
355 if (ASPI_POSTING(lpPRB
) && lpPRB
->SRB_PostProc
) {
356 TRACE("Post Routine (%lx) called\n", (DWORD
) lpPRB
->SRB_PostProc
);
361 SEGPTR spPRB
= MapLS(lpPRB
);
363 ASPI_CallTo16_long_l(lpPRB
->SRB_PostProc
, spPRB
);
368 ASPI_CallTo16_long_l(lpPRB
->SRB_PostProc
, ptrPRB
);
375 ASPI_DebugPrintResult(lpPRB
, mode
);
379 if (error_code
== EBUSY
) {
380 lpPRB
->SRB_Status
= SS_ASPI_IS_BUSY
;
381 TRACE("Device busy\n");
385 lpPRB
->SRB_Status
= SS_ERR
;
388 /* I'm not sure exactly error codes work here
389 * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
391 WARN("error_exit\n");
394 return lpPRB
->SRB_Status
;
399 /***********************************************************************
400 * GetASPISupportInfo (WINASPI.1)
403 WORD WINAPI
GetASPISupportInfo16(void)
406 TRACE("GETASPISupportInfo16\n");
407 /* high byte SS_COMP - low byte number of host adapters */
408 return ((SS_COMP
<< 8) | HA_Count
);
410 return ((SS_NO_ASPI
<< 8) | 0);
415 DWORD
ASPI_SendASPICommand(DWORD ptrSRB
, UINT16 mode
)
424 lpSRB
= PTR_REAL_TO_LIN( SELECTOROF(ptrSRB
), OFFSETOF(ptrSRB
));
427 lpSRB
= MapSL(ptrSRB
);
430 /* This is not the post proc, it's the chain proc this time */
431 DWORD ret
= ASPI_CallTo16_long_l(ASPIChainFunc
, ptrSRB
);
434 lpSRB
->inquiry
.SRB_Status
= SS_INVALID_SRB
;
441 switch (lpSRB
->common
.SRB_Cmd
) {
443 lpSRB
->inquiry
.SRB_Status
= SS_COMP
; /* completed successfully */
444 if (lpSRB
->inquiry
.SRB_55AASignature
== 0x55aa) {
445 TRACE("Extended request detected (Adaptec's ASPIxDOS).\nWe don't support it at the moment.\n");
447 lpSRB
->inquiry
.SRB_ExtBufferSize
= 0x2000; /* bogus value */
448 lpSRB
->inquiry
.HA_Count
= HA_Count
;
449 lpSRB
->inquiry
.HA_SCSI_ID
= 7; /* not always ID 7 */
450 strcat(lpSRB
->inquiry
.HA_ManagerId
, "Wine ASPI16"); /* max 15 chars */
451 strcat(lpSRB
->inquiry
.HA_Identifier
, "Wine host"); /* FIXME: return host
453 memset(lpSRB
->inquiry
.HA_Unique
, 0, 16); /* default HA_Unique content */
454 lpSRB
->inquiry
.HA_Unique
[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
455 FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB
->inquiry
.SRB_HaId
);
457 case SC_GET_DEV_TYPE
:
458 FIXME("Not implemented SC_GET_DEV_TYPE\n");
460 case SC_EXEC_SCSI_CMD
:
461 return ASPI_ExecScsiCmd((DWORD
)ptrSRB
, mode
);
464 FIXME("Not implemented SC_RESET_DEV\n");
467 FIXME("Unknown command %d\n", lpSRB
->common
.SRB_Cmd
);
470 return SS_INVALID_SRB
;
474 /***********************************************************************
475 * SendASPICommand (WINASPI.2)
477 WORD WINAPI
SendASPICommand16(SEGPTR segptr_srb
)
480 return ASPI_SendASPICommand(segptr_srb
, ASPI_WIN16
);
487 /***********************************************************************
488 * InsertInASPIChain (WINASPI.3)
490 WORD WINAPI
InsertInASPIChain16(BOOL16 remove
, FARPROC16 pASPIChainFunc
)
493 if (remove
== TRUE
) /* Remove */
495 if (ASPIChainFunc
== pASPIChainFunc
)
497 ASPIChainFunc
= NULL
;
502 if (remove
== FALSE
) /* Insert */
504 if (ASPIChainFunc
== NULL
)
506 ASPIChainFunc
= pASPIChainFunc
;
515 /***********************************************************************
516 * GETASPIDLLVERSION (WINASPI.4)
519 DWORD WINAPI
GetASPIDLLVersion16()