diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kernel/eka/drivers/debug/common/d_debug_functionality.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/kernelhwsrv/kernel/eka/drivers/debug/common/d_debug_functionality.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,582 @@
+// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Defines the DebugFunctionality class. This is responsible for
+// providing configuration data needed by a host debugger to be able
+// to correctly use the functionality provided by the run-mode debug subsystem.
+// 
+
+#include <e32def.h>
+#include <e32def_private.h>
+#include <e32cmn.h>
+#include <e32cmn_private.h>
+#include <u32std.h>
+#include <kernel/kernel.h>
+#include <rm_debug_api.h>
+#include <sm_debug_api.h>
+#include "d_rmd_breakpoints.h"
+#include "rm_debug_kerneldriver.h"
+#include "d_debug_functionality.h"
+#include "d_buffer_manager.h"
+
+using namespace Debug;
+
+// Core
+const TTag DebugFunctionalityCoreInfo[] =
+	{
+	{ECoreEvents,ETagTypeBoolean,0,ETrue},
+	{ECoreStartStop,ETagTypeBoolean,0,ETrue},
+	{ECoreMemory,ETagTypeBoolean,0,ETrue},
+	{ECoreRegister,ETagTypeBoolean,0,ETrue},
+	{ECoreBreakpoint,ETagTypeBoolean,0,ETrue},
+	{ECoreStepping,ETagTypeBoolean,0,ETrue},
+	{ECoreLists,ETagTypeBoolean,0,ETrue},
+	{ECoreLogging,ETagTypeBoolean,0,EFalse},
+	{ECoreHardware,ETagTypeBoolean,0,EFalse},
+	{ECoreApiConstants,ETagTypeBoolean,0,ETrue},
+	{ECoreKillObjects,ETagTypeBoolean,0,ETrue},
+	{ECoreSecurity,ETagTypeBoolean,0,ETrue},
+	{ECoreStopModeFunctions,ETagTypeBoolean,0,EFalse},
+	{ECoreStopModeBuffers,ETagTypeBoolean,0,EFalse},	
+	};
+
+const TSubBlock DebugFunctionalityCore[] =
+	{
+	ETagHeaderIdCore,ECoreLast,
+	(TTag*)DebugFunctionalityCoreInfo
+	};
+
+// Core
+const TTag StopModeFunctionalityCoreInfo[] =
+	{
+	{ECoreEvents,ETagTypeBoolean,0,EFalse},
+	{ECoreStartStop,ETagTypeBoolean,0,EFalse},
+	{ECoreMemory,ETagTypeBoolean,0,EFalse},
+	{ECoreRegister,ETagTypeBoolean,0,EFalse},
+	{ECoreBreakpoint,ETagTypeBoolean,0,EFalse},
+	{ECoreStepping,ETagTypeBoolean,0,EFalse},
+	{ECoreLists,ETagTypeBoolean,0,ETrue},
+	{ECoreLogging,ETagTypeBoolean,0,EFalse},
+	{ECoreHardware,ETagTypeBoolean,0,EFalse},
+	{ECoreApiConstants,ETagTypeBoolean,0,EFalse},
+	{ECoreKillObjects, ETagTypeBoolean,0, EFalse},
+	{ECoreSecurity, ETagTypeBoolean,0,EFalse},
+	{ECoreStopModeFunctions,ETagTypeBoolean,0,ETrue},
+	{ECoreStopModeBuffers,ETagTypeBoolean,0,ETrue},
+	};
+
+const TSubBlock StopModeFunctionalityCore[] =
+	{
+	ETagHeaderIdCore,ECoreLast,
+	(TTag*)StopModeFunctionalityCoreInfo
+	};
+
+const TSubBlock StopModeFunctionalityBuffers[]=
+	{
+	ETagHeaderIdBuffers,EBuffersLast,
+	(TTag*)NULL
+	};
+
+const TTag StopModeFunctionalityFunctionsInfo[] =
+	{
+#ifdef __LAUNCH_AS_EXTENSION__
+	{EStopModeFunctionsExitPoint,ETagTypePointer,0,(TUint32)&StopModeDebug::ExitPoint}, 
+	{EStopModeFunctionsGetList,ETagTypePointer,0,(TUint32)&StopModeDebug::GetList},
+	{EStopModeFunctionsTestAPI,ETagTypePointer,0,(TUint32)&StopModeDebug::TestAPI} 
+#else
+	{EStopModeFunctionsExitPoint,ETagTypePointer,0,NULL}, 
+	{EStopModeFunctionsGetList,ETagTypePointer,0,NULL},
+	{EStopModeFunctionsTestAPI,ETagTypePointer,0,NULL} 
+#endif
+	};
+
+const TSubBlock StopModeFunctionalityFunctions[]=
+	{
+	ETagHeaderIdStopModeFunctions,EStopModeFunctionsLast,
+	(TTag*)StopModeFunctionalityFunctionsInfo
+	};
+
+
+// Memory
+const TTag DebugFunctionalityMemoryInfo[] =
+	{
+	{EMemoryRead,ETagTypeBoolean,0,ETrue}, 
+	{EMemoryWrite,ETagTypeBoolean,0,ETrue},
+	{EMemoryAccess64,ETagTypeBoolean,0,EFalse},
+	{EMemoryAccess32,ETagTypeBoolean,0,ETrue},
+	{EMemoryAccess16,ETagTypeBoolean,0,EFalse},
+	{EMemoryAccess8,ETagTypeBoolean,0,EFalse},
+	{EMemoryBE8,ETagTypeBoolean,0,EFalse},
+	{EMemoryBE32,ETagTypeBoolean,0,EFalse},
+	{EMemoryLE8,ETagTypeBoolean,0,ETrue},
+	{EMemoryMaxBlockSize,ETagTypeTUint32,0,16 * KKilo /* 16Kbytes */}	// binaryMax size of memory requests in bytes
+	};
+
+const TSubBlock DebugFunctionalityMemory[]=
+	{
+	ETagHeaderIdMemory,EMemoryLast,
+	(TTag*)DebugFunctionalityMemoryInfo
+	};
+
+// Kill Objects
+const TTag DebugFunctionalityKillObjectsInfo[] =
+	{
+	{EFunctionalityKillThread,ETagTypeBoolean,0,EFalse}, 
+	{EFunctionalityKillProcess,ETagTypeBoolean,0,ETrue}
+	};
+
+const TSubBlock DebugFunctionalityKillObjects[]=
+	{
+	ETagHeaderIdKillObjects,EFunctionalityKillObjectLast,
+	(TTag*)DebugFunctionalityKillObjectsInfo
+	};
+
+// Core Registers
+const TTag DebugFunctionalityRegistersCoreInfo[] =
+	{
+	{ERegisterR0,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR1,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR2,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR3,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR4,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR5,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR6,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR7,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR8,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR9,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR10,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR11,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR12,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR13,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR14,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR15,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterCpsr,ETagTypeEnum, 4,EAccessReadWrite},
+	{ERegisterR13Svc,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR14Svc,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterSpsrSvc,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR13Abt,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR14Abt,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterSpsrAbt,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR13Und,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR14Und,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterSpsrUnd,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR13Irq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR14Irq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterSpsrIrq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR8Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR9Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR10Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR11Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR12Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR13Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterR14Fiq,ETagTypeEnum, 4,EAccessNone},
+	{ERegisterSpsrFiq, ETagTypeEnum, 4,EAccessNone}
+	};
+
+const TSubBlock DebugFunctionalityRegistersCore[] =
+	{
+	ETagHeaderIdRegistersCore, ERegisterLast,
+	(TTag*)DebugFunctionalityRegistersCoreInfo
+	};
+
+// Co-processor registers
+const TTag DebugFunctionalityRegistersCoProInfo[]=
+	{
+	//this is the DACR register
+	{0x00300f01, ETagTypeTUint32, 4, EAccessReadWrite} 
+	};
+
+const TSubBlock DebugFunctionalityRegistersCoPro[]=
+	{
+	ETagHeaderIdCoProRegisters,1,
+	(TTag*)DebugFunctionalityRegistersCoProInfo
+	};
+
+// Breakpoints
+const TTag DebugFunctionalityBreakpointsInfo[]=
+	{
+	{EBreakpointThread,ETagTypeBoolean,0,ETrue},
+	{EBreakpointProcess,ETagTypeBoolean,0,ETrue},
+	{EBreakpointSystem,ETagTypeBoolean,0,EFalse},
+	{EBreakpointArm,ETagTypeBoolean,0,ETrue},
+	{EBreakpointThumb,ETagTypeBoolean,0,ETrue},
+	{EBreakpointT2EE,ETagTypeBoolean,0,ETrue},
+	{EBreakpointArmInst,ETagTypeBoolean,0,EFalse},
+	{EBreakpointThumbInst,ETagTypeBoolean,0,EFalse},
+	{EBreakpointT2EEInst,ETagTypeBoolean,0,ETrue},
+	{EBreakpointSetArmInst,ETagTypeBoolean,0,EFalse},
+	{EBreakpointSetThumbInst,ETagTypeBoolean,0,EFalse},
+	{EBreakpointSetT2EEInst,ETagTypeBoolean,0,ETrue}
+	};
+
+const TSubBlock DebugFunctionalityBreakpoints[] =
+	{
+	ETagHeaderIdBreakpoints, EBreakpointLast,
+	(TTag*)DebugFunctionalityBreakpointsInfo
+	};
+
+// Stepping
+const TTag DebugFunctionalitySteppingInfo[]=
+	{
+	{EStep,ETagTypeBoolean,0,ETrue}
+	};
+
+const TSubBlock DebugFunctionalityStepping[] =
+	{
+	ETagHeaderIdStepping, EStepLast,
+	(TTag*)DebugFunctionalitySteppingInfo
+	};
+
+// Execution Control
+const TTag DebugFunctionalityExecutionInfo[]=
+	{
+	{EExecThreadSuspendResume,ETagTypeBoolean,0,ETrue},
+	{EExecProcessSuspendResume,ETagTypeBoolean,0,EFalse},
+	{EExecSystemSuspendResume,ETagTypeBoolean,0,EFalse},
+	};
+
+const TSubBlock DebugFunctionalityExecution[]=
+	{
+	ETagHeaderIdExecution, EExecLast,
+	(TTag*)DebugFunctionalityExecutionInfo
+	};
+
+// Events
+const TTag DebugFunctionalityEventsInfo[]=
+	{
+	{EEventsBreakPoint,ETagTypeEnum,0,EActionSuspend},
+	{EEventsProcessBreakPoint,ETagTypeEnum,0,EActionSuspend},
+	{EEventsSwExc,ETagTypeEnum,0,EActionSuspend},
+	{EEventsHwExc,ETagTypeEnum,0,EActionSuspend},
+	{EEventsKillThread,ETagTypeEnum,0,EActionContinue},
+	{EEventsAddLibrary,ETagTypeEnum,0,EActionSuspend},
+	{EEventsRemoveLibrary,ETagTypeEnum,0,EActionSuspend},
+	{EEventsUserTrace,ETagTypeEnum,0,EActionSuspend},
+	{EEventsStartThread,ETagTypeEnum,0,EActionSuspend},
+	{EEventsBufferFull,ETagTypeEnum,0,EActionContinue},
+	{EEventsUnknown,ETagTypeEnum,0,EActionContinue},
+	{EEventsUserTracesLost, ETagTypeEnum, 0, EActionContinue},
+	{EEventsAddProcess,ETagTypeEnum,0,EActionContinue},
+	{EEventsRemoveProcess,ETagTypeEnum,0,EActionContinue}
+	};
+
+const TSubBlock DebugFunctionalityEvents[] =
+	{
+	ETagHeaderIdEvents, EEventsLast,
+	(TTag*)DebugFunctionalityEventsInfo
+	};
+
+// API Constants
+const TTag DebugFunctionalityApiConstantsInfo[]=
+	{
+	{EApiConstantsTEventInfoSize,ETagTypeTUint32,0,sizeof(TEventInfo)},
+	};
+
+const TSubBlock DebugFunctionalityApiConstants[] =
+	{
+	ETagHeaderIdApiConstants, EApiConstantsLast,
+	(TTag*)DebugFunctionalityApiConstantsInfo
+	};
+
+// Listings
+const TTag DebugFunctionalityListInfo[] =
+	{
+	{EProcesses,ETagTypeBitField,0,EScopeGlobal},
+	{EThreads,ETagTypeBitField,0,EScopeGlobal|EScopeProcessSpecific|EScopeThreadSpecific},
+	{ECodeSegs,ETagTypeBitField,0,EScopeGlobal|EScopeProcessSpecific|EScopeThreadSpecific},
+	{EXipLibraries,ETagTypeBitField,0,EScopeGlobal},
+	{EExecutables,ETagTypeBitField,0,EScopeGlobal},
+	{ELogicalDevices,ETagTypeBitField,0,EScopeNone},
+	{EMutexes,ETagTypeBitField,0,EScopeNone},
+	{EServers,ETagTypeBitField,0,EScopeNone},
+	{ESessions,ETagTypeBitField,0,EScopeNone},
+	{ESemaphores,ETagTypeBitField,0,EScopeNone},
+	{EChunks,ETagTypeBitField,0,EScopeNone},
+	{EBreakpoints,ETagTypeBitField,0,EScopeNone},
+	{ESetBreak,ETagTypeBitField,0,EScopeNone},
+	{ERemoveBreak,ETagTypeBitField,0,EScopeNone},
+	{EModifyBreak,ETagTypeBitField,0,EScopeNone},
+	};
+
+const TSubBlock DebugFunctionalityList[] =
+	{
+	ETagHeaderList, EListLast,
+	(TTag*)DebugFunctionalityListInfo
+	};
+
+// Listings
+const TTag StopModeFunctionalityListInfo[] =
+	{
+	{EProcesses,ETagTypeBitField,0,EScopeNone},
+	{EThreads,ETagTypeBitField,0,EScopeNone},
+	{ECodeSegs,ETagTypeBitField,0,EScopeGlobal|EScopeThreadSpecific},
+	{EXipLibraries,ETagTypeBitField,0,EScopeNone},
+	{EExecutables,ETagTypeBitField,0,EScopeNone},
+	{ELogicalDevices,ETagTypeBitField,0,EScopeNone},
+	{EMutexes,ETagTypeBitField,0,EScopeNone},
+	{EServers,ETagTypeBitField,0,EScopeNone},
+	{ESessions,ETagTypeBitField,0,EScopeNone},
+	{ESemaphores,ETagTypeBitField,0,EScopeNone},
+	{EChunks,ETagTypeBitField,0,EScopeNone},
+	{EBreakpoints,ETagTypeBitField,0,EScopeNone},
+	{ESetBreak,ETagTypeBitField,0,EScopeNone},
+	{ERemoveBreak,ETagTypeBitField,0,EScopeNone},
+	{EModifyBreak,ETagTypeBitField,0,EScopeNone},
+	};
+
+const TSubBlock StopModeFunctionalityList[] =
+	{
+	ETagHeaderList, EListLast,
+	(TTag*)StopModeFunctionalityListInfo
+	};
+	// not implemented
+
+// actionpoints
+	// not implemented
+
+// codeapplets
+	// not implemented
+
+// BTrace/UTrace
+	// not implemented
+
+// Security
+const TTag DebugFunctionalitySecurityInfo[]=
+	{
+	{ESecurityOEMDebugToken,ETagTypeBoolean,0,ETrue}
+	};
+
+const TSubBlock DebugFunctionalitySecurity[] =
+	{
+	ETagHeaderIdSecurity, ESecurityLast,
+	(TTag*)DebugFunctionalitySecurityInfo
+	};
+
+TUint32 TDebugFunctionality::GetDebugFunctionalityBufSize(void)
+	{
+	TUint32 df_size = 0;
+
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityCore);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityMemory);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityRegistersCore);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityRegistersCoPro);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityBreakpoints);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityStepping);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityExecution);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityEvents);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityApiConstants);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityList);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalityKillObjects);
+	df_size += ComputeBlockSize((const TSubBlock&)DebugFunctionalitySecurity);
+	
+	return df_size;
+	}
+
+TUint32 TDebugFunctionality::GetStopModeFunctionalityBufSize(void)
+	{
+	TUint32 bytes = 0;
+	
+	// First four bytes are length field
+	// Next four are version
+	// Last four bytes will be the checksum	
+	bytes = 12 +
+            ComputeBlockSize((const TSubBlock&)StopModeFunctionalityCore) +
+            ComputeBlockSize((const TSubBlock&)StopModeFunctionalityBuffers) +
+            ComputeBlockSize((const TSubBlock&)StopModeFunctionalityFunctions) +
+            ComputeBlockSize((const TSubBlock&)StopModeFunctionalityList);
+            
+	return bytes;
+	}
+
+TBool TDebugFunctionality::GetStopModeFunctionality(TDes8& aDFBlock)
+	{
+	TUint32 size = GetStopModeFunctionalityBufSize();
+	if (aDFBlock.MaxLength() < size)
+		{
+		// Insufficient space to contain the debug functionality block
+		return EFalse;
+		}
+
+	TUint8* ptr = (TUint8*)&size;
+	aDFBlock.SetLength(0);
+	aDFBlock.Append(ptr, 4);
+	TVersion version = TVersion(KStopModeMajorVersionNumber, KStopModeMinorVersionNumber, KStopModePatchVersionNumber);
+	ptr = (TUint8*)&version;
+	aDFBlock.Append(ptr, sizeof(TVersion));
+	
+	AppendBlock((const TSubBlock&)StopModeFunctionalityCore,aDFBlock);
+	AppendBlock((const TSubBlock&)StopModeFunctionalityFunctions,aDFBlock);
+	AppendBlock((const TSubBlock&)StopModeFunctionalityList,aDFBlock);
+	
+	const TTagHeader& header = StopModeFunctionalityBuffers->iHeader;
+	aDFBlock.Append((TUint8*)&header, sizeof(TTagHeader));
+	
+	for(TInt i=0; i<EBuffersLast; i++)
+		{
+		TTag tag;
+		TheDBufferManager.GetBufferDetails((TBufferType)i, tag);
+		aDFBlock.Append((TUint8*)&tag, sizeof(TTag));
+		}
+
+	if(aDFBlock.Length() != size - 4)
+		{
+		return EFalse;
+		}
+
+	TUint32* ptr32 = (TUint32*)aDFBlock.Ptr();
+	TUint32 checksum = 0;
+	for(TInt i=0; i<aDFBlock.Length(); i+=4)
+		{
+		checksum^=*ptr32;
+		ptr32++;
+		}
+	
+	ptr = (TUint8*)&checksum;
+	aDFBlock.Append(ptr, 4);
+	
+	return ETrue;
+	}
+
+TBool TDebugFunctionality::GetDebugFunctionality(TDes8& aDFBlock)
+	{
+	if (aDFBlock.MaxLength() < GetDebugFunctionalityBufSize() )
+		{
+		// Insufficient space to contain the debug functionality block
+		return EFalse;
+		}
+
+	AppendBlock((const TSubBlock&)DebugFunctionalityCore,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityMemory,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityRegistersCore,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityRegistersCoPro,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityBreakpoints,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityStepping,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityExecution,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityEvents,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityApiConstants,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityList,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalityKillObjects,aDFBlock);
+	AppendBlock((const TSubBlock&)DebugFunctionalitySecurity,aDFBlock);
+
+	return ETrue;
+	}
+
+/**
+ * Get the register information associated with aRegisterInfo. If aRegisterInfo is
+ * an unsupported register then an entry of the form:
+ *   {aRegisterInfo, x, 0, EAccessUnknown}
+ *   will be returned where x is an arbitrary value.
+ *   
+ *   @param aRegisterInfo register id information
+ *   @param aTag The functionality information for this register.
+ *   @return One of the system wide error codes
+ */
+TInt TDebugFunctionality::GetRegister(const TRegisterInfo aRegisterInfo, TTag& aTag)
+	{
+	if(Register::IsCoreReg(aRegisterInfo))
+		{
+		for(TInt i=0; i<ERegisterLast; i++)
+			{
+			if(Register::GetCoreRegId(DebugFunctionalityRegistersCoreInfo[i].iTagId) == Register::GetCoreRegId(aRegisterInfo))
+				{
+				aTag = DebugFunctionalityRegistersCoreInfo[i];
+				return KErrNone;
+				}
+			}
+		}
+	else if(Register::IsCoproReg(aRegisterInfo))
+		{
+		//get aRegisterInfo's details
+		TUint32 crn = Register::GetCRn(aRegisterInfo);
+		TUint32 crm = Register::GetCRm(aRegisterInfo);
+		TUint32 opcode1 = Register::GetOpcode1(aRegisterInfo);
+		TUint32 opcode2 = Register::GetOpcode2(aRegisterInfo);
+		TUint32 coproNum = Register::GetCoproNum(aRegisterInfo);
+
+		for(TInt i=0; i<sizeof(DebugFunctionalityRegistersCoProInfo)/sizeof(TTag); i++)
+			{
+			TUint32 tagId = DebugFunctionalityRegistersCoProInfo[i].iTagId;
+
+			//if this entry is the DACR
+			if((Register::GetCRm(tagId) == 3) && (Register::GetCoproNum(tagId) == 15))
+				{
+				if((crm == 3) && (coproNum == 15))
+					{
+					aTag = DebugFunctionalityRegistersCoProInfo[i];
+					return KErrNone;
+					}
+				}
+			//each coprocessor register that is supported will need logic adding here
+			}
+		}
+	else // in the future there could be other types of register supported
+		{
+		//for now just fall through to unsupported case
+		}
+
+	//found an unsupported register so just return EAccessUnknown as the access level
+	aTag.iTagId = aRegisterInfo;
+	aTag.iSize = 0;
+	aTag.iValue = EAccessUnknown;
+
+	return KErrNotSupported;
+	}
+
+/**
+ * Returns the maximum memory block size which can be read or written.
+ * @return the maximum memory block size which can be read or written
+*/
+TUint32 TDebugFunctionality::GetMemoryOperationMaxBlockSize()
+	{
+	return DebugFunctionalityMemoryInfo[EMemoryMaxBlockSize].iValue;
+	}
+
+/**
+ * Helper function to append a DebugFunctionalityXXX SubBlock 
+ * into a TDes buffer
+ */
+void TDebugFunctionality::AppendBlock(const TSubBlock& aDFSubBlock, TDes8& aDFBlock)
+	{
+	// Copy the aSubDFBlock.header into aDFBlock (Note we don't put in a TSubBlock structure
+	// as the block is just that - a flat block so the pointer is not required)
+	TPtr8 SubDFBlockHdrPtr((TUint8*)&aDFSubBlock.iHeader,sizeof(TTagHeader),sizeof(TTagHeader));
+
+	aDFBlock.Append(SubDFBlockHdrPtr);
+
+	// Append all the Tags
+	for (TUint i=0; i<aDFSubBlock.iHeader.iNumTags; i++)
+		{
+		TPtr8 tmpPtr((TUint8*)&aDFSubBlock.iTagArray[i],sizeof(TTag),sizeof(TTag));
+
+		aDFBlock.Append(tmpPtr);
+		}
+	}
+
+/**
+ * Computes the size in bytes of aDFBlock
+ * @param aDFSubBlock
+ * @return TUint32 size of sub block
+ */
+TUint32 TDebugFunctionality::ComputeBlockSize(const TSubBlock& aDFSubBlock)
+	{
+	TUint32 size = 0;
+
+	// Header size
+	size += sizeof(TTagHeader);
+
+	// size of all the tags within the header:
+	size += aDFSubBlock.iHeader.iNumTags * sizeof(TTag); 
+
+	return size;
+	}
+