/*
 * IDD_INIT.C - IDD initialization
 */

#include <ndis.h>
#include <ndiswan.h>
#include <ndistapi.h>
#include <mytypes.h>
#include <mydefs.h>
#include <disp.h>
#include <util.h>
#include <opcodes.h>
#include <adapter.h>
#include <idd.h>
#include <mtl.h>
#include <cm.h>
#include <res.h>
#include <trc.h>
#include <io.h>

#include <ansihelp.h>


typedef struct
{
    NDIS_SPIN_LOCK  lock;
    ULONG   NumberOfIddsInSystem;
    ULONG   LastIddPolled;
    ADAPTER *CurrentAdapter;
    ADAPTER *LastAdapter;
    IDD*    Idd[MAX_IDD_IN_SYSTEM];
}IDD_TABLE;

IDD_TABLE GlobalIddTbl;

BOOLEAN IsThisAdapterNext(ADAPTER *Adapter);

/* driver global vars */
extern DRIVER_BLOCK Pcimac;

ULONG EnumIddInSystem()
{
    ULONG   NumberOfIddsInSystem;

    NdisAcquireSpinLock(&GlobalIddTbl.lock);

    NumberOfIddsInSystem = GlobalIddTbl.NumberOfIddsInSystem;

    NdisReleaseSpinLock(&GlobalIddTbl.lock);

    return(NumberOfIddsInSystem);
}

IDD* GetIddByIndex( ULONG Index )
{
    IDD *idd;

    NdisAcquireSpinLock(&GlobalIddTbl.lock);

    idd = GlobalIddTbl.Idd[Index];

    NdisReleaseSpinLock(&GlobalIddTbl.lock);

    return(idd);
}

ULONG
EnumIddPerAdapter(
    VOID *Adapter_1
    )
{
    ADAPTER *Adapter = (ADAPTER*)Adapter_1;

    return(Adapter->NumberOfIddOnAdapter);
}


INT
IoEnumIdd(VOID *cmd_1)
{
    ULONG   n;
    IO_CMD  *cmd = (IO_CMD*)cmd_1;

    NdisAcquireSpinLock(&GlobalIddTbl.lock);

    cmd->val.enum_idd.num = (USHORT)GlobalIddTbl.NumberOfIddsInSystem;

    for (n = 0; n < GlobalIddTbl.NumberOfIddsInSystem; n++)
    {
        IDD *idd;

        idd = cmd->val.enum_idd.tbl[n] = GlobalIddTbl.Idd[n];

        NdisMoveMemory(&cmd->val.enum_idd.name[n],
                       idd->name,
                       sizeof(cmd->val.enum_idd.name[n]));
    }

    NdisReleaseSpinLock(&GlobalIddTbl.lock);

    return(0);
}

#pragma NDIS_INIT_FUNCTION(idd_init)

ULONG
idd_init(VOID)
{
    //
    // clear out idd table
    //
    NdisZeroMemory(&GlobalIddTbl, sizeof(IDD_TABLE));

    NdisAllocateSpinLock(&GlobalIddTbl.lock);

    return(IDD_E_SUCC);
}

#pragma NDIS_INIT_FUNCTION(idd_create)

/* allocate & initialize an idd object */
INT
idd_create(VOID **ret_idd, USHORT btype)
{
    IDD     *idd;
    INT     n;
    NDIS_PHYSICAL_ADDRESS   pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);

    D_LOG(D_ENTRY, ("idd_create: BoardType: %d\n", btype));
    
    /* allocate memory object */
    NdisAllocateMemory((PVOID*)&idd, sizeof(IDD), 0, pa);                            
    if ( !idd )
    {
        D_LOG(DIGIINIT, ("idd_create: memory allocate failed!\n")); 
        return(IDD_E_NOMEM);
    }

    NdisAcquireSpinLock(&GlobalIddTbl.lock);

    //
    // store idd in system idd table
    //
    for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
        if (!GlobalIddTbl.Idd[n])
            break;

    if (n >= MAX_IDD_IN_SYSTEM)
    {
       //
       //   We are unable to find an empty slot for the IDD object.
       //
       /* free memory for idd */
       NdisFreeMemory(idd, sizeof(*idd), 0);
       
       NdisReleaseSpinLock(&GlobalIddTbl.lock);

       return(IDD_E_NOROOM);
    }

    GlobalIddTbl.Idd[n] = idd;
    GlobalIddTbl.NumberOfIddsInSystem++;

    NdisReleaseSpinLock(&GlobalIddTbl.lock);

    D_LOG(DIGIINIT, ("idd_create: idd: 0x%lx\n", idd));
    NdisZeroMemory(idd, sizeof(IDD));
        
    /* setup init state, adapter handle */
    idd->state = IDD_S_INIT;
    idd->trc = NULL;

    /* allocate root spinlock */
    NdisAllocateSpinLock(&idd->lock);
    
    /* initialize send queues */
    for( n = 0 ; n < IDD_TX_PORTS ; n++ )
    {
       INT     max;

       /* initialize queue */
       idd->sendq[n].max = max = IDD_MAX_SEND / IDD_TX_PORTS;

       idd->sendq[n].tbl = idd->smsg_pool + max * n;
       
       /* allocate spin lock */
       NdisAllocateSpinLock(&idd->sendq[n].lock);
    }

    /* initialize receiver tables */
    for ( n = 0 ; n < IDD_RX_PORTS ; n++ )
    {
       INT     max;
       
       /* initialize table */
       idd->recit[n].max = max = IDD_MAX_HAND / IDD_RX_PORTS;
       idd->recit[n].tbl = idd->rhand_pool + max * n;
       
       /* allocate spin lock */
       NdisAllocateSpinLock(&idd->recit[n].lock);
    }

    /* initialize board specific functions */
    switch ( btype )
    {
        case IDD_BT_PCIMAC :
            idd->SetBank = (VOID*)IdpPcSetBank;
            idd->SetPage = (VOID*)IdpPcSetPage;
            idd->SetBasemem = (VOID*)IdpPcSetBasemem;
            idd->CheckIO = (VOID*)IdpCheckIO;
            idd->CheckMem = (VOID*)IdpCheckMem;
            idd->LoadCode = (VOID*)IdpLoadCode;
            idd->PollTx = (VOID*)IdpPollTx;
            idd->PollRx = (VOID*)IdpPollRx;
            idd->Execute = (VOID*)IdpExec;
            idd->OutToPort = (VOID*)IdpOutp;
            idd->InFromPort = (VOID*)IdpInp;
            idd->ApiGetPort = (VOID*)IdpGetPort;
            idd->ApiBindPort = (VOID*)IdpBindPort;
            idd->ApiAllocBuffer = (VOID*)IdpAllocBuf;
            idd->ResetAdapter = (VOID*)IdpResetBoard;
            idd->NVRamRead = (VOID*)IdpNVRead;
            idd->ChangePage = (VOID*)IdpCPage;
            break;

        case IDD_BT_PCIMAC4 :
            idd->SetBank = (VOID*)IdpPc4SetBank;
            idd->SetPage = (VOID*)IdpPc4SetPage;
            idd->SetBasemem = (VOID*)IdpPc4SetBasemem;
            idd->CheckIO = (VOID*)IdpCheckIO;
            idd->CheckMem = (VOID*)IdpCheckMem;
            idd->LoadCode = (VOID*)IdpLoadCode;
            idd->PollTx = (VOID*)IdpPollTx;
            idd->PollRx = (VOID*)IdpPollRx;
            idd->Execute = (VOID*)IdpExec;
            idd->OutToPort = (VOID*)IdpOutp;
            idd->InFromPort = (VOID*)IdpInp;
            idd->ApiGetPort = (VOID*)IdpGetPort;
            idd->ApiBindPort = (VOID*)IdpBindPort;
            idd->ApiAllocBuffer = (VOID*)IdpAllocBuf;
            idd->ResetAdapter = (VOID*)IdpResetBoard;
            idd->NVRamRead = (VOID*)IdpNVRead;
            idd->ChangePage = (VOID*)IdpCPage;
            break;

        case IDD_BT_MCIMAC :
            idd->SetBank = (VOID*)IdpMcSetBank;
            idd->SetPage = (VOID*)IdpMcSetPage;
            idd->SetBasemem = (VOID*)IdpMcSetBasemem;
            idd->CheckIO = (VOID*)IdpCheckIO;
            idd->CheckMem = (VOID*)IdpCheckMem;
            idd->LoadCode = (VOID*)IdpLoadCode;
            idd->PollTx = (VOID*)IdpPollTx;
            idd->PollRx = (VOID*)IdpPollRx;
            idd->Execute = (VOID*)IdpExec;
            idd->OutToPort = (VOID*)IdpOutp;
            idd->InFromPort = (VOID*)IdpInp;
            idd->ApiGetPort = (VOID*)IdpGetPort;
            idd->ApiBindPort = (VOID*)IdpBindPort;
            idd->ApiAllocBuffer = (VOID*)IdpAllocBuf;
            idd->ResetAdapter = (VOID*)IdpResetBoard;
            idd->NVRamRead = (VOID*)IdpNVRead;
            idd->ChangePage = (VOID*)IdpCPage;
            break;

      case IDD_BT_DATAFIREU :
      case IDD_BT_DATAFIREST:
      case IDD_BT_DATAFIRE4ST:
            idd->SetBank = (VOID*)AdpSetBank;
            idd->SetPage = (VOID*)AdpSetPage;
            idd->SetBasemem = (VOID*)AdpSetBasemem;
            idd->CheckIO = (VOID*)AdpCheckIO;
            idd->CheckMem = (VOID*)AdpCheckMem;
            idd->LoadCode = (VOID*)AdpLoadCode;
            idd->PollTx = (VOID*)AdpPollTx;
            idd->PollRx = (VOID*)AdpPollRx;
            idd->Execute = (VOID*)AdpExec;
            idd->OutToPort = (VOID*)AdpOutp;
            idd->InFromPort = (VOID*)AdpInp;
            idd->ApiGetPort = (VOID*)AdpGetPort;
            idd->ApiBindPort = (VOID*)AdpBindPort;
            idd->ApiAllocBuffer = (VOID*)AdpAllocBuf;
            idd->ResetAdapter = (VOID*)AdpResetBoard;
            idd->NVRamRead = (VOID*)AdpNVRead;
            idd->ChangePage = (VOID*)AdpCPage;
            break;
    }


    /* init sema */
    sema_init(&idd->proc_sema);
    
    //
    // attach idd frame detection handlers
    // these must be attached 1st for all data handlers
    //
    idd_attach(idd, IDD_PORT_B1_RX, (VOID*)DetectFramingHandler, idd);
    idd_attach(idd, IDD_PORT_B2_RX, (VOID*)DetectFramingHandler, idd);

    // attach a command handler to get area info from idp
    idd_attach (idd, IDD_PORT_CMD_RX, (VOID*)idd__cmd_handler, idd);

    /* return address & success */
    *ret_idd = idd;
    D_LOG(D_EXIT, ("idd_create: exit\n"));
    return(IDD_E_SUCC);
}

