ohcddrv.cpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

/*++
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.
Copyright (c) 1995-1998  Microsoft Corporation

Module Name:  
    ohcddrv.cpp

Abstract:  
    
Notes: 

Revision History:

	2/3/00	dma		Removed assertion which is not valid for HD64465

--*/

// There are four warnings that I like from Warning level 4.  Since we build
// at warning level 3, I'm setting these four down to level 3 so I still get
// them.
// C4100 unrefrenced formal parameter
// C4101 unrefrenced local variable
// C4705 statement has no effect
// C4706 assignment in conditional
#pragma warning (3 : 4100 4101 4705 4706)

#include <windows.h>
#include <types.h>      // For UINT8 etc.
#include <ceddk.h>
#include <cardserv.h>
#include <devload.h>
#include <ohcdddsi.h>

#include "hcdi.h"
#include "globals.hpp"
#include "mem.hpp"
#include "ohcdinc.hpp"
#include "ohcd.hpp"

/* Debug Zones.
 */
#ifdef DEBUG

#define DBG_INIT                0x0001
#define DBG_ATTACH              0x0002
#define DBG_DESCRIPTORS         0x0004
#define DBG_HUB                 0x0008
#define DBG_PCI                 0x0010
#define DBG_INTR                0x0020
#define DBG_TD                  0x0040
#define DBG_ED                  0x0080
#define DBG_CRITICAL            0x0100
#define DBG_UNUSED1             0x0200
#define DBG_UNUSED2             0x0400
#define DBG_UNUSED3             0x0800
#define DBG_ALLOC               0x1000
#define DBG_FUNCTION            0x2000
#define DBG_WARNING             0x4000
#define DBG_ERROR               0x8000

DBGPARAM dpCurSettings = {
    TEXT("Ohcd"), {
        TEXT("Init"), TEXT("Attach/Detach"), TEXT("Descriptors"), TEXT("Hub"),
        TEXT("PCI"), TEXT("Interrupts"), TEXT("TDs"), TEXT("EDs"),
        TEXT("Critical Thread"), TEXT("Unused"), TEXT("Unused"),TEXT("Unused"), 
        TEXT("Alloc"), TEXT("Functions"),TEXT("Warnings"), TEXT("Errors")},
    DBG_ERROR | DBG_WARNING};
#endif

extern "C" HINSTANCE g_hInstance;
DWORD g_IstThreadPriority;

// By wrapping these two in an #ifdef DEBUG, I can rely on the complier to
// make sure I didn't use them in a retail build.
// I'm just not doing that right now because I'm still using these for testing.
#ifdef DEBUG


void __cdecl
DbgPrintf(PTCHAR pszFormat, ...)
{
    static TCHAR        szDebugStr[128] = TEXT("Ohcd:");

    va_list ap;

    va_start(ap, pszFormat);

    wvsprintf(&szDebugStr[5], pszFormat, ap);

    OutputDebugString(szDebugStr);
}

void __cdecl
Printf(PTCHAR pszFormat, ...)
{
    static TCHAR        szDebugStr[128];

    va_list ap;

    va_start(ap, pszFormat);

    wvsprintf(&szDebugStr[0], pszFormat, ap);

    OutputDebugString(szDebugStr);
}
#endif //DEBUG

extern HCD_FUNCS gc_HcdFuncs =
{
    sizeof(HCD_FUNCS),      //DWORD                   dwCount;

    &HcdGetFrameNumber,     //LPHCD_GET_FRAME_NUMBER      lpGetFrameNumber;
    &HcdGetFrameLength,     //LPHCD_GET_FRAME_LENGTH      lpGetFrameLength;
    &HcdSetFrameLength,     //LPHCD_SET_FRAME_LENGTH      lpSetFrameLength;
    &HcdStopAdjustingFrame, //LPHCD_STOP_ADJUSTING_FRAME  lpStopAdjustingFrame;
    &HcdOpenPipe,           //LPHCD_OPEN_PIPE             lpOpenPipe;
    &HcdClosePipe,          //LPHCD_CLOSE_PIPE            lpClosePipe;
    &HcdResetPipe,          //LPHCD_RESET_PIPE            lpResetPipe;
    &HcdIsPipeHalted,       //LPHCD_IS_PIPE_HALTED        lpIsPipeHalted;
    &HcdIssueTransfer,      //LPHCD_ISSUE_TRANSFER        lpIssueTransfer;
    &HcdAbortTransfer       //LPHCD_ABORT_TRANSFER        lpAbortTransfer;
};

