/** Second stage constructor. */
TInt DTestResManLdd::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
{
// Check version
if (!Kern::QueryVersionSupported(RTestResMan::VersionRequired(),aVer))
return KErrNotSupported;
SetDfcQ(((DTestResManLddFactory*)iDevice)->iLddQue);
iMsgQ.Receive();
return KErrNone;
}
TInt DNanoWait::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
//
// Create channel
//
{
if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
return KErrNotSupported;
SetDfcQ(gDfcQ);
iMsgQ.Receive();
return KErrNone;
}
//
// DTrkXtiChannel::DoCreate
//
TInt DTrkXtiChannel::DoCreate(TInt /*aUnit*/, const TDesC* /*anInfo*/, const TVersion& aVer)
{
LOG_MSG("DTrkXtiChannel::DoCreate()");
if (!Kern::QueryVersionSupported(TVersion(KMajorXtiVersionNumber, KMinorXtiVersionNumber, KBuildXtiVersionNumber), aVer))
return KErrNotSupported;
//Setup the driver for receiving client messages
iDFCQue = NULL;
TBuf8<KMaxInfoName> xtiDFC = _L8("XTI DFC");;
TInt err = Kern::DfcQCreate(iDFCQue, 27, &xtiDFC);
if (err == KErrNone)
{
SetDfcQ(iDFCQue);
}
else
{
SetDfcQ(Kern::DfcQue0());
}
iMsgQ.Receive();
// create subscriber and subscribe to receive trk messages from TraceCore
iTrkXtiSubscriber = new DTrkXtiSubscriber;
if (!iTrkXtiSubscriber)
return KErrNoMemory;
err = iTrkXtiSubscriber->Create(this, iClientThread);
if (err != KErrNone)
return err;
err = Kern::SemaphoreCreate(iLock, _L("TrkXtiDriverWriteLock"), 1 /* Initial count */);
if (err != KErrNone)
return err;
return KErrNone;
}
TInt DExampleChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
{
// Existing drivers may use the kernel global DFC queue, but for testing purposes we actually
// allocate our own so we can control its realtime state.
TInt r = Kern::DynamicDfcQCreate(iDynamicDfcQ, KDfcQThreadPriority, KPagingExample1PreLdd);
if (r != KErrNone)
return r;
iDynamicDfcQ->SetRealtimeState(ERealtimeStateWarn);
SetDfcQ(DfcQ());
iAsyncGetValueDfc.SetDfcQ(DfcQ());
iAsyncGetValue2Dfc.SetDfcQ(DfcQ());
iCompleteReadDfc.SetDfcQ(DfcQ());
iCompleteWriteDfc.SetDfcQ(DfcQ());
iMsgQ.Receive();
return KErrNone;
}
/**
Second stage constructor called by the kernel's device driver framework.
This is called in the context of the user thread (client) which requested the creation of a Logical Channel
(E.g. through a call to RBusLogicalChannel::DoCreate)
The thread is in a critical section.
@param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate
@param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate
@param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate
@return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DZeroCopyLoopbackChannel::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 ECapability_None (which always passes)...
if(!Kern::CurrentThreadHasCapability(ECapability_None,__PLATSEC_DIAGNOSTIC_STRING("Checked by zerocopy loopback")))
return KErrPermissionDenied;
// Check version
if (!Kern::QueryVersionSupported(RZeroCopyLoopbackDriver::VersionRequired(),aVer))
return KErrNotSupported;
// Setup LDD for receiving client messages
SetDfcQ(((DZeroCopyLoopbackPddFactory*)iPhysicalDevice)->iDfcQ);
iMsgQ.Receive();
// Associate DFCs with the same queue we set above to receive client messages on
iSendDataDfc.SetDfcQ(iDfcQ);
iReceiveDataDfc.SetDfcQ(iDfcQ);
iPond = DCommsPond::New();
if(!iPond)
{
return KErrNoMemory;
}
// Give PDD a pointer to this channel
Pdd()->iLdd = this;
// Done
return KErrNone;
}
/**
Second stage constructor called by the kernel's device driver framework.
This is called in the context of the user thread (client) which requested the creation
of the Logical Channel (e.g. through a call to RBusLogicalChannel::DoCreate())
The thread is in a critical section.
@param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate()
@param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate()
@param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate()
@return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DCrashDriverChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
{
if(!Kern::CurrentThreadHasCapability(ECapability_None,__PLATSEC_DIAGNOSTIC_STRING("Checked by crashdriver")))
return KErrPermissionDenied;
// Check version
if (!Kern::QueryVersionSupported(RKernelCrashDrv::VersionRequired(),aVer))
return KErrNotSupported;
// Setup LDD for receiving client messages.
TInt err = Kern::DynamicDfcQCreate(iDfcQ, 25, RKernelCrashDrv::Name());
if(err != KErrNone)
{
Kern::Printf("Creating Dfc queue failed.");
}
SetDfcQ(iDfcQ);
iMsgQ.Receive();
return KErrNone;
}
TInt DChannelComm::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion &aVer)
{
if(!Kern::CurrentThreadHasCapability(ECapabilityCommDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by ECOMM.LDD (Comm Driver)")))
return KErrPermissionDenied;
if (!Kern::QueryVersionSupported(TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber),aVer))
return KErrNotSupported;
// set up the correct DFC queue
SetDfcQ(((DComm*)iPdd)->DfcQ(aUnit));
iRxCompleteDfc.SetDfcQ(iDfcQ);
iTxCompleteDfc.SetDfcQ(iDfcQ);
iRxDataAvailableDfc.SetDfcQ(iDfcQ);
iSigNotifyDfc.SetDfcQ(iDfcQ);
iTurnaroundDfc.SetDfcQ(iDfcQ);
iMsgQ.Receive();
((DComm *)iPdd)->iLdd = this;
//setup the initial port configuration
PddConfigure(iConfig);
return KErrNone;
}
/**
LDD second stage constructor
*/
TInt DDisplayLdd::DoCreate(TInt aUnit, const TDesC8* /* anInfo*/, const TVersion& aVer)
{
__DEBUG_PRINT("DDisplayLdd::DoCreate()\n");
if( !Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt, __PLATSEC_DIAGNOSTIC_STRING("Checked by DISPLAY.LDD (GCE Driver)") )
|| !Kern::CurrentThreadHasCapability(ECapabilityReadDeviceData, __PLATSEC_DIAGNOSTIC_STRING("Checked by DISPLAY.LDD (GCE Driver)") )
|| !Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by DISPLAY.LDD (GCE Driver)") )
|| !Kern::CurrentThreadHasCapability(ECapabilityProtServ, __PLATSEC_DIAGNOSTIC_STRING("Checked by DISPLAY.LDD (GCE Driver)") ) )
{
return KErrPermissionDenied;
}
// Check that the display driver version specified by the client is compatible.
if (!Kern::QueryVersionSupported(RDisplayChannel::VersionRequired(),aVer))
{
return(KErrNotSupported);
}
// Check that a channel hasn't already been opened on this unit.
TInt r=((DDisplayLddFactory*)iDevice)->SetUnitOpen(aUnit,ETrue); // Try to update 'units open mask' in the LDD factory.
if (r!=KErrNone)
return r;
iUnit=aUnit;
Pdd()->iLdd = this;
r = Pdd()->CreateChannelSetup(aUnit);
if ( r!= KErrNone)
{
return r;
}
// set up user buffer nodes
for (TInt node = 0; node < KDisplayUBMax; node++)
{
iUserBuffer[node].iType = EBufferTypeUser;
iUserBuffer[node].iBufferId = (node + 1);
iUserBuffer[node].iFree = ETrue;
iUserBuffer[node].iState = EBufferFree;
iUserBuffer[node].iAddress = 0;
iUserBuffer[node].iSize = 0;
iUserBuffer[node].iHandle = 0;
iUserBuffer[node].iChunk = 0;
iUserBuffer[node].iOffset = 0;
iUserBuffer[node].iPendingRequest = 0;
}
//Initialise pending queue for asynchronous requests and queue of TClientRequests
for(TInt k = 0; k < KPendingReqArraySize; k++)
{
iPendingIndex[k]=0;
for(TInt i = 0; i < KMaxQueuedRequests; i++)
{
iPendingReq[k][i].iTClientReq = 0;
iPendingReq[k][i].iOwningThread = 0;
r = Kern::CreateClientRequest(iClientRequest[k][i]);
if (r != KErrNone)
{
return r;
}
}
}
r = Kern::MutexCreate(iClientRequestMutex, KClientRequestMutex, KMutexOrder);
if (r != KErrNone)
{
return r;
}
Pdd()->SetGceMode();
SetDfcQ(Pdd()->DfcQ(aUnit));
iMsgQ.Receive();
return KErrNone;
}
/**
Logical Channel - DoCreate(), called by framework after creating logical
channel object as a part of the driver loading process. Driver should do
the required validation like capabilities check, version check etc. It
associates the DFC queue which it shall use to queue the requests. It
can do any required driver level initializations here.
@param aUnit
device unit number
@param anInfo
device related information
@param aVer
version number
@return KErrNone or standard error code
*/
TInt DExDriverLogicalChannel::DoCreate(TInt aUnit,
const TDesC8* /*anInfo*/,
const TVersion& aVer)
{
// Not using anInfo, so anInfo is commented in function arguments.
// It can also be made void it to avoid compilation warnings by doing
// (void)anInfo;
//
// As a part of platform security guidelines, every driver needs to
// enusure capability check. This check is to ensure that the client
// accessing the driver has the required level of trust to perform any
// operations on the device. Any client that does not have required
// capability as expected by the driver is returned with no permission
// error.Kernel API Kern::CurrentThreadHasCapability(),checks if the
// current thread has the required capability (arg1) and displays the
// diagnostic string in case of failure.
//
// Check if the client has level of trust to do serial comm related
// operations.
if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,
__PLATSEC_DIAGNOSTIC_STRING("Checked by Tutorial Driver")))
return KErrPermissionDenied;
// Check if driver version matches with the version client is trying
// to use. Kernel API, Kern::QueryVersionSupported() verifies if the
// versions match, returns true if test version is less than current
// version (arg2<arg1).
//
if (!Kern::QueryVersionSupported(iDevice->iVersion,aVer))
return KErrNotSupported;
// Store the LDD object pointer in PDD. This will enable PDD to access
// and call the LDD member functions easily. In case of callbacks to
// LDD, PDD can use this pointer.
//
Pdd()->iLdd=this;
// Logical channel based driver has a DFC created for itself. A dedicated
// DFC can be created for the driver, instead of using default kernel DFC
// thread 0. PDD implements DFCQ function and returns the DFCQ created
// by PDD. All synchronous and asynchronous messages and events for this
// driver will be queued to this queue.
//
// Here, LDD leaves it to PDD to associate a context,(dfcq+kernel thread)
// with a hardware unit, so that requests on different channels (units)
// execute in different contexts.
//
// SetDfcQ() initializes the message queue used by LDD with the
// DFC(TDynamicDfcQue object) returned by Pdd()->DfcQ().
//
SetDfcQ(Pdd()->DfcQ(aUnit));
// Set the message queue to start receiving the messages.
// TMessageQue::Receive() will request driver to receive next message
// (sent by client) in the queue. It makes the queue as ready and also
// activates the DFC when the message is present in queue.
//
iMsgQ.Receive();
Pdd()->SetChannelOpened(aUnit);
// return no error
//
return KErrNone;
}
