//
// 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:  

    WINCE driver for MultiMediaCard

Functions:

Notes:


--*/
#include <windows.h>
#include <types.h>
#include <wtypes.h>
#include <tchar.h>
#include <devload.h>
#include "diskio.h"
//#include <atapi.h>
#include <windev.h>
#include <storemgr.h>

#include "sdmmc.h"
#include "sddisk.h"


//for testing
#include <winbase.h>




//
// This module contains the necessary OS interface functions:
//  SDDiskEntry
//  CreateDiskObject
//  IsValidDisk
//  DiskFromSocket
//  GetDiskStateError
//  DSK_Init and the other device API functions
//  IsCardInserted
//  mmcinit
//

//#define TRY_FOR_8BIT 1

#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_IO         32

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

PDISK mmcinit(LPTSTR ActiveKey);
DWORD GetDiskStateError(DWORD DiskState);
BOOL  GetFolderName(PDISK pDisk, LPWSTR pOutBuf, DWORD nOutBufSize, DWORD * pBytesReturned);
BOOL  GetStorageID(PDISK pDisk, PSTORAGE_IDENTIFICATION pOutBuf, DWORD nOutBufSize, DWORD * pBytesReturned);
HKEY OpenDriverKey(LPTSTR ActiveKey);

extern void hw_powerup(void);
extern void hw_powerdown(void);

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


//
// SD.DLL entry
//
BOOL WINAPI
SDMMCDiskEntry(HINSTANCE DllInstance, DWORD Reason, LPVOID Reserved)
{
    switch(Reason) {
    case DLL_PROCESS_ATTACH:
    DEBUGREGISTER(DllInstance);
    InitializeCriticalSection(&v_DiskCrit);
    DisableThreadLibraryCalls((HMODULE) DllInstance);
//    RETAILMSG(1, (TEXT("SDMMC--DLL_PROCESS_ATTACH\r\n")));
    return TRUE;

    case DLL_PROCESS_DETACH:
    DeleteCriticalSection(&v_DiskCrit);
//    RETAILMSG(1, (TEXT("SDMMC--DLL_PROCESS_DETACH\r\n")));
    break;
    }
    return TRUE;
}   // SDMMCDiskEntry


//
// CreateDiskObject - create a DISK structure, init some fields and link it.
//
PDISK
CreateDiskObject(VOID)
{
    PDISK pDisk;

    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);
    }
    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
    )
{
#ifdef DEBUG1
    LPTSTR lpState;
    switch (DiskState) {
    case STATE_INITING:lpState = TEXT("STATE_INITING");break;
    case STATE_CLOSED:lpState = TEXT("STATE_CLOSED");break;
    case STATE_OPENED:lpState = TEXT("STATE_OPENED");break;
    case STATE_DEAD:lpState = TEXT("STATE_DEAD");break;
    case STATE_REMOVED:lpState = TEXT("STATE_REMOVED");break;
    default:lpState = TEXT("Unknown");break;
    }
    RETAILMSG(1, (TEXT("MmcDISK:GetDiskStateError: State of disk is %s=%d\r\n"), lpState, DiskState));
#endif
    
    switch (DiskState) {
    case STATE_DEAD:
    return DISK_DEAD_ERROR;

    case STATE_REMOVED:
    return DISK_REMOVED_ERROR;
    }
    return ERROR_GEN_FAILURE;
}

typedef struct _INIT_FSD_CONTEXT {
    HANDLE hDevice;
    TCHAR FSDll[256];
} INIT_FSD_CONTEXT, * PINIT_FSD_CONTEXT;

//
// File system device entrypoints (DSK_????)
//

//
// Returns context data (PDISK) for this Init instance or 0 for failure.
//
// Arguments:
//      dwContext - registry path for this device's active key
//
DWORD
DSK_Init(
    DWORD dwContext
    )
{


//    RETAILMSG(1, (TEXT("MmcDISK: DSK_Init\r\n")));

    return (DWORD)mmcinit((LPTSTR)dwContext);
}   // DSK_Init