/* free idd object */
INT
idd_destroy(VOID *idd_1)
{
    IDD *idd = (IDD*)idd_1;
    INT         n;

    D_LOG(D_ENTRY, ("idd_destroy: entry, idd: 0x%lx\n", idd));

    // detach command handler from this idd
    idd_detach (idd, IDD_PORT_CMD_RX, (VOID*)idd__cmd_handler, idd);

    /* perform a shutdown (maybe null) */
    idd_shutdown(idd);
    
    /* if file handle for binary file open, close it */
    if ( idd->phw.fbin )
        NdisCloseFile(idd->phw.fbin);

    /* free spin locks for send queue */
    for ( n = 0 ; n < IDD_TX_PORTS ; n++ )
        NdisFreeSpinLock(&idd->sendq[n].lock);
    
    /* free spin locks for reciever tables */
    for ( n = 0 ; n < IDD_RX_PORTS ; n++ )
        NdisFreeSpinLock(&idd->recit[n].lock);

    /* free resource handles */
    if ( idd->res_io != NULL)
        res_destroy(idd->res_io);

    if ( idd->res_mem != NULL)
        res_destroy(idd->res_mem);

    // free trc object
    if (idd->trc != NULL)
    {
        trc_deregister_idd(idd);
        trc_destroy (idd->trc);
    }

    /* term sema */
    sema_term(&idd->proc_sema);

    /* free spinlock (while allocated!) */
    NdisFreeSpinLock(&idd->lock);

    NdisAcquireSpinLock(&GlobalIddTbl.lock);

    //
    // store idd in system idd table
    //
    for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
        if (GlobalIddTbl.Idd[n] == idd)
            break;

    if (n < MAX_IDD_IN_SYSTEM)
        GlobalIddTbl.Idd[n] = NULL;

    GlobalIddTbl.NumberOfIddsInSystem--;

    NdisReleaseSpinLock(&GlobalIddTbl.lock);

    /* free memory for idd */
    NdisFreeMemory(idd, sizeof(*idd), 0);

    
    /* return success */
    D_LOG(D_EXIT, ("idd_destroy: exit\n"));
    return(IDD_E_SUCC);
}


