1 // Copyright (c) 1997-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 "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 // AT Initialisation

    15 // 

    16 //

    17 

    18 #include <commsdattypesv1_1.h>

    19 #include <cdblen.h>

    20 #include "ATINIT.H"

    21 #include "NOTIFY.H"

    22 #include "mSLOGGER.H"

    23 #include "PHONE.H"

    24 #include "CALL.H"

    25 #include "ATNOCARR.H"

    26 #include "mPHBOOK.H"

    27 #include "ATIO.H"

    28 #include "Matstd.h"

    29 #include "ATHANGUP.H"

    30 #include <etelqos.h>

    31 

    32 _LIT8(KTestPhoneBookStorage,"AT+CPBS=?");

    33 _LIT8(KSetExtendedCallIndicationCommand,   "AT+CRC=1\r");

    34 _LIT8(KClearUnsolicitedNetworkRegistration, "AT+CREG=0\r");

    35 _LIT8(KSetUnsolicitedNetworkRegistration2,  "AT+CREG=2\r");

    36 _LIT8(KSetUnsolicitedNetworkRegistration1,  "AT+CREG=1\r");

    37 _LIT8(KReadUnsolicitedNetworkRegistration,  "AT+CREG?\r");

    38 _LIT8(KGetCurrentOperatorCommand, "AT+COPS?\r");

    39 _LIT8(KGetBatteryInfoCommand, "AT+CBC\r");

    40 _LIT8(KGetSignalInfoCommand, "AT+CSQ\r");

    41 _LIT8(KOperatorResponse,"+COPS:");

    42 _LIT8(KGetServiceCentreAddressCommand,"AT+CSCA?\r");

    43 

    44 _LIT8(KSetUnsolicitedGPRSNetworkRegistration1,  "AT+CGREG=1\r");

    45 _LIT8(KSetECAMConfigCommand, "AT*ECAM=1\r");

    46 

    47 _LIT(KSpaceSeparator," ");

    48 

    49 _LIT8(KClassA,"A");

    50 _LIT8(KClassB,"B");

    51 _LIT8(KClassC,"C");

    52 _LIT8(KClassCG,"CG");

    53 _LIT8(KClassCC,"CC");

    54 _LIT16(KEricsson,"*ERICSSON*");

    55 

    56 const TInt KMaxNoRetries=3;

    57 

    58 const TUint KZeroChar='0';

    59 const TUint KOneChar='1';

    60 

    61 

    62 #ifdef __LOGDEB__

    63 _LIT8(KLogEntry,"CATInit::%S\t%S");

    64 #define LOCAL_LOGTEXT(function,text) {_LIT8(F,function);_LIT8(T,text);LOGTEXT3(KLogEntry,&F,&T);}

    65 #else

    66 #define LOCAL_LOGTEXT(function,text)

    67 #endif

    68 

    69 

    70 

    71 CATInit* CATInit::NewL(CATIO* aIo,CTelObject* aTelObject,CPhoneGlobals* aPhoneGlobals)

    72 	{

    73 	CATInit* self = new(ELeave) CATInit(aIo,aTelObject,aPhoneGlobals);

    74 	CleanupStack::PushL(self);

    75 	self->ConstructL();

    76 	CleanupStack::Pop();

    77 	return self;

    78 	}

    79 

    80 CATInit::CATInit(CATIO* aIo,CTelObject* aTelObject,CPhoneGlobals* aPhoneGlobals)

    81 	: CATBase(aIo,aTelObject,aPhoneGlobals)

    82 	{}

    83 

    84 void CATInit::ConstructL()

    85 	{

    86 	iEnumerate = CATSmsMemoryStorage::NewL(iIo, iTelObject, this, iPhoneGlobals);

    87 	}

    88 

    89 CATInit::~CATInit()

    90 	{

    91 	iIo->RemoveExpectStrings(this);

    92 	delete iEnumerate;

    93 	}

    94 

    95 void CATInit::StartInit(CATCommands* aPendingCommand,TTsyReqHandle aTsyReqHandle, TAny* aParams)

    96 	{

    97 	SetToNotInitialised();	

    98 	iPendingCommand = aPendingCommand;

    99 	iReqHandle = aTsyReqHandle;

   100 	iParams = aParams;

   101 	iCallInfo = aPendingCommand->CallInfo();	// iCallInfo is NULL if 

   102 												// aPendingCommand has no iCallInfo

   103 	iIo->Cancel();

   104 	iAttemptCnt=1;

   105 	InitAttempt();

   106 	}

   107 

   108 TBool CATInit::CheckActiveReqHandle(const TTsyReqHandle aTsyReqHandle)

   109 //

   110 // Check the Request against the current request handle

   111 //

   112 	{

   113 	if((iPhoneGlobals->iPhoneStatus.iInitStatus==EPhoneInitialising)&&

   114 	   (aTsyReqHandle==iReqHandle))

   115 		return ETrue;

   116 	else

   117 		return EFalse;

   118 	}

   119 

   120 void CATInit::StopInit(TTsyReqHandle aTsyReqHandle)

   121 	{

   122 	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle));

   123 	LOGTEXT(_L8("Cancelling Initialisation"));

   124 	iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneInitialiseCancelling;

   125 	iIo->SetTimeOut(this,KOneSecondPause);

   126 	}

   127 

   128 void CATInit::SpecialStart(TTsyReqHandle aTsyReqHandle)

   129 //

   130 //	If aTsyReqHandle is NULL, this is an Automatic Init with no ReqComplete to call

   131 //	Otherwise it is from CPhoneHayes::ControlledInitialise() which should be completed

   132 //

   133 	{

   134 	iReqHandle = aTsyReqHandle;

   135 	iPendingCommand = NULL;

   136 	iAttemptCnt=1;

   137 	InitAttempt();

   138 	}

   139 

   140 void CATInit::InitAttempt()

   141 	{

   142 	if (iPhoneGlobals->iPhoneStatus.iInitStatus == EPhoneInitialiseCancelling)

   143 		return;	// "initialise" may have been cancelled while we were waiting for the call back.

   144 

   145 	LOGTEXT2(_L8("Starting Initialisation Sequence, Attempt %d"),iAttemptCnt);

   146 	iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneInitialising;

   147 	iPhoneGlobals->iSmsPduModeSupported=EFalse;

   148 	TCommConfig aConfigPckg;

   149 	iIo->Cancel();

   150 	TInt ret = iPhoneGlobals->iConfiguration->PortConfig(aConfigPckg,EConfigTypePreInit);

   151 	if (ret==KErrNone)

   152 		ret = iIo->ConfigurePort(aConfigPckg);

   153 	if (ret)

   154 		{

   155 		Complete(ret);

   156 		return;

   157 		}

   158 	iIo->SetTimeOut(this,100);

   159 	iState=EShortTimeOutFix;

   160 	}

   161 	

   162 void CATInit::RetryOrFail(TBool aCommsErrorOccurred)

   163 	{

   164 	if (!aCommsErrorOccurred)

   165 		iIo->RemoveExpectStrings(this);	

   166 	iConnectExpectString = NULL;

   167 	iNoCarrierExpectString = NULL;

   168 	iOKExpectString = NULL;

   169 	iErrorExpectString = NULL;

   170 	if(++iAttemptCnt > (TUint)KMaxNoRetries)

   171 		{

   172 		LOGTEXT(_L8("Cannot Initialise"));

   173 		iIo->RemoveExpectStrings(this);

   174 		if (iPhoneGlobals->iPhoneStatus.iModemDetected != RPhone::EDetectedPresent)

   175 			Complete(KErrEtelModemNotDetected);

   176 		else

   177 			Complete(KErrEtelInitialisationFailure);

   178 		}

   179 	else

   180 		{

   181 		iIo->Cancel();

   182 		InitAttempt();

   183 		}	

   184 	}

   185 

   186 void CATInit::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)

   187 //

   188 //	CATIO removes expect strings in the event of an error from the port, so set ptrs to NULL.

   189 //	If error is KErrCommsFrame and this is the first attempt at initialising, give the modem

   190 //	benefit of the doubt and try again.

   191 //

   192 	{

   193 	if (aStatus==KErrCommsFrame && iAttemptCnt==1)

   194 		RetryOrFail(ETrue);

   195 	else

   196 		{

   197 		iNoCarrierExpectString = NULL;

   198 		iConnectExpectString = NULL;

   199 		iOKExpectString = NULL;

   200 		iErrorExpectString = NULL;

   201 		Complete(aStatus);

   202 		}

   203 	}

   204 

   205 void CATInit::ValidateATHExpectStringL()

   206 	{

   207 	if(iIo->FoundChatString()==iErrorExpectString)

   208 		{

   209 		LOGTEXT(_L8("Modem returned ERROR in response to command"));

   210 		User::Leave(KErrGeneral);

   211 		}

   212 	if(iIo->FoundChatString()==iNoCarrierExpectString)

   213 		{

   214 		LOGTEXT(_L8("Modem returned NO CARRIER in response to command"));

   215 		return;

   216 		}

   217 	if(iIo->FoundChatString()==iOKExpectString)

   218 		return;

   219 	LOGTEXT(_L8("Modem returned unexpected response to command"));

   220 	User::Leave(KErrUnknown);

   221 	}

   222 

   223 void CATInit::EventSignal(TEventSource aSource)

   224 	{

   225 	if(aSource==ETimeOutCompletion && iState==EWaitForDSR)

   226 		{

   227 		LOGTEXT(_L8("CATInit::EventSignal  Ignoring timeout during EWaitForDSR"));

   228 		iIo->WriteAndTimerCancel(this);

   229  		iIo->RemoveExpectStrings(this);

   230 		}

   231 	else if ((aSource==ETimeOutCompletion)

   232 	  &&(iPhoneGlobals->iPhoneStatus.iInitStatus != EPhoneInitialiseCancelling)

   233 	  &&(iState!=EATWaitForATCheckOK)&&(iState!=EShortTimeOutFix))

   234 		{

   235 		LOGTEXT(_L8("CATInit::EventSignal  Error during Initialisation Sequence"));

   236 		RetryOrFail();

   237 		return;

   238 		}

   239 	

   240 	if (iPhoneGlobals->iPhoneStatus.iInitStatus == EPhoneInitialiseCancelling)

   241 		{

   242 		if (aSource==EWriteCompletion)

   243 			{

   244 			iIo->SetTimeOut(this,KOneSecondPause);

   245 			}

   246 		if (aSource==EReadCompletion || aSource==ETimeOutCompletion)

   247 			{

   248 			LOGTEXT2(_L8("Entered InitCancelling with aSource=%d"),aSource);

   249 			iIo->WriteAndTimerCancel(this);

   250 			iIo->RemoveExpectStrings(this);

   251 			iOKExpectString=NULL;

   252 			iErrorExpectString=NULL;

   253 			iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneNotInitialised;

   254 			if (iPendingCommand)

   255 				{

   256 				if (iCallInfo)

   257 					REINTERPRET_CAST(CCallHayes*,iPendingCommand->Owner())->SetToIdle();

   258 				iPendingCommand->Owner()->ReqCompleted(iReqHandle,KErrCancel);

   259 				iPendingCommand=NULL;

   260 				}

   261 			else

   262 				{

   263 				iTelObject->ReqCompleted(iReqHandle,KErrCancel);

   264 				return;

   265 				}

   266 			if ((iCallInfo != NULL) && (iCallInfo->iClientPanicOccurred!=ENoPanicOccurred))

   267 				{

   268 				__ASSERT_DEBUG(iPendingCommand!=NULL,Panic(ERelinquishOwnershipWithNoCall));

   269 				iComplete = CCompleteRelinquish::New(iPendingCommand->Owner());

   270 				iComplete->SetWhichCompletion(iCallInfo->iClientPanicOccurred);

   271 				iComplete->Call();	// calls the AysncOneShot Relinquish completion function

   272 				iCallInfo->iClientPanicOccurred = ENoPanicOccurred;

   273 				}	

   274 			}

   275 		return;

   276 		}

   277 

   278 	switch(iState)

   279 		{

   280 	case EShortTimeOutFix:

   281 		//

   282 		//	Calling iIo->Start() synchronously inside the InitAttempt() function caused a 

   283 		//  hang when using IrDA on the ARM, and Netdial, as Netdial is in the ESock thread

   284 		//  and is blocking waiting for its RTelSubSession::Open() to complete, but iIo->Start()

   285 		//	calls C32 which calls ESock. So introduced this short time out.

   286 		//

   287 		//	Also retrieving the strings here at the start of the initialisation - the first

   288 		//	time we get back KErrAccessDenied for some reason.

   289 		//

   290 		{

   291 		iIo->Cancel();

   292 		iIo->Start(this);		// ramps up DTR

   293 		iIo->SetTimeOut(this,5 * KOneSecondPause);	// should be enough time for a battery-powered

   294 													// modem to initialise itself

   295 		__ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral));

   296 		iState=EWaitForDSR;

   297 		}

   298 		break;

   299 		

   300 	case EWaitForDSR:

   301  		// Do not assert aSource==EWriteCompletion as we could have got here with a ETimeOutCompletion

   302 		{

   303 		if (!(iIo->ReadPending()))		// Otherwise CATIO will queue a read on the way back down the stack anyway

   304 			iIo->Read();

   305 		Write(KAT2Command(),5);		// needs to be long because IR takes a while 

   306 		iState=EWaitForATHangUpWriteComplete;

   307 		}

   308 		break; //ATHcommand is now an AT. Introduced 23/03/99: Fix ER5-defect EDNJWAD-465K6M

   309 

   310 	case EWaitForATHangUpWriteComplete:

   311 		StandardWriteCompletionHandler(aSource,5);

   312 		if (!iNoCarrierExpectString)

   313 			iNoCarrierExpectString = iIo->AddExpectString(this,KNoCarrierString);

   314 		iState=EWaitForATHangUpOK;

   315 		break;

   316 

   317 	case EWaitForATHangUpOK:

   318 		{

   319 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   320 

   321 		// Fix defect CLE-4RGN8Z, NM, 9/01/01.

   322 		// Fix defect SIH-4UCMW9, that actually fixes the problem caused by

   323 		// previous CLE-4RGN8Z fix !  KAS 2/03/01 

   324 		if (iPhoneGlobals->iPhoneStatus.iModemDetected != RPhone::EDetectedPresent) 

   325 			{

   326 			iPhoneGlobals->iNotificationStore->CheckNotification(iTelObject,EPhoneDetected);

   327 			iPhoneGlobals->iPhoneStatus.iModemDetected = RPhone::EDetectedPresent;

   328 			}

   329 

   330 		TRAPD(ret,ValidateATHExpectStringL());

   331 		if (ret)

   332 			{

   333 			RetryOrFail();

   334 			break;

   335 			}

   336 		iIo->WriteAndTimerCancel(this);

   337 		RemoveStdExpectStrings();

   338 		iIo->RemoveExpectString(iConnectExpectString);

   339 		iConnectExpectString = NULL;

   340 		iIo->RemoveExpectString(iNoCarrierExpectString);

   341 		iNoCarrierExpectString=NULL;

   342 		TCommConfig aConfigPckg;

   343 		iIo->Cancel();

   344 		ret = iPhoneGlobals->iConfiguration->PortConfig(aConfigPckg,EConfigTypeInit);

   345 		if (ret==KErrNone)

   346 			ret = iIo->ConfigurePort(aConfigPckg);

   347 		if (ret)

   348 			{

   349 			Complete(ret);

   350 			return;

   351 			}

   352 

   353 		//

   354 		// iCallInfo is NULL if this hasn't been originated by a CCallHayes command,

   355 		// eg using CPhoneHayes::Init()

   356 		//

   357 		// Don't bother notifying about hook change here as it's likely only to be from 

   358 		// unknown to on.

   359 		//

   360 		iPhoneGlobals->iNotificationStore->CheckNotification(iTelObject,EBecomeIdle);

   361 		REINTERPRET_CAST(CPhoneHayes*,iTelObject)->SetHookStatus(RCall::EHookStatusOn);

   362 		iPhoneGlobals->iPhoneStatus.iMode = RPhone::EModeIdle;

   363 		TBuf8<KMaxLengthOfUserDefinedInitString> initCommand;

   364 			initCommand=KAT2Command;			

   365 		Write(initCommand,5);

   366 		iState=EWaitForModemInitWrite;

   367 		}

   368 		break;

   369 

   370 	case EWaitForModemInitWrite:

   371 		StandardWriteCompletionHandler(aSource,5);

   372 		iState=EWaitForModemInitOK;

   373 		break;

   374 

   375 	case EWaitForModemInitOK:

   376 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   377 			{

   378 			TInt ret(ValidateExpectString());

   379 			if (ret)

   380 				{

   381 				RetryOrFail();

   382 				break;

   383 				}

   384 			RemoveStdExpectStrings();

   385 			iIo->WriteAndTimerCancel(this);	

   386 			TPtrC8 atCheck(KAT2Command);		// modem may take time to complete user-defined

   387 											// Init string, so send an AT once and if this

   388 											// fails try again twice

   389 			Write(atCheck,5);

   390 			iState=EWaitForATCheckWrite;

   391 			}

   392 		break;

   393 

   394 	case EWaitForATCheckWrite:

   395 		StandardWriteCompletionHandler(aSource,5);

   396 		iState=EATWaitForATCheckOK;

   397 		break;

   398 

   399 	case EATWaitForATCheckOK:

   400 		{

   401 		if (aSource==ETimeOutCompletion)

   402 			{

   403 			RemoveStdExpectStrings();

   404 			if (iRetryCounter++ == (TUint)KMaxNoChecks)

   405 				{

   406 				iRetryCounter=0;

   407 				Complete(KErrTimedOut);

   408 				}

   409 			else

   410 				{

   411 				TPtrC8 atCheck(KAT2Command);

   412 				Write(atCheck,5);

   413 				iState=EWaitForATCheckWrite;

   414 				}

   415 			return;

   416 			}

   417 		TInt ret(ValidateExpectString());

   418 		if (ret)

   419 			{

   420 			RetryOrFail();

   421 			break;

   422 			}

   423 		RemoveStdExpectStrings();

   424 		WriteExpectingResults(KGetPhoneCapsCommand(),5);

   425 		iState=EWaitForATGetPhoneCapsWrite;

   426 		}

   427 		break;

   428 

   429 	case EWaitForATGetPhoneCapsWrite:

   430 		StandardWriteCompletionHandler(aSource,5);

   431 		iState=EWaitForATGetPhoneCapsOK;

   432 		break;

   433 

   434 	case EWaitForATGetPhoneCapsOK:

   435 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   436 			{

   437 			TInt ret(ValidateExpectString());

   438 			if(ret==KErrGeneral)

   439 				ParseAnErroredPhoneCaps();

   440 			else if(ret!=KErrNone)

   441 				{	

   442 				RetryOrFail();

   443 				break;

   444 				}

   445 			else

   446 				{

   447 				iIo->WriteAndTimerCancel(this);

   448 				TRAP(ret,ParsePhoneCapsL());

   449 				if (ret)

   450 					{	

   451 					iIo->RemoveExpectStrings(this);

   452 					Complete(KErrEtelInitialisationFailure);

   453 					break;

   454 					}

   455 				}

   456 			RemoveStdExpectStrings();

   457 			TBuf8<KCommsDbSvrMaxFieldLength> echoSetting;

   458 			TBuf8<KCommsDbSvrMaxFieldLength> quietSetting;

   459 			TBuf8<KCommsDbSvrMaxFieldLength> verboseSetting;

   460 			ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameEchoOff),echoSetting);

   461 			if (ret==KErrNone)

   462 				{

   463 				ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameQuietOff),quietSetting);

   464 				}

   465 			if (ret==KErrNone)

   466 				{

   467 				ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameVerboseText),verboseSetting);

   468 				}

   469 			if (ret)

   470 				{

   471 				iIo->RemoveExpectStrings(this);

   472 				Complete(ret);

   473 				break;

   474 				}

   475 			iTxBuffer.Format(_L8("AT%S%S%S\r"),&echoSetting, &quietSetting, &verboseSetting);

   476 			iIo->Write(this,iTxBuffer);

   477 			iIo->SetTimeOut(this,5*KOneSecondPause);

   478 			iState=EWaitForATStandardInitWrite;

   479 			}

   480 		break;

   481 

   482 	case EWaitForATStandardInitWrite:

   483 		StandardWriteCompletionHandler(aSource,5);

   484 		iState=EWaitForATStandardInitOK;

   485 		break;

   486 

   487 	case EWaitForATStandardInitOK:

   488 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   489 			{

   490 			TInt ret(ValidateExpectString());

   491 			if (ret)

   492 				{

   493 				RetryOrFail();

   494 				break;

   495 				}

   496 			iIo->WriteAndTimerCancel(this);

   497 			RemoveStdExpectStrings();

   498 			TPtrC8 interrogateWaitTime(KSmsSetTABufferMode);

   499 			WriteExpectingResults(interrogateWaitTime,5);

   500 			iState=EWaitForATUnsolicitedFixWrite;

   501 			}

   502 		break;

   503 

   504 	case EWaitForATUnsolicitedFixWrite:

   505 		StandardWriteCompletionHandler(aSource,5);

   506 		iState=EWaitForATUnsolicitedFixOK;

   507 		break;

   508 

   509 	case EWaitForATUnsolicitedFixOK:

   510 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   511 			{

   512 			// Ensures that unsolicited messages are buffered by the TA during initialisation

   513 			// We dont care what this returns becasue if AT+CNMI= fails, it is unlikely

   514 			// that SMS's can received at all.

   515 			iIo->WriteAndTimerCancel(this);

   516 			RemoveStdExpectStrings();

   517 			TPtrC8 interrogateWaitTime(KGetCarrierWaitTimeCommand);

   518 			WriteExpectingResults(interrogateWaitTime,5);

   519 			iState=EWaitForATCarrierWaitTimeWrite;

   520 			}

   521 		break;

   522 

   523 	case EWaitForATCarrierWaitTimeWrite:

   524 		StandardWriteCompletionHandler(aSource,5);

   525 		iState=EWaitForATCarrierWaitTimeOK;

   526 		break;

   527 

   528 	case EWaitForATCarrierWaitTimeOK:

   529 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   530 		//

   531 		//	if modem does not support ATS7 (carrier wait time) set it to default value

   532 		//

   533 			{

   534 			TInt ret(ValidateExpectString());

   535 			if (ret==KErrNone)

   536 				TRAP(ret,ParseWaitTimeL());

   537 			if (ret)

   538 				iPhoneGlobals->iPhoneStatus.iWaitForCarrierTime = KDefaultSecondsToWaitForCarrier;

   539 			iIo->WriteAndTimerCancel(this);	

   540 			RemoveStdExpectStrings();

   541 			Write(KAutoAnswerCommand(),5,KDefaultAutoAnswer);

   542 			iState=EWaitForATAutoAnswerTimeWrite;

   543 			}

   544 		break;

   545 

   546 	case EWaitForATAutoAnswerTimeWrite:

   547 		StandardWriteCompletionHandler(aSource,5);

   548 		iState=EWaitForATAutoAnswerTimeOK;

   549 		break;

   550 

   551 	case EWaitForATAutoAnswerTimeOK:

   552 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   553 			{

   554 			iIo->WriteAndTimerCancel(this);	

   555 			RemoveStdExpectStrings();

   556 			//

   557 			//

   558 			//All the MM initialization stuff starts now//

   559 			//

   560 			// 

   561 			iPhoneGlobals->iPhoneTestState = CPhoneGlobals::EPhoneTestUndefined; //New-ETSI-Phone or Old-ETSI-Phone? 

   562 

   563 			iTxBuffer.Copy(KGetManufacturerIDCommand);

   564 			iIo->Write(this, iTxBuffer);

   565 			iIo->SetTimeOut(this, 5000);

   566 			iState = EATWaitForSendingCGMIRequest;

   567 			}

   568 		break;	

   569 

   570 	case EATWaitForSendingCGMIRequest:

   571 		iIo->WriteAndTimerCancel(this);

   572 		StandardWriteCompletionHandler(aSource,5);

   573 		iState = EATWaitForSendingCGMIRequestComplete;

   574 		break;

   575 

   576 	case EATWaitForSendingCGMIRequestComplete:

   577 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   578 			{

   579 			iIo->WriteAndTimerCancel(this);

   580 			TInt ret(ValidateExpectString());

   581 			RemoveStdExpectStrings();

   582 			if (ret == KErrNone)

   583 				{

   584 				iCGMIFlag = ETrue;

   585 				__ASSERT_ALWAYS(GetIdentityResponse() == KErrNone,Panic(EGeneral));

   586 				iCGMIFlag = EFalse;

   587 				iPhoneGlobals->iPhoneIdCaps |= RMobilePhone::KCapsGetManufacturer;

   588 				}

   589 			else

   590 				{

   591 				LOGTEXT(_L8("MMTsy:\tCATInit:\tCGMI query returned ERROR. Setting NULL TBuf8"));

   592 				iPhoneGlobals->iPhoneId.iManufacturer.Zero();

   593 				}

   594 			iTxBuffer.Copy(KGetModelIDCommand);

   595 			iIo->Write(this, iTxBuffer);

   596 			iIo->SetTimeOut(this, 5000);

   597 			iState = EATWaitForSendingCGMMRequest;

   598 			}

   599 		break;

   600 		

   601 	case EATWaitForSendingCGMMRequest:

   602 		iIo->WriteAndTimerCancel(this);

   603 		StandardWriteCompletionHandler(aSource,5);

   604 		iState = EATWaitForSendingCGMMRequestComplete;

   605 		break;

   606 	

   607 	case EATWaitForSendingCGMMRequestComplete:

   608 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   609 			{

   610 			iIo->WriteAndTimerCancel(this);

   611 			TInt ret(ValidateExpectString());

   612 			RemoveStdExpectStrings();

   613 			if (ret == KErrNone)

   614 				{

   615 				iCGMMFlag = ETrue;

   616 				LOGTEXT(_L8("MMTsy:\tEntering CGMMResponse TRAPD' function"));

   617 				__ASSERT_ALWAYS(GetIdentityResponse() == KErrNone,Panic(EGeneral));

   618 				iCGMMFlag = EFalse;

   619 				iPhoneGlobals->iPhoneIdCaps |= RMobilePhone::KCapsGetModel;

   620 				}

   621 			else

   622 				{

   623 				LOGTEXT(_L8("MMTsy:\tCATInit:\tCGMM query returned ERROR. Setting NULL TBuf8"));

   624 				iPhoneGlobals->iPhoneId.iModel.Zero();

   625 				}

   626 			iTxBuffer.Copy(KGetRevisionIDCommand);

   627 			iIo->SetTimeOut(this, 5000);

   628 			iIo->Write(this, iTxBuffer);

   629 			iState = EATWaitForSendingCGMRRequest;

   630 			}

   631 		break;

   632 

   633 	case EATWaitForSendingCGMRRequest:

   634 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

   635 			{

   636 			iIo->WriteAndTimerCancel(this);

   637 			StandardWriteCompletionHandler(aSource, 5);

   638 			iState = EATWaitForSendingCGMRRequestComplete;

   639 			}

   640 		break;

   641 

   642 	case EATWaitForSendingCGMRRequestComplete:

   643 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   644 			{

   645 			iIo->WriteAndTimerCancel(this);

   646 			TInt ret(ValidateExpectString());

   647 			RemoveStdExpectStrings();

   648 			if (ret == KErrNone)

   649 				{

   650 				iCGMRFlag = ETrue;

   651 				__ASSERT_ALWAYS(GetIdentityResponse() == KErrNone,Panic(EGeneral));

   652 				iCGMRFlag = EFalse;

   653 				iPhoneGlobals->iPhoneIdCaps |= RMobilePhone::KCapsGetRevision;

   654 				}

   655 			else

   656 				{

   657 				LOGTEXT(_L8("MMTsy:\tCATInit:\tCGMR query returned ERROR. Setting NULL TBuf8"));

   658 				iPhoneGlobals->iPhoneId.iRevision.Zero();

   659 				}

   660 			iTxBuffer.Copy(KGetSerialNumberIDCommand);

   661 			iIo->Write(this, iTxBuffer);

   662 			iIo->SetTimeOut(this, 5000);

   663 			iState = EATWaitForSendingCGSNRequest;

   664 			}

   665 		break;

   666 

   667 

   668 	case EATWaitForSendingCGSNRequest:

   669 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

   670 			{

   671 			iIo->WriteAndTimerCancel(this);

   672 			StandardWriteCompletionHandler(aSource, 5);

   673 			iState = EATWaitForSendingCGSNRequestComplete;

   674 			}

   675 		break;

   676 

   677 	case EATWaitForSendingCGSNRequestComplete:

   678 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   679 			{

   680 			iIo->WriteAndTimerCancel(this);

   681 			TInt ret(ValidateExpectString());

   682 			RemoveStdExpectStrings();

   683 			if (ret == KErrNone)

   684 				{

   685 				iCGSNFlag = ETrue;

   686 				__ASSERT_ALWAYS(GetIdentityResponse() == KErrNone,Panic(EGeneral));

   687 				iCGSNFlag = EFalse;

   688 				iPhoneGlobals->iPhoneIdCaps |= RMobilePhone::KCapsGetSerialNumber;

   689 				}

   690 			else

   691 				{

   692 				LOGTEXT(_L8("MMTsy:\tCATInit:\tCGSN query returned ERROR. Setting NULL TBuf8"));

   693 				iPhoneGlobals->iPhoneId.iSerialNumber.Zero();

   694 				}

   695 

   696 			LOGTEXT(_L8("MMTsy:\tGrabbing the subscriber id capabilities"));

   697 			WriteExpectingResults(KGetSubscrieberIDCommand(), 5); 

   698 			iState=EATGetSubscriberIdWriteComplete;

   699 			}

   700 		break;

   701 

   702 	case EATGetSubscriberIdWriteComplete:

   703 		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

   704 			{

   705 			iIo->WriteAndTimerCancel(this);

   706 			StandardWriteCompletionHandler(aSource, 5);

   707 			iState=EATGetSubscriberIdReadComplete;

   708 			}

   709 			break;

   710                 

   711 	case EATGetSubscriberIdReadComplete:

   712 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   713 			{

   714 			iIo->WriteAndTimerCancel(this);

   715 			TInt ret(ValidateExpectString());

   716 			RemoveStdExpectStrings();

   717 			if (ret != KErrNone)

   718 				{

   719 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+CIMI not supported"));

   720 				}

   721 			else

   722 				{

   723 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+CIMI supported"));

   724 				iPhoneGlobals->iPhoneIdCaps |= RMobilePhone::KCapsGetSubscriberId;

   725 				}

   726 

   727 			LOGTEXT(_L8("MMTsy:\tGrabbing the SMS <mode> capabilities"));

   728 			WriteExpectingResults(KSmsGetModeCommand(), 5); 

   729 			iState=EATWaitForSendingCMGFRequestWrite;

   730 

   731 			}

   732 			break;		

   733 

   734 	case EATWaitForSendingCMGFRequestWrite:

   735 		StandardWriteCompletionHandler(aSource,5);

   736 		iState=EATWaitForSendingCMGFRequestComplete;

   737 		break;

   738 

   739 	case EATWaitForSendingCMGFRequestComplete:

   740 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   741 			{

   742 			iIo->WriteAndTimerCancel(this);	

   743 			TInt ret(ValidateExpectString());

   744 			RemoveStdExpectStrings();

   745 			iPhoneGlobals->iSmsPduModeSupported=EFalse;

   746 			if(ret==KErrNone)

   747 				{

   748 				TRAP(ret,CheckCMGFResponseL());

   749 				}

   750 			if((ret==KErrNone)&&(iPhoneGlobals->iSmsPduModeSupported))

   751 				{

   752 				LOGTEXT(_L8("MMTsy:\tPdu mode is supported by ME. Enabling this as the default mode."));

   753 				WriteExpectingResults(KSetSmsModeSupportCommand, 5);

   754 				iState = EATWaitForSendingCMGFConfigureWrite;

   755 				}

   756 			else

   757 				{

   758 				LOGTEXT(_L8("MMTsy:\tPdu mode not supported by ME. Sending a dummy \"AT\" instead."));

   759 				WriteExpectingResults(KATCommand, 5);

   760 				iState = EATWaitForSendingCMGFConfigureWrite;

   761 				}

   762 			} //case

   763 		break;

   764 	

   765 	case EATWaitForSendingCMGFConfigureWrite:

   766 		StandardWriteCompletionHandler(aSource,5);

   767 		iState=EATWaitForCMGFResponseOKComplete;

   768 		break;

   769 

   770 	case EATWaitForCMGFResponseOKComplete:

   771 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   772 			{

   773 			iIo->WriteAndTimerCancel(this);

   774 			TInt ret(ValidateExpectString());

   775 			if (ret)

   776 				{

   777 				RetryOrFail();

   778 				break;

   779 				}

   780 			RemoveStdExpectStrings();

   781 		

   782 		// CMGF is taken care of... mode capabilites assessed, and Pdu mode (for now) has been assigned to ME. (Mobile Equipment)

   783 			iTxBuffer.Copy(KGetPrefMemCommand);	// Preferred Memory Storage cmd. ETSI std GSM 07.05, May 1996

   784 			iIo->Write(this, iTxBuffer);

   785 			iIo->SetTimeOut(this, 5000);

   786 			iState = EATWaitForSendingEnumRequest;

   787 			} //case

   788 		break;

   789 

   790 	case EATWaitForSendingEnumRequest:

   791 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

   792 		{

   793 		iIo->WriteAndTimerCancel(this);

   794 		StandardWriteCompletionHandler(aSource, 5);

   795 		iState = EATWaitForSendingEnumRequestComplete;

   796 		}

   797 		break;

   798 

   799 	case EATWaitForSendingEnumRequestComplete:

   800 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   801 		{

   802 		iIo->WriteAndTimerCancel(this);

   803 		TInt ret(ValidateExpectString());

   804 		if (ret!=KErrNone)

   805 			{

   806 			LOGTEXT(_L8("MMTsy:\tCATInit:\tAT+CPMS=? command not supported by this phone"));

   807 			LOGTEXT(_L8("MMTsy:\tCATInit:\tThis situation should NOT occur for a MM(GSM) phone as this command is mandatory!"));

   808 			}

   809 		else

   810 			{

   811 			TRAPD(ret, iEnumerate->EnumerateCPMSResponseL());

   812 			if (ret != KErrNone)

   813 				{

   814 				LOGTEXT(_L8("MMTsy:\tCATInit:\tError Enumerating Message Stores"));

   815 				RetryOrFail();

   816 				break;

   817 				}

   818 			}

   819 		RemoveStdExpectStrings();

   820 

   821 		iTxBuffer.Copy(KGetPrefMemTestCommand);

   822 		iIo->Write(this, iTxBuffer);

   823 		iIo->SetTimeOut(this, 5000);

   824 		iState = EATWaitForGetPrefMemWriteComplete;				

   825 		}

   826 		break;

   827 

   828 	case EATWaitForGetPrefMemWriteComplete:

   829 		StandardWriteCompletionHandler(aSource, 5);

   830 		iState=EATWaitForGetPrefMemReadComplete;

   831 		break;

   832 

   833 	case EATWaitForGetPrefMemReadComplete:

   834 		__ASSERT_ALWAYS(aSource==EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   835 		{

   836 		iIo->WriteAndTimerCancel(this);

   837 		TInt ret(ValidateExpectString());

   838 		if (ret!=KErrNone)

   839 			{

   840 			LOGTEXT(_L8("MMTsy:\tCATInit:\tAT+CPMS? command not supported by this phone"));

   841 			LOGTEXT(_L8("MMTsy:\tCATInit:\tThis situation should NOT occur for a MM/(GSM) phone as this command is mandatory!"));

   842 			}

   843 		else

   844 			{

   845 			TRAPD(ret, iEnumerate->GetPrefMemL());

   846 			if (ret != KErrNone)

   847 				{

   848 				LOGTEXT(_L8("MMTsy:\tCATInit:\tError Determining Pref'd Memory"));

   849 				RetryOrFail();

   850 				break;

   851 				}

   852 			}

   853 		RemoveStdExpectStrings();

   854 

   855 		Write(KTestPhoneBookStorage(), 5);

   856 		iState=EATWaitForTestPhoneBookStorageWriteComplete;

   857 		}

   858 		break;

   859 

   860 	case EATWaitForTestPhoneBookStorageWriteComplete:

   861 		StandardWriteCompletionHandler(aSource,5);

   862 		iState=EATWaitForTestPhoneBookStorageRequestComplete;

   863 		break;

   864 

   865 	case EATWaitForTestPhoneBookStorageRequestComplete:

   866 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

   867 			{

   868 			iIo->WriteAndTimerCancel(this);

   869 			TInt ret(ValidateExpectString());

   870 			if (ret!=KErrNone)

   871 				LOGTEXT(_L8("CATInit:\tAT+CPBS command not supported by this phone. Skipping to Network Registration"));

   872 			else

   873 				{

   874 				TRAP(ret,ParsePhoneBookStorageL());

   875 				if (ret!=KErrNone)

   876 					{

   877 					RetryOrFail();

   878 					break;

   879 					}

   880 				}

   881 			RemoveStdExpectStrings();

   882 

   883 			// Start waiting for asynchronous notification

   884 			// Some notifications may be ignored until the phone is fully initialized.

   885 			STATIC_CAST(CPhoneHayes*,iTelObject)->StartWaitForRing(); 

   886 

   887 			iTxBuffer.Copy(KClearUnsolicitedNetworkRegistration);

   888 			iIo->Write(this, iTxBuffer);

   889 			iIo->SetTimeOut(this, 5000);

   890 			iState = EATWaitForClearUnsolicitedNetworkRegistrationWrite;

   891 			}

   892 		break;

   893 

   894 

   895 	case EATWaitForClearUnsolicitedNetworkRegistrationWrite:

   896 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

   897 			{

   898 			iIo->WriteAndTimerCancel(this);

   899 			StandardWriteCompletionHandler(aSource, 5);

   900 			iState = EATWaitForClearUnsolicitedNetworkRegistrationOK;

   901 			}

   902 		break;

   903 

   904 	case EATWaitForClearUnsolicitedNetworkRegistrationOK:

   905 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   906 			{

   907 			iIo->WriteAndTimerCancel(this);

   908 			TInt ret(ValidateExpectString());

   909 			RemoveStdExpectStrings();

   910 			if (ret != KErrNone)

   911 				{

   912 				LOGTEXT(_L8("MMTsy:\tCATWaitForCall:\t+CREG=0 failed"));

   913 				}

   914 			else

   915 				{

   916 				// Getting the network capabilities that AT+CREG supplies 

   917 				// The phone supports retrieval of current registration status.

   918 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsGetRegistrationStatus; //0x00000001

   919 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsGetCurrentMode; //0x00000004

   920 				}

   921 

   922 			iTxBuffer.Copy(KSetUnsolicitedNetworkRegistration2);

   923 			iIo->Write(this, iTxBuffer);

   924 			iIo->SetTimeOut(this, 5000);

   925 			iState = EATWaitForSetUnsolicitedNetworkRegistrationWrite;

   926 			}

   927 		break;

   928 

   929 	case EATWaitForSetUnsolicitedNetworkRegistrationWrite:

   930 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

   931 			{

   932 			iIo->WriteAndTimerCancel(this);

   933 			StandardWriteCompletionHandler(aSource, 5);

   934 			iState = EATWaitForSetUnsolicitedNetworkRegistrationOK;

   935 			}

   936 		break;

   937 

   938 	case EATWaitForSetUnsolicitedNetworkRegistrationOK:

   939 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   940 			{

   941 			iIo->WriteAndTimerCancel(this);

   942 			TInt ret(ValidateExpectString());

   943 			RemoveStdExpectStrings();

   944 			if (ret != KErrNone)

   945 				{

   946 				if (iTxBuffer==KSetUnsolicitedNetworkRegistration2)

   947 					{

   948 					// Some phones do not support +CREG=2 (e.g SH888)

   949 					// Try the fallback position with +CREG=1

   950 

   951 					iTxBuffer.Copy(KSetUnsolicitedNetworkRegistration1);

   952 					iIo->Write(this, iTxBuffer);

   953 					iIo->SetTimeOut(this, 5000);

   954 					iState = EATWaitForSetUnsolicitedNetworkRegistrationWrite;

   955 					break;

   956 					}

   957 				LOGTEXT(_L8("MMTsy:\tCATInit:\tC+CREG failed"));

   958 				}

   959 

   960 			if(ret == KErrNone) // If +CREG=2 or +CREG=1 were succesfully executed the capabilities can be set. 

   961 				{

   962 				// The phone supports notify registration status.

   963 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsNotifyRegistrationStatus;

   964 

   965 				// The phone supports notify mode.

   966 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsNotifyMode;

   967 				}

   968 			

   969 			iTxBuffer.Copy(KReadUnsolicitedNetworkRegistration);

   970 			iIo->Write(this, iTxBuffer);

   971 			iIo->SetTimeOut(this, 5000);

   972 			iState = EATWaitForReadUnsolicitedNetworkRegistrationWrite;

   973 			}

   974 		break;

   975 

   976 	case EATWaitForReadUnsolicitedNetworkRegistrationWrite:

   977 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

   978 			{

   979 			iIo->WriteAndTimerCancel(this);

   980 			StandardWriteCompletionHandler(aSource, 5);

   981 			iState = EATWaitForReadUnsolicitedNetworkRegistrationOK;

   982 			}

   983 		break;

   984 

   985 	case EATWaitForReadUnsolicitedNetworkRegistrationOK:

   986 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

   987 			{

   988 			iIo->WriteAndTimerCancel(this);

   989 			TInt ret(ValidateExpectString());

   990 			RemoveStdExpectStrings();

   991 			if (ret != KErrNone)

   992 				{				

   993 				LOGTEXT(_L8("MMTsy:\tCATInit:\tRead Network Registration Not Supported"));				

   994 				}

   995 			iTxBuffer.Copy(KSetExtendedCallIndicationCommand);

   996 			iIo->Write(this, iTxBuffer);

   997 			iIo->SetTimeOut(this, 5000);

   998 			iState = EATWaitForSetExtendedCallIndicationWrite;

   999 			}

  1000 		break;

  1001 

  1002 	case EATWaitForSetExtendedCallIndicationWrite:

  1003 		__ASSERT_ALWAYS(aSource == EWriteCompletion, Panic(EATCommand_IllegalCompletionWriteExpected));

  1004 			{

  1005 			iIo->WriteAndTimerCancel(this);

  1006 			StandardWriteCompletionHandler(aSource, 5);

  1007 			iState = EATWaitForSetExtendedCallIndicationOK;

  1008 			}

  1009 		break;

  1010 

  1011 	case EATWaitForSetExtendedCallIndicationOK:

  1012 		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

  1013 			{

  1014 			iIo->WriteAndTimerCancel(this);

  1015 			TInt ret(ValidateExpectString());

  1016 			RemoveStdExpectStrings();

  1017 			if (ret != KErrNone)

  1018 				{

  1019 				LOGTEXT(_L8("MMTsy:\tCATWaitForCall:\t+CRC=1 failed"));

  1020 				}

  1021 			iTxBuffer.Copy(KGetCurrentOperatorCommand);

  1022 			iIo->Write(this, iTxBuffer);

  1023 			iIo->SetTimeOut(this, 5000);

  1024 			iState=EATGetCurrentOperatorWriteComplete;

  1025 			}

  1026 		break;

  1027 	

  1028 	case EATGetCurrentOperatorWriteComplete:

  1029 		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

  1030 			{

  1031 			iIo->WriteAndTimerCancel(this);

  1032 			StandardWriteCompletionHandler(aSource, 5);

  1033 			iState=EATGetCurrentOperatorReadComplete;

  1034 			}

  1035 			break;

  1036 

  1037 	case EATGetCurrentOperatorReadComplete:

  1038 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

  1039 			{

  1040 			iIo->WriteAndTimerCancel(this);

  1041 			TInt ret(ValidateExpectString());

  1042 			RemoveStdExpectStrings();

  1043 			if (ret != KErrNone)

  1044 				{

  1045 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+COPS? not supported"));

  1046 				}

  1047 			else

  1048 				{

  1049 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+COPS? supported"));

  1050 

  1051 				// Getting the network capabilities that AT+COPS supplies.

  1052 				// The phone supports get/notify current network information.

  1053 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsGetCurrentNetwork; //0x00000010

  1054 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsNotifyCurrentNetwork; //0x00000020

  1055 

  1056 				// The phone supprts retrieval of a list of detected networks.

  1057 				iPhoneGlobals->iNetworkCaps |= RMobilePhone::KCapsGetDetectedNetworks; //0x00000080

  1058 

  1059 				TRAPD(ret,ParseOperatorL());

  1060 				if (ret != KErrNone)

  1061 					{

  1062 					LOGTEXT(_L8("MMTsy:\tCATInit:\tError parsing +COPS?"));

  1063 					}								

  1064 				}

  1065 			iTxBuffer.Copy(KGetBatteryInfoCommand); // Start the sequence of getting the battery capabilities.

  1066 			iIo->Write(this, iTxBuffer);

  1067 			iIo->SetTimeOut(this, 5000);

  1068 			iState=EATGetBatteryInfoWriteComplete;

  1069 			}

  1070 			break;

  1071 

  1072 	case EATGetBatteryInfoWriteComplete:

  1073 		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

  1074 			{

  1075 			iIo->WriteAndTimerCancel(this);

  1076 			StandardWriteCompletionHandler(aSource, 5);

  1077 			iState=EATGetBatteryInfoReadComplete;

  1078 			}

  1079 			break;

  1080                 

  1081 	case EATGetBatteryInfoReadComplete:

  1082 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

  1083 			{

  1084 			iIo->WriteAndTimerCancel(this);

  1085 			TInt ret(ValidateExpectString());

  1086 			RemoveStdExpectStrings();

  1087 			if (ret != KErrNone)

  1088 				{

  1089 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+CBC not supported"));

  1090 				}

  1091 			else

  1092 				{

  1093 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+CBC supported"));		

  1094 				iPhoneGlobals->iBatteryCaps=RMobilePhone::KCapsGetBatteryInfo;

  1095 				}

  1096 			iTxBuffer.Copy(KGetSignalInfoCommand); // Start the sequence of getting the signal capabilities.

  1097 			iIo->Write(this, iTxBuffer);

  1098 			iIo->SetTimeOut(this, 5000);

  1099 			iState=EATGetSignalInfoWriteComplete;

  1100 

  1101 			}

  1102 			break;

  1103 

  1104 	case EATGetSignalInfoWriteComplete:

  1105 		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

  1106 			{

  1107 			iIo->WriteAndTimerCancel(this);

  1108 			StandardWriteCompletionHandler(aSource, 5);

  1109 			iState=EATGetSignalInfoReadComplete;

  1110 			}

  1111 			break;

  1112                 

  1113 	case EATGetSignalInfoReadComplete:

  1114 		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

  1115 			{

  1116 			iIo->WriteAndTimerCancel(this);

  1117 			TInt ret(ValidateExpectString());

  1118 			RemoveStdExpectStrings();

  1119 			if (ret != KErrNone)

  1120 				{

  1121 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+CSQ not supported"));

  1122 				}

  1123 			else

  1124 				{

  1125 				LOGTEXT(_L8("MMTsy:\tCATInit:\t+CSQ supported"));		

  1126 				iPhoneGlobals->iSignalCaps=RMobilePhone::KCapsGetSignalStrength;

  1127 				}

  1128 			iTxBuffer.Copy(KCurrentCGCLASSCommand);

  1129 			iIo->Write(this, iTxBuffer);

  1130 			iIo->SetTimeOut(this, 5000);

  1131 			iState=EATGetCurrentMSCLASSWriteComplete;

  1132 			}

  1133 			break;

  1134 

  1135 	case EATGetCurrentMSCLASSWriteComplete: