windows-nt-4.0/private/ntos/ndis/digi/pcimac/mtl_rx.c

/*
 * MTL_RX.C - Receive side processing for MTL
 */

#include	<ndis.h>
#include	<ndiswan.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>

/* main handler, called when data arrives at bchannels */
VOID
mtl__rx_bchan_handler
	(
	MTL_CHAN	*chan,
	USHORT 		bchan,
	ULONG		IddRxFrameType,
	IDD_XMSG 	*msg
	)
{
    MTL         *mtl;
    MTL_HDR     hdr;
    MTL_AS      *as;
	USHORT		FragmentFlags, CopyLen;
	MTL_RX_TBL	*RxTable;
    D_LOG(D_ENTRY, ("mtl__rx_bchan_handler: chan: 0x%lx, bchan: %d, msg: 0x%lx\n", chan, bchan, msg));

    /* assigned mtl using back pointer */
    mtl = chan->mtl;

	//
	// acquire the lock fot this mtl
	//
	NdisAcquireSpinLock(&mtl->lock);

    /* if not connected, ignore */
    if ( !mtl->is_conn )
    {
        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: packet on non connected mtl, ignored\n"));
		goto exit_code;
    }

	RxTable = &mtl->rx_tbl;
    D_LOG(D_ENTRY, ("mtl__rx_bchan_handler: mtl: 0x%lx, buflen: %d, bufptr: 0x%lx\n", \
                                                            mtl, msg->buflen, msg->bufptr));
	//
	// if we are in detect mode
	//
	if (!mtl->RecvFramingBits)
	{
		UCHAR	DetectData[3];

		/* extract header, check for fields */
		IddGetDataFromAdapter(chan->idd,
		                      (PUCHAR)&hdr,
   				      (PUCHAR)msg->bufptr,
      			      sizeof(MTL_HDR));

        DigiDump( DIGIRXFRAGDATA, ("Recv Frag (detect):\n") );
        DigiDumpData( DIGIRXFRAGDATA, (PUCHAR)&hdr, sizeof(MTL_HDR) );

//		NdisMoveMemory ((PUCHAR)&hdr, (PUCHAR)msg->bufptr, sizeof(MTL_HDR));

		//
		// this is used for inband signalling - ignore it
		//
		if (hdr.sig_tot == 0x50)
			goto exit_code;

		//
		// if this is dkf we need offset of zero for detection to work
		//
		if ( ((hdr.sig_tot & 0xF0) == 0x50) && (hdr.ofs != 0) )
			goto exit_code;

		//
		// extract some data from the frame
		//
		IddGetDataFromAdapter(chan->idd,
		                      (PUCHAR)&DetectData,
							  (PUCHAR)&msg->bufptr[4],
							  2);

        DigiDump( DIGIRXFRAGDATA, ("Recv Frag (detect con't):\n") );
        DigiDumpData( DIGIRXFRAGDATA, (PUCHAR)&DetectData, 2 );

//		NdisMoveMemory((PUCHAR)&DetectData, (PUCHAR)&msg->bufptr[4], 2);
	
		D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: hdr: 0x%x 0x%x 0x%x\n", hdr.sig_tot, \
																	 hdr.seq, hdr.ofs));

		D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: DetectData: 0x%x 0x%x\n", DetectData[0], DetectData[1]));

		if ( (IddRxFrameType & IDD_FRAME_PPP) ||
			((IddRxFrameType & IDD_FRAME_DKF) &&
			   ((DetectData[0] == 0xFF) && (DetectData[1] == 0x03))))
		{
			mtl->RecvFramingBits = PPP_FRAMING;
			mtl->SendFramingBits = PPP_FRAMING;
			RxTable->NextFree = 0;
		}
		else
		{
			mtl->RecvFramingBits = RAS_FRAMING;
			mtl->SendFramingBits = RAS_FRAMING;
		}

        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: Deteced WrapperFrameType: 0x%x\n", mtl->RecvFramingBits));

		//
		// don't pass up detected frame for now
		//
		goto exit_code;
	}

	if (IddRxFrameType & IDD_FRAME_DKF)
	{
        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: Received IddFrameType: DKF\n"));

		/* size of packet has to be atleast as size of header */
		if ( msg->buflen < sizeof(hdr) )
		{
			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: packet size too small, ignored\n"));
			RxTable->DKFReceiveError1++;
			goto exit_code;
		}
	
		/* extract header, check for fields */
		IddGetDataFromAdapter(chan->idd,
		                      (PUCHAR)&hdr,
							  (PUCHAR)msg->bufptr,
							  sizeof(MTL_HDR));

        DigiDump( DIGIRXFRAGDATA, ("Recv Frag (DKF hdr):\n") );
        DigiDumpData( DIGIRXFRAGDATA, (PUCHAR)&hdr, sizeof(MTL_HDR) );

		D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: hdr: 0x%x 0x%x 0x%x\n", hdr.sig_tot, \
																	 hdr.seq, hdr.ofs));

		//
		// if this is not our header of if this is an inband uus
		// ignore it
		//
		if ( (hdr.sig_tot & 0xF0) != 0x50 || hdr.sig_tot == 0x50)
		{
			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: bad header signature, ignored\n"));
			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: mtl: 0x%lx, [0]: 0x%x", mtl, hdr.sig_tot));
			RxTable->DKFReceiveError2++;
			goto exit_code;
		}
	
		if ( (hdr.ofs >= MTL_MAC_MTU) || ((hdr.ofs + msg->buflen - sizeof(hdr)) > MTL_MAC_MTU) )
		{
			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: bad offset/buflen, ignored\n"));
			D_LOG(DIGIMTL, ("mtl: 0x%lx, Offset: %d, BufferLength: %d\n", mtl, hdr.ofs, msg->buflen));
			RxTable->DKFReceiveError3++;
			goto exit_code;
		}
	
		NdisAcquireSpinLock(&RxTable->lock);

		/* build pointer to assembly descriptor & lock it */
		as = RxTable->as_tbl + (hdr.seq % MTL_RX_BUFS);

		//
		// if this assembly pointer is not free (queued) then
		// just drop this fragment
		//
		if (as->Queued)
		{
			D_LOG(DIGIMTL, ("DKFRx: AssemblyQueue Overrun! mtl: 0x%lx, as: 0x%lx, seq: %d\n", \
			         mtl, as, hdr.seq));

			RxTable->DKFReceiveError4++;
			as->QueueOverRun++;
			NdisReleaseSpinLock(&RxTable->lock);
			goto exit_code;
		}
	
		/* check for new slot */
		if ( !as->tot )
		{
			new_slot:
	
			/* new entry, fill-up */
			as->seq = hdr.seq;              /* record sequence number */
			as->num = 1;                    /* just received 1'st fragment */
			as->ttl = 1000;                 /* time to live init val */
			as->len = msg->buflen - sizeof(hdr); /* record received length */
			as->tot = hdr.sig_tot & 0x0F;   /* record number of expected fragments */
	
			/* copy received data into buffer */
			copy_data:
			IddGetDataFromAdapter(chan->idd,
			                      (PUCHAR)as->buf + hdr.ofs,
								  (PUCHAR)msg->bufptr + sizeof(hdr),
								  (USHORT)(msg->buflen - sizeof(hdr)));
                DigiDump( DIGIRXFRAGDATA, ("Recv Frag (DKF data):\n") );
                DigiDumpData( DIGIRXFRAGDATA,
                              (PUCHAR)as->buf + hdr.ofs,
                              (msg->buflen - sizeof(hdr)) );

//			NdisMoveMemory (as->buf + hdr.ofs, msg->bufptr + sizeof(hdr), msg->buflen - sizeof(hdr));
		}
		else if ( as->seq == hdr.seq )
		{
			/* same_seq: */
	
			/* same sequence number, accumulate */
			as->num++;
			as->len += (msg->buflen - sizeof(hdr));
	
			goto copy_data;
		}
		else
		{
			/* bad_frag: */
	
			/*
			* if this case, an already taken slot is hit, but with a different
			* sequence number. this indicates a wrap-around in as_tbl. prev
			* entry is freed and then this fragment is recorded as first
			*/
			D_LOG(DIGIMTL, ("DKFRx: Bad Fragment! mtl: 0x%lx, as: 0x%lx, as->seq: %d, seq: %d\n", \
			         mtl, as, as->seq, hdr.seq));

			D_LOG(DIGIMTL, ("as->tot: %d, as->num: %d\n", as->tot, as->num));

			RxTable->DKFReceiveError5++;
			goto new_slot;
		}
	
		/* if all fragments recieved for packet, time to mail it up */
		if ( as->tot == as->num )
		{
			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: pkt mailed up, buf: 0x%lx, len: 0x%x\n", \
												as->buf, as->len));

			QueueDescriptorForRxIndication(mtl, as);

			//
			// mark this guy as being queued
			//
			as->Queued = 1;
		}
	
		/* release assembly descriptor */
		NdisReleaseSpinLock(&RxTable->lock);
	}
	else if (IddRxFrameType & IDD_FRAME_PPP)
	{
        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: Received IddFrameType: PPP\n"));

		NdisAcquireSpinLock(&RxTable->lock);

		/* build pointer to assembly descriptor & lock it */
		as = RxTable->as_tbl + (RxTable->NextFree % MTL_RX_BUFS);

		//
		// if this assembly pointer is not free (queued) then
		// just drop this fragment
		//
		if (as->Queued)
		{
			D_LOG(DIGIMTL, ("PPPRx: AssemblyQueue Overrun! mtl: 0x%lx, as: 0x%lx, NextFree: %d\n", \
			         mtl, as, RxTable->NextFree));

			as->QueueOverRun++;

			RxTable->PPPReceiveError1++;

			NdisReleaseSpinLock(&RxTable->lock);

			goto exit_code;
		}

		FragmentFlags = msg->FragmentFlags;

        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: FragmentFlags: 0x%x, CurrentRxState: 0x%x\n", FragmentFlags, as->State));

		switch (as->State)
		{
			case RX_MIDDLE:
				if (FragmentFlags & H_RX_N_BEG)
					break;

				as->MissCount++;

				//
				// missed an end buffer
				//
				D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: mtl: 0x%lx, Miss in State: %d, FragmentFlags: 0x%x, MissCount: %d\n", \
				              mtl, as->State, FragmentFlags, as->MissCount));

				RxTable->PPPReceiveError2++;

				goto clearbuffer;

				break;

			case RX_BEGIN:
			case RX_END:
				if (FragmentFlags & H_RX_N_BEG)
				{
					//
					// missed a begining buffer
					//
					as->MissCount++;

					D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: mtl: 0x%lx, Miss in State: %d, FragmentFlags: 0x%x, MissCount: %d\n", \
				              mtl, as->State, FragmentFlags, as->MissCount));

					RxTable->PPPReceiveError3++;

					goto done;
				}
clearbuffer:
				//
				// clear rx buffer
				//
				NdisZeroMemory(as->buf, sizeof(as->buf));

				//
				// start data at begin of buffer
				//
				as->DataPtr = as->buf;

				//
				// new buffer
				//
				as->len = 0;

				//
				// set rx state
				//
				as->State = RX_MIDDLE;

				//
				// set time to live
				//
				as->ttl = 1000;

				//
				// there is always only one fragment with PPP
				// maybe a big one but still only one
				//
				as->tot = 1;

				break;

			default:
				D_LOG(DIGIMTL, ("Invalid PPP Rx State! mtl: 0x%lx, as: 0x%lx State: 0x%x\n", \
				          mtl, as, as->State));

				as->State = RX_BEGIN;

				as->tot = 0;

				as->MissCount++;

				goto done;

				break;
		}

		//
		// get the length to be copy
		//
		CopyLen = msg->buflen;


        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: CopyLen: %d\n", CopyLen));

		if (FragmentFlags & H_RX_N_END)
		{
			//
			// if this is not the last buffer and length is 0
			// we are done
			//
			if (CopyLen == 0)
				goto done_copy;

		}
		else
		{
			//
			// if CopyLen = 0 buffer only contains 2 CRC bytes
			//
			if (CopyLen == 0)
			{
				goto done_copy;
			}

			//
			// buffer contains only 1 CRC byte
			//
			else if (CopyLen == (-1 & H_RX_LEN_MASK))
			{
				//
				// previous buffer had a crc byte in it so remove it
				//
				as->len -= 1;
				goto done_copy;
			}

			//
			// buffer contains no crc or data bytes
			//
			else if (CopyLen == (-2 & H_RX_LEN_MASK))
			{
				//
				// previous buffer had 2 crc bytes in it so remove them
				//
				as->len -= 2;
				goto done_copy;
			}

		}

		//
		// if larger than max rx size throw away
		//
		if (CopyLen > IDP_MAX_RX_LEN)
		{
			//
			// buffer to big so dump it
			//
			as->State = RX_BEGIN;

			as->MissCount++;

			RxTable->PPPReceiveError4++;

			/* mark as free now */
			as->tot = 0;

			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: mtl: 0x%lx, RxToLarge: RxSize: %d, MissCount: %d\n", mtl, CopyLen, as->MissCount));
			goto done;
		}

		as->len += CopyLen;

		if (as->len > MTL_MAC_MTU)
		{
			//
			// Frame is to big so dump it
			//
			as->State = RX_BEGIN;

			RxTable->PPPReceiveError5++;

			as->MissCount++;

			/* mark as free now */
			as->tot = 0;

			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: AssembledRxToLarge: mtl: 0x%lx, AsRxSize: %d, MissCount: %d\n", mtl, as->len, as->MissCount));
			goto done;
		}

		//
		// copy the data to rx descriptor
		//
		IddGetDataFromAdapter(chan->idd,
		                      (PUCHAR)as->DataPtr,
							  (PUCHAR)msg->bufptr,
							  CopyLen);
        DigiDump( DIGIRXFRAGDATA, ("Recv Frag (PPP):\n") );
        DigiDumpData( DIGIRXFRAGDATA,
                      (PUCHAR)as->DataPtr,
                      CopyLen );

//		NdisMoveMemory(as->DataPtr, msg->bufptr, CopyLen);

		//
		// update data ptr
		//
		as->DataPtr += CopyLen;


done_copy:
		if (!(FragmentFlags & H_RX_N_END))
		{
			//
			// if this is the end of the frame indicate to wrapper
			//
			as->State = RX_END;

			RxTable->NextFree++;

			QueueDescriptorForRxIndication(mtl, as);

			//
			// mark this guy as being queued
			//
			as->Queued = 1;
		}

done:
		/* release assembly descriptor */
		NdisReleaseSpinLock(&RxTable->lock);
	}
	else
        D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: Received IddFrameType: ??????!!!!!!\n"));

	//
	// exit code
	// release spinlock and return
	//
    exit_code:

	NdisReleaseSpinLock(&mtl->lock);
}

VOID
IndicateRxToWrapper(
	MTL	*mtl
	)
{
	UCHAR	*BufferPtr;
	USHORT	BufferLength = 0;
	NDIS_STATUS	Status = NDIS_STATUS_SUCCESS;
	ADAPTER	*Adapter;
	MTL_AS	*as;
	MTL_RX_TBL	*RxTable;

	NdisAcquireSpinLock(&mtl->lock);

	Adapter = mtl->Adapter;
	RxTable = &mtl->rx_tbl;

	while (!IsRxIndicationFifoEmpty(mtl))
	{
		NdisAcquireSpinLock(&RxTable->lock);

		//
		// get the next completed rx assembly
		//
   		as = GetAssemblyFromRxIndicationFifo(mtl);

		if (!as)
		{
			D_LOG(DIGIMTL, ("IndicateRx: Got a NULL as from queue! mtl: 0x%lx\n", mtl));
			RxTable->IndicateReceiveError1++;
			NdisReleaseSpinLock(&RxTable->lock);
			goto exit_code;
		}


		//
		// if this is an old ras frame then we must strip off
		// the mac header Dst[6] + Src[6] + Length[2]
		//
		if (mtl->RecvFramingBits & RAS_FRAMING)
		{
			//
			// pass over the mac header - tommyd does not want to see this
			//
			BufferPtr = as->buf + 14;
	
			//
			// indicate with the size of the ethernet packet not the received size
			// this takes care of the old driver that does padding on small frames
			//
			BufferLength = as->buf[12];
			BufferLength = BufferLength << 8;
			BufferLength += as->buf[13];
			D_LOG(DIGIMTL, ("IndicateRxToWrapper: WrapperFrameType: RAS\n"));
			D_LOG(DIGIMTL, ("IndicateRxToWrapper: BufPtr: 0x%lx, BufLen: %d\n", BufferPtr, BufferLength));
		}
		else if (mtl->RecvFramingBits & PPP_FRAMING)
		{
			//
			// the received buffer is the data that needs to be inidcated
			//
			BufferPtr = as->buf;
	
			//
			// the received length is the length that needs to be indicated
			//
			BufferLength = as->len;
			D_LOG(DIGIMTL, ("IndicateRxToWrapper: WrapperFrameType: PPP\n"));
			D_LOG(DIGIMTL, ("IndicateRxToWrapper: BufPtr: 0x%lx, BufLen: %d\n", BufferPtr, BufferLength));
		}
		else
		{
			//
			// unknown framing - what to do what to do
			// throw it away
			//
			D_LOG(DIGIMTL, ("IndicateRxToWrapper: mtl: 0x%lx, Unknown WrapperFramming: 0x%x\n", mtl, mtl->RecvFramingBits));
			RxTable->IndicateReceiveError2++;
			as->tot = 0;
			as->Queued = 0;
			NdisReleaseSpinLock(&RxTable->lock);
			goto exit_code;
		}
	
		if (BufferLength > MTL_MAC_MTU)
		{
			D_LOG(DIGIMTL, ("IndicateRxToWrapper: mtl: 0x%lx, ReceiveLength > MAX ALLOWED (1514):  RxLength: %d\n", mtl, as->len));
			RxTable->IndicateReceiveError3++;
			as->tot = 0;
			as->Queued = 0;
			NdisReleaseSpinLock(&RxTable->lock);
			goto exit_code;
		}

		//
		// send frame up
		//
		if (mtl->LinkHandle)
		{
			/* release assembly descriptor */
			NdisReleaseSpinLock(&RxTable->lock);

			NdisReleaseSpinLock(&mtl->lock);

                DigiDump( DIGIRXDATA, ("Indicating Recv Data:\n") );
                DigiDumpData( DIGIRXDATA, BufferPtr, BufferLength );

			NdisMWanIndicateReceive(&Status,
			      			Adapter->Handle,
			      			mtl->LinkHandle,
			      			BufferPtr,
			      			BufferLength);

			NdisAcquireSpinLock(&mtl->lock);

			NdisAcquireSpinLock(&RxTable->lock);

			mtl->RecvCompleteScheduled = 1;
		}
	
	
		/* mark as free now */
		as->tot = 0;

		//
		// mark this guy as being free
		//
		as->Queued = 0;

		/* release assembly descriptor */
		NdisReleaseSpinLock(&RxTable->lock);
	}

	//
	// exit code
	// release spinlock and return
	//
    exit_code:

	NdisReleaseSpinLock(&mtl->lock);
}

//
// this function checks all of the mtl's on this adapter to see if
// the protocols need to be given a chance to do some work
//
VOID
MtlRecvCompleteFunction(
	ADAPTER *Adapter
	)
{
	ULONG	n;

	for ( n = 0; n < MAX_MTL_PER_ADAPTER; n++)
	{
		MTL	*mtl = Adapter->MtlTbl[n] ;

		//
		// if this is a valid mtl
		//
		if (mtl)
		{
			//
			// get lock for this mtl
			//
			NdisAcquireSpinLock(&mtl->lock);

			//
			// is a receive complete scheduled on a valid link?
			//
			if (mtl->RecvCompleteScheduled && mtl->LinkHandle)
			{
				//
				// release the lock
				//
				NdisReleaseSpinLock(&mtl->lock);
	
				NdisMWanIndicateReceiveComplete(Adapter->Handle,
													mtl->LinkHandle);
	
				//
				// reaquire the lock
				//
				NdisAcquireSpinLock(&mtl->lock);

				//
				// clear the schedule flag
				//
				mtl->RecvCompleteScheduled = 0;
			}

			//
			// release the lock
			//
			NdisReleaseSpinLock(&mtl->lock);
		}
	}
}

BOOLEAN
IsRxIndicationFifoEmpty(
	MTL	*mtl)
{
	BOOLEAN	Ret = 0;

	NdisAcquireSpinLock(&mtl->RxIndicationFifo.lock);

	Ret = IsListEmpty(&mtl->RxIndicationFifo.head);

	NdisReleaseSpinLock(&mtl->RxIndicationFifo.lock);

	return(Ret);
		
}

MTL_AS*
GetAssemblyFromRxIndicationFifo(
	MTL	*mtl
	)
{
	MTL_AS	*as = NULL;

	NdisAcquireSpinLock(&mtl->RxIndicationFifo.lock);

	if (!IsListEmpty(&mtl->RxIndicationFifo.head))
		as = (MTL_AS*)RemoveHeadList(&mtl->RxIndicationFifo.head);

	NdisReleaseSpinLock(&mtl->RxIndicationFifo.lock);

	return(as);
}

VOID
QueueDescriptorForRxIndication(
	MTL	*mtl,
	MTL_AS	*as
	)
{
	NdisAcquireSpinLock(&mtl->RxIndicationFifo.lock);

	InsertTailList(&mtl->RxIndicationFifo.head, &as->link);

	NdisReleaseSpinLock(&mtl->RxIndicationFifo.lock);
}

/* do timer tick processing for rx side */
VOID
mtl__rx_tick(MTL *mtl)
{
    INT         n;
    MTL_AS      *as;
	MTL_RX_TBL	*RxTable = &mtl->rx_tbl;

	//
	// see if there are any receives to give to wrapper
	//
	IndicateRxToWrapper(mtl);

	NdisAcquireSpinLock(&mtl->lock);

	NdisAcquireSpinLock(&RxTable->lock);

    /* scan assembly table */
    for ( n = 0, as = RxTable->as_tbl ; n < MTL_RX_BUFS ; n++, as++ )
    {
        /* update ttl & check */
        if ( as->tot && !(as->ttl -= 25) )
        {
			D_LOG(DIGIMTL, ("mtl__rx_bchan_handler: Pkt Kill ttl = 0: Slot: %d, mtl: 0x%lx\n", n, mtl));

			D_LOG(DIGIMTL, ("AS Timeout! mtl: 0x%lx, as: 0x%lx, as->seq: 0x%x\n", mtl, as, as->seq));
			D_LOG(DIGIMTL, ("as->tot: %d, as->num: %d", as->tot, as->num));

			RxTable->TimeOutReceiveError1++;

			//
			// if this guy was queued for indication to wrapper
			// and was not indicated within a second something is wrong
			//
			if (as->Queued)
			{
				D_LOG(DIGIMTL, ("AS Timeout while queued for indication! mtl: 0x%lx, as: 0x%lx\n", mtl, as));
#if	DBG
				DbgBreakPoint();
#endif
			}

            as->tot = 0;

			//
			// mark this guy as being free
			//
			as->Queued = 0;
        }
    }

	NdisReleaseSpinLock(&RxTable->lock);

	NdisReleaseSpinLock(&mtl->lock);
}

//
// see if there are any receives to give to wrapper
//
VOID
TryToIndicateMtlReceives(
	ADAPTER *Adapter
	)
{
	ULONG	n;

	for (n = 0; n < MAX_MTL_PER_ADAPTER; n++)
	{
		MTL	*mtl = Adapter->MtlTbl[n];

		if (mtl)
			IndicateRxToWrapper(mtl);
	}
}