bool
DSK_Close(
    DWORD Handle
    )
{
    bool bClose = TRUE;
    PDISK pDisk = (PDISK)Handle;

    DEBUGMSG(ZONE_IO, (TEXT("MmcDISK: DSK_Close\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;
    } else {
        bClose = FALSE;
    }
    LeaveCriticalSection(&(pDisk->d_DiskCardCrit));
    }
    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     // pointer to the per disk structure
    )
{
    PDISK pDisk = (PDISK)dwContext;


    DSK_Close(dwContext);
    CloseDisk(pDisk);
    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 rett = 0;



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

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

    EnterCriticalSection(&(pDisk->d_DiskCardCrit));
    if (pDisk->d_DiskCardState == STATE_CLOSED) {
    pDisk->d_DiskCardState = STATE_OPENED;
    }
    rett = (DWORD)pDisk;
    pDisk->d_OpenCount++;
    LeaveCriticalSection(&(pDisk->d_DiskCardCrit));

    return rett;
}   // 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
    )
{
    PDISK pDisk = (PDISK)Handle;
    PSG_REQ pSG;


    if (IsValidDisk(pDisk) == FALSE) {
    SetLastError(ERROR_INVALID_HANDLE);
    return FALSE;
    }

    if (pDisk->d_DiskCardState != STATE_OPENED) {
    SetLastError(GetDiskStateError(pDisk->d_DiskCardState));
    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:
    case IOCTL_DISK_READ:
    case IOCTL_DISK_WRITE:
    case IOCTL_DISK_GETINFO:
    case IOCTL_DISK_SETINFO:
    case IOCTL_DISK_INITIALIZED:
    case IOCTL_DISK_DEVICE_INFO:
    if (pInBuf == NULL) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    break;

    case DISK_IOCTL_GETNAME:
    //case DISK_IOCTL_IDENTIFY:
    case IOCTL_DISK_GET_STORAGEID:  // this is a new op, so use new codes //
		if (pOutBuf == NULL) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    break;
    case DISK_IOCTL_FORMAT_MEDIA:
    SetLastError(ERROR_SUCCESS);
    return TRUE;
    
    default:
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
    }

    switch (dwIoControlCode) {
    case DISK_IOCTL_READ:
    case DISK_IOCTL_WRITE:
    case IOCTL_DISK_READ:
    case IOCTL_DISK_WRITE:
		pSG = (PSG_REQ)pInBuf;
    
    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_FORMAT_MEDIA:
    SetLastError(ERROR_SUCCESS);
    return TRUE;
  
    case DISK_IOCTL_GETNAME:
    return GetFolderName(pDisk, (LPWSTR)pOutBuf, nOutBufSize, pBytesReturned);

    case IOCTL_DISK_DEVICE_INFO:
    {
        PSTORAGEDEVICEINFO psdi = (PSTORAGEDEVICEINFO)pInBuf;
        if (nInBufSize == sizeof(STORAGEDEVICEINFO)) {
            wcscpy( psdi->szProfile, L"SDMMC");
            psdi->dwDeviceClass = STORAGE_DEVICE_CLASS_BLOCK;
            psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_REMOVABLE_MEDIA;
            psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_UNKNOWN;
            psdi->dwDeviceFlags |= STORAGE_DEVICE_FLAG_READWRITE;
            if (pBytesReturned)
                *pBytesReturned = sizeof(STORAGEDEVICEINFO);
            return TRUE;
        } else {
            SetLastError( ERROR_INVALID_PARAMETER);
            return FALSE;
        }
    }    
    

    case IOCTL_DISK_GET_STORAGEID:
    return GetStorageID(pDisk,
                (PSTORAGE_IDENTIFICATION)pOutBuf,
                nOutBufSize,
                pBytesReturned);


    default:
    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)
{
	hw_powerup();
}
void DSK_PowerDown(void) 
{
	hw_powerdown();
}


//
// Returns TRUE if the MMC card is inserted
//
bool
IsCardInserted(
    PDISK pDisk
    )
{
    INT16 logical_drive;

    logical_drive = (0xFFFF & (INT16)pDisk->d_DrvNo); 


    // Check for MMC card presenting and working
    if (is_device_changed (logical_drive))
    return FALSE;

    return TRUE;

}   // IsCardInserted


//
// mmcinit:
//
// ActivePath is the registry path to our device's active key under
// HKEY_LOCAL_MACHINE\Drivers\Active
// Allocate storage to hold a copy of this and point pDisk->d_ActivePath
// to it. This will be used in getfoldername call.
//
// Return pointer to new disk structure or NULL.
//
PDISK
mmcinit(
    LPTSTR ActiveKey
    )
{
    DWORD status;
    PDISK pDisk;
    HKEY hKey;

    pDisk = CreateDiskObject();
    if (pDisk == NULL) {
    RETAILMSG(1, (TEXT("MmcDisk LocalAlloc(PDISK) failed %d\r\n"), GetLastError()));
    return NULL;
    }
    if (pDisk->d_ActivePath = LocalAlloc(LPTR, wcslen(ActiveKey)*sizeof(WCHAR)+sizeof(WCHAR))) {
    wcscpy(pDisk->d_ActivePath, ActiveKey);
    }


	hKey = OpenDriverKey( ActiveKey);
	RegCloseKey( hKey);
    //
    // InitDisk 
    //
    status = InitDisk(pDisk);
    if (status) {
    goto ci_fail;
    }



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


ci_fail:
/*    pDisk->d_pDataReg = NULL;*/


    CloseDisk(pDisk);
    return NULL;
}   // mmcinit