--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/linklayerprotocols/ethernetnif/EtherPkt/CardCtl.cpp Thu Mar 04 11:58:36 2010 +0000
@@ -0,0 +1,452 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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:
+// Control engine for ethernet packet driver
+//
+//
+
+/**
+ @file
+*/
+
+#include <nifman.h>
+#include <nifvar.h>
+#include <nifutl.h>
+#include <es_mbuf.h>
+#include <es_ini.h>
+#include <ir_sock.h>
+#include "PKTDRV.H"
+#include "ETHINTER.H"
+#include "Cardctl.h"
+#include <f32file.h>
+#include <e32svr.h>
+
+//#define __DebugCardCtl__ 1
+
+
+
+/**
+Create a new CPcCardControlEngine object.
+@param aPktDrv Pointer to PC Card Packet Driver.
+@return A pointer to CPcCardControlEngine object.
+*/
+CPcCardControlEngine *CPcCardControlEngine::NewL(CPcCardPktDrv* aPktDrv)
+{
+ CPcCardControlEngine *cc=new (ELeave) CPcCardControlEngine(aPktDrv);
+ CleanupStack::PushL(cc);
+ cc->ConstructL();
+ CleanupStack::Pop();
+ return cc;
+}
+
+/**
+Physical device driver settings
+@internalComponent
+*/
+_LIT(KPddSection,"pdd_settings");
+
+/**
+PCMCIA Socket Number
+@internalComponent
+*/
+_LIT(KSocketNumber,"PCMCIA_socket");
+
+/**
+Create the CPcCardControlEngine object.
+*/
+void CPcCardControlEngine::ConstructL()
+{
+ iSender = CPcCardSender::NewL(this);
+ iReceiver = CPcCardReceiver::NewL(this);
+ iEventHandler = CPcCardEventHandler::NewL(this);
+
+ LoadDeviceDriversL();
+
+ CESockIniData* ini = CESockIniData::NewL(ETHER802_CONFIG_FILENAME);
+ CleanupStack::PushL(ini);
+
+ TInt socket;
+ if(!ini->FindVar(KPddSection,KSocketNumber,socket))
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ CleanupStack::PopAndDestroy(ini);
+
+ TInt error = iCard.Open(socket);
+ User::LeaveIfError(error);
+}
+
+/**
+Open the Card LDD
+*/
+void CPcCardControlEngine::StartL()
+{
+ iCardOpen = ETrue;
+ iReceiver->QueueRead();
+ LinkLayerUp();
+}
+
+/**
+Find and loads the LDD and the PDD if the logical device driver loaded OK.
+The driver names are read from the LAN bearer table in commdb.
+*/
+void CPcCardControlEngine::LoadDeviceDriversL()
+{
+ TInt err;
+
+ //
+ // Get the device driver filenames for loading
+ //
+ TBuf<KCommsDbSvrDefaultTextFieldLength> pddOrLddFileName;
+
+ // LDD first...
+ TBuf<KCommsDbSvrMaxColumnNameLength> columnName=TPtrC(LAN_BEARER);
+ columnName.Append(TChar(KSlashChar));
+ columnName.Append(TPtrC(LAN_BEARER_LDD_FILENAME));
+
+ err = iNotify->NifNotify()->ReadDes(columnName, pddOrLddFileName); // Get the LDD name from commdb
+
+ if(err!=KErrNone)
+ {
+ __FLOG_STATIC(KEther802LogTag1,KEthLogTag3, _L("Could not find LDD filename in commdb - is .cfg file up-to-date? See ether802.ini for information on required fields in commdb."));
+ User::Leave(err);
+ }
+
+ err=User::LoadLogicalDevice(pddOrLddFileName);
+ if(err != KErrNone && err != KErrAlreadyExists)
+ {
+ User::Leave(err);
+ }
+
+ // ...and now the PDD
+ columnName.Zero();
+ columnName.Append(TPtrC(LAN_BEARER));
+ columnName.Append(TChar(KSlashChar));
+ columnName.Append(TPtrC(LAN_BEARER_PDD_FILENAME));
+
+ err = iNotify->NifNotify()->ReadDes(columnName, pddOrLddFileName); // Get the PDD filename from commdb
+
+ if(err!=KErrNone)
+ {
+ __FLOG_STATIC(KEther802LogTag1,KEthLogTag3, _L("Could not find PDD filename in commdb - is .cfg file up-to-date? See ether802.ini for information on required fields in commdb."));
+ User::Leave(err);
+ }
+
+ err = User::LoadPhysicalDevice(pddOrLddFileName);
+ if (err != KErrNone && err != KErrAlreadyExists)
+ {
+ User::Leave(err);
+ }
+
+ //
+ // Get device driver names for unloading
+ //
+ columnName.Zero();
+ columnName.Append(TPtrC(LAN_BEARER));
+ columnName.Append(TChar(KSlashChar));
+ columnName.Append(TPtrC(LAN_BEARER_PDD_NAME));
+
+ err = iNotify->NifNotify()->ReadDes(columnName, iPDDName); // Get the PDD name from commdb (so we can close it when we've finished with it)
+
+ if(err!=KErrNone)
+ {
+ __FLOG_STATIC(KEther802LogTag1,KEthLogTag3, _L("Could not find PDD name in commdb - is .cfg file up-to-date? See ether802.ini for information on required fields in commdb."));
+
+#ifdef _DEBUG
+ // Not being able to unload the device drivers is not a fatal error, so don't worry too
+ // much if we can't read the field out of commdb in release builds, but if the user is
+ // using a debug nif they ought to get it right...
+ User::Leave(err);
+#endif // _DEBUG
+ }
+
+ // Rather than fiddle around trying to reuse the contents of the descriptor (problems with field name lengths), just zero and start again
+ columnName.Zero();
+ columnName.Append(TPtrC(LAN_BEARER));
+ columnName.Append(TChar(KSlashChar));
+ columnName.Append(TPtrC(LAN_BEARER_LDD_NAME));
+
+ err = iNotify->NifNotify()->ReadDes(columnName, iLDDName); // Get the LDD name from commdb (so we can close it when we've finished with it)
+
+ if(err!=KErrNone)
+ {
+ __FLOG_STATIC(KEther802LogTag1,KEthLogTag3, _L("Could not find LDD name in commdb - is .cfg file up-to-date? See ether802.ini for information on required fields in commdb."));
+
+#ifdef _DEBUG
+ User::Leave(err); // see reasoning for LDD above
+#endif // _DEBUG
+ }
+
+ __FLOG_STATIC(KEther802LogTag1,KEthLogTag3, _L("Device drivers loaded"));
+}
+
+/**
+Cancel I/O and close the Card LDD.
+*/
+void CPcCardControlEngine::Stop()
+{
+ // LDD Performs status checks on Read and Write
+ // Completes requests with an error code if they are pending
+ iCard.WriteCancel();
+ iSender->EmptyQueue();
+ iSender->Cancel();
+
+ iCard.ReadCancel();
+ iCardOpen = EFalse;
+ iCard.Close();
+}
+
+CPcCardControlEngine::CPcCardControlEngine(CPcCardPktDrv* aPktDrv)
+:iCardOpen(EFalse), iNotify(aPktDrv)
+/**
+Constructor.
+@param aPktDrv Pointer to PC Card Packet Driver.
+*/
+{
+
+}
+
+/**
+Destructor.
+*/
+CPcCardControlEngine::~CPcCardControlEngine()
+{
+#ifdef _DEBUG
+ // see reasoning for only doing this in debug builds in LoadPacketDrivers()
+ User::FreeLogicalDevice(iLDDName);
+ User::FreePhysicalDevice(iPDDName);
+#endif
+
+ delete iReceiver;
+ delete iSender;
+ delete iEventHandler;
+}
+
+/**
+Upwards notify
+@param aBuffer A Reference to a buffer holding data.
+*/
+void CPcCardControlEngine::ProcessReceivedPacket(TDesC8& aBuffer)
+{
+ iNotify->ReadDataAvailable(aBuffer);
+}
+
+/**
+Resume Sending is a notification call into NIF from the lower layer telling the NIF that a
+previous sending congestion situation has been cleared and it can accept more downstack data.
+*/
+void CPcCardControlEngine::ResumeSending()
+{
+ iNotify->ResumeSending();
+}
+
+/**
+Resume Sending is a notification call into NIF from the lower layer telling the NIF that
+the interface is now up and can accept and transmit data. NIF subsequently calls all the
+bearers' StartSending() methods directly.
+*/
+void CPcCardControlEngine::LinkLayerUp()
+{
+ iNotify->LinkLayerUp();
+}
+
+/**
+Sender class handles queueing and takes ownership of the HBuf and the CIOBuffer.
+@param aBuffer The data to be send is set.
+@return 0 Tells the higher layer to send no more data.
+ 1 Tells higher layer that it can send more data.
+*/
+TInt CPcCardControlEngine::Send(HBufC8* aBuffer)
+{
+ CIOBuffer* buf = NULL;
+ TRAPD(err,buf = CIOBuffer::NewL(aBuffer));
+ if(err != KErrNone)
+ {
+ delete aBuffer;
+ }
+ else
+ {
+ err = iSender->Send(buf);
+ }
+ return err;
+}
+
+/**
+Call to LDD or subordinate object to get the Hardware address of the LAN Device
+@return NULL Failure.
+ (NULL Terminated Binary String) The Hardware Address of the interface. LAN Device
+ Specific
+*/
+TUint8* CPcCardControlEngine::GetInterfaceAddress()
+{
+ iConfig.SetMax();
+ iCard.Config(iConfig);
+ return ((TUint8*)iConfig.Ptr())+2; // The MAC address is located 2 bytes
+ // from the start of the buffer
+}
+
+#if !defined(__WINS__)
+//
+
+/**
+ethermac.dat reading - work around for mac address problem
+@internal component
+*/
+_LIT(KEtherMacFileName,"C:\\System\\Data\\EtherMac.dat");
+
+/**
+Parse the Machine Address from the File.
+*/
+void CPcCardControlEngine::ParseMACFromFileL()
+{
+
+ TBuf8<64> controlBuf; // the size of this is defined in the driver as 64.
+ TBuf8<12> macAddress = 0;
+ RFile macFile;
+ RFs fileSrv;
+
+ User::LeaveIfError(fileSrv.Connect());
+ User::LeaveIfError(macFile.Open(fileSrv,KEtherMacFileName,EFileRead));
+ User::LeaveIfError(macFile.Read(macAddress,12));
+ macFile.Close();
+ fileSrv.Close();
+ controlBuf.SetLength(8);
+ controlBuf[0] = KEthSpeed10BaseT;
+ controlBuf[1] = KEthDuplexHalf;
+
+ TBuf<20> validChars(_L("0123456789abcdef"));
+ TUint8 value;
+ TUint8 upper=0;
+ TChar c;
+ TInt pos;
+ iConfig.SetMax(); // MAC Address fix
+ for(TInt i=0; i<6; i++)
+ {
+ c = macAddress[2*i];
+ c.LowerCase();
+ if((pos = validChars.Locate(c))==KErrNotFound)
+ {
+ pos = upper;
+ break;
+ }
+ upper = (TUint8)pos;
+ c = macAddress[(2*i)+1];
+ c.LowerCase();
+ if((pos = validChars.Locate(c))==KErrNotFound)
+ {
+ User::Leave(KErrNotFound);
+ }
+ value = (TUint8)pos;
+ value = (TUint8)((upper<<4) | value);
+ controlBuf.Append(value);
+ iConfig[i+2]=value; // MAC Address fix 21/05/01
+ }
+ TRequestStatus status = 0;
+
+ User::LeaveIfError(iCard.SetMAC(controlBuf));
+
+ User::WaitForRequest(status);
+ User::LeaveIfError(status.Int());
+}
+#endif
+
+/**
+Constructor. Generic Buffer class
+Currently used for transmit buffers
+*/
+CIOBuffer::CIOBuffer() : iBufPtr(NULL,0)
+{
+}
+
+/**
+Destructor. Free the HBuf if there is one
+*/
+CIOBuffer::~CIOBuffer()
+{
+ FreeData();
+}
+
+/**
+Creation where we new the HBuf.
+@param aSize Length of the Buffer.
+@return A pointer to CIOBuffer object.
+*/
+CIOBuffer* CIOBuffer::NewL(const TInt aSize)
+{
+ CIOBuffer * self = new (ELeave) CIOBuffer;
+ CleanupStack::PushL(self);
+ self->ConstructL(aSize);
+ CleanupStack::Pop();
+ return self;
+}
+
+/**
+Construction where we new the HBuf
+@param aSize Length of the Buffer.
+*/
+void CIOBuffer::ConstructL(const TInt aSize)
+{
+ iBuf = HBufC8::NewL(aSize);
+ TPtr8 temp=iBuf->Des();
+ iBufPtr.Set(temp);
+}
+
+/**
+HBuf provided.
+@param aBuf The data to be assigned
+@return A pointer to CIOBuffer object.
+*/
+CIOBuffer* CIOBuffer::NewL(HBufC8* aBuf)
+{
+ CIOBuffer * self = new (ELeave) CIOBuffer;
+ self->Assign(aBuf);
+ return self;
+}
+
+/**
+Offset
+*/
+TInt CIOBuffer::LinkOffset()
+{
+ return _FOFF(CIOBuffer,iLink);
+}
+
+/**
+Assigns the data from buffer to pointer.
+
+@param aBuffer The data to be assigned
+*/
+void CIOBuffer::Assign(HBufC8* aBuffer)
+{
+ FreeData();
+ iBuf = aBuffer;
+ if(aBuffer)
+ {
+ TPtr8 temp=iBuf->Des();
+ iBufPtr.Set(temp);
+ }
+}
+
+/**
+Frees the data.
+*/
+void CIOBuffer::FreeData()
+{
+ if(iBuf)
+ {
+ delete iBuf;
+ iBuf = NULL;
+ }
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/linklayerprotocols/ethernetnif/EtherPkt/CardDll.cpp Thu Mar 04 11:58:36 2010 +0000
@@ -0,0 +1,365 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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:
+//
+
+
+#include <nifman.h>
+#include <nifvar.h>
+#include <nifutl.h>
+#include <es_mbuf.h>
+#include <nifmbuf.h>
+#include "PKTDRV.H"
+#include "ETHINTER.H"
+#include "Cardctl.h"
+
+
+/**
+@internalComponent
+*/
+extern "C"
+{
+ IMPORT_C CPktDrvFactory * NewPcCardPktDrvFactoryL(); //< Force export
+}
+
+/**
+Library file is opened and this is the the first and only export.
+@internalComponent
+@return A pointer to CPktDrvFactory object.
+*/
+EXPORT_C CPktDrvFactory* NewPcCardPktDrvFactoryL()
+{
+ CPktDrvFactory *f=new (ELeave) CPcCardPktDrvFactory;
+ return f;
+}
+
+/**
+Create the packet driver object
+@param aParent Pointer to the parent Ethint NIF class.
+@return A pointer to CPktDrvBase object.
+*/
+CPktDrvBase* CPcCardPktDrvFactory::NewDriverL(CLANLinkCommon* aParent)
+{
+ CPktDrvBase *drv = new (ELeave) CPcCardPktDrv(*this);
+ CleanupStack::PushL(drv);
+ drv->ConstructL(aParent);
+ CleanupStack::Pop();
+ return drv;
+}
+
+/**
+Constructor.
+*/
+CPcCardPktDrvFactory::CPcCardPktDrvFactory()
+{
+
+}
+
+/**
+Packet Driver version number.
+@return Version number of the Packet Driver
+*/
+TVersion CPcCardPktDrvFactory::Version() const
+{
+ return(TVersion(KPcCardDrvMajorVersionNumber,KPcCardDrvMinorVersionNumber,KPcCardDrvBuildVersionNumber));
+}
+
+
+/**
+Constructor. Packet Driver object.
+*/
+CPcCardPktDrv::CPcCardPktDrv(CPktDrvFactory& aFactory) : CPktDrvBase(aFactory)
+{
+
+}
+
+/**
+Only one object owned
+Destructor.
+*/
+CPcCardPktDrv::~CPcCardPktDrv()
+{
+ delete iControl;
+}
+
+/**
+Pure Virtual Construction of the CPktDrvBase object
+@param aParent Pointer to the CLANLinkCommon class.
+*/
+void CPcCardPktDrv::ConstructL(CLANLinkCommon* aParent)
+{
+ iParent = aParent;
+ // Card control engine
+ iControl=CPcCardControlEngine::NewL(this);
+}
+
+/**
+Pure Virtual Downstack call. " Call to LDD or subordinate object to start/initialise the
+Physical device
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::StartInterface()
+{
+ // Opens the card and queues a read
+ // Control engine validates
+ TRAPD(err,iControl->StartL());
+ return err;
+}
+
+/**
+Call to LDD or subordinate object to stop/de-initialise the Physical device
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::StopInterface()
+{
+ // Closes the card
+ // Control engine validates
+ iControl->Stop();
+ return KErrNone;
+}
+
+/**
+Call to LDD or subordinate object to reset/re-initialise the Physical device
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::ResetInterface()
+{
+ iControl->Stop();
+ TRAPD(err,iControl->StartL());
+ return err;
+}
+
+/**
+Sender Class is generic and does not want to know about RMBuf's
+Copy to a Heap Buffer and Free the packet. EtherII MAC layer comments
+Say we should free the packet buffer
+RMBuf could contain a chain so get into a contiguous buffer
+@param aPacket Reference to a chain of data buffers to be passed to the line.
+@return 0 Tells the higher layer to send no more data.
+ 1 Tells higher layer that it can send more data.
+*/
+TInt CPcCardPktDrv::Send(RMBufChain &aPacket)
+{
+ if(!iControl->CardOpen())
+ {
+ aPacket.Free();
+ return KErrNotReady;
+ }
+ HBufC8 * buf = NULL;
+ TRAPD(err,buf = HBufC8::NewMaxL(aPacket.Length()));
+ if(err != KErrNone)
+ {
+ aPacket.Free();
+ return err;
+ }
+ TPtr8 ptr = buf->Des();
+ aPacket.CopyOut(ptr);
+ aPacket.Free();
+ return(iControl->Send(buf));
+}
+
+/**
+Read the Available data.
+@param aBuffer A Reference to a buffer holding data.
+*/
+void CPcCardPktDrv::ReadDataAvailable(TDesC8& aBuffer)
+{
+ RMBufPacket frame;
+ TRAPD(ret,frame.CreateL(aBuffer,0));
+ if (ret == KErrNone)
+ {
+ frame.Pack();
+ iParent->Process(frame);
+ }
+}
+
+/**
+Resume Sending is a notification call into NIF from the lower layer telling the NIF that a
+previous sending congestion situation has been cleared and it can accept more downstack data.
+*/
+void CPcCardPktDrv::ResumeSending()
+{
+ iParent->ResumeSending();
+}
+
+/**
+Call to LDD or subordinate object to set the receive mode of the LAN Device
+@param aMode The mode to be set for the LAN Device.
+@return KErrNotSupported LAN Device does not support.
+*/
+TInt CPcCardPktDrv::SetRxMode(TRxMode /*aMode*/)
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to Get the receive mode of the LAN Device
+@return KErrNotSupported LAN Device does not support.
+*/
+TInt CPcCardPktDrv::GetRxMode() const
+{
+ return KErrNotSupported;
+}
+
+/**
+Specifies the AccessType.
+@return KErrNotSupported LAN Device does not support.
+*/
+TInt CPcCardPktDrv::AccessType()
+{
+ return KErrNotSupported;
+}
+
+/**
+Specifies the ReleaseType.
+@return KErrNotSupported LAN Device does not support.
+*/
+TInt CPcCardPktDrv::ReleaseType()
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to get the Hardware address of the LAN Device
+@return NULL Failure.
+ (NULL Terminated Binary String) The Hardware Address of the interface. LAN Device
+ Specific
+*/
+TUint8* CPcCardPktDrv::GetInterfaceAddress()const
+{
+ return (iControl->GetInterfaceAddress());
+}
+
+/**
+Call to LDD or subordinate object to set the Hardware address of the LAN Device.
+@param THWAddr Address of where the Multicast list should be written.
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::SetInterfaceAddress(const THWAddr&)
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to retrieve the Multicast List from the LAN Device
+@param aAddr Address of where the Multicast list should be written.
+@param n Output Parameter , number of Addresses written
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::GetMulticastList(const THWAddr* /*aAddr*/, TInt& /*n*/) const
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to set the Multicast List for the LAN Device.
+@param aAddr Address of where the Multicast list should be written.
+@param n Output Parameter , number of Addresses written
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::SetMulticastList(const THWAddr* /*aAddr*/, TInt /*n*/)
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to power up the LAN Device.
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::InterfacePowerUp()
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to power down the LAN Device
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::InterfacePowerDown()
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to suspend the LAN Device.
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::InterfaceSleep()
+{
+ return KErrNotSupported;
+}
+
+/**
+Call to LDD or subordinate object to resume the LAN Device.
+@return KErrNone if Successful
+ KErrNotSupported LAN Device does not support.
+ Implementation specific Error Code Failure
+*/
+TInt CPcCardPktDrv::InterfaceResume()
+{
+ return KErrNotSupported;
+}
+
+/**
+Resume Sending is a notification call into NIF from the lower layer telling the NIF that
+the interface is now up and can accept and transmit data. NIF subsequently calls all the
+bearers' StartSending() methods directly.
+*/
+void CPcCardPktDrv::LinkLayerUp()
+{
+ iParent->LinkLayerUp();
+}
+
+/**
+Receive notifications from agent
+*/
+TInt CPcCardPktDrv::Notification(enum TAgentToNifEventType /*aEvent*/, void* /*aInfo*/)
+{
+ return KErrNotSupported;
+}
+
+/**
+Receive Control() calls from agent/nifman/connection
+*/
+TInt CPcCardPktDrv::Control(TUint /*aLevel*/,TUint /*aName*/,TDes8& /*aOption*/, TAny* /*aSource*/)
+{
+ return KErrNotSupported;
+}
+
+/**
+Return the pointer to the ethernet nif.
+Purely for access to commdb reading functionality
+*/
+CLANLinkCommon* CPcCardPktDrv::NifNotify()
+{
+ return iParent;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/linklayerprotocols/ethernetnif/EtherPkt/CardIo.cpp Thu Mar 04 11:58:36 2010 +0000
@@ -0,0 +1,461 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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:
+//
+//
+
+/**
+ @file
+*/
+
+#include <nifman.h>
+#include <nifvar.h>
+#include <nifutl.h>
+#include <es_mbuf.h>
+#include "PKTDRV.H"
+#include "ETHINTER.H"
+#include "Cardctl.h"
+
+
+
+
+#ifdef __DebugCardLo__
+// TCP packet tracing debug
+const TUint8 ETHER2_TYPE_IP_MSB = 0x08;
+const TUint8 ETHER2_TYPE_IP_LSB = 0x00;
+const TUint8 IP_TYPE_TCP = 0x06;
+static inline 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
+
+
+/**
+Send active object class
+When CIOBuffer's are passed to SendL() the class takes ownership and is
+therefore resposible for freeing them in the RunL()
+@internalComponent
+*/
+const TInt KTxQueueThreshold = 40;
+
+/**
+Constructor.
+*/
+CPcCardSender::CPcCardSender() : CActive(EPriorityStandard)
+{
+
+}
+
+/**
+Destructor.
+Could be buffers on the transmit queue, free them as this class should be sole owner.
+*/
+CPcCardSender::~CPcCardSender()
+{
+ EmptyQueue();
+ Cancel();
+}
+
+/**
+Standard CActive construction.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+@return A pointer to CPcCardSender object.
+*/
+CPcCardSender* CPcCardSender::NewL(CPcCardControlEngine* aParent)
+{
+ CPcCardSender *sd=new (ELeave) CPcCardSender;
+ CleanupStack::PushL(sd);
+ sd->InitL(aParent);
+ CActiveScheduler::Add(sd);
+ CleanupStack::Pop();
+ return sd;
+}
+
+/**
+Add the newly created object to an object container.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+*/
+void CPcCardSender::InitL(CPcCardControlEngine* aParent)
+{
+ iParent=aParent;
+ iTxQueue.SetOffset(CIOBuffer::LinkOffset());
+ iQueueLength = 0;
+ iStopSending = EFalse;
+}
+
+/**
+Protocol inspects return
+It blocks sending if it receives a return <= 0
+This value should be propogated up through the stack
+@internalComponent
+*/
+const TInt KStopSending = 0;
+
+/**
+Protocol inspects return to indicate Keep sending the data.
+@internalComponent
+*/
+const TInt KContinueSending = 1;
+
+/**
+Writes the data to buffer.
+
+@param aBuffer The data to be send.
+@return 0 Tells the higher layer to stop sending the data.
+ 1 Tells higher layer that it can continue sending more data.
+*/
+TInt CPcCardSender::Send(CIOBuffer *aBuffer)
+{
+
+ // Check to see if we need to start transmission
+ // Pseudo interrupt queue
+ TBool startTx = iTxQueue.IsEmpty();
+
+ iTxQueue.AddLast(*aBuffer);
+ iQueueLength++;
+ if(startTx)
+ {
+ // Transmitter was idle start next transmit
+ iParent->iCard.Write(iStatus,aBuffer->Ptr());
+ SetActive();
+ }
+ else
+ {
+ }
+ // The stack could saturate us with data
+ // Tell the stack to send no more
+ // We will unblock the stack when the queue size drops below
+ // the the threshold
+ if(iQueueLength >= KTxQueueThreshold)
+ {
+ iStopSending = ETrue;
+ return KStopSending;
+ }
+ else
+ {
+ return KContinueSending;
+ }
+}
+
+/**
+Free all queued buffers. Should be safe as this class owns them
+*/
+void CPcCardSender::EmptyQueue()
+{
+
+ while(!iTxQueue.IsEmpty())
+ {
+ CIOBuffer* buf = iTxQueue.First();
+ iTxQueue.Remove(*buf);
+ delete buf;
+ }
+ iQueueLength = 0;
+ iStopSending = EFalse;
+}
+
+/**
+Write completion from the LDD. Pseudo transmit interrupt handler
+*/
+void CPcCardSender::RunL()
+{
+ // Check for error, all we can do is free the buffers
+ if(iStatus.Int()!=KErrNone)
+ {
+ EmptyQueue();
+ return;
+ }
+
+ if(!iTxQueue.IsEmpty())
+ {
+ // Head of the queue has been transmitted
+ // Remove it and free it
+ CIOBuffer* buf = iTxQueue.First();
+ iTxQueue.Remove(*buf);
+ iQueueLength--;
+ delete buf;
+
+
+ // Check to see if there are still buffers queued.
+ // Start next transmit if there are
+ TBool startTx;
+ (iTxQueue.IsEmpty()) ? (startTx = EFalse) : (startTx = ETrue);
+ if(startTx)
+ {
+ buf = iTxQueue.First();
+ iParent->iCard.Write(iStatus,buf->Ptr());
+ SetActive();
+ }
+ else
+ {
+
+ }
+ // Resume sending if the protocol was previously blocked
+ if(iStopSending && iQueueLength < KTxQueueThreshold)
+ {
+ iStopSending = EFalse;
+ iParent->ResumeSending();
+ }
+ }
+}
+
+/**
+cancellation of an outstanding request.
+*/
+void CPcCardSender::DoCancel()
+{
+ iParent->iCard.WriteCancel();
+}
+
+/**
+Read active object class.
+Read kept permanently on the LDD
+Read completion is notified immediately up through the stack
+with the one receive buffer therefore no Q.
+*/
+CPcCardReceiver::CPcCardReceiver() : CActive(EPriorityMore) , iRecvBufPtr(NULL,0)
+{
+
+}
+
+/**
+Constructor.
+*/
+CPcCardReceiver::~CPcCardReceiver()
+{
+ Cancel();
+ // One buffer only
+ delete iRecvBuffer;
+}
+
+/**
+Standard CActive construction.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+@return A pointer to CPcCardReceiver object.
+*/
+CPcCardReceiver* CPcCardReceiver::NewL(CPcCardControlEngine* aParent)
+{
+ CPcCardReceiver *rv=new (ELeave) CPcCardReceiver;
+ CleanupStack::PushL(rv);
+ rv->InitL(aParent);
+ CActiveScheduler::Add(rv);
+ CleanupStack::Pop();
+ return rv;
+}
+
+/**
+Allocate the one and only read buffer.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+*/
+void CPcCardReceiver::InitL(CPcCardControlEngine* aParent)
+{
+ iParent=aParent;
+ iRecvBufLength=KEtherBufSize;
+ iRecvBuffer=HBufC8::NewMaxL(iRecvBufLength);
+ TPtr8 temp=iRecvBuffer->Des();
+ iRecvBufPtr.Set(temp);
+}
+
+/**
+Pass the receive buffer to the Card.
+*/
+void CPcCardReceiver::QueueRead()
+{
+ iRecvBufPtr.SetMax();
+ iParent->iCard.Read(iStatus,iRecvBufPtr);
+ SetActive();
+}
+
+/**
+Pseudo read interrupt handler.
+*/
+void CPcCardReceiver::RunL()
+{
+ if (iParent->CardOpen())
+ {
+ if (iStatus.Int()!=KErrNone)
+ {
+ QueueRead();
+ return;
+ }
+ // Pass the buffer up the stack
+ // and queue the next read, safe to reuse the buffer.
+ if(iRecvBufPtr.Length())
+ {
+ iParent->ProcessReceivedPacket(iRecvBufPtr);
+ }
+ QueueRead();
+ }
+ else
+ {
+
+ }
+}
+
+/**
+Cancellation of an outstanding request.
+*/
+void CPcCardReceiver::DoCancel()
+{
+ iParent->iCard.ReadCancel();
+}
+
+/**
+Constructor.
+*/
+CPcCardEventHandler::CPcCardEventHandler() : CActive(EPriorityStandard)
+{
+
+}
+
+/**
+Destructor.
+*/
+CPcCardEventHandler::~CPcCardEventHandler()
+{
+ Cancel();
+}
+
+/**
+Allocate the one and only read buffer.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+*/
+void CPcCardEventHandler::InitL(CPcCardControlEngine* aParent)
+{
+ iParent = aParent;
+}
+
+/**
+Standard CActive construction
+@param aParent Pointer to the parent CPcCardControlEngine class.
+@return A pointer to the CPcCardEventHandler object.
+*/
+CPcCardEventHandler* CPcCardEventHandler::NewL(CPcCardControlEngine* aParent)
+{
+ CPcCardEventHandler *p=new (ELeave) CPcCardEventHandler;
+ CleanupStack::PushL(p);
+ p->InitL(aParent);
+ CActiveScheduler::Add(p);
+ CleanupStack::Pop();
+ return p;
+}
+
+/**
+Handles an active object’s request completion event.
+*/
+void CPcCardEventHandler::RunL()
+{
+ // TODO Parse code in iStatus for type of event
+}
+
+/**
+Cancellation of an outstanding request.
+*/
+void CPcCardEventHandler::DoCancel()
+{
+}
+
+/**
+Gets the Event generated by the device drivers.
+*/
+void CPcCardEventHandler::GetEvent()
+{
+ // Tell the device driver we want ALL Events
+ iEventBuffer.SetLength(1);
+ iEventBuffer[0] = 0xFF;
+ SetActive();
+}
+
+/**
+Constructor.
+*/
+CPcCardIOCTL::CPcCardIOCTL() : CActive(EPriorityStandard)
+{
+
+}
+
+/**
+Destructor.
+*/
+CPcCardIOCTL::~CPcCardIOCTL()
+{
+ Cancel();
+}
+
+/**
+Add the newly created object to an object container.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+*/
+void CPcCardIOCTL::InitL(CPcCardControlEngine* aParent)
+{
+ iParent = aParent;
+}
+
+TInt CPcCardIOCTL::Ioctl(const TUint8 aIOCTLCode)
+{
+ if(IsActive())
+ return KErrNotReady;
+ iIOCTLBuffer.SetLength(1);
+ iIOCTLBuffer[0] = aIOCTLCode;
+ iCurrentIOCTL = aIOCTLCode;
+ SetActive();
+ return KErrNone;
+}
+
+
+/**
+Standard CActive construction.
+@param aParent Pointer to the parent CPcCardControlEngine class.
+@return A pointer to CPcCardIOCTL object.
+*/
+CPcCardIOCTL* CPcCardIOCTL::NewL(CPcCardControlEngine* aParent)
+{
+ CPcCardIOCTL *p=new (ELeave) CPcCardIOCTL;
+ CleanupStack::PushL(p);
+ p->InitL(aParent);
+ CActiveScheduler::Add(p);
+ CleanupStack::Pop();
+ return p;
+}
+
+/**
+Handles an active object’s request completion event.
+*/
+void CPcCardIOCTL::RunL()
+{
+ {
+ iParent->iReceiver->QueueRead();
+ iParent->LinkLayerUp();
+ }
+}
+
+/**
+Cancellation of an outstanding request.
+*/
+void CPcCardIOCTL::DoCancel()
+{
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/linklayerprotocols/ethernetnif/EtherPkt/Cardctl.h Thu Mar 04 11:58:36 2010 +0000
@@ -0,0 +1,201 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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:
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#if !defined(__CARDCTL_H__)
+#define __CARDCTL_H__
+
+#include <d32ethernet.h>
+
+#include "carddrv.h"
+#include <comms-infras/connectionsettings.h> // for KSlashChar
+
+const TInt KConfigBufferSize = 12;
+
+
+NONSHARABLE_CLASS(CIOBuffer) : public CBase
+/**
+Generic buffer class
+Enables HBufC8 pointers to be queued
+@internalComponent
+*/
+{
+public:
+ ~CIOBuffer();
+ inline HBufC8* Data() const {return iBuf;};
+ void FreeData();
+ inline TPtr8& Ptr() {return iBufPtr;};
+ void Assign(HBufC8* aBuffer = NULL);
+ static CIOBuffer* NewL(HBufC8* aBuf = NULL);
+ static CIOBuffer* NewL(const TInt aSize);
+ static TInt LinkOffset();
+
+private:
+ CIOBuffer();
+ void ConstructL(const TInt aSize);
+ // void Construct(HBufC8* aBuffer);
+
+ TSglQueLink iLink;
+ HBufC8* iBuf;
+ TPtr8 iBufPtr;
+};
+
+
+// Main Card Control class. Controls open, close, read, write etc
+class CPcCardSender;
+class CPcCardReceiver;
+class CPcCardIOCTL;
+class CPcCardEventHandler;
+
+NONSHARABLE_CLASS(CPcCardControlEngine) : public CBase
+/**
+@internalComponent
+*/
+{
+public:
+ friend class CPcCardSender;
+ friend class CPcCardReceiver;
+ friend class CPcCardIOCTL;
+ friend class CPcCardEventHandler;
+
+ static CPcCardControlEngine *NewL(CPcCardPktDrv* aPktDrv);
+ ~CPcCardControlEngine();
+ void StartL();
+ void Stop();
+ TUint8* GetInterfaceAddress();
+ TInt Send(HBufC8* aBuffer);
+ TBool CardOpen(){return iCardOpen;};
+
+#if (!defined __WINS__)
+ void ParseMACFromFileL();
+#endif
+
+
+private:
+ CPcCardControlEngine(CPcCardPktDrv* aPktDrv);
+ void ConstructL();
+ void ProcessReceivedPacket(TDesC8 &aBuffer);
+ void ResumeSending();
+ void LinkLayerUp();
+ void LoadDeviceDriversL();
+
+private:
+ TBool iCardOpen;
+ CPcCardPktDrv* iNotify;
+
+ TBuf8<KConfigBufferSize> iConfig;
+
+ CPcCardSender* iSender;
+ CPcCardReceiver* iReceiver;
+ CPcCardEventHandler* iEventHandler;
+ RBusDevEthernet iCard;
+ TInt iPcmciaSocket;
+
+ TBuf<KCommsDbSvrDefaultTextFieldLength> iPDDName;
+ TBuf<KCommsDbSvrDefaultTextFieldLength> iLDDName;
+};
+
+NONSHARABLE_CLASS(CPcCardSender) : public CActive
+/**
+Writer Active object class
+Queues buffers for transmit
+@internalComponent
+*/
+{
+public:
+ static CPcCardSender* NewL(CPcCardControlEngine* aParent);
+ ~CPcCardSender();
+ TInt Send(CIOBuffer* aBuffer);
+ void EmptyQueue();
+
+private:
+ virtual void RunL();
+ virtual void DoCancel();
+ CPcCardSender();
+ void InitL(CPcCardControlEngine* aParent);
+
+ TInt iQueueLength;
+ CPcCardControlEngine* iParent;
+ TSglQue<CIOBuffer> iTxQueue;
+ TBool iStopSending;
+};
+
+NONSHARABLE_CLASS(CPcCardReceiver) : public CActive
+/**
+Reader active object
+One receive buffer only, read queue handled by LDD
+@internalComponent
+*/
+{
+public:
+ static CPcCardReceiver* NewL(CPcCardControlEngine* aParent);
+ ~CPcCardReceiver();
+ void QueueRead();
+private:
+ virtual void RunL();
+ virtual void DoCancel();
+ CPcCardReceiver();
+ void InitL(CPcCardControlEngine* aParent);
+
+ CPcCardControlEngine* iParent;
+ HBufC8* iRecvBuffer;
+ TUint iRecvBufLength;
+ TPtr8 iRecvBufPtr;
+};
+
+NONSHARABLE_CLASS(CPcCardEventHandler) : public CActive
+/**
+@internalComponent
+*/
+{
+public:
+ ~CPcCardEventHandler();
+ static CPcCardEventHandler* NewL(CPcCardControlEngine* aParent);
+ void GetEvent();
+private:
+ virtual void RunL();
+ virtual void DoCancel();
+ CPcCardEventHandler();
+ void InitL(CPcCardControlEngine* aParent);
+
+ TBuf8<32> iEventBuffer;
+ CPcCardControlEngine* iParent;
+};
+
+NONSHARABLE_CLASS(CPcCardIOCTL) : public CActive
+/**
+@internalComponent
+*/
+{
+public:
+ ~CPcCardIOCTL();
+ static CPcCardIOCTL* NewL(CPcCardControlEngine* aParent);
+ TInt Ioctl(const TUint8 aIOCTLCode);
+private:
+ virtual void RunL();
+ virtual void DoCancel();
+ CPcCardIOCTL();
+ void InitL(CPcCardControlEngine* aParent);
+ TBuf8<32> iIOCTLBuffer;
+ TUint8 iCurrentIOCTL;
+
+ CPcCardControlEngine* iParent;
+};
+
+#endif