callmgr.c

驱动开发,经过测试可以直接编译后使用,编译使用DDK中的build工具

    //
    AtmSmConnectToPMPDestinations(pVc);

    return;
}


VOID
AtmSmIncomingCloseCall(
    IN  NDIS_STATUS             CloseStatus,
    IN  NDIS_HANDLE             ProtocolVcContext,
    IN  PVOID                   CloseData   OPTIONAL,
    IN  UINT                    Size        OPTIONAL
    )
/*++

Routine Description:

    Indication of an incoming close call from the network. If this
    is not an outgoing PMP VC, then we mark the VC as inactive, and
    move it to the Inactive VC list. If this is on PMP Vc,
    there must be only one party on the PMP connection. We update
    that member's state.

    In any case, we call NdisClCloseCall to complete the handshake.

Arguments:

    CloseStatus         Status of Close
    ProtocolVcContext   Pointer to VC 
    CloseData           Optional Close data (IGNORED)
    Size                Size of Optional Close Data (OPTIONAL)

Return Value:

    None

--*/
{
    PATMSM_VC           pVc             = (PATMSM_VC)ProtocolVcContext;
    PATMSM_ADAPTER      pAdapt          = pVc->pAdapt;
    NDIS_HANDLE         NdisVcHandle    = pVc->NdisVcHandle;
    NDIS_HANDLE         NdisPartyHandle;
    PATMSM_PMP_MEMBER   pMember;
    NDIS_STATUS         Status;


    if (VC_TYPE_PMP_OUTGOING != pVc->VcType){


        DbgInfo(("AtmSmIncomingCloseCall: On Vc 0x%x\n",
                                        ProtocolVcContext));

        ACQUIRE_ADAPTER_GEN_LOCK(pAdapt);

        ASSERT (ATMSM_GET_VC_STATE(pVc) != ATMSM_VC_CLOSING);

        NdisPartyHandle = NULL;


        ATMSM_SET_VC_STATE(pVc, ATMSM_VC_CLOSING);


        ASSERT(pVc->HwAddr.SubAddress == NULL);

        RemoveEntryList(&pVc->List);
        InsertHeadList(&pAdapt->InactiveVcHead, &pVc->List);

        RELEASE_ADAPTER_GEN_LOCK(pAdapt);

        pMember = NULL;

        Status = NdisClCloseCall(NdisVcHandle, NdisPartyHandle, NULL, 0);
        
        DbgInfo(("NdisCloseCall Status - 0x%X Vc - 0x%X\n", Status, pVc));

        if (Status != NDIS_STATUS_PENDING){

            AtmSmCloseCallComplete(Status, pVc, (NDIS_HANDLE)pMember);
        }

    } else {

        //
        // May be the net has gone bad
        //
        DbgInfo(("PMP IncomingCloseCall: On Vc %x\n", ProtocolVcContext));

        AtmSmDisconnectVc(pVc);
    }
}


VOID
AtmSmCloseCallComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolVcContext,
    IN  NDIS_HANDLE             ProtocolPartyContext OPTIONAL
    )
