init.c

YLP270的Windows CE5.0 bsp源码。

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

    init.c

Abstract:

    This file implements the PCMCIA model device driver initialization functions
    This is provided as a sample to platform writers and is
    expected to be able to be used without modification on most (if not
    all) hardware platforms.

Functions:

    CardSystemInit()
    InitAdapterInfo()
    InitSocketInfo()
    BitNumber()
    InitWindowInfo()
    DeInitCardSvc()
    InitCardSvc()
    DllEntry()

Notes:


--*/

#include <windows.h>
#include <types.h>
#include <cardserv.h>
#include <sockserv.h>
#include <linklist.h>
#include <pcmcia.h>
#include <nkintr.h>
#include <extern.h>

#ifdef INSTRUM_DEV
#include <instrumd.h>
#endif

extern UINT StatusChangeThread(UINT Nothing);
extern UINT IREQThread(UINT Nothing);
extern UINT CallbackThread(UINT Nothing);
extern BOOL v_bSharedIntr;

#ifdef DEBUG

//
// These defines must match the ZONE_* defines in PCMCIA.H
//
#define DBG_ERROR      1
#define DBG_WARNING    2
#define DBG_FUNCTION   4
#define DBG_CALLBACK   8
#define DBG_STSCHG     16
#define DBG_IREQ       32
#define DBG_INIT       64
#define DBG_MEM        128
#define DBG_PDD        256
#define DBG_POWER      512
#define DBG_TUPLE      1024

DBGPARAM dpCurSettings = {
    TEXT("PCMCIA"), {
    TEXT("Errors"),TEXT("Warnings"),TEXT("Functions"),TEXT("Callbacks"),
    TEXT("STSCHG Int"),TEXT("IREQ Int"),TEXT("Init"),TEXT("Memory"),
    TEXT("PDD"),TEXT("Power"),TEXT("CIS Tuples"),TEXT("Undefined"),
    TEXT("Undefined"),TEXT("Undefined"),TEXT("Undefined"),TEXT("Undefined") },
    DBG_INIT
};
#endif  // DEBUG

HINSTANCE g_hPcmDll;
DWORD g_LoaderPrio;      // Thread priority of FindDriversThread
CARD_CLIENT_HANDLE v_hNextClient;

#define DEFAULT_IREQ_PRIO           105
#define CALLBACK_RELATIVE_PRIO      1
#define STATUSCHANGE_RELATIVE_PRIO  2

#define KEYNAME_PCMCIA_DRIVER   TEXT("\\Drivers\\PCMCIA")
#define VALNAME_THREAD_PRIO     TEXT("Priority256")
#define VALNAME_ACTIVITY_EVENT  TEXT("StatusChangeActivityEvent")

//
// GetPCMCIAThreadPriority - Read the PCMCIA thread priority from the registry
//
// Return: Priority read from registry OR the default priority if not in registry.
//
DWORD GetPCMCIAThreadPriority(void)
{
    HKEY hKey;
    DWORD dwType;
    DWORD dwVal;
    DWORD dwSize;
    DWORD dwStatus;

    dwStatus = RegOpenKeyEx(
                    HKEY_LOCAL_MACHINE,
                    KEYNAME_PCMCIA_DRIVER,
                    0,
                    0,
                    &hKey
                    );
    if (dwStatus) {
        DEBUGMSG(ZONE_INIT, (TEXT("PCMCIA:GetPCMCIAThreadPriority - RegOpenKeyEx(%s) failed %d\n"),
            KEYNAME_PCMCIA_DRIVER, dwStatus));
        return DEFAULT_IREQ_PRIO;
    }

    dwSize = sizeof(DWORD);
    dwStatus = RegQueryValueEx(
                    hKey,
                    VALNAME_THREAD_PRIO,
                    0,
                    &dwType,
                    (PUCHAR)&dwVal,
                    &dwSize
                    );
    if (dwStatus) {
        DEBUGMSG(ZONE_INIT, (TEXT("PCMCIA:GetPCMCIAThreadPriority - RegQueryValueEx(%s) failed %d\n"),
            VALNAME_THREAD_PRIO, dwStatus));
        dwVal = DEFAULT_IREQ_PRIO;
    }

    RegCloseKey(hKey);
    return dwVal;
}   // GetPCMCIAThreadPriority