//#ifdef PERADAPTER

VOID
IddPollFunction(
    VOID    *a1,
    VOID    *Adapter_1,
    VOID    *a3,
    VOID    *a4
    )
{
#define MAX_EVENTS  1000
    ULONG   i, j, EventNum, TotalEventNum = 0;
    ULONG   FirstIdd, NumberOfIddOnAdapter;
    ADAPTER *Adapter = (ADAPTER*)Adapter_1;
    IDD *idd;

    //
    // check to see if there is someone else already polling
    // an adapter that has the same shared memory window
    // as this adapter.  if someone is then get out so that we
    // don't burn up this processor waiting for the other to complete
    // if this adapter is supposed to be the next adapter to be polled
    // only send him away for awhile, else send him away for normal polling
    // time
    //
    if (CheckInDriverFlag(Adapter))
    {
        if (IsThisAdapterNext(Adapter))
        {
            //
            // we want to come back asap
            //
            NdisMSetTimer(&Adapter->IddPollTimer, 0);
        }
        else
        {
            //
            // we want to come back at our regular time
            //
            NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
        }
        return;
    }

    SetInDriverFlag(Adapter);

    //
    // this will be the first idd that we will poll
    //
    FirstIdd = Adapter->LastIddPolled;

    //
    // this will be the number of idds that we will poll
    //
    NumberOfIddOnAdapter = Adapter->NumberOfIddOnAdapter;

    do
    {
        EventNum = 0;

        //
        // we will service all of the idd's in the system
        // first lets do some receives
        //

        for (i = FirstIdd, j = FirstIdd + NumberOfIddOnAdapter; i < j; i++)
        {
            idd = Adapter->IddTbl[i % NumberOfIddOnAdapter];

            if (idd && (idd->state == IDD_S_RUN))
                EventNum += idd->PollRx(idd);
        }


        //
        // we will service all of the idd's in the system
        // now lets do the send queue
        //
        for (i = FirstIdd, j = FirstIdd + NumberOfIddOnAdapter; i < j; i++)
        {
            idd = Adapter->IddTbl[i % NumberOfIddOnAdapter];

            if (idd && (idd->state == IDD_S_RUN))
            {
                EventNum += idd->PollTx(idd);
                EventNum += idd->PollRx(idd);
            }
        }

        TotalEventNum += EventNum;

    } while (EventNum && (TotalEventNum < MAX_EVENTS) );

    //
    // bump so we start at next idd next time
    //
    Adapter->LastIddPolled++;

    if (Adapter->LastIddPolled == NumberOfIddOnAdapter)
        Adapter->LastIddPolled = 0;

    ClearInDriverFlag(Adapter);

    NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);

    //
    // lets go ahead and give some of this data up to the wrapper
    // hopefully this will keep us from running out of room in our
    // assembly descriptor table
    //
    TryToIndicateMtlReceives(Adapter);
}

