diff -r 28479eeba3fb -r f53839ff73b7 bthci/hci2implementations/initialisors/brcm/src/ControllerInitialisationPluginImpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bthci/hci2implementations/initialisors/brcm/src/ControllerInitialisationPluginImpl.cpp	Wed Jul 28 17:24:32 2010 +0100
@@ -0,0 +1,971 @@
+// 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 "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:
+//
+
+/**
+ @file
+ @internalComponent
+*/
+#include <bluetooth/hcicommandQueue.h>
+#include "broadcomcontrollerinitialisor.h"
+#include "controllerinitialisationpluginimpl.h"
+
+#include <bluetooth/hci/vendordebugcommand.h>
+#include <bluetooth/hci/controllerinitialisationobserver.h>
+
+
+#include <bluetooth/hci/commandcompleteevent.h>
+
+#include <bluetooth/hci/vendordebugcompleteevent.h>
+
+#include <bluetooth/hci/hctlinterface.h>
+
+#include <bluetooth/hci/corehci.h>
+
+#include <bluetooth/logger.h>
+#include <e32debug.h>
+#include <CIniData.h>
+
+#define INITIALISOR_BCM_LOGGER
+#define BCM_TRANSPORT
+#define UPDATEBAUDRATE_AFTER_PRD
+
+#ifdef INITIALISOR_BCM_LOGGER
+#define INITIALISOR_BCM_LOG(A)		RDebug::Print(A);
+#define INITIALISOR_BCM_LOG2(A,B)	RDebug::Print(A,B);
+#define INITIALISOR_BCM_LOG3(A,B,C)		RDebug::Print(A,B,C);
+#else
+#define INITIALISOR_BCM_LOG(A)
+#define INITIALISOR_BCM_LOG2(A,B)
+#define INITIALISOR_BCM_LOG3(A,B,C)
+#define INITIALISOR_BCM_LOG4(A,B,C,D)
+#endif
+
+const TUint32 BCM2048_RAM_LOCATION = 0x00085D00;
+const TUint32 BCM4325_RAM_LOCATION = 0x00086800;
+const TUint32 BCM2046_RAM_LOCATION = 0x00086800 ; //0x00087AC8;
+
+TUint32 KDestRamLocation = BCM2048_RAM_LOCATION;	// by default this location is for BCM2048
+// 50 mstimer.
+const TInt KMiniDriverToPatchRamTimerDuration = 50000;		// 50000;
+const TInt KEndDelayTimerDuration = 750000;		//250000;
+
+#define BAUDRATE_921600		921600
+#define BAUDRATE_115200		115200
+#define BAUDRATE_57600		BAUDRATE_921600		// for now we map the BR 57600 to 921600
+#define UART_24MHZ_CLOCK	24000000
+
+TInt iBaudRate = BAUDRATE_115200;		// default baudrate
+TInt iBaudRateAfter = BAUDRATE_115200;		// default baudrate
+TInt iUartClock = UART_24MHZ_CLOCK;		// default baudrate
+
+#ifdef BCM_TRANSPORT
+_LIT(KDefaultIniFileName, "hctl_broadcom.ini");
+#else
+_LIT(KDefaultIniFileName, "hctl_uart_original.ini");
+#endif
+
+_LIT(KConfigFileFileFormat, "%S%S");
+#if 0
+_LIT(KDefaultConfigFileFileFormat, "%S%S.bin");
+#else
+_LIT(KDefaultConfigFileFileFormat, "%S%S.hcd");
+#endif
+_LIT(KDefaultConfigFileName, "BCM2046B1");
+_LIT(KDefaultConfigFilePath, "z:\\private\\101f7989\\Bluetooth\\");
+
+_LIT(KGlobalReadySemName, "BCM_BT_READY_010155");
+//RSemaphore BCM_DriverReadySem;
+
+#ifdef __FLOG_ACTIVE
+_LIT8(KLogComponent, LOG_COMPONENT_INITIALISOR_BROADCOM);
+//_LIT8(KLogComponent, "InitBRCM");
+#endif
+
+
+
+/*static*/ CControllerInitialisationPluginImpl* CControllerInitialisationPluginImpl::NewL()
+	{
+	LOG_STATIC_FUNC
+
+	CControllerInitialisationPluginImpl* self = new (ELeave) CControllerInitialisationPluginImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CControllerInitialisationPluginImpl::~CControllerInitialisationPluginImpl()
+	{
+	LOG_FUNC
+	
+	// Delete async CallBacks.	If running, these should be cancelled by the
+	// d'tor of CAsyncOneShot.
+	delete iAsyncCallBackForPostReset;
+	delete iCConfigFileDownload;
+	delete iMiniDrive2ConfigFileTimer;
+	}
+
+void CControllerInitialisationPluginImpl::ConstructL()
+	{
+	LOG_FUNC
+	
+	// Add Async Callbacks	
+	TCallBack postResetCallBack(AsyncCallBackForPostReset, this);
+	iAsyncCallBackForPostReset = new (ELeave)CAsyncCallBack(postResetCallBack, CActive::EPriorityStandard); 
+	iMiniDrive2ConfigFileTimer = CConfigFileTimer::NewL(*this);	
+	}
+
+// Protected constructor.
+CControllerInitialisationPluginImpl::CControllerInitialisationPluginImpl()
+	{
+	LOG_FUNC
+
+	}
+
+/*virtual*/ void CControllerInitialisationPluginImpl::MciiPreResetCommand()
+	{
+	LOG_FUNC
+
+	__ASSERT_DEBUG(iControllerInitialisationObserver, PANIC(KBroadcomControllerInitialisorPanic, ENullInitialisationObserver));
+	// Do any pre-reset initialisation...
+#ifndef __WINSCW__
+
+	INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : Set Initial BaudRate to %d before reset"), iBaudRate)
+    
+	MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+	__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+	hctlConfigInterface->MhciUpdateBaudRate(iBaudRate);
+#endif
+	
+	INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : call McioPreResetCommandComplete(KErrNone)"))
+	// Inform stack that we have finished
+	iControllerInitialisationObserver->McioPreResetCommandComplete(KErrNone);
+	
+	}
+/*virtual*/ TAny* CControllerInitialisationPluginImpl::Interface(TUid aUid)
+	{
+	LOG_FUNC
+
+	TAny* ret = NULL;
+	switch(aUid.iUid)
+		{
+		case KControllerInitialisationInterfaceUid:
+			ret = reinterpret_cast<TAny*>(static_cast<MControllerInitialisationInterface*>(this));
+			break;
+
+		default:
+			break;
+		};
+
+	return ret;
+	}
+
+/*static*/ TInt CControllerInitialisationPluginImpl::AsyncCallBackForPostReset(TAny* aInitPlugin)
+	{
+	LOG_STATIC_FUNC
+
+	INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : CControllerInitialisationPluginImpl::AsyncCallBackForPostReset(TAny* aInitPlugin)"))
+
+	CControllerInitialisationPluginImpl* initPlugin = static_cast<CControllerInitialisationPluginImpl*>(aInitPlugin);
+	initPlugin->DoPostReset();
+	return EFalse;	// Don't call back any more.
+	}
+
+void CControllerInitialisationPluginImpl::InitialiseAndLoadMiniDriver()
+	{
+	LOG_FUNC
+
+	CVendorDebugCommand* cmd = NULL;
+	TInt err = KErrNone;
+
+	INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : InitialiseAndLoadMiniDriver()"))
+
+	// Chinda - Check for specific patch ram file in patch_ram section in hctl_bcm.ini file
+	TFileName fileName;
+	CIniData* pIniFile = NULL;
+	
+	TName name;
+	
+	name.Copy(KDefaultConfigFilePath);
+	name.Append(KDefaultIniFileName);
+	
+	_LIT(KFileHcdExtension,"*.hcd");
+	_LIT(KFileBinExtension,"*.bin");
+	
+	_LIT(KPatchramSection, "patch_ram");
+	_LIT(KPatchramPath, "path");
+	_LIT(KPatchramFile, "file");
+	_LIT(KPatchramLocation, "location");
+	TInt iRamLocation;	
+
+	
+	TRAP(err, pIniFile = CIniData::NewL(name));
+	if (err != KErrNone)
+		{
+		// Attempt to open the config file.
+		fileName.Format(KDefaultConfigFileFileFormat,&KDefaultConfigFilePath, &KDefaultConfigFileName);
+		iBaudRate = BAUDRATE_115200;
+		iBaudRateAfter = BAUDRATE_115200;
+		} 
+	else
+		{
+		// First read COM port and baudrate
+		if (pIniFile)
+			{
+			_LIT(KCOMPortSection, "hctl");
+			_LIT(KCOMBaudRate, "baud_rate");
+			_LIT(KCOMBaudRateAfter, "functional_baud_rate");
+			_LIT(KCOMUARTClock, "uart_clock");
+			
+			if (!pIniFile->FindVar(KCOMPortSection, KCOMBaudRate, iBaudRate))
+				{
+				iBaudRate = BAUDRATE_115200;
+				}
+
+			if (!pIniFile->FindVar(KCOMPortSection, KCOMBaudRateAfter, iBaudRateAfter))
+				{
+					iBaudRateAfter = BAUDRATE_115200;
+				}
+			if (!pIniFile->FindVar(KCOMPortSection, KCOMUARTClock, iUartClock))
+				{
+					iUartClock = UART_24MHZ_CLOCK;
+				}
+
+			TPtrC PathText;
+			TPtrC FileText;			
+		
+			//TBufC8<256> strFileExtension;
+
+			if (!pIniFile->FindVar(KPatchramSection, KPatchramPath, PathText))
+				{
+				PathText.Set(KDefaultConfigFilePath);
+				}
+#if 1
+			if (!pIniFile->FindVar(KPatchramSection, KPatchramFile, FileText))
+				{
+				FileText.Set(KDefaultConfigFileName);
+				fileName.Format(KDefaultConfigFileFileFormat,&PathText, &FileText);					
+				}
+			else
+				{
+				fileName.Format(KConfigFileFileFormat,&PathText, &FileText);
+				}
+			}
+		else
+			{
+			//FileText.Set(KDefaultConfigFileName);
+			fileName.Format(KDefaultConfigFileFileFormat,&KDefaultConfigFilePath, &KDefaultConfigFileName);
+			// ADD EXTENSION CHECK HERE
+			}
+		
+		// Check if we have an hcd file to download
+		if(fileName.Match(KFileHcdExtension) != KErrNotFound)
+			{
+			iFileFormat = EHcdFileFormat;
+			delete pIniFile;
+			}
+		else
+			{
+			// Check if we have a binary file to download
+			if(fileName.Match(KFileBinExtension) != KErrNotFound)
+				{
+				iFileFormat = EBinFileFormat;
+				// check for ram location in ini file
+				if (pIniFile->FindVar(KPatchramSection, KPatchramLocation, iRamLocation) != EFalse)
+					KDestRamLocation = iRamLocation;
+				else if (fileName.Find(_L("2048")) != KErrNotFound)
+					KDestRamLocation = BCM2048_RAM_LOCATION;
+				else if (fileName.Find(_L("4325")) != KErrNotFound)
+					KDestRamLocation = BCM4325_RAM_LOCATION;
+				else if (fileName.Find(_L("2046")) != KErrNotFound)
+					KDestRamLocation = BCM2046_RAM_LOCATION;
+				delete pIniFile;
+				}
+			else	//Unknown file type SHOULD NEVER FALL IN THIS CONDITION
+				{
+					iInitState = EIdle;
+					MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+					__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+					hctlConfigInterface->MhciSetInitPluginState(EIdle);
+					
+					iFileFormat = EUnknownFileFormat;
+					delete pIniFile;
+					return;
+				}			
+			}
+		}			
+			
+#else
+		
+		if (!pIniFile->FindVar(KPatchramSection, KPatchramFile, FileText))
+			{
+			FileText.Set(KDefaultConfigFileName);
+			fileName.Format(KDefaultConfigFileFileFormat,&PathText, &FileText);
+			}
+		else
+			{
+			fileName.Format(KConfigFileFileFormat,&PathText, &FileText);
+			}
+
+		// check for ram location in ini file
+		if (pIniFile->FindVar(KPatchramSection, KPatchramLocation, iRamLocation) != EFalse)
+			KDestRamLocation = iRamLocation;
+		else if (fileName.Find(_L("2048")) != KErrNotFound)
+			KDestRamLocation = BCM2048_RAM_LOCATION;
+		else if (fileName.Find(_L("4325")) != KErrNotFound)
+			KDestRamLocation = BCM4325_RAM_LOCATION;
+		else if (fileName.Find(_L("2046")) != KErrNotFound)
+			KDestRamLocation = BCM2046_RAM_LOCATION;
+		delete pIniFile;
+		}
+	else
+		{
+		fileName.Format(KDefaultConfigFileFileFormat,&KDefaultConfigFilePath, &KDefaultConfigFileName);
+		}
+	
+	}
+		
+			
+#endif
+			
+				
+	// Open the config file 
+	TRAP(err, iCConfigFileDownload = CConfigFileDownload::NewL(fileName));
+	
+	if (err != KErrNone)
+		{
+		iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+		iInitState = EIdle;
+		MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+		__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+		hctlConfigInterface->MhciSetInitPluginState(EIdle);
+
+		
+		}
+	else
+		{
+		// initiate Dwl config file
+		TRAP(err, cmd = CVendorDebugCommand::NewL(KHciVSDownloadMiniDriver));
+		if (err == KErrNone)
+			{
+			TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+			if(err != KErrNone)
+				{
+				// Inform the stack of the initialisation status.
+				iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+				iInitState = EIdle;
+				MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+				__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+				hctlConfigInterface->MhciSetInitPluginState(EIdle);
+				}
+			else
+				{
+				if(iFileFormat == EBinFileFormat)
+					{
+					iDestRam = KDestRamLocation;
+					iTxPatchLength = 0;
+					}
+				iInitState = EloadingMiniDriver;
+				MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+				__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+				hctlConfigInterface->MhciSetInitPluginState(EloadingMiniDriver);
+
+				}
+			}
+		else
+			{
+			iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+			iInitState = EIdle;
+			MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+			__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+			hctlConfigInterface->MhciSetInitPluginState(EIdle);
+			}
+		}
+	}
+
+
+void CControllerInitialisationPluginImpl::DoPostReset()
+	{
+	LOG_FUNC
+
+	INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : CControllerInitialisationPluginImpl::DoPostReset()"))
+
+	InitialiseAndLoadMiniDriver();
+
+	}
+
+/*virtual*/ void CControllerInitialisationPluginImpl::MciiPostResetCommand()
+	{
+	LOG_FUNC
+
+	__ASSERT_DEBUG(iControllerInitialisationObserver, PANIC(KBroadcomControllerInitialisorPanic, ENullInitialisationObserver));
+
+	// Use async callback
+	iAsyncCallBackForPostReset->CallBack();
+	}
+
+void CControllerInitialisationPluginImpl::HandleVendorSpecificCompleteEvent(const TVendorDebugCompleteEvent& aEvent)
+	{
+	LOG_FUNC
+	
+	CVendorDebugCommand* cmd = NULL;
+	TInt err = KErrNone;
+	THCIErrorCode hcierr = EOK;
+	
+
+	switch(iInitState)
+		{
+		
+		case EloadingMiniDriver:
+			{	    			    	
+			if (aEvent.CommandOpcode() == KHciVSDownloadMiniDriver )
+				{
+				INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : HCI VSC Download Mini Driver event (%04x)"), aEvent.CommandOpcode())
+
+				hcierr = aEvent.ErrorCode();
+				if (hcierr == EOK)
+					{
+				   	// Delay before actual patch ram download
+				   	iMiniDrive2ConfigFileTimer->Start(KMiniDriverToPatchRamTimerDuration);
+				   	if(iFileFormat == EBinFileFormat)
+				   		{
+						iInitState = EMiniDrvToBinConfigFileDelay;
+						MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+						__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+						hctlConfigInterface->MhciSetInitPluginState(EMiniDrvToBinConfigFileDelay);
+				   		}
+				   	else if(iFileFormat == EHcdFileFormat)
+				   		{
+						iInitState = EMiniDrvToHcdConfigFileDelay;	
+						MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+						__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+						hctlConfigInterface->MhciSetInitPluginState(EMiniDrvToHcdConfigFileDelay);
+				   		}
+					}
+				}
+			}
+			break;
+			
+		case ELoadingHcdConfigFileData:
+			{
+			INITIALISOR_BCM_LOG(_L("WRITE RAM COMPLETE EVENT"))
+
+			if (aEvent.CommandOpcode() == KHciVSWriteRam )
+				{
+				hcierr = aEvent.ErrorCode();
+				if (hcierr == EOK)
+					{
+					THCIOpcode CommandOpcode;
+					TUint8 DataChunkLen = 0;			
+				
+					iCConfigFileDownload->ReadCommandOpcode(CommandOpcode);
+				
+					TRAP(err, cmd = CVendorDebugCommand::NewL(CommandOpcode));
+					if (err == KErrNone)	
+						{
+						TDes8& cmdData = cmd->Command();
+				
+						iCConfigFileDownload->ReadDataChunkLen(DataChunkLen);
+										
+						if(DataChunkLen != 0)
+							{
+							TBuf8<4> AddressBuf;
+							TBuf8<KHcdConfigFileChunkSize> patchRamData;
+							if(CommandOpcode == KHciVSLaunchRam)
+								{
+								
+								err = iCConfigFileDownload->ConfigFileSendData(patchRamData,DataChunkLen);
+								if (KErrNone == err)
+									{
+									cmd->Reset(KHciVSLaunchRam);
+									cmdData.Append(patchRamData);
+									INITIALISOR_BCM_LOG(_L("LAUNCH RAM"))
+									iInitState = ELoadingconfigFileDataDone;
+									TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+									
+									MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+									__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+									hctlConfigInterface->MhciSetInitPluginState(ELoadingconfigFileDataDone);
+									}
+								}
+							else
+								{
+								err = iCConfigFileDownload->SetDataChunkAddress(AddressBuf);
+					
+								if (KErrNone == err)
+									{
+									cmdData.FillZ(4);
+									cmdData[0] = AddressBuf[0];
+									cmdData[1] = AddressBuf[1];
+									cmdData[2] = AddressBuf[2];
+									cmdData[3] = AddressBuf[3];
+																
+									err = iCConfigFileDownload->ConfigFileSendData(patchRamData,(DataChunkLen-4));
+									
+									if (KErrNone == err)
+										{
+										cmdData.Append(patchRamData);
+										TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+										INITIALISOR_BCM_LOG(_L("WRITE RAM"))						
+										}
+									}
+								}
+							}
+						}
+						
+					if(KErrNone != err)
+						{
+							// something went wrong during the file read
+							delete cmd; //command was not sent due to read file error
+							
+							// Inform the stack of the initialisation status.
+							iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+							iInitState = EIdle;
+							MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+							__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+							hctlConfigInterface->MhciSetInitPluginState(EIdle);
+						}					
+					}//hcierr == EOK
+				}//aEvent.CommandOpcode() == KHciVSWriteRam
+			else
+				{
+				err = KErrGeneral; //complete event is not the expected one
+				}
+			}
+			break;
+			
+		case ELoadingBinConfigFileData:
+			{
+			if (aEvent.CommandOpcode() == KHciVSWriteRam )
+				{
+				hcierr = aEvent.ErrorCode();
+				if (hcierr == EOK)
+				    {
+		    	    //Update the Destination Ram address
+		    		iDestRam = iDestRam + iTxPatchLength;
+		    		
+				    TRAP(err, cmd = CVendorDebugCommand::NewL(KHciVSWriteRam));
+					if (err == KErrNone)	
+						{
+						TBuf8<KConfigFileChunkSize> patchRamData;
+						
+						// Try to read config file data
+						err = iCConfigFileDownload->ConfigFileSendDataChunk(patchRamData);
+						if (KErrEof == err)
+							{
+							// EOF reached
+							iInitState = ELoadingconfigFileDataDone;
+							
+							MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+							__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+							hctlConfigInterface->MhciSetInitPluginState(ELoadingconfigFileDataDone);
+							
+							// Launch Patch ram
+							cmd->Reset(KHciVSLaunchRam); 
+							// reuse allocated cmd
+							
+							TDes8& cmdData = cmd->Command();
+
+							cmdData.FillZ(4);
+							cmdData[0] = 0xFF;
+							cmdData[1] = 0xFF;
+							cmdData[2] = 0xFF;
+							cmdData[3] = 0xFF;
+							
+							TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+							// Wait for the launch config file complete event 
+							
+							}
+					    else if (KErrNone == err) 
+					    	{					    										
+
+					    		TDes8& cmdData = cmd->Command();
+
+								INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : HCI VSC Write RAM event (%04x)"), aEvent.CommandOpcode())
+
+								cmdData.FillZ(4);
+								cmdData[0] =  (iDestRam)        & 0xFF;
+								cmdData[1] = ((iDestRam) >>  8) & 0xFF;
+								cmdData[2] = ((iDestRam) >> 16) & 0xFF;
+								cmdData[3] = ((iDestRam) >> 24) & 0xFF;
+
+								cmdData.Append(patchRamData);
+								
+					    		// 	Send another chunk of config file data
+								TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+								if (KErrNone == err)
+									{
+									// Update length of Tx'd data
+									iTxPatchLength = patchRamData.Length();
+									iInitState = ELoadingBinConfigFileData;
+									
+									MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+									__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+									hctlConfigInterface->MhciSetInitPluginState(ELoadingBinConfigFileData);
+									// Wait for the VSC complete event
+									}
+					    	}
+					    else if (KErrNone != err)
+					    	{
+					    	// something went wrong during the file read
+					    	delete cmd; //command was not sent due to read file error
+					    	}
+						}
+				    }
+				else
+					{
+					err = KErrGeneral; //complete event is not the expected one
+					}
+
+				if (err != KErrNone)
+					{
+					iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+					iInitState = EIdle;
+					MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+					__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+					hctlConfigInterface->MhciSetInitPluginState(EIdle);
+					}
+				}
+			}
+			break;
+			
+		case ELoadingconfigFileDataDone:
+			{
+			INITIALISOR_BCM_LOG(_L("LAUNCH RAM COMPLETE EVENT"))
+			if (aEvent.CommandOpcode() == KHciVSLaunchRam)
+				{
+				INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : HCI VSC Launch RAM event (%04x)"), aEvent.CommandOpcode())
+
+				hcierr = aEvent.ErrorCode();
+				if (hcierr == EOK)
+					{
+				    iMiniDrive2ConfigFileTimer->Start(KEndDelayTimerDuration);
+				    iInitState = EWaitEndDelay;
+				    
+					MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+					__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+					hctlConfigInterface->MhciSetInitPluginState(EWaitEndDelay);
+					}
+				}
+			}
+			break;
+			
+			
+		case EWaitUpdateBaudRateAfterPrm:
+			{
+#ifdef UPDATEBAUDRATE_AFTER_PRD
+			INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : VSC Update BaudRate event (%04x)"), aEvent.CommandOpcode())
+
+			MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+			if (aEvent.CommandOpcode() == KHciVSUpdateUartHCIBaudRate)
+				{
+				hcierr = aEvent.ErrorCode();
+				if (hcierr == EOK)
+					{
+					INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : Change UART BaudRate to %d bps after launching RAM"), iBaudRateAfter)
+
+					err = hctlConfigInterface->MhciUpdateBaudRate(iBaudRateAfter);
+					}
+				else
+					{
+					err = KErrGeneral;
+					}		
+				}
+			else			
+				{
+				err = KErrGeneral;
+				}
+#else
+			err = KErrNone;
+#endif			
+			// BCM initialisation is completed- resume generic init
+			iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+			iInitState = EIdle;
+			hctlConfigInterface->MhciSetInitPluginState(EIdle);
+			
+			//iInitState = EReset;	
+			// Signal to everyone that we are ready 
+			//BCM_DriverReadySem.CreateGlobal(KGlobalReadySemName,1,EOwnerProcess);
+			}
+			break;
+			
+		default:
+		INITIALISOR_BCM_LOG2(_L("Broadcom: CControllerInitialisationPluginImpl::HandleVendorSpecificCompleteEvent - Default state (%d)"),iInitState)
+
+			break;
+	    }
+	}
+
+/*virtual*/ void CControllerInitialisationPluginImpl::ConfigFileTimerExpired()
+	{
+	LOG_FUNC
+	
+	TInt err = KErrNone;
+	CVendorDebugCommand* cmd = NULL;
+
+	switch(iInitState)
+		{
+		case EMiniDrvToHcdConfigFileDelay:
+			{
+			THCIOpcode CommandOpcode;
+			TUint8 DataChunkLen = 0;			
+			
+			INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : Start patch ram download"))
+			
+			iCConfigFileDownload->ReadCommandOpcode(CommandOpcode);
+			
+			TRAP(err, cmd = CVendorDebugCommand::NewL(CommandOpcode));
+			TDes8& cmdData = cmd->Command();
+			
+			iCConfigFileDownload->ReadDataChunkLen(DataChunkLen);
+									
+			if(DataChunkLen != 0)
+				{
+				//TBuf8<4> AddressBuf;
+				TBuf8<4> AddressBuf;
+				
+				err = iCConfigFileDownload->SetDataChunkAddress(AddressBuf);
+				if (KErrNone == err)
+					{
+					cmdData.FillZ(4);
+					cmdData[0] = AddressBuf[0];
+					cmdData[1] = AddressBuf[1];
+					cmdData[2] = AddressBuf[2];
+					cmdData[3] = AddressBuf[3];
+				
+					TBuf8<KHcdConfigFileChunkSize> HcdpatchRamData;
+					
+					// Substract 4 from DataChunkLen for download address
+					err = iCConfigFileDownload->ConfigFileSendData(HcdpatchRamData,(DataChunkLen-4));
+					if (KErrNone == err)
+						{
+						cmdData.Append(HcdpatchRamData);
+						TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+						INITIALISOR_BCM_LOG(_L("FIRST WRITE RAM"))
+						if (KErrNone == err)
+							{
+							iInitState = ELoadingHcdConfigFileData;
+							
+							MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+							__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+							hctlConfigInterface->MhciSetInitPluginState(ELoadingHcdConfigFileData);
+							}
+						}
+					}
+
+				if(KErrNone != err)
+					{
+					// something went wrong during the file read
+					delete cmd; //command was not sent due to read file error
+						
+					// Inform the stack of the initialisation status.
+					iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+					iInitState = EIdle;
+					MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+					__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+					hctlConfigInterface->MhciSetInitPluginState(EIdle);
+					}
+				
+				}
+			}
+			break;
+			
+		case EMiniDrvToBinConfigFileDelay:
+			{
+			INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : Waiting for Mini download Driver"))
+			// initiate actual downloading of the Config file
+		    TRAP(err, cmd = CVendorDebugCommand::NewL(KHciVSWriteRam));
+			if (err == KErrNone)	
+				{				
+				TBuf8<KConfigFileChunkSize> patchRamData;
+				TDes8& cmdData = cmd->Command();
+
+				err = iCConfigFileDownload->ConfigFileSendDataChunk(patchRamData);
+				
+				// Start sending config file data
+				if (KErrNone == err)
+					{
+					cmdData.FillZ(4);
+					cmdData[0] =  (KDestRamLocation)        & 0xFF;
+					cmdData[1] = ((KDestRamLocation) >>  8) & 0xFF;
+					cmdData[2] = ((KDestRamLocation) >> 16) & 0xFF;
+					cmdData[3] = ((KDestRamLocation) >> 24) & 0xFF;
+					
+					cmdData.Append(patchRamData);
+					TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+					if (KErrNone == err)
+						{
+						// Update length of Tx'd data
+						iTxPatchLength = iTxPatchLength + patchRamData.Length();
+						iInitState = ELoadingBinConfigFileData;
+						
+						MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+						__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+						hctlConfigInterface->MhciSetInitPluginState(ELoadingBinConfigFileData);
+						// Wait for the VSC complete event
+						}
+					}
+				else
+					{
+			    	// something went wrong during the file read
+			    	delete cmd; //command was not sent due to read file error
+					}
+				}
+			
+				
+				if (KErrNone != err)
+					{
+					// Inform the stack of the initialisation status.
+					iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+					iInitState = EIdle;
+					
+					MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+					__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+					hctlConfigInterface->MhciSetInitPluginState(EIdle);
+					}
+				}
+			break;
+			
+		case EWaitEndDelay:
+			{
+#ifdef UPDATEBAUDRATE_AFTER_PRD			
+			// BCM initialisation is completed- resume generic init
+			INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : END Initialisation steps (PatchRAM downloaded OK))"))
+			
+			// Request baud rate update.
+			CVendorDebugCommand* cmd = NULL;
+			TRAP(err, cmd = CVendorDebugCommand::NewL(KHciVSUpdateUartHCIBaudRate));
+			TDes8& cmdData = cmd->Command();
+
+			if(err == KErrNone)
+			{	
+				INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : Change BaudRate to %d bps after launchRAM"), iBaudRateAfter)
+				INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : UART Clock is %d"), iUartClock)
+				cmdData.FillZ(6);
+				cmdData[2] = iBaudRateAfter 		& 0xFF;
+				cmdData[3] = (iBaudRateAfter >> 8)	& 0xFF;
+				cmdData[4] = (iBaudRateAfter >> 16)	& 0xFF;
+				cmdData[5] = (iBaudRateAfter >> 24)	& 0xFF;
+				
+				TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
+				// error handling if the method above fails is handled in at the end of the function
+//				INITIALISOR_BCM_LOG2(_L("Initialisor_Broadcom : Send %x %x %x %x %x %x after launchRAM OK"), iBaudRateAfter)
+				RDebug::Print(_L("Initialisor_Broadcom : Send %x %x %x %x %x %x after launchRAM OK"), 
+						cmdData[0],
+						cmdData[1],
+						cmdData[2],
+						cmdData[3],
+						cmdData[4],
+						cmdData[5]);
+				iInitState = EWaitUpdateBaudRateAfterPrm;
+				
+				MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+				__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+				hctlConfigInterface->MhciSetInitPluginState(EWaitUpdateBaudRateAfterPrm);
+			}
+#else
+			iInitState = EWaitUpdateBaudRateAfterPrm;
+			MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+			__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+			hctlConfigInterface->MhciSetInitPluginState(EWaitUpdateBaudRateAfterPrm);
+			
+			iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+#endif
+
+
+			if(err != KErrNone)
+			{
+				iInitState = EIdle;	
+				
+				MHctlBcmConfigInterface* hctlConfigInterface = static_cast<MHctlBcmConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlBcmConfigInterfaceUid)));	
+				__ASSERT_DEBUG(hctlConfigInterface, PANIC(KBroadcomControllerInitialisorPanic, EConfigInterfaceNull));			
+				hctlConfigInterface->MhciSetInitPluginState(EIdle);
+				
+				iControllerInitialisationObserver->McioPostResetCommandComplete(err);
+			}
+			
+			// Signal to everyone that we are ready 
+			//BCM_DriverReadySem.CreateGlobal(KGlobalReadySemName,1,EOwnerProcess);
+
+			}
+			break;
+			
+		default:
+		break;
+		}
+	}
+
+
+/*virtual*/ void CControllerInitialisationPluginImpl::MciiSetHCICommandQueue(MHCICommandQueue& aHCICommandQueue)
+	{
+	LOG_FUNC
+
+	__ASSERT_DEBUG(iHCICommandQueue == 0, PANIC(KBroadcomControllerInitialisorPanic, EHciCommandQueueOverwritten));
+	iHCICommandQueue = &aHCICommandQueue;
+	}
+
+/*virtual*/ void CControllerInitialisationPluginImpl::MciiSetControllerInitialisationObserver(MControllerInitialisationObserver& aObserver)
+	{
+	LOG_FUNC
+
+	__ASSERT_DEBUG(iControllerInitialisationObserver == 0, PANIC(KBroadcomControllerInitialisorPanic, EInitialisationObserverOverwritten));
+	iControllerInitialisationObserver = &aObserver;
+	}
+void CControllerInitialisationPluginImpl::MhcqcCommandErrored(TInt aErrorCode,
+					  										  const CHCICommandBase* /*aCommand*/)
+	{
+	LOG_FUNC
+
+	switch(iInitState)
+		{
+		default:
+			PANIC(KBroadcomControllerInitialisorPanic, EInvalidInitialisorState);
+			break;
+		};
+	}
+	
+void CControllerInitialisationPluginImpl::MhcqcCommandEventReceived(const THCIEventBase& aEvent,
+																	const CHCICommandBase* /*aRelatedCommand*/)
+	{
+	LOG_FUNC
+
+	if (aEvent.EventCode() == ECommandCompleteEvent)
+		{
+		// Switch on the opcode.
+		THCICommandCompleteEvent& event = THCICommandCompleteEvent::Cast(aEvent);
+		switch(event.CommandOpcode())
+			{
+
+			default:
+				// Check for VS commands.
+				if((event.CommandOpcode() & KVendorDebugOGF) == KVendorDebugOGF)
+					{
+					TVendorDebugCompleteEvent& vEvent = TVendorDebugCompleteEvent::Cast(event);
+					HandleVendorSpecificCompleteEvent(vEvent);
+					}						
+				break;	
+			}
+		}
+	}	
+
+/*virtual*/ void CControllerInitialisationPluginImpl::MciiSetCoreHci(MCoreHci& aCoreHci)
+	{
+	LOG_FUNC
+
+	INITIALISOR_BCM_LOG(_L("Initialisor_Broadcom : Setting Core HCI"))
+	__ASSERT_DEBUG(iCoreHci == 0, PANIC(KBroadcomControllerInitialisorPanic, ECoreHciOverwritten));
+    iCoreHci = &aCoreHci;
+	}
+