system.c

来自「针对Intel Xscale PXA255的WinCE boot loader源」· C语言 代码 · 共 640 行 · 第 1/2 页

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


//For debug
#define IOTRACE 1
#define INIT 1


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);

extern BOOL	bWriteProtect;


//
// 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(INIT, (TEXT("SDMMC--DLL_PROCESS_ATTACH\r\n")));
    return TRUE;

    case DLL_PROCESS_DETACH:
    DeleteCriticalSection(&v_DiskCrit);
    RETAILMSG(INIT, (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(0, (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(INIT, (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