void GetPCMCIAPowerManagerEvent(void)
{
    HKEY hKey;
    DWORD dwType;
    DWORD dwSize;
    DWORD dwStatus;
    TCHAR ActivityEvent[128];

    v_PowerManagerEvent = NULL;
    dwStatus = RegOpenKeyEx(
                    HKEY_LOCAL_MACHINE,
                    KEYNAME_PCMCIA_DRIVER,
                    0,
                    0,
                    &hKey
                    );
    if (dwStatus) {
        DEBUGMSG(ZONE_INIT, (TEXT("PCMCIA:GetPCMCIAPowerManagerEvent - RegOpenKeyEx(%s) failed %d\n"),
            KEYNAME_PCMCIA_DRIVER, dwStatus));
        return;
    }

    dwSize = sizeof(ActivityEvent);
    dwStatus = RegQueryValueEx(
                    hKey,
                    VALNAME_ACTIVITY_EVENT,
                    0,
                    &dwType,
                    (PUCHAR)&ActivityEvent[0],
                    &dwSize
                    );
    if (dwStatus) {
        DEBUGMSG(ZONE_INIT, (TEXT("PCMCIA:GetPCMCIAPowerManagerEvent - RegQueryValueEx(%s) failed %d\n"),
            VALNAME_THREAD_PRIO, dwStatus));
    } else {
        v_PowerManagerEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, ActivityEvent);
    }

    RegCloseKey(hKey);
    return;
}   // GetPCMCIAPowerManagerEvent

//
// CardSystemInit
//
// @func    STATUS | CardSystemInit | Indicate to card services that the
// operating system has initialized.
// @rdesc   Return CERR_SUCCESS
//
// @comm    There are system dependencies at initialization time that require
// card services to wait before detecting cards that were inserted before
// system boot.
//
STATUS
CardSystemInit(VOID)
{
    DEBUGMSG(ZONE_INIT|ZONE_FUNCTION,
        (TEXT("PCMCIA:CardSystemInit entered\r\n")));
    DEBUGMSG(ZONE_INIT|ZONE_FUNCTION,
        (TEXT("PCMCIA:CardSystemInit succeeded\r\n")));
    return CERR_SUCCESS;
}   // CardSystemInit

//
// Get adapter info using the PDCardInquireAdapter() PDD function.
//
BOOL InitAdapterInfo(void)
{
    STATUS ret;
    PDCARD_ADAPTER_INFO adpt;

    //
    // Call it twice. The first time is to get the size.
    //
    adpt.uPowerEntries = 0;
    ret = PDCardInquireAdapter(&adpt);
    if (!((ret == CERR_BAD_ARG_LENGTH) || (ret == CERR_SUCCESS))) {
        DEBUGMSG(ZONE_INIT|ZONE_WARNING,
            (TEXT("PCMCIA:InitAdapterInfo PDCardInquireAdapter returned %d\r\n"), ret));
        return FALSE;
    }

    v_pAdapterInfo = alloc(sizeof(PDCARD_ADAPTER_INFO) +
                           sizeof(PDCARD_POWER_ENTRY)*adpt.uPowerEntries);
    if (v_pAdapterInfo == NULL) {
        return FALSE;
    }
#ifdef MYMEMTRACKING
    v_TrackSocketInfo++;
#endif
#ifdef MEMTRACKING
    AddTrackedItem(v_TrackSocketInfo, v_pAdapterInfo, NULL, GetCurrentProcessId(),
        sizeof(PDCARD_ADAPTER_INFO) + sizeof(PDCARD_POWER_ENTRY)*adpt.uPowerEntries,
        0, 0);
#endif

    v_pAdapterInfo->uPowerEntries = adpt.uPowerEntries;
    ret = PDCardInquireAdapter(v_pAdapterInfo);
    if (ret != CERR_SUCCESS) {
        free(v_pAdapterInfo);
#ifdef MYMEMTRACKING
    v_TrackSocketInfo--;
#endif
#ifdef MEMTRACKING
    DeleteTrackedItem(v_TrackSocketInfo, v_pAdapterInfo);
#endif
        v_pAdapterInfo = NULL;
        return FALSE;
    }

    return TRUE;
}   // InitAdapterInfo