/*++

Routine Description:

    This is called to complete our call to NdisClCloseCall. If the VC
    is other than outgoing PMP, we update its state and dereference it

    If this is an outgoing PMP, we delete the last member

Arguments:

    Status                  Status of NdisClCloseCall
    ProtocolVcContext       Pointer to our VC structure
    ProtocolPartyContext    If the VC is PMP Vc, this is a pointer
                            to the Member that was disconnected.

Return Value:

    None

--*/
{
    PATMSM_VC       pVc             = (PATMSM_VC)ProtocolVcContext;
    PATMSM_ADAPTER  pAdapt          = pVc->pAdapt;
    BOOLEAN         bStopping;

    DbgInfo(("AtmSmCloseCallComplete: On Vc %lx\n", pVc));

    ASSERT(Status == NDIS_STATUS_SUCCESS);

    switch(pVc->VcType){

        case VC_TYPE_INCOMING:
        case VC_TYPE_PP_OUTGOING:

            // Both incoming call and outgoing PP calls

            ACQUIRE_ADAPTER_GEN_LOCK(pAdapt);

            ASSERT (ATMSM_GET_VC_STATE(pVc) == ATMSM_VC_CLOSING);
            
            ATMSM_SET_VC_STATE(pVc, ATMSM_VC_CLOSED);

            RELEASE_ADAPTER_GEN_LOCK(pAdapt);

            // Now dereference the VC
            AtmSmDereferenceVc(pVc);

        break;


        case VC_TYPE_PMP_OUTGOING: {

            // Outgoing PMP

            ACQUIRE_ADAPTER_GEN_LOCK(pAdapt);

            pVc->ulNumDroppingMembers--;

            ATMSM_SET_VC_STATE(pVc, ATMSM_VC_CLOSED);

            ASSERT(1 == pVc->ulNumTotalMembers);
            ASSERT((0 == pVc->ulNumActiveMembers)      &&
                   (0 == pVc->ulNumConnectingMembers)  &&
                   (0 == pVc->ulNumDroppingMembers));

            RELEASE_ADAPTER_GEN_LOCK(pAdapt);

            if(DeleteMemberInfoFromVc(pVc, 
                (PATMSM_PMP_MEMBER)ProtocolPartyContext)){

            }
        }

        break;

        default:
            ASSERT(FALSE);

    }
}


VOID
AtmSmAddPartyComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolPartyContext,
    IN  NDIS_HANDLE             NdisPartyHandle,
    IN  PCO_CALL_PARAMETERS     CallParameters
    )
/*++

Routine Description:

    Completion of NdisClAddParty to add a new party to PMP Vc.
    If successful, update the member's state. Otherwise, delete it.

Arguments:

    Status                  Status of AddParty
    ProtocolPartyContext    Pointer to Member being added
    NdisPartyHandle         Valid if AddParty successful
    CallParameters          Pointer to AddParty call parameters

Return Value:

    None

--*/
{
    PATMSM_PMP_MEMBER   pMember = (PATMSM_PMP_MEMBER)ProtocolPartyContext;
    PATMSM_VC           pVc     = (PATMSM_VC)pMember->pVc;
    PATMSM_ADAPTER      pAdapt  = (PATMSM_ADAPTER)pVc->pAdapt;
    BOOLEAN             bLockReleased = FALSE;

    // Free the memory for CallParameters
    AtmSmFreeMem(CallParameters);

    DbgLoud(("AddPartyComplete: Status %x, pMember %x, NdisPartyHandle %x\n",
                    Status, pMember, NdisPartyHandle));

    ACQUIRE_ADAPTER_GEN_LOCK(pAdapt);

    pVc->ulNumConnectingMembers--;

    if (NDIS_STATUS_SUCCESS == Status){

        ATMSM_SET_MEMBER_STATE(pMember, ATMSM_MEMBER_CONNECTED);

        ASSERT(NdisPartyHandle);

        pMember->NdisPartyHandle = NdisPartyHandle;

        pVc->ulNumActiveMembers++;

        //
        // check if the member was invalidated during the call setup
        // if so, remove this guy
        //
        if(ATMSM_IS_MEMBER_INVALID(pMember)){

            RELEASE_ADAPTER_GEN_LOCK(pAdapt);
            bLockReleased = TRUE;

            // This member was invalidated, now drop him off
            AtmSmDropMemberFromVc(pVc, pMember); 
        }

    } else {

        DbgWarn(("MakeCall error %x, pMember %x to addr:", Status, pMember));

        DumpATMAddress(ATMSMD_ERR, "", &pMember->HwAddr.Address);

        RELEASE_ADAPTER_GEN_LOCK(pAdapt);
        bLockReleased = TRUE;

        //
        // Connection failed. Delete this member from our list of members.
        //
        DeleteMemberInfoFromVc(pVc, 
            (PATMSM_PMP_MEMBER)ProtocolPartyContext);

    }

    if(!bLockReleased) {
    
        RELEASE_ADAPTER_GEN_LOCK(pAdapt);
    }

    //
    // Add anymore members remaining
    //
    AtmSmConnectToPMPDestinations(pVc);

}


