git.oblomov.eu Git - wine/blob - 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 "wine/windef16.h"
  15 #include "winreg.h"
  16 #include "aspi.h"
  17 #include "winescsi.h"
  18 #include "wine/winaspi.h"
  19 #include "heap.h"
  20 #include "debugtools.h"
  21 #include "selectors.h"
  22 #include "miscemu.h"
  23 #include "ldt.h"
  24
  25 DEFAULT_DEBUG_CHANNEL(aspi);
  26
  27
  28 /* FIXME!
  29  * 1) Residual byte length reporting not handled
  30  * 2) Make this code re-entrant for multithreading
  31  * 3) Only linux supported so far
  32  */
  33
  34 /* ### start build ### */
  35 extern LONG CALLBACK ASPI_CallTo16_long_l(FARPROC16,SEGPTR);
  36 /* ### stop build ### */
  37
  38 #ifdef linux
  39
  40 static ASPI_DEVICE_INFO *ASPI_open_devices = NULL;
  41
  42 static FARPROC16 ASPIChainFunc = NULL;
  43 static WORD HA_Count = 1; /* host adapter count; FIXME: detect it */
  44
  45 static int
  46 ASPI_OpenDevice16(SRB_ExecSCSICmd16 *prb)
  47 {
  48     HKEY hkey;
  49     int fd;
  50     char        idstr[50];
  51     char        device_str[50];
  52     ASPI_DEVICE_INFO *curr;
  53
  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.
  57      */
  58
  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) {
  63             return curr->fd;
  64         }
  65     }
  66
  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);
  70
  71     device_str[0] = 0;
  72     if (!RegOpenKeyExA( HKEY_LOCAL_MACHINE, idstr, 0, KEY_ALL_ACCESS, &hkey ))
  73     {
  74         DWORD type, count = sizeof(device_str);
  75         if (RegQueryValueExA( hkey, "Device", 0, &type, device_str, &count )) device_str[0] = 0;
  76         RegCloseKey( hkey );
  77     }
  78
  79     if (!device_str[0])
  80     {
  81         TRACE("Trying to open unlisted scsi device %s\n", idstr);
  82         return -1;
  83     }
  84
  85     TRACE("Opening device %s=%s\n", idstr, device_str);
  86
  87     fd = open(device_str, O_RDWR);
  88     if (fd == -1) {
  89         int save_error = errno;
  90         ERR("Error opening device %s, error '%s'\n", device_str, strerror(save_error));
  91         return -1;
  92     }
  93
  94     /* device is now open */
  95     curr = HeapAlloc( GetProcessHeap(), 0, sizeof(ASPI_DEVICE_INFO) );
  96     curr->fd = fd;
  97     curr->hostId = prb->SRB_HaId;
  98     curr->target = prb->SRB_Target;
  99     curr->lun = prb->SRB_Lun;
 100
 101     /* insert new record at beginning of open device list */
 102     curr->next = ASPI_open_devices;
 103     ASPI_open_devices = curr;
 104     return fd;
 105 }
 106
 107
 108 static void
 109 ASPI_DebugPrintCmd(SRB_ExecSCSICmd16 *prb, UINT16 mode)
 110 {
 111   BYTE  cmd;
 112   int   i;
 113   BYTE *cdb;
 114   BYTE *lpBuf = 0;
 115
 116   switch (mode)
 117   {
 118       case ASPI_DOS:
 119         /* translate real mode address */
 120         if (prb->SRB_BufPointer)
 121             lpBuf = PTR_REAL_TO_LIN( SELECTOROF(prb->SRB_BufPointer), OFFSETOF(prb->SRB_BufPointer));
 122         break;
 123       case ASPI_WIN16:
 124         lpBuf = PTR_SEG_TO_LIN(prb->SRB_BufPointer);
 125         break;
 126   }
 127
 128   switch (prb->CDBByte[0]) {
 129   case CMD_INQUIRY:
 130     TRACE("{\n");
 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]);
 136     TRACE("}\n");
 137     break;
 138   case CMD_SCAN_SCAN:
 139     TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
 140     break;
 141   }
 142
 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");
 147   }
 148   else if (HOST_TO_TARGET(prb)) {
 149     TRACE("\tData transfer: Host to target. Length checked.\n");
 150   }
 151   else if (NO_DATA_TRANSFERED(prb)) {
 152     TRACE("\tData transfer: none\n");
 153   }
 154   else {
 155     WARN("\tTransfer by scsi cmd. Length not checked\n");
 156   }
 157
 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];
 171   if (TRACE_ON(aspi))
 172   {
 173       DPRINTF("CDB buffer[");
 174       for (i = 0; i < prb->SRB_CDBLen; i++) {
 175           if (i != 0) DPRINTF(",");
 176           DPRINTF("%02x", *cdb++);
 177       }
 178       DPRINTF("]\n");
 179   }
 180 }
 181
 182 static void
 183 ASPI_PrintSenseArea16(SRB_ExecSCSICmd16 *prb)
 184 {
 185   int   i;
 186   BYTE *cdb;
 187
 188   if (TRACE_ON(aspi))
 189   {
 190       cdb = &prb->CDBByte[0];
 191       DPRINTF("SenseArea[");
 192       for (i = 0; i < prb->SRB_SenseLen; i++) {
 193           if (i) DPRINTF(",");
 194           DPRINTF("%02x", *cdb++);
 195       }
 196       DPRINTF("]\n");
 197   }
 198 }
 199
 200 static void
 201 ASPI_DebugPrintResult(SRB_ExecSCSICmd16 *prb, UINT16 mode)
 202 {
 203   BYTE *lpBuf = 0;
 204
 205   switch (mode)
 206   {
 207       case ASPI_DOS:
 208         /* translate real mode address */
 209         if (prb->SRB_BufPointer)
 210             lpBuf = PTR_REAL_TO_LIN( SELECTOROF(prb->SRB_BufPointer), OFFSETOF(prb->SRB_BufPointer));
 211         break;
 212       case ASPI_WIN16:
 213         lpBuf = PTR_SEG_TO_LIN(prb->SRB_BufPointer);
 214         break;
 215   }
 216
 217   switch (prb->CDBByte[0]) {
 218   case CMD_INQUIRY:
 219     TRACE("Vendor: '%s'\n", lpBuf + INQUIRY_VENDOR);
 220     break;
 221   case CMD_TEST_UNIT_READY:
 222     ASPI_PrintSenseArea16(prb);
 223     break;
 224   }
 225 }
 226
 227 static WORD
 228 ASPI_ExecScsiCmd(DWORD ptrPRB, UINT16 mode)
 229 {
 230   SRB_ExecSCSICmd16 *lpPRB = 0;
 231   struct sg_header *sg_hd, *sg_reply_hdr;
 232   int   status;
 233   BYTE *lpBuf = 0;
 234   int   in_len, out_len;
 235   int   error_code = 0;
 236   int   fd;
 237
 238   switch (mode)
 239   {
 240       case ASPI_DOS:
 241         if (ptrPRB)
 242             lpPRB = PTR_REAL_TO_LIN( SELECTOROF(ptrPRB), OFFSETOF(ptrPRB));
 243         break;
 244       case ASPI_WIN16:
 245         lpPRB = PTR_SEG_TO_LIN(ptrPRB);
 246         break;
 247   }
 248
 249   ASPI_DebugPrintCmd(lpPRB, mode);
 250
 251   fd = ASPI_OpenDevice16(lpPRB);
 252   if (fd == -1) {
 253       WARN("Failed: could not open device. Device permissions !?\n");
 254       lpPRB->SRB_Status = SS_ERR;
 255       return SS_ERR;
 256   }
 257
 258   sg_hd = NULL;
 259   sg_reply_hdr = NULL;
 260
 261   lpPRB->SRB_Status = SS_PENDING;
 262
 263   switch (mode)
 264   {
 265       case ASPI_DOS:
 266         /* translate real mode address */
 267         if (ptrPRB)
 268             lpBuf = PTR_REAL_TO_LIN( SELECTOROF(lpPRB->SRB_BufPointer),
 269                                      OFFSETOF(lpPRB->SRB_BufPointer));
 270         break;
 271       case ASPI_WIN16:
 272         lpBuf = PTR_SEG_TO_LIN(lpPRB->SRB_BufPointer);
 273         break;
 274   }
 275
 276   if (!lpPRB->SRB_CDBLen) {
 277       WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
 278       lpPRB->SRB_Status = SS_ERR;
 279       return SS_ERR;
 280   }
 281
 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);
 291     }
 292   }
 293   else {
 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);
 299   }
 300
 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;
 306   }
 307   else {
 308     out_len = SCSI_OFF;
 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;
 312   }
 313
 314   status = write(fd, sg_hd, in_len);
 315   if (status < 0 || status != in_len) {
 316       int save_error = errno;
 317
 318     WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status);
 319     if (status < 0) {
 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");
 322         }
 323                 WARN("error:= '%s'\n", strerror(save_error));
 324     }
 325     goto error_exit;
 326   }
 327
 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);
 331     goto error_exit;
 332   }
 333
 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);
 337     goto error_exit;
 338   }
 339
 340   if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) {
 341     memcpy(lpBuf, sg_reply_hdr + 1, lpPRB->SRB_BufLen);
 342   }
 343
 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)
 348       sense_len = 16;
 349     memcpy(SENSE_BUFFER(lpPRB), &sg_reply_hdr->sense_buffer[0], sense_len);
 350   }
 351
 352
 353   lpPRB->SRB_Status = SS_COMP;
 354   lpPRB->SRB_HaStat = HASTAT_OK;
 355   lpPRB->SRB_TargStat = STATUS_GOOD;
 356
 357   /* now do posting */
 358
 359   if (ASPI_POSTING(lpPRB) && lpPRB->SRB_PostProc) {
 360     TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
 361     switch (mode)
 362     {
 363       case ASPI_DOS:
 364       {
 365         SEGPTR spPRB = MapLS(lpPRB);
 366
 367         ASPI_CallTo16_long_l(lpPRB->SRB_PostProc, spPRB);
 368         UnMapLS(spPRB);
 369         break;
 370       }
 371       case ASPI_WIN16:
 372         ASPI_CallTo16_long_l(lpPRB->SRB_PostProc, ptrPRB);
 373         break;
 374     }
 375   }
 376
 377   free(sg_reply_hdr);
 378   free(sg_hd);
 379   ASPI_DebugPrintResult(lpPRB, mode);
 380   return SS_COMP;
 381
 382 error_exit:
 383   if (error_code == EBUSY) {
 384       lpPRB->SRB_Status = SS_ASPI_IS_BUSY;
 385       TRACE("Device busy\n");
 386   }
 387   else {
 388       WARN("Failed\n");
 389       lpPRB->SRB_Status = SS_ERR;
 390   }
 391
 392   /* I'm not sure exactly error codes work here
 393    * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
 394    */
 395   WARN("error_exit\n");
 396   free(sg_reply_hdr);
 397   free(sg_hd);
 398   return lpPRB->SRB_Status;
 399 }
 400 #endif
 401
 402
 403 /***********************************************************************
 404  *             GetASPISupportInfo16   (WINASPI.1)
 405  */
 406
 407 WORD WINAPI GetASPISupportInfo16(void)
 408 {
 409 #ifdef linux
 410     TRACE("GETASPISupportInfo16\n");
 411     /* high byte SS_COMP - low byte number of host adapters */
 412     return ((SS_COMP << 8) | HA_Count);
 413 #else
 414     return ((SS_NO_ASPI << 8) | 0);
 415 #endif
 416 }
 417
 418
 419 DWORD ASPI_SendASPICommand(DWORD ptrSRB, UINT16 mode)
 420 {
 421 #ifdef linux
 422   LPSRB16 lpSRB = 0;
 423
 424   switch (mode)
 425   {
 426       case ASPI_DOS:
 427         if (ptrSRB)
 428             lpSRB = PTR_REAL_TO_LIN( SELECTOROF(ptrSRB), OFFSETOF(ptrSRB));
 429         break;
 430       case ASPI_WIN16:
 431         lpSRB = PTR_SEG_TO_LIN(ptrSRB);
 432         if (ASPIChainFunc)
 433         {
 434             /* This is not the post proc, it's the chain proc this time */
 435             DWORD ret = ASPI_CallTo16_long_l(ASPIChainFunc, ptrSRB);
 436             if (ret)
 437             {
 438                 lpSRB->inquiry.SRB_Status = SS_INVALID_SRB;
 439                 return ret;
 440             }
 441         }
 442         break;
 443   }
 444
 445   switch (lpSRB->common.SRB_Cmd) {
 446   case SC_HA_INQUIRY:
 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");
 450     }
 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
 456 adapter name */
 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);
 460     return SS_COMP;
 461   case SC_GET_DEV_TYPE:
 462     FIXME("Not implemented SC_GET_DEV_TYPE\n");
 463     break;
 464   case SC_EXEC_SCSI_CMD:
 465     return ASPI_ExecScsiCmd((DWORD)ptrSRB, mode);
 466     break;
 467   case SC_RESET_DEV:
 468     FIXME("Not implemented SC_RESET_DEV\n");
 469     break;
 470   default:
 471     FIXME("Unknown command %d\n", lpSRB->common.SRB_Cmd);
 472   }
 473 #endif
 474   return SS_INVALID_SRB;
 475 }
 476
 477
 478 /***********************************************************************
 479  *             SendASPICommand16   (WINASPI.2)
 480  */
 481 WORD WINAPI SendASPICommand16(SEGPTR segptr_srb)
 482 {
 483 #ifdef linux
 484     return ASPI_SendASPICommand(segptr_srb, ASPI_WIN16);
 485 #else
 486     return 0;
 487 #endif
 488 }
 489
 490
 491 /***********************************************************************
 492  *             InsertInASPIChain16   (WINASPI.3)
 493  */
 494 WORD WINAPI InsertInASPIChain16(BOOL16 remove, FARPROC16 pASPIChainFunc)
 495 {
 496 #ifdef linux
 497     if (remove == TRUE) /* Remove */
 498     {
 499         if (ASPIChainFunc == pASPIChainFunc)
 500         {
 501             ASPIChainFunc = NULL;
 502             return SS_COMP;
 503         }
 504     }
 505     else
 506     if (remove == FALSE) /* Insert */
 507     {
 508         if (ASPIChainFunc == NULL)
 509         {
 510             ASPIChainFunc = pASPIChainFunc;
 511             return SS_COMP;
 512         }
 513     }
 514 #endif
 515     return SS_ERR;
 516 }
 517
 518
 519 /***********************************************************************
 520  *             GetASPIDLLVersion16   (WINASPI.4)
 521  */
 522
 523 DWORD WINAPI GetASPIDLLVersion16()
 524 {
 525 #ifdef linux
 526         return 2;
 527 #else
 528         return 0;
 529 #endif
 530 }
 531