//
// Build list of available PCMCIA sockets.
//
BOOL InitSocketInfo(void)
{
    HKEY hKey;
    DWORD dwType;
    DWORD dwVal;
    DWORD dwSize;
    DWORD dwStatus;
    PDCARD_SOCKET_STATE SockState;
    PPHYS_SOCKET pSock;
    STATUS ret;
    TCHAR AccessName[10];

    v_cSockets = 0;
    pSock = v_Sockets;
    ret = CERR_SUCCESS;

    dwStatus = RegOpenKeyEx(
                    HKEY_LOCAL_MACHINE,
                    KEYNAME_PCMCIA_DRIVER,
                    0,
                    0,
                    &hKey
                    );
    if (dwStatus) {
        DEBUGMSG(ZONE_INIT, (TEXT("PCMCIA:InitSocketInfo - RegOpenKeyEx(%s) failed %d\n"),
            KEYNAME_PCMCIA_DRIVER, dwStatus));
        hKey = NULL;
    }

    while ((ret == CERR_SUCCESS) && (v_cSockets <= MAX_SOCKETS)) {
        ret = PDCardGetSocket(v_cSockets, &SockState);
        if (ret == CERR_SUCCESS) {
            pSock->pDevId = NULL;
            pSock->pLsock = NULL;
            pSock->pAttrWin = NULL;
            pSock->pCmnWin = NULL;
            pSock->cFunctions = 0;
            pSock->PowerState = POWER_NORMAL;
            pSock->DetectState = DETECT_NONE;
            pSock->fFlags = SockState.fInterruptEvents;
            pSock->fFlags |= (SockState.fSocketCaps  << 8);
            pSock->fFlags |= (SockState.fControlCaps << 16);

            if (hKey != NULL) {
                _tcsncpy(AccessName, L"NoAccess", 8);
                AccessName[8] = '0' + v_cSockets;
                AccessName[9] = 0;
                dwSize = sizeof(DWORD);
                dwStatus = RegQueryValueEx(
                                hKey,
                                AccessName,
                                0,
                                &dwType,
                                (PUCHAR)&dwVal,
                                &dwSize
                                );
                if (dwStatus == ERROR_SUCCESS && dwVal != 0) {
                    pSock->fFlags |= PHYS_SOCK_FLAG_NOT_USER_ACCESS;
                }
            }

            SockState.fInterruptEvents = INITIAL_SOCKET_EVENTS;
            SockState.fIREQRouting = 0;
            ret = PDCardSetSocket(v_cSockets, &SockState);
            if (ret != CERR_SUCCESS) {
                DEBUGMSG(ZONE_INIT|ZONE_WARNING,
                    (TEXT("PCMCIA:InitSocketInfo PDCardSetSocket returned %d\r\n"), ret));
            }
            v_cSockets++;
            pSock++;
        }
    }

    if (hKey != NULL)
        RegCloseKey(hKey);

    if (v_cSockets)
        return TRUE;

    DEBUGMSG(ZONE_INIT|ZONE_WARNING,
        (TEXT("PCMCIA: %d sockets in the system\r\n"), v_cSockets));
    return FALSE;
}   // InitSocketInfo


//
// Return number of first bit that is set in the mask.
//
UINT
BitNumber(
    UINT fBitMask
    )
{
    UINT i;

    for (i = 0; i < 32; i++) {
        if (fBitMask & 1) {
            return i;
        }
        fBitMask >>= 1;
    }
    // What should be returned if no bit is set?
    return i;
}   // BitNumber


//
// Build a list of available memory and I/O windows
//
BOOL
InitWindowInfo(void)
{
    UINT32 uWindow = 0;
    PDCARD_WINDOW_INFO WinInfo;
    PDCARD_WINDOW_STATE WinState;
    PPHYS_WINDOW pPhys;
    PPHYS_WINDOW pTmp;
    STATUS ret = CERR_SUCCESS;

#ifdef DEBUG
    WCHAR Output[128];
#endif

    v_cWindows = 0;
    v_pWinList = NULL;

    while (ret == CERR_SUCCESS) {
        ret = PDCardInquireWindow(uWindow, &WinInfo);
        if (ret == CERR_SUCCESS) {
            if ((pPhys = alloc(sizeof(PHYS_WINDOW))) == NULL) {
                goto iwi_done;
            }

#ifdef MYMEMTRACKING
    v_TrackPhysicalWindowInfo++;
#endif
#ifdef MEMTRACKING
    AddTrackedItem(v_TrackPhysicalWindowInfo, pPhys, NULL, GetCurrentProcessId(),
        sizeof(PHYS_WINDOW), 0, 0);
#endif

            pPhys->uWindow = uWindow;
            pPhys->uSock = (UINT8)BitNumber(WinInfo.fSockets);
            pPhys->fFlags = 0;
            pPhys->fWindowCaps = WinInfo.fWindowCaps;