examples/Base/IPC/AdvancedClientServerExample/driver/driver1_ldd.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 Logical Device Driver 
*/

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

_LIT(KDriver1PanicCategory,"Driver1");

//
// DDriver1Factory
//

DECLARE_STANDARD_LDD()
        {
        return new DDriver1Factory;
        }

DDriver1Factory::DDriver1Factory()
        {
        // Sets the version number for this device.
        iVersion=RDriver1::VersionRequired();
        // Indicate that we work with a PDD
        iParseMask=KDeviceAllowPhysicalDevice;
        }

TInt DDriver1Factory::Install()
        {
        return SetName(&RDriver1::Name());
        }

DDriver1Factory::~DDriver1Factory()
        {
        }

void DDriver1Factory::GetCaps(TDes8& aDes) const
        {
        // Create a capabilities object
        RDriver1::TCaps caps;
        caps.iVersion = iVersion;
        // Write it back to user memory
        Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));
        }

TInt DDriver1Factory::Create(DLogicalChannelBase*& aChannel)
        {
        aChannel=new DDriver1Channel;
        if(!aChannel)
                return KErrNoMemory;

        return KErrNone;
        }

DDriver1Channel::DDriver1Channel()
        :       iSendDataDfc(SendDataDfc, this, 1),        // DFC is priority '1'
                iReceiveDataDfc(ReceiveDataDfc, this, 1)   // DFC is priority '1'
        {
        // Get pointer to client thread's DThread object
        iClient=&Kern::CurrentThread();

        // Open a reference on client thread so its control block can't disappear until
        // this driver has finished with it.
        // Note, this call to Open can't fail since it's the thread we are currently running in.
        iClient->Open();
        }

TInt DDriver1Channel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
        {
        // Check Platform Security capabilities of client thread (if required).
        //
        // Here we handle the simple case where:
        // 1. The device driver can only have one client thread
        // 2. The security policy is the binary all-or-nothing policy.
        //    E.g. "If you have the right capability you can do anything with the driver
        //    and if you don't have the capability you can't do anything"
        // 
        // If only some functionality of the driver is restricted, then the security check should
        // go elsewhere, e.g. in DoRequest/DoControl. In that case Kern::CurrentThreadHasCapability()
        // shouldn't be used because the 'current thread' isn't the client.
        //
        // In this example we do a check here for ECapabilityMultimediaDD...
        if(!Kern::CurrentThreadHasCapability(ECapabilityMultimediaDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by DRIVER1")))
                return KErrPermissionDenied;

        // Check version
        if (!Kern::QueryVersionSupported(RDriver1::VersionRequired(),aVer))
                return KErrNotSupported;

        // Setup LDD for receiving client messages
        SetDfcQ(Kern::DfcQue0());
        iMsgQ.Receive();

        // To receive client messages, associate the DFCs with the queue created above.
        iSendDataDfc.SetDfcQ(iDfcQ);
        iReceiveDataDfc.SetDfcQ(iDfcQ);

        // Give PDD a pointer to this channel
        Pdd()->iLdd=this;

        // Done
        return KErrNone;
        }

DDriver1Channel::~DDriver1Channel()
        {
        // Cancel all processing that we may be doing
        DoCancel(RDriver1::EAllRequests);
        // Close our reference on the client thread
        Kern::SafeClose((DObject*&)iClient,NULL);
        }

TInt DDriver1Channel::RequestUserHandle(DThread* aThread, TOwnerType aType)
        {
        // Make sure that only our client can get a handle
        if (aType!=EOwnerThread || aThread!=iClient)
                return KErrAccessDenied;
        return KErrNone;
        }

void DDriver1Channel::HandleMsg(TMessageBase* aMsg)
        {
        TThreadMessage& m=*(TThreadMessage*)aMsg;

        // Get message type
        TInt id=m.iValue;

        // Decode the message type and dispatch it to the relevent handler function...
        if (id==(TInt)ECloseMsg)
                {
                // Channel Close
                DoCancel(RDriver1::EAllRequests);
                m.Complete(KErrNone, EFalse);
                return;
                }

        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());
                if (r!=KErrNone)
                        Kern::RequestComplete(iClient,pS,r);
                m.Complete(KErrNone,ETrue);
                }
        else
                {
                // DoControl
                TInt r=DoControl(id,m.Ptr0(),m.Ptr1());
                m.Complete(r,ETrue);
                }
        }