//#endif

BOOLEAN
IsThisAdapterNext(
    ADAPTER *Adapter
    )
{
    BOOLEAN ThisIsIt = FALSE;

    NdisAcquireSpinLock(&Pcimac.lock);

    if (Adapter == Pcimac.AdapterTbl[Pcimac.NextAdapterToPoll])
        ThisIsIt = TRUE;

    NdisReleaseSpinLock(&Pcimac.lock);

    return(ThisIsIt);
}


#ifdef ALLADAPTERS
VOID
IddPollFunction(
    VOID    *a1,
    VOID    *Adapter_1,
    VOID    *a3,
    VOID    *a4
    )
{
#define MAX_EVENTS  1000
    ULONG   i, j, EventNum, TotalEventNum = 0;
    ULONG   FirstIdd, NumberOfIddsInSystem;
    ADAPTER *Adapter = (ADAPTER*)Adapter_1;
    IDD *idd;


    NdisAcquireSpinLock(&GlobalIddTbl.lock);

    GlobalIddTbl.LastAdapter = GlobalIddTbl.CurrentAdapter;

    GlobalIddTbl.CurrentAdapter = Adapter;

    //
    // this will be the first idd that we will poll
    //
    FirstIdd = GlobalIddTbl.LastIddPolled;

    //
    // this will be the number of idds that we will poll
    //
    NumberOfIddsInSystem = GlobalIddTbl.NumberOfIddsInSystem;

    do
    {
        EventNum = 0;

        //
        // we will service all of the idd's in the system
        // first lets do some receives
        //
        for (i = FirstIdd, j = FirstIdd + NumberOfIddsInSystem; i < j; i++)
        {
            idd = GlobalIddTbl.Idd[i % NumberOfIddsInSystem];

            if (idd->state == IDD_S_RUN)
                EventNum += idd->PollRx(idd);
        }

        //
        // we will service all of the idd's in the system
        // now lets do the send queue
        //
        for (i = FirstIdd, j = FirstIdd + NumberOfIddsInSystem; i < j; i++)
        {
            idd = GlobalIddTbl.Idd[i % NumberOfIddsInSystem];

            if (idd->state == IDD_S_RUN)
            {
                EventNum += idd->PollTx(idd);
                EventNum += idd->PollRx(idd);
            }
        }

        TotalEventNum += EventNum;

    } while (EventNum && (TotalEventNum < MAX_EVENTS) );

    GlobalIddTbl.LastIddPolled++;

    if (GlobalIddTbl.LastIddPolled == NumberOfIddsInSystem)
        GlobalIddTbl.LastIddPolled = 0;

    NdisReleaseSpinLock(&GlobalIddTbl.lock);

    //
    // lets go ahead and give some of this data up to the wrapper
    // hopefully this will keep us from running out of room in our
    // assembly descriptor table
    //
//  TryToIndicateMtlReceives(Adapter);

    NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
}

#endif

#ifdef OLD
VOID
IddPollFunction(
    VOID    *a1,
    VOID    *Adapter_1,
    VOID    *a3,
    VOID    *a4
    )
{
#define MAX_EVENTS  1000
    ULONG   n, EventNum, TotalEventNum = 0;

    ADAPTER *Adapter = (ADAPTER*)Adapter_1;

    do
    {
        EventNum = 0;

        //
        // we will service all of the idd's in the system
        // first lets do some receives
        //
        for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
        {
            IDD *idd = GlobalIddTbl[n];

            if (idd && (idd->state == IDD_S_RUN))
                EventNum += idd->PollRx(idd);
        }

        //
        // we will service all of the idd's in the system
        // now lets do the send queue
        //
        for (n = 0; n < MAX_IDD_IN_SYSTEM; n++)
        {
            IDD *idd = GlobalIddTbl[n];

            if (idd && (idd->state == IDD_S_RUN))
                EventNum += idd->PollTx(idd);
        }

        TotalEventNum += EventNum;

    } while (EventNum && (TotalEventNum < MAX_EVENTS) );

    //
    // lets go ahead and give some of this data up to the wrapper
    // hopefully this will keep us from running out of room in our
    // assembly descriptor table
    //
//  TryToIndicateMtlReceives(Adapter);

    NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T);
}
#endif

