Ignore:
Timestamp:
May 15, 2000, 9:02:21 PM (25 years ago)
Author:
sandervl
Message:

PD:Implemented working ASPI

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wnaspi32/winaspi32.cpp

    r987 r3541  
    1414#include "debugtools.h"
    1515
    16 #include "srbos2.h"
    17 #include "odinaspi.h"
     16//#include "srbos2.h"
     17//#include "odinaspi.h"
     18#include "aspilib.h"
    1819//#include "callback.h"
    1920
    2021DEFAULT_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 
    31 static ASPI_DEVICE_INFO *ASPI_open_devices = NULL;
    32 
    33 static int
    34 ASPI_OpenDevice(SRB_ExecSCSICmd *prb)
    35 {
    36     int fd;
    37     char        idstr[20];
    38     char        device_str[50];
    39     ASPI_DEVICE_INFO *curr;
    40 
    41     /* search list of devices to see if we've opened it already.
    42      * There is not an explicit open/close in ASPI land, so hopefully
    43      * keeping a device open won't be a problem.
    44      */
    45 
    46     for (curr = ASPI_open_devices; curr; curr = curr->next) {
    47         if (curr->hostId == prb->SRB_HaId &&
    48             curr->target == prb->SRB_Target &&
    49             curr->lun == prb->SRB_Lun) {
    50             return curr->fd;
    51         }
    52     }
    53 
    54     /* device wasn't cached, go ahead and open it */
    55     sprintf(idstr, "scsi c%1dt%1dd%1d", prb->SRB_HaId, prb->SRB_Target, prb->SRB_Lun);
    56 
    57     if (!PROFILE_GetWineIniString(idstr, "Device", "", device_str, sizeof(device_str))) {
    58         TRACE("Trying to open unlisted scsi device %s\n", idstr);
    59         return -1;
    60     }
    61 
    62     TRACE("Opening device %s=%s\n", idstr, device_str);
    63 
    64     fd = open(device_str, O_RDWR);
    65     if (fd == -1) {
    66         int save_error = errno;
    67 #ifdef HAVE_STRERROR
    68     ERR("Error opening device %s, error '%s'\n", device_str, strerror(save_error));
    69 #else
    70     ERR("Error opening device %s, error %d\n", device_str, save_error);
    71 #endif
    72         return -1;
    73     }
    74 
    75     /* device is now open */
    76     curr = HeapAlloc( SystemHeap, 0, sizeof(ASPI_DEVICE_INFO) );
    77     curr->fd = fd;
    78     curr->hostId = prb->SRB_HaId;
    79     curr->target = prb->SRB_Target;
    80     curr->lun = prb->SRB_Lun;
    81 
    82     /* insert new record at beginning of open device list */
    83     curr->next = ASPI_open_devices;
    84     ASPI_open_devices = curr;
    85     return fd;
    86 }
    87 
    8822
    8923static void
    … …  
    179113}
    180114
     115
    181116static WORD
    182 ASPI_ExecScsiCmd(SRB_ExecSCSICmd *lpPRB)
    183 {
    184   struct sg_header *sg_hd, *sg_reply_hdr;
     117ASPI_ExecScsiCmd( scsiObj *aspi,
     118                  SRB_ExecSCSICmd *lpPRB)
     119{
    185120  int   status;
    186   int   in_len, out_len;
    187121  int   error_code = 0;
    188   int   fd;
     122  LONG rc;
    189123
    190124  ASPI_DebugPrintCmd(lpPRB);
    191125
    192   fd = ASPI_OpenDevice(lpPRB);
    193   if (fd == -1) {
    194       ERR("Failed: could not open device c%01dt%01dd%01d. Device permissions !?\n",
    195           lpPRB->SRB_HaId,lpPRB->SRB_Target,lpPRB->SRB_Lun);
    196       lpPRB->SRB_Status = SS_NO_DEVICE;
    197       return SS_NO_DEVICE;
    198   }
    199 
    200   sg_hd = NULL;
    201   sg_reply_hdr = NULL;
    202 
    203126  lpPRB->SRB_Status = SS_PENDING;
    204127
    205   if (!lpPRB->SRB_CDBLen) {
     128  if (!lpPRB->SRB_CDBLen)
     129  {
    206130      WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
    207131      lpPRB->SRB_Status = SS_ERR;
    … …  
    209133  }
    210134
    211   /* build up sg_header + scsi cmd */
    212   if (HOST_TO_TARGET(lpPRB)) {
    213     /* send header, command, and then data */
    214     in_len = SCSI_OFF + lpPRB->SRB_CDBLen + lpPRB->SRB_BufLen;
    215     sg_hd = (struct sg_header *) malloc(in_len);
    216     memset(sg_hd, 0, SCSI_OFF);
    217     memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
    218     if (lpPRB->SRB_BufLen) {
    219       memcpy(((BYTE *) sg_hd) + SCSI_OFF + lpPRB->SRB_CDBLen, lpPRB->SRB_BufPointer, lpPRB->SRB_BufLen);
    220     }
    221   }
    222   else {
    223     /* send header and command - no data */
    224     in_len = SCSI_OFF + lpPRB->SRB_CDBLen;
    225     sg_hd = (struct sg_header *) malloc(in_len);
    226     memset(sg_hd, 0, SCSI_OFF);
    227     memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
    228   }
    229 
    230   if (TARGET_TO_HOST(lpPRB)) {
    231     out_len = SCSI_OFF + lpPRB->SRB_BufLen;
    232     sg_reply_hdr = (struct sg_header *) malloc(out_len);
    233     memset(sg_reply_hdr, 0, SCSI_OFF);
    234     sg_hd->reply_len = out_len;
    235   }
    236   else {
    237     out_len = SCSI_OFF;
    238     sg_reply_hdr = (struct sg_header *) malloc(out_len);
    239     memset(sg_reply_hdr, 0, SCSI_OFF);
    240     sg_hd->reply_len = out_len;
    241   }
    242 
    243   status = write(fd, sg_hd, in_len);
    244   if (status < 0 || status != in_len) {
    245       int save_error = errno;
    246 
    247     WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status);
    248     if (status < 0) {
    249                 if (save_error == ENOMEM) {
    250             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");
    251         }
    252 #ifdef HAVE_STRERROR
    253                 WARN("error:= '%s'\n", strerror(save_error));
    254 #else
    255                 WARN("error:= %d\n", save_error);
    256 #endif
    257     }
    258     goto error_exit;
    259   }
    260 
    261   status = read(fd, sg_reply_hdr, out_len);
    262   if (status < 0 || status != out_len) {
    263     WARN("not enough bytes read from scsi device%d\n", status);
    264     goto error_exit;
    265   }
    266 
    267   if (sg_reply_hdr->result != 0) {
    268     error_code = sg_reply_hdr->result;
    269     WARN("reply header error (%d)\n", sg_reply_hdr->result);
    270     goto error_exit;
    271   }
    272 
    273   if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) {
    274     memcpy(lpPRB->SRB_BufPointer, sg_reply_hdr + 1, lpPRB->SRB_BufLen);
    275   }
    276 
    277   /* copy in sense buffer to amount that is available in client */
    278   if (lpPRB->SRB_SenseLen) {
    279     int sense_len = lpPRB->SRB_SenseLen;
    280     if (lpPRB->SRB_SenseLen > 16)
    281       sense_len = 16;
    282     memcpy(SENSE_BUFFER(lpPRB), &sg_reply_hdr->sense_buffer[0], sense_len);
    283   }
    284 
    285 
    286   lpPRB->SRB_Status = SS_COMP;
    287   lpPRB->SRB_HaStat = HASTAT_OK;
    288   lpPRB->SRB_TargStat = STATUS_GOOD;
    289 
    290   /* now do posting */
    291 
    292   if (lpPRB->SRB_PostProc) {
    293     if (ASPI_POSTING(lpPRB)) {
    294       TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
    295       (*lpPRB->SRB_PostProc)(lpPRB);
    296     }
    297     else
    298     if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY) {
    299       TRACE("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc);
    300       SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
    301     }
    302   }
    303   free(sg_reply_hdr);
    304   free(sg_hd);
    305   ASPI_DebugPrintResult(lpPRB);
    306   return SS_COMP;
    307 
    308 error_exit:
    309   if (error_code == EBUSY) {
    310       lpPRB->SRB_Status = SS_ASPI_IS_BUSY;
    311       TRACE("Device busy\n");
    312   }
    313   else {
    314       WARN("Failed\n");
    315       lpPRB->SRB_Status = SS_ERR;
    316   }
    317 
    318   /* I'm not sure exactly error codes work here
    319    * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
    320    */
    321   WARN("error_exit\n");
    322   free(sg_reply_hdr);
    323   free(sg_hd);
    324   return lpPRB->SRB_Status;
    325 }
    326 #endif
    327 
    328 // OS/2 ODIN implemetation code
    329 #ifdef _ODIN_H_
    330 
    331 static void
    332 ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
    333 {
    334   BYTE  cmd;
    335   int   i;
    336   BYTE *cdb;
    337 
    338   switch (prb->CDBByte[0]) {
    339   case CMD_INQUIRY:
    340     TRACE("{\n");
    341     TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
    342     TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
    343     TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
    344     TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
    345     TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
    346     TRACE("}\n");
    347     break;
    348   case CMD_SCAN_SCAN:
    349     TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
    350     break;
    351   }
    352 
    353   TRACE("Host Adapter: %d\n", prb->SRB_HaId);
    354   TRACE("Flags: %d\n", prb->SRB_Flags);
    355   if (TARGET_TO_HOST(prb)) {
    356     TRACE("\tData transfer: Target to host. Length checked.\n");
    357   }
    358   else if (HOST_TO_TARGET(prb)) {
    359     TRACE("\tData transfer: Host to target. Length checked.\n");
    360   }
    361   else if (NO_DATA_TRANSFERED(prb)) {
    362     TRACE("\tData transfer: none\n");
    363   }
    364   else {
    365     WARN("\tTransfer by scsi cmd. Length not checked.\n");
    366   }
    367 
    368   TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
    369   TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
    370   TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
    371   TRACE("Target: %d\n", prb->SRB_Target);
    372   TRACE("Lun: %d\n", prb->SRB_Lun);
    373   TRACE("BufLen: %ld\n", prb->SRB_BufLen);
    374   TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
    375   TRACE("BufPtr: %p\n", prb->SRB_BufPointer);
    376   TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
    377   TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
    378   cdb = &prb->CDBByte[0];
    379   cmd = prb->CDBByte[0];
    380   if (TRACE_ON(aspi))
    381   {
    382       DPRINTF("CDB buffer[");
    383       for (i = 0; i < prb->SRB_CDBLen; i++) {
    384           if (i != 0) DPRINTF(",");
    385           DPRINTF("%02x", *cdb++);
    386       }
    387       DPRINTF("]\n");
    388   }
    389 }
    390 
    391 static void
    392 ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
    393 {
    394   int   i;
    395   BYTE *cdb;
    396 
    397   if (TRACE_ON(aspi))
    398   {
    399       cdb = &prb->CDBByte[0];
    400       DPRINTF("SenseArea[");
    401       for (i = 0; i < prb->SRB_SenseLen; i++) {
    402           if (i) DPRINTF(",");
    403           DPRINTF("%02x", *cdb++);
    404       }
    405       DPRINTF("]\n");
    406   }
    407 }
    408 
    409 static void
    410 ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
    411 {
    412 
    413   switch (prb->CDBByte[0]) {
    414   case CMD_INQUIRY:
    415     TRACE("Vendor: '%s'\n", prb->SRB_BufPointer + INQUIRY_VENDOR);
    416     break;
    417   case CMD_TEST_UNIT_READY:
    418     ASPI_PrintSenseArea(prb);
    419     break;
    420   }
    421 }
    422 
    423 
    424 static WORD
    425 ASPI_ExecScsiCmd( PODINASPIDATA pData,
    426                   SRB_ExecSCSICmd *lpPRB)
    427 {
    428   int   status;
    429   int   error_code = 0;
    430   SRBOS2 SRBlock;
    431   LONG rc;
    432 
    433   ASPI_DebugPrintCmd(lpPRB);
    434 
    435   lpPRB->SRB_Status = SS_PENDING;
    436 
    437   if (!lpPRB->SRB_CDBLen)
    438   {
    439       WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
    440       lpPRB->SRB_Status = SS_ERR;
    441       return SS_ERR;
    442   }
    443 
    444135  if(MaxCDBStatus<lpPRB->SRB_CDBLen)
    445136  {
    … …  
    457148
    458149  // copy up to LUN SRBOS2 has no WORD for padding like in WINE
    459   memcpy( &SRBlock,
     150  memcpy( &aspi->SRBlock,
    460151          lpPRB,
    461152          6* sizeof(BYTE) + sizeof(DWORD));
    462   SRBlock.flags |= SRB_Post;
    463   SRBlock.u.cmd.sense_len = 32;                    // length of sense buffer
    464   SRBlock.u.cmd.data_ptr  = NULL;                  // pointer to data buffer
    465   SRBlock.u.cmd.link_ptr  = NULL;                  // pointer to next SRB
    466   SRBlock.u.cmd.cdb_len   = lpPRB->SRB_CDBLen;     // SCSI command length
    467   memcpy( &SRBlock.u.cmd.cdb_st[0],
     153  aspi->SRBlock.flags |= SRB_Post;
     154  aspi->SRBlock.u.cmd.sense_len = 32;                    // length of sense buffer
     155  aspi->SRBlock.u.cmd.data_ptr  = NULL;                  // pointer to data buffer
     156  aspi->SRBlock.u.cmd.link_ptr  = NULL;                  // pointer to next SRB
     157  aspi->SRBlock.u.cmd.cdb_len   = lpPRB->SRB_CDBLen;     // SCSI command length
     158  memcpy( &aspi->SRBlock.u.cmd.cdb_st[0],
    468159          &lpPRB->CDBByte[0],
    469160          lpPRB->SRB_CDBLen);
    … …  
    474165    if (lpPRB->SRB_BufLen)
    475166    {
    476       memcpy( pData->pvBuffer,
     167      memcpy( aspi->buffer,
    477168              lpPRB->SRB_BufPointer,
    478169              lpPRB->SRB_BufLen);
    … …  
    480171  }
    481172
    482   rc = lSendSRBlock( pData->hfDriver,
    483                      &SRBlock,
    484                      &SRBlock);
     173  rc = aspi->SendSRBlock();
    485174
    486175  if(!rc)
    487176  {
    488     if( fWaitPost(pData->hevPost))
     177    if( aspi->waitPost())
    489178    {
    490179      if (TARGET_TO_HOST(lpPRB))
    … …  
    494183        {
    495184          memcpy( lpPRB->SRB_BufPointer,
    496                   pData->pvBuffer,
     185                  aspi->buffer,
    497186                  lpPRB->SRB_BufLen);
    498187        }
    … …  
    505194          sense_len = 32;
    506195        memcpy( SENSE_BUFFER(lpPRB),
    507                 &SRBlock.u.cmd.cdb_st[SRBlock.u.cmd.cdb_len],
     196                &aspi->SRBlock.u.cmd.cdb_st[aspi->SRBlock.u.cmd.cdb_len],
    508197                sense_len);
    509198      }
    … …  
    526215      }
    527216    }
    528     lpPRB->SRB_Status = SRBlock.status;
    529     lpPRB->SRB_HaStat = SRBlock.u.cmd.ha_status;
    530     lpPRB->SRB_TargStat = SRBlock.u.cmd.target_status;
     217    lpPRB->SRB_Status = aspi->SRBlock.status;
     218    lpPRB->SRB_HaStat = aspi->SRBlock.u.cmd.ha_status;
     219    lpPRB->SRB_TargStat = aspi->SRBlock.u.cmd.target_status;
    531220  }
    532221  else
    … …  
    539228
    540229}
    541 #endif
    542230
    543231/*******************************************************************
    … …  
    551239 *    LOBYTE of LOWORD: # of host adapters.
    552240 */
    553 #ifdef _ODIN_H_
    554241DWORD WINAPI GetASPI32SupportInfo()
    555242{
    556243  LONG rc;
    557   ODINASPIDATA aspi;
     244  scsiObj *aspi;
    558245  ULONG hmtxDriver;
    559246  BYTE bNumDrv;
    … …  
    562249  DWORD dwData;
    563250  DWORD dwSize;
    564   SRBOS2 SRBlock;
    565251  ULONG ulParam, ulReturn;
    566252  BYTE brc;
    … …  
    568254  bNumDrv = 0;
    569255
     256  aspi= new scsiObj();
     257
    570258  if( fGainDrvAccess( FALSE, &hmtxDriver) ) // Do nonblocking call for info
    571259  {
    572     brc = bOpenASPI(&aspi);
    573     if(SS_COMP==brc  )
    574     {
    575       SRBlock.cmd=SRB_Inquiry;                      // host adapter inquiry
    576       SRBlock.ha_num=0;                             // host adapter number
    577       SRBlock.flags=0;                              // no flags set
    578 
    579       rc = lSendSRBlock( aspi.hfDriver,
    580                          &SRBlock,
    581                          &SRBlock);
    582 
    583       if (!rc)
    584       {
    585         bNumDrv = SRBlock.u.inq.num_ha;
    586 
     260   
     261    if(aspi->init(65535)==TRUE)
     262    {
     263       
     264        bNumDrv = aspi->getNumHosts();
     265        brc = SS_COMP;
    587266        rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
    588267                           "Software\\ODIN\\ASPIROUT",
    … …  
    599278          RegCloseKey( hkeyDrvInfo);
    600279        }
    601       }
    602 
    603       fCloseASPI(&aspi);
     280
     281      aspi->close();
     282      delete aspi;
    604283    }
    605284    else
    … …  
    641320  return ((brc << 8) | bNumDrv); /* FIXME: get # of host adapters installed */
    642321}
    643 #else
    644 DWORD WINAPI GetASPI32SupportInfo()
    645 {
    646   return ((SS_COMP << 8) | 1); /* FIXME: get # of host adapters installed */
    647 }
    648 #endif
    649322
    650323/***********************************************************************
    … …  
    653326DWORD __cdecl SendASPI32Command(LPSRB lpSRB)
    654327{
    655 #ifdef linux
    656   switch (lpSRB->common.SRB_Cmd) {
    657   case SC_HA_INQUIRY:
    658     lpSRB->inquiry.SRB_Status = SS_COMP;       /* completed successfully */
    659     lpSRB->inquiry.HA_Count = 1;               /* not always */
    660     lpSRB->inquiry.HA_SCSI_ID = 7;             /* not always ID 7 */
    661     strcat(lpSRB->inquiry.HA_ManagerId, "ASPI for WIN32"); /* max 15 chars, don't change */
    662     strcat(lpSRB->inquiry.HA_Identifier, "Wine host"); /* FIXME: return host adapter name */
    663     memset(lpSRB->inquiry.HA_Unique, 0, 16); /* default HA_Unique content */
    664     lpSRB->inquiry.HA_Unique[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
    665     FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB->inquiry.SRB_HaId);
    666     return SS_COMP;
    667   case SC_GET_DEV_TYPE:
    668     FIXME("Not implemented SC_GET_DEV_TYPE\n");
    669     break;
    670   case SC_EXEC_SCSI_CMD:
    671     return ASPI_ExecScsiCmd(&lpSRB->cmd);
    672     break;
    673   case SC_RESET_DEV:
    674     FIXME("Not implemented SC_RESET_DEV\n");
    675     break;
    676   default:
    677     WARN("Unknown command %d\n", lpSRB->common.SRB_Cmd);
    678   }
    679   return SS_INVALID_SRB;
    680 #else
    681   #ifdef _ODIN_H_
    682 
    683     SRBOS2 SRBlock;
    684328    DWORD dwRC;
    685329    ULONG ulParam, ulReturn;
    686330    BYTE  bRC;
    687     ODINASPIDATA aspi;
     331    scsiObj *aspi;
    688332    ULONG hmtxDriver;
    689333    LONG rc;
    … …  
    691335    if(NULL==lpSRB)
    692336      return SS_INVALID_SRB;  // Not sure what to return here but that is an error
     337
     338    aspi = new scsiObj();
    693339
    694340    // test first for a valid command
    … …  
    704350    if( fGainDrvAccess( TRUE, &hmtxDriver) ) // Block if a SRB is pending
    705351    {
    706       bRC = bOpenASPI( &aspi);
    707       if(SS_COMP==bRC)
     352      if(aspi->init(65535)==TRUE)
    708353      {
    709354        switch (lpSRB->common.SRB_Cmd)
    710355        {
    711356          case SC_HA_INQUIRY:
    712             SRBlock.cmd=SRB_Inquiry;                      // host adapter inquiry
    713             SRBlock.ha_num=lpSRB->inquiry.SRB_HaId;           // host adapter number
    714             SRBlock.flags=0;                              // no flags set
    715 
    716             rc = lSendSRBlock( aspi.hfDriver,
    717                                &SRBlock,
    718                                &SRBlock);
     357            aspi->SRBlock.cmd=SRB_Inquiry;                      // host adapter inquiry
     358            aspi->SRBlock.ha_num=lpSRB->inquiry.SRB_HaId;           // host adapter number
     359            aspi->SRBlock.flags=0;                              // no flags set
     360            rc = aspi->SendSRBlock();
     361
    719362            if (!rc)
    720363            {
    721364              memcpy( lpSRB,
    722                       &SRBlock,
     365                      &aspi->SRBlock,
    723366                      sizeof(SRB_HaInquiry) );
    724               dwRC = SRBlock.status;
     367              dwRC = aspi->SRBlock.status;
    725368            }
    726369            break;
     370
    727371          case SC_GET_DEV_TYPE:
    728             memcpy( &SRBlock,
     372            memcpy( &aspi->SRBlock,
    729373                    lpSRB,
    730374                    sizeof(SRB_GDEVBlock));
    731             SRBlock.flags = 0;
    732 
    733             rc = lSendSRBlock( aspi.hfDriver,
    734                                &SRBlock,
    735                                &SRBlock);
     375            aspi->SRBlock.flags = 0;
     376
     377            rc = aspi->SendSRBlock();
    736378
    737379            if (!rc)
    738380            {
    739381              memcpy( lpSRB,
    740                       &SRBlock,
     382                      &aspi->SRBlock,
    741383                      sizeof(SRB_GDEVBlock) );
     384
    742385              lpSRB->devtype.SRB_Rsvd1 = 0x00;
    743               dwRC = SRBlock.status;
     386              dwRC = aspi->SRBlock.status;
    744387            }
    745388
    746389            break;
    747390          case SC_EXEC_SCSI_CMD:
    748             dwRC = ASPI_ExecScsiCmd( &aspi,
     391            dwRC = ASPI_ExecScsiCmd( aspi,
    749392                                     &lpSRB->cmd);
    750393            break;
     394
    751395          case SC_ABORT_SRB:
    752396            dwRC = SS_INVALID_SRB; // We don't do async ASPI so no way to abort
    753397            break;
     398
    754399          case SC_RESET_DEV:
    755             memset( &SRBlock,
     400            memset( &aspi->SRBlock,
    756401                    0,
    757402                    sizeof(SRBOS2) );
    758             SRBlock.cmd = lpSRB->reset.SRB_Cmd;       /* ASPI command code = SC_RESET_DEV */
    759             SRBlock.status = lpSRB->reset.SRB_Status; /* ASPI command status byte */
    760             SRBlock.ha_num = lpSRB->reset.SRB_HaId;   /* ASPI host adapter number */
    761             SRBlock.flags =  SRB_Post;
    762             SRBlock.u.res.target = lpSRB->reset.SRB_Target; /* Target's SCSI ID */
    763             SRBlock.u.res.lun    = lpSRB->reset.SRB_Lun;    /* Target's LUN number */
    764 
    765             rc = lSendSRBlock( aspi.hfDriver,
    766                                &SRBlock,
    767                                &SRBlock);
     403            aspi->SRBlock.cmd = lpSRB->reset.SRB_Cmd;       /* ASPI command code = SC_RESET_DEV */
     404            aspi->SRBlock.status = lpSRB->reset.SRB_Status; /* ASPI command status byte */
     405            aspi->SRBlock.ha_num = lpSRB->reset.SRB_HaId;   /* ASPI host adapter number */
     406            aspi->SRBlock.flags =  SRB_Post;
     407            aspi->SRBlock.u.res.target = lpSRB->reset.SRB_Target; /* Target's SCSI ID */
     408            aspi->SRBlock.u.res.lun    = lpSRB->reset.SRB_Lun;    /* Target's LUN number */
     409
     410            rc = aspi->SendSRBlock();
    768411
    769412            if (!rc)
    770413            {
    771               fWaitPost( aspi.hevPost );
    772               lpSRB->reset.SRB_Status   = SRBlock.status;
    773               lpSRB->reset.SRB_Flags    = SRBlock.flags;
     414              aspi->waitPost();
     415              lpSRB->reset.SRB_Status   = aspi->SRBlock.status;
     416              lpSRB->reset.SRB_Flags    = aspi->SRBlock.flags;
    774417              lpSRB->reset.SRB_Hdr_Rsvd = 0;
    775418              memset( lpSRB->reset.SRB_Rsvd1,
    776419                      0,
    777420                      12 );
    778               lpSRB->reset.SRB_HaStat   = SRBlock.u.res.ha_status;     /* Host Adapter Status */
    779               lpSRB->reset.SRB_TargStat = SRBlock.u.res.target_status; /* Target Status */
     421              lpSRB->reset.SRB_HaStat   = aspi->SRBlock.u.res.ha_status;     /* Host Adapter Status */
     422              lpSRB->reset.SRB_TargStat = aspi->SRBlock.u.res.target_status; /* Target Status */
    780423              lpSRB->reset.SRB_PostProc = NULL;                  /* Post routine */
    781424              lpSRB->reset.SRB_Rsvd2    = NULL;                  /* Reserved */
    … …  
    783426                      0,
    784427                      32);            /* Reserved */
    785               dwRC = SRBlock.status;
     428              dwRC = aspi->SRBlock.status;
    786429            }
    787430            break;
    788431          } // end switch (lpSRB->common.SRB_Cmd)
    789432
    790         fCloseASPI(&aspi);
     433        aspi->close();
     434        delete aspi;
    791435      }
    792436      else
    … …  
    803447
    804448    return dwRC;
    805 
    806   #else
    807     return SS_INVALID_SRB;
    808   #endif
    809 #endif
    810449}
    811450
    … …  
    814453 *             GetASPI32DLLVersion32   (WNASPI32.3)
    815454 */
    816 
    817455DWORD WINAPI GetASPI32DLLVersion()
    818456{
    819 #ifdef linux
    820457  return (DWORD)1;
    821 #else
    822   #ifdef _ODIN_H_
    823     return (DWORD)1;
    824   #else
    825     return (DWORD)0;
    826   #endif
    827 #endif
    828 }
    829 
     458}
     459
Note: See TracChangeset for help on using the changeset viewer.