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 		}

   188 

   189 	if (iCaptureModeConfig)

   190 		{

   191 		// Delete any buffers and shared chunk we created.

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

   193 			{

   194 			if (iCaptureModeConfig[captureMode].iBufManager)

   195 				delete iCaptureModeConfig[captureMode].iBufManager;

   196 			}

   197 

   198 		// Delete the buffer config. info. structure.

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

   200 			{

   201 			if (iCaptureModeConfig[captureMode].iBufConfig)

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

   203 			}

   204 

   205 			if (iCaptureModeConfig)

   206 				delete[] iCaptureModeConfig;

   207 		}

   208 	// Close our reference on the client thread

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

   210 

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

   212 	if (iUnit>=0)

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

   214 	}

   215 

   216 /**

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

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

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

   220 The thread is in a critical section.

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

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

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

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

   225 */

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

   227 	{

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

   229 

   230 	// Check the client has EMultimediaDD capability.

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

   232 		return(KErrPermissionDenied);

   233 

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

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

   236 		return(KErrNotSupported);

   237 

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

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

   240 	if (r!=KErrNone)

   241 		return(r);

   242 	iUnit=aUnit;

   243 

   244 	// Create the power handler

   245 	iPowerHandler=new DCameraScPowerHandler(this);

   246 	if (!iPowerHandler)

   247 		return(KErrNoMemory);

   248 	iPowerHandler->Add();

   249 

   250 	// Create the pending capture request list

   251 	r=iRequestQueue.Create(iOwningThread);

   252 	if (r!=KErrNone)

   253 		return(r);

   254 

   255 	// Initialise the PDD

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

   257 

   258 	// Setup the default camera config

   259 	iCaptureMode=ECamCaptureModeImage;

   260 

   261 	iCaptureModeConfig = new TCaptureModeConfig[ECamCaptureModeMax];

   262 	if(!iCaptureModeConfig)

   263 		return KErrNoMemory;

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

   265 	TInt captureMode;

   266 	TAny* capsBuf;

   267 	capsBuf = Kern::Alloc(capsSize);

   268 	if(!capsBuf)

   269 		return KErrNoMemory;

   270 

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

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

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

   274 	Pdd()->Caps(capsPtr);

   275 

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

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

   278 	SDevCamFrameSize* frameSize;

   279 	TAny* frameSizeCapsBuf=0;

   280 	TPtr8 frameSizeCapsPtr(0,0,0);

   281 

   282 	// Set the cache to hold the default dynamic attribute values.

   283 	iBrightnessValue = caps->iDynamicRange[ECamAttributeBrightness].iDefault;

   284 	iContrastValue = caps->iDynamicRange[ECamAttributeContrast].iDefault;

   285 	iColorEffectValue = caps->iDynamicRange[ECamAttributeColorEffect].iDefault;

   286 	

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

   288 		{

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

   290 			continue;

   291 

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

   293 			continue;

   294 

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

   296 			continue;

   297 

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

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

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

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

   302 		if(r!=KErrNone)

   303 			{

   304 			Kern::Free(frameSizeCapsBuf);

   305 			return r;

   306 			}

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

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

   309 		iCaptureModeConfig[captureMode].iCamConfig.iFrameRate = frameSize->iMinFrameRate;

   310 		Kern::Free(frameSizeCapsBuf);

   311 

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

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

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

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

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

   317 		}

   318 	Kern::Free(capsBuf);

   319 	// Setup the default buffer config.

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

   321 	if (r!=KErrNone)

   322 		return(r);

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

   324 		{

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

   326 		}

   327 

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

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

   330 	SetDfcQ(dfcq);

   331 	iRestartDfc.SetDfcQ(dfcq);

   332 	iPowerDownDfc.SetDfcQ(dfcq);

   333 	iPowerUpDfc.SetDfcQ(dfcq);

   334 	iMsgQ.Receive();

   335 

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

   337 

   338 	return(KErrNone);

   339 	}

   340 

   341 /**

   342 Shutdown the camera device.

   343 Terminate all device activity and power down the hardware.

   344 */

   345 void DCameraScLdd::Shutdown()

   346 	{

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

   348 

   349 	iState=EOpen;

   350 

   351 	// Power down the hardware

   352 	Pdd()->PowerDown();

   353 

   354 	// Cancel any requests that we may be handling

   355 	DoCancel(RDevCameraSc::EAllRequests);

   356 

   357 	// Make sure DFCs are not queued.

   358 	iRestartDfc.Cancel();

   359 	iPowerDownDfc.Cancel();

   360 	iPowerUpDfc.Cancel();

   361 	}

   362 

   363 /**

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

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

   366 EMultimediaDD capability).

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

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

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

   370 		the same the thread that created the channel object;

   371 		KErrAccessDenied, otherwise.

   372 */

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

   374 	{

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

   376 

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

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

   379 		return(KErrAccessDenied);

   380 	return(KErrNone);

   381 	}

   382 

   383 /**

   384 Process a request on this logical channel

   385 Called in the context of the client thread.

   386 @param aReqNo	The request number:

   387 				==KMaxTInt: a 'DoCancel' message;

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

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

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

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

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

   393 */

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

   395 	{

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

   397 	TInt r;

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

   399 		{

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

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

   402 		}

   403 	else

   404 		{

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

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

   407 		if ((TUint)aReqNo<(TUint)KMaxTInt)

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

   409 

   410 		else if (aReqNo==KMaxTInt)

   411 			{

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

   413 			}

   414 

   415 		else

   416 			{

   417 			// DoRequest

   418 			TInt func=~aReqNo;

   419 

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

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

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

   423 			else

   424 				{

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

   426 				TAny* a[2];

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

   428 				TRequestStatus* status=(TRequestStatus*)a1;

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

   430 

   431 				// Complete request if there was an error

   432 				if (r!=KErrNone)

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

   434 				r=KErrNone;

   435 				}

   436 			}

   437 		}

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

   439 	return(r);

   440 	}

   441 

   442 /**

   443 Process a message for this logical channel.

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

   445 @param aMsg The message to process.

   446 			The iValue member of this distinguishes the message type:

   447 			iValue==ECloseMsg, channel close message.

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

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

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

   451 */

   452 void DCameraScLdd::HandleMsg(TMessageBase* aMsg)

   453 	{

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

   455 	TInt id=m.iValue;

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

   457 

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

   459 	if (id==(TInt)ECloseMsg)

   460 		{

   461 		// Channel close.

   462 		Shutdown();

   463 		m.Complete(KErrNone,EFalse);

   464 		return;

   465 		}

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

   467 		{

   468 		// DoRequest

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

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

   471 		if (r!=KErrNone)

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

   473 		m.Complete(KErrNone,ETrue);

   474 		}

   475 	else

   476 		{

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

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

   479 		m.Complete(r,ETrue);

   480 		}

   481 	}

   482 

   483 /**

   484 Process a synchronous 'DoControl' request.

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

   486 @param aFunction The request number.

   487 @param a1 The first request argument.

   488 @param a2 The second request argument.

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

   490 */

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

   492 	{

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

   494 

   495 	TInt r=KErrNotSupported;

   496 	switch (aFunction)

   497 		{

   498 		case RDevCameraSc::EControlCaps:

   499 			{

   500 			r = GetSensorCaps(a1);

   501 			break;

   502 			}

   503 		case RDevCameraSc::EControlSetCaptureMode:

   504 			{

   505 			// Change the capture mode.

   506 			r=SetCaptureMode((TInt)a1);

   507 			break;

   508 			}

   509 		case RDevCameraSc::EControlSetCamConfig:

   510 			{

   511 			// Set the new camera configuration.

   512 			NKern::ThreadEnterCS();

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

   514 			NKern::ThreadLeaveCS();

   515 			break;

   516 			}

   517 		case RDevCameraSc::EControlGetCamConfig:

   518 			{

   519 			// Write the config to the client.

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

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

   522 			r=KErrNone;

   523 			break;

   524 			}

   525 		case RDevCameraSc::EControlGetBufferConfig:

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

   527 				{

   528 				// Write the buffer config to the client.

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

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

   531 				r=KErrNone;

   532 				}

   533 			break;

   534 		case RDevCameraSc::EControlSetBufConfigChunkCreate:

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

   536 			NKern::ThreadEnterCS();

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

   538 			NKern::ThreadLeaveCS();

   539 			break;

   540 		case RDevCameraSc::EControlSetBufConfigChunkOpen:

   541 			SSetBufConfigChunkOpenInfo info;

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

   543 			if (r==KErrNone)

   544 				{

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

   546 				NKern::ThreadEnterCS();

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

   548 				NKern::ThreadLeaveCS();

   549 				}

   550 			break;

   551 		case RDevCameraSc::EControlChunkClose:

   552 			r=ChunkClose((TInt)a1);

   553 			break;

   554 		case RDevCameraSc::EControlStart:

   555 			r=Start();

   556 			break;

   557 		case RDevCameraSc::EControlStop:

   558 			if (iState==ECapturing)

   559 				{

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

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

   562 				if (r==KErrNone)

   563 					iState=EConfigured;

   564 				}

   565 			else

   566 				{

   567 				r=KErrGeneral;

   568 				}

   569 			break;

   570 		case RDevCameraSc::EControlReleaseBuffer:

   571 			r=ReleaseBuffer((TInt)a1);

   572 			break;

   573 		case RDevCameraSc::EControlNotifyNewImageSpecificCancel:

   574 			{

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

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

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

   578 			r=KErrNone;

   579 			break;

   580 			}

   581 			

   582 		case RDevCameraSc::EControlBufferIdToOffset:

   583 			{

   584 			// a1 has pointer to buffer for search criteria

   585 			// a2 has pointer to offset for result

   586 			TDevCamBufferModeAndId info;

   587 			TPtr8 inDesc((TUint8*)(&info), sizeof(info));

   588 

   589 			r = Kern::ThreadDesRead(iOwningThread,a1,inDesc,0);

   590 			if (r == KErrNone)

   591 				{

   592 				TInt id = info.iId;

   593 				TDevCamCaptureMode captureMode = info.iCaptureMode;

   594 

   595 				r = KErrNotFound;

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

   597 				if (mgr)

   598 					{

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

   600 						{

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

   602 						r = KErrNone;

   603 						}

   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 			

   620 		case RDevCameraSc::EControlSetDynamicAttribute:

   621 			{

   622 			NKern::ThreadEnterCS();

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

   624 			NKern::ThreadLeaveCS();

   625 			break;

   626 			}

   627 			

   628 		case RDevCameraSc::EControlGetDynamicAttribute:

   629 			{

   630 			TInt attribute = (TInt)(a1);

   631 			TUint value = 0;

   632 			

   633 			r = GetDynamicAttribute(attribute, value);

   634 			if (r == KErrNone)

   635 				{

   636 				kumemput32(a2, &value, sizeof(TUint));

   637 				}

   638 				

   639 			break;

   640 			}

   641 			

   642 		}

   643 	return(r);

   644 	}

   645 

   646 /**

   647 Process an asynchronous 'DoRequest' request.

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

   649 @param aFunction The request number.

   650 @param aStatus A pointer to the TRequestStatus.

   651 @param a1 The first request argument.

   652 @param a2 The second request argument.

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

   654 */

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

   656 	{

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

   658 

   659 	TInt r=KErrNotSupported;

   660 	switch (aFunction)

   661 		{

   662 		case RDevCameraSc::ERequestNotifyNewImage:

   663 			r=NotifyNewImage(aStatus);

   664 			break;

   665 		}

   666 

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

   668 	return(r);

   669 	}

   670 

   671 /**

   672 Process the cancelling of asynchronous requests.

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

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

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

   676 	system wide error codes.

   677 */

   678 TInt DCameraScLdd::DoCancel(TUint aMask)

   679 	{

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

   681 

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

   683 		{

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

   685 		iRequestQueue.CancelAll();

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

   687 		}

   688 	return(KErrNone);

   689 	}

   690 

   691 /**

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

   693 */

   694 TInt DCameraScLdd::ReAllocBufferConfigInfo(TInt aNumBuffers)

   695 	{

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

   697 		{

   698 		if (iCaptureModeConfig[captureMode].iBufConfig)

   699 			{

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

   701 			iCaptureModeConfig[captureMode].iBufConfig=NULL;

   702 			}

   703 

   704 		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.

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

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

   707 		if (!iCaptureModeConfig[captureMode].iBufConfig)

   708 			return(KErrNoMemory);

   709 		}

   710 	return(KErrNone);

   711 	}

   712 

   713 /**

   714 Reallocate memory for the new buffer configuration.

   715 @param aNumBuffers The number of buffers.

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

   717 */

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

   719 	{

   720 	if (iCaptureModeConfig[aCaptureMode].iBufConfig)

   721 		{

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

   723 		iCaptureModeConfig[aCaptureMode].iBufConfig=NULL;

   724 		}

   725 

   726 	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.

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

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

   729 	if (!iCaptureModeConfig[aCaptureMode].iBufConfig)

   730 		return(KErrNoMemory);

   731 

   732 	return(KErrNone);

   733 	}

   734 

   735 /**

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

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

   738 @param aCamConfigBuf The supplied camera configuration.

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

   740 */

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

   742 	{

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

   744 

   745 	// Set the configuration of the sensor

   746 	TInt r=DoSetConfig(aCaptureMode, aCamConfigBuf);

   747 	return(r);

   748 	}

   749 

   750 /**

   751 Allows changing of the dynamic settings.

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

   753 forcing a context switch.

   754 

   755 If the setting has been accepted by the sensor the new value is cached by the LDD so further

   756 querying does not involve another context switch.

   757 

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

   759 @param aValue The attributes value.

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

   761 		Otherwise, one of the system wide error codes.

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

   763 */

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

   765 	{

   766 	TUint* attrCachePtr = NULL;

   767 	TInt err = KErrNotSupported;

   768 	

   769 	switch (aAttribute)

   770 		{

   771 		case ECamAttributeBrightness:

   772 			err = Pdd()->SetBrightness(aValue);

   773 			attrCachePtr = &iBrightnessValue;

   774 			break;

   775 			

   776 		case ECamAttributeContrast:

   777 			err = Pdd()->SetContrast(aValue);

   778 			attrCachePtr = &iContrastValue;

   779 			break;

   780 			

   781 		case ECamAttributeColorEffect:

   782 			err = Pdd()->SetColorEffect(aValue);

   783 			attrCachePtr = &iColorEffectValue;

   784 			break;

   785 			

   786 		default:

   787 			return err;

   788 		}

   789 	

   790 	if (err == KErrNone)

   791 		{

   792 		// Cache the set value.

   793 		__ASSERT_DEBUG(attrCachePtr, Kern::Fault(KCameraLddPanic, __LINE__));

   794 		*attrCachePtr = aValue;

   795 		}

   796 		

   797 	return err;

   798 	}

   799 

   800 

   801 /**

   802 Allows querying of a dynamic setting.

   803 The value is read from the cached LDD values.

   804 

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

   806 @param aValue A reference to a variable that will receive the attribute value.

   807 @return KErrNone if successful, KErrNotFound if aAttribute is an unsupported

   808         setting. The parameter aValue is not changed if this function fails.

   809 */

   810 TInt DCameraScLdd::GetDynamicAttribute(TInt aAttribute, TUint& aValue)

   811 	{

   812 	switch (aAttribute)

   813 		{

   814 		case ECamAttributeBrightness:

   815 			aValue = iBrightnessValue;

   816 			break;

   817 			

   818 		case ECamAttributeContrast:

   819 			aValue = iContrastValue;

   820 			break;

   821 			

   822 		case ECamAttributeColorEffect:

   823 			aValue = iColorEffectValue;

   824 			break;

   825 			

   826 		default:

   827 			return KErrNotFound;

   828 		}

   829 		

   830 	return KErrNone;

   831 	}

   832 

   833 

   834 /**

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

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

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

   838 */

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

   840 	{

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

   842 

   843 	// Free any memory and chunk already allocated

   844 	TInt r=ChunkClose(aCaptureMode);

   845 	if (r!=KErrNone)

   846 		return(r);

   847 

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

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

   850 	__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));

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

   852 	if (!iCaptureModeConfig[aCaptureMode].iBufManager)

   853 		return(KErrNoMemory);

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

   855 	if (r!=KErrNone)

   856 		return(r);

   857 

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

   859 	r=ReAllocBufferConfigInfo(aCaptureMode, aNumBuffers);

   860 	if (r!=KErrNone)

   861 		return(r);

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

   863 

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

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

   866 	if (r>0)

   867 		{

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

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

   870 		iCaptureModeConfig[aCaptureMode].iChunkHandle=r;

   871 		}

   872 

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

   874 	return(r);

   875 	}

   876 

   877 /**

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

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

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

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

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

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

   884 */

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

   886 	{

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

   888 

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

   890 	TInt numBuffers;

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

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

   893 	if (r!=KErrNone)

   894 		return(r);

   895 	// Calculate the minimum length of the descriptor.

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

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

   898 	if (r<minDesLen)

   899 		return(KErrArgument);

   900 	r=ReAllocBufferConfigInfo(aCaptureMode, numBuffers);

   901 	if (r!=KErrNone)

   902 		return(r);

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

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

   905 	if (r!=KErrNone)

   906 		return(r);

   907 

   908 	// Free any memory and chunk already allocated

   909 	r=ChunkClose(aCaptureMode);

   910 	if (r!=KErrNone)

   911 		return(r);

   912 

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

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

   915 	if (!iCaptureModeConfig[aCaptureMode].iBufManager)

   916 		return(KErrNoMemory);

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

   918 	if (r!=KErrNone)

   919 		return(r);

   920 

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

   922 	return(r);

   923 	}

   924 

   925 /**

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

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

   928 this is not a requirement.

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

   930 @return	KErrNone if successful.

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

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

   933 */

   934 TInt DCameraScLdd::ChunkClose(TInt aCaptureMode)

   935 	{

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

   937 

   938 	if(iCaptureMode == aCaptureMode)

   939         {

   940         if (iState==ECapturing)

   941             return(KErrInUse);

   942         }

   943 

   944 	// Delete any existing buffers

   945 	if (iCaptureModeConfig[aCaptureMode].iBufManager)

   946 		{

   947 		delete iCaptureModeConfig[aCaptureMode].iBufManager;

   948 		iCaptureModeConfig[aCaptureMode].iBufManager=NULL;

   949 		}

   950 

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

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

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

   954 		{

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

   956 		iCaptureModeConfig[aCaptureMode].iChunkHandle=0;

   957 		}

   958 

   959 	return(KErrNone);

   960 	}

   961 

   962 /**

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

   964 to support future changes to the config structure.

   965 

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

   967 @return KErrNone if successful;

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

   969 */

   970 TInt DCameraScLdd::SetCaptureMode(TInt aCaptureMode)

   971 	{

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

   973 

   974 	TInt r=KErrNone;

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

   976 		{

   977 		r=KErrNotFound;

   978 		return(r);

   979 		}

   980 

   981 	if (!iCaptureModeConfig[aCaptureMode].iBufManager)

   982 		{

   983 		r=KErrNotReady;

   984 		return(r);

   985 		}

   986 

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

   988 

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

   990 

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

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

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

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

   995 	if (r!=KErrNone)

   996 		return(r);

   997 	return KErrNone;

   998 	}

   999 

  1000 

  1001 /**

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

  1003 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

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

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

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

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

  1008 */

  1009 TInt DCameraScLdd::Start()

  1010 	{

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

  1012 

  1013 	if (iState==ECapturing)

  1014 		return(KErrInUse);

  1015 	TInt r=KErrNone;

  1016 

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

  1018 	if (iCaptureModeConfig[iCaptureMode].iBufManager)

  1019 		iState=EConfigured;

  1020 

  1021 	if (iState==EOpen)

  1022 		r=KErrNotReady;

  1023 	else if (iState==EConfigured)

  1024 		{

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

  1026 		if (iCaptureMode!=ECamCaptureModeImage)

  1027 			r=DoStart();

  1028 		if (r==KErrNone)

  1029 			iState=ECapturing;

  1030 		}

  1031 	else

  1032 		r=KErrGeneral;

  1033 	return(r);

  1034 	}

  1035 

  1036 /**

  1037 Start the PDD capturing images.

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

  1039 */

  1040 TInt DCameraScLdd::DoStart()

  1041 	{

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

  1043 

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

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

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

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

  1048 

  1049 /*

  1050  * 	James Cooper: Uncommenting this code will cause the ASSERT_DEBUG in SetImageCaptured() to fail

  1051  * 	if (r==KErrNone && bufManager->iNextBuffer)

  1052 		{

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

  1054 		physAddr=bufManager->iNextBuffer->iPhysicalAddress;

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

  1056 		}

  1057 */	

  1058 	return(r);

  1059 	}

  1060 

  1061 /**

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

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

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

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

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

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

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

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

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

  1071 		otherwise one of the other system wide error codes.

  1072 */

  1073 TInt DCameraScLdd::NotifyNewImage(TRequestStatus* aStatus)

  1074 	{

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

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

  1077 	TInt r;

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

  1079 		return(KErrNotReady);

  1080 

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

  1082 	if (iCaptureMode!=ECamCaptureModeImage)

  1083 		{

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

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

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

  1087 		if (buf)

  1088 			{

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

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

  1091 			r=buf->iResult;

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

  1093 			if (r==KErrNone)

  1094 				{

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

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

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

  1098 				}

  1099 			return(r);

  1100 			}

  1101 

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

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

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

  1105 			{

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

  1107 			return(KErrInUse);

  1108 			}

  1109 		}

  1110 	else

  1111 		{

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

  1113 		// before we can accept the request.

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

  1115 			{

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

  1117 			return(KErrInUse);

  1118 			}

  1119 

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

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

  1122 		if (iRequestQueue.IsEmpty())

  1123 			{

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

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

  1126 			r=DoStart();

  1127 			if (r!=KErrNone)

  1128 				return(r);

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

  1130 			}

  1131 		}

  1132 

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

  1134 	// an image is available.