Changeset 4265 for trunk/src


Ignore:
Timestamp:
Sep 15, 2000, 3:25:50 PM (25 years ago)
Author:
sandervl
Message:

open + init aspirout during dll load

Location:
trunk/src/wnaspi32
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wnaspi32/aspilib.cpp

    r4260 r4265  
    1 /* $Id: aspilib.cpp,v 1.4 2000-09-14 19:09:16 sandervl Exp $ */
     1/* $Id: aspilib.cpp,v 1.5 2000-09-15 13:25:46 sandervl Exp $ */
    22/*
    33 *  ASPI Router Library
    … …  
    2121#include     <stdio.h>
    2222#include     <misc.h>
    23 #include "aspilib.h"
     23#include     "aspilib.h"
     24
     25#define WNASPI32_MUTEX_NAME "\\SEM32\\ODIN\\ASPIROUT"
    2426
    2527//***************************************************************************
    … …  
    3032//*                                                                         *
    3133//***************************************************************************
    32 scsiObj::scsiObj() : buffer(NULL)
     34scsiObj::scsiObj() : buffer(NULL), hmtxDriver(0)
    3335{
    3436   memset(&SRBlock, 0, sizeof(SRBlock));
    … …  
    202204BOOL scsiObj::init(ULONG bufsize)
    203205{
    204   BOOL  success;
    205   ULONG rc;
    206 
    207   rc = DosAllocMem(&buffer, bufsize, OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
    208   if (rc) return FALSE;
    209   success=openDriver();                         // call openDriver member function
    210   if (!success) return FALSE;
    211   success=initSemaphore();                      // call initSemaphore member function
    212   if (!success) return FALSE;
    213 
    214   success=initBuffer();
    215 
    216   return TRUE;
     206  BOOL   success;
     207  APIRET rc;
     208
     209
     210   rc = DosCreateMutexSem(WNASPI32_MUTEX_NAME, (HMTX*)&hmtxDriver,
     211                          0, TRUE);
     212   if(rc == ERROR_DUPLICATE_NAME) {
     213        rc = DosOpenMutexSem(WNASPI32_MUTEX_NAME, (HMTX*)&hmtxDriver);
     214   }
     215   if(rc != NO_ERROR) {
     216        dprintf(("scsiObj::init: DosCreate/OpenMutexSem failed! (rc=%d)", rc));
     217        return FALSE;
     218   }
     219
     220   rc = DosAllocMem(&buffer, bufsize, OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
     221   if (rc) return FALSE;
     222   success=openDriver();                         // call openDriver member function
     223   if (!success) return FALSE;
     224   success=initSemaphore();                      // call initSemaphore member function
     225   if (!success) return FALSE;
     226
     227   success=initBuffer();
     228 
     229   return TRUE;
    217230}
    218231
    … …  
    239252  if (!success)
    240253  {
    241     printf("closeSemaphore() unsuccessful.\n");
     254    dprintf(("scsiObj::close: closeSemaphore() unsuccessful."));
    242255    return FALSE;
    243256  }
    … …  
    245258  if (!success)
    246259  {
     260    dprintf(("scsiObj::close: closeDriver() unsucessful."));
    247261    return FALSE;
    248     printf("closeDriver() unsucessful.\n");
    249262  }
    250263  rc = DosFreeMem(buffer);
    251264  if (rc)
    252265  {
    253     printf("DosFreeMem unsuccessful. return code: %ld\n", rc);
     266    dprintf(("scsiObj::close: DosFreeMem unsuccessful. return code: %ld", rc));
    254267    return FALSE;
    255268  }
     269  if(hmtxDriver) {
     270        rc = DosCloseMutexSem((HMTX)hmtxDriver);
     271        if(rc != NO_ERROR) {
     272                dprintf(("scsiObj::close: DosCloseMutexSem unsuccessful. return code: %ld", rc));
     273                return FALSE;
     274        }
     275  }
     276
    256277  return TRUE;
    257278}
    … …  
    451472//***************************************************************************
    452473//***************************************************************************
    453 BOOL fGainDrvAccess( BOOL fWait,
    454                      ULONG *phSem)
    455 {
    456   ULONG rc;
    457   rc = DosCreateMutexSem ( "\\SEM32\\ODIN\\ASPIROUT",
    458                            (HMTX*)phSem,
    459                            0,
    460                            TRUE);
    461   if(NO_ERROR==rc)
    462     return TRUE;
    463   if((ERROR_DUPLICATE_NAME!=rc)||(!fWait))
    464     return FALSE;
    465   rc = DosOpenMutexSem ( "\\SEM32\\ODIN\\ASPIROUT",
    466                          (HMTX*)phSem);
    467   if(NO_ERROR!=rc)
    468     return FALSE;
    469 
    470   rc = DosRequestMutexSem( (HMTX)(*phSem),
    471                            SEM_INDEFINITE_WAIT);
    472 
    473   if(NO_ERROR!=rc)
    474     return FALSE;
    475 
    476   return TRUE;
    477 }
    478 //***************************************************************************
    479 //***************************************************************************
    480 BOOL fReleaseDrvAccess(ULONG hSem)
    481 {
    482   ULONG rc;
    483   BOOL frc = TRUE;
    484 
    485   rc = DosReleaseMutexSem((HMTX)hSem);
    486   if(NO_ERROR!=rc)
    487     frc=FALSE;
    488 
    489   rc = DosCloseMutexSem((HMTX)hSem);
    490   if(NO_ERROR!=rc)
    491     frc=FALSE;
    492 
    493   return frc;
    494 }
     474BOOL scsiObj::access(BOOL fWait)
     475{
     476 APIRET rc;
     477
     478  if(!fWait) {
     479        rc = DosRequestMutexSem((HMTX) hmtxDriver, SEM_INDEFINITE_WAIT);
     480  }
     481  else  rc = DosRequestMutexSem((HMTX) hmtxDriver, 100);
     482
     483  if(rc != NO_ERROR) {
     484        dprintf(("scsiObj::access: DosRequestMutexSem failed with rc = %d", rc));
     485        return FALSE;
     486  }
     487  return TRUE;
     488}
     489//***************************************************************************
     490//***************************************************************************
     491BOOL scsiObj::release()
     492{
     493  APIRET rc;
     494
     495  rc = DosReleaseMutexSem((HMTX)hmtxDriver);
     496  if(rc != NO_ERROR) {
     497        dprintf(("scsiObj::access: DosReleaseMutexSem failed with rc = %d", rc));
     498        return FALSE;
     499  }
     500
     501  return TRUE;
     502}
     503//***************************************************************************
     504//***************************************************************************

  • trunk/src/wnaspi32/aspilib.h

    r3564 r4265  
    2828    BOOL        closeDriver();
    2929    BOOL        initBuffer();
     30    ULONG       hmtxDriver;
    3031
    3132  public:
    … …  
    5051    ULONG       SendSRBlock(VOID);
    5152    ULONG       getNumHosts();
     53    BOOL        access(BOOL fWait);
     54    BOOL        release();
     55
    5256
    5357    SRBOS2      SRBlock;                // SCSI Request Block
    … …  
    5660};
    5761
    58 
    59 extern "C"
    60 {
    61   BOOL fGainDrvAccess( BOOL fWait, ULONG *phSem);
    62   BOOL fReleaseDrvAccess(ULONG hSem);
    63 }
    64 
     62extern scsiObj *aspi;
    6563
    6664#endif // _ASPILIB_H_

  • trunk/src/wnaspi32/makefile

    r3864 r4265  
    1 # $Id: makefile,v 1.10 2000-07-19 19:05:27 sandervl Exp $
     1# $Id: makefile,v 1.11 2000-09-15 13:25:49 sandervl Exp $
    22
    33#
    … …  
    2727$(OBJDIR)\winaspi32.obj \
    2828$(OBJDIR)\wnaspi32rsrc.obj \
    29 $(PDWIN32_LIB)\dllentry.obj
     29$(OBJDIR)\initterm.obj
    3030
    3131

  • trunk/src/wnaspi32/winaspi32.cpp

    r4260 r4265  
    1 /* $Id: winaspi32.cpp,v 1.8 2000-09-14 19:09:17 sandervl Exp $ */
     1/* $Id: winaspi32.cpp,v 1.9 2000-09-15 13:25:50 sandervl Exp $ */
    22/*
    33 * WNASPI routines
    … …  
    2828//#include "callback.h"
    2929
     30#ifdef DEBUG
     31#define DEBUG_BUFFER
     32#endif
     33
    3034DEFAULT_DEBUG_CHANNEL(aspi)
    3135ODINDEBUGCHANNEL(WNASPI32)
    … …  
    8084  cdb = &prb->CDBByte[0];
    8185  cmd = prb->CDBByte[0];
    82   if (TRACE_ON(aspi))
    83   {
    84       DPRINTF("CDB buffer[");
     86#ifdef DEBUG_BUFFER
     87      dprintfNoEOL(("CDB buffer["));
    8588      for (i = 0; i < prb->SRB_CDBLen; i++) {
    86           if (i != 0) DPRINTF(",");
    87           DPRINTF("%02x", *cdb++);
    88       }
    89       DPRINTF("]\n");
    90   }
     89          if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
     90          else        dprintfNoEOL(("0x%02x", *cdb++));
     91      }
     92      dprintfNoEOL(("]\n"));
     93#endif
    9194}
    9295
    … …  
    178181              lpPRB->SRB_BufPointer,
    179182              lpPRB->SRB_BufLen);
     183
     184#ifdef DEBUG_BUFFER
     185      char *cdb = (char *)lpPRB->SRB_BufPointer;
     186      dprintfNoEOL(("Write SRB buffer["));
     187      for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
     188          if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
     189          else        dprintfNoEOL(("0x%02x", *cdb++));
     190      }
     191      dprintfNoEOL(("]\n"));
     192#endif
    180193    }
    181194  }
    … …  
    195208                  aspi->buffer,
    196209                  lpPRB->SRB_BufLen);
     210#ifdef DEBUG_BUFFER
     211      char *cdb = (char *)lpPRB->SRB_BufPointer;
     212      dprintfNoEOL(("Read SRB buffer["));
     213      for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
     214          if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
     215          else        dprintfNoEOL(("0x%02x", *cdb++));
     216      }
     217      dprintfNoEOL(("]\n"));
     218#endif
     219
    197220        }
    198221      }
    … …  
    251274{
    252275  LONG rc;
    253   scsiObj *aspi;
    254   ULONG hmtxDriver;
    255276  BYTE bNumDrv;
    256277  HKEY hkeyDrvInfo;
    … …  
    263284  bNumDrv = 0;
    264285
    265   aspi = new scsiObj();
    266 
    267   if( fGainDrvAccess( FALSE, &hmtxDriver) ) // Do nonblocking call for info
    268   {
    269 
    270     if(aspi->init(65535)==TRUE)
    271     {
    272 
     286  if(aspi->access(FALSE)) //'non-blocking' call
     287  {
    273288        bNumDrv = aspi->getNumHosts();
    274289        brc = SS_COMP;
    … …  
    287302          RegCloseKey( hkeyDrvInfo);
    288303        }
    289         aspi->close();
    290     }
    291     else
    292       brc = SS_FAILED_INIT;
    293 
    294     fReleaseDrvAccess( hmtxDriver);
     304        aspi->release();
    295305  }
    296306  else
    … …  
    324334    }
    325335  }
    326   delete aspi;
    327336
    328337  return ((brc << 8) | bNumDrv); /* FIXME: get # of host adapters installed */
    … …  
    337346    ULONG ulParam, ulReturn;
    338347    BYTE  bRC;
    339     scsiObj *aspi;
    340     ULONG hmtxDriver;
    341348    LONG rc;
    342349
    … …  
    357364    }
    358365
    359     aspi = new scsiObj();
    360 
    361366    dwRC = SS_ERR;
    362367
    363     if( fGainDrvAccess( TRUE, &hmtxDriver) ) // Block if a SRB is pending
    364     {
    365       if(aspi->init(65535)==TRUE)
    366       {
     368    if(aspi->access(TRUE)) // Block if a SRB is pending
     369    {
    367370        switch (lpSRB->common.SRB_Cmd)
    368371        {
    … …  
    414417             break;
    415418
    416           } // end switch (lpSRB->common.SRB_Cmd)
    417 
    418       }
    419       else
    420       {
    421         dwRC = bRC;
    422       }
    423 
    424       fReleaseDrvAccess( hmtxDriver);
    425       aspi->close();
     419        } // end switch (lpSRB->common.SRB_Cmd)
     420
     421        aspi->release();
    426422    }
    427423    else
    428424    {
    429       dwRC = SS_NO_ASPI;
    430     }
    431     delete aspi;
     425        dwRC = SS_NO_ASPI;
     426    }
    432427
    433428    return dwRC;
Note: See TracChangeset for help on using the changeset viewer.