15 #include "debugtools.h"
16 #include "selectors.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
32 static ASPI_DEVICE_INFO *ASPI_open_devices = NULL;
34 static FARPROC16 ASPIChainFunc = NULL;
35 static WORD HA_Count = 1; /* host adapter count; FIXME: detect it */
38 ASPI_OpenDevice16(SRB_ExecSCSICmd16 *prb)
43 ASPI_DEVICE_INFO *curr;
45 /* search list of devices to see if we've opened it already.
46 * There is not an explicit open/close in ASPI land, so hopefully
47 * keeping a device open won't be a problem.
50 for (curr = ASPI_open_devices; curr; curr = curr->next) {
51 if (curr->hostId == prb->SRB_HaId &&
52 curr->target == prb->SRB_Target &&
53 curr->lun == prb->SRB_Lun) {
58 /* device wasn't cached, go ahead and open it */
59 sprintf(idstr, "scsi c%1dt%1dd%1d", prb->SRB_HaId, prb->SRB_Target, prb->SRB_Lun);
61 if (!PROFILE_GetWineIniString(idstr, "Device", "", device_str, sizeof(device_str))) {
62 TRACE("Trying to open unlisted scsi device %s\n", idstr);
66 TRACE("Opening device %s=%s\n", idstr, device_str);
68 fd = open(device_str, O_RDWR);
70 int save_error = errno;
72 ERR("Error opening device %s, error '%s'\n", device_str, strerror(save_error));
74 ERR("Error opening device %s, error %d\n", device_str, save_error);
79 /* device is now open */
80 curr = HeapAlloc( SystemHeap, 0, sizeof(ASPI_DEVICE_INFO) );
82 curr->hostId = prb->SRB_HaId;
83 curr->target = prb->SRB_Target;
84 curr->lun = prb->SRB_Lun;
86 /* insert new record at beginning of open device list */
87 curr->next = ASPI_open_devices;
88 ASPI_open_devices = curr;
94 ASPI_DebugPrintCmd(SRB_ExecSCSICmd16 *prb, UINT16 mode)
104 /* translate real mode address */
105 if (prb->SRB_BufPointer)
106 lpBuf = (BYTE *)DOSMEM_MapRealToLinear((UINT)prb->SRB_BufPointer);
109 lpBuf = PTR_SEG_TO_LIN(prb->SRB_BufPointer);
113 switch (prb->CDBByte[0]) {
116 TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
117 TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
118 TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
119 TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
120 TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
124 TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
128 TRACE("Host Adapter: %d\n", prb->SRB_HaId);
129 TRACE("Flags: %d\n", prb->SRB_Flags);
130 if (TARGET_TO_HOST(prb)) {
131 TRACE("\tData transfer: Target to host. Length checked.\n");
133 else if (HOST_TO_TARGET(prb)) {
134 TRACE("\tData transfer: Host to target. Length checked.\n");
136 else if (NO_DATA_TRANSFERED(prb)) {
137 TRACE("\tData transfer: none\n");
140 WARN("\tTransfer by scsi cmd. Length not checked\n");
143 TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
144 TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
145 TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
146 TRACE("Target: %d\n", prb->SRB_Target);
147 TRACE("Lun: %d\n", prb->SRB_Lun);
148 TRACE("BufLen: %ld\n", prb->SRB_BufLen);
149 TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
150 TRACE("BufPtr: %lx (%p)\n", prb->SRB_BufPointer, lpBuf);
151 TRACE("LinkPointer %lx\n", prb->SRB_Rsvd1);
152 TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
153 TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
154 cdb = &prb->CDBByte[0];
155 cmd = prb->CDBByte[0];
158 DPRINTF("CDB buffer[");
159 for (i = 0; i < prb->SRB_CDBLen; i++) {
160 if (i != 0) DPRINTF(",");
161 DPRINTF("%02x", *cdb++);
168 ASPI_PrintSenseArea16(SRB_ExecSCSICmd16 *prb)
175 cdb = &prb->CDBByte[0];
176 DPRINTF("SenseArea[");
177 for (i = 0; i < prb->SRB_SenseLen; i++) {
179 DPRINTF("%02x", *cdb++);
186 ASPI_DebugPrintResult(SRB_ExecSCSICmd16 *prb, UINT16 mode)
193 /* translate real mode address */
194 if (prb->SRB_BufPointer)
195 lpBuf = (BYTE *)DOSMEM_MapRealToLinear((UINT)prb->SRB_BufPointer);
198 lpBuf = PTR_SEG_TO_LIN(prb->SRB_BufPointer);
202 switch (prb->CDBByte[0]) {
204 TRACE("Vendor: '%s'\n", lpBuf + INQUIRY_VENDOR);
206 case CMD_TEST_UNIT_READY:
207 ASPI_PrintSenseArea16(prb);
213 ASPI_ExecScsiCmd(DWORD ptrPRB, UINT16 mode)
215 SRB_ExecSCSICmd16 *lpPRB = 0;
216 struct sg_header *sg_hd, *sg_reply_hdr;
227 lpPRB = (SRB_ExecSCSICmd16 *)DOSMEM_MapRealToLinear(ptrPRB);
230 lpPRB = PTR_SEG_TO_LIN(ptrPRB);
234 ASPI_DebugPrintCmd(lpPRB, mode);
236 fd = ASPI_OpenDevice16(lpPRB);
238 WARN("Failed: could not open device. Device permissions !?\n");
239 lpPRB->SRB_Status = SS_ERR;
246 lpPRB->SRB_Status = SS_PENDING;
251 /* translate real mode address */
253 lpBuf = (BYTE *)DOSMEM_MapRealToLinear((UINT)lpPRB->SRB_BufPointer);
256 lpBuf = PTR_SEG_TO_LIN(lpPRB->SRB_BufPointer);
260 if (!lpPRB->SRB_CDBLen) {
261 WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
262 lpPRB->SRB_Status = SS_ERR;
266 /* build up sg_header + scsi cmd */
267 if (HOST_TO_TARGET(lpPRB)) {
268 /* send header, command, and then data */
269 in_len = SCSI_OFF + lpPRB->SRB_CDBLen + lpPRB->SRB_BufLen;
270 sg_hd = (struct sg_header *) malloc(in_len);
271 memset(sg_hd, 0, SCSI_OFF);
272 memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
273 if (lpPRB->SRB_BufLen) {
274 memcpy(((BYTE *) sg_hd) + SCSI_OFF + lpPRB->SRB_CDBLen, lpBuf, lpPRB->SRB_BufLen);
278 /* send header and command - no data */
279 in_len = SCSI_OFF + lpPRB->SRB_CDBLen;
280 sg_hd = (struct sg_header *) malloc(in_len);
281 memset(sg_hd, 0, SCSI_OFF);
282 memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
285 if (TARGET_TO_HOST(lpPRB)) {
286 out_len = SCSI_OFF + lpPRB->SRB_BufLen;
287 sg_reply_hdr = (struct sg_header *) malloc(out_len);
288 memset(sg_reply_hdr, 0, SCSI_OFF);
289 sg_hd->reply_len = out_len;
293 sg_reply_hdr = (struct sg_header *) malloc(out_len);
294 memset(sg_reply_hdr, 0, SCSI_OFF);
295 sg_hd->reply_len = out_len;
298 status = write(fd, sg_hd, in_len);
299 if (status < 0 || status != in_len) {
300 int save_error = errno;
302 WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status);
304 if (save_error == ENOMEM) {
305 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");
308 WARN("error:= '%s'\n", strerror(save_error));
310 WARN("error:= %d\n", save_error);
316 status = read(fd, sg_reply_hdr, out_len);
317 if (status < 0 || status != out_len) {
318 WARN("not enough bytes read from scsi device%d\n", status);
322 if (sg_reply_hdr->result != 0) {
323 error_code = sg_reply_hdr->result;
324 WARN("reply header error (%d)\n", sg_reply_hdr->result);
328 if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) {
329 memcpy(lpBuf, sg_reply_hdr + 1, lpPRB->SRB_BufLen);
332 /* copy in sense buffer to amount that is available in client */
333 if (lpPRB->SRB_SenseLen) {
334 int sense_len = lpPRB->SRB_SenseLen;
335 if (lpPRB->SRB_SenseLen > 16)
337 memcpy(SENSE_BUFFER(lpPRB), &sg_reply_hdr->sense_buffer[0], sense_len);
341 lpPRB->SRB_Status = SS_COMP;
342 lpPRB->SRB_HaStat = HASTAT_OK;
343 lpPRB->SRB_TargStat = STATUS_GOOD;
347 if (ASPI_POSTING(lpPRB) && lpPRB->SRB_PostProc) {
348 TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
353 SEGPTR spPRB = MapLS(lpPRB);
355 Callbacks->CallASPIPostProc(lpPRB->SRB_PostProc, spPRB);
360 Callbacks->CallASPIPostProc(lpPRB->SRB_PostProc, ptrPRB);
367 ASPI_DebugPrintResult(lpPRB, mode);
371 if (error_code == EBUSY) {
372 lpPRB->SRB_Status = SS_ASPI_IS_BUSY;
373 TRACE("Device busy\n");
377 lpPRB->SRB_Status = SS_ERR;
380 /* I'm not sure exactly error codes work here
381 * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
383 WARN("error_exit\n");
386 return lpPRB->SRB_Status;
391 /***********************************************************************
392 * GetASPISupportInfo16 (WINASPI.1)
395 WORD WINAPI GetASPISupportInfo16()
398 TRACE("GETASPISupportInfo16\n");
399 /* high byte SS_COMP - low byte number of host adapters */
400 return ((SS_COMP << 8) | HA_Count);
402 return ((SS_NO_ASPI << 8) | 0);
407 DWORD ASPI_SendASPICommand(DWORD ptrSRB, UINT16 mode)
416 lpSRB = (LPSRB16)DOSMEM_MapRealToLinear(ptrSRB);
419 lpSRB = PTR_SEG_TO_LIN(ptrSRB);
422 /* This is not the post proc, it's the chain proc this time */
423 DWORD ret = Callbacks->CallASPIPostProc(ASPIChainFunc, ptrSRB);
426 lpSRB->inquiry.SRB_Status = SS_INVALID_SRB;
433 switch (lpSRB->common.SRB_Cmd) {
435 lpSRB->inquiry.SRB_Status = SS_COMP; /* completed successfully */
436 if (lpSRB->inquiry.SRB_55AASignature == 0x55aa) {
437 TRACE("Extended request detected (Adaptec's ASPIxDOS).\nWe don't support it at the moment.\n");
439 lpSRB->inquiry.SRB_ExtBufferSize = 0x2000; /* bogus value */
440 lpSRB->inquiry.HA_Count = HA_Count;
441 lpSRB->inquiry.HA_SCSI_ID = 7; /* not always ID 7 */
442 strcat(lpSRB->inquiry.HA_ManagerId, "Wine ASPI16"); /* max 15 chars */
443 strcat(lpSRB->inquiry.HA_Identifier, "Wine host"); /* FIXME: return host
445 memset(lpSRB->inquiry.HA_Unique, 0, 16); /* default HA_Unique content */
446 lpSRB->inquiry.HA_Unique[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
447 FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB->inquiry.SRB_HaId);
449 case SC_GET_DEV_TYPE:
450 FIXME("Not implemented SC_GET_DEV_TYPE\n");
452 case SC_EXEC_SCSI_CMD:
453 return ASPI_ExecScsiCmd((DWORD)ptrSRB, mode);
456 FIXME("Not implemented SC_RESET_DEV\n");
459 FIXME("Unknown command %d\n", lpSRB->common.SRB_Cmd);
462 return SS_INVALID_SRB;
466 /***********************************************************************
467 * SendASPICommand16 (WINASPI.2)
469 WORD WINAPI SendASPICommand16(SEGPTR segptr_srb)
472 return ASPI_SendASPICommand(segptr_srb, ASPI_WIN16);
479 /***********************************************************************
480 * InsertInASPIChain16 (WINASPI.3)
482 WORD WINAPI InsertInASPIChain16(BOOL16 remove, FARPROC16 pASPIChainFunc)
485 if (remove == TRUE) /* Remove */
487 if (ASPIChainFunc == pASPIChainFunc)
489 ASPIChainFunc = NULL;
494 if (remove == FALSE) /* Insert */
496 if (ASPIChainFunc == NULL)
498 ASPIChainFunc = pASPIChainFunc;
507 /***********************************************************************
508 * GetASPIDLLVersion16 (WINASPI.4)
511 DWORD WINAPI GetASPIDLLVersion16()
521 void WINAPI ASPI_DOS_func(CONTEXT86 *context)
523 WORD *stack = CTX_SEG_OFF_TO_LIN(context, SS_reg(context), ESP_reg(context));
524 DWORD ptrSRB = *(DWORD *)&stack[2];
526 ASPI_SendASPICommand(ptrSRB, ASPI_DOS);
528 /* simulate a normal RETF sequence as required by DPMI CallRMProcFar */
529 EIP_reg(context) = *(stack++);
530 CS_reg(context) = *(stack++);
531 ESP_reg(context) += 2*sizeof(WORD);
535 /* returns the address of a real mode callback to ASPI_DOS_func() */
536 void ASPI_DOS_HandleInt(CONTEXT86 *context)
539 FARPROC16 *p = (FARPROC16 *)CTX_SEG_OFF_TO_LIN(context, DS_reg(context), EDX_reg(context));
540 if ((CX_reg(context) == 4) || (CX_reg(context) == 5))
542 *p = DPMI_AllocInternalRMCB(ASPI_DOS_func);
543 TRACE("allocated real mode proc %p\n", *p);
544 AX_reg(context) = CX_reg(context);