irda.h

WinCE5.0部分核心源码

#define IRDA_MSG_pDiscContext       MsgType.IRDA_DisconnectService.pDiscContext

#define IRDA_MSG_AccessMode         MsgType.IRLMP_AccessModeService.AccessMode
#define IRDA_MSG_ModeStatus         MsgType.IRLMP_AccessModeService.ModeStatus
#define IRDA_MSG_IrLPTMode          MsgType.IRLMP_AccessModeService.IrLPTMode

#define IRDA_MSG_pIasSet            MsgType.IRLMP_IASService.pIasSet
#define IRDA_MSG_pClassName         MsgType.IRLMP_IASService.pClassName
#define IRDA_MSG_pIasQuery          MsgType.IRLMP_IASService.pIasQuery
#define IRDA_MSG_AttribLen          MsgType.IRLMP_IASService.AttribLen
#define IRDA_MSG_IASStatus          MsgType.IRLMP_IASService.IASStatus
#define IRDA_MSG_AttribHandle       MsgType.IRLMP_IASService.AttribHandle
#define IRDA_MSG_pAttribHandle      MsgType.IRLMP_IASService.pAttribHandle

#define IRDA_MSG_LinkStatus         MsgType.LinkStatus
extern PDRIVER_OBJECT pIrdaDriverObject;

extern LIST_ENTRY   IrdaLinkCbList;
extern NDIS_HANDLE  NdisIrdaHandle;
extern PVOID        IrdaMsgPool;

VOID IrdaTimerInitialize(PIRDA_TIMER     pTimer,
                         VOID            (*ExpFunc)(PVOID Context),
                         UINT            Timeout,
                         PVOID           Context,
                         PIRDA_LINK_CB   pIrdaLinkCb);

VOID IrdaTimerStart(PIRDA_TIMER pTimer);

VOID IrdaTimerStop(PIRDA_TIMER pTimer);

VOID IrdaTimerRestart(PIRDA_TIMER pTimer);

VOID IrdaEventInitialize(PIRDA_EVENT pIrdaEvent,
                         VOID        (*Callback)(PVOID Context));
    
VOID IrdaEventSchedule(PIRDA_EVENT pIrdaEvent, PVOID Context);

NTSTATUS
IrdaInitialize(
    IN PNDIS_STRING,
    IN PUNICODE_STRING, 
    OUT PUINT);

VOID
IrdaShutdown();

UINT 
TdiUp(void *pContext, IRDA_MSG *pMsg);

IRDA_MSG *
AllocTxMsg(
    PIRDA_LINK_CB);

VOID
IrmacDown(
    IN PVOID    IrmacContext,
    PIRDA_MSG   pMsg);

_inline
VOID
INIT_LINK_LOCK(PIRDA_LINK_CB pIrdaLinkCb)
{
#ifdef UNDER_CE
    InitializeCriticalSection(&pIrdaLinkCb->Mutex);
#else
    KeInitializeMutex(&pIrdaLinkCb->Mutex, 1);
#endif 
}

__inline VOID
DELETE_LINK_LOCK(PIRDA_LINK_CB pIrdaLinkCb)
{
#ifdef UNDER_CE
    DeleteCriticalSection(&pIrdaLinkCb->Mutex);
#endif 
}

_inline
VOID
LOCK_LINK(PIRDA_LINK_CB pIrdaLinkCb)
{
#ifdef UNDER_CE
    EnterCriticalSection(&pIrdaLinkCb->Mutex);
#else
    NTSTATUS Status;

    Status = KeWaitForSingleObject(&pIrdaLinkCb->Mutex,
        Executive,
        KernelMode,
        FALSE,
        NULL);

    ASSERT(Status == STATUS_SUCCESS);
#endif 
}

_inline 
VOID
UNLOCK_LINK(PIRDA_LINK_CB pIrdaLinkCb)
{
#ifdef UNDER_CE
    LeaveCriticalSection(&pIrdaLinkCb->Mutex);
#else 
    KeReleaseMutex(&pIrdaLinkCb->Mutex, FALSE);
#endif 
}

#ifndef UNDER_CE
#if DBG
typedef struct
{
    NPAGED_LOOKASIDE_LIST Lookaside;
    UINT                  Allocd;
} DBG_BUF_POOL, *PDBG_BUF_POOL;
#endif 
#endif 

__inline
PVOID
CreateIrdaBufPool(ULONG Size, ULONG Tag)
{
#ifdef UNDER_CE
    return ((PVOID)Size);
#else 
#if DBG
    PDBG_BUF_POOL           pDbgBufPool;
#else
    PNPAGED_LOOKASIDE_LIST  pLookaside;
#endif 

#if DBG
    pDbgBufPool = ExAllocatePool(NonPagedPool, sizeof(DBG_BUF_POOL));
//DEBUGMSG(1, ("Created pool %x\n", pDbgBufPool));
    if (!pDbgBufPool)
        return NULL;
#else
    pLookaside = ExAllocatePool(NonPagedPool, sizeof(NPAGED_LOOKASIDE_LIST));

    if (!pLookaside)
        return NULL;
#endif 

    ExInitializeNPagedLookasideList(
#if DBG
        &pDbgBufPool->Lookaside,
#else
        pLookaside,
#endif 
        NULL,
        NULL,
        0,
        Size,
        Tag,
        4); // doesn't do anything

#if DBG
    pDbgBufPool->Allocd = 0;
    return pDbgBufPool;
#else
    return pLookaside;
#endif 
#endif
}

