sdmemmain.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//

// Copyright (c) 2002 BSQUARE Corporation.  All rights reserved.
// DO NOT REMOVE --- BEGIN EXTERNALLY DEVELOPED SOURCE CODE ID 40973--- DO NOT REMOVE

// Driver entry points for SD Memory Card client driver

#include "SDMemory.h"
#include <ceddk.h>

    // initialize debug zones
SD_DEBUG_INSTANTIATE_ZONES(
     TEXT("SDMemory"), // module name
     ZONE_ENABLE_INIT | ZONE_ENABLE_ERROR | ZONE_ENABLE_WARN,   // initial settings
     TEXT("Disk I/O"),
     TEXT("Card I/O"),
     TEXT("Bus Requests"),
     TEXT("Power"),
     TEXT(""),
     TEXT(""),
     TEXT(""),
     TEXT(""),
     TEXT(""),
     TEXT(""),
     TEXT(""));

DWORD SetDiskInfo( PSD_MEMCARD_INFO, PDISK_INFO );
DWORD GetDiskInfo( PSD_MEMCARD_INFO, PDISK_INFO );
DWORD GetStorageID( PSD_MEMCARD_INFO, PSTORAGE_IDENTIFICATION, DWORD, DWORD* );
BOOL GetDeviceInfo(PSD_MEMCARD_INFO pMemCard, PSTORAGEDEVICEINFO pStorageInfo);

#define DEFAULT_MEMORY_TAGS 4

///////////////////////////////////////////////////////////////////////////////
//  DllEntry - the main dll entry point
//  Input:  hInstance - the instance that is attaching
//          Reason - the reason for attaching
//          pReserved - not much
//  Output:
//  Return: always returns TRUE
//  Notes:  this is only used to initialize the zones
///////////////////////////////////////////////////////////////////////////////
extern "C" BOOL WINAPI DllEntry(HINSTANCE hInstance, ULONG Reason, LPVOID pReserved)
{
    BOOL fRet = TRUE;

    if ( Reason == DLL_PROCESS_ATTACH ) {
        if (!SDInitializeCardLib()) {
            fRet = FALSE;
        }
    }
    else if ( Reason == DLL_PROCESS_DETACH ) {
        SDDeinitializeCardLib();
    }

    return fRet;
}

///////////////////////////////////////////////////////////////////////////////
//  SMC_Close - the close entry point for the memory driver
//  Input:  hOpenContext - the context returned from SMC_Open
//  Output:
//  Return: always returns TRUE
//  Notes:
///////////////////////////////////////////////////////////////////////////////
extern "C" BOOL WINAPI SMC_Close(DWORD hOpenContext)
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (TEXT("SDMemory: +-SMC_Close\n")));
    return TRUE;
}

///////////////////////////////////////////////////////////////////////////////
//  CleanUpDevice - cleanup the device instance
//  Input:  pDevice - device instance
//  Output:
//  Return:
//  Notes:
///////////////////////////////////////////////////////////////////////////////
VOID CleanUpDevice(PSD_MEMCARD_INFO pDevice)
{
    DeinitializePowerManagement(pDevice);

    // acquire removal lock
    AcquireRemovalLock(pDevice);

    if (NULL != pDevice->pRegPath) {
        // free the reg path
        SDFreeMemory(pDevice->pRegPath);
    }

    if (NULL != pDevice->hBufferList) {
        // delete the buffer memory list
        SDDeleteMemList(pDevice->hBufferList);
    }

    ReleaseRemovalLock(pDevice);

    DeleteCriticalSection(&pDevice->RemovalLock);
    DeleteCriticalSection(&pDevice->CriticalSection);

    // free the sterile I/O request
    if (NULL != pDevice->pSterileIoRequest) {
        LocalFree(pDevice->pSterileIoRequest);
        pDevice->pSterileIoRequest = NULL;
    }

    // free the device memory
    SDFreeMemory(pDevice);
}

