TB10.1 Example Applications: examples/Base/IPC/AdvancedClientServerExample/driver/driver1

00001 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
-00002 // All rights reserved.
-00003 // This component and the accompanying materials are made available
-00004 // under the terms of "Eclipse Public License v1.0"
-00005 // which accompanies this distribution, and is available
-00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
-00007 //
-00008 // Initial Contributors:
-00009 // Nokia Corporation - initial contribution.
-00010 //
-00011 // Contributors:
-00012 //
-00013 // Description:
-00014 // Example Logical Device Driver
-00015 //
-00016 
-00017 
-00018 
-00023 #include <kern_priv.h>
-00024 #include "driver1.h"
-00025 #include "driver1_dev.h"
-00026 
-00027 _LIT(KDriver1PanicCategory,"Driver1");
-00028 
-00029 //
-00030 // DDriver1Factory
-00031 //
-00032 
-00037 DECLARE_STANDARD_LDD()
-00038         {
-00039         return new DDriver1Factory;
-00040         }
-00041 
-00045 DDriver1Factory::DDriver1Factory()
-00046         {
-00047         // Sets the version number for this device.
-00048         iVersion=RDriver1::VersionRequired();
-00049         // Indicate that we work with a PDD
-00050         iParseMask=KDeviceAllowPhysicalDevice;
-00051         }
-00052 
-00059 TInt DDriver1Factory::Install()
-00060         {
-00061         return SetName(&RDriver1::Name());
-00062         }
-00063 
-00067 DDriver1Factory::~DDriver1Factory()
-00068         {
-00069         }
-00070 
-00076 void DDriver1Factory::GetCaps(TDes8& aDes) const
-00077         {
-00078         // Create a capabilities object
-00079         RDriver1::TCaps caps;
-00080         caps.iVersion = iVersion;
-00081         // Write it back to user memory
-00082         Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));
-00083         }
-00084 
-00093 TInt DDriver1Factory::Create(DLogicalChannelBase*& aChannel)
-00094         {
-00095         aChannel=new DDriver1Channel;
-00096         if(!aChannel)
-00097                 return KErrNoMemory;
-00098 
-00099         return KErrNone;
-00100         }
-00101 
-00105 DDriver1Channel::DDriver1Channel()
-00106         :       iSendDataDfc(SendDataDfc, this, 1),        // DFC is priority '1'
-00107                 iReceiveDataDfc(ReceiveDataDfc, this, 1)   // DFC is priority '1'
-00108         {
-00109         // Get pointer to client thread's DThread object
-00110         iClient=&Kern::CurrentThread();
-00111 
-00112         // Open a reference on client thread so its control block can't disappear until
-00113         // this driver has finished with it.
-00114         // Note, this call to Open can't fail since it's the thread we are currently running in.
-00115         iClient->Open();
-00116         }
-00117 
-00128 TInt DDriver1Channel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
-00129         {
-00130         // Check Platform Security capabilities of client thread (if required).
-00131         //
-00132         // Here we handle the simple case where:
-00133         // 1. The device driver can only have one client thread
-00134         // 2. The security policy is the binary all-or-nothing policy.
-00135         //    E.g. "If you have the right capability you can do anything with the driver
-00136         //    and if you don't have the capability you can't do anything"
-00137         // 
-00138         // If only some functionality of the driver is restricted, then the security check should
-00139         // go elsewhere, e.g. in DoRequest/DoControl. In that case Kern::CurrentThreadHasCapability()
-00140         // shouldn't be used because the 'current thread' isn't the client.
-00141         //
-00142         // In this example we do a check here for ECapabilityMultimediaDD...
-00143         if(!Kern::CurrentThreadHasCapability(ECapabilityMultimediaDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by DRIVER1")))
-00144                 return KErrPermissionDenied;
-00145 
-00146         // Check version
-00147         if (!Kern::QueryVersionSupported(RDriver1::VersionRequired(),aVer))
-00148                 return KErrNotSupported;
-00149 
-00150         // Setup LDD for receiving client messages
-00151         SetDfcQ(Kern::DfcQue0());
-00152         iMsgQ.Receive();
-00153 
-00154         // To receive client messages, associate the DFCs with the queue created above.
-00155         iSendDataDfc.SetDfcQ(iDfcQ);
-00156         iReceiveDataDfc.SetDfcQ(iDfcQ);
-00157 
-00158         // Give PDD a pointer to this channel
-00159         Pdd()->iLdd=this;
-00160 
-00161         // Done
-00162         return KErrNone;
-00163         }
-00164 
-00168 DDriver1Channel::~DDriver1Channel()
-00169         {
-00170         // Cancel all processing that we may be doing
-00171         DoCancel(RDriver1::EAllRequests);
-00172         // Close our reference on the client thread
-00173         Kern::SafeClose((DObject*&)iClient,NULL);
-00174         }
-00175 
-00183 TInt DDriver1Channel::RequestUserHandle(DThread* aThread, TOwnerType aType)
-00184         {
-00185         // Make sure that only our client can get a handle
-00186         if (aType!=EOwnerThread || aThread!=iClient)
-00187                 return KErrAccessDenied;
-00188         return KErrNone;
-00189         }
-00190 
-00202 void DDriver1Channel::HandleMsg(TMessageBase* aMsg)
-00203         {
-00204         TThreadMessage& m=*(TThreadMessage*)aMsg;
-00205 
-00206         // Get message type
-00207         TInt id=m.iValue;
-00208 
-00209         // Decode the message type and dispatch it to the relevent handler function...
-00210         if (id==(TInt)ECloseMsg)
-00211                 {
-00212                 // Channel Close
-00213                 DoCancel(RDriver1::EAllRequests);
-00214                 m.Complete(KErrNone, EFalse);
-00215                 return;
-00216                 }
-00217 
-00218         if (id==KMaxTInt)
-00219                 {
-00220                 // DoCancel
-00221                 DoCancel(m.Int0());
-00222                 m.Complete(KErrNone,ETrue);
-00223                 return;
-00224                 }
-00225 
-00226         if (id<0)
-00227                 {
-00228                 // DoRequest
-00229                 TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
-00230                 TInt r=DoRequest(~id,pS,m.Ptr1(),m.Ptr2());
-00231                 if (r!=KErrNone)
-00232                         Kern::RequestComplete(iClient,pS,r);
-00233                 m.Complete(KErrNone,ETrue);
-00234                 }
-00235         else
-00236                 {
-00237                 // DoControl
-00238                 TInt r=DoControl(id,m.Ptr0(),m.Ptr1());
-00239                 m.Complete(r,ETrue);
-00240                 }
-00241         }
-00242 
-00250 TInt DDriver1Channel::DoControl(TInt aFunction, TAny* a1, TAny* a2)
-00251         {
-00252         (void)a2;   // a2 not used in this example
-00253 
-00254         TInt r;
-00255 
-00256         switch (aFunction)
-00257                 {
-00258                 case RDriver1::EGetConfig:
-00259                         r = GetConfig((TDes8*)a1);
-00260                         break;
-00261 
-00262                 case RDriver1::ESetConfig:
-00263                         r = SetConfig((const TDesC8*)a1);
-00264                         break;
-00265 
-00266                 default:
-00267                         r = KErrNotSupported;
-00268                         break;
-00269                 }
-00270 
-00271         return r;
-00272         }
-00273 
-00282 TInt DDriver1Channel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
-00283         {
-00284         (void)a2;   // a2 not used in this example
-00285 
-00286         TInt r;
-00287 
-00288         switch(aReqNo)
-00289                 {
-00290                 case RDriver1::ESendData:
-00291                         r=SendData(aStatus,(const TDesC8*)a1);
-00292                         break;
-00293 
-00294                 case RDriver1::EReceiveData:
-00295                         r=ReceiveData(aStatus,(TDes8*)a1);
-00296                         break;
-00297 
-00298                 default:
-00299                         r = KErrNotSupported;
-00300                         break;
-00301                 }
-00302 
-00303         return r;
-00304         }
-00305 
-00310 void DDriver1Channel::DoCancel(TUint aMask)
-00311         {
-00312         if(aMask&(1<<RDriver1::ESendData))
-00313                 SendDataCancel();
-00314         if(aMask&(1<<RDriver1::EReceiveData))
-00315                 ReceiveDataCancel();
-00316         }
-00317 
-00318 //
-00319 // Methods for processing configuration control messages
-00320 //
-00321 
-00326 TInt DDriver1Channel::GetConfig(TDes8* aConfigBuf)
-00327         {
-00328         // Create a structure giving the current configuration
-00329         RDriver1::TConfig config;
-00330         CurrentConfig(config);
-00331 
-00332         // Write the config to the client
-00333         TPtrC8 ptr((const TUint8*)&config,sizeof(config));
-00334         return Kern::ThreadDesWrite(iClient,aConfigBuf,ptr,0,KTruncateToMaxLength,NULL);
-00335         }
-00336 
-00341 TInt DDriver1Channel::SetConfig(const TDesC8* aConfigBuf)
-00342         {
-00343         // Don't allow configuration changes whilst we're busy
-00344         if(iSendDataStatus || iReceiveDataStatus)
-00345                 return KErrInUse;
-00346 
-00347         // Create a config structure.
-00348         RDriver1::TConfig config;
-00349         CurrentConfig(config);
-00350 
-00351         // Note: We have filled config with the current settings, this is to allow
-00352         // backwards compatibility when a client gives us an old (and shorter) version
-00353         // of the config structure.
-00354 
-00355         // Read the config structure from client
-00356         TPtr8 ptr((TUint8*)&config,sizeof(config));
-00357         TInt r=Kern::ThreadDesRead(iClient,aConfigBuf,ptr,0);
-00358         if(r!=KErrNone)
-00359                 return r;
-00360 
-00361         // Use config data to setup the driver. Checking that parameters which aren't settable
-00362         // either contain the correct values or are zero (meaning 'default')
-00363         if(config.iPddBufferSize && config.iPddBufferSize!=Pdd()->BufferSize())
-00364                 return KErrArgument;
-00365 
-00366         if(config.iMaxSendDataSize && config.iMaxSendDataSize!=iSendDataBuffer.MaxSize())
-00367                 return KErrArgument;
-00368 
-00369         if(config.iMaxReceiveDataSize && config.iMaxReceiveDataSize!=iReceiveDataBuffer.MaxSize())
-00370                 return KErrArgument;
-00371 
-00372         r=Pdd()->SetSpeed(config.iSpeed);
-00373         if(r!=KErrNone)
-00374                 return r;
-00375 
-00376         return r;
-00377         }
-00378 
-00383 void DDriver1Channel::CurrentConfig(RDriver1::TConfig& aConfig)
-00384         {
-00385         aConfig.iSpeed = Pdd()->Speed();
-00386         aConfig.iPddBufferSize = Pdd()->BufferSize();
-00387         aConfig.iMaxSendDataSize = iSendDataBuffer.MaxSize();
-00388         aConfig.iMaxReceiveDataSize = iReceiveDataBuffer.MaxSize();
-00389         }
-00390 
-00391 //
-00392 // Methods for processing 'SendData'
-00393 //
-00394 
-00402 TInt DDriver1Channel::SendData(TRequestStatus* aStatus,const TDesC8* aData)
-00403         {
-00404         // Check that a 'SendData' isn't already in progress
-00405         if(iSendDataStatus)
-00406                 {
-00407                 Kern::ThreadKill(iClient,EExitPanic,ERequestAlreadyPending,KDriver1PanicCategory);
-00408                 return KErrInUse;
-00409                 }
-00410 
-00411         // Read data from client into our buffer
-00412         TInt r=Kern::ThreadDesRead(iClient,aData,iSendDataBuffer,0);
-00413         if(r!=KErrNone)
-00414                 return r;
-00415 
-00416         // Give data to PDD so that it can do the work
-00417         r=Pdd()->SendData(iSendDataBuffer);
-00418         if(r!=KErrNone)
-00419                 return r;
-00420 
-00421         // Save the client request status and return
-00422         iSendDataStatus = aStatus;
-00423         return KErrNone;
-00424         }
-00425 
-00429 void DDriver1Channel::SendDataCancel()
-00430         {
-00431         if(iSendDataStatus)
-00432                 {
-00433                 // Tell PDD to stop processing the request
-00434                 Pdd()->SendDataCancel();
-00435                 // Cancel DFC
-00436                 iSendDataDfc.Cancel();
-00437                 // Complete client's request
-00438                 Kern::RequestComplete(iClient,iSendDataStatus,KErrCancel);
-00439                 }
-00440         }
-00441 
-00445 void DDriver1Channel::SendDataComplete(TInt aResult)
-00446         {
-00447         // Save result code
-00448         iSendDataResult = aResult;
-00449         // Queue DFC
-00450         iSendDataDfc.Add();
-00451         }
-00452 
-00457 void DDriver1Channel::SendDataDfc(TAny* aPtr)
-00458         {
-00459         ((DDriver1Channel*)aPtr)->DoSendDataComplete();
-00460         }
-00461 
-00465 void DDriver1Channel::DoSendDataComplete()
-00466         {
-00467         TInt result = iSendDataResult;
-00468         // Complete clients request
-00469         Kern::RequestComplete(iClient,iSendDataStatus,result);
-00470         }
-00471 
-00472 //
-00473 // Methods for processing 'ReceiveData'
-00474 //
-00475 
-00482 TInt DDriver1Channel::ReceiveData(TRequestStatus* aStatus,TDes8* aPtr)
-00483         {
-00484         // Check that a 'ReceiveData' isn't already in progress
-00485         if(iReceiveDataStatus)
-00486                 {
-00487                 Kern::ThreadKill(iClient,EExitPanic,ERequestAlreadyPending,KDriver1PanicCategory);
-00488                 return KErrInUse;
-00489                 }
-00490 
-00491         // Ask PDD for data
-00492         TInt r=Pdd()->ReceiveData(iReceiveDataBuffer);
-00493         if(r!=KErrNone)
-00494                 return r;
-00495 
-00496         // Save the client request status and descriptor before returning
-00497         iReceiveDataStatus = aStatus;
-00498         iReceiveDataDescriptor = aPtr;
-00499         return KErrNone;
-00500         }
-00501 
-00505 void DDriver1Channel::ReceiveDataCancel()
-00506         {
-00507         if(iReceiveDataStatus)
-00508                 {
-00509                 // Tell PDD to stop processing the request
-00510                 Pdd()->ReceiveDataCancel();
-00511                 // Cancel DFC
-00512                 iReceiveDataDfc.Cancel();
-00513                 // Finished with client descriptor, so NULL it to help detect coding errors
-00514                 iReceiveDataDescriptor = NULL;
-00515                 // Complete clients request
-00516                 Kern::RequestComplete(iClient,iReceiveDataStatus,KErrCancel);
-00517                 }
-00518         }
-00519 
-00523 void DDriver1Channel::ReceiveDataComplete(TInt aResult)
-00524         {
-00525         // Save result code
-00526         iReceiveDataResult = aResult;
-00527         // Queue DFC
-00528         iReceiveDataDfc.Add();
-00529         }
-00530 
-00535 void DDriver1Channel::ReceiveDataDfc(TAny* aPtr)
-00536         {
-00537         ((DDriver1Channel*)aPtr)->DoReceiveDataComplete();
-00538         }
-00539 
-00543 void DDriver1Channel::DoReceiveDataComplete()
-00544         {
-00545         // Write data to client from our buffer
-00546         TInt result=Kern::ThreadDesWrite(iClient,iReceiveDataDescriptor,iReceiveDataBuffer,0);
-00547 
-00548         // Finished with client descriptor, so NULL it to help detect coding errors
-00549         iReceiveDataDescriptor = NULL;
-00550 
-00551         // Use result code from PDD if it was an error
-00552         if(iReceiveDataResult!=KErrNone)
-00553                 result = iReceiveDataResult;
-00554 
-00555         // Complete client's request
-00556         Kern::RequestComplete(iClient,iReceiveDataStatus,result);
-00557         }
-00558 
-
examples/Base/IPC/AdvancedClientServerExample/driver/driver1_ldd.cpp