__inline
VOID
DeleteIrdaBufPool(PVOID pBufPool)
{
#ifdef UNDER_CE
    return;
#else 
#if DBG
    PDBG_BUF_POOL    pDbgBufPool = pBufPool;
//DEBUGMSG(1, ("Deleted pool %x\n", pDbgBufPool));

    ExDeleteNPagedLookasideList(&pDbgBufPool->Lookaside);
    ExFreePool(pDbgBufPool);
#else
    ExDeleteNPagedLookasideList((PNPAGED_LOOKASIDE_LIST) pBufPool);
    ExFreePool(pBufPool);
#endif 
#endif
}

extern HANDLE g_hIrdaHeap;

__inline
PVOID
AllocIrdaBuf(PVOID pBufPool)
{
#ifdef UNDER_CE
    return (HeapAlloc(g_hIrdaHeap, HEAP_ZERO_MEMORY, (ULONG)pBufPool));
#else
#if DBG
    PDBG_BUF_POOL    pDbgBufPool = pBufPool;

    pDbgBufPool->Allocd++;

    //DEBUGMSG(1, ("+Pool %x, cnt %d\n", pBufPool, pDbgBufPool->Allocd));

    return ExAllocateFromNPagedLookasideList(&pDbgBufPool->Lookaside);
#else
    return ExAllocateFromNPagedLookasideList(
            (PNPAGED_LOOKASIDE_LIST) pBufPool);
#endif 
#endif 
}

__inline
VOID
FreeIrdaBuf(PVOID pBufPool, PVOID Buf)
{
#ifdef UNDER_CE
    HeapFree(g_hIrdaHeap, 0, Buf);
#else
#if DBG
    PDBG_BUF_POOL    pDbgBufPool = pBufPool;

    pDbgBufPool->Allocd--;
    //DEBUGMSG(1, ("-Pool %x, cnt %d\n", pBufPool, pDbgBufPool->Allocd));
    ExFreeToNPagedLookasideList(&pDbgBufPool->Lookaside, Buf);
#else
    ExFreeToNPagedLookasideList((PNPAGED_LOOKASIDE_LIST)pBufPool, Buf);
#endif 
#endif 
}

// I'm wrapping lookaside lists so I don't have to keep track of
// which pool to free to.
/*
__inline
PVOID
CreateMsgPool(ULONG Size,
             USHORT Depth,
             ULONG Tag)
{
    PNPAGED_LOOKASIDE_LIST  pLookaside;

    pLookaside = ExAllocatePool(NonPagedPool, sizeof(NPAGED_LOOKASIDE_LIST));

    if (!pLookaside)
        return NULL;

	ExInitializeNPagedLookasideList(
		pLookaside,
		NULL,
		NULL,
		0,
		Size + sizeof(PVOID),
		Tag,
		Depth);

    DEBUGMSG(0, ("CreateMsgPool %x\n", pLookaside));
    
    return pLookaside;
}

__inline
VOID
DeleteMsgPool(PVOID pLookaside)
{
    DEBUGMSG(0, ("DeleteMsgPool %x\n", pLookaside));
    
    ExDeleteNPagedLookasideList((PNPAGED_LOOKASIDE_LIST) pLookaside);

    ExFreePool(pLookaside);
}

__inline
PVOID
AllocFromMsgPool(PVOID pLookaside)
{
    PVOID   pEntry;

    pEntry = ExAllocateFromNPagedLookasideList(pLookaside);

    if (!pEntry)
        return NULL;

    // store lookaside with entry
    
    *(PVOID *) pEntry = pLookaside;

    DEBUGMSG(0, ("Alloc %x: Total %d, AllocMiss %d, FreeTot %d, FreeMiss %d Depth%d\n",
                 pLookaside,
                 ((PNPAGED_LOOKASIDE_LIST)pLookaside)->L.TotalAllocates,
                 ((PNPAGED_LOOKASIDE_LIST)pLookaside)->L.AllocateMisses,
                 ((PNPAGED_LOOKASIDE_LIST)pLookaside)->L.TotalFrees,
                 ((PNPAGED_LOOKASIDE_LIST)pLookaside)->L.FreeMisses,
                 ((PNPAGED_LOOKASIDE_LIST)pLookaside)->L.Depth));

    return ++(PVOID *)pEntry;
}

__inline
VOID
FreeToMsgPool(PVOID pEntry)
{
    PNPAGED_LOOKASIDE_LIST pLookaside;

    pEntry = --(PVOID *) pEntry;
    
    pLookaside = *(PVOID *) pEntry;

    DEBUGMSG(1, ("Listdepth %d, depth %d\n",
                 ExQueryDepthSList(&pLookaside->L.ListHead),
                 pLookaside->L.Depth));
    
    ExFreeToNPagedLookasideList(pLookaside, pEntry);

    DEBUGMSG(0, ("FREE %x: Total %d, AllocMiss %d, FreeTot %d, FreeMiss %d Depth %d\n",
                 pLookaside,
             pLookaside->L.TotalAllocates, pLookaside->L.AllocateMisses,
             pLookaside->L.TotalFrees, pLookaside->L.FreeMisses, pLookaside->L.Depth));
}
*/
    
// sh - add extern support for Nickname and charset so that we can reload 
//      the device name whenever an irlmp control req (acquire = TRUE).

#define NICK_NAME_LEN   (IRDA_MAX_DEVICE_NAME - sizeof(WCHAR))
extern UINT    Hints;
extern BYTE    CharSet;
extern UCHAR   NickName[NICK_NAME_LEN + sizeof(WCHAR)];
extern UINT    NickNameLen;