///////////////////////////////////////////////////////////////////////////////
//  SMC_Deinit - the deinit entry point for the memory driver
//  Input:  hDeviceContext - the context returned from SMC_Init
//  Output:
//  Return: always returns TRUE
//  Notes:
///////////////////////////////////////////////////////////////////////////////
extern "C" BOOL WINAPI SMC_Deinit(DWORD hDeviceContext)
{
    PSD_MEMCARD_INFO pDevice;

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: +SMC_Deinit\n")));

    pDevice = (PSD_MEMCARD_INFO)hDeviceContext;

        // now it is safe to clean up
    CleanUpDevice(pDevice);

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SMC_Deinit\n")));

    return TRUE;
}

///////////////////////////////////////////////////////////////////////////////
//  SlotEventCallBack - slot event callback for fast-path events
//  Input:  hDevice - device handle
//          pContext - device specific context that was registered
//          SlotEventType - slot event type
//          pData - Slot event data (can be NULL)
//          DataLength - length of slot event data (can be 0)
//  Output:
//  Return:
//  Notes:
//
//      If this callback is registered the client driver can be notified of
//      slot events (such as device removal) using a fast path mechanism.  This
//      is useful if a driver must be notified of device removal
//      before its XXX_Deinit is called.
//
//      This callback can be called at a high thread priority and should only
//      set flags or set events.  This callback must not perform any
//      bus requests or call any apis that can perform bus requests.
///////////////////////////////////////////////////////////////////////////////
VOID SlotEventCallBack(SD_DEVICE_HANDLE    hDevice,
                       PVOID               pContext,
                       SD_SLOT_EVENT_TYPE  SlotEventType,
                       PVOID               pData,
                       DWORD               DataLength)
{
    PSD_MEMCARD_INFO pDevice;

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: +SlotEventCallBack - %d \n"),SlotEventType));

    switch (SlotEventType) {
        case SDCardEjected :
            pDevice = (PSD_MEMCARD_INFO)pContext;
                // mark that the card is being ejected
            pDevice->CardEjected = TRUE;
                // acquire the removal lock to block this callback
                // in case an ioctl is in progress
            AcquireRemovalLock(pDevice);
            ReleaseRemovalLock(pDevice);

            break;

    }

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SlotEventCallBack \n")));
}

