Symaptic: os/kernelhwsrv/kernel/eka/drivers/debug/common/d_debug

     1 // Copyright (c) 2006-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 // Defines the DebugFunctionality class. This is responsible for

    15 // providing configuration data needed by a host debugger to be able

    16 // to correctly use the functionality provided by the run-mode debug subsystem.

    17 //

    19 #include <e32def.h>

    20 #include <e32def_private.h>

    21 #include <e32cmn.h>

    22 #include <e32cmn_private.h>

    23 #include <u32std.h>

    24 #include <kernel/kernel.h>

    25 #include <rm_debug_api.h>

    26 #include <sm_debug_api.h>

    27 #include "d_rmd_breakpoints.h"

    28 #include "rm_debug_kerneldriver.h"

    29 #include "d_debug_functionality.h"

    30 #include "d_buffer_manager.h"

    32 using namespace Debug;

    34 // Core

    35 const TTag DebugFunctionalityCoreInfo[] =

    36 	{

    37 	{ECoreEvents,ETagTypeBoolean,0,ETrue},

    38 	{ECoreStartStop,ETagTypeBoolean,0,ETrue},

    39 	{ECoreMemory,ETagTypeBoolean,0,ETrue},

    40 	{ECoreRegister,ETagTypeBoolean,0,ETrue},

    41 	{ECoreBreakpoint,ETagTypeBoolean,0,ETrue},

    42 	{ECoreStepping,ETagTypeBoolean,0,ETrue},

    43 	{ECoreLists,ETagTypeBoolean,0,ETrue},

    44 	{ECoreLogging,ETagTypeBoolean,0,EFalse},

    45 	{ECoreHardware,ETagTypeBoolean,0,EFalse},

    46 	{ECoreApiConstants,ETagTypeBoolean,0,ETrue},

    47 	{ECoreKillObjects,ETagTypeBoolean,0,ETrue},

    48 	{ECoreSecurity,ETagTypeBoolean,0,ETrue},

    49 	{ECoreStopModeFunctions,ETagTypeBoolean,0,EFalse},

    50 	{ECoreStopModeBuffers,ETagTypeBoolean,0,EFalse},

    51 	};

    53 const TSubBlock DebugFunctionalityCore[] =

    54 	{

    55 	ETagHeaderIdCore,ECoreLast,

    56 	(TTag*)DebugFunctionalityCoreInfo

    57 	};

    59 // Core

    60 const TTag StopModeFunctionalityCoreInfo[] =

    61 	{

    62 	{ECoreEvents,ETagTypeBoolean,0,EFalse},

    63 	{ECoreStartStop,ETagTypeBoolean,0,EFalse},

    64 	{ECoreMemory,ETagTypeBoolean,0,EFalse},

    65 	{ECoreRegister,ETagTypeBoolean,0,EFalse},

    66 	{ECoreBreakpoint,ETagTypeBoolean,0,EFalse},

    67 	{ECoreStepping,ETagTypeBoolean,0,EFalse},

    68 	{ECoreLists,ETagTypeBoolean,0,ETrue},

    69 	{ECoreLogging,ETagTypeBoolean,0,EFalse},

    70 	{ECoreHardware,ETagTypeBoolean,0,EFalse},

    71 	{ECoreApiConstants,ETagTypeBoolean,0,EFalse},

    72 	{ECoreKillObjects, ETagTypeBoolean,0, EFalse},

    73 	{ECoreSecurity, ETagTypeBoolean,0,EFalse},

    74 	{ECoreStopModeFunctions,ETagTypeBoolean,0,ETrue},

    75 	{ECoreStopModeBuffers,ETagTypeBoolean,0,ETrue},

    76 	};

    78 const TSubBlock StopModeFunctionalityCore[] =

    79 	{

    80 	ETagHeaderIdCore,ECoreLast,

    81 	(TTag*)StopModeFunctionalityCoreInfo

    82 	};

    84 const TSubBlock StopModeFunctionalityBuffers[]=

    85 	{

    86 	ETagHeaderIdBuffers,EBuffersLast,

    87 	(TTag*)NULL

    88 	};

    90 const TTag StopModeFunctionalityFunctionsInfo[] =

    91 	{

    92 #ifdef __LAUNCH_AS_EXTENSION__

    93 	{EStopModeFunctionsExitPoint,ETagTypePointer,0,(TUint32)&StopModeDebug::ExitPoint},

    94 	{EStopModeFunctionsGetList,ETagTypePointer,0,(TUint32)&StopModeDebug::GetList},

    95 	{EStopModeFunctionsTestAPI,ETagTypePointer,0,(TUint32)&StopModeDebug::TestAPI}

    96 #else

    97 	{EStopModeFunctionsExitPoint,ETagTypePointer,0,NULL},

    98 	{EStopModeFunctionsGetList,ETagTypePointer,0,NULL},

    99 	{EStopModeFunctionsTestAPI,ETagTypePointer,0,NULL}

   100 #endif

   101 	};

   103 const TSubBlock StopModeFunctionalityFunctions[]=

   104 	{

   105 	ETagHeaderIdStopModeFunctions,EStopModeFunctionsLast,

   106 	(TTag*)StopModeFunctionalityFunctionsInfo

   107 	};

   110 // Memory

   111 const TTag DebugFunctionalityMemoryInfo[] =

   112 	{

   113 	{EMemoryRead,ETagTypeBoolean,0,ETrue},

   114 	{EMemoryWrite,ETagTypeBoolean,0,ETrue},

   115 	{EMemoryAccess64,ETagTypeBoolean,0,EFalse},

   116 	{EMemoryAccess32,ETagTypeBoolean,0,ETrue},

   117 	{EMemoryAccess16,ETagTypeBoolean,0,EFalse},

   118 	{EMemoryAccess8,ETagTypeBoolean,0,EFalse},

   119 	{EMemoryBE8,ETagTypeBoolean,0,EFalse},

   120 	{EMemoryBE32,ETagTypeBoolean,0,EFalse},

   121 	{EMemoryLE8,ETagTypeBoolean,0,ETrue},

   122 	{EMemoryMaxBlockSize,ETagTypeTUint32,0,16 * KKilo /* 16Kbytes */}	// binaryMax size of memory requests in bytes

   123 	};

   125 const TSubBlock DebugFunctionalityMemory[]=

   126 	{

   127 	ETagHeaderIdMemory,EMemoryLast,

   128 	(TTag*)DebugFunctionalityMemoryInfo

   129 	};

   131 // Kill Objects

   132 const TTag DebugFunctionalityKillObjectsInfo[] =

   133 	{

   134 	{EFunctionalityKillThread,ETagTypeBoolean,0,EFalse},

   135 	{EFunctionalityKillProcess,ETagTypeBoolean,0,ETrue}

   136 	};

   138 const TSubBlock DebugFunctionalityKillObjects[]=

   139 	{

   140 	ETagHeaderIdKillObjects,EFunctionalityKillObjectLast,

   141 	(TTag*)DebugFunctionalityKillObjectsInfo

   142 	};

   144 // Core Registers

   145 const TTag DebugFunctionalityRegistersCoreInfo[] =

   146 	{

   147 	{ERegisterR0,ETagTypeEnum, 4,EAccessReadWrite},

   148 	{ERegisterR1,ETagTypeEnum, 4,EAccessReadWrite},

   149 	{ERegisterR2,ETagTypeEnum, 4,EAccessReadWrite},

   150 	{ERegisterR3,ETagTypeEnum, 4,EAccessReadWrite},

   151 	{ERegisterR4,ETagTypeEnum, 4,EAccessReadWrite},

   152 	{ERegisterR5,ETagTypeEnum, 4,EAccessReadWrite},

   153 	{ERegisterR6,ETagTypeEnum, 4,EAccessReadWrite},

   154 	{ERegisterR7,ETagTypeEnum, 4,EAccessReadWrite},

   155 	{ERegisterR8,ETagTypeEnum, 4,EAccessReadWrite},

   156 	{ERegisterR9,ETagTypeEnum, 4,EAccessReadWrite},

   157 	{ERegisterR10,ETagTypeEnum, 4,EAccessReadWrite},

   158 	{ERegisterR11,ETagTypeEnum, 4,EAccessReadWrite},

   159 	{ERegisterR12,ETagTypeEnum, 4,EAccessReadWrite},

   160 	{ERegisterR13,ETagTypeEnum, 4,EAccessReadWrite},

   161 	{ERegisterR14,ETagTypeEnum, 4,EAccessReadWrite},

   162 	{ERegisterR15,ETagTypeEnum, 4,EAccessReadWrite},

   163 	{ERegisterCpsr,ETagTypeEnum, 4,EAccessReadWrite},

   164 	{ERegisterR13Svc,ETagTypeEnum, 4,EAccessNone},

   165 	{ERegisterR14Svc,ETagTypeEnum, 4,EAccessNone},

   166 	{ERegisterSpsrSvc,ETagTypeEnum, 4,EAccessNone},

   167 	{ERegisterR13Abt,ETagTypeEnum, 4,EAccessNone},

   168 	{ERegisterR14Abt,ETagTypeEnum, 4,EAccessNone},

   169 	{ERegisterSpsrAbt,ETagTypeEnum, 4,EAccessNone},

   170 	{ERegisterR13Und,ETagTypeEnum, 4,EAccessNone},

   171 	{ERegisterR14Und,ETagTypeEnum, 4,EAccessNone},

   172 	{ERegisterSpsrUnd,ETagTypeEnum, 4,EAccessNone},

   173 	{ERegisterR13Irq,ETagTypeEnum, 4,EAccessNone},

   174 	{ERegisterR14Irq,ETagTypeEnum, 4,EAccessNone},

   175 	{ERegisterSpsrIrq,ETagTypeEnum, 4,EAccessNone},

   176 	{ERegisterR8Fiq,ETagTypeEnum, 4,EAccessNone},

   177 	{ERegisterR9Fiq,ETagTypeEnum, 4,EAccessNone},

   178 	{ERegisterR10Fiq,ETagTypeEnum, 4,EAccessNone},

   179 	{ERegisterR11Fiq,ETagTypeEnum, 4,EAccessNone},

   180 	{ERegisterR12Fiq,ETagTypeEnum, 4,EAccessNone},

   181 	{ERegisterR13Fiq,ETagTypeEnum, 4,EAccessNone},

   182 	{ERegisterR14Fiq,ETagTypeEnum, 4,EAccessNone},

   183 	{ERegisterSpsrFiq, ETagTypeEnum, 4,EAccessNone}

   184 	};

   186 const TSubBlock DebugFunctionalityRegistersCore[] =

   187 	{

   188 	ETagHeaderIdRegistersCore, ERegisterLast,

   189 	(TTag*)DebugFunctionalityRegistersCoreInfo

   190 	};

   192 // Co-processor registers

   193 const TTag DebugFunctionalityRegistersCoProInfo[]=

   194 	{

   195 	//this is the DACR register

   196 	{0x00300f01, ETagTypeTUint32, 4, EAccessReadWrite}

   197 	};

   199 const TSubBlock DebugFunctionalityRegistersCoPro[]=

   200 	{

   201 	ETagHeaderIdCoProRegisters,1,

   202 	(TTag*)DebugFunctionalityRegistersCoProInfo

   203 	};

   205 // Breakpoints

   206 const TTag DebugFunctionalityBreakpointsInfo[]=

   207 	{

   208 	{EBreakpointThread,ETagTypeBoolean,0,ETrue},

   209 	{EBreakpointProcess,ETagTypeBoolean,0,ETrue},

   210 	{EBreakpointSystem,ETagTypeBoolean,0,EFalse},

   211 	{EBreakpointArm,ETagTypeBoolean,0,ETrue},

   212 	{EBreakpointThumb,ETagTypeBoolean,0,ETrue},

   213 	{EBreakpointT2EE,ETagTypeBoolean,0,ETrue},

   214 	{EBreakpointArmInst,ETagTypeBoolean,0,EFalse},

   215 	{EBreakpointThumbInst,ETagTypeBoolean,0,EFalse},

   216 	{EBreakpointT2EEInst,ETagTypeBoolean,0,ETrue},

   217 	{EBreakpointSetArmInst,ETagTypeBoolean,0,EFalse},

   218 	{EBreakpointSetThumbInst,ETagTypeBoolean,0,EFalse},

   219 	{EBreakpointSetT2EEInst,ETagTypeBoolean,0,ETrue}

   220 	};

   222 const TSubBlock DebugFunctionalityBreakpoints[] =

   223 	{

   224 	ETagHeaderIdBreakpoints, EBreakpointLast,

   225 	(TTag*)DebugFunctionalityBreakpointsInfo

   226 	};

   228 // Stepping

   229 const TTag DebugFunctionalitySteppingInfo[]=

   230 	{

   231 	{EStep,ETagTypeBoolean,0,ETrue}

   232 	};

   234 const TSubBlock DebugFunctionalityStepping[] =

   235 	{

   236 	ETagHeaderIdStepping, EStepLast,

   237 	(TTag*)DebugFunctionalitySteppingInfo

   238 	};

   240 // Execution Control

   241 const TTag DebugFunctionalityExecutionInfo[]=

   242 	{

   243 	{EExecThreadSuspendResume,ETagTypeBoolean,0,ETrue},

   244 	{EExecProcessSuspendResume,ETagTypeBoolean,0,EFalse},

   245 	{EExecSystemSuspendResume,ETagTypeBoolean,0,EFalse},

   246 	};

   248 const TSubBlock DebugFunctionalityExecution[]=

   249 	{

   250 	ETagHeaderIdExecution, EExecLast,

   251 	(TTag*)DebugFunctionalityExecutionInfo

   252 	};

   254 // Events

   255 const TTag DebugFunctionalityEventsInfo[]=

   256 	{

   257 	{EEventsBreakPoint,ETagTypeEnum,0,EActionSuspend},

   258 	{EEventsProcessBreakPoint,ETagTypeEnum,0,EActionSuspend},

   259 	{EEventsSwExc,ETagTypeEnum,0,EActionSuspend},

   260 	{EEventsHwExc,ETagTypeEnum,0,EActionSuspend},

   261 	{EEventsKillThread,ETagTypeEnum,0,EActionContinue},

   262 	{EEventsAddLibrary,ETagTypeEnum,0,EActionSuspend},

   263 	{EEventsRemoveLibrary,ETagTypeEnum,0,EActionSuspend},

   264 	{EEventsUserTrace,ETagTypeEnum,0,EActionSuspend},

   265 	{EEventsStartThread,ETagTypeEnum,0,EActionSuspend},

   266 	{EEventsBufferFull,ETagTypeEnum,0,EActionContinue},

   267 	{EEventsUnknown,ETagTypeEnum,0,EActionContinue},

   268 	{EEventsUserTracesLost, ETagTypeEnum, 0, EActionContinue},

   269 	{EEventsAddProcess,ETagTypeEnum,0,EActionContinue},

   270 	{EEventsRemoveProcess,ETagTypeEnum,0,EActionContinue}

   271 	};

   273 const TSubBlock DebugFunctionalityEvents[] =

   274 	{

   275 	ETagHeaderIdEvents, EEventsLast,

   276 	(TTag*)DebugFunctionalityEventsInfo

   277 	};

   279 // API Constants

   280 const TTag DebugFunctionalityApiConstantsInfo[]=

   281 	{

   282 	{EApiConstantsTEventInfoSize,ETagTypeTUint32,0,sizeof(TEventInfo)},

   283 	};

   285 const TSubBlock DebugFunctionalityApiConstants[] =

   286 	{

   287 	ETagHeaderIdApiConstants, EApiConstantsLast,

   288 	(TTag*)DebugFunctionalityApiConstantsInfo

   289 	};

   291 // Listings

   292 const TTag DebugFunctionalityListInfo[] =

   293 	{

   294 	{EProcesses,ETagTypeBitField,0,EScopeGlobal},

   295 	{EThreads,ETagTypeBitField,0,EScopeGlobal|EScopeProcessSpecific|EScopeThreadSpecific},

   296 	{ECodeSegs,ETagTypeBitField,0,EScopeGlobal|EScopeProcessSpecific|EScopeThreadSpecific},

   297 	{EXipLibraries,ETagTypeBitField,0,EScopeGlobal},

   298 	{EExecutables,ETagTypeBitField,0,EScopeGlobal},

   299 	{ELogicalDevices,ETagTypeBitField,0,EScopeNone},

   300 	{EMutexes,ETagTypeBitField,0,EScopeNone},

   301 	{EServers,ETagTypeBitField,0,EScopeNone},

   302 	{ESessions,ETagTypeBitField,0,EScopeNone},

   303 	{ESemaphores,ETagTypeBitField,0,EScopeNone},

   304 	{EChunks,ETagTypeBitField,0,EScopeNone},

   305 	{EBreakpoints,ETagTypeBitField,0,EScopeNone},

   306 	{ESetBreak,ETagTypeBitField,0,EScopeNone},

   307 	{ERemoveBreak,ETagTypeBitField,0,EScopeNone},

   308 	{EModifyBreak,ETagTypeBitField,0,EScopeNone},

   309 	};

   311 const TSubBlock DebugFunctionalityList[] =

   312 	{

   313 	ETagHeaderList, EListLast,

   314 	(TTag*)DebugFunctionalityListInfo

   315 	};

   317 // Listings

   318 const TTag StopModeFunctionalityListInfo[] =

   319 	{

   320 	{EProcesses,ETagTypeBitField,0,EScopeNone},

   321 	{EThreads,ETagTypeBitField,0,EScopeNone},

   322 	{ECodeSegs,ETagTypeBitField,0,EScopeGlobal|EScopeThreadSpecific},

   323 	{EXipLibraries,ETagTypeBitField,0,EScopeNone},

   324 	{EExecutables,ETagTypeBitField,0,EScopeNone},

   325 	{ELogicalDevices,ETagTypeBitField,0,EScopeNone},

   326 	{EMutexes,ETagTypeBitField,0,EScopeNone},

   327 	{EServers,ETagTypeBitField,0,EScopeNone},

   328 	{ESessions,ETagTypeBitField,0,EScopeNone},

   329 	{ESemaphores,ETagTypeBitField,0,EScopeNone},

   330 	{EChunks,ETagTypeBitField,0,EScopeNone},

   331 	{EBreakpoints,ETagTypeBitField,0,EScopeNone},

   332 	{ESetBreak,ETagTypeBitField,0,EScopeNone},

   333 	{ERemoveBreak,ETagTypeBitField,0,EScopeNone},

   334 	{EModifyBreak,ETagTypeBitField,0,EScopeNone},

   335 	};

   337 const TSubBlock StopModeFunctionalityList[] =

   338 	{

   339 	ETagHeaderList, EListLast,

   340 	(TTag*)StopModeFunctionalityListInfo

   341 	};

   342 	// not implemented

   344 // actionpoints

   345 	// not implemented

   347 // codeapplets

   348 	// not implemented

   350 // BTrace/UTrace

   351 	// not implemented

   353 // Security

   354 const TTag DebugFunctionalitySecurityInfo[]=

   355 	{

   356 	{ESecurityOEMDebugToken,ETagTypeBoolean,0,ETrue}

   357 	};

   359 const TSubBlock DebugFunctionalitySecurity[] =

   360 	{

   361 	ETagHeaderIdSecurity, ESecurityLast,

   362 	(TTag*)DebugFunctionalitySecurityInfo

   363 	};

   365 TUint32 TDebugFunctionality::GetDebugFunctionalityBufSize(void)

   366 	{

   367 	TUint32 df_size = 0;

   369 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityCore);

   370 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityMemory);

   371 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityRegistersCore);

   372 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityRegistersCoPro);

   373 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityBreakpoints);

   374 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityStepping);

   375 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityExecution);

   376 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityEvents);

   377 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityApiConstants);

   378 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityList);

   379 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityKillObjects);

   380 	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalitySecurity);

   382 	return df_size;

   383 	}

   385 TUint32 TDebugFunctionality::GetStopModeFunctionalityBufSize(void)

   386 	{

   387 	TUint32 bytes = 0;

   389 	// First four bytes are length field

   390 	// Next four are version

   391 	// Last four bytes will be the checksum

   392 	bytes = 12 +

   393             ComputeBlockSize((const TSubBlock&)StopModeFunctionalityCore) +

   394             ComputeBlockSize((const TSubBlock&)StopModeFunctionalityBuffers) +

   395             ComputeBlockSize((const TSubBlock&)StopModeFunctionalityFunctions) +

   396             ComputeBlockSize((const TSubBlock&)StopModeFunctionalityList);

   398 	return bytes;

   399 	}

   401 TBool TDebugFunctionality::GetStopModeFunctionality(TDes8& aDFBlock)

   402 	{

   403 	TUint32 size = GetStopModeFunctionalityBufSize();

   404 	if (aDFBlock.MaxLength() < size)

   405 		{

   406 		// Insufficient space to contain the debug functionality block

   407 		return EFalse;

   408 		}

   410 	TUint8* ptr = (TUint8*)&size;

   411 	aDFBlock.SetLength(0);

   412 	aDFBlock.Append(ptr, 4);

   413 	TVersion version = TVersion(KStopModeMajorVersionNumber, KStopModeMinorVersionNumber, KStopModePatchVersionNumber);

   414 	ptr = (TUint8*)&version;

   415 	aDFBlock.Append(ptr, sizeof(TVersion));

   417 	AppendBlock((const TSubBlock&)StopModeFunctionalityCore,aDFBlock);

   418 	AppendBlock((const TSubBlock&)StopModeFunctionalityFunctions,aDFBlock);

   419 	AppendBlock((const TSubBlock&)StopModeFunctionalityList,aDFBlock);

   421 	const TTagHeader& header = StopModeFunctionalityBuffers->iHeader;

   422 	aDFBlock.Append((TUint8*)&header, sizeof(TTagHeader));

   424 	for(TInt i=0; i<EBuffersLast; i++)

   425 		{

   426 		TTag tag;

   427 		TheDBufferManager.GetBufferDetails((TBufferType)i, tag);

   428 		aDFBlock.Append((TUint8*)&tag, sizeof(TTag));

   429 		}

   431 	if(aDFBlock.Length() != size - 4)

   432 		{

   433 		return EFalse;

   434 		}

   436 	TUint32* ptr32 = (TUint32*)aDFBlock.Ptr();

   437 	TUint32 checksum = 0;

   438 	for(TInt i=0; i<aDFBlock.Length(); i+=4)

   439 		{

   440 		checksum^=*ptr32;

   441 		ptr32++;

   442 		}

   444 	ptr = (TUint8*)&checksum;

   445 	aDFBlock.Append(ptr, 4);

   447 	return ETrue;

   448 	}

   450 TBool TDebugFunctionality::GetDebugFunctionality(TDes8& aDFBlock)

   451 	{

   452 	if (aDFBlock.MaxLength() < GetDebugFunctionalityBufSize() )

   453 		{

   454 		// Insufficient space to contain the debug functionality block

   455 		return EFalse;

   456 		}

   458 	AppendBlock((const TSubBlock&)DebugFunctionalityCore,aDFBlock);

   459 	AppendBlock((const TSubBlock&)DebugFunctionalityMemory,aDFBlock);

   460 	AppendBlock((const TSubBlock&)DebugFunctionalityRegistersCore,aDFBlock);

   461 	AppendBlock((const TSubBlock&)DebugFunctionalityRegistersCoPro,aDFBlock);

   462 	AppendBlock((const TSubBlock&)DebugFunctionalityBreakpoints,aDFBlock);

   463 	AppendBlock((const TSubBlock&)DebugFunctionalityStepping,aDFBlock);

   464 	AppendBlock((const TSubBlock&)DebugFunctionalityExecution,aDFBlock);

   465 	AppendBlock((const TSubBlock&)DebugFunctionalityEvents,aDFBlock);

   466 	AppendBlock((const TSubBlock&)DebugFunctionalityApiConstants,aDFBlock);

   467 	AppendBlock((const TSubBlock&)DebugFunctionalityList,aDFBlock);

   468 	AppendBlock((const TSubBlock&)DebugFunctionalityKillObjects,aDFBlock);

   469 	AppendBlock((const TSubBlock&)DebugFunctionalitySecurity,aDFBlock);

   471 	return ETrue;

   472 	}

   474 /**

   475  * Get the register information associated with aRegisterInfo. If aRegisterInfo is

   476  * an unsupported register then an entry of the form:

   477  *   {aRegisterInfo, x, 0, EAccessUnknown}

   478  *   will be returned where x is an arbitrary value.

   479  *

   480  *   @param aRegisterInfo register id information

   481  *   @param aTag The functionality information for this register.

   482  *   @return One of the system wide error codes

   483  */

   484 TInt TDebugFunctionality::GetRegister(const TRegisterInfo aRegisterInfo, TTag& aTag)

   485 	{

   486 	if(Register::IsCoreReg(aRegisterInfo))

   487 		{

   488 		for(TInt i=0; i<ERegisterLast; i++)

   489 			{

   490 			if(Register::GetCoreRegId(DebugFunctionalityRegistersCoreInfo[i].iTagId) == Register::GetCoreRegId(aRegisterInfo))

   491 				{

   492 				aTag = DebugFunctionalityRegistersCoreInfo[i];

   493 				return KErrNone;

   494 				}

   495 			}

   496 		}

   497 	else if(Register::IsCoproReg(aRegisterInfo))

   498 		{

   499 		//get aRegisterInfo's details

   500 		TUint32 crn = Register::GetCRn(aRegisterInfo);

   501 		TUint32 crm = Register::GetCRm(aRegisterInfo);

   502 		TUint32 opcode1 = Register::GetOpcode1(aRegisterInfo);

   503 		TUint32 opcode2 = Register::GetOpcode2(aRegisterInfo);

   504 		TUint32 coproNum = Register::GetCoproNum(aRegisterInfo);

   506 		for(TInt i=0; i<sizeof(DebugFunctionalityRegistersCoProInfo)/sizeof(TTag); i++)

   507 			{

   508 			TUint32 tagId = DebugFunctionalityRegistersCoProInfo[i].iTagId;

   510 			//if this entry is the DACR

   511 			if((Register::GetCRm(tagId) == 3) && (Register::GetCoproNum(tagId) == 15))

   512 				{

   513 				if((crm == 3) && (coproNum == 15))

   514 					{

   515 					aTag = DebugFunctionalityRegistersCoProInfo[i];

   516 					return KErrNone;

   517 					}

   518 				}

   519 			//each coprocessor register that is supported will need logic adding here

   520 			}

   521 		}

   522 	else // in the future there could be other types of register supported

   523 		{

   524 		//for now just fall through to unsupported case

   525 		}

   527 	//found an unsupported register so just return EAccessUnknown as the access level

   528 	aTag.iTagId = aRegisterInfo;

   529 	aTag.iSize = 0;

   530 	aTag.iValue = EAccessUnknown;

   532 	return KErrNotSupported;

   533 	}

   535 /**

   536  * Returns the maximum memory block size which can be read or written.

   537  * @return the maximum memory block size which can be read or written

   538 */

   539 TUint32 TDebugFunctionality::GetMemoryOperationMaxBlockSize()

   540 	{

   541 	return DebugFunctionalityMemoryInfo[EMemoryMaxBlockSize].iValue;

   542 	}

   544 /**

   545  * Helper function to append a DebugFunctionalityXXX SubBlock

   546  * into a TDes buffer

   547  */

   548 void TDebugFunctionality::AppendBlock(const TSubBlock& aDFSubBlock, TDes8& aDFBlock)

   549 	{

   550 	// Copy the aSubDFBlock.header into aDFBlock (Note we don't put in a TSubBlock structure

   551 	// as the block is just that - a flat block so the pointer is not required)

   552 	TPtr8 SubDFBlockHdrPtr((TUint8*)&aDFSubBlock.iHeader,sizeof(TTagHeader),sizeof(TTagHeader));

   554 	aDFBlock.Append(SubDFBlockHdrPtr);

   556 	// Append all the Tags

   557 	for (TUint i=0; i<aDFSubBlock.iHeader.iNumTags; i++)

   558 		{

   559 		TPtr8 tmpPtr((TUint8*)&aDFSubBlock.iTagArray[i],sizeof(TTag),sizeof(TTag));

   561 		aDFBlock.Append(tmpPtr);

   562 		}

   563 	}

   565 /**

   566  * Computes the size in bytes of aDFBlock

   567  * @param aDFSubBlock

   568  * @return TUint32 size of sub block

   569  */

   570 TUint32 TDebugFunctionality::ComputeBlockSize(const TSubBlock& aDFSubBlock)

   571 	{

   572 	TUint32 size = 0;

   574 	// Header size

   575 	size += sizeof(TTagHeader);

   577 	// size of all the tags within the header:

   578 	size += aDFSubBlock.iHeader.iNumTags * sizeof(TTag);

   580 	return size;

   581 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--