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

Go to the documentation of this file.

/*
Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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);
        }

---