BOOL WINAPI DllMain(HANDLE hinstDLL, DWORD dwReason, LPVOID lpvReserved)
{
	if ( dwReason == DLL_PROCESS_ATTACH ) {
		DEBUGREGISTER((HINSTANCE)hinstDLL);
        DEBUGMSG (ZONE_INIT,(TEXT("OHCD driver DLL attach\r\n")));
    }
    return OhcdPdd_DllMain(hinstDLL, dwReason, lpvReserved);
}


static BOOL HcdGetFrameNumber(LPVOID lpvHcd, LPDWORD lpdwFrameNumber)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->GetFrameNumber(lpdwFrameNumber);
}

static BOOL HcdGetFrameLength(LPVOID lpvHcd, LPUSHORT lpuFrameLength)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->GetFrameLength(lpuFrameLength);
}

static BOOL HcdSetFrameLength(LPVOID lpvHcd, HANDLE hEvent, USHORT uFrameLength)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->SetFrameLength(hEvent, uFrameLength);
}

static BOOL HcdStopAdjustingFrame(LPVOID lpvHcd)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->StopAdjustingFrame();
}

static BOOL HcdOpenPipe(LPVOID lpvHcd, UINT iDevice,
        LPCUSB_ENDPOINT_DESCRIPTOR lpEndpointDescriptor,
        LPUINT lpiEndpointIndex)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->OpenPipe(iDevice, lpEndpointDescriptor, lpiEndpointIndex);
}

static BOOL HcdClosePipe(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->ClosePipe(iDevice, iEndpointIndex);
}

static BOOL HcdResetPipe(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->ResetPipe(iDevice, iEndpointIndex);
}

static BOOL HcdIsPipeHalted(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex, LPBOOL lpbHalted)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->IsPipeHalted(iDevice, iEndpointIndex, lpbHalted);
}

static BOOL HcdIssueTransfer(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex,
        LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter,
        DWORD dwFlags, LPCVOID lpvControlHeader,
        DWORD dwStartingFrame, DWORD dwFrames, LPCDWORD aLengths,
        DWORD dwBufferSize, LPVOID lpvBuffer, ULONG paBuffer,
        LPCVOID lpvCancelId, LPDWORD adwIsochErrors, LPDWORD adwIsochLengths,
        LPBOOL lpfComplete, LPDWORD lpdwBytesTransfered, LPDWORD lpdwError)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->IssueTransfer(iDevice, iEndpointIndex, lpStartAddress,
            lpParameter, dwFlags, lpvControlHeader, dwStartingFrame, dwFrames,
            aLengths, dwBufferSize, lpvBuffer, paBuffer, lpvCancelId,
            adwIsochErrors, adwIsochLengths,lpfComplete, lpdwBytesTransfered,
            lpdwError);
}

static BOOL HcdAbortTransfer(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex,
        LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter,
        LPCVOID lpvCancelId)
{
    COhcd * const pOhcd = (COhcd *)lpvHcd;
    return pOhcd->AbortTransfer(iDevice, iEndpointIndex, lpStartAddress,
            lpParameter, lpvCancelId);
}



// -----------------------------------------------------------------------------
// Function to read the interrupt thread priority from the registry.
// If it is not in the registry then a default value is returned.
// -----------------------------------------------------------------------------
static DWORD
GetInterruptThreadPriority(
    LPWSTR lpszActiveKey
    )
{
    HKEY hDevKey;
    DWORD dwValType;
    DWORD dwValLen;
    DWORD dwPrio;

    dwPrio = DEFAULT_OHCD_IST_PRIORITY;

    hDevKey = OpenDeviceKey(lpszActiveKey);
    if (hDevKey) {
        dwValLen = sizeof(DWORD);
        RegQueryValueEx(
            hDevKey,
            TEXT("Priority256"),
            NULL,
            &dwValType,
            (PUCHAR)&dwPrio,
            &dwValLen);
        RegCloseKey(hDevKey);
    }
    return dwPrio;
}