TInt DDriver1Channel::DoControl(TInt aFunction, TAny* a1, TAny* a2)
        {
        (void)a2;   // a2 not used in this example

        TInt r;

        switch (aFunction)
                {
                case RDriver1::EGetConfig:
                        r = GetConfig((TDes8*)a1);
                        break;

                case RDriver1::ESetConfig:
                        r = SetConfig((const TDesC8*)a1);
                        break;

                default:
                        r = KErrNotSupported;
                        break;
                }

        return r;
        }

TInt DDriver1Channel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
        {
        (void)a2;   // a2 not used in this example

        TInt r;

        switch(aReqNo)
                {
                case RDriver1::ESendData:
                        r=SendData(aStatus,(const TDesC8*)a1);
                        break;

                case RDriver1::EReceiveData:
                        r=ReceiveData(aStatus,(TDes8*)a1);
                        break;

                default:
                        r = KErrNotSupported;
                        break;
                }

        return r;
        }

void DDriver1Channel::DoCancel(TUint aMask)
        {
        if(aMask&(1<<RDriver1::ESendData))
                SendDataCancel();
        if(aMask&(1<<RDriver1::EReceiveData))
                ReceiveDataCancel();
        }

//
// Methods for processing configuration control messages
//

TInt DDriver1Channel::GetConfig(TDes8* aConfigBuf)
        {
        // Create a structure giving the current configuration
        RDriver1::TConfig config;
        CurrentConfig(config);

        // Write the config to the client
        TPtrC8 ptr((const TUint8*)&config,sizeof(config));
        return Kern::ThreadDesWrite(iClient,aConfigBuf,ptr,0,KTruncateToMaxLength,NULL);
        }

TInt DDriver1Channel::SetConfig(const TDesC8* aConfigBuf)
        {
        // Don't allow configuration changes whilst we're busy
        if(iSendDataStatus || iReceiveDataStatus)
                return KErrInUse;

        // Create a config structure.
        RDriver1::TConfig config;
        CurrentConfig(config);

        // Note: We have filled config with the current settings, this is to allow
        // backwards compatibility when a client gives us an old (and shorter) version
        // of the config structure.

        // Read the config structure from client
        TPtr8 ptr((TUint8*)&config,sizeof(config));
        TInt r=Kern::ThreadDesRead(iClient,aConfigBuf,ptr,0);
        if(r!=KErrNone)
                return r;

        // Use config data to setup the driver. Checking that parameters which aren't settable
        // either contain the correct values or are zero (meaning 'default')
        if(config.iPddBufferSize && config.iPddBufferSize!=Pdd()->BufferSize())
                return KErrArgument;

        if(config.iMaxSendDataSize && config.iMaxSendDataSize!=iSendDataBuffer.MaxSize())
                return KErrArgument;

        if(config.iMaxReceiveDataSize && config.iMaxReceiveDataSize!=iReceiveDataBuffer.MaxSize())
                return KErrArgument;

        r=Pdd()->SetSpeed(config.iSpeed);
        if(r!=KErrNone)
                return r;

        return r;
        }

void DDriver1Channel::CurrentConfig(RDriver1::TConfig& aConfig)
        {
        aConfig.iSpeed = Pdd()->Speed();
        aConfig.iPddBufferSize = Pdd()->BufferSize();
        aConfig.iMaxSendDataSize = iSendDataBuffer.MaxSize();
        aConfig.iMaxReceiveDataSize = iReceiveDataBuffer.MaxSize();
        }

