/*++
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:  
    phcddrv.cpp

Abstract:  
    
Notes: 

--*/

// 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 <phcdddsi.h>

#include "hcdi.h"
#include "globals.hpp"
#include "mem.hpp"
#include "phcdinc.hpp"
#include "phcd.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("Phcd"), {
        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("Phcd:");

    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("PHCD driver DLL attach\r\n")));
    }

    return PhcdPdd_DllMain(hinstDLL, dwReason, lpvReserved);
}


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

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

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

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

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

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

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

static BOOL HcdIsPipeHalted(LPVOID lpvHcd, UINT iDevice, UINT iEndpointIndex, LPBOOL lpbHalted)
{
    CPhcd * const pPhcd = (CPhcd *)lpvHcd;
    return pPhcd->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)
{
    CPhcd * const pPhcd = (CPhcd *)lpvHcd;
    return pPhcd->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)
{
    CPhcd * const pPhcd = (CPhcd *)lpvHcd;
    return pPhcd->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_PHCD_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 PhcdMdd_CreateMemoryObject(DWORD cbSize, DWORD cbHighPrioritySize, 
                                             PUCHAR pVirtAddr, PUCHAR pPhysAddr)
{
    //
    // We need at least a USBPAGE for Special allocation and a PAGE for normal
    // allocation.
    //
    ASSERT((cbHighPrioritySize + (2*USBPAGESIZE)) < cbSize);

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

    return pobMem;
}

extern "C" LPVOID PhcdMdd_CreatePhcdObject(LPVOID lpvPhcdPddObject,
        LPVOID lpvMemoryObject, LPCWSTR szRegKey, PUCHAR ioPortBase,
        DWORD dwSysIntr)
{
	
	CPhysMem * pobMem = (CPhysMem *)lpvMemoryObject;
    CPhcd * pobPhcd = new CPhcd(lpvPhcdPddObject, pobMem, szRegKey, ioPortBase,
            dwSysIntr);
    if(pobPhcd->Initialize() == FALSE)
    {
        delete pobPhcd;
        pobPhcd = NULL;
    }

    return pobPhcd;
}

extern "C" BOOL PhcdMdd_DestroyPhcdObject(LPVOID lpvPhcdObject)
{
    CPhcd * pobPhcd = (CPhcd *)lpvPhcdObject;
    delete pobPhcd;

    return TRUE;
}

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

    return TRUE;
}

extern "C" BOOL PhcdMdd_PowerUp(LPVOID lpvPhcdObject)
{
    CPhcd * pobPhcd = (CPhcd *)lpvPhcdObject;
    pobPhcd->PowerMgmtCallback(FALSE);

    return TRUE;
}

extern "C" BOOL PhcdMdd_PowerDown(LPVOID lpvPhcdObject)
{
    CPhcd * pobPhcd = (CPhcd *)lpvPhcdObject;
    pobPhcd->PowerMgmtCallback(TRUE);

    return TRUE;
}



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


extern "C" void PCD_PowerUp(DWORD hDeviceContext)
{
    PhcdPdd_PowerUp(hDeviceContext);

    return;
}


extern "C" void PCD_PowerDown(DWORD hDeviceContext)
{
    PhcdPdd_PowerDown(hDeviceContext);

    return;
}


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


extern "C" DWORD PCD_Open(DWORD hDeviceContext, DWORD AccessCode,
        DWORD ShareMode)
{
    return PhcdPdd_Open(hDeviceContext, AccessCode, ShareMode);
}


extern "C" BOOL PCD_Close(DWORD hOpenContext)
{
    return PhcdPdd_Close(hOpenContext);
}


extern "C" DWORD PCD_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
    return PhcdPdd_Read(hOpenContext, pBuffer, Count);
}


extern "C" DWORD PCD_Write(DWORD hOpenContext, LPCVOID pSourceBytes,
        DWORD NumberOfBytes)
{
    return PhcdPdd_Write(hOpenContext, pSourceBytes, NumberOfBytes);
}


extern "C" DWORD PCD_Seek(DWORD hOpenContext, LONG Amount, DWORD Type)
{
    return PhcdPdd_Seek(hOpenContext, Amount, Type);
}


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