///////////////////////////////////////////////////////////////////////////////
//  SMC_Init - the init entry point for the memory driver
//  Input:  dwContext - the context for this init
//  Output:
//  Return: non-zero context
//  Notes:
///////////////////////////////////////////////////////////////////////////////
extern "C" DWORD WINAPI SMC_Init(DWORD dwContext)
{
    SD_DEVICE_HANDLE                hClientHandle;  // client handle
    PSD_MEMCARD_INFO                pDevice;        // this instance of the device
    SDCARD_CLIENT_REGISTRATION_INFO ClientInfo;     // client into
    ULONG                           BufferSize;     // size of buffer
    HKEY                            hSubKey;        // registry key
    SD_API_STATUS                   Status;         // intermediate status
    DWORD                           data;           // registry data
    DWORD                           dataLength;     // registry data length

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: +SMC_Init\r\n")));

    pDevice = (PSD_MEMCARD_INFO)SDAllocateMemoryWithTag(
        sizeof(SD_MEMCARD_INFO),
        SD_MEMORY_TAG);
    if (pDevice == NULL) {
        DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDMemory: Failed to allocate device info\r\n")));
        DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SMC_Init\r\n")));
        return 0;
    }

    // initialize sterile I/O request to NULL
    pDevice->pSterileIoRequest = NULL;

    InitializeCriticalSection(&pDevice->CriticalSection);
    InitializeCriticalSection(&pDevice->RemovalLock);

    // get the device handle from the bus driver
    hClientHandle = SDGetDeviceHandle(dwContext, &pDevice->pRegPath);
    // store device handle in local context
    pDevice->hDevice = hClientHandle;
    if (NULL == hClientHandle) {
        DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDMemory: Failed to get client handle\r\n")));
        CleanUpDevice(pDevice);
        DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SMC_Init\r\n")));
        return 0;
    }

    // allocate sterile I/O request
    pDevice->pSterileIoRequest = (PSG_REQ)LocalAlloc(
        LPTR,
        (sizeof(SG_REQ) + ((MAX_SG_BUF - 1) * sizeof(SG_BUF)))
        );
    if (NULL == pDevice->pSterileIoRequest) {
        DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDMemory: Failed to allocate sterile I/O request\r\n")));
        CleanUpDevice(pDevice);
        DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SMC_Init\r\n")));
        return 0;
    }

    // register our debug zones
    SDRegisterDebugZones(hClientHandle, pDevice->pRegPath);

    memset(&ClientInfo, 0, sizeof(ClientInfo));

    // set client options and register as a client device
    _tcscpy(ClientInfo.ClientName, TEXT("Memory Card"));

    // set the callback
    ClientInfo.pSlotEventCallBack = SlotEventCallBack;

    Status = SDRegisterClient(hClientHandle, pDevice, &ClientInfo);
    if (!SD_API_SUCCESS(Status)) {
        DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDMemory: Failed to register client : 0x%08X\r\n"),
            Status));
        CleanUpDevice(pDevice);
        DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SMC_Init\r\n")));
        return 0;
    }

    // configure card and retrieve disk size/format information
    if( SDMemCardConfig( pDevice ) != ERROR_SUCCESS ) {
        CleanUpDevice(pDevice);
        DEBUGMSG( SDCARD_ZONE_ERROR, (TEXT("SDMemory: Error initializing MemCard structure and card\r\n")));
        return 0;
    }

    // aet a default block transfer size
    pDevice->BlockTransferSize = DEFAULT_BLOCK_TRANSFER_SIZE;

    // read configuration from registry

    // open the reg path
    if (RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        pDevice->pRegPath,
        0,
        KEY_ALL_ACCESS,
        &hSubKey) == ERROR_SUCCESS
    ) {
        // read "BlockTransferSize"
        dataLength = sizeof(pDevice->BlockTransferSize);
        RegQueryValueEx(
            hSubKey,
            BLOCK_TRANSFER_SIZE_KEY,
            NULL,
            NULL,
            (PUCHAR)&(pDevice->BlockTransferSize),
            &dataLength);
        if (pDevice->BlockTransferSize != DEFAULT_BLOCK_TRANSFER_SIZE) {
            DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: Initialize: Using block transfer size of %d blocks\r\n"),
                   pDevice->BlockTransferSize));
        }

        // read "SingleBlockWrites"
        // default to using mulitple block writes
        pDevice->SingleBlockWrites = FALSE;
        dataLength = sizeof(DWORD);
        data = 0;
        if (RegQueryValueEx(
            hSubKey,
            SINGLE_BLOCK_WRITES_KEY,
            NULL,
            NULL,
            (PUCHAR)&data,
            &dataLength) == ERROR_SUCCESS
        ) {
            // key is present
            pDevice->SingleBlockWrites = TRUE;
            DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: Initialize: Using single block write commands only\r\n")));
        }

        // read "DisablePowerManagement"
        // on by default unless key is present
        pDevice->EnablePowerManagement = TRUE;
        dataLength = sizeof(DWORD);
        data = 0;
        if (RegQueryValueEx(
            hSubKey,
            DISABLE_POWER_MANAGEMENT,
            NULL,
            NULL,
            (PUCHAR)&data,
            &dataLength) == ERROR_SUCCESS
        ) {
            // key is present
            DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: Initialize: Disabled power management\r\n")));
            pDevice->EnablePowerManagement = FALSE;
        }

        // read "IdleTimeout"
        pDevice->IdleTimeout = DEFAULT_IDLE_TIMEOUT;
        dataLength = sizeof(pDevice->IdleTimeout);
        if (RegQueryValueEx(
            hSubKey,
            IDLE_TIMEOUT,
            NULL,
            NULL,