system.c

wince ramdisk drivers

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:  

    system.c

Abstract:  

    Windows CE RAM disk driver.

--*/
#include "ramdisk.h"
#include <Windev.h>


#ifdef DEBUG
//
// These defines must match the ZONE_* defines
//
#define DBG_ERROR      1
#define DBG_WARNING    2
#define DBG_FUNCTION   4
#define DBG_INIT       8
#define DBG_PCMCIA     16
#define DBG_IO         32

DBGPARAM dpCurSettings = {
    TEXT("RAM Disk"), {
    TEXT("Errors"),TEXT("Warnings"),TEXT("Functions"),TEXT("Initialization"),
    TEXT("PCMCIA"),TEXT("Disk I/O"),TEXT("Misc"),TEXT("Undefined"),
    TEXT("Undefined"),TEXT("Undefined"),TEXT("Undefined"),TEXT("Undefined"),
    TEXT("Undefined"),TEXT("Undefined"),TEXT("Undefined"),TEXT("Undefined") },
    0x1
};
#endif  // DEBUG


//
// Global Variables
//
CRITICAL_SECTION v_DiskCrit;
PDISK v_DiskList;				// initialized to 0 in bss


//------------------------------------------------------------------------------
//
// RAMDISK.DLL entry
//
//------------------------------------------------------------------------------
BOOL WINAPI
DllMain(HINSTANCE DllInstance, DWORD Reason, LPVOID Reserved)
{
    switch(Reason) {
        case DLL_PROCESS_ATTACH:
            DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK: DLL_PROCESS_ATTACH\r\n")));
            DEBUGREGISTER(DllInstance);
	    DisableThreadLibraryCalls((HMODULE) DllInstance);
            break;
    
        case DLL_PROCESS_DETACH:
            DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK: DLL_PROCESS_DETACH\r\n")));
            DeleteCriticalSection(&v_DiskCrit);
            break;
    }
    return TRUE;
}   // DllMain


//------------------------------------------------------------------------------
//
// CreateDiskObject - create a DISK structure, init some fields and link it.
//
//------------------------------------------------------------------------------
PDISK
CreateDiskObject(VOID)
{
    PDISK pDisk;
    
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+CreateDiskObject\r\n")));
    
    pDisk = LocalAlloc(LPTR, sizeof(DISK));
    if (pDisk != NULL) {
        pDisk->d_OpenCount = 0;
        pDisk->d_ActivePath = NULL;
        InitializeCriticalSection(&(pDisk->d_DiskCardCrit));
        pDisk->d_DiskCardState = STATE_INITING;
        EnterCriticalSection(&v_DiskCrit);
        pDisk->d_next = v_DiskList;
        v_DiskList = pDisk;
        LeaveCriticalSection(&v_DiskCrit);
    }
    
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-CreateDiskObject\r\n")));
    return pDisk;
}   // CreateDiskObject



//------------------------------------------------------------------------------
//
// IsValidDisk - verify that pDisk points to something in our list
//
// Return TRUE if pDisk is valid, FALSE if not.
//
//------------------------------------------------------------------------------
BOOL
IsValidDisk(
    PDISK pDisk
    )
{
    PDISK pd;
    BOOL ret = FALSE;

    EnterCriticalSection(&v_DiskCrit);
    pd = v_DiskList;
    while (pd) {
        if (pd == pDisk) {
            ret = TRUE;
            break;
        }
        pd = pd->d_next;
    }
    LeaveCriticalSection(&v_DiskCrit);
    return ret;
}   // IsValidDisk



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DWORD
GetDiskStateError(
    DWORD DiskState
    )
{
    switch (DiskState) {
    case STATE_DEAD:
        return DISK_DEAD_ERROR;

    case STATE_REMOVED:
        return DISK_REMOVED_ERROR;

    }
    return ERROR_GEN_FAILURE;
}