/* get idd name */
CHAR*
idd_get_name(VOID *idd_1)
{
    IDD *idd = (IDD*)idd_1;
    return(idd->name);
}

USHORT
idd_get_bline(VOID *idd_1)
{
    IDD *idd = (IDD*)idd_1;
    return(idd->bline);
}

USHORT
idd_get_btype(VOID *idd_1)
{
    IDD *idd = (IDD*)idd_1;
    return(idd->btype);
}

VOID*
idd_get_trc (VOID *idd_1)
{
    IDD *idd = (IDD*)idd_1;
    return(idd->trc);
}

VOID
idd_set_trc (VOID *idd_1, TRC* Trace)
{
    IDD *idd = (IDD*)idd_1;
    idd->trc = Trace;
}

INT
idd_reset_area (VOID* idd_1)
{
    IDD *idd = (IDD*)idd_1;

    idd->Area.area_state = AREA_ST_IDLE;

    return(IDD_E_SUCC);
}

INT
idd_get_area_stat (VOID *idd_1, IDD_AREA *IddStat)
{
    IDD *idd = (IDD*)idd_1;

    *IddStat = idd->Area;

    return(IDD_E_SUCC);
}


/* get an idd area (really start operation, complete on handler callback) */
INT
idd_get_area(VOID *idd_1, ULONG area_id, VOID (*handler)(), VOID *handler_arg)
{
    IDD *idd = (IDD*)idd_1;
    IDD_MSG     msg;
    
    D_LOG(D_ENTRY, ("idd_get_area: entry, idd: 0x%lx, area_id: %ld\n", idd, area_id));
    D_LOG(D_ENTRY, ("idd_get_area: handler: 0x%lx, handler_arg: 0x%lx\n", handler, handler_arg));

    /* check if area is not busy */
    if ( idd->Area.area_state == AREA_ST_PEND )
        return(IDD_E_BUSY);

    /* mark area is pending, store arguments */
    idd->Area.area_state = AREA_ST_PEND;
    idd->Area.area_id = area_id;
    idd->Area.area_idd = idd;
    idd->Area.area_len = 0;
    idd->Area.area_handler = handler;
    idd->Area.area_handler_arg = handler_arg;

    /* issue idd command to get area */
    NdisZeroMemory(&msg, sizeof(msg));
    msg.opcode = CMD_DUMP_PARAM;
    msg.param = msg.bufid = area_id;
    if ( idd_send_msg(idd, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC )
    {
        /* idd op failed! */
        idd->Area.area_state = AREA_ST_IDLE;
        return(IDD_E_AREA);
    }

    /* succ here */
    return(IDD_E_SUCC);
}

VOID
IddSetRxFraming(
    IDD     *idd,
    USHORT  bchan,
    ULONG   FrameType
    )
{
    idd->recit[bchan].RxFrameType = FrameType;
}

VOID
DetectFramingHandler(
    IDD         *idd,
    USHORT      port,
    ULONG       RxFrameType,
    IDD_XMSG    *msg
    )
{
    UCHAR   DetectBytes[2];

   DigiDump( DIGIQ931, ("DetectFramingHandler: idd = 0x%x, port = 0x%x, RxFrameType = 0x%x, msg = 0x%x\n",
                        idd,
                        port,
                        RxFrameType,
                        msg) );

    if (RxFrameType & IDD_FRAME_DETECT)
    {
        //
        // get detection bytes
        //
        IddGetDataFromAdapter(idd,
                              (PUCHAR)&DetectBytes,
                              (PUCHAR)msg->bufptr,
                              2);

//      NdisMoveMemory ((PUCHAR)&DetectBytes, (PUCHAR)msg->bufptr, 2);

        D_LOG(D_ENTRY, ("DetectRxFraming: 0x%x, 0x%x\n",DetectBytes[0], DetectBytes[1]));

        if ((DetectBytes[0] == DKF_UUS_SIG) && (!DetectBytes[1]))
            idd->recit[port].RxFrameType = IDD_FRAME_DKF;

        else if ((DetectBytes[0] == PPP_SIG_0) && (DetectBytes[1] == PPP_SIG_1))
        {
            idd->recit[port].RxFrameType = IDD_FRAME_PPP;
            cm__ppp_conn(idd, port);
        }
    }
}

VOID
idd__cmd_handler(IDD *idd, USHORT chan, ULONG Reserved, IDD_MSG *msg)
{
    ULONG   bytes;

    /* check for show area more/last frames (3/4) */
    if ( msg->bufid >= 2 )
    {
        if ( (idd->Area.area_state == AREA_ST_PEND) &&
             (idd->Area.area_idd == idd) )
        {
            /* copy frame data, as much as possible */
            bytes = MIN(msg->buflen, (sizeof(idd->Area.area_buf) - idd->Area.area_len));

            IddGetDataFromAdapter(idd,
                                  (PUCHAR)idd->Area.area_buf + idd->Area.area_len,
                                  (PUCHAR)msg->bufptr,
                                  (USHORT)bytes);

//          NdisMoveMemory (idd->Area.area_buf + idd->Area.area_len, msg->bufptr, bytes);

            idd->Area.area_len += bytes;

            /* if last, complete */
            if ( msg->bufid == 3 )
            {
                idd->Area.area_state = AREA_ST_DONE;
                if ( idd->Area.area_handler )
                    (*idd->Area.area_handler)(idd->Area.area_handler_arg,
                                            idd->Area.area_id,
                                            idd->Area.area_buf,
                                            idd->Area.area_len);
            }                
        }
    }
}

#pragma NDIS_INIT_FUNCTION(idd_add_def)

/* add a definition to initialization definition database */
INT
idd_add_def(IDD *idd, CHAR *name, CHAR *val)
{
    INT     name_len = __strlen(name) + 1;
    INT     val_len = __strlen(val) + 1;
    
    D_LOG(D_ENTRY, ("idd_add_def: entry\n"));

    __strlwr(name);

    __strlwr(val);

    D_LOG(D_ENTRY, ("idd_add_def: name: [%s], val: [%s]\n", name, val));
    /* check for room */

    if ( (idd->DefinitionTableLength + name_len + val_len) > IDD_DEF_SIZE )
    {
        D_LOG(DIGIINIT, ("idd_add_def: no room in definition table!\n"));
        return(IDD_E_NOROOM);
    }
    
    /* enter into table */
    NdisMoveMemory(idd->DefinitionTable + idd->DefinitionTableLength, name, name_len);
    idd->DefinitionTableLength += name_len;

    NdisMoveMemory(idd->DefinitionTable + idd->DefinitionTableLength, val, val_len);
    idd->DefinitionTableLength += val_len;
    
    /* return success */
    return(IDD_E_SUCC);     
}  // end idd_add_def

#pragma NDIS_INIT_FUNCTION(idd_get_nvram)

/* get an nvram location */
INT
idd_get_nvram(VOID *idd_1, USHORT addr, USHORT *val)
{
    IDD *idd = (IDD*)idd_1;
    D_LOG(D_ENTRY, ("idd_get_nvram: entry, idd: 0x%lx, addr: 0x%x\n", idd, addr));

    /* lock card */
    NdisAcquireSpinLock(&idd->lock);

    /* do the read */
    *val = idd->NVRamRead(idd, addr);
    
    /* release card & return */
    NdisReleaseSpinLock(&idd->lock);
    D_LOG(D_EXIT, ("idd_get_nvram: exit, val: 0x%x\n", *val));
    return(IDD_E_SUCC);   
}