/*++

Copyright (c) 1990-1995  Microsoft Corporation

Module Name:

	Indicate.c

Abstract:

	This file contains procedures to handle indications from the
	WAN Miniport drivers.


Author:

	Tony Bell	(TonyBe) June 06, 1995

Environment:

	Kernel Mode

Revision History:

	TonyBe		06/06/95		Created

--*/

#include "wan.h"


VOID
NdisWanLineUpIndication(
	PWAN_ADAPTERCB	WanAdapterCB,
	PUCHAR			Buffer,
	ULONG			BufferSize
	)
/*++

Routine Name:

	NdisWanLineupIndication

Routine Description:

	This routine is called when a WAN Miniport driver has a new connetion
	become active or when the status of an active connection changes.  If
	this is a new connection the routine creates a LinkCB, and a BundleCB
	for the new connection.  If this is for an already active connetion the
	connection info is updated.

Arguments:

Return Values:

	None

--*/
{
	PLINKCB		LinkCB;
	PBUNDLECB	BundleCB;
	PPROTOCOLCB	ProtocolCB;
	NDIS_STATUS	Status;
	PNDIS_MAC_LINE_UP	LineUpInfo = (PNDIS_MAC_LINE_UP)Buffer;
	PNDIS_MAC_LINE_UP	LinkLineUpInfo;
	BOOLEAN				EmptyList;

	if (BufferSize >= sizeof(NDIS_MAC_LINE_UP)) {

		//
		// Is this for a new connetion?
		//
		if (LineUpInfo->NdisLinkContext == NULL) {

			//
			// This is a new connection!
			//

			//
			// Get a linkcb
			//
			NdisWanGetLinkCB(&LinkCB,
			                 WanAdapterCB,
							 LineUpInfo->SendWindow);

			if (LinkCB == NULL) {

				//
				// Error getting LinkCB!
				//

				return;
				
			}

			LinkCB->NdisLinkHandle = LineUpInfo->NdisLinkHandle;

			//
			// Get a bundlecb
			//
			NdisWanGetBundleCB(&BundleCB);

			if (BundleCB == NULL) {

				//
				// Error getting BundleCB!
				//

				NdisWanReturnLinkCB(LinkCB);

				return;
			}

			//
			// Copy LineUpInfo to Link LineUpInfo
			//
			NdisMoveMemory((PUCHAR)&LinkCB->LineUpInfo,
			               (PUCHAR)LineUpInfo,
						   sizeof(NDIS_MAC_LINE_UP));

			//
			// Add LinkCB to BundleCB
			//
			AddLinkToBundle(BundleCB, LinkCB);

			//
			// Place BundleCB in active connection table
			//
			InsertBundleInConnectionTable(BundleCB);

			//
			// Place LinkCB in active connection table
			//
			InsertLinkInConnectionTable(LinkCB);

            LineUpInfo->NdisLinkContext = (NDIS_HANDLE)LinkCB->hLinkHandle;


		} else {

			//
			// This is an already existing connetion
			//
			LINKCB_FROM_LINKH(LinkCB, LineUpInfo->NdisLinkContext);

			if (LinkCB == NULL) {
#if DBG
				DbgPrint("NDISWAN.SYS: Invalid LinkContext (0x%8.8x) in LineUp!",
				LineUpInfo->NdisLinkContext);
#endif
				return;
			}

			BundleCB = BUNDLECB_FROM_LINKCB(LinkCB);

			if (BundleCB == NULL) {
#if DBG
				DbgPrint("NDISWAN.SYS: Invalid BundleCB in LineUp, BundleCB: 0x%8.8x, LinkCB: 0x%8.8x\n",
				LinkCB, BundleCB);
#endif
				return;
			}

			NdisAcquireSpinLock(&BundleCB->Lock);

			LinkLineUpInfo = &LinkCB->LineUpInfo;

			LinkLineUpInfo->LinkSpeed = LineUpInfo->LinkSpeed;
			LinkLineUpInfo->Quality = LineUpInfo->Quality;
			LinkLineUpInfo->SendWindow = LineUpInfo->SendWindow;

			//
			// Update BundleCB info
			//
			UpdateBundleInfo(BundleCB);

			NdisReleaseSpinLock(&BundleCB->Lock);
		}
	}
}


