1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32/drivers/camerasc/cameraldd.cpp

    15 // 

    16 //

    17 

    18 #include <drivers/camerasc.h>

    19 #include <kernel/kern_priv.h>

    20 #include <kernel/cache.h>

    21 

    22 //#define __KTRACE_CAM(s) s;

    23 #define __KTRACE_CAM(s)

    24 

    25 #define DISCARD_COMPLETED_TO_AVOID_OVERFLOW

    26 

    27 static const char KCameraLddPanic[]="CameraSc LDD";

    28 

    29 /**

    30 Standard export function for LDDs. This creates a DLogicalDevice derived object,

    31 in this case, DSoundScLddFactory.

    32 */

    33 DECLARE_STANDARD_LDD()

    34 	{

    35 	return new DCameraScLddFactory;

    36 	}

    37 

    38 /**

    39 Constructor for the camera driver factory class.

    40 */

    41 DCameraScLddFactory::DCameraScLddFactory()

    42 	{

    43 //	iUnitsOpenMask=0;

    44 

    45 	__KTRACE_CAM(Kern::Printf(">DCameraScLddFactory::DCameraScLddFactory"));

    46 

    47 	// Set version number for this device.

    48 	iVersion=RDevCameraSc::VersionRequired();

    49 

    50 	// Indicate that units / PDD are supported.

    51 	iParseMask=KDeviceAllowUnit|KDeviceAllowPhysicalDevice;

    52 

    53 	// Leave the units decision to the PDD

    54 	iUnitsMask=0xffffffff;

    55 	}

    56 

    57 /**

    58 Second stage constructor for the camera driver factory class.

    59 This must at least set a name for the driver object.

    60 @return KErrNone if successful, otherwise one of the other system wide error codes.

    61 */

    62 TInt DCameraScLddFactory::Install()

    63 	{

    64 	return(SetName(&KDevCameraScName));

    65 	}

    66 

    67 /**

    68 Return the 'capabilities' of the camera driver in general.

    69 Called in the response to an RDevice::GetCaps() request.

    70 @param aDes A user-side descriptor to write the capabilities information into.

    71 */

    72 void DCameraScLddFactory::GetCaps(TDes8 &aDes) const

    73 	{

    74 	// Create a capabilities object

    75 	TCapsDevCameraV01 caps;

    76 	caps.iVersion=iVersion;

    77 

    78 	// Write it back to user memory

    79 	Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));

    80 	}

    81 

    82 /**

    83 Called by the kernel's device driver framework to create a logical channel.

    84 This is called in the context of the client thread which requested the creation of a logical

    85 channel - through a call to RBusLogicalChannel::DoCreate().

    86 The thread is in a critical section.

    87 @param aChannel Set by this function to point to the created logical channel.

    88 @return KErrNone if successful, otherwise one of the other system wide error codes.

    89 */

    90 TInt DCameraScLddFactory::Create(DLogicalChannelBase*& aChannel)

    91 	{

    92 	__KTRACE_CAM(Kern::Printf(">DCameraScLddFactory::Create"));

    93 

    94 	aChannel=new DCameraScLdd;

    95 	if (!aChannel)

    96 		return(KErrNoMemory);

    97 

    98 	return(KErrNone);

    99 	}

   100 

   101 /**

   102 Check whether a channel has is currently open on the specified unit.

   103 @param aUnit The number of the unit to be checked.

   104 @return ETrue if a channel is open on the specified channel, EFalse otherwise.

   105 @pre The unit info. mutex must be held.

   106 */

   107 TBool DCameraScLddFactory::IsUnitOpen(TInt aUnit)

   108 	{

   109 	return(iUnitsOpenMask&(1<<aUnit));

   110 	}

   111 

   112 /**

   113 Attempt to change the state of the channel open status for a particular channel.

   114 @param aUnit The number of the unit to be updated.

   115 @param aIsOpenSetting	The required new state for the channel open status: either ETrue to set the status to open or

   116 						EFalse to set the status to closed.

   117 @return KErrNone if the status was updated successfully;

   118 		KErrInUse if an attempt has been made to set the channnel status to open while it is already open.

   119 */

   120 TInt DCameraScLddFactory::SetUnitOpen(TInt aUnit,TBool aIsOpenSetting)

   121 	{

   122 	NKern::FMWait(&iUnitInfoMutex); // Acquire the unit info. mutex.

   123 

   124 	// Fail a request to open an channel that is already open

   125 	if (aIsOpenSetting && IsUnitOpen(aUnit))

   126 		{

   127 		NKern::FMSignal(&iUnitInfoMutex); // Release the unit info. mutex.

   128 		return(KErrInUse);

   129 		}

   130 

   131 	// Update the open status as requested

   132 	if (aIsOpenSetting)

   133 		iUnitsOpenMask|=(1<<aUnit);

   134 	else

   135 		iUnitsOpenMask&=~(1<<aUnit);

   136 

   137 	NKern::FMSignal(&iUnitInfoMutex); // Release the unit info. mutex.

   138 	return(KErrNone);

   139 	}

   140 

   141 /**

   142 Constructor for the camera driver logical channel.

   143 */

   144 DCameraScLdd::DCameraScLdd()

   145 	:	iRequestQueue(&iMutex),

   146 		iRestartDfc(DCameraScLdd::RestartDfc,this,5),

   147 		iPowerDownDfc(DCameraScLdd::PowerDownDfc,this,3),

   148 		iPowerUpDfc(DCameraScLdd::PowerUpDfc,this,3)

   149 	{

   150 //	iState=EOpen;

   151 //	iCaptureMode=ECaptureModeImage;

   152 //	iFrameHeight=0;

   153 //	iFrameWidth=0;

   154 //	iBufManager=NULL;

   155 //	iPowerHandler=NULL;

   156 //	iImageGatherCount=0;

   157 

   158 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DCameraScLdd"));

   159 

   160 	iUnit=-1;	// Invalid unit number

   161 

   162 	// Get pointer to client thread's DThread object

   163 	iOwningThread=&Kern::CurrentThread();

   164 

   165 	// Open a reference on client thread so it's control block can't dissapear until

   166 	// this driver has finished with it. Note, this call to Open() can't fail since

   167 	// it is the thread we are currently running in

   168 	iOwningThread->Open();

   169 	}

   170 

   171 /**

   172 Destructor for the camera driver logical channel.

   173 This is called in the context of the client thread once a 'ECloseMsg' message has been

   174 sent to the device driver DFC thread.

   175 */

   176 DCameraScLdd::~DCameraScLdd()

   177 	{

   178 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::~DCameraScLdd"));

   179 

   180 	TInt captureMode;

   181 

   182 	// Remove and delete the power handler.

   183 	if (iPowerHandler)

   184 		{

   185 		iPowerHandler->Remove();

   186 		delete iPowerHandler;

   187 		iPowerHandler=NULL;

   188 		}

   189 

   190 	if (iCaptureModeConfig)

   191 		{

   192 		// Delete any buffers, the shared chunk we created, and the buffer config struct.

   193 		for (captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

   194 			{

   195 			if (iCaptureModeConfig[captureMode].iBufManager)

   196 				{

   197 				delete iCaptureModeConfig[captureMode].iBufManager;

   198 				iCaptureModeConfig[captureMode].iBufManager=NULL;

   199 				}

   200 

   201 			if (iCaptureModeConfig[captureMode].iBufConfig)

   202 				{

   203 				Kern::Free(iCaptureModeConfig[captureMode].iBufConfig);

   204 				iCaptureModeConfig[captureMode].iBufConfig=NULL;

   205 				}

   206 			}

   207 

   208 		delete[] iCaptureModeConfig;

   209 		iCaptureModeConfig=NULL;

   210 		}

   211 

   212 	// Close our reference on the client thread

   213 	Kern::SafeClose((DObject*&)iOwningThread,NULL);

   214 

   215 	// Clear the 'units open mask' in the LDD factory.

   216 	if (iUnit>=0)

   217 		((DCameraScLddFactory*)iDevice)->SetUnitOpen(iUnit,EFalse);

   218 	}

   219 

   220 /**

   221 Second stage constructor for the camera driver - called by the kernel's device driver framework.

   222 This is called in the context of the client thread which requested the creation of a logical channel

   223 (e.g. through a call to RBusLogicalChannel::DoCreate()).

   224 The thread is in a critical section.

   225 @param aUnit The unit argument supplied by the client. This is checked by the PDD and not used here.

   226 @param aInfo The info argument supplied by the client. Always NULL in this case.

   227 @param aVer The version argument supplied by the client.

   228 @return KErrNone if successful, otherwise one of the other system wide error codes.

   229 */

   230 TInt DCameraScLdd::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)

   231 	{

   232 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoCreate"));

   233 

   234 	// Check the client has EMultimediaDD capability.

   235 	if (!Kern::CurrentThreadHasCapability(ECapabilityMultimediaDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by ECAMERA.LDD (Camera driver)")))

   236 		return(KErrPermissionDenied);

   237 

   238 	// Check that the camera driver version specified by the client is compatible.

   239 	if (!Kern::QueryVersionSupported(RDevCameraSc::VersionRequired(),aVer))

   240 		return(KErrNotSupported);

   241 

   242 	// Check that a channel hasn't already been opened on this unit.

   243 	TInt r=((DCameraScLddFactory*)iDevice)->SetUnitOpen(aUnit,ETrue); // Try to update 'units open mask' in the LDD factory.

   244 	if (r!=KErrNone)

   245 		return(r);

   246 	iUnit=aUnit;

   247 

   248 	// Create the power handler

   249 	iPowerHandler=new DCameraScPowerHandler(this);

   250 	if (!iPowerHandler)

   251 		return(KErrNoMemory);

   252 	iPowerHandler->Add();

   253 

   254 	// Create the pending capture request list

   255 	r=iRequestQueue.Create(iOwningThread);

   256 	if (r!=KErrNone)

   257 		return(r);

   258 

   259 	// Initialise the PDD

   260 	((DCameraScPdd*)iPdd)->iLdd=this;

   261 

   262 	// Setup the default camera config

   263 	iCaptureMode=ECamCaptureModeImage;

   264 

   265 	iCaptureModeConfig = new TCaptureModeConfig[ECamCaptureModeMax];

   266 	if(!iCaptureModeConfig)

   267 		return KErrNoMemory;

   268 	TInt capsSize = Pdd()->CapsSize();

   269 	TInt captureMode;

   270 	TAny* capsBuf;

   271 	capsBuf = Kern::Alloc(capsSize);

   272 	if(!capsBuf)

   273 		return KErrNoMemory;

   274 

   275 	// Query the driver for its capabilities and set a default pixel format

   276 	// and frame size for each available capture mode.

   277 	TPtr8 capsPtr( (TUint8*)capsBuf, capsSize, capsSize );

   278 	Pdd()->Caps(capsPtr);

   279 

   280 	TCameraCapsV02* caps = (TCameraCapsV02*) capsPtr.Ptr();

   281 	SDevCamPixelFormat* pixelFormat = (SDevCamPixelFormat*) (caps + 1);

   282 	SDevCamFrameSize* frameSize;

   283 	TAny* frameSizeCapsBuf=0;

   284 	TPtr8 frameSizeCapsPtr(0,0,0);

   285 

   286 	for (captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

   287 		{

   288 		if ((captureMode==ECamCaptureModeImage) && (caps->iNumImagePixelFormats==0))

   289 			continue;

   290 

   291 		if ((captureMode==ECamCaptureModeVideo) && (caps->iNumVideoPixelFormats==0))

   292 			continue;

   293 

   294 		if ((captureMode==ECamCaptureModeViewFinder) && (caps->iNumViewFinderPixelFormats==0))

   295 			continue;

   296 

   297 		iCaptureModeConfig[captureMode].iCamConfig.iPixelFormat=*pixelFormat;

   298 		frameSizeCapsBuf = Kern::Alloc(pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

   299 		new (&frameSizeCapsPtr) TPtr8((TUint8*)frameSizeCapsBuf, pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize), pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

   300 		r=Pdd()->FrameSizeCaps((TDevCamCaptureMode)captureMode, pixelFormat->iPixelFormat, frameSizeCapsPtr);

   301 		if(r!=KErrNone)

   302 			{

   303 			Kern::Free(frameSizeCapsBuf);

   304 			return r;

   305 			}

   306 		frameSize=(SDevCamFrameSize*) frameSizeCapsPtr.Ptr();

   307 		iCaptureModeConfig[captureMode].iCamConfig.iFrameSize=*frameSize;

   308 		Kern::Free(frameSizeCapsBuf);

   309 

   310 		iCaptureModeConfig[captureMode].iCamConfig.iFlashMode=ECamFlashNone;

   311 		iCaptureModeConfig[captureMode].iCamConfig.iExposureMode=ECamExposureAuto;

   312 		iCaptureModeConfig[captureMode].iCamConfig.iWhiteBalanceMode=ECamWBAuto;

   313 		iCaptureModeConfig[captureMode].iCamConfig.iZoom=0;

   314 		iCaptureModeConfig[captureMode].iCamConfig.iPixelWidthInBytes=0;

   315 		iCaptureModeConfig[captureMode].iCamConfig.iFrameRate = 0;

   316 		}

   317 	Kern::Free(capsBuf);

   318 	// Setup the default buffer config.

   319 	r=ReAllocBufferConfigInfo(0);	// Zeros the structure

   320 	if (r!=KErrNone)

   321 		return(r);

   322 	for (captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

   323 		{

   324 		iCaptureModeConfig[captureMode].iBufConfig->iNumBuffers=KDefaultNumClientBuffers;

   325 		}

   326 

   327 	// Set up the correct DFC queue and enable the reception of client messages.

   328 	TDfcQue* dfcq=((DCameraScPdd*)iPdd)->DfcQ(aUnit);

   329 	SetDfcQ(dfcq);

   330 	iRestartDfc.SetDfcQ(dfcq);

   331 	iPowerDownDfc.SetDfcQ(dfcq);

   332 	iPowerUpDfc.SetDfcQ(dfcq);

   333 	iMsgQ.Receive();

   334 

   335 	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::DoCreate"));

   336 

   337 	return(KErrNone);

   338 	}

   339 

   340 /**

   341 Shutdown the camera device.

   342 Terminate all device activity and power down the hardware.

   343 */

   344 void DCameraScLdd::Shutdown()

   345 	{

   346 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::Shutdown"));

   347 

   348 	iState=EOpen;

   349 

   350 	// Power down the hardware

   351 	Pdd()->PowerDown();

   352 

   353 	// Cancel any requests that we may be handling

   354 	DoCancel(RDevCameraSc::EAllRequests);

   355 

   356 	// Make sure DFCs are not queued.

   357 	iRestartDfc.Cancel();

   358 	iPowerDownDfc.Cancel();

   359 	iPowerUpDfc.Cancel();

   360 	}

   361 

   362 /**

   363 Notification to the driver that a handle to it has been requested by a user thread.

   364 The use of a camera driver channel is restricted here to a single thread (that has

   365 EMultimediaDD capability).

   366 @param aThread A pointer to thread which is requesting the handle.

   367 @param aType Whether the requested handle is thread or process relative.

   368 @return	KErrNone, if the request is for a thread relative handle - originating from

   369 		the same the thread that created the channel object;

   370 		KErrAccessDenied, otherwise.

   371 */

   372 TInt DCameraScLdd::RequestUserHandle(DThread* aThread, TOwnerType aType)

   373 	{

   374 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::RequestUserHandle"));

   375 

   376 	// Ensure that each channel can only be used by a single thread.

   377 	if (aType!=EOwnerThread || aThread!=iOwningThread)

   378 		return(KErrAccessDenied);

   379 	return(KErrNone);

   380 	}

   381 

   382 /**

   383 Process a request on this logical channel

   384 Called in the context of the client thread.

   385 @param aReqNo	The request number:

   386 				==KMaxTInt: a 'DoCancel' message;

   387 				>=0: a 'DoControl' message with function number equal to value.

   388 				<0: a 'DoRequest' message with function number equal to ~value.

   389 @param a1 The first request argument. For DoRequest(), this is a pointer to the TRequestStatus.

   390 @param a2 The second request argument. For DoRequest(), this is a pointer to the 2 actual TAny* arguments.

   391 @return The result of the request. This is ignored by device driver framework for DoRequest().

   392 */

   393 TInt DCameraScLdd::Request(TInt aReqNo, TAny* a1, TAny* a2)

   394 	{

   395 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::Request(%d)",aReqNo));

   396 	TInt r;

   397 	if (aReqNo<RDevCameraSc::EMsgControlMax && aReqNo>(~RDevCameraSc::EMsgRequestMax))

   398 		{

   399 		// Implement in the context of the kernel thread - prepare and issue a kernel message.

   400 		r=DLogicalChannel::Request(aReqNo,a1,a2);

   401 		}

   402 	else

   403 		{

   404 		// Implement in the context of the client thread.

   405 		// Decode the message type and dispatch it to the relevent handler function.

   406 		if ((TUint)aReqNo<(TUint)KMaxTInt)

   407 			r=DoControl(aReqNo,a1,a2);		// DoControl - process the request.

   408 

   409 		else if (aReqNo==KMaxTInt)

   410 			{

   411 			r=DoCancel((TInt)a1);			// DoCancel - cancel the request.

   412 			}

   413 

   414 		else

   415 			{

   416 			// DoRequest

   417 			TInt func=~aReqNo;

   418 

   419 			// NotifyNewImage() during image capture mode is another case which must be handled in the kernel thread.

   420 			if (iCaptureMode==ECamCaptureModeImage && func==RDevCameraSc::ERequestNotifyNewImage)

   421 				r=DLogicalChannel::Request(aReqNo,a1,a2);

   422 			else

   423 				{

   424 				// Read the arguments from the client thread and process the request.

   425 				TAny* a[2];

   426 				kumemget32(a,a2,sizeof(a));

   427 				TRequestStatus* status=(TRequestStatus*)a1;

   428 				r=DoRequest(func,status,a[0],a[1]);

   429 

   430 				// Complete request if there was an error

   431 				if (r!=KErrNone)

   432 					Kern::RequestComplete(iOwningThread,status,r);

   433 				r=KErrNone;

   434 				}

   435 			}

   436 		}

   437 	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::Request - %d",r));

   438 	return(r);

   439 	}

   440 

   441 /**

   442 Process a message for this logical channel.

   443 This function is called in the context of the DFC thread.

   444 @param aMsg The message to process.

   445 			The iValue member of this distinguishes the message type:

   446 			iValue==ECloseMsg, channel close message.

   447 			iValue==KMaxTInt, a 'DoCancel' message.

   448 			iValue>=0, a 'DoControl' message with function number equal to iValue.

   449 			iValue<0, a 'DoRequest' message with function number equal to ~iValue.

   450 */

   451 void DCameraScLdd::HandleMsg(TMessageBase* aMsg)

   452 	{

   453 	TThreadMessage& m=*(TThreadMessage*)aMsg;

   454 	TInt id=m.iValue;

   455 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::HandleMsg(%d)",id));

   456 

   457 	// Decode the message type and dispatch it to the relevent handler function.

   458 	if (id==(TInt)ECloseMsg)

   459 		{

   460 		// Channel close.

   461 		Shutdown();

   462 		m.Complete(KErrNone,EFalse);

   463 		return;

   464 		}

   465 	else if (id<0)	// The only DoRequest handled in the kernel thread is NotifyNewImage(ECamCaptureModeImage).

   466 		{

   467 		// DoRequest

   468 		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

   469 		TInt r=DoRequest(~id,pS,m.Ptr1(),m.Ptr2());

   470 		if (r!=KErrNone)

   471 			Kern::RequestComplete(iOwningThread,pS,r);

   472 		m.Complete(KErrNone,ETrue);

   473 		}

   474 	else

   475 		{

   476 		// Must be DoControl (Cancel is handled in the client thread).

   477 		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

   478 		m.Complete(r,ETrue);

   479 		}

   480 	}

   481 

   482 /**

   483 Process a synchronous 'DoControl' request.

   484 This function is called in the context of the DFC thread.

   485 @param aFunction The request number.

   486 @param a1 The first request argument.

   487 @param a2 The second request argument.

   488 @return KErrNone if successful, otherwise one of the other system wide error codes.

   489 */

   490 TInt DCameraScLdd::DoControl(TInt aFunction, TAny* a1, TAny* a2)

   491 	{

   492 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoControl(%d)",aFunction));

   493 

   494 	TInt r=KErrNotSupported;

   495 	switch (aFunction)

   496 		{

   497 		case RDevCameraSc::EControlCaps:

   498 			{

   499 			r = GetSensorCaps(a1);

   500 			break;

   501 			}

   502 		case RDevCameraSc::EControlSetCaptureMode:

   503 			{

   504 			// Change the capture mode.

   505 			r=SetCaptureMode((TInt)a1);

   506 			break;

   507 			}

   508 		case RDevCameraSc::EControlSetCamConfig:

   509 			{

   510 			// Set the new camera configuration.

   511 			NKern::ThreadEnterCS();

   512 			r=SetCamConfig((TInt)a1, (const TDesC8*)a2);

   513 			NKern::ThreadLeaveCS();

   514 			break;

   515 			}

   516 		case RDevCameraSc::EControlGetCamConfig:

   517 			{

   518 			// Write the config to the client.

   519 			TPtrC8 ptr((const TUint8*)&iCaptureModeConfig[(TInt)a1].iCamConfig,sizeof(iCaptureModeConfig[(TInt)a1].iCamConfig));

   520 			Kern::InfoCopy(*((TDes8*)a2),ptr);

   521 			r=KErrNone;

   522 			break;

   523 			}

   524 		case RDevCameraSc::EControlGetBufferConfig:

   525 			if (iCaptureModeConfig[(TInt)a1].iBufConfig)

   526 				{

   527 				// Write the buffer config to the client.

   528 				TPtrC8 ptr((const TUint8*)&(*iCaptureModeConfig[(TInt)a1].iBufConfig),iCaptureModeConfig[(TInt)a1].iBufConfigSize);

   529 				Kern::InfoCopy(*((TDes8*)a2),ptr);

   530 				r=KErrNone;

   531 				}

   532 			break;

   533 		case RDevCameraSc::EControlSetBufConfigChunkCreate:

   534 			// Need to be in critical section while deleting an exisiting config and creating a new one

   535 			NKern::ThreadEnterCS();

   536 			r=SetBufConfig((TInt)a1,(TInt)a2);

   537 			NKern::ThreadLeaveCS();

   538 			break;

   539 		case RDevCameraSc::EControlSetBufConfigChunkOpen:

   540 			SSetBufConfigChunkOpenInfo info;

   541 			r=Kern::ThreadRawRead(iOwningThread,a2,&info,sizeof(info));

   542 			if (r==KErrNone)

   543 				{

   544 				// Need to be in critical section while deleting an exisiting config and creating a new one

   545 				NKern::ThreadEnterCS();

   546 				r=SetBufConfig((TInt)a1,info.iBufferConfigBuf,info.iChunkHandle);

   547 				NKern::ThreadLeaveCS();

   548 				}

   549 			break;

   550 		case RDevCameraSc::EControlChunkClose:

   551 			r=ChunkClose((TInt)a1);

   552 			break;

   553 		case RDevCameraSc::EControlStart:

   554 			r=Start();

   555 			break;

   556 		case RDevCameraSc::EControlStop:

   557 			if (iState==ECapturing)

   558 				{

   559 				r=Pdd()->Stop();

   560 				DoCancel(1<<RDevCameraSc::ERequestNotifyNewImage);

   561 				if (r==KErrNone)

   562 					iState=EConfigured;

   563 				}

   564 			else

   565 				{

   566 				r=KErrGeneral;

   567 				}

   568 			break;

   569 		case RDevCameraSc::EControlReleaseBuffer:

   570 			r=ReleaseBuffer((TInt)a1);

   571 			break;

   572 		case RDevCameraSc::EControlNotifyNewImageSpecificCancel:

   573 			{

   574 			NKern::FMWait(&iMutex); 		// Acquire the buffer/request list mutex.

   575 			iRequestQueue.Cancel((TRequestStatus*)a1);

   576 			NKern::FMSignal(&iMutex); 		// Release the buffer/request list mutex.

   577 			r=KErrNone;

   578 			break;

   579 			}

   580 		case RDevCameraSc::EControlBufferIdToOffset:

   581 			{

   582 			// a1 has pointer to buffer for search criteria

   583 			// a2 has pointer to offset for result

   584 			TDevCamBufferModeAndId info;

   585 			TPtr8 indesc((TUint8*)&info,sizeof(info));

   586 

   587 			r = Kern::ThreadDesRead(iOwningThread,a1,indesc,0);

   588 			if (KErrNone==r)

   589 				{

   590 				TInt id = info.iId;

   591 				TDevCamCaptureMode captureMode = info.iCaptureMode;

   592 				DBufferManager* mgr = iCaptureModeConfig[captureMode].iBufManager;

   593 				

   594 				if (mgr)

   595 					{

   596 					if (mgr->iImageBuffer[id].iId == id)

   597 						{

   598 						kumemput32(a2, &mgr->iImageBuffer[id].iChunkOffset, sizeof(TInt));

   599 						r = KErrNone;

   600 						}

   601 					else

   602 						{

   603 						r = KErrNotFound;

   604 						}

   605 					}

   606 				}

   607 			break;

   608 			}

   609 		case RDevCameraSc::EControlCapsSize:

   610 			{

   611 			r = Pdd()->CapsSize();

   612 			break;

   613 			}

   614 		case RDevCameraSc::EControlFrameSizeCaps:

   615 			{

   616 			r = GetFrameSizeCaps(a1, a2);

   617 			break;

   618 			}

   619 		case RDevCameraSc::EControlSetDynamicAttribute:

   620 			{

   621 			// Set the new camera configuration.

   622 			NKern::ThreadEnterCS();

   623 			r=SetDynamicAttribute((TInt)a1, (TUint)a2);

   624 			NKern::ThreadLeaveCS();

   625 			break;

   626 			}

   627 		}

   628 	return(r);

   629 	}

   630 

   631 /**

   632 Process an asynchronous 'DoRequest' request.

   633 This function is called in the context of the DFC thread.

   634 @param aFunction The request number.

   635 @param aStatus A pointer to the TRequestStatus.

   636 @param a1 The first request argument.

   637 @param a2 The second request argument.

   638 @return KErrNone if successful, otherwise one of the other system wide error codes.

   639 */

   640 TInt DCameraScLdd::DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* /*a1*/, TAny* /*a2*/)

   641 	{

   642 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoRequest(%d)",aFunction));

   643 

   644 	TInt r=KErrNotSupported;

   645 	switch (aFunction)

   646 		{

   647 		case RDevCameraSc::ERequestNotifyNewImage:

   648 			r=NotifyNewImage(aStatus);

   649 			break;

   650 		}

   651 

   652 	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::DoRequest - %d",r));

   653 	return(r);

   654 	}

   655 

   656 /**

   657 Process the cancelling of asynchronous requests.

   658 This function is called in the context of the DFC thread.

   659 @param aMask A mask indicating which requests need to be cancelled.

   660 @return The result of the cancel. Either KErrNone if successful, otherwise one of the other

   661 	system wide error codes.

   662 */

   663 TInt DCameraScLdd::DoCancel(TUint aMask)

   664 	{

   665 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoCancel(%08x)",aMask));

   666 

   667 	if (aMask&(1<<RDevCameraSc::ERequestNotifyNewImage))

   668 		{

   669 		NKern::FMWait(&iMutex); 		// Acquire the buffer/request list mutex.

   670 		iRequestQueue.CancelAll();

   671 		NKern::FMSignal(&iMutex); 		// Release the buffer/request list mutex.

   672 		}

   673 	return(KErrNone);

   674 	}

   675 

   676 /**

   677 @pre The thread must be in a critical section.

   678 */

   679 TInt DCameraScLdd::ReAllocBufferConfigInfo(TInt aNumBuffers)

   680 	{

   681 	for (TInt captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

   682 		{

   683 		if (iCaptureModeConfig[captureMode].iBufConfig)

   684 			{

   685 			Kern::Free(iCaptureModeConfig[captureMode].iBufConfig);

   686 			iCaptureModeConfig[captureMode].iBufConfig=NULL;

   687 			}

   688 

   689 		iCaptureModeConfig[captureMode].iBufConfigSize=aNumBuffers*(sizeof(SBufSpecList)); // Size of the three integers that hold the offset to the start of each buffer and the buffer id.

   690 		iCaptureModeConfig[captureMode].iBufConfigSize+=sizeof(TSharedChunkBufConfigBase);

   691 		iCaptureModeConfig[captureMode].iBufConfig=(TCameraSharedChunkBufConfig*)Kern::AllocZ(iCaptureModeConfig[captureMode].iBufConfigSize);

   692 		if (!iCaptureModeConfig[captureMode].iBufConfig)

   693 			return(KErrNoMemory);

   694 		}

   695 	return(KErrNone);

   696 	}

   697 

   698 /**

   699 Reallocate memory for the new buffer configuration.

   700 @param aNumBuffers The number of buffers.

   701 @pre The thread must be in a critical section.

   702 */

   703 TInt DCameraScLdd::ReAllocBufferConfigInfo(TInt aCaptureMode, TInt aNumBuffers)

   704 	{

   705 	if (iCaptureModeConfig[aCaptureMode].iBufConfig)

   706 		{

   707 		Kern::Free(iCaptureModeConfig[aCaptureMode].iBufConfig);

   708 		iCaptureModeConfig[aCaptureMode].iBufConfig=NULL;

   709 		}

   710 

   711 	iCaptureModeConfig[aCaptureMode].iBufConfigSize=aNumBuffers*(sizeof(SBufSpecList)); // Size of the three integers that hold the offset to the start of each buffer and the buffer id.

   712 	iCaptureModeConfig[aCaptureMode].iBufConfigSize+=sizeof(TSharedChunkBufConfigBase);

   713 	iCaptureModeConfig[aCaptureMode].iBufConfig=(TCameraSharedChunkBufConfig*)Kern::AllocZ(iCaptureModeConfig[aCaptureMode].iBufConfigSize);

   714 	if (!iCaptureModeConfig[aCaptureMode].iBufConfig)

   715 		return(KErrNoMemory);

   716 

   717 	return(KErrNone);

   718 	}

   719 

   720 /**

   721 @return	A handle to the shared chunk for the owning thread (a value >0), if successful;

   722 		otherwise one of the other system wide error codes, (a value <0).

   723 @param aCamConfigBuf The supplied camera configuration.

   724 @pre The thread must be in a critical section.

   725 */

   726 TInt DCameraScLdd::SetCamConfig(TInt aCaptureMode, const TDesC8* aCamConfigBuf)

   727 	{

   728 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::SetCamConfig()"));

   729 

   730 	// Set the configuration of the sensor

   731 	TInt r=DoSetConfig(aCaptureMode, aCamConfigBuf);

   732 	return(r);

   733 	}

   734 

   735 /**

   736 Allows changing of the dynamic settings.

   737 Checks locally the validity of the arguments passed so as to increase performance by not

   738 forcing a context switch.

   739 

   740 @param aAttribute An enum identifying the dynamic attribute to change.

   741 @param aValue The attributes value.

   742 @return KErrNone if successful, KErrNotSupported if not supported, KErrArgument if aValue out of range.

   743 		Otherwise, one of the system wide error codes.

   744 @pre The thread must be in a critical section.

   745 */

   746 TInt DCameraScLdd::SetDynamicAttribute(TInt aAttribute, TUint aValue)

   747 	{

   748 	Kern::Printf(">DCameraScLdd::SetDynamicAttribute()");

   749 	switch(aAttribute)

   750 		{

   751 		case ECamAttributeBrightness:

   752 			return Pdd()->SetBrightness(aValue);

   753 		case ECamAttributeContrast:

   754 			return Pdd()->SetContrast(aValue);

   755 		case ECamAttributeColorEffect:

   756 			return Pdd()->SetColorEffect(aValue);

   757 		default:

   758 			return KErrNotFound;

   759 		}

   760 	}

   761 

   762 /**

   763 Updates the buffer configuration of the camera for the specified capture mode.

   764 @return	A handle to the shared chunk for the owning thread (a value >0), if successful;

   765 		otherwise one of the other system wide error codes, (a value <0).

   766 */

   767 TInt DCameraScLdd::SetBufConfig(TInt aCaptureMode, TInt aNumBuffers)

   768 	{

   769 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::SetBufConfig(CaptureMode=%d,NumBuffers=%d)",aCaptureMode,aNumBuffers));

   770 

   771 	// Free any memory and chunk already allocated

   772 	TInt r=ChunkClose(aCaptureMode);

   773 	if (r!=KErrNone)

   774 		return(r);

   775 

   776 	// Allocate a new shared chunk and create the specified number of buffers within it.

   777 	TInt buffersize=((iCaptureModeConfig[aCaptureMode].iCamConfig.iFrameSize.iWidth*iCaptureModeConfig[aCaptureMode].iCamConfig.iFrameSize.iHeight) * iCaptureModeConfig[aCaptureMode].iCamConfig.iPixelWidthInBytes);

   778 	__KTRACE_CAM(Kern::Printf(">>DCameraScLdd::SetBufConfig - iFrameSize:%d, iPixelWidthInBytes:%d => bufferSize:%d",(iCaptureModeConfig[aCaptureMode].iCamConfig.iFrameSize.iWidth*iCaptureModeConfig[aCaptureMode].iCamConfig.iFrameSize.iHeight),iCaptureModeConfig[aCaptureMode].iCamConfig.iPixelWidthInBytes,buffersize));

   779 	iCaptureModeConfig[aCaptureMode].iBufManager=new DBufferManager(this);

   780 	if (!iCaptureModeConfig[aCaptureMode].iBufManager)

   781 		return(KErrNoMemory);

   782 	r=iCaptureModeConfig[aCaptureMode].iBufManager->Create(aNumBuffers,buffersize);

   783 	if (r!=KErrNone)

   784 		return(r);

   785 

   786 	// Update the LDD's chunk/buffer geometry info.

   787 	r=ReAllocBufferConfigInfo(aCaptureMode, aNumBuffers);

   788 	if (r!=KErrNone)

   789 		return(r);

   790 	iCaptureModeConfig[aCaptureMode].iBufManager->GetBufConfig(*iCaptureModeConfig[aCaptureMode].iBufConfig);

   791 

   792 	// Create handle to the shared chunk for the owning thread.

   793 	r=Kern::MakeHandleAndOpen(iOwningThread,iCaptureModeConfig[aCaptureMode].iBufManager->iChunk);

   794 	if (r>0)

   795 		{

   796 		// And save the the chunk and handle for later.  Normally the chunk handle will be closed when the chunk

   797 		// is closed, but if the chunk is re-allocated then it will need to be closed before re-allocation.

   798 		iCaptureModeConfig[aCaptureMode].iChunkHandle=r;

   799 		}

   800 

   801 	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::SetBufConfig - %d",r));

   802 	return(r);

   803 	}

   804 

   805 /**

   806 Updates the buffer configuration of the camera, which has been supplied by the user, for the specified capture mode.

   807 @param aCaptureMode		The capture mode for which the setting of the buffer configuration is made.

   808 @param aBufferConfigBuf	A buffer that holds the buffer configuration for the camera.

   809 @param aChunkHandle		A handle for the shared chunk supplied by the client.

   810 @return KErrNone if successful, otherwise one of the other system wide error codes.

   811 @pre The thread must be in a critical section.

   812 */

   813 TInt DCameraScLdd::SetBufConfig(TInt aCaptureMode,const TDesC8* aBufferConfigBuf,TInt aChunkHandle)

   814 	{

   815 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::SetConfig(Handle-%d)",aChunkHandle));

   816 

   817 	// Read the buffer config structure from the client.

   818 	TInt numBuffers;

   819 	TPtr8 ptr((TUint8*)&numBuffers,sizeof(numBuffers));

   820 	TInt r=Kern::ThreadDesRead(iOwningThread,aBufferConfigBuf,ptr,0);

   821 	if (r!=KErrNone)

   822 		return(r);

   823 	// Calculate the minimum length of the descriptor.

   824 	TInt minDesLen=(numBuffers*sizeof(SBufSpecList))+sizeof(TSharedChunkBufConfigBase);

   825 	r=Kern::ThreadGetDesLength(iOwningThread,aBufferConfigBuf);

   826 	if (r<minDesLen)

   827 		return(KErrArgument);

   828 	r=ReAllocBufferConfigInfo(aCaptureMode, numBuffers);

   829 	if (r!=KErrNone)

   830 		return(r);

   831 	ptr.Set((TUint8*)iCaptureModeConfig[aCaptureMode].iBufConfig,0,iCaptureModeConfig[aCaptureMode].iBufConfigSize);

   832 	r=Kern::ThreadDesRead(iOwningThread,aBufferConfigBuf,ptr,0);

   833 	if (r!=KErrNone)

   834 		return(r);

   835 

   836 	// Free any memory and chunk already allocated

   837 	r=ChunkClose(aCaptureMode);

   838 	if (r!=KErrNone)

   839 		return(r);

   840 

   841 	// Open the shared chunk supplied and create buffer objects for the committed buffers within it.

   842 	iCaptureModeConfig[aCaptureMode].iBufManager=new DBufferManager(this);

   843 	if (!iCaptureModeConfig[aCaptureMode].iBufManager)

   844 		return(KErrNoMemory);

   845 	r=iCaptureModeConfig[aCaptureMode].iBufManager->Create(*iCaptureModeConfig[aCaptureMode].iBufConfig,aChunkHandle,iOwningThread);

   846 	if (r!=KErrNone)

   847 		return(r);

   848 

   849 	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::SetConfig - %d",KErrNone));

   850 	return(r);

   851 	}

   852 

   853 /**

   854 Frees the buffer manager associated with a chunk, and closes the chunk itself.  The chunk being closed,

   855 and its associated DBufferManager instance should have been allocated by the device driver.  However,

   856 this is not a requirement.

   857 @param aCaptureMode The capture mode for which to free the buffer manager and chunk.

   858 @return	KErrNone if successful.

   859 		KErrInUse if an attempt has been made to free the memory and chunk while they are in use.

   860 		Otherwise one of the other system-wide error codes.

   861 */

   862 TInt DCameraScLdd::ChunkClose(TInt aCaptureMode)

   863 	{

   864 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::ChunkClose(Capture Mode-%d)",aCaptureMode));

   865 

   866 	// For the active mode we need to perform extra checks.

   867 	if(iCaptureMode == aCaptureMode)

   868 		{

   869 		if (iState==ECapturing)

   870 			{

   871 			return(KErrInUse);

   872 			}

   873 		}

   874 

   875 	// Delete any existing buffers

   876 	if (iCaptureModeConfig[aCaptureMode].iBufManager)

   877 		{

   878 		delete iCaptureModeConfig[aCaptureMode].iBufManager;

   879 		iCaptureModeConfig[aCaptureMode].iBufManager=NULL;

   880 		}

   881 

   882 	// If a handle to the shared chunk was created, close it, using the handle of the thread on which

   883 	// it was created, in case a different thread is now calling us

   884 	if (iCaptureModeConfig[aCaptureMode].iChunkHandle>0)

   885 		{

   886 		Kern::CloseHandle(iOwningThread,iCaptureModeConfig[aCaptureMode].iChunkHandle);

   887 		iCaptureModeConfig[aCaptureMode].iChunkHandle=0;

   888 		}

   889 

   890 	return(KErrNone);

   891 	}

   892 

   893 /**

   894 Set the current capture mode and submits the camera configuration to the PDD, passing it as a descriptor

   895 to support future changes to the config structure.

   896 

   897 @param aCaptureMode	The capture mode that the camera switches to.

   898 @return KErrNone if successful;

   899 		otherwise one of the other system-wide error codes.

   900 */

   901 TInt DCameraScLdd::SetCaptureMode(TInt aCaptureMode)

   902 	{

   903 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::SetCaptureMode(Mode-%d)",aCaptureMode));

   904 

   905 	TInt r=KErrNone;

   906 	if(aCaptureMode >= ECamCaptureModeMax || aCaptureMode < 0)

   907 		{

   908 		r=KErrNotFound;

   909 		return(r);

   910 		}

   911 

   912 	if (!iCaptureModeConfig[aCaptureMode].iBufManager)

   913 		{

   914 		r=KErrNotReady;

   915 		return(r);

   916 		}

   917 

   918 	iCaptureMode=(TDevCamCaptureMode)aCaptureMode;	// The capture mode has already been checked for its validity.

   919 

   920 	__KTRACE_CAM(Kern::Printf("DCameraScLdd::SetCaptureMode: iFrameSize:%dx%d)",iCaptureModeConfig[iCaptureMode].iCamConfig.iFrameSize.iWidth, iCaptureModeConfig[iCaptureMode].iCamConfig.iFrameSize.iHeight));

   921 

   922 	// Call the PDD to change the hardware configuration according to the new capture mode.

   923 	// Pass it as a descriptor - to support future changes to the config structure.

   924 	TPtr8 ptr((TUint8*)&iCaptureModeConfig[iCaptureMode].iCamConfig,sizeof(iCaptureModeConfig[iCaptureMode].iCamConfig),sizeof(iCaptureModeConfig[iCaptureMode].iCamConfig));

   925 	r=Pdd()->SetConfig(ptr);

   926 	if (r!=KErrNone)

   927 		return(r);

   928 	return KErrNone;

   929 	}

   930 

   931 

   932 /**

   933 Process a start image capture request from the client - in the capture mode supplied.

   934 If this is a free running mode then the PDD is called straight away to commence capturing frames. In one shot mode the driver postpones the capturing

   935 of frames until a NotifyNewImage() request is received.

   936 @return KErrNone if successful; whether capture mode was actually started or deferred until NotifyNewImage();

   937 		KErrNotReady if SetConfig() has not been previously called;

   938 		otherwise one of the other system-wide error codes.

   939 */

   940 TInt DCameraScLdd::Start()

   941 	{

   942 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::Start(Current Mode-%d)",iCaptureMode));

   943 

   944 	// We should only be able to do this for the active mode.

   945 	if (iState==ECapturing)

   946 		return(KErrInUse);

   947 

   948 	TInt r=KErrNone;

   949 

   950 	// Only continue if the mode being started has been configured

   951 	if (iCaptureModeConfig[iCaptureMode].iBufManager)

   952 		iState=EConfigured;

   953 

   954 	if (iState==EOpen)

   955 		r=KErrNotReady;

   956 	else if (iState==EConfigured)

   957 		{

   958 		iCaptureModeConfig[iCaptureMode].iBufManager->Reset();

   959 		if (iCaptureMode!=ECamCaptureModeImage)

   960 			r=DoStart();

   961 		if (r==KErrNone)

   962 			iState=ECapturing;

   963 		}

   964 	else

   965 		r=KErrGeneral;

   966 	return(r);

   967 	}

   968 

   969 /**

   970 Start the PDD capturing images.

   971 @return KErrNone if successful, otherwise one of the other system wide error codes.

   972 */

   973 TInt DCameraScLdd::DoStart()

   974 	{

   975 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoStart()"));

   976 

   977 	DBufferManager* bufManager=iCaptureModeConfig[iCaptureMode].iBufManager;

   978 	TLinAddr linAddr=(bufManager->iChunkBase)+(bufManager->iCurrentBuffer->iChunkOffset);

   979 	TPhysAddr physAddr=bufManager->iCurrentBuffer->iPhysicalAddress;

   980 	TInt r=Pdd()->Start(iCaptureMode,linAddr,physAddr);

   981 

   982 	if (r==KErrNone && bufManager->iNextBuffer)

   983 		{

   984 		linAddr=(bufManager->iChunkBase)+(bufManager->iNextBuffer->iChunkOffset);

   985 		physAddr=bufManager->iNextBuffer->iPhysicalAddress;

   986 		r=Pdd()->CaptureNextImage(linAddr,physAddr);

   987 		}

   988 	return(r);

   989 	}

   990 

   991 /**

   992 Process a notify a new image request from the client.

   993 If there is an image already available then the request is completed straight away, otherwise it is added to the capture request queue.

   994 @param aStatus	The request status to be signalled when the request is complete. If the request is successful then this is set

   995 				to the offset within the shared chunk where the record data resides. Alternatively, if an error occurs,

   996 				it will be set to one of the system wide error values.

   997 @return KErrNone if successful - whether the request was completed or simply queued;

   998 		KErrNotReady if Start() hasn't been previousely called;

   999 		KErrInUse: if the client needs to free up buffers before further requests can be accepted;

  1000 		KErrGeneral: if the client has more requests queued than there are buffers;

  1001 		otherwise one of the other system wide error codes.

  1002 */

  1003 TInt DCameraScLdd::NotifyNewImage(TRequestStatus* aStatus)

  1004 	{

  1005 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::NotifyNewImage(%x) - iState(%d)",aStatus,iState));

  1006 	DBufferManager* bufManager=iCaptureModeConfig[iCaptureMode].iBufManager;

  1007 	TInt r;

  1008 	if (iState!=ECapturing || !bufManager)

  1009 		return(KErrNotReady);

  1010 

  1011 	NKern::FMWait(&iMutex); 		// Acquire the buffer/request list mutex.

  1012 	if (iCaptureMode!=ECamCaptureModeImage)

  1013 		{

  1014 		// We're operating in one of the free running modes, see if an image is already available.

  1015 		__KTRACE_CAM(Kern::Printf(">DCameraScLdd::NotifyNewImage - Getting image for client"));

  1016 		TImageBuffer* buf=bufManager->GetImageForClient(EFalse);

  1017 		if (buf)

  1018 			{

  1019 			__KTRACE_CAM(Kern::Printf(">DCameraScLdd::NotifyNewImage - There is an image available already"));

  1020 			// There is an image available already - complete the request.

  1021 			r=buf->iResult;

  1022 			NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1023 			if (r==KErrNone)

  1024 				{

  1025 				// Only complete if successful here. Errors will be completed on returning from this method.

  1026 				__KTRACE_CAM(Kern::Printf(">DCameraScLdd::NotifyNewImage(iId:%d)",buf->iId));

  1027 				Kern::RequestComplete(iOwningThread,aStatus,(buf->iId));

  1028 				}

  1029 			return(r);

  1030 			}

  1031 

  1032 		// The buffer 'completed' list is empty. If the 'in-use' list contains all the buffers apart from the one being filled

  1033 		// then let the client know they need to free some buffers.

  1034 		if (bufManager->iFreeBufferQ.IsEmpty() && !bufManager->iNextBuffer)

  1035 			{

  1036 			NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1037 			return(KErrInUse);

  1038 			}

  1039 		}

  1040 	else

  1041 		{

  1042 		// We're operating in one shot image capture mode. Check if the client needs to free up some buffers

  1043 		// before we can accept the request.

  1044 		if (bufManager->iCompletedBufferQ.IsEmpty() && bufManager->iFreeBufferQ.IsEmpty() && !bufManager->iNextBuffer)

  1045 			{

  1046 			NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1047 			return(KErrInUse);

  1048 			}

  1049 

  1050 		// Enough buffers are available so we can start capturing data. First

  1051 		// check that there isn't already a capture request in progress.

  1052 		if (iRequestQueue.IsEmpty())

  1053 			{

  1054 			// No previous request in progress so start the PDD.

  1055 			NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1056 			r=DoStart();

  1057 			if (r!=KErrNone)

  1058 				return(r);

  1059 			NKern::FMWait(&iMutex); 		// Acquire the buffer/request list mutex again.

  1060 			}

  1061 		}

  1062 

  1063 	// Save the request in the pending queue and return. The request will be completed from the PDD and the DFC thread when

  1064 	// an image is available.

  1065 	r=iRequestQueue.Add(aStatus);

  1066 	NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1067 	return(r);

  1068 	}

  1069 

  1070 /**

  1071 Process a release buffer request from the client.

  1072 @param aChunkOffset The chunk offset corresponding to the buffer to be freed.

  1073 @return KErrNone if successful;

  1074 		KErrNotFound if no 'in use' buffer had the specified chunk offset;

  1075 		KErrNotReady if the driver hasn't been configured for the current capture mode.

  1076 */

  1077 TInt DCameraScLdd::ReleaseBuffer(TInt aBufferId)

  1078 	{

  1079 	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::ReleaseBuffer(%d)",aBufferId));

  1080 	if(!iCaptureModeConfig[iCaptureMode].iBufManager)

  1081 		return KErrNotReady;

  1082 	DBufferManager* bufManager=iCaptureModeConfig[iCaptureMode].iBufManager;

  1083 	TInt chunkOffset = 0;

  1084 

  1085 	TInt r=KErrNone;

  1086 	/*	The driver is left in an ECapturing state after capturing frames. However, it can be left in an

  1087 		EConfigured state as a result of Stop() being called. Stop() cancels all pending capture requests and

  1088 		leaves the driver in a state in which it can be restarted without needing reconfiguring.	*/

  1089 	if (iState!=EOpen && bufManager)

  1090 		{

  1091 		chunkOffset = bufManager->iImageBuffer[aBufferId].iChunkOffset;

  1092 		TImageBuffer* buf=NULL;

  1093 		NKern::FMWait(&iMutex); 		// Acquire the buffer/request list mutex.

  1094 		buf=bufManager->FindInUseImage(chunkOffset);

  1095 		NKern::FMSignal(&iMutex); 		// Release the buffer/request list mutex.

  1096 		if (buf)

  1097 			{

  1098 			// The buffer specified by the client has been found in the 'in-use' list.

  1099 			bufManager->Purge(buf);

  1100 			}

  1101 		else

  1102 			r=KErrNotFound;

  1103 

  1104 		if (r==KErrNone)

  1105 			{

  1106 			NKern::FMWait(&iMutex); 		// Acquire the buffer/request list mutex.

  1107 			// Release it from the 'in-use list into the 'free' list.

  1108 			r=bufManager->ReleaseImage(chunkOffset);

  1109 			if (r>0)

  1110 				{

  1111 				// The buffer needs to be queued straight away - so signal this to the PDD

  1112 				TLinAddr linAddr=(bufManager->iChunkBase)+(bufManager->iNextBuffer->iChunkOffset);

  1113 				TPhysAddr physAddr=bufManager->iNextBuffer->iPhysicalAddress;

  1114 				buf=bufManager->iNextBuffer;

  1115 				NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1116 				r=Pdd()->CaptureNextImage(linAddr,physAddr);

  1117 				if (r==KErrNotReady)

  1118 					r=KErrNone;

  1119 				}

  1120 			else

  1121 				NKern::FMSignal(&iMutex); 	// Release the buffer/request list mutex.

  1122 			}

  1123 		}

  1124 	else

  1125 		r=KErrNotReady;

  1126 	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::ReleaseBuffer() - r(%d)",r));

  1127 	return(r);

  1128 	}

  1129 

  1130 /**

  1131 Called from the PDD in the DFC thread each time it finishes capturing an image frame.

  1132 This will complete a pending capture request and update buffer lists.

  1133 @param aCaptureMode The capture mode of the image captured. @see TDevCamCaptureMode.

  1134 @param aResult The result of the image capture request being completed.