extern "C" LPVOID OhcdMdd_CreateMemoryObject(DWORD cbSize, DWORD cbHighPrioritySize, 
                                             PUCHAR pVirtAddr, PUCHAR pPhysAddr)
{
    //
    // We need at least a USBPAGE for Special allocation and a PAGE for normal
    // allocation.
    //
	// The following assertion is not valid for HD64465
#if 0
    ASSERT((cbHighPrioritySize + (2*USBPAGESIZE)) < cbSize);
#endif

    CPhysMem * pobMem = new CPhysMem(cbSize,cbHighPrioritySize,pVirtAddr,pPhysAddr);

    return pobMem;
}

extern "C" LPVOID OhcdMdd_CreateOhcdObject(LPVOID lpvOhcdPddObject,
        LPVOID lpvMemoryObject, LPCWSTR szRegKey, PUCHAR ioPortBase,
        DWORD dwSysIntr)
{
    CPhysMem * pobMem = (CPhysMem *)lpvMemoryObject;
    COhcd * pobOhcd = new COhcd(lpvOhcdPddObject, pobMem, szRegKey, ioPortBase,
            dwSysIntr);
    if(pobOhcd->Initialize() == FALSE)
    {
        delete pobOhcd;
        pobOhcd = NULL;
    }

    return pobOhcd;
}

extern "C" BOOL OhcdMdd_DestroyOhcdObject(LPVOID lpvOhcdObject)
{
    COhcd * pobOhcd = (COhcd *)lpvOhcdObject;
    delete pobOhcd;

    return TRUE;
}

extern "C" BOOL OhcdMdd_DestroyMemoryObject(LPVOID lpvMemoryObject)
{
    CPhysMem * pobMem = (CPhysMem *)lpvMemoryObject;
    delete pobMem;

    return TRUE;
}

extern "C" BOOL OhcdMdd_PowerUp(LPVOID lpvOhcdObject)
{
    COhcd * pobOhcd = (COhcd *)lpvOhcdObject;
    pobOhcd->PowerMgmtCallback(FALSE);

    return TRUE;
}

extern "C" BOOL OhcdMdd_PowerDown(LPVOID lpvOhcdObject)
{
    COhcd * pobOhcd = (COhcd *)lpvOhcdObject;
    pobOhcd->PowerMgmtCallback(TRUE);

    return TRUE;
}







// Stream functions
extern "C" DWORD HCD_Init(DWORD dwContext)
{
    DEBUGMSG (ZONE_INIT, (TEXT("OHCD: HCD_Init\r\n")));
    g_IstThreadPriority = GetInterruptThreadPriority((LPWSTR)dwContext);
    return OhcdPdd_Init(dwContext);
}


extern "C" void HCD_PowerUp(DWORD hDeviceContext)
{
    OhcdPdd_PowerUp(hDeviceContext);

    return;
}


extern "C" void HCD_PowerDown(DWORD hDeviceContext)
{
    OhcdPdd_PowerDown(hDeviceContext);

    return;
}


extern "C" BOOL HCD_Deinit(DWORD hDeviceContext)
{
    DEBUGMSG (ZONE_INIT, (TEXT("OHCD: HCD_Deinit\r\n")));
    return OhcdPdd_Deinit(hDeviceContext);
}


extern "C" DWORD HCD_Open(DWORD hDeviceContext, DWORD AccessCode,
        DWORD ShareMode)
{
    return OhcdPdd_Open(hDeviceContext, AccessCode, ShareMode);
}


extern "C" BOOL HCD_Close(DWORD hOpenContext)
{
    return OhcdPdd_Close(hOpenContext);
}


extern "C" DWORD HCD_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
    return OhcdPdd_Read(hOpenContext, pBuffer, Count);
}


extern "C" DWORD HCD_Write(DWORD hOpenContext, LPCVOID pSourceBytes,
        DWORD NumberOfBytes)
{
    return OhcdPdd_Write(hOpenContext, pSourceBytes, NumberOfBytes);
}


extern "C" DWORD HCD_Seek(DWORD hOpenContext, LONG Amount, DWORD Type)
{
    return OhcdPdd_Seek(hOpenContext, Amount, Type);
}


extern "C" BOOL HCD_IOControl(DWORD hOpenContext, DWORD dwCode, PBYTE pBufIn,
        DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut)
{
    return OhcdPdd_IOControl(hOpenContext, dwCode, pBufIn, dwLenIn, pBufOut,
            dwLenOut, pdwActualOut);
}