VOID
AtmSmDropPartyComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolPartyContext
    )
/*++

Routine Description:

    This is called to signify completion of a previous NdisClDropParty,
    to drop a member off a PMP Vc. Delete the member.

Arguments:

    Status                  Status of DropParty
    ProtocolPartyContext    Pointer to Member being dropped

Return Value:

    None.

--*/
{
    PATMSM_PMP_MEMBER   pMember = (PATMSM_PMP_MEMBER)ProtocolPartyContext;
    PATMSM_VC           pVc     = (PATMSM_VC)pMember->pVc;
    PATMSM_ADAPTER      pAdapt  = (PATMSM_ADAPTER)pVc->pAdapt;
    BOOLEAN             IsVcClosing;

    DbgInfo(("DropPartyComplete: Vc - %x Member - %x\n", pVc, pMember));

    ASSERT(Status == NDIS_STATUS_SUCCESS);

    ACQUIRE_ADAPTER_GEN_LOCK(pAdapt);

    pVc->ulNumDroppingMembers--;

    IsVcClosing = ((ATMSM_GET_VC_STATE(pVc) == ATMSM_VC_NEED_CLOSING) &&
                   (pVc->ulNumActiveMembers == 1) &&
                   ((pVc->ulNumDroppingMembers + pVc->ulNumConnectingMembers)
                                                                       == 0));
    RELEASE_ADAPTER_GEN_LOCK(pAdapt);

    //
    // Delete this member info structure
    //
    DeleteMemberInfoFromVc(pVc, pMember);

    //
    // If this VC is closing remove the last member in it
    // (This member will issue a close call).
    //
    if(IsVcClosing){

        ASSERT(1 == pVc->ulNumTotalMembers);
        
        AtmSmDropMemberFromVc(pVc, pVc->pPMPMembers);
    }
}


VOID
AtmSmIncomingDropParty(
    IN  NDIS_STATUS             DropStatus,
    IN  NDIS_HANDLE             ProtocolPartyContext,
    IN  PVOID                   CloseData   OPTIONAL,
    IN  UINT                    Size        OPTIONAL
    )
/*++

Routine Description:

    Indication that a Member has dropped off the PMP Vc
    We complete this handshake by calling NdisClDropParty.

Arguments:

    DropStatus              Status
    ProtocolPartyContext    Pointer to Member
    CloseData               Optional Close data (IGNORED)
    Size                    Size of Optional Close Data (OPTIONAL)

Return Value:

    None

--*/
{
    PATMSM_PMP_MEMBER   pMember = (PATMSM_PMP_MEMBER)ProtocolPartyContext;
    PATMSM_VC           pVc     = (PATMSM_VC)pMember->pVc;

    ASSERT(DropStatus == NDIS_STATUS_SUCCESS);

    ASSERT(ATMSM_GET_MEMBER_STATE(pMember) == ATMSM_MEMBER_CONNECTED);

    DbgInfo(("IncomingDropParty: pVc %x, pMember %x, Addr: ", 
                                                    pVc, pMember));

    DumpATMAddress(ATMSMD_INFO, "", &pMember->HwAddr.Address);

 
    AtmSmDropMemberFromVc(pVc, pMember);
}



VOID
AtmSmIncomingCallQoSChange(
    IN  NDIS_HANDLE             ProtocolVcContext,
    IN  PCO_CALL_PARAMETERS     CallParameters
    )
/*++

Routine Description:


Arguments:


Return Value:


--*/
{
    DbgWarn(("QoSChange: Ignored\n"));
}