VOID
NdisWanLineDownIndication(
	PWAN_ADAPTERCB	WanAdapterCB,
	PUCHAR			Buffer,
	ULONG			BufferSize
	)
/*++

Routine Name:

Routine Description:

Arguments:

Return Values:

--*/
{
	PNDIS_MAC_LINE_DOWN	LineDownInfo = (PNDIS_MAC_LINE_DOWN)Buffer;
	PLINKCB	LinkCB;
	PBUNDLECB BundleCB;
	PPROTOCOLCB	ProtocolCB;
	BOOLEAN	FreeBundle = FALSE;
	BOOLEAN	FreeLink = FALSE;

	LINKCB_FROM_LINKH(LinkCB, (ULONG)LineDownInfo->NdisLinkContext);

	if (LinkCB == NULL) {
		return;
	}

	BundleCB = LinkCB->BundleCB;

	NdisAcquireSpinLock(&BundleCB->Lock);

	//
	// Link is now going down
	//
	LinkCB->State = LINK_GOING_DOWN;

	//
	// If there are not any frames pending on this
	// link we will go ahead and free it's resources.
	// If there are frames pending the resources will
	// be freed in the sendcomplete routine.
	//
	if (LinkCB->OutstandingFrames == 0) {

		//
		// Mark this link as being down
		//
		LinkCB->State = LINK_DOWN;
		FreeLink = TRUE;
		
		//
		// Remove the link from the bundle
		//
		RemoveLinkFromBundle(BundleCB, LinkCB);

	}

	//
	// If this bundle's link count has gone to
	// zero and it is not been routed yet no
	// user-mode component will be freeing the
	// resources so we may need to free the
	// resources.
	//
	if (BundleCB->ulLinkCBCount == 0) {
			
		BundleCB->State = BUNDLE_GOING_DOWN;

		//
		// If there are not any frames pending on this
		// bundle so we need to free it's resources now.
		// If there are frames pending the resources will
		// be freed in the sendcomplete routine.
		//
		if ((BundleCB->OutstandingFrames == 0) &&
			!(BundleCB->Flags & BUNDLE_ROUTED)) {
				
			BundleCB->State = BUNDLE_DOWN;
		
			FreeBundle = TRUE;
		}
	}

	NdisReleaseSpinLock(&BundleCB->Lock);

	if (FreeLink) {
		//
		// Remove this link from the connection table
		//
		RemoveLinkFromConnectionTable(LinkCB);
		NdisWanReturnLinkCB(LinkCB);
	}

	if (FreeBundle) {
		//
		// Remove this bundle from the connection table
		//
		RemoveBundleFromConnectionTable(BundleCB);
		NdisWanReturnBundleCB(BundleCB);
	}

}


VOID
NdisWanFragmentIndication(
	PWAN_ADAPTERCB	WanAdapterCB,
	PUCHAR			Buffer,
	ULONG			BufferSize
	)
/*++

Routine Name:

Routine Description:

Arguments:

Return Values:

--*/
{
	PNDIS_MAC_FRAGMENT	FragmentInfo = (PNDIS_MAC_FRAGMENT)Buffer;
	PLINKCB	LinkCB;
	PBUNDLECB BundleCB;

	LINKCB_FROM_LINKH(LinkCB, (ULONG)FragmentInfo->NdisLinkContext);

	if (LinkCB == NULL) {
		return;
	}

	BundleCB = LinkCB->BundleCB;

	if (BundleCB == NULL) {
		return;
	}

	NdisAcquireSpinLock(&BundleCB->Lock);

	if (FragmentInfo->Errors & WAN_ERROR_CRC) {
		LinkCB->LinkStats.CRCErrors++;
		BundleCB->BundleStats.CRCErrors++;
	}

	if (FragmentInfo->Errors & WAN_ERROR_FRAMING) {
		LinkCB->LinkStats.FramingErrors++;
		BundleCB->BundleStats.FramingErrors++;
	}

	if (FragmentInfo->Errors & WAN_ERROR_HARDWAREOVERRUN) {
		LinkCB->LinkStats.SerialOverrunErrors++;
		BundleCB->BundleStats.SerialOverrunErrors++;
	}

	if (FragmentInfo->Errors & WAN_ERROR_BUFFEROVERRUN) {
		LinkCB->LinkStats.BufferOverrunErrors++;
		BundleCB->BundleStats.BufferOverrunErrors++;
	}

	if (FragmentInfo->Errors & WAN_ERROR_TIMEOUT) {
		LinkCB->LinkStats.TimeoutErrors++;
		BundleCB->BundleStats.TimeoutErrors++;
	}

	if (FragmentInfo->Errors & WAN_ERROR_ALIGNMENT) {
		LinkCB->LinkStats.AlignmentErrors++;
		BundleCB->BundleStats.AlignmentErrors++;
	}

	NdisReleaseSpinLock(&BundleCB->Lock);

}