//------------------------------------------------------------------------------
//
// Returns context data for this Init instance
//
// Arguments:
//      dwContext - registry path for this device's active key
//
//------------------------------------------------------------------------------
DWORD
DSK_Init(
    DWORD dwContext
    )
{
    PDISK pDisk;
    DWORD dwSize;
	DWORD dwAddress;
    LPWSTR ActivePath = (LPWSTR) dwContext;

    DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK: DSK_Init entered\r\n")));

    if (v_DiskList == NULL) {
        InitializeCriticalSection(&v_DiskCrit);
    }

    pDisk = CreateDiskObject();
    if (pDisk == NULL) {
        RETAILMSG(1,(TEXT("RAMDISK: LocalAlloc(PDISK) failed %d\r\n"), GetLastError()));
        return 0;
    }

    if (ActivePath) {
        DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK : ActiveKey = %s\r\n"), ActivePath));
        if (pDisk->d_ActivePath = LocalAlloc(LPTR, wcslen(ActivePath)*sizeof(WCHAR)+sizeof(WCHAR))) {
            wcscpy(pDisk->d_ActivePath, ActivePath);
        }
        DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK : ActiveKey (copy) = %s (@ 0x%08X)\r\n"), pDisk->d_ActivePath, pDisk->d_ActivePath));
    }
    
    dwSize = GetDiskSize(pDisk);
	dwAddress = GetDiskAddress(pDisk);
	if (!dwAddress) {	
	    pDisk->pbRAM = (PBYTE) LocalAlloc(LPTR, dwSize);
	    if (pDisk->pbRAM == NULL) {
	        RETAILMSG(1,(TEXT("RAMDISK: LocalAlloc(pbRAM) failed %d\r\n"), GetLastError()));
	        LocalFree(pDisk);
	        return 0;
	    }
	} else {
		pDisk->pbRAM = (PBYTE)dwAddress;
	}	

    pDisk->d_DiskInfo.di_total_sectors = dwSize/BYTES_PER_SECTOR;  // 0 if card has no CIS
    DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK: sectors = %d\r\n"), pDisk->d_DiskInfo.di_total_sectors));
    
    if (pDisk->d_DiskCardState == STATE_INITING) {
        DEBUGMSG(ZONE_INIT,
            (TEXT("RAMDISK: RAMInit returning 0x%x\r\n"), pDisk));
        return (DWORD) pDisk;
    }

    DEBUGMSG(ZONE_FUNCTION, (TEXT("-RAMInit (failure)\r\n")));
    CloseDisk(pDisk);
    return 0;
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
DSK_Close(
    DWORD Handle
    )
{
    PDISK pDisk = (PDISK)Handle;
    BOOL bClose = FALSE;

    DEBUGMSG(ZONE_IO, (TEXT("RAMDISK: DSK_Close entered\r\n")));

    if (!IsValidDisk(pDisk)) {
        return FALSE;
    }

    if (pDisk->d_DiskCardState == STATE_OPENED) {
        EnterCriticalSection(&(pDisk->d_DiskCardCrit));
        pDisk->d_OpenCount--;
        if (pDisk->d_OpenCount == 0) {
            pDisk->d_DiskCardState = STATE_CLOSED;
            bClose = TRUE;
        }
        LeaveCriticalSection(&(pDisk->d_DiskCardCrit));
    }
    DEBUGMSG(ZONE_IO, (TEXT("RAMDISK: DSK_Close done\r\n")));
    return TRUE;
}   // DSK_Close


//------------------------------------------------------------------------------
//
// Device deinit - devices are expected to close down.
// The device manager does not check the return code.
//
//------------------------------------------------------------------------------
BOOL
DSK_Deinit(
    DWORD dwContext     // future: pointer to the per disk structure
    )
{
    DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK: DSK_Deinit entered\r\n")));

    DSK_Close(dwContext);
    CloseDisk((PDISK)dwContext);
    DEBUGMSG(ZONE_INIT, (TEXT("RAMDISK: DSK_Deinit done\r\n")));
    return TRUE;
}   // DSK_Deinit


//------------------------------------------------------------------------------
//
// Returns handle value for the open instance.
//
//------------------------------------------------------------------------------
DWORD
DSK_Open(
    DWORD dwData,
    DWORD dwAccess,
    DWORD dwShareMode
    )
{
    PDISK pDisk = (PDISK)dwData;
    DWORD ret = 0;

    DEBUGMSG(ZONE_IO, (TEXT("RAMDISK: DSK_Open(0x%x)\r\n"),dwData));

    if (IsValidDisk(pDisk) == FALSE) {
        DEBUGMSG(ZONE_IO, (TEXT("RAMDISK: DSK_Open - Passed invalid disk handle\r\n")));
        return ret;
    }

    //
    // Finish initialization by determining the card's capacity
    //
    if (pDisk->d_DiskCardState == STATE_INITING) {
        
        if (pDisk->d_DiskInfo.di_total_sectors == 0) {
            pDisk->d_DiskCardState = STATE_DEAD;
        }

        pDisk->d_DiskInfo.di_bytes_per_sect = BYTES_PER_SECTOR;
        pDisk->d_DiskInfo.di_cylinders = 0;
        pDisk->d_DiskInfo.di_heads = 0;
        pDisk->d_DiskInfo.di_sectors = pDisk->d_DiskInfo.di_total_sectors/(16*2);
        pDisk->d_DiskInfo.di_flags = DISK_INFO_FLAG_CHS_UNCERTAIN | DISK_INFO_FLAG_UNFORMATTED;

        if (pDisk->d_DiskCardState == STATE_INITING) {
            pDisk->d_DiskCardState = STATE_CLOSED;
        }
    }

    if ((pDisk->d_DiskCardState != STATE_OPENED) &&
        (pDisk->d_DiskCardState != STATE_CLOSED)) {
        SetLastError(GetDiskStateError(pDisk->d_DiskCardState));
        return 0;
    }

    EnterCriticalSection(&(pDisk->d_DiskCardCrit));
    if (pDisk->d_DiskCardState == STATE_CLOSED) {
        pDisk->d_DiskCardState = STATE_OPENED;
    }
    ret = (DWORD)pDisk;
    pDisk->d_OpenCount++;
    LeaveCriticalSection(&(pDisk->d_DiskCardCrit));
    DEBUGMSG(ZONE_IO, (TEXT("RAMDISK: DSK_Open(0x%x) returning %d\r\n"),dwData, ret));
    return ret;
}   // DSK_Open


//------------------------------------------------------------------------------
//
// I/O Control function - responds to info, read and write control codes.
// The read and write take a scatter/gather list in pInBuf
//
//------------------------------------------------------------------------------
BOOL
DSK_IOControl(
    DWORD Handle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
    PSG_REQ pSG;
    PDISK pDisk = (PDISK) Handle;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("+DSK_IOControl (%d) \r\n"), dwIoControlCode));
    
    if (IsValidDisk(pDisk) == FALSE) {
        SetLastError(ERROR_INVALID_HANDLE);
        DEBUGMSG(ZONE_FUNCTION, (TEXT("-DSK_IOControl (invalid disk) \r\n")));
        return FALSE;
    }

    if (pDisk->d_DiskCardState != STATE_OPENED) {
        SetLastError(GetDiskStateError(pDisk->d_DiskCardState));
        DEBUGMSG(ZONE_FUNCTION, (TEXT("-DSK_IOControl (disk card state) \r\n")));
        return FALSE;
    }

    //
    // Check parameters
    //
    switch (dwIoControlCode) {
    case DISK_IOCTL_READ:
    case DISK_IOCTL_WRITE:
    case DISK_IOCTL_GETINFO:
    case DISK_IOCTL_SETINFO:
    case DISK_IOCTL_INITIALIZED:
        if (pInBuf == NULL) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

    case DISK_IOCTL_GETNAME:
        if (pOutBuf == NULL) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

    case IOCTL_DISK_DEVICE_INFO:
        if(!pInBuf || nInBufSize != sizeof(STORAGEDEVICEINFO)) {
            SetLastError(ERROR_INVALID_PARAMETER);   
            return FALSE;
        }
        break;

    case DISK_IOCTL_FORMAT_MEDIA:
        SetLastError(ERROR_SUCCESS);
        return TRUE;
    
    default:
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    //
    // Execute dwIoControlCode
    //
    switch (dwIoControlCode) {
    case DISK_IOCTL_READ:
  /*  case DISK_IOCTL_WRITE:
        /*pSG = (PSG_REQ)pInBuf;
       /* if (1!= OEM_CERTIFY_TRUST) {
            PSG_REQ pSgReq=pSG;
            if  (pSgReq && nInBufSize >= (sizeof(SG_REQ) + sizeof(SG_BUF) * (pSgReq->sr_num_sg - 1))) {
                DWORD dwIndex;
                for (dwIndex=0; dwIndex < pSgReq -> sr_num_sg; dwIndex++) {
                    pSgReq->sr_sglist[dwIndex].sb_buf = 
                        (PUCHAR)((LPVOID)pSgReq->sr_sglist[dwIndex].sb_buf,pSgReq->sr_sglist[dwIndex].sb_len);
                }
				*/
           // }
            /*else {// Parameter Wrong.
                SetLastError(ERROR_INVALID_PARAMETER);
                return FALSE;
				
		return TRUE;

        }*/
        DoDiskIO(pDisk, dwIoControlCode, pSG);
        if (pSG->sr_status) {
            SetLastError(pSG->sr_status);
            return FALSE;
        }
        return TRUE;

    case DISK_IOCTL_GETINFO:
        SetLastError(GetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
        return TRUE;

    case DISK_IOCTL_SETINFO:
        SetLastError(SetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
        return TRUE;

    case DISK_IOCTL_INITIALIZED:
        return TRUE;

    case DISK_IOCTL_GETNAME:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("-DSK_IOControl (name) \r\n")));
        return GetFolderName(pDisk, (LPWSTR)pOutBuf, nOutBufSize, pBytesReturned);

    case IOCTL_DISK_DEVICE_INFO: // new ioctl for disk info
        DEBUGMSG(ZONE_FUNCTION, (TEXT("-DSK_IOControl (device info) \r\n")));
        return GetDeviceInfo(pDisk, (PSTORAGEDEVICEINFO)pInBuf);

    default:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("-DSK_IOControl (default) \r\n")));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
}   // DSK_IOControl




//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DWORD DSK_Read(DWORD Handle, LPVOID pBuffer, DWORD dwNumBytes){return 0;}
DWORD DSK_Write(DWORD Handle, LPCVOID pBuffer, DWORD dwNumBytes){return 0;}
DWORD DSK_Seek(DWORD Handle, long lDistance, DWORD dwMoveMethod){return 0;}
void DSK_PowerUp(void){}
void DSK_PowerDown(void){}