//
// Methods for processing 'SendData'
//

TInt DDriver1Channel::SendData(TRequestStatus* aStatus,const TDesC8* aData)
        {
        // Check that a 'SendData' isn't already in progress
        if(iSendDataStatus)
                {
                Kern::ThreadKill(iClient,EExitPanic,ERequestAlreadyPending,KDriver1PanicCategory);
                return KErrInUse;
                }

        // Read data from client into our buffer
        TInt r=Kern::ThreadDesRead(iClient,aData,iSendDataBuffer,0);
        if(r!=KErrNone)
                return r;

        // Give data to PDD so that it can do the work
        r=Pdd()->SendData(iSendDataBuffer);
        if(r!=KErrNone)
                return r;

        // Save the client request status and return
        iSendDataStatus = aStatus;
        return KErrNone;
        }

void DDriver1Channel::SendDataCancel()
        {
        if(iSendDataStatus)
                {
                // Tell PDD to stop processing the request
                Pdd()->SendDataCancel();
                // Cancel DFC
                iSendDataDfc.Cancel();
                // Complete client's request
                Kern::RequestComplete(iClient,iSendDataStatus,KErrCancel);
                }
        }

void DDriver1Channel::SendDataComplete(TInt aResult)
        {
        // Save result code
        iSendDataResult = aResult;
        // Queue DFC
        iSendDataDfc.Add();
        }

void DDriver1Channel::SendDataDfc(TAny* aPtr)
        {
        ((DDriver1Channel*)aPtr)->DoSendDataComplete();
        }

void DDriver1Channel::DoSendDataComplete()
        {
        TInt result = iSendDataResult;
        // Complete clients request
        Kern::RequestComplete(iClient,iSendDataStatus,result);
        }

//
// Methods for processing 'ReceiveData'
//

TInt DDriver1Channel::ReceiveData(TRequestStatus* aStatus,TDes8* aPtr)
        {
        // Check that a 'ReceiveData' isn't already in progress
        if(iReceiveDataStatus)
                {
                Kern::ThreadKill(iClient,EExitPanic,ERequestAlreadyPending,KDriver1PanicCategory);
                return KErrInUse;
                }

        // Ask PDD for data
        TInt r=Pdd()->ReceiveData(iReceiveDataBuffer);
        if(r!=KErrNone)
                return r;

        // Save the client request status and descriptor before returning
        iReceiveDataStatus = aStatus;
        iReceiveDataDescriptor = aPtr;
        return KErrNone;
        }

void DDriver1Channel::ReceiveDataCancel()
        {
        if(iReceiveDataStatus)
                {
                // Tell PDD to stop processing the request
                Pdd()->ReceiveDataCancel();
                // Cancel DFC
                iReceiveDataDfc.Cancel();
                // Finished with client descriptor, so NULL it to help detect coding errors
                iReceiveDataDescriptor = NULL;
                // Complete clients request
                Kern::RequestComplete(iClient,iReceiveDataStatus,KErrCancel);
                }
        }

void DDriver1Channel::ReceiveDataComplete(TInt aResult)
        {
        // Save result code
        iReceiveDataResult = aResult;
        // Queue DFC
        iReceiveDataDfc.Add();
        }

void DDriver1Channel::ReceiveDataDfc(TAny* aPtr)
        {
        ((DDriver1Channel*)aPtr)->DoReceiveDataComplete();
        }

void DDriver1Channel::DoReceiveDataComplete()
        {
        // Write data to client from our buffer
        TInt result=Kern::ThreadDesWrite(iClient,iReceiveDataDescriptor,iReceiveDataBuffer,0);

        // Finished with client descriptor, so NULL it to help detect coding errors
        iReceiveDataDescriptor = NULL;

        // Use result code from PDD if it was an error
        if(iReceiveDataResult!=KErrNone)
                result = iReceiveDataResult;

        // Complete client's request
        Kern::RequestComplete(iClient,iReceiveDataStatus,result);
        }

---