system.c

2443 wince5.0 bsp, source code

//
// 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 <pm.h> 
#include <ceddk.h>
      
#include <memory.h>

#include <types.h>
#include <wtypes.h>
#include <tchar.h>
#include <devload.h>
#include <nkintr.h>
#include <ddkreg.h>
#include <winnt.h>

#include <windev.h>
#include <storemgr.h>
#include "system.h"

// Processor Definitions






//
// 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 AtapiInit(LPTSTR ActiveKey);
DWORD GetDiskStateError(DWORD DiskState);
int  GetFolderName(PDISK pDisk, LPWSTR pOutBuf, DWORD nOutBufSize, DWORD * pBytesReturned);
int  GetStorageID(PDISK pDisk, PSTORAGE_IDENTIFICATION pOutBuf, DWORD nOutBufSize, DWORD * pBytesReturned);
HKEY OpenDriverKey(LPTSTR ActiveKey);
void FreeVirtualMemory(void);


CRITICAL_SECTION v_DiskCrit;
PDISK v_DiskList;                                       // initialized to 0 in bss
//volatile PUCHAR virtime;
CEDEVICE_POWER_STATE m_Dx;
DWORD g_dwContext;
PDEVICE_CONTROLLER g_pcPC;
PDRIVE_DESC g_pdPD;
DEVICE_CONTROLLER _dc;
DRIVE_DESC _dd;

extern volatile S3C2443_MATRIX_REG *g_vEBIRegs;
extern volatile S3C2443_CFCARD_REG *g_vATAPIRegs;
extern UINT8 *g_vDmaBuffer;
extern volatile S3C2443_IOPORT_REG *g_vIOPORTRegs;
extern  CRITICAL_SECTION        g_ControllerCriticalSection;     // controller critical section 

//
// ATAPI_CF.DLL entry
//
int WINAPI
DllMain(HINSTANCE DllInstance, DWORD Reason, LPVOID Reserved)
{
    
    switch(Reason) 
    {
    	case DLL_PROCESS_ATTACH:
	    DEBUGREGISTER(DllInstance);
	    InitializeCriticalSection(&v_DiskCrit);
	    DisableThreadLibraryCalls((HMODULE) DllInstance);
	    //RETAILMSG(RTL_MSG,(TEXT("ATAPI_CF::IS Being Loaded\r\n")));
	    break;
	return TRUE;

	case DLL_PROCESS_DETACH:
	    DeleteCriticalSection(&v_DiskCrit);
		//RETAILMSG(RTL_MSG,(TEXT("ATAPI_CF::IS Being UnLoaded\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.
//
int
IsValidDisk(
    PDISK pDisk
    )
{
    PDISK pd;
    int 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(RTL_MSG, (TEXT("ATAPI::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;
}



//
// 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
    )
{
	g_pcPC = &_dc;
	g_pdPD = &_dd;

	g_dwContext =(DWORD)AtapiInit((LPTSTR)dwContext);

	RETAILMSG(1,(TEXT("####### The string passed by DD is %s\r\n"),(WCHAR *)dwContext));
	m_Dx = D0;
	DevicePowerNotify(_T("DSK1:"),D0, POWER_NAME);
	return g_dwContext;
}  


int
DSK_Close(
    DWORD Handle
    )
{
    int 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.
//
int
DSK_Deinit(
    DWORD dwContext     // pointer to the per disk structure
    )
{
	PDISK pDisk = (PDISK)dwContext;


	CloseDisk(pDisk);			/* to delete critical section */
	DSK_Close(dwContext);

	FreeVirtualMemory();	/* to release memory allocted */

	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;

	RETAILMSG(1,(TEXT("### DSK_OPEN Called by DD\r\n")));


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

int
DSK_IOControl(
    DWORD Handle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
#if 1
    PDISK pDisk = (PDISK)Handle;
    PSG_REQ pSG;
    DWORD dwErr = ERROR_SUCCESS;    
    int  bRc = TRUE;

    UNREFERENCED_PARAMETER(Handle);

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

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

#if 1
    switch (dwIoControlCode) {
        //
        // Power Management
        //
        case IOCTL_POWER_CAPABILITIES: 
        {

		PPOWER_CAPABILITIES ppc;

		RETAILMSG(1,(TEXT("#############################1 \r\n")));            
            if ( !pBytesReturned || !pOutBuf || (nOutBufSize < sizeof(POWER_CAPABILITIES)) ) {
                bRc = FALSE;
                dwErr = ERROR_INVALID_PARAMETER;
		RETAILMSG(1,(TEXT("#############################11 \r\n")));          
                break;