//**********************************************************************
//                                                                      
// Filename: irmain.cpp
//                                                                      
// Description: This file implements the IrDA Serial IR NDIS MAC driver 
// DLL initialization functions.
//
// 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) Cirrus Logic Corporation 2001, All Rights Reserved                       
//                                                                      
//**********************************************************************
#include <windows.h>
extern "C"
{
    #include <ndis.h>
    #include <ntddndis.h>
}    
#include <linklist.h>
#include <ceddk.h>
#include "settings.h"
#include "debugzone.h"
#include "recvlist.h"
#include "sendlist.h"
#include "sirstate.h"
#include "irdahw.h"
#include "miniport.h"

//
// NDIS compatibility version.
//
#define     NDIS_MAJOR_VERSION      0x04
#define     NDIS_MINOR_VERSION      0x00

//
// Debugging information.
//
DBGPARAM dpCurSettings =
{
        TEXT("IrSIR"),
        {
            TEXT("Init"),       
            TEXT("IrdaHW"),
            TEXT("Receive"),
            TEXT("Send"),
            TEXT("SetInfo"),
            TEXT("QueryInfo"),
            TEXT("6"),     
            TEXT("7"),
            TEXT("8"),
            TEXT("9"),
            TEXT("10"),
            TEXT("11"),
            TEXT("12"),
            TEXT("13"),
            TEXT("Warning"),
            TEXT("Error")
        },
        0x0000c03F
};

//****************************************************************************
// DllEntry
//****************************************************************************
// Dummy dll entry. DriverEntry is the real initialize  function.
// 
//
extern "C" BOOL WINAPI DllEntry
(
    HANDLE hInstDll,
    DWORD  Op,
    LPVOID lpvReserved
)
{
    switch (Op)
    {                               
        case DLL_PROCESS_ATTACH:

            DEBUGREGISTER((HMODULE)hInstDll);
            DEBUGMSG(ZONE_INIT, (TEXT("Epirda: DLL Process Attach.\r\n")));
            //IRSIR_LOG_INIT();

            break; 

        case DLL_PROCESS_DETACH:

            DEBUGMSG(ZONE_INIT, (TEXT("Epirda: DLL Process Detach.\r\n")));
            break;

        default:
            break;
    }

    return (TRUE);
}






//****************************************************************************
// DriverEntry
//****************************************************************************
// Description:    Register the driver's entry points with NDIS.
//
// Arguments:
//    pDriverObject - The driver object being initialized.
//    pRegistryPath - Registry path of the driver.
//
// Returns:
//    NDIS_STATUS - Status returned by NdisMRegisterMiniport.
// 

extern "C" NDIS_STATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
#pragma NDIS_INIT_FUNCTION(DriverEntry)

extern "C" NDIS_STATUS DriverEntry
(
    IN PDRIVER_OBJECT  pDriverObject,
    IN PUNICODE_STRING pRegistryPath
)
{
    NDIS_STATUS                     status;
    NDIS40_MINIPORT_CHARACTERISTICS mcIrda;
    NDIS_HANDLE                     hWrapper;

    DEBUGMSG(ZONE_INIT,(
            TEXT("Epirda: +DriverEntry(0x%.8X, 0x%.8X)\r\n"),
              pDriverObject, pRegistryPath)
             );
    
    //
    // Tells the NDIS library that the NDIS driver is initializing.
    // This function needs to be called before any other NDIS function.
    //
    NdisMInitializeWrapper
    (
        &hWrapper,
        pDriverObject,
        pRegistryPath,
        NULL
    );

    //
    // Initialize the miniport characteristics.
    //
    NdisZeroMemory(&mcIrda, sizeof(NDIS40_MINIPORT_CHARACTERISTICS));

    mcIrda.Ndis30Chars.MajorNdisVersion         = NDIS_MAJOR_VERSION;
    mcIrda.Ndis30Chars.MinorNdisVersion         = NDIS_MINOR_VERSION;
//  mcIrda.Reserved                             = 0;

    mcIrda.Ndis30Chars.HaltHandler              = MiniportHalt;
    mcIrda.Ndis30Chars.InitializeHandler        = MiniportInitialize;
    mcIrda.Ndis30Chars.QueryInformationHandler  = MiniportQueryInformation;
    mcIrda.Ndis30Chars.SetInformationHandler    = MiniportSetInformation;
    mcIrda.Ndis30Chars.ResetHandler             = MiniportReset;

    // Allow protocol to send only one packet at a time.
    mcIrda.Ndis30Chars.SendHandler              = MiniportSend;
//  mcIrda.SendPacketsHandler                   = NULL;

    // We don't use NdisMIndicateXxxReceive functions so we will need
    // a return packet handler.
    mcIrda.ReturnPacketHandler                  = MiniportReturnPacket;
//  mcIrda.TransferDataHandler                  = NULL;

    // NDIS never calls the reconfigure handler.
//  mcIrda.ReconfigureHandler                   = NULL;

    // Let NDIS handle hangs for now.
    //
    // If a CheckForHangHandler is supplied, NDIS will call it every two
    // seconds (by default) or at a driver specified interval.
    //
    // When not supplied, NDIS will conclude that the miniport is hung:
    //   1) a send packet has been pending longer than twice the
    //      timeout period
    //   2) a request to IrsirQueryInformation or IrsirSetInformation
    //      is not completed in a period equal to twice the timeout
    //      period.
    // NDIS will keep track of the NdisMSendComplete calls and probably do
    // a better job of ensuring the miniport is not hung.
    //
    // If NDIS detects that the miniport is hung, NDIS calls
    // IrsirReset.
//  mcIrda.CheckForHangHandler             = NULL;

    // This miniport does not handle interrupts.
//  mcIrda.HandleInterruptHandler          = NULL;
//  mcIrda.ISRHandler                      = NULL;
//  mcIrda.DisableInterruptHandler         = NULL;
//  mcIrda.EnableInterruptHandler          = NULL;

    // This miniport does not control a DMA busmaster.
//  mcIrda.AllocateCompleteHandler         = NULL;

    //
    // Register the miniport with NDIS.
    //

    status = NdisMRegisterMiniport
    (
        hWrapper,
        &mcIrda,
        sizeof(mcIrda)
    );

    if (status != NDIS_STATUS_SUCCESS)
    {
        DEBUGMSG(ZONE_ERROR,
                 (TEXT("Epirda: NdisMRegisterMiniport failure [0x%.8X].\r\n"),
                  status)
                 );
        NdisTerminateWrapper(hWrapper, NULL);
    }

    DEBUGMSG(ZONE_INIT,                         
             (TEXT("Epirda: -DriverEntry [0x%.8X]\r\n"),
              status)
             );
    
    return (status);
}