git.oblomov.eu Git - wine/blob - dlls/winaspi/winaspi16.c

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