Changeset 6086 for trunk/src


Ignore:
Timestamp:
Jun 23, 2001, 9:43:50 PM (24 years ago)
Author:
sandervl
Message:

added cdrom get/setvolume ioctls

Location:
trunk/src/kernel32
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/kernel32/HandleManager.cpp

    r6084 r6086  
    1 /* $Id: HandleManager.cpp,v 1.68 2001-06-23 16:59:26 sandervl Exp $ */
     1/* $Id: HandleManager.cpp,v 1.69 2001-06-23 19:43:49 sandervl Exp $ */
    22
    33/*
     
    30983098                                     dwWakeMask);
    30993099
     3100  dprintf2(("MsgWaitForMultipleObjects returned %d", rc));
    31003101  return (rc);                            // OK, done
    31013102#endif
  • trunk/src/kernel32/hmdevio.cpp

    r6035 r6086  
    1 /* $Id: hmdevio.cpp,v 1.13 2001-06-17 11:16:42 achimha Exp $ */
     1/* $Id: hmdevio.cpp,v 1.14 2001-06-23 19:43:49 sandervl Exp $ */
    22
    33/*
     
    4343static BOOL MAPMEMIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
    4444static BOOL FXMEMMAPIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
     45static BOOL VPCIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
    4546
    4647static WIN32DRV knownDriver[] =
    4748    {{"\\\\.\\GpdDev", "",      TRUE,  666,   GpdDevIOCtl},
    4849    { "\\\\.\\MAPMEM", "PMAP$", FALSE, 0,     MAPMEMIOCtl},
    49     { "FXMEMMAP.VXD",  "PMAP$", FALSE, 0,     FXMEMMAPIOCtl}
     50    { "FXMEMMAP.VXD",  "PMAP$", FALSE, 0,     FXMEMMAPIOCtl},
     51#if 1
     52    { "\\\\.\\VPCAppSv", "", TRUE,  667,   VPCIOCtl}};
     53#else
    5054    };
     55#endif
    5156
    5257static int nrKnownDrivers = sizeof(knownDriver)/sizeof(WIN32DRV);
     58BOOL fVirtualPC = FALSE;
    5359
    5460//******************************************************************************
     
    356362//******************************************************************************
    357363//******************************************************************************
     364static BOOL VPCIOCtl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
     365{
     366  APIRET rc;
     367
     368  dprintf(("VPCIOCtl func %x: %x %d %x %d %x %x", dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
     369  switch(dwIoControlCode) {
     370  case 0x9C402880: //0x00
     371        if(nOutBufferSize < 4) {
     372            SetLastError(ERROR_BAD_LENGTH);
     373            return FALSE;
     374        }
     375        *(DWORD *)lpOutBuffer = 0x60001;
     376        *lpBytesReturned = 4;
     377        return TRUE;
     378
     379  case 0x9C402894: //0x14 (get IDT table)
     380  {
     381        DWORD *lpBuffer = (DWORD *)lpOutBuffer;
     382        if(nOutBufferSize < 0x800) {
     383            SetLastError(ERROR_BAD_LENGTH);
     384            return FALSE;
     385        }
     386        memset(lpOutBuffer, 0, nOutBufferSize);
     387        for(int i=0;i<32;i++) {
     388            lpBuffer[i*2]   = 0x0178c4c8;
     389            lpBuffer[i*2+1] = 0xfff18F00;
     390        }
     391        for(i=0x50;i<0x57;i++) {
     392            lpBuffer[i*2]   = 0x0178c4c8;
     393            lpBuffer[i*2+1] = 0xfff18E00;
     394        }
     395        for(i=0x70;i<0x77;i++) {
     396            lpBuffer[i*2]   = 0x0178c4c8;
     397            lpBuffer[i*2+1] = 0xfff18E00;
     398        }
     399        lpBuffer[0x4F*2]   = 0x0178c4c8;
     400        lpBuffer[0x4F*2+1] = 0xfff18E00;
     401        lpBuffer[0xEF*2]   = 0x0178c4c8;
     402        lpBuffer[0xEF*2+1] = 0xfff18E00;
     403        *lpBytesReturned = 0xFF*8;
     404        return TRUE;
     405  }
     406  case 0x9C40288C: //0x0C change IDT
     407        if(nInBufferSize < 0x22) {
     408            SetLastError(ERROR_BAD_LENGTH);
     409            return FALSE;
     410        }
     411        fVirtualPC = TRUE;
     412        return TRUE;
     413
     414  case 0x9C402884: //0x04 ExAllocatePoolWithTag
     415  {
     416        DWORD *lpBuffer = (DWORD *)lpInBuffer;
     417        if(nInBufferSize < 0x08) {
     418            SetLastError(ERROR_BAD_LENGTH);
     419            return FALSE;
     420        }
     421        dprintf(("In: %x %x", lpBuffer[0], lpBuffer[1]));
     422        return TRUE;
     423  }
     424
     425  case 0x9C402898: //0x18 Remove IDT patch
     426        if(nInBufferSize < 0x01) {
     427            SetLastError(ERROR_BAD_LENGTH);
     428            return FALSE;
     429        }
     430        fVirtualPC = FALSE;
     431        return TRUE;
     432  default:
     433        dprintf(("VPCIOCtl unknown func %X\n", dwIoControlCode));
     434        return FALSE;
     435  }
     436}
     437//******************************************************************************
     438//******************************************************************************
    358439HMCustomDriver::HMCustomDriver(HINSTANCE hInstance, LPCSTR lpDeviceName)
    359440                : HMDeviceDriver(lpDeviceName)
     
    400481                                     LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
    401482{
    402    return driverIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
    403                       lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
     483   BOOL ret;
     484
     485   ret = driverIOCtl(pHMHandleData->hHMHandle, dwIoControlCode, lpInBuffer, nInBufferSize,
     486                     lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
     487   dprintf(("DeviceIoControl %x returned %d", dwIoControlCode, ret));
     488   return ret;
    404489}
    405490//******************************************************************************
  • trunk/src/kernel32/hmdisk.cpp

    r6053 r6086  
    1 /* $Id: hmdisk.cpp,v 1.11 2001-06-20 20:51:57 sandervl Exp $ */
     1/* $Id: hmdisk.cpp,v 1.12 2001-06-23 19:43:50 sandervl Exp $ */
    22
    33/*
     
    2525#include "dbglocal.h"
    2626
    27 static HINSTANCE hInstAspi                           = 0;
    28 static DWORD (WIN32API *GetASPI32SupportInfo)()      = NULL;
    29 static DWORD (CDECL *SendASPI32Command)(LPSRB lpSRB) = NULL;
     27typedef struct
     28{
     29    HINSTANCE hInstAspi;
     30    DWORD (WIN32API *GetASPI32SupportInfo)();
     31    DWORD (CDECL *SendASPI32Command)(LPSRB lpSRB);
     32    ULONG     driveLetter;
     33    CHAR      signature[8];
     34} DRIVE_INFO;
    3035
    3136HMDeviceDiskClass::HMDeviceDiskClass(LPCSTR lpDeviceName) : HMDeviceKernelObjectClass(lpDeviceName)
     
    117122        else pHMHandleData->hHMHandle  = hFile;
    118123
    119         pHMHandleData->dwUserData = *lpFileName; //save drive letter
    120         if(pHMHandleData->dwUserData >= 'a') {
    121             pHMHandleData->dwUserData = pHMHandleData->dwUserData - ((int)'a' - (int)'A');
    122         }
    123 
    124         if(GetDriveTypeA(lpFileName) == DRIVE_CDROM && hInstAspi == NULL) {
    125             hInstAspi = LoadLibraryA("WNASPI32.DLL");
    126             if(hInstAspi == NULL) {
     124        DRIVE_INFO *drvInfo = (DRIVE_INFO *)malloc(sizeof(DRIVE_INFO));
     125        if(drvInfo == NULL) {
     126             if(pHMHandleData->hHMHandle) OSLibDosClose(pHMHandleData->hHMHandle);
     127             return ERROR_OUTOFMEMORY;
     128        }
     129        pHMHandleData->dwUserData = (DWORD)drvInfo;
     130
     131        memset(drvInfo, 0, sizeof(DRIVE_INFO));
     132        drvInfo->driveLetter = *lpFileName; //save drive letter
     133        if(drvInfo->driveLetter >= 'a') {
     134            drvInfo->driveLetter = drvInfo->driveLetter - ((int)'a' - (int)'A');
     135        }
     136
     137        if(GetDriveTypeA(lpFileName) == DRIVE_CDROM) {
     138            drvInfo->hInstAspi = LoadLibraryA("WNASPI32.DLL");
     139            if(drvInfo->hInstAspi == NULL) {
     140                if(pHMHandleData->hHMHandle) OSLibDosClose(pHMHandleData->hHMHandle);
     141                free(drvInfo);
    127142                return ERROR_INVALID_PARAMETER;
    128143            }
    129             *(FARPROC *)&GetASPI32SupportInfo = GetProcAddress(hInstAspi, "GetASPI32SupportInfo");
    130             *(FARPROC *)&SendASPI32Command    = GetProcAddress(hInstAspi, "SendASPI32Command");
     144            *(FARPROC *)&drvInfo->GetASPI32SupportInfo = GetProcAddress(drvInfo->hInstAspi, "GetASPI32SupportInfo");
     145            *(FARPROC *)&drvInfo->SendASPI32Command    = GetProcAddress(drvInfo->hInstAspi, "SendASPI32Command");
     146   
     147            //get cdrom signature (TODO: why doesn't this work???)
     148            DWORD parsize = 4;
     149            DWORD datasize = 4;
     150            strcpy(drvInfo->signature, "CD01");
     151            OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, &drvInfo->signature[0], 4, &parsize,
     152                             &drvInfo->signature[0], 4, &datasize);
    131153        }
    132154        return (NO_ERROR);
     
    141163BOOL HMDeviceDiskClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
    142164{
     165    BOOL ret = TRUE;
     166
    143167    if(pHMHandleData->hHMHandle) {
    144         return OSLibDosClose(pHMHandleData->hHMHandle);
    145     }
    146     return TRUE;
     168        ret = OSLibDosClose(pHMHandleData->hHMHandle);
     169    }
     170    if(pHMHandleData->dwUserData) {
     171       DRIVE_INFO *drvInfo = (DRIVE_INFO*)pHMHandleData->dwUserData;
     172       if(drvInfo->hInstAspi)    FreeLibrary(drvInfo->hInstAspi);
     173       free(drvInfo);
     174    }
     175    return ret;
    147176}
    148177//******************************************************************************
     
    349378    }
    350379    if(msg) {
    351         dprintf(("HMDeviceDiskClass::DeviceIoControl %s", msg));
     380        dprintf(("HMDeviceDiskClass::DeviceIoControl %s %x %d %x %d %x %x", msg, lpInBuffer, nInBufferSize,
     381                 lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped));
    352382    }
    353383#endif
    354384
     385    DRIVE_INFO *drvInfo = (DRIVE_INFO*)pHMHandleData->dwUserData;
     386    if(drvInfo == NULL) {
     387        dprintf(("ERROR: DeviceIoControl: drvInfo == NULL!!!"));
     388        DebugInt3();
     389        SetLastError(ERROR_INVALID_HANDLE);
     390        return FALSE;
     391    }
    355392    switch(dwIoControlCode)
    356393    {
     
    385422            *lpBytesReturned = 0;
    386423        }
    387         if(OSLibDosGetDiskGeometry(pHMHandleData->hHMHandle, pHMHandleData->dwUserData, pGeom) == FALSE) {
     424        if(OSLibDosGetDiskGeometry(pHMHandleData->hHMHandle, drvInfo->driveLetter, pGeom) == FALSE) {
    388425            return FALSE;
    389426        }
     
    414451    case IOCTL_CDROM_PAUSE_AUDIO:
    415452    case IOCTL_CDROM_RESUME_AUDIO:
     453        break;
     454
    416455    case IOCTL_CDROM_GET_VOLUME:
     456    {
     457        PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpOutBuffer;
     458        char volbuf[8];
     459        DWORD parsize, datasize, ret;
     460
     461        if(nOutBufferSize < sizeof(VOLUME_CONTROL) || !pVol) {
     462            SetLastError(ERROR_INSUFFICIENT_BUFFER);
     463            return FALSE;
     464        }
     465        if(lpBytesReturned) {
     466            *lpBytesReturned = 0;
     467        }
     468        parsize = 4;
     469        datasize = 8;
     470        ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x60, "CD01", 4, &parsize,
     471                               volbuf, 8, &datasize);
     472
     473        if(ret) {
     474            SetLastError(error2WinError(ret));
     475            return FALSE;
     476        }
     477        if(lpBytesReturned) {
     478            *lpBytesReturned = sizeof(VOLUME_CONTROL);
     479        }
     480        pVol->PortVolume[0] = volbuf[1];
     481        pVol->PortVolume[1] = volbuf[3];
     482        pVol->PortVolume[2] = volbuf[5];
     483        pVol->PortVolume[3] = volbuf[7];
     484        SetLastError(ERROR_SUCCESS);
     485        return TRUE;
     486    }
     487
    417488    case IOCTL_CDROM_SET_VOLUME:
     489    {
     490        PVOLUME_CONTROL pVol = (PVOLUME_CONTROL)lpInBuffer;
     491        char volbuf[8];
     492        DWORD parsize, datasize, ret;
     493
     494        if(nInBufferSize < sizeof(VOLUME_CONTROL) || !pVol) {
     495            SetLastError(ERROR_INSUFFICIENT_BUFFER);
     496            return FALSE;
     497        }
     498        if(lpBytesReturned) {
     499            *lpBytesReturned = 0;
     500        }
     501        parsize = 4;
     502        datasize = 8;
     503        volbuf[0] = 0;
     504        volbuf[1] = pVol->PortVolume[0];
     505        volbuf[2] = 1;
     506        volbuf[3] = pVol->PortVolume[1];
     507        volbuf[4] = 2;
     508        volbuf[5] = pVol->PortVolume[2];
     509        volbuf[6] = 3;
     510        volbuf[7] = pVol->PortVolume[3];
     511        dprintf(("Set CD volume (%d,%d)(%d,%d)", pVol->PortVolume[0], pVol->PortVolume[1], pVol->PortVolume[2], pVol->PortVolume[3]));
     512        ret = OSLibDosDevIOCtl(pHMHandleData->hHMHandle, 0x81, 0x40, "CD01", 4, &parsize,
     513                               volbuf, 8, &datasize);
     514
     515        if(ret) {
     516            SetLastError(error2WinError(ret));
     517            return FALSE;
     518        }
     519        SetLastError(ERROR_SUCCESS);
     520        return TRUE;
     521    }
    418522    case IOCTL_CDROM_READ_Q_CHANNEL:
    419523    case IOCTL_CDROM_GET_LAST_SESSION:
     
    432536    case IOCTL_STORAGE_CHECK_VERIFY:
    433537        if(lpBytesReturned) {
    434             lpBytesReturned = 0;
     538            *lpBytesReturned = 0;
    435539        }
    436540        //TODO: check if disk has been inserted or removed
     
    458562        SRB_ExecSCSICmd *psrb;
    459563
    460         if(hInstAspi == NULL) {
     564        if(drvInfo->hInstAspi == NULL) {
    461565            SetLastError(ERROR_ACCESS_DENIED);
    462566            return FALSE;
     
    508612        }
    509613        //TODO: pPacket->TimeOutValue ignored
    510         int rc = SendASPI32Command((LPSRB)psrb);
     614        int rc = drvInfo->SendASPI32Command((LPSRB)psrb);
    511615        if(rc != SS_COMP) {
    512616            dprintf(("SendASPI32Command failed with error %d", rc));
     
    542646        addr->PortNumber = 0;
    543647        addr->PathId     = 0;
    544         numAdapters = GetASPI32SupportInfo();
     648        numAdapters = drvInfo->GetASPI32SupportInfo();
    545649        if(LOBYTE(numAdapters) == 0) goto failure;
    546650
    547651        memset(&srb, 0, sizeof(srb));
    548652        srb.common.SRB_Cmd = SC_HA_INQUIRY;
    549         rc = SendASPI32Command(&srb);
     653        rc = drvInfo->SendASPI32Command(&srb);
    550654
    551655        char drivename[3];
    552         drivename[0] = (char)pHMHandleData->dwUserData;
     656        drivename[0] = (char)drvInfo->driveLetter;
    553657        drivename[1] = ':';
    554658        drivename[2] = 0;
     
    562666                    srb.devtype.SRB_Target = j;
    563667                    srb.devtype.SRB_Lun    = k;
    564                     rc = SendASPI32Command(&srb);
     668                    rc = drvInfo->SendASPI32Command(&srb);
    565669                    if(rc == SS_COMP) {
    566670                        if(srb.devtype.SRB_DeviceType == SS_DEVTYPE_CDROM &&
  • trunk/src/kernel32/hmsemaphore.cpp

    r6084 r6086  
    1 /* $Id: hmsemaphore.cpp,v 1.8 2001-06-23 16:59:28 sandervl Exp $ */
     1/* $Id: hmsemaphore.cpp,v 1.9 2001-06-23 19:43:50 sandervl Exp $ */
    22
    33/*
     
    456456            PSEM_INFO pSemInfo  = (PSEM_INFO)pHandle->hHMHandle;
    457457
    458             dprintf(("KERNEL32: HMWaitForMultipleObjects: handle 0: ODIN-%08xh, OS/2-%08xh",
     458            dprintf(("KERNEL32: HMWaitForMultipleObjects(S): handle 0: ODIN-%08xh, OS/2-%08xh",
    459459                     lphObjects[0], pSemInfo->hev));
    460460            if(InterlockedDecrement(&pSemInfo->currentCount) >= 0) {
     
    465465        }
    466466        case HMTYPE_EVENTSEM:
    467             dprintf(("KERNEL32: HMWaitForMultipleObjects: handle 0: ODIN-%08xh, OS/2-%08xh",
     467            dprintf(("KERNEL32: HMWaitForMultipleObjects(E): handle 0: ODIN-%08xh, OS/2-%08xh",
    468468                     lphObjects[0], pHandle->hHMHandle));
    469469            rc = WinWaitEventSem((HEV)pHandle->hHMHandle, dwTimeout);
    470470            break;
    471471        case HMTYPE_MUTEXSEM:
    472             dprintf(("KERNEL32: HMWaitForMultipleObjects: handle %3i: ODIN-%08xh, OS/2-%08xh",
     472            dprintf(("KERNEL32: HMWaitForMultipleObjects(M): handle 0: ODIN-%08xh, OS/2-%08xh",
    473473                     lphObjects[0], pHandle->hHMHandle));
    474474            rc = WinRequestMutexSem((HMTX)pHandle->hHMHandle, dwTimeout);
     
    482482        SetLastError(ERROR_SUCCESS_W);
    483483        if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {
    484             dprintf(("WAIT_ABANDONED_W"));
     484            dprintf(("WAIT_ABANDONED_W (rc %d)", rc));
    485485            return WAIT_ABANDONED_W;
    486486        }
    487487        else
    488488        if(rc == ERROR_TIMEOUT) {
    489             dprintf(("WAIT_TIMEOUT_W"));
     489            dprintf(("WAIT_TIMEOUT_W (rc %d)", rc));
    490490            return WAIT_TIMEOUT_W;
    491491        }
     
    493493   
    494494        if(pfnPeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE_W) == TRUE) {
    495             dprintf(("WAIT_OBJECT_0_W+1"));
     495            dprintf(("WAIT_OBJECT_0_W+1 (rc %d)", rc));
    496496            return WAIT_OBJECT_0_W + 1;
    497497        }
    498         dprintf(("WAIT_OBJECT_0_W+1"));
     498        dprintf(("WAIT_OBJECT_0_W+1 (rc %d)", rc));
    499499        return WAIT_OBJECT_0_W;
    500500    }
  • trunk/src/kernel32/oslibdos.cpp

    r6060 r6086  
    1 /* $Id: oslibdos.cpp,v 1.68 2001-06-21 21:07:54 sandervl Exp $ */
     1/* $Id: oslibdos.cpp,v 1.69 2001-06-23 19:43:50 sandervl Exp $ */
    22/*
    33 * Wrappers for OS/2 Dos* API
     
    23472347{
    23482348   PDISK_GEOMETRY pGeom = (PDISK_GEOMETRY)pdiskgeom;
    2349    BYTE  param[2] = {1, 0};
     2349   BYTE  param[2] = {0, 0};
    23502350   ULONG parsize = 2;
    23512351   BIOSPARAMETERBLOCK bpb;
Note: See TracChangeset for help on using the changeset viewer.