dlls/winaspi/winaspi16.c

   1 #include "config.h"
   2
   3 #include <stdlib.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <memory.h>
   9 #include <unistd.h>
  10 #include <string.h>
  11 #include <stdio.h>
  12
  13 #include "winbase.h"
  14 #include "aspi.h"
  15 #include "winaspi.h"
  16 #include "options.h"
  17 #include "heap.h"
  18 #include "debugtools.h"
  19 #include "selectors.h"
  20 #include "miscemu.h"
  21 #include "ldt.h"
  22 #include "callback.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(aspi)
  25
  26
  27 /* FIXME!
  28  * 1) Residual byte length reporting not handled
  29  * 2) Make this code re-entrant for multithreading
  30  * 3) Only linux supported so far
  31  */
  32
  33 #ifdef linux
  34
  35 static ASPI_DEVICE_INFO *ASPI_open_devices = NULL;
  36
  37 static FARPROC16 ASPIChainFunc = NULL;
  38 static WORD HA_Count = 1; /* host adapter count; FIXME: detect it */
  39
  40 static int
  41 ASPI_OpenDevice16(SRB_ExecSCSICmd16 *prb)
  42 {
  43     int fd;
  44     char        idstr[20];
  45     char        device_str[50];
  46     ASPI_DEVICE_INFO *curr;
  47
  48     /* search list of devices to see if we've opened it already.
  49      * There is not an explicit open/close in ASPI land, so hopefully
  50      * keeping a device open won't be a problem.
  51      */
  52
  53     for (curr = ASPI_open_devices; curr; curr = curr->next) {
  54         if (curr->hostId == prb->SRB_HaId &&
  55             curr->target == prb->SRB_Target &&
  56             curr->lun == prb->SRB_Lun) {
  57             return curr->fd;
  58         }
  59     }
  60
  61     /* device wasn't cached, go ahead and open it */
  62     sprintf(idstr, "scsi c%1dt%1dd%1d", prb->SRB_HaId, prb->SRB_Target, prb->SRB_Lun);
  63
  64     if (!PROFILE_GetWineIniString(idstr, "Device", "", device_str, sizeof(device_str))) {
  65         TRACE("Trying to open unlisted scsi device %s\n", idstr);
  66         return -1;
  67     }
  68
  69     TRACE("Opening device %s=%s\n", idstr, device_str);
  70
  71     fd = open(device_str, O_RDWR);
  72     if (fd == -1) {
  73         int save_error = errno;
  74 #ifdef HAVE_STRERROR
  75         ERR("Error opening device %s, error '%s'\n", device_str, strerror(save_error));
  76 #else
  77     ERR("Error opening device %s, error %d\n", device_str, save_error);
  78 #endif
  79         return -1;
  80     }
  81
  82     /* device is now open */
  83     curr = HeapAlloc( GetProcessHeap(), 0, sizeof(ASPI_DEVICE_INFO) );
  84     curr->fd = fd;
  85     curr->hostId = prb->SRB_HaId;
  86     curr->target = prb->SRB_Target;
  87     curr->lun = prb->SRB_Lun;
  88
  89     /* insert new record at beginning of open device list */
  90     curr->next = ASPI_open_devices;
  91     ASPI_open_devices = curr;
  92     return fd;
  93 }
  94
  95
  96 static void
  97 ASPI_DebugPrintCmd(SRB_ExecSCSICmd16 *prb, UINT16 mode)
  98 {
  99   BYTE  cmd;
 100   int   i;
 101   BYTE *cdb;
 102   BYTE *lpBuf = 0;
 103
 104   switch (mode)
 105   {
 106       case ASPI_DOS:
 107         /* translate real mode address */
 108         if (prb->SRB_BufPointer)
 109             lpBuf = (BYTE *)DOSMEM_MapRealToLinear((UINT)prb->SRB_BufPointer);
 110         break;
 111       case ASPI_WIN16:
 112         lpBuf = PTR_SEG_TO_LIN(prb->SRB_BufPointer);
 113         break;
 114   }
 115
 116   switch (prb->CDBByte[0]) {
 117   case CMD_INQUIRY:
 118     TRACE("{\n");
 119     TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
 120     TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
 121     TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
 122     TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
 123     TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
 124     TRACE("}\n");
 125     break;
 126   case CMD_SCAN_SCAN:
 127     TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
 128     break;
 129   }
 130
 131   TRACE("Host Adapter: %d\n", prb->SRB_HaId);
 132   TRACE("Flags: %d\n", prb->SRB_Flags);
 133   if (TARGET_TO_HOST(prb)) {
 134     TRACE("\tData transfer: Target to host. Length checked.\n");
 135   }
 136   else if (HOST_TO_TARGET(prb)) {
 137     TRACE("\tData transfer: Host to target. Length checked.\n");
 138   }
 139   else if (NO_DATA_TRANSFERED(prb)) {
 140     TRACE("\tData transfer: none\n");
 141   }
 142   else {
 143     WARN("\tTransfer by scsi cmd. Length not checked\n");
 144   }
 145
 146   TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
 147   TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
 148   TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
 149   TRACE("Target: %d\n", prb->SRB_Target);
 150   TRACE("Lun: %d\n", prb->SRB_Lun);
 151   TRACE("BufLen: %ld\n", prb->SRB_BufLen);
 152   TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
 153   TRACE("BufPtr: %lx (%p)\n", prb->SRB_BufPointer, lpBuf);
 154   TRACE("LinkPointer %lx\n", prb->SRB_Rsvd1);
 155   TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
 156   TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
 157   cdb = &prb->CDBByte[0];
 158   cmd = prb->CDBByte[0];
 159   if (TRACE_ON(aspi))
 160   {
 161       DPRINTF("CDB buffer[");
 162       for (i = 0; i < prb->SRB_CDBLen; i++) {
 163           if (i != 0) DPRINTF(",");
 164           DPRINTF("%02x", *cdb++);
 165       }
 166       DPRINTF("]\n");
 167   }
 168 }
 169
 170 static void
 171 ASPI_PrintSenseArea16(SRB_ExecSCSICmd16 *prb)
 172 {
 173   int   i;
 174   BYTE *cdb;
 175
 176   if (TRACE_ON(aspi))
 177   {
 178       cdb = &prb->CDBByte[0];
 179       DPRINTF("SenseArea[");
 180       for (i = 0; i < prb->SRB_SenseLen; i++) {
 181           if (i) DPRINTF(",");
 182           DPRINTF("%02x", *cdb++);
 183       }
 184       DPRINTF("]\n");
 185   }
 186 }
 187
 188 static void
 189 ASPI_DebugPrintResult(SRB_ExecSCSICmd16 *prb, UINT16 mode)
 190 {
 191   BYTE *lpBuf = 0;
 192
 193   switch (mode)
 194   {
 195       case ASPI_DOS:
 196         /* translate real mode address */
 197         if (prb->SRB_BufPointer)
 198             lpBuf = (BYTE *)DOSMEM_MapRealToLinear((UINT)prb->SRB_BufPointer);
 199         break;
 200       case ASPI_WIN16:
 201         lpBuf = PTR_SEG_TO_LIN(prb->SRB_BufPointer);
 202         break;
 203   }
 204
 205   switch (prb->CDBByte[0]) {
 206   case CMD_INQUIRY:
 207     TRACE("Vendor: '%s'\n", lpBuf + INQUIRY_VENDOR);
 208     break;
 209   case CMD_TEST_UNIT_READY:
 210     ASPI_PrintSenseArea16(prb);
 211     break;
 212   }
 213 }
 214
 215 static WORD
 216 ASPI_ExecScsiCmd(DWORD ptrPRB, UINT16 mode)
 217 {
 218   SRB_ExecSCSICmd16 *lpPRB = 0;
 219   struct sg_header *sg_hd, *sg_reply_hdr;
 220   int   status;
 221   BYTE *lpBuf = 0;
 222   int   in_len, out_len;
 223   int   error_code = 0;
 224   int   fd;
 225
 226   switch (mode)
 227   {
 228       case ASPI_DOS:
 229         if (ptrPRB)
 230             lpPRB = (SRB_ExecSCSICmd16 *)DOSMEM_MapRealToLinear(ptrPRB);
 231         break;
 232       case ASPI_WIN16:
 233         lpPRB = PTR_SEG_TO_LIN(ptrPRB);
 234         break;
 235   }
 236
 237   ASPI_DebugPrintCmd(lpPRB, mode);
 238
 239   fd = ASPI_OpenDevice16(lpPRB);
 240   if (fd == -1) {
 241       WARN("Failed: could not open device. Device permissions !?\n");
 242       lpPRB->SRB_Status = SS_ERR;
 243       return SS_ERR;
 244   }
 245
 246   sg_hd = NULL;
 247   sg_reply_hdr = NULL;
 248
 249   lpPRB->SRB_Status = SS_PENDING;
 250
 251   switch (mode)
 252   {
 253       case ASPI_DOS:
 254         /* translate real mode address */
 255         if (ptrPRB)
 256             lpBuf = (BYTE *)DOSMEM_MapRealToLinear((UINT)lpPRB->SRB_BufPointer);
 257         break;
 258       case ASPI_WIN16:
 259         lpBuf = PTR_SEG_TO_LIN(lpPRB->SRB_BufPointer);
 260         break;
 261   }
 262
 263   if (!lpPRB->SRB_CDBLen) {
 264       WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
 265       lpPRB->SRB_Status = SS_ERR;
 266       return SS_ERR;
 267   }
 268
 269   /* build up sg_header + scsi cmd */
 270   if (HOST_TO_TARGET(lpPRB)) {
 271     /* send header, command, and then data */
 272     in_len = SCSI_OFF + lpPRB->SRB_CDBLen + lpPRB->SRB_BufLen;
 273     sg_hd = (struct sg_header *) malloc(in_len);
 274     memset(sg_hd, 0, SCSI_OFF);
 275     memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
 276     if (lpPRB->SRB_BufLen) {
 277       memcpy(((BYTE *) sg_hd) + SCSI_OFF + lpPRB->SRB_CDBLen, lpBuf, lpPRB->SRB_BufLen);
 278     }
 279   }
 280   else {
 281     /* send header and command - no data */
 282     in_len = SCSI_OFF + lpPRB->SRB_CDBLen;
 283     sg_hd = (struct sg_header *) malloc(in_len);
 284     memset(sg_hd, 0, SCSI_OFF);
 285     memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
 286   }
 287
 288   if (TARGET_TO_HOST(lpPRB)) {
 289     out_len = SCSI_OFF + lpPRB->SRB_BufLen;
 290     sg_reply_hdr = (struct sg_header *) malloc(out_len);
 291     memset(sg_reply_hdr, 0, SCSI_OFF);
 292     sg_hd->reply_len = out_len;
 293   }
 294   else {
 295     out_len = SCSI_OFF;
 296     sg_reply_hdr = (struct sg_header *) malloc(out_len);
 297     memset(sg_reply_hdr, 0, SCSI_OFF);
 298     sg_hd->reply_len = out_len;
 299   }
 300
 301   status = write(fd, sg_hd, in_len);
 302   if (status < 0 || status != in_len) {
 303       int save_error = errno;
 304
 305     WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status);
 306     if (status < 0) {
 307                 if (save_error == ENOMEM) {
 308             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");
 309         }
 310 #ifdef HAVE_STRERROR
 311                 WARN("error:= '%s'\n", strerror(save_error));
 312 #else
 313                 WARN("error:= %d\n", save_error);
 314 #endif
 315     }
 316     goto error_exit;
 317   }
 318
 319   status = read(fd, sg_reply_hdr, out_len);
 320   if (status < 0 || status != out_len) {
 321     WARN("not enough bytes read from scsi device%d\n", status);
 322     goto error_exit;
 323   }
 324
 325   if (sg_reply_hdr->result != 0) {
 326     error_code = sg_reply_hdr->result;
 327     WARN("reply header error (%d)\n", sg_reply_hdr->result);
 328     goto error_exit;
 329   }
 330
 331   if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) {
 332     memcpy(lpBuf, sg_reply_hdr + 1, lpPRB->SRB_BufLen);
 333   }
 334
 335   /* copy in sense buffer to amount that is available in client */
 336   if (lpPRB->SRB_SenseLen) {
 337     int sense_len = lpPRB->SRB_SenseLen;
 338     if (lpPRB->SRB_SenseLen > 16)
 339       sense_len = 16;
 340     memcpy(SENSE_BUFFER(lpPRB), &sg_reply_hdr->sense_buffer[0], sense_len);
 341   }
 342
 343
 344   lpPRB->SRB_Status = SS_COMP;
 345   lpPRB->SRB_HaStat = HASTAT_OK;
 346   lpPRB->SRB_TargStat = STATUS_GOOD;
 347
 348   /* now do posting */
 349
 350   if (ASPI_POSTING(lpPRB) && lpPRB->SRB_PostProc) {
 351     TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
 352     switch (mode)
 353     {
 354       case ASPI_DOS:
 355       {
 356         SEGPTR spPRB = MapLS(lpPRB);
 357
 358         Callbacks->CallASPIPostProc(lpPRB->SRB_PostProc, spPRB);
 359         UnMapLS(spPRB);
 360         break;
 361       }
 362       case ASPI_WIN16:
 363         Callbacks->CallASPIPostProc(lpPRB->SRB_PostProc, ptrPRB);
 364         break;
 365     }
 366   }
 367
 368   free(sg_reply_hdr);
 369   free(sg_hd);
 370   ASPI_DebugPrintResult(lpPRB, mode);
 371   return SS_COMP;
 372
 373 error_exit:
 374   if (error_code == EBUSY) {
 375       lpPRB->SRB_Status = SS_ASPI_IS_BUSY;
 376       TRACE("Device busy\n");
 377   }
 378   else {
 379       WARN("Failed\n");
 380       lpPRB->SRB_Status = SS_ERR;
 381   }
 382
 383   /* I'm not sure exactly error codes work here
 384    * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
 385    */
 386   WARN("error_exit\n");
 387   free(sg_reply_hdr);
 388   free(sg_hd);
 389   return lpPRB->SRB_Status;
 390 }
 391 #endif
 392
 393
 394 /***********************************************************************
 395  *             GetASPISupportInfo16   (WINASPI.1)
 396  */
 397
 398 WORD WINAPI GetASPISupportInfo16()
 399 {
 400 #ifdef linux
 401     TRACE("GETASPISupportInfo16\n");
 402     /* high byte SS_COMP - low byte number of host adapters */
 403     return ((SS_COMP << 8) | HA_Count);
 404 #else
 405     return ((SS_NO_ASPI << 8) | 0);
 406 #endif
 407 }
 408
 409
 410 DWORD ASPI_SendASPICommand(DWORD ptrSRB, UINT16 mode)
 411 {
 412 #ifdef linux
 413   LPSRB16 lpSRB = 0;
 414
 415   switch (mode)
 416   {
 417       case ASPI_DOS:
 418         if (ptrSRB)
 419             lpSRB = (LPSRB16)DOSMEM_MapRealToLinear(ptrSRB);
 420         break;
 421       case ASPI_WIN16:
 422         lpSRB = PTR_SEG_TO_LIN(ptrSRB);
 423         if (ASPIChainFunc)
 424         {
 425             /* This is not the post proc, it's the chain proc this time */
 426             DWORD ret = Callbacks->CallASPIPostProc(ASPIChainFunc, ptrSRB);
 427             if (ret)
 428             {
 429                 lpSRB->inquiry.SRB_Status = SS_INVALID_SRB;
 430                 return ret;
 431             }
 432         }
 433         break;
 434   }
 435
 436   switch (lpSRB->common.SRB_Cmd) {
 437   case SC_HA_INQUIRY:
 438     lpSRB->inquiry.SRB_Status = SS_COMP;       /* completed successfully */
 439     if (lpSRB->inquiry.SRB_55AASignature == 0x55aa) {
 440         TRACE("Extended request detected (Adaptec's ASPIxDOS).\nWe don't support it at the moment.\n");
 441     }
 442     lpSRB->inquiry.SRB_ExtBufferSize = 0x2000; /* bogus value */
 443     lpSRB->inquiry.HA_Count = HA_Count;
 444     lpSRB->inquiry.HA_SCSI_ID = 7;             /* not always ID 7 */
 445     strcat(lpSRB->inquiry.HA_ManagerId, "Wine ASPI16"); /* max 15 chars */
 446     strcat(lpSRB->inquiry.HA_Identifier, "Wine host"); /* FIXME: return host
 447 adapter name */
 448     memset(lpSRB->inquiry.HA_Unique, 0, 16); /* default HA_Unique content */
 449     lpSRB->inquiry.HA_Unique[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
 450     FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB->inquiry.SRB_HaId);
 451     return SS_COMP;
 452   case SC_GET_DEV_TYPE:
 453     FIXME("Not implemented SC_GET_DEV_TYPE\n");
 454     break;
 455   case SC_EXEC_SCSI_CMD:
 456     return ASPI_ExecScsiCmd((DWORD)ptrSRB, mode);
 457     break;
 458   case SC_RESET_DEV:
 459     FIXME("Not implemented SC_RESET_DEV\n");
 460     break;
 461   default:
 462     FIXME("Unknown command %d\n", lpSRB->common.SRB_Cmd);
 463   }
 464 #endif
 465   return SS_INVALID_SRB;
 466 }
 467
 468
 469 /***********************************************************************
 470  *             SendASPICommand16   (WINASPI.2)
 471  */
 472 WORD WINAPI SendASPICommand16(SEGPTR segptr_srb)
 473 {
 474 #ifdef linux
 475     return ASPI_SendASPICommand(segptr_srb, ASPI_WIN16);
 476 #else
 477     return 0;
 478 #endif
 479 }
 480
 481
 482 /***********************************************************************
 483  *             InsertInASPIChain16   (WINASPI.3)
 484  */
 485 WORD WINAPI InsertInASPIChain16(BOOL16 remove, FARPROC16 pASPIChainFunc)
 486 {
 487 #ifdef linux
 488     if (remove == TRUE) /* Remove */
 489     {
 490         if (ASPIChainFunc == pASPIChainFunc)
 491         {
 492             ASPIChainFunc = NULL;
 493             return SS_COMP;
 494         }
 495     }
 496     else
 497     if (remove == FALSE) /* Insert */
 498     {
 499         if (ASPIChainFunc == NULL)
 500         {
 501             ASPIChainFunc = pASPIChainFunc;
 502             return SS_COMP;
 503         }
 504     }
 505 #endif
 506     return SS_ERR;
 507 }
 508
 509
 510 /***********************************************************************
 511  *             GetASPIDLLVersion16   (WINASPI.4)
 512  */
 513
 514 DWORD WINAPI GetASPIDLLVersion16()
 515 {
 516 #ifdef linux
 517         return 2;
 518 #else
 519         return 0;
 520 #endif
 521 }
 522
 523
 524 void WINAPI ASPI_DOS_func(CONTEXT86 *context)
 525 {
 526         WORD *stack = CTX_SEG_OFF_TO_LIN(context, SS_reg(context), ESP_reg(context));
 527         DWORD ptrSRB = *(DWORD *)&stack[2];
 528
 529         ASPI_SendASPICommand(ptrSRB, ASPI_DOS);
 530
 531         /* simulate a normal RETF sequence as required by DPMI CallRMProcFar */
 532         EIP_reg(context) = *(stack++);
 533         CS_reg(context)  = *(stack++);
 534         ESP_reg(context) += 2*sizeof(WORD);
 535 }
 536
 537
 538 /* returns the address of a real mode callback to ASPI_DOS_func() */
 539 void ASPI_DOS_HandleInt(CONTEXT86 *context)
 540 {
 541 #ifdef linux
 542         FARPROC16 *p = (FARPROC16 *)CTX_SEG_OFF_TO_LIN(context, DS_reg(context), EDX_reg(context));
 543         if ((CX_reg(context) == 4) || (CX_reg(context) == 5))
 544         {
 545         *p = DPMI_AllocInternalRMCB(ASPI_DOS_func);
 546         TRACE("allocated real mode proc %p\n", *p);
 547             AX_reg(context) = CX_reg(context);
 548         }
 549         else
 550 #endif
 551         SET_CFLAG(context);
 552 }