VOID
UpdateBundleInfo(
	PBUNDLECB	BundleCB
	)
/*++

Routine Name:

Routine Description:

	Expects the BundleCB->Lock to be held!

Arguments:

Return Values:

--*/
{
	PLINKCB	LinkCB;
	ULONG		SlowestLink;
	PPROTOCOLCB	ProtocolCB, IoProtocolCB;
#ifdef BANDWIDTH_ON_DEMAND
	ULONG		SecondsInSamplePeriod;
	ULONG		BytesPerSecond;
	ULONG		BytesInSamplePeriod;
#endif // end of BANDWIDTH_ON_DEMAND

	//
	// If there are any links attached to this bundlecb we will
	// update the bundlecb's info
	//
	if (BundleCB->ulLinkCBCount != 0) {
		PBUNDLE_LINE_UP	BundleLineUpInfo = &BundleCB->LineUpInfo;
	
		SlowestLink =
		BundleLineUpInfo->BundleSpeed = 0;
		BundleLineUpInfo->usSendWindow = 0;
		BundleLineUpInfo->Quality = NdisWanReliable;
	
		//
		// Walk the LinkCBList and update the bundle's info
		//
		for (LinkCB = (PLINKCB)BundleCB->LinkCBList.Flink;
			(PVOID)LinkCB != (PVOID)&BundleCB->LinkCBList;
			LinkCB = (PLINKCB)LinkCB->Linkage.Flink) {
	
			PWAN_ADAPTERCB	WanAdapterCB = LinkCB->WanAdapterCB;
			PNDIS_MAC_LINE_UP	LinkLineUpInfo = &LinkCB->LineUpInfo;
	
			//
			// Bundle link speed is total of all links.  Keep track
			// of slowest link for multilink recv desc's time to live.
			//
			BundleLineUpInfo->BundleSpeed += LinkLineUpInfo->LinkSpeed;
			if ((LinkLineUpInfo->LinkSpeed < SlowestLink) || (SlowestLink == 0)) {
				SlowestLink = LinkLineUpInfo->LinkSpeed;
			}
	
			//
			// Bundle send windows is the total of all links
			//
			BundleLineUpInfo->usSendWindow += LinkLineUpInfo->SendWindow;
	
			//
			// Bundle line quality is the worst of all links
			//
			if (BundleLineUpInfo->Quality < LinkLineUpInfo->Quality) {
				BundleLineUpInfo->Quality = LinkLineUpInfo->Quality;			
			}
	
		}

#if 0
		//
		// Update the time to live for multilink recv desc's.  This is in ms and
		// is the time it would take to receive a complete frame of size MRRU
		// across the slowest link in the bundle.  Value must be a multiple of
		// 100ms with a minimum value of 1sec.  If the slowest link in the bundle is
		// slower than a 28.8K modem we will increase the timeout value by 2
		//
		if (SlowestLink == 0) {
			SlowestLink = 288;
		}

		BundleCB->TimeToLive =
		(BundleCB->FramingInfo.MaxRRecvFrameSize * 1000) /
		((SlowestLink * 100) / 8);

		if (SlowestLink < 64) {
			BundleCB->TimeToLive *= 2;
		}

		BundleCB->TimeToLive |= 0x3E8;
		BundleCB->TimeToLive /= 0x64;
		BundleCB->TimeToLive *= 0x64;
#endif
		
		//
		// Now calculate the % bandwidth that each links contributes to the
		// bundle.
		//
		BundleCB->NextLinkToXmit = (PLINKCB)BundleCB->LinkCBList.Flink;

		for (LinkCB = (PLINKCB)BundleCB->LinkCBList.Flink;
			(PVOID)LinkCB != (PVOID)&BundleCB->LinkCBList;
			LinkCB = (PLINKCB)LinkCB->Linkage.Flink) {

			if (LinkCB->LineUpInfo.LinkSpeed != 0) {
				ULONG	n, d, temp;

				d = BundleCB->LineUpInfo.BundleSpeed;
				n = LinkCB->LineUpInfo.LinkSpeed * 100;

				LinkCB->ulBandwidth = (temp = (n / d)) ? temp : 1;
			} else {
				LinkCB->ulBandwidth = 1;
			}

			if (LinkCB->ulBandwidth > ((PLINKCB)(BundleCB->NextLinkToXmit))->ulBandwidth) {
				BundleCB->NextLinkToXmit = LinkCB;
			}
		}


#ifdef BANDWIDTH_ON_DEMAND

		//
		// Update the BandwidthOnDemand information
		//
		SecondsInSamplePeriod = BundleCB->UpperBonDInfo.ulSecondsInSamplePeriod;

		BytesPerSecond = BundleCB->LineUpInfo.BundleSpeed * 100 / 8;

		BytesInSamplePeriod = BytesPerSecond * SecondsInSamplePeriod;

		BundleCB->UpperBonDInfo.ulBytesThreshold = BytesInSamplePeriod *
		BundleCB->UpperBonDInfo.usPercentBandwidth / 100;

		SecondsInSamplePeriod = BundleCB->LowerBonDInfo.ulSecondsInSamplePeriod;

		BytesPerSecond = BundleCB->LineUpInfo.BundleSpeed * 100 / 8;

		BytesInSamplePeriod = BytesPerSecond * SecondsInSamplePeriod;

		BundleCB->LowerBonDInfo.ulBytesThreshold = BytesInSamplePeriod *
		BundleCB->LowerBonDInfo.usPercentBandwidth / 100;

#endif // end of BANDWIDTH_ON_DEMAND

		//
		// We need to do a new lineup to all routed protocols skipping
		// the IoProtocolCB!
		//
		IoProtocolCB = (PPROTOCOLCB)BundleCB->ProtocolCBList.Flink;

		for (ProtocolCB = (PPROTOCOLCB)IoProtocolCB->Linkage.Flink;
			(PVOID)ProtocolCB != (PVOID)&BundleCB->ProtocolCBList;
			ProtocolCB = (PPROTOCOLCB)ProtocolCB->Linkage.Flink) {

#ifdef BANDWIDTH_ON_DEMAND

			ProtocolCB->ulByteQuota =
			(BytesPerSecond * ProtocolCB->usPriority) / 100;

#endif // end of BANDWIDTH_ON_DEMAND

			NdisReleaseSpinLock(&BundleCB->Lock);

			DoLineUpToProtocol(ProtocolCB);

			NdisAcquireSpinLock(&BundleCB->Lock);
		}

	}
}


VOID
AddLinkToBundle(
	IN	PBUNDLECB	BundleCB,
	IN	PLINKCB		LinkCB
	)
/*++

Routine Name:

Routine Description:

Arguments:

Return Values:

--*/
{
	NdisAcquireSpinLock(&(BundleCB->Lock));

	InsertTailList(&(BundleCB->LinkCBList), &(LinkCB->Linkage));

	BundleCB->ulLinkCBCount++;

	BundleCB->SendingLinks++;

	LinkCB->BundleCB = BundleCB;

	LinkCB->LastRecvSeqNumber = BundleCB->MinReceivedSeqNumber;

	//
	// Update BundleCB Info
	//
	UpdateBundleInfo(BundleCB);

	NdisReleaseSpinLock(&(BundleCB->Lock));
}

VOID
RemoveLinkFromBundle(
	IN	PBUNDLECB	BundleCB,
	IN	PLINKCB		LinkCB
	)
/*++

Routine Name:

Routine Description:

	Expects the BundleCB->Lock to be held!

Arguments:

Return Values:

--*/
{

	//
	// Remove link from the bundle
	//
	RemoveEntryList(&LinkCB->Linkage);

	LinkCB->BundleCB = NULL;

	BundleCB->ulLinkCBCount--;

	BundleCB->SendingLinks--;

	//
	// Update BundleCB LineUp Info
	//
	UpdateBundleInfo(BundleCB);

}