Changeset 8601 for trunk/src


Ignore:
Timestamp:
Jun 8, 2002, 1:42:04 PM (23 years ago)
Author:
sandervl
Message:

os2cdrom.dmd rewrite

Location:
trunk/src/wnaspi32
Files:
13 added
2 deleted
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wnaspi32/initwnaspi32.cpp

    r8134 r8601  
    1 /* $Id: initwnaspi32.cpp,v 1.6 2002-03-28 16:53:47 sandervl Exp $
     1/* $Id: initwnaspi32.cpp,v 1.7 2002-06-08 11:42:02 sandervl Exp $
    22 *
    33 * DLL entry point
    … …  
    3737#include <misc.h>       /*PLF Wed  98-03-18 23:18:15*/
    3838#include <initdll.h>
    39 #include "aspilib.h"
    4039#include <custombuild.h>
     40#include "cdio.h"
    4141
    4242extern "C" {
    … …  
    4444 extern DWORD wnaspi32_PEResTab;
    4545}
    46 scsiObj *aspi = NULL;
    4746static HMODULE dllHandle = 0;
    48 static BOOL fDisableASPI = FALSE;
     47BOOL fASPIAvailable = TRUE;
    4948
    5049//******************************************************************************
    … …  
    5352{
    5453   dprintf(("DisableASPI"));
    55    fDisableASPI = TRUE;
     54   fASPIAvailable = FALSE;
    5655}
    5756//******************************************************************************
    … …  
    6362   case DLL_PROCESS_ATTACH:
    6463   {
    65        if(fDisableASPI) return TRUE;
     64       if(fASPIAvailable == FALSE) return TRUE;
    6665
    67        aspi = new scsiObj();
    68        if(aspi == NULL) {
     66       if(OSLibCdIoInitialize() == FALSE) {
    6967           dprintf(("WNASPI32: LibMain; can't allocate aspi object! APIs will not work!"));
    7068           // @@@AH 20011020 we shouldn't prevent DLL loading in this case
    … …  
    7270           return TRUE;
    7371       }
    74        if(aspi->init(65535) == FALSE)
    75        {
    76            delete aspi;
    77            aspi = NULL;
    78            dprintf(("WNASPI32: LibMain; can't init aspi object!"));
    79            // @@@20011026 and also in this case we shouldn't prevent DLL loading...
    80            return TRUE;
    81        }
    82        dprintf(("WNASPI32: LibMain; aspi object created successfully"));
     72       fASPIAvailable = TRUE;
     73       dprintf(("WNASPI32: LibMain; os2cdrom.dmd ASPI interface available"));
    8374       return TRUE;
    8475   }
    … …  
    8980
    9081   case DLL_PROCESS_DETACH:
    91        if(aspi) {
    92            aspi->close();
    93            delete aspi;
    94            aspi = NULL;
    95        }
     82       OSLibCdIoTerminate();
    9683       return TRUE;
    9784   }

  • trunk/src/wnaspi32/makefile

    r7063 r8601  
    1 # $Id: makefile,v 1.14 2001-10-15 17:06:19 sandervl Exp $
     1# $Id: makefile,v 1.15 2002-06-08 11:42:02 sandervl Exp $
    22
    33#
    … …  
    1919#
    2020OBJS = \
    21 $(OBJDIR)\aspilib.obj \
    2221$(OBJDIR)\winaspi32.obj \
     22$(OBJDIR)\cdio.obj \
    2323$(OBJDIR)\wnaspi32rsrc.obj \
    2424$(OBJDIR)\initwnaspi32.obj \
    … …  
    3232$(ODIN32_LIB)/kernel32.lib \
    3333$(ODIN32_LIB)/$(ODINCRT).lib \
    34 $(ODIN32_LIB)/advapi32.lib \
    3534OS2386.LIB \
    3635$(RTLLIB_O)

  • trunk/src/wnaspi32/winaspi32.cpp

    r7143 r8601  
    1 /* $Id: winaspi32.cpp,v 1.13 2001-10-20 09:49:01 achimha Exp $ */
     1/* $Id: winaspi32.cpp,v 1.14 2002-06-08 11:42:02 sandervl Exp $ */
    22/*
    33 * WNASPI routines
    … …  
    55 * Copyright 1999 Markus Montkowski
    66 * Copyright 2000 Przemyslaw Dobrowolski
     7 * Copyright 2002 Sander van Leeuwen
     8 *
     9 * Partly based on WINE code (dlls\winaspi\winaspi32.c)
     10 *
     11 * Copyright 1997 Bruce Milner
     12 * Copyright 1998 Andreas Mohr
    713 *
    814 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    1117#include <os2win.h>
    1218#include <stdlib.h>
     19#include <string.h>
    1320#include <sys/types.h>
    1421#include <sys/stat.h>
    … …  
    1926#include "aspi.h"
    2027#include "wnaspi32.h"
    21 #include <winreg.h>
    2228#include "options.h"
    2329#include "debugtools.h"
    24 
    25 //#include "srbos2.h"
    26 //#include "odinaspi.h"
    27 #include "aspilib.h"
    28 //#include "callback.h"
     30#include "cdio.h"
    2931
    3032#ifdef DEBUG
    … …  
    3234#endif
    3335
    34 DEFAULT_DEBUG_CHANNEL(aspi)
    35 ODINDEBUGCHANNEL(WNASPI32)
    36 
    37 static void
    38 ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
     36
     37#ifdef DEBUG
     38//*****************************************************************************
     39//*****************************************************************************
     40static void ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
    3941{
    4042  BYTE  cmd;
    … …  
    9395#endif
    9496}
    95 
    96 static void
    97 ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
     97//*****************************************************************************
     98//*****************************************************************************
     99static void ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
    98100{
    99101  int   i;
    100102  BYTE *cdb;
    101103
    102   if (TRACE_ON(aspi))
    103   {
    104104      cdb = &prb->CDBByte[0];
    105105      DPRINTF("SenseArea[");
    … …  
    109109      }
    110110      DPRINTF("]\n");
    111   }
    112 }
    113 
    114 static void
    115 ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
     111}
     112//*****************************************************************************
     113//*****************************************************************************
     114static void ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
    116115{
    117116
    … …  
    126125  dprintf(("Result code: %x", prb->SRB_Status));
    127126}
    128 
    129 
    130 static WORD ASPI_ExecScsiCmd( scsiObj *aspi, SRB_ExecSCSICmd *lpPRB)
    131 {
    132   int   status;
    133   int   error_code = 0;
    134   LONG rc;
     127#else
     128#define ASPI_DebugPrintResult(a)
     129#define ASPI_DebugPrintCmd(a)
     130#endif
     131
     132//*****************************************************************************
     133// Posting must be done in such a way that as soon as the SRB_Status is set
     134// we don't touch the SRB anymore because it could possibly be freed
     135// if the app is doing ASPI polling
     136//*****************************************************************************
     137static DWORD WNASPI32_DoPosting( SRB_ExecSCSICmd *lpPRB, DWORD status )
     138{
     139        void (* CDECL SRB_PostProc)(SRB_ExecSCSICmd *);
     140        BYTE SRB_Flags = lpPRB->SRB_Flags;
     141        if( status == SS_PENDING )
     142        {
     143                dprintf(("Tried posting SS_PENDING\n"));
     144                return SS_PENDING;
     145        }
     146    *((DWORD *)&SRB_PostProc) = (DWORD)lpPRB->SRB_PostProc;
     147
     148        lpPRB->SRB_Status = status;
     149        /* lpPRB is NOT safe, it could be freed in another thread */
     150
     151        if (SRB_PostProc)
     152        {
     153                if (SRB_Flags & 0x1)
     154                {
     155                        dprintf(("Post Routine (%lx) called\n", (DWORD) SRB_PostProc));
     156                        /* Even though lpPRB could have been freed by
     157                         * the program.. that's unlikely if it planned
     158                         * to use it in the PostProc
     159                         */
     160                        (*SRB_PostProc)(lpPRB);
     161                }
     162                else if (SRB_Flags & SRB_EVENT_NOTIFY) {
     163                        dprintf(("Setting event %04x\n", (HANDLE)SRB_PostProc));
     164                        SetEvent((HANDLE)SRB_PostProc);
     165                }
     166        }
     167        return lpPRB->SRB_Status;
     168}
     169//*****************************************************************************
     170//*****************************************************************************
     171static WORD ASPI_ExecScsiCmd(SRB_ExecSCSICmd *lpPRB)
     172{
     173    int   status;
     174    int   error_code = 0;
     175    LONG  rc;
     176    CDIO_CMD_BUFFER cdiocmd;
     177
     178    HCDIO hCDIO = OSLibCdIoGetDevice(lpPRB->SRB_HaId, lpPRB->SRB_Target, lpPRB->SRB_Lun);
     179    if(hCDIO == -1) {
     180        dprintf(("Failed: invalid device %d %d %d", lpPRB->SRB_HaId, lpPRB->SRB_Target, lpPRB->SRB_Lun));
     181        return WNASPI32_DoPosting( lpPRB, SS_NO_DEVICE );
     182    }
    135183
    136184  /* FIXME: hackmode */
    137185#define MAKE_TARGET_TO_HOST(lpPRB) \
    138186        if (!TARGET_TO_HOST(lpPRB)) { \
    139             WARN("program was not sending target_to_host for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags); \
    140             lpPRB->SRB_Flags |= 8; \
     187            dprintf(("program was not sending target_to_host for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags)); \
     188            lpPRB->SRB_Flags |= SRB_DIR_IN; \
    141189        }
    142190#define MAKE_HOST_TO_TARGET(lpPRB) \
    143191        if (!HOST_TO_TARGET(lpPRB)) { \
    144             WARN("program was not sending host_to_target for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags); \
    145             lpPRB->SRB_Flags |= 0x10; \
     192            dprintf(("program was not sending host_to_target for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags)); \
     193            lpPRB->SRB_Flags |= SRB_DIR_OUT; \
    146194        }
    147   switch (lpPRB->CDBByte[0]) {
    148   case 0x12: /* INQUIRY */
    149   case 0x5a: /* MODE_SENSE_10 */
    150   case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
    151   case 0xad: /* READ DVD STRUCTURE MMC-2 */
    152         MAKE_TARGET_TO_HOST(lpPRB)
    153         break;
    154   case 0xa3: /* SEND KEY (DVD) MMC-2 */
    155         MAKE_HOST_TO_TARGET(lpPRB)
    156         break;
    157   default:
    158         if ((((lpPRB->SRB_Flags & 0x18) == 0x00) ||
    159              ((lpPRB->SRB_Flags & 0x18) == 0x18)
    160             ) && lpPRB->SRB_BufLen
    161         ) {
    162             FIXME("command 0x%02x, no data transfer specified, but buflen is %ld!!!\n",lpPRB->CDBByte[0],lpPRB->SRB_BufLen);
    163         }
    164         break;
    165   }
    166 
    167   ASPI_DebugPrintCmd(lpPRB);
    168 
    169   lpPRB->SRB_Status = SS_PENDING;
    170 
    171   if (!lpPRB->SRB_CDBLen)
    172   {
    173       dprintf(("Failed: lpPRB->SRB_CDBLen = 0."));
    174       lpPRB->SRB_Status = SS_ERR;
    175       return SS_ERR;
    176   }
    177 
    178   if(MaxCDBStatus<lpPRB->SRB_CDBLen)
    179   {
    180     dprintf(("Failed: lpPRB->SRB_CDBLen > 64."));
    181     lpPRB->SRB_Status = SS_ERR;
    182     return SS_ERR;
    183   }
    184 
    185   if(lpPRB->SRB_BufLen>65536)    // Check Max 64k!!
    186   {
    187     dprintf(("Failed: lpPRB->SRB_BufLen > 65536."));
    188     lpPRB->SRB_Status = SS_BUFFER_TO_BIG;
    189     return SS_BUFFER_TO_BIG;
    190   }
    191 
    192   // copy up to LUN SRBOS2 has no WORD for padding like in WINE
    193   memcpy( &aspi->SRBlock,
    194           lpPRB,
    195           6* sizeof(BYTE) + sizeof(DWORD));
    196   aspi->SRBlock.flags |= SRB_Post;
    197   aspi->SRBlock.u.cmd.sense_len = lpPRB->SRB_SenseLen;;   // length of sense buffer
    198   aspi->SRBlock.u.cmd.data_ptr  = NULL;                   // pointer to data buffer
    199   aspi->SRBlock.u.cmd.link_ptr  = NULL;                   // pointer to next SRB
    200   aspi->SRBlock.u.cmd.data_len  = lpPRB->SRB_BufLen;
    201   aspi->SRBlock.u.cmd.cdb_len   = lpPRB->SRB_CDBLen;     // SCSI command length
    202   memcpy( &aspi->SRBlock.u.cmd.cdb_st[0],
    203           &lpPRB->CDBByte[0],
    204           lpPRB->SRB_CDBLen);
    205 
    206   if (HOST_TO_TARGET(lpPRB))
    207   {
    208     // Write: Copy all Data to Communication Buffer
    209     if (lpPRB->SRB_BufLen)
    210     {
    211       memcpy( aspi->buffer,
    212               lpPRB->SRB_BufPointer,
    213               lpPRB->SRB_BufLen);
     195    switch (lpPRB->CDBByte[0]) {
     196    case 0x12: /* INQUIRY */
     197    case 0x5a: /* MODE_SENSE_10 */
     198    case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
     199    case 0xad: /* READ DVD STRUCTURE MMC-2 */
     200            MAKE_TARGET_TO_HOST(lpPRB)
     201            break;
     202    case 0xa3: /* SEND KEY (DVD) MMC-2 */
     203            MAKE_HOST_TO_TARGET(lpPRB)
     204            break;
     205    default:
     206        if ((((lpPRB->SRB_Flags & 0x18) == 0x00) ||
     207                ((lpPRB->SRB_Flags & 0x18) == 0x18)
     208                ) && lpPRB->SRB_BufLen
     209            ) {
     210                dprintf(("command 0x%02x, no data transfer specified, but buflen is %ld!!!\n",lpPRB->CDBByte[0],lpPRB->SRB_BufLen));
     211            }
     212            break;
     213    }
     214
     215    ASPI_DebugPrintCmd(lpPRB);
     216
     217    lpPRB->SRB_Status = SS_PENDING;
     218
     219    if (!lpPRB->SRB_CDBLen)
     220    {
     221        dprintf(("Failed: lpPRB->SRB_CDBLen = 0."));
     222        return WNASPI32_DoPosting( lpPRB, SS_INVALID_SRB );
     223    }
     224
     225    if(MAX_CDBLEN < lpPRB->SRB_CDBLen)
     226    {
     227        dprintf(("Failed: lpPRB->SRB_CDBLen > 64."));
     228        return WNASPI32_DoPosting( lpPRB, SS_INVALID_SRB );
     229    }
     230
     231    if(lpPRB->SRB_BufLen > 65536)    // Check Max 64k!!
     232    {
     233        dprintf(("Failed: lpPRB->SRB_BufLen > 65536."));
     234        return WNASPI32_DoPosting( lpPRB, SS_BUFFER_TO_BIG );
     235    }
     236
     237    memset(&cdiocmd, 0, sizeof(cdiocmd));
     238
     239    if(lpPRB->SRB_Flags & SRB_DIR_IN) {
     240        cdiocmd.flDirection |= CMDDIR_INPUT;
     241    }
     242    if(lpPRB->SRB_Flags & SRB_DIR_OUT) {
     243        cdiocmd.flDirection |= CMDDIR_OUTPUT;
     244    }
     245
     246    cdiocmd.cbCDB = lpPRB->SRB_CDBLen;
     247    memcpy(cdiocmd.arCDB, lpPRB->CDBByte, lpPRB->SRB_CDBLen);
    214248
    215249#ifdef DEBUG_BUFFER
    216       char *cdb = (char *)lpPRB->SRB_BufPointer;
    217       dprintfNoEOL(("Write SRB buffer["));
    218       for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
    219           if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
    220           else        dprintfNoEOL(("0x%02x", *cdb++));
    221       }
    222       dprintfNoEOL(("]\n"));
     250    if(lpPRB->SRB_Flags & SRB_DIR_OUT) {
     251        char *cdb = (char *)lpPRB->SRB_BufPointer;
     252        dprintfNoEOL(("Write SRB buffer["));
     253        for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
     254            if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
     255            else        dprintfNoEOL(("0x%02x", *cdb++));
     256        }
     257        dprintfNoEOL(("]\n"));
     258    }
    223259#endif
    224     }
    225   }
    226 
    227   rc = aspi->SendSRBlock();
    228 
    229   if(!rc)
    230   {
    231     if( aspi->waitPost())
    232     {
    233       if (TARGET_TO_HOST(lpPRB))
    234       {
    235         // Was Read : Copy all Data from Communication Buffer
    236         if (lpPRB->SRB_BufLen)
    237         {
    238           memcpy( lpPRB->SRB_BufPointer,
    239                   aspi->buffer,
    240                   lpPRB->SRB_BufLen);
     260
     261    lpPRB->SRB_HaStat   = HASTAT_OK;
     262    lpPRB->SRB_TargStat = HASTAT_OK;
     263
     264    if(OSLibCdIoSendCommand(hCDIO, &cdiocmd, lpPRB->SRB_BufPointer, lpPRB->SRB_BufLen) == FALSE) {
     265        dprintf(("OSLibCdIoSendCommand failed!!"));
     266        return WNASPI32_DoPosting( lpPRB, SS_ERR );
     267    }
     268
     269    if(lpPRB->SRB_SenseLen) {
     270        if(OSLibCdIoRequestSense(hCDIO, SENSE_BUFFER(lpPRB), lpPRB->SRB_SenseLen) == FALSE) {
     271            dprintf(("OSLibCdIoRequestSense failed!!"));
     272            return WNASPI32_DoPosting( lpPRB, SS_ERR );
     273        }
     274    }
    241275#ifdef DEBUG_BUFFER
    242           char *cdb = (char *)lpPRB->SRB_BufPointer;
    243           dprintfNoEOL(("Read SRB buffer["));
    244           for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
    245              if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
    246              else        dprintfNoEOL(("0x%02x", *cdb++));
    247           }
    248           dprintfNoEOL(("]\n"));
     276    if(lpPRB->SRB_Flags & SRB_DIR_IN) {
     277        char *cdb = (char *)lpPRB->SRB_BufPointer;
     278        dprintfNoEOL(("Write SRB buffer["));
     279        for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
     280            if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
     281            else        dprintfNoEOL(("0x%02x", *cdb++));
     282        }
     283        dprintfNoEOL(("]\n"));
     284    }
    249285#endif
    250         }
    251       }
    252 
    253       if (lpPRB->SRB_SenseLen)
    254       {
    255         int sense_len = lpPRB->SRB_SenseLen;
    256         if (lpPRB->SRB_SenseLen > 32)
    257           sense_len = 32;
    258         memcpy( SENSE_BUFFER(lpPRB),
    259                 &aspi->SRBlock.u.cmd.cdb_st[aspi->SRBlock.u.cmd.cdb_len],
    260                 sense_len);
    261       }
    262 
    263 #if 0
    264       /* FIXME: Should this be != 0 maybe? */
    265       if(aspi->SRBlock.u.cmd.target_status == 2 ) {
    266         aspi->SRBlock.status = SS_ERR;
    267         switch (lpPRB->CDBByte[0]) {
    268                 case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
    269                 case 0xa3: /* SEND KEY (DVD) MMC-2 */
    270                         aspi->SRBlock.status              = SS_COMP;
    271                         aspi->SRBlock.u.cmd.target_status = 0;
    272                         FIXME("Program wants to do DVD Region switching, but fails (non compliant DVD drive). Ignoring....\n");
    273                         break;
    274         }
    275       }
    276 #endif
    277       /* now do posting */
    278       if (lpPRB->SRB_PostProc)
    279       {
    280         if(ASPI_POSTING(lpPRB))
    281         {
    282           dprintf(("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc));
    283           (*lpPRB->SRB_PostProc)();
    284         }
    285         else
    286         if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY)
    287         {
    288           dprintf(("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc));
    289           SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
    290         }
    291       }
    292     }
    293   }
    294   else
    295     lpPRB->SRB_Status = SS_ERR;
    296 
    297   //SvL: Shouldn't this be set before posting?
    298   lpPRB->SRB_Status = aspi->SRBlock.status;
    299   lpPRB->SRB_HaStat = aspi->SRBlock.u.cmd.ha_status;
    300   lpPRB->SRB_TargStat = aspi->SRBlock.u.cmd.target_status;
    301 
    302   ASPI_DebugPrintResult(lpPRB);
    303 
    304   return lpPRB->SRB_Status;
    305 }
    306 
    307 /*******************************************************************
    308  *     GetASPI32SupportInfo32           [WNASPI32.0]
    309  *
    310  * Checks if the ASPI subsystem is initialized correctly.
    311  *
    312  * RETURNS
    313  *    HIWORD: 0.
    314  *    HIBYTE of LOWORD: status (SS_COMP or SS_FAILED_INIT)
    315  *    LOBYTE of LOWORD: # of host adapters.
    316  */
    317 ODINFUNCTION0(DWORD, GetASPI32SupportInfo)
    318 {
    319   LONG rc;
    320   BYTE bNumDrv;
    321   HKEY hkeyDrvInfo;
    322   DWORD dwType;
    323   DWORD dwData;
    324   DWORD dwSize;
    325   ULONG ulParam, ulReturn;
    326   BYTE brc;
    327 
    328   bNumDrv = 0;
    329 
    330   // first thing we do is check whether we have a successful ASPI setup
    331   if (aspi == NULL)
    332   {
    333       dprintf(("ASPI was not initialized successfully, return error"));
    334       return (SS_FAILED_INIT << 8);
    335   }
    336 
    337   if(aspi->access(FALSE)) //'non-blocking' call
    338   {
    339         bNumDrv = aspi->getNumHosts();
    340         brc = SS_COMP;
    341         rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
    342                            "Software\\ODIN\\ASPIROUT",
    343                            &hkeyDrvInfo);
    344         if(ERROR_SUCCESS==rc)
    345         {
    346           dwData = bNumDrv;
    347           RegSetValueExA( hkeyDrvInfo,
    348                           "NumAdapers",
    349                           NULL,
    350                           REG_DWORD,
    351                           (LPBYTE)&dwData,
    352                           sizeof(DWORD));
    353           RegCloseKey( hkeyDrvInfo);
    354         }
    355         aspi->release();
    356   }
    357   else
    358   {
    359     // Driver is used by other process/thread
    360     // so try get value form registry
    361 
    362     brc = SS_FAILED_INIT;
    363     rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
    364                        "Software\\ODIN\\ASPIROUT",
    365                        &hkeyDrvInfo);
    366 
    367     if(ERROR_SUCCESS!=rc)
    368       return ((SS_FAILED_INIT << 8) | bNumDrv);
    369 
    370     dwSize = sizeof(DWORD);
    371     rc = RegQueryValueExA( hkeyDrvInfo,
    372                            "NumAdapers",
    373                            NULL,
    374                            &dwType,
    375                            (BYTE*)&dwData,
    376                            &dwSize);
    377 
    378     RegCloseKey( hkeyDrvInfo);
    379 
    380     if( (ERROR_SUCCESS==rc) &&
    381         (REG_DWORD != dwType) )
    382     {
    383       bNumDrv = 0xFF & dwData;
    384       brc = SS_COMP;
    385     }
    386   }
    387 
    388   return ((brc << 8) | bNumDrv); /* FIXME: get # of host adapters installed */
    389 }
    390 
    391 /***********************************************************************
    392  *             SendASPI32Command32 (WNASPI32.1)
    393  */
     286    ASPI_DebugPrintResult(lpPRB);
     287    return WNASPI32_DoPosting( lpPRB, SS_COMP );
     288}
     289//*****************************************************************************
     290//     GetASPI32SupportInfo32           [WNASPI32.0]
     291//
     292// Checks if the ASPI subsystem is initialized correctly.
     293//
     294// RETURNS
     295//    HIWORD: 0.
     296//    HIBYTE of LOWORD: status (SS_COMP or SS_FAILED_INIT)
     297//    LOBYTE of LOWORD: # of host adapters.
     298//*****************************************************************************
     299DWORD CDECL GetASPI32SupportInfo()
     300{
     301    BYTE bNumDrv;
     302    BYTE brc;
     303
     304    bNumDrv = 0;
     305
     306    // first thing we do is check whether we have a successful ASPI setup
     307    if(fASPIAvailable == FALSE)
     308    {
     309        dprintf(("ASPI was not initialized successfully, return error"));
     310        return (SS_FAILED_INIT << 8);
     311    }
     312
     313    bNumDrv = OSLibCdIoGetNumDrives();
     314    if (!bNumDrv)
     315            return SS_NO_ADAPTERS << 8;
     316
     317    brc = SS_COMP;
     318
     319    //pretend there's only one controller
     320    return ((brc << 8) | 1);
     321}
     322//*****************************************************************************
     323//    SendASPI32Command32 (WNASPI32.1)
     324//*****************************************************************************
    394325DWORD CDECL SendASPI32Command(LPSRB lpSRB)
    395326{
    … …  
    397328    ULONG ulParam, ulReturn;
    398329    BYTE  bRC;
    399     LONG rc;
     330    LONG  rc;
    400331
    401332    // first thing we do is check whether we have a successful ASPI setup
    402     if (aspi == NULL)
     333    if(fASPIAvailable == FALSE)
    403334    {
    404335        dprintf(("SendASPI32Command: ASPI was not initialized successfully, return error"));
    … …  
    407338
    408339    if(NULL==lpSRB)
    409       return SS_INVALID_SRB;  // Not sure what to return here but that is an error
     340        return SS_INVALID_SRB;  // Not sure what to return here but that is an error
    410341
    411342    dprintf(("SendASPI32Command %x %d", lpSRB, lpSRB->common.SRB_Cmd));
    412343
    413     // test first for a valid command
    414     if( (SC_HA_INQUIRY!=lpSRB->common.SRB_Cmd) &&
    415         (SC_GET_DEV_TYPE!=lpSRB->common.SRB_Cmd) &&
    416         (SC_EXEC_SCSI_CMD!=lpSRB->common.SRB_Cmd) &&
    417         (SC_ABORT_SRB!=lpSRB->common.SRB_Cmd) &&
    418         (SC_RESET_DEV!=lpSRB->common.SRB_Cmd) )
    419     {
    420         dprintf(("Invalid command!"));
     344    dwRC = SS_ERR;
     345
     346    switch (lpSRB->common.SRB_Cmd)
     347    {
     348    case SC_HA_INQUIRY:
     349        lpSRB->inquiry.SRB_Status   = SS_COMP;       /* completed successfully */
     350        lpSRB->inquiry.HA_Count     = 1;
     351        lpSRB->inquiry.HA_SCSI_ID   = 7;             /* not always ID 7 */
     352        strcpy((char *)lpSRB->inquiry.HA_ManagerId, "ASPI for WIN32"); /* max 15 chars, don't change */
     353        strcpy((char *)lpSRB->inquiry.HA_Identifier, "Odin host"); /* FIXME: return host adapter name */
     354        memset(lpSRB->inquiry.HA_Unique, 0, 16); /* default HA_Unique content */
     355        lpSRB->inquiry.HA_Unique[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
     356        lpSRB->inquiry.HA_Unique[3] = 0x08; /* Maximum number of SCSI targets */
     357        dprintf(("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB->inquiry.SRB_HaId));
     358       
     359        //OS/2 override
     360        lpSRB->inquiry.HA_Unique[6] = 0x01; // transfer only 64KB
     361        lpSRB->inquiry.HA_Unique[3] = 0x10; // 16 devices.
     362
     363        dwRC = SS_COMP;
     364        break;
     365
     366    case SC_GET_DEV_TYPE:
     367    {
     368        dprintf(("SC_GET_DEV_TYPE %d %d %d", lpSRB->devtype.SRB_HaId, lpSRB->devtype.SRB_Target, lpSRB->devtype.SRB_Lun));
     369
     370        /* FIXME: We should return SS_NO_DEVICE if the device is not configured */
     371        /* FIXME: We should return SS_INVALID_HA if HostAdapter!=0 */
     372        SRB             tmpsrb;
     373        char    inqbuf[200];
     374        DWORD   ret;
     375
     376        memset(&tmpsrb,0,sizeof(tmpsrb));
     377
     378        /* Copy header */
     379        memcpy(&tmpsrb.common,&(lpSRB->common),sizeof(tmpsrb.common));
     380
     381        tmpsrb.cmd.SRB_Flags    |= 8; /* target to host */
     382        tmpsrb.cmd.SRB_Cmd              = SC_EXEC_SCSI_CMD;
     383        tmpsrb.cmd.SRB_Target   = lpSRB->devtype.SRB_Target;
     384        tmpsrb.cmd.SRB_Lun              = lpSRB->devtype.SRB_Lun;
     385        tmpsrb.cmd.SRB_BufLen   = sizeof(inqbuf);
     386        tmpsrb.cmd.SRB_BufPointer       = (BYTE *)inqbuf;
     387        tmpsrb.cmd.CDBByte[0]   = 0x12; /* INQUIRY  */
     388                          /* FIXME: handle lun */
     389        tmpsrb.cmd.CDBByte[4]   = sizeof(inqbuf);
     390        tmpsrb.cmd.SRB_CDBLen   = 6;
     391
     392        ret = ASPI_ExecScsiCmd(&tmpsrb.cmd);
     393
     394        lpSRB->devtype.SRB_Status         = tmpsrb.cmd.SRB_Status;
     395        lpSRB->devtype.SRB_DeviceType = inqbuf[0] & 0x1f;
     396
     397        TRACE("returning devicetype %d for target %d\n", inqbuf[0] & 0x1f, tmpsrb.cmd.SRB_Target);
     398
     399        if (ret!=SS_PENDING) /* Any error is passed down directly */
     400            return ret;
     401        /* FIXME: knows that the command is finished already, pass final Status */
     402        return tmpsrb.cmd.SRB_Status;
     403    }
     404
     405    case SC_EXEC_SCSI_CMD:
     406        dwRC = ASPI_ExecScsiCmd(&lpSRB->cmd);
     407        break;
     408
     409    case SC_ABORT_SRB:
     410        dprintf(("SC_ABORT_SRB %d", lpSRB->abort.SRB_HaId));
     411        dwRC = SS_INVALID_SRB; // We don't do async ASPI so no way to abort
     412        break;
     413
     414    case SC_RESET_DEV:
     415    {
     416        HCDIO hCDIO = OSLibCdIoGetDevice(lpSRB->reset.SRB_HaId, lpSRB->reset.SRB_Target, lpSRB->reset.SRB_Lun);
     417        if(hCDIO == -1) {
     418            return SS_NO_DEVICE;
     419        }
     420        dprintf(("SC_RESET_DEV %d %d %d", lpSRB->reset.SRB_HaId, lpSRB->reset.SRB_Target, lpSRB->reset.SRB_Lun));
     421        OSLibCdIoResetUnit(hCDIO);
     422        dwRC = SS_COMP;
     423        break;
     424    }
     425
     426    case SC_GET_DISK_INFO:
     427        /* here we have to find out the int13 / bios association.
     428         * We just say we do not have any.
     429         */
     430        FIXME("SC_GET_DISK_INFO always return 'int13 unassociated disk'.\n");
     431        lpSRB->diskinfo.SRB_DriveFlags = 0; /* disk is not int13 served */
     432        return SS_COMP;
     433
     434    default:
     435            dprintf(("Invalid command!"));
    421436        return SS_INVALID_SRB; // shoud be invalid command
    422     }
    423 
    424     dwRC = SS_ERR;
    425 
    426     if(aspi->access(TRUE)) // Block if a SRB is pending
    427     {
    428         switch (lpSRB->common.SRB_Cmd)
    429         {
    430           case SC_HA_INQUIRY:
    431             aspi->HA_inquiry(lpSRB->inquiry.SRB_HaId);
    432             memset(lpSRB,0,sizeof(SRB_HaInquiry));
    433             memcpy( lpSRB,
    434                     &aspi->SRBlock,
    435                     sizeof(SRB_HaInquiry)-4 );
    436             // FIXME: I'dont know why in OS/2->ha_unique are filled with 0
    437             // Hackmode ON ======
    438             lpSRB->inquiry.HA_Unique[6]  = 0x01; // transfer only 64KB
    439             lpSRB->inquiry.HA_Unique[3]  = 0x10; // 16 devices.
    440             // HackMode OFF =====
    441             dwRC = aspi->SRBlock.status;
    442             break;
    443 
    444           case SC_GET_DEV_TYPE:
    445             rc=aspi->getDeviceType(lpSRB->devtype.SRB_HaId,lpSRB->devtype.SRB_Target, lpSRB->devtype.SRB_Lun);
    446             dwRC = lpSRB->devtype.SRB_Status = aspi->SRBlock.status;
    447             lpSRB->devtype.SRB_DeviceType = aspi->SRBlock.u.dev.devtype;
    448             break;
    449 
    450           case SC_EXEC_SCSI_CMD:
    451             dwRC = ASPI_ExecScsiCmd( aspi, &lpSRB->cmd);
    452             break;
    453 
    454           case SC_ABORT_SRB:
    455             dwRC = SS_INVALID_SRB; // We don't do async ASPI so no way to abort
    456             break;
    457 
    458           case SC_RESET_DEV:
    459             aspi->resetDevice(lpSRB->reset.SRB_HaId,lpSRB->reset.SRB_Target, lpSRB->reset.SRB_Lun);
    460             lpSRB->reset.SRB_Status   = aspi->SRBlock.status;
    461             lpSRB->reset.SRB_Flags    = aspi->SRBlock.flags;
    462             lpSRB->reset.SRB_Hdr_Rsvd = 0;
    463             memset( lpSRB->reset.SRB_Rsvd1,
    464                     0,
    465                     12 );
    466             lpSRB->reset.SRB_HaStat   = aspi->SRBlock.u.res.ha_status;     /* Host Adapter Status */
    467             lpSRB->reset.SRB_TargStat = aspi->SRBlock.u.res.target_status; /* Target Status */
    468             lpSRB->reset.SRB_PostProc = NULL;                  /* Post routine */
    469             lpSRB->reset.SRB_Rsvd2    = NULL;                  /* Reserved */
    470             memset( lpSRB->reset.SRB_Rsvd3,
    471                     0,
    472                     32);            /* Reserved */
    473              dwRC = aspi->SRBlock.status;
    474              break;
    475 
    476         } // end switch (lpSRB->common.SRB_Cmd)
    477 
    478         aspi->release();
    479     }
    480     else
    481     {
    482         dprintf(("Unable to access aspi!!"));
    483         dwRC = SS_NO_ASPI;
    484     }
    485 
     437
     438    } // end switch (lpSRB->common.SRB_Cmd)
     439
     440    dprintf(("SendASPI32Command %x %d done", lpSRB, lpSRB->common.SRB_Cmd));
    486441    return dwRC;
    487442}
    488 
    489 /***********************************************************************
    490  *             GetASPI32DLLVersion32   (WNASPI32.3)
    491  */
    492 DWORD WINAPI GetASPI32DLLVersion()
    493 {
    494   return (DWORD)1;
    495 }
    496 
     443//*****************************************************************************
     444//   GetASPI32DLLVersion32   (WNASPI32.3)
     445//*****************************************************************************
     446DWORD CDECL GetASPI32DLLVersion()
     447{
     448    return (DWORD)1;
     449}
     450//*****************************************************************************
     451//*****************************************************************************
     452
     453

  • trunk/src/wnaspi32/wnaspi32.def

    r4809 r8601  
    88
    99EXPORTS
    10   GetASPI32SupportInfo       = _GetASPI32SupportInfo@0         @1
     10  GetASPI32SupportInfo       = _GetASPI32SupportInfo           @1    ; CDECL
    1111  SendASPI32Command          = _SendASPI32Command              @2    ; CDECL
    12   GetASPI32DLLVersion        = _GetASPI32DLLVersion@0          @3
     12  GetASPI32DLLVersion        = _GetASPI32DLLVersion            @3    ; CDECL
    1313; OrdinalOnlyExport
    1414
Note: See TracChangeset for help on using the changeset viewer.