// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\drivers\ethernet\d_ethernet.cpp

 // LDD the ethernet which has no power managment and is not PCCard based

 // 

 //

 /**

  @file d_ethernet.cpp

 */

 #include <drivers/ethernet.h>

 #include <kernel/kern_priv.h>

 #include <e32hal.h>

 #include <e32uid.h>

 _LIT(KLddName,"Ethernet");

 #ifdef KNETWORK1

 const TUint8 ETHER2_TYPE_IP_MSB = 0x08;

 const TUint8 ETHER2_TYPE_IP_LSB = 0x00;

 const TUint8 IP_TYPE_TCP        = 0x06;

 static TBool IsTcp(TDesC8 &aFrame)

 	{

 	return (aFrame[12] == ETHER2_TYPE_IP_MSB && aFrame[13] == ETHER2_TYPE_IP_LSB && aFrame[23] == IP_TYPE_TCP);

 	}

 static TInt GetTcpSeqNumber(TDesC8 &aFrame)

 	{

 	TInt seqNum = 0;

 	if (IsTcp(aFrame))

 		seqNum = aFrame[38] << 24 | aFrame[39] << 16 | aFrame[40] << 8| aFrame[41];

 	return seqNum;

 	}

 static TInt GetTcpAckNumber(TDesC8 &aFrame)

 	{

 	TInt ackNum = 0;

 	if (IsTcp(aFrame))

 		ackNum = aFrame[42] << 24 | aFrame[43] << 16 | aFrame[44] << 8| aFrame[45];

 	return ackNum;

 	}

 #endif

 DDeviceEthernet::DDeviceEthernet()

 // Constructor

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DDeviceEthernet::DDeviceEthernet()"));

     iParseMask=KDeviceAllowAll;

     iUnitsMask=0xffffffff; // Leave units decision to the PDD

     iVersion=TVersion(KEthernetMajorVersionNumber,

 		      KEthernetMinorVersionNumber,

 		      KEthernetBuildVersionNumber);

     }

 TInt DDeviceEthernet::Install()

 // Install the device driver.

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DDeviceEthernet::Install()"));

     return(SetName(&KLddName));

     }

 void DDeviceEthernet::GetCaps(TDes8& aDes) const

 // Return the Ethernet capabilities.

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DDeviceEthernet::GetCaps(TDes8& aDes) const"));

     TPckgBuf<TCapsDevEthernetV01> b;

     b().version=TVersion(KEthernetMajorVersionNumber,

 			 KEthernetMinorVersionNumber,

 			 KEthernetBuildVersionNumber);

     Kern::InfoCopy(aDes,b);

     }

 TInt DDeviceEthernet::Create(DLogicalChannelBase*& aChannel)

 // Create a channel on the device.

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DDeviceEthernet::Create(DLogicalChannelBase*& aChannel)"));

     aChannel=new DChannelEthernet;

     return aChannel?KErrNone:KErrNoMemory;

     }

 DChannelEthernet::DChannelEthernet()

 // Constructor

     :   iRxCompleteDfc(CompleteRxDfc, this, 2)

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DChannelEthernet()"));

     // Setup the default config

     iConfig.iEthSpeed      = KEthSpeed10BaseT;

     iConfig.iEthDuplex     = KEthDuplexHalf;

     iConfig.iEthAddress[0] = 0x00;

     iConfig.iEthAddress[1] = 0x00;

     iConfig.iEthAddress[2] = 0x00;

     iConfig.iEthAddress[3] = 0x00;

     iConfig.iEthAddress[4] = 0x00;

     iConfig.iEthAddress[5] = 0x00;

     iStatus=EOpen;

     iClient=&Kern::CurrentThread();

 	// Increse the Dthread's ref count so that it does not close without us

 	iClient->Open();

     }

 DChannelEthernet::~DChannelEthernet()

 // Destructor

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::~DChannelEthernet()"));

 	Kern::DestroyClientRequest(iWriteRequest);

 	Kern::DestroyClientBufferRequest(iReadRequest);

 	// decrement it's reference count

 	Kern::SafeClose((DObject*&)iClient, NULL);

     }

 void DChannelEthernet::Complete(TInt aMask, TInt aReason)

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::Complete(TInt aMask, TInt aReason)"));

     if (aMask & ERx)

 		{

     	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::Complete iReadRequest"));

 		if (iReadRequest->IsReady())

 			{

 			Kern::QueueBufferRequestComplete(iClient, iReadRequest, aReason);

 			}

 		}

     if (aMask & ETx)

 		{

     	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::Complete iWriteRequest"));

 		__KTRACE_OPT(KNETWORK2, Kern::Printf(" >ldd tx: PRE complete reason=%d iClient=%08x iTxStatus=%08x\n", aReason, iClient, iWriteRequest->StatusPtr()));

 		Kern::QueueRequestComplete(iClient, iWriteRequest, aReason);

 		}

 	}

 void DChannelEthernet::Shutdown()

     {

     __KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf("DChannelEthernet::Shutdown()"));

 	// Suspend the chip and disable interrupts

 	(static_cast<DEthernet*>(iPdd))->Stop(EStopNormal);

 	Complete(EAll, KErrAbort);

 	if (iRxCompleteDfc.Queued())

 		{

     	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::Shutdown()- Cancelling old dfc"));

 		// Ethernet interrupts are disabled; must make sure DFCs are not queued.

 	    iRxCompleteDfc.Cancel();

 		}

 	// No harm in doing this

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::Shutdown()- Completing message"));

     iMsgQ.iMessage->Complete(KErrNone,EFalse);

     }

 TInt DChannelEthernet::DoCreate(TInt aUnit, 

                                 const TDesC8* /*anInfo*/, 

                                 const TVersion &aVer)

 // Create the channel from the passed info.

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion &aVer)"));

 	if(!Kern::CurrentThreadHasCapability(ECapabilityCommDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by ENET.LDD (Ethernet Driver)")))

 		return KErrPermissionDenied;

 	if (!Kern::QueryVersionSupported(TVersion(KEthernetMajorVersionNumber,

 					      KEthernetMinorVersionNumber,

 					      KEthernetBuildVersionNumber),

 				     aVer))

 		return KErrNotSupported;

 	TInt r = Kern::CreateClientBufferRequest(iReadRequest, 1, TClientBufferRequest::EPinVirtual);

 	if (r != KErrNone)

 		return r;

 	r = Kern::CreateClientRequest(iWriteRequest);

 	if (r != KErrNone)

 		return r;

 	SetDfcQ(((DEthernet*)iPdd)->DfcQ(aUnit));

 	iRxCompleteDfc.SetDfcQ(iDfcQ);

     iMsgQ.Receive();

     ((DEthernet *)iPdd)->iLdd=this;

     //Get config from the device

     ((DEthernet *)iPdd)->GetConfig(iConfig);

     PddCheckConfig(iConfig);

     return KErrNone;

     }

 void DChannelEthernet::Start()

 // Start the driver receiving.

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::Start()"));

     if (iStatus!=EClosed)

 		{

 		PddStart();

 		iStatus=EActive;

 		}

     }

 void DChannelEthernet::ReceiveIsr()

 	// Copies data into the iFifo's buffers

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::ReceiveIsr()"));

     TBuf8<KMaxEthernetPacket+32> * buffer;

 //	TInt err;

     buffer = iFIFO.GetFree();

     if(buffer == NULL)

 		{

 	    __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::ReceiveIsr()- Dropping a frame"));

 		/*err =*/ PddReceive(*buffer, EFalse); //Need to call as must drain RX buffer

 		// Should something be done about returned errors?

 		return;

 		}

     else

 		/*err =*/ PddReceive(*buffer, ETrue);

 		// Should something be done about returned errors?

 	// Add another DFc as we have a buffer and is not already queued

 	if (!iRxCompleteDfc.Queued())

 		{

         if (NKern::CurrentContext()==NKern::EInterrupt)

  			iRxCompleteDfc.Add();

  		else

  			iRxCompleteDfc.Enque();

 		return;

 		}

 	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::ReceiveIsr()- DFC already added"));

     }

 void DChannelEthernet::CompleteRxDfc(TAny* aPtr)

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::CompleteRxDfc(TAny* aPtr)"));

     DChannelEthernet *pC=(DChannelEthernet*)aPtr;

     pC->DoCompleteRx();

     }

 void DChannelEthernet::DoCompleteRx()

     {

 	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoCompleteRx()"));

 	__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd isr triggered..."));

 	if (iReadRequest->IsReady())

     	{

 		__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoCompleteRx()- Read waiting"));

 		TBuf8<KMaxEthernetPacket+32> * buffer;

 		buffer = iFIFO.GetNext();

 		if (buffer == NULL)

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoCompleteRx()- Unexpected read request earlier"));

 			__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd isr - miss = empty"));

 			Complete(ERx, KErrNone);

 			return;	

 			}

 		// RX buffer has data, must scan buffer and then complete

 		TInt r = Kern::ThreadBufWrite(iClient, iClientReadBuffer, *(const TDesC8*)buffer, 0, KChunkShiftBy0, iClient);

 		iFIFO.SetNext();

 		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd isr - hit = rx tcp seq=%u ack=%u\n", GetTcpSeqNumber(*buffer), GetTcpAckNumber(*buffer)) );

 		Complete(ERx, r);

 		} 

 	else

 		{

 		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd isr - skipped! no request pending\n"));

 		}

     }

 //Override sendMsg to allow data copy in the context of client thread for WDP.

 TInt DChannelEthernet::SendMsg(TMessageBase* aMsg)

 	{

 	TThreadMessage& m = *(TThreadMessage*)aMsg;

 	TInt id = m.iValue;

 	TInt r = KErrNone;

 	if (id != (TInt)ECloseMsg && id != KMaxTInt)

 		{

 		if (id<0)

 			{

 			TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

 			r = SendRequest(aMsg);

 			if (r != KErrNone)

 				{	

 				Kern::RequestComplete(pS,r);

 				}

 			}

 		else

 			{

 			r = SendControl(aMsg);

 			}

 		}

 	else

 		{

 		r = DLogicalChannel::SendMsg(aMsg);

 		}

 	return r;

 	}

 TInt DChannelEthernet::SendControl(TMessageBase* aMsg)

 	{

 	TThreadMessage& m = *(TThreadMessage*)aMsg;

 	TInt id = m.iValue;

 	TInt bufLen;

 	TInt bufMaxLen;

 	TEthernetConfigV01 config;

 	TEthernetCaps caps;

 	TAny* a1 = m.Ptr0();

 	TInt r = KErrNone;

 	switch(id)

 		{

 		case RBusDevEthernet::EControlConfig:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::SendControl EControlConfig"));

 			Kern::KUDesInfo(*(const TDesC8*)a1, bufLen, bufMaxLen);

 			if((TUint)bufMaxLen < sizeof(TEthernetConfigV01))

 				{

 				return KErrUnderflow;

 				}

 			m.iArg[0] = &config;

 			break;

 			}

 		case RBusDevEthernet::EControlCaps:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::SendControl EControlCaps"));

 			Kern::KUDesInfo(*(const TDesC8*)a1, bufLen, bufMaxLen);

 			if((TUint)bufMaxLen < sizeof(caps))

 				{

 				return KErrUnderflow;

 				}

 			m.iArg[0] = ∩︀

 			break;

 			}

 		case RBusDevEthernet::EControlSetConfig:

 		case RBusDevEthernet::EControlSetMac:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::SendControl EControlSetConfig"));

 			Kern::KUDesInfo(*(const TDesC8*)a1, bufLen, bufMaxLen);

 			if((TUint)bufLen > sizeof(config))

 				{

 				return KErrOverflow;

 				}

 			memset(&config,0,sizeof(config));

 			TPtr8 cfg((TUint8*)&config,0,sizeof(config));

 			Kern::KUDesGet(*(TDes8*)&cfg, *(const TDesC8*)a1);

 			m.iArg[0] = (TAny*)&config;

 			break;

 			}

 		default:

 			return KErrNotSupported;

 		}

 	r = DLogicalChannel::SendMsg(aMsg);

 	if(r != KErrNone)

 		return r;

 	switch(id)

 		{

 		case RBusDevEthernet::EControlConfig:

 			{

 			Kern::InfoCopy(*(TDes8*)a1, (const TUint8*)&config, sizeof(TEthernetConfigV01));

 			break;

 			}

 		case RBusDevEthernet::EControlCaps:

 			{

 			Kern::KUDesPut(*(TDes8*)a1, (const TDesC8&)caps);

 			break;

 			}

 		}

 	return r;

 	}

 TInt DChannelEthernet::SendRequest(TMessageBase* aMsg)

 	{

 	TThreadMessage& m = *(TThreadMessage*)aMsg;

 	TInt id = ~m.iValue;

 	TRequestStatus* pS = (TRequestStatus*)m.Ptr0();

 	TAny* a1 = m.Ptr1();

 	TAny* a2 = m.Ptr2();

 	TInt r = KErrNone;

 	switch(id)

 		{

 		case RBusDevEthernet::ERequestWrite:

 			{

 			if(iStatus == EClosed)

 				{

 				return KErrNotReady;

 				}

 			TInt len;

 			umemget32(&len, a2, sizeof(len));

 			if(len == 0)

 				{	

 				return KErrNone;

 				}

 			if(!a1)

 				{

 				return KErrArgument;

 				}

 			Kern::KUDesGet((TDes8&)iFIFO.iTxBuf, *(const TDesC8*)a1);

 			iFIFO.iTxBuf.SetLength(len);

 			iWriteRequest->SetStatus(pS);

 			break;

 			}

 		case RBusDevEthernet::ERequestRead:

 			{

 			TInt len;

 			TInt bufLen;

 			TInt bufMaxLen;

 			umemget32(&len, a2, sizeof(len));

 			if(len == 0)

 				{

 				return KErrNone;

 				}

 			Kern::KUDesInfo(*(const TDesC8*)a1, bufLen, bufMaxLen);

 			if(bufMaxLen < Abs(len))

 				{	

 				return KErrGeneral;

 				}

 			if(bufLen != 0)

 				{

 				Kern::KUDesSetLength(*(TDes8*)a1, 0);

 				}

 			r = iReadRequest->StartSetup(pS);

 			if (r != KErrNone)

 				{

 				return r;

 				}

 			r = iReadRequest->AddBuffer(iClientReadBuffer, a1);

 			if (r != KErrNone)

 				{

 				return KErrNoMemory;

 				}

 			iReadRequest->EndSetup();

 			break;

 			}

 #ifdef ETH_CHIP_IO_ENABLED

 		case RBusDevEthernet::EChipDiagIOCtrl:

 			{

 			Kern::KUDesGet((TDes8&)iChipInfo, *(const TDesC8*)a1);

 			break;

 			}

 #endif

 		default:

 			return KErrNotSupported;

 		}

 	r = DLogicalChannel::SendMsg(aMsg);

 #ifdef ETH_CHIP_IO_ENABLED

 	if(r == KErrNone)

 		{

 		switch(id)

 			{

 			case RBusDevEthernet::EChipDiagIOCtrl:

 				{

 				Kern::KUDesPut(*(TDes8*)a1, (const TDesC8&)iChipInfo);

 				Kern::RequestComplete(pS,r);

 				break;

 				}

 			}

 		}

 #endif

 	return r;

 	}

 void DChannelEthernet::HandleMsg(TMessageBase* aMsg)

     {

     TThreadMessage& m=*(TThreadMessage*)aMsg;

     TInt id=m.iValue;

     __KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd: DChannelEthernet::HandleMsg(TMessageBase* aMsg) id=%d\n", id));

 	if (id==(TInt)ECloseMsg)

 		{

 		Shutdown();

 		return;

 		}

     else if (id==KMaxTInt)

 		{

 		// DoCancel

 		DoCancel(m.Int0());

 		m.Complete(KErrNone,ETrue);

 		return;

 		}

     if (id<0)

 		{

 		// DoRequest

 		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

 		TInt r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

 		//Kern::Printf(" >ldd: about to complete TThreadMessage id=%d...\n", id);

 		m.Complete(r,ETrue);

 		}

     else

 		{

 		// DoControl

 		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd: do control id=%d...\n", id));

 		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

 		m.Complete(r,ETrue);

 		}

 	}

 void DChannelEthernet::DoCancel(TInt aMask)

 // Cancel an outstanding request.

     {

 	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoCancel(TInt aMask = %d)", aMask));

 	if (aMask & RBusDevEthernet::ERequestReadCancel)

 		{

 		if (iRxCompleteDfc.Queued())

 			{

     		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf("DChannelEthernet::DoCancel()- Cancelling old dfc"));

 			iRxCompleteDfc.Cancel();

 			}

 		Complete(ERx,KErrCancel);

 		}

 	if (aMask & RBusDevEthernet::ERequestWriteCancel)

 		{

 		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf("> ldd: DChannelEthernet::DoCancel - Completing write cancel\n"));

 		Complete(ETx,KErrCancel);

 		}

     }

 TInt DChannelEthernet::DoRequest(TInt aReqNo, TRequestStatus* /*aStatus*/, TAny* a1, TAny* /*a2*/)

 // Async requests.

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)"));

     // First check if we have started

     if (iStatus==EOpen)

 		{

 		Start();

 		}

     // Now we can dispatch the request

     TInt r=KErrNone;

     TInt len=0;

     switch (aReqNo)

 		{

 		case RBusDevEthernet::ERequestRead:

 			InitiateRead(a1,len);

 		    break;

 		case RBusDevEthernet::ERequestWrite:

 		    __KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd tx: RBusDevEthernet::ERequestWrite..."));

 			InitiateWrite(a1,len);

 		    break;

 #ifdef ETH_CHIP_IO_ENABLED

         case RBusDevEthernet::EChipDiagIOCtrl:

             {

 			r=((DEthernet*)iPdd)->BgeChipIOCtrl(iChipInfo); 

             break;

             }

 #endif             

 		}

 	    return r;

     }

 void DChannelEthernet::InitiateRead(TAny* /*aRxDes*/, TInt aLength)

     {

 	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::InitiateRead(TAny *aRxDes, TInt aLength)"));

 	__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd client triggered read...\n"));

     iRxLength=Abs(aLength);

     TBuf8<KMaxEthernetPacket+32> * next;

     next = iFIFO.GetNext();

     if (next == NULL)

  		{

 		__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::InitiateRead - RX buffer empty"));

 		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd client - miss = rx buf empty...\n"));

 	 	return;

  		}

     iFIFO.SetNext();

     // RX buffer has data, must scan buffer and then complete

 	TInt r = Kern::ThreadBufWrite(iClient, iClientReadBuffer, *(const TDesC8*)next, 0, KChunkShiftBy0, iClient);

 	__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd client - hit = rx tcp seq=%u ack=%d\n", GetTcpSeqNumber(*next), GetTcpAckNumber(*next)) );

     Complete(ERx,r);

     }

 void DChannelEthernet::InitiateWrite(TAny* /*aTxDes*/, TInt /*aLength*/)

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::InitiateWrite(TAny *aTxDes, TInt aLength)"));

 	__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >ldd tx: tcp seq=%u ack=%u\n", GetTcpSeqNumber(iFIFO.iTxBuf), GetTcpAckNumber(iFIFO.iTxBuf)) );

 	if(PddSend(iFIFO.iTxBuf) != KErrNone)

 		Complete(ETx, KErrCommsLineFail);

 	else

 		Complete(ETx, KErrNone);

     }

 TInt DChannelEthernet::SetConfig(TEthernetConfigV01& c)

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::SetConfig(TEthernetConfigV01& c)"));

     TInt r;

 	if ((r=ValidateConfig(c))!=KErrNone)

 		return r;    

     iConfig = c;

     PddConfigure(iConfig);

     return r;

     }

 TInt DChannelEthernet::SetMAC(TEthernetConfigV01& c)

     {

     __KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::SetMAC(TEthernetConfigV01& c)"));

     TInt r;

     if ((r=ValidateConfig(c))!=KErrNone)

 		return r;    

     iConfig = c;

     MacConfigure(iConfig);

     PddConfigure(iConfig);

     return r;

     }

 TInt DChannelEthernet::DoControl(TInt aFunction, TAny* a1, TAny* /*a2*/)

 // Sync requests.

     {

     __KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf("DChannelEthernet::DoControl(TInt aFunction, TAny* a1, TAny* a2)") );

 	TInt r=KErrNone;

     switch (aFunction)

 		{

 		case RBusDevEthernet::EControlConfig:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoControl EControlConfig"));

 			*(TEthernetConfigV01*)a1 = iConfig;

 			break;

 			}

 		case RBusDevEthernet::EControlSetConfig:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoControl EControlSetConfig"));

 	    	r=SetConfig(*(TEthernetConfigV01*)a1);

 			break;

 			}

 		case RBusDevEthernet::EControlSetMac:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoControl EControlSetMac"));

 			r = SetMAC(*(TEthernetConfigV01*)a1);

 			break;

 			}

 		case RBusDevEthernet::EControlCaps:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoControl EControlCaps"));

 			TEthernetCaps capsBuf;

 			PddCaps(capsBuf);

 			*(TEthernetCaps*)a1 = capsBuf;

 			break;

 			}

 		default:

 			{

 			__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernet::DoControl default 0x%x", aFunction));

 			r=KErrNotSupported;

 			}

 		}

 	    return(r);

     }

 // Implementation of driver Rx / Tx FIFO class.

 DChannelEthernetFIFO::DChannelEthernetFIFO()

     {

     iRxQueIterNext = 0;

     iRxQueIterFree = 0;

     iNumFree = KNumRXBuffers;

     }

 DChannelEthernetFIFO::~DChannelEthernetFIFO()

     {

     }

 TBuf8<KMaxEthernetPacket+32> * DChannelEthernetFIFO::GetFree()

     // Return location of current Rx FIFO free element

     {

     if(iNumFree == 0)

 		{

 		__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf("DChannelEthernetFIFO::GetFree()- No free free buffers"));

 		return NULL;

 		}

     iNumFree--;

 	TBuf8<KMaxEthernetPacket+32> &rxBuf = iRxBuf[iRxQueIterFree++];

     if(iRxQueIterFree == KNumRXBuffers)

 		{

 		iRxQueIterFree = 0;

 		__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernetFIFO::GetFree()- free wrap return 0"));

 		}

 	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernetFIFO::GetFree()- free return %d", iRxQueIterFree));

 	return &rxBuf;

     }

 TBuf8<KMaxEthernetPacket+32> * DChannelEthernetFIFO::GetNext()

     // Return location of next data element within Rx FIFO

     {

 	__KTRACE_OPT2(KNETWORK1, KNETWORK2, Kern::Printf(" >LDDx: GetNext() - iNumFree=%d iRxQueIterNext(read)=%d iRxQueIterFree(write)=%d", iNumFree, iRxQueIterNext, iRxQueIterFree));

     if(iNumFree == KNumRXBuffers)

 		{

 		__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernetFIFO::GetNext()- No data waiting"));

 		return NULL;

 		}

 	TBuf8<KMaxEthernetPacket+32> &rxBuf = iRxBuf[iRxQueIterNext++];

     if(iRxQueIterNext == KNumRXBuffers)

 		{

 		__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernetFIFO::GetNext()- Wrap next return 0"));

 		iRxQueIterNext = 0;

 		}

 	__KTRACE_OPT(KNETWORK1, Kern::Printf("DChannelEthernetFIFO::GetNext()- Data found return %d", iRxQueIterNext));

 	return &rxBuf;

     }

 void DChannelEthernetFIFO::SetNext()

     // Increment location of next data element within Rx FIFO

     {

 	// locked since iNumFree is decremented in function which could be called

  	// from interrupt context

 	// DENNIS: SOUNDS DODGY

     __e32_atomic_add_ord32(&iNumFree, 1);

     }

 /** @addtogroup enet Ethernet Drivers

  *  Kernel Ethernet Support

  */

 /** @addtogroup enet_ldd Driver LDD's

  * @ingroup enet

  */

 /**

  * @addtogroup enet_ldd_nopm_nopccard Ethernet LDD Not PCMCIA and No Power Managment

  * @ingroup enet_ldd

  * @{

  */

 /**

  * Real entry point from the Kernel: return a new driver

  */

 DECLARE_STANDARD_LDD()

 	{

 	return new DDeviceEthernet;

 	}

 /** @} */ // end of assabet group