examples/Base/IPC/AdvancedClientServerExample/driver/driver1_pdd.cpp

Go to the documentation of this file.

// Copyright (c) 2007-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:
// Example Physical Device Driver
//



#include <kern_priv.h>
#include "driver1.h"
#include "driver1_dev.h"

class DDevice1PddFactory : public DPhysicalDevice
        {
public:
        DDevice1PddFactory();
        
        // Inherited from DPhysicalDevice
        virtual TInt Install();
        virtual void GetCaps(TDes8& aDes) const;
        virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);
        virtual TInt Validate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);
public:
        TInt iHardwareInUse;
private:
        enum TMinimumLDDVersion
                {
                EMinimumLddMajorVersion=1,
                EMinimumLddMinorVersion=0,
                EMinimumLddBuild=0 //Not used
                };
        };

// Name for PDD, must match LDD name with a '.' and distinguishing name appended
_LIT(KDriver1PddName,"DRIVER1.template");

class DDriver1Device : public DDriver1
        {
public:
        DDriver1Device(DDevice1PddFactory* aFactory);
        ~DDriver1Device();
        TInt DoCreate();
        
        // Inherited from DDriver1. These functions are called by the LDD.
        virtual TInt BufferSize() const;
        virtual TInt Speed() const;
        virtual TInt SetSpeed(TInt aSpeed);
        virtual TInt SendData(const TDesC8& aData);
        virtual void SendDataCancel();
        virtual TInt ReceiveData(TDes8& aBuffer);
        virtual void ReceiveDataCancel();
private:
        static void SendDataTimerCallback(TAny* aPtr);
        void SendDataCallback();
        static void ReceiveDataTimerCallback(TAny* aPtr);
        void ReceiveDataCallback();
private:
        DDevice1PddFactory* iFactory;
        TInt iSpeed;
        NTimer iSendDataTimer;
        NTimer iReceiveDataTimer;
        TBuf8<256> iBuffer;
        TDes8* iReceiveBuffer;
        };
//
// DDevice1PddFactory
//

DECLARE_STANDARD_PDD()
        {
        return new DDevice1PddFactory;
        }

DDevice1PddFactory::DDevice1PddFactory()
        {
        // Sets version number for this device
        iVersion=RDriver1::VersionRequired();
        }

TInt DDevice1PddFactory::Install()
        {
        return SetName(&KDriver1PddName);
        }

void DDevice1PddFactory::GetCaps(TDes8& aDes) const
        {
        // Create a capabilities object
        DDriver1::TCaps caps;
        caps.iVersion = iVersion;
        // Zero the buffer
        TInt maxLen = aDes.MaxLength();
        aDes.FillZ(maxLen);
        // Copy capabilities
        TInt size=sizeof(caps);
        if(size>maxLen)
                size=maxLen;
        aDes.Copy((TUint8*)&caps,size);
        }

TInt DDevice1PddFactory::Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)
        {
        // Ignore the parameters we aren't interested in...
        (void)aUnit;
        (void)aInfo;
        (void)aVer;

        // Create a new physical channel
        DDriver1Device* device=new DDriver1Device(this);
        aChannel=device;
        if (!device)
                return KErrNoMemory;
        return device->DoCreate();
        }

TInt DDevice1PddFactory::Validate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)
        {
        // Check version numbers
        if ((!Kern::QueryVersionSupported(iVersion,aVer)) || (!Kern::QueryVersionSupported(aVer,TVersion(EMinimumLddMajorVersion,EMinimumLddMinorVersion,EMinimumLddBuild))))
                return KErrNotSupported;

        // We don't support units
    if (aUnit != -1)
        return KErrNotSupported;

        // Ignore extra info, (this could be used for validation purposes).
        // Note, aInfo is a pointer to a descriptor in user memory, therefore safe methods should
        // be used for reading its contents e.g. using Kern::KUDesGet()
        (void)aInfo;

        // OK
        return KErrNone;
        }

DDriver1Device::DDriver1Device(DDevice1PddFactory* aFactory)
        :       iFactory(aFactory),
                iSpeed(100000),  // 100000us (100ms) per byte
                iSendDataTimer(SendDataTimerCallback,this),
                iReceiveDataTimer(ReceiveDataTimerCallback,this)
        {
        }

DDriver1Device::~DDriver1Device()
        {
        // Driver no longer using hardware resources
        NKern::LockedDec(iFactory->iHardwareInUse);
        }

TInt DDriver1Device::DoCreate()
        {
        // Claim the hardware resources by incrementing iHardwareInUse.
        // Must do this before any other failure can happen in this function so that
        // the destructor can safely decrement iHardwareInUse.
        //
        // This method of ensuring hardware is only in use by one driver at a time
        // wouldn't be needed if the driver claimed real hardware resources which
        // could only be used once. E.g. binding to an interrupt.
        if(NKern::LockedInc(iFactory->iHardwareInUse))
                return KErrInUse;

        // Other setup goes here
        return KErrNone;
        }
TInt DDriver1Device::BufferSize() const
        {
        return iBuffer.MaxSize();
        }
        
TInt DDriver1Device::Speed() const
        {
        return iSpeed;
        }

TInt DDriver1Device::SetSpeed(TInt aSpeed)
        {
        if(aSpeed<=0)
                return KErrArgument;
        iSpeed = aSpeed;
        return KErrNone;
        }

// Methods for processing 'SendData'
//
TInt DDriver1Device::SendData(const TDesC8& aData)
        {
        // Save the last part of the data to 'send', we will pretend to 'receive' this later
        iBuffer=aData.Right(iBuffer.MaxSize());
        // Pretend to send the data by waiting for iSpeed micro-seconds per byte...
        iSendDataTimer.OneShot(aData.Size()*iSpeed/NKern::TickPeriod());
        return KErrNone;
        }

void DDriver1Device::SendDataCancel()
        {
        // Stop the timer we were using to pretend we were processing the send.
        iSendDataTimer.Cancel();
        }

void DDriver1Device::SendDataTimerCallback(TAny* aPtr)
        {
        // Just forward callback to non-static callback function
        ((DDriver1Device*)aPtr)->SendDataCallback();
        }

void DDriver1Device::SendDataCallback()
        {
        // Tell LDD we've finished
        iLdd->SendDataComplete(KErrNone);
        }
        
//
// Methods for processing 'ReceiveData'
//
TInt DDriver1Device::ReceiveData(TDes8& aBuffer)
        {
        // Save a pointer to the buffer we need to put the 'received' data in
        iReceiveBuffer=&aBuffer;
        // Pretend to receive the data by waiting for iSpeed micro-seconds per byte...
        iReceiveDataTimer.OneShot(iBuffer.Size()*iSpeed/NKern::TickPeriod());
        return KErrNone;
        }
void DDriver1Device::ReceiveDataCancel()
        {
        // Stop the timer we were using to pretend we were processing the receive
        iReceiveDataTimer.Cancel();
        }
void DDriver1Device::ReceiveDataTimerCallback(TAny* aPtr)
        {
        // Just forward callback to non-static callback function
        ((DDriver1Device*)aPtr)->ReceiveDataCallback();
        }
void DDriver1Device::ReceiveDataCallback()
        {
        // Pretend the data we have received is that saved in iBuffer when we last did a send
        *iReceiveBuffer=iBuffer;
        // Tell LDD we've finished
        iLdd->ReceiveDataComplete(KErrNone);
        }

---