1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\drivers\ecomm\d_comm.cpp

    15 // 

    16 //

    17 

    18 #include <drivers/comm.h>

    19 #include <kernel/kern_priv.h>

    20 #include <e32hal.h>

    21 #include <e32uid.h>

    22 

    23 // Logging

    24 #define LOG_ON(x) Kern::Printf##x

    25 #define LOG_OFF(x)

    26 #define LOG		LOG_OFF

    27 

    28 

    29 //#define __UART_RX_ERROR(x)    *(TUint*)0xfeedface=(x)

    30 //#define __OVERRUN() *(TUint*)0xfaece5=0

    31 

    32 #define __UART_RX_ERROR(x)

    33 #define __OVERRUN()

    34 

    35 _LIT(KLddName,"Comm");

    36 

    37 

    38 const TUint KXoffSignal=0x80;

    39 //

    40 const TUint KBreaking=0x02;

    41 const TUint KBreakPending=0x04;

    42 //

    43 enum TPanic

    44 	{

    45 	ESetConfigWhileRequestPending,

    46 	ESetSignalsSetAndClear,

    47 	EResetBuffers,

    48 	ESetReceiveBufferLength,

    49 	};

    50 

    51 DECLARE_STANDARD_LDD()

    52 	{

    53 	return new DDeviceComm;

    54 	}

    55 

    56 DDeviceComm::DDeviceComm()

    57 //

    58 // Constructor

    59 //

    60 	{

    61 	LOG(("DDeviceComm::DDeviceComm"));

    62 	iParseMask=KDeviceAllowAll;

    63 	iUnitsMask=0xffffffff; // Leave units decision to the PDD

    64 	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

    65 	}

    66 

    67 TInt DDeviceComm::Install()

    68 //

    69 // Install the device driver.

    70 //

    71 	{

    72 	LOG(("DDeviceComm::Install"));

    73 	return(SetName(&KLddName));

    74 	}

    75 

    76 void DDeviceComm::GetCaps(TDes8& aDes) const

    77 //

    78 // Return the Comm capabilities.

    79 //

    80 	{

    81 	LOG(("DDeviceComm::GetCaps"));

    82 	TPckgBuf<TCapsDevCommV01> b;

    83 	b().version=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

    84 	Kern::InfoCopy(aDes,b);

    85 	}

    86 

    87 TInt DDeviceComm::Create(DLogicalChannelBase*& aChannel)

    88 //

    89 // Create a channel on the device.

    90 //

    91 	{

    92 	LOG(("DDeviceComm::Create"));

    93 	aChannel=new DChannelComm;

    94 	return aChannel?KErrNone:KErrNoMemory;

    95 	}

    96 

    97 DChannelComm::DChannelComm()

    98 //

    99 // Constructor

   100 //

   101 	:	iPowerUpDfc(DChannelComm::PowerUpDfc,this,3),

   102 		iPowerDownDfc(DChannelComm::PowerDownDfc,this,3),

   103 		iRxDrainDfc(DChannelComm::DrainRxDfc,this,2),

   104 		iRxCompleteDfc(DChannelComm::CompleteRxDfc,this,2),

   105 		iTxFillDfc(DChannelComm::FillTxDfc,this,2),

   106 		iTxCompleteDfc(DChannelComm::CompleteTxDfc,this,2),

   107 		iTimerDfc(DChannelComm::TimerDfcFn,this,3),

   108 		iSigNotifyDfc(DChannelComm::SigNotifyDfc,this,2),

   109 //		iTurnaroundMinMilliSeconds(0),

   110 //		iTurnaroundTimerRunning(EFalse),

   111 //		iTurnaroundTransmitDelayed(EFalse),

   112 		iTurnaroundTimer(DChannelComm::TurnaroundStartDfc, this),

   113 		iTurnaroundDfc(DChannelComm::TurnaroundTimeout, this, 2),

   114 		iTimer(DChannelComm::MsCallBack,this),

   115 		iBreakDfc(DChannelComm::FinishBreakDfc, this, 2),

   116 		iLock(TSpinLock::EOrderGenericIrqLow3)

   117 	{

   118 	LOG(("DChannelComm"));

   119 //

   120 // Setup the default config

   121 //

   122 	iConfig.iRate=EBps9600;

   123 	iConfig.iDataBits=EData8;

   124 	iConfig.iStopBits=EStop1;

   125 	iConfig.iParity=EParityNone;

   126 	iConfig.iFifo=EFifoEnable;

   127 	iConfig.iHandshake=KConfigObeyCTS;

   128 	iConfig.iParityError=KConfigParityErrorFail;

   129 	iConfig.iSIREnable=ESIRDisable;

   130 //	iConfig.iTerminatorCount=0;

   131 //	iConfig.iTerminator[0]=0;

   132 //	iConfig.iTerminator[1]=0;

   133 //	iConfig.iTerminator[2]=0;

   134 //	iConfig.iTerminator[3]=0;

   135 	iConfig.iXonChar=0x11; // XON

   136 	iConfig.iXoffChar=0x13; // XOFF

   137 //	iConfig.iSpecialRate=0;

   138 //	iConfig.iParityErrorChar=0;

   139 	iRxXonChar=0xffffffff;

   140 	iRxXoffChar=0xffffffff;

   141 	iStatus=EOpen;

   142 //	iFlags=0;

   143 //	iSignals=0;

   144 //	iFailSignals=0;

   145 //	iHoldSignals=0;

   146 //	iFlowControlSignals=0;

   147 //	iAutoSignals=0;

   148 //	iTerminatorMask[0...31]=0;

   149 //	iShutdown=EFalse;

   150 //	iRxCharBuf=NULL;

   151 //	iRxErrorBuf=NULL;

   152 //	iRxPutIndex=0;

   153 //	iRxGetIndex=0;

   154 //	iRxBufSize=0;

   155 //	iFlowControlLowerThreshold=0;

   156 //	iFlowControlUpperThreshold=0;

   157 //	iRxDrainThreshold=0;

   158 //	iRxBufCompleteIndex=0;

   159 //	iInputHeld=EFalse;

   160 //	iRxClientBufReq=NULL;

   161 //	iRxDesPos=0;

   162 //	iRxLength=0;

   163 //	iRxOutstanding=EFalse;

   164 //	iRxError=KErrNone;

   165 //	iTxBuffer=NULL;

   166 //	iTxPutIndex=0;

   167 //	iTxGetIndex=0;

   168 //	iTxBufSize=0;

   169 //	iTxFillThreshold=0;

   170 	iOutputHeld=0;

   171 	iJamChar=KTxNoChar;

   172 //	iTxDesPtr=NULL;

   173 //	iTxDesPos=0;

   174 //	iTxDesLength=0;

   175 //	iTxOutstanding=EFalse;

   176 //	iTxError=KErrNone;

   177 

   178 //	iTimeout=10;

   179 	iTimeout=NKern::TimerTicks(5);

   180 	iClient=&Kern::CurrentThread();

   181 	iClient->Open();

   182 //	iSigNotifyMask=0;

   183 //	iSignalsPtr=NULL;

   184 //	iSigNotifyStatus=NULL;

   185 	iBreakStatus=NULL;

   186 	iNotifiedSignals=0xffffffff;

   187 	iPinObjSetConfig=NULL;

   188 	}

   189 

   190 DChannelComm::~DChannelComm()

   191 //

   192 // Destructor

   193 //

   194 	{

   195 	LOG(("~DChannelComm"));

   196 	if (iPowerHandler)

   197 		{

   198 		iPowerHandler->Remove(); 

   199 		delete iPowerHandler;

   200 		}

   201     if (iRxCharBuf)

   202         Kern::Free(iRxCharBuf);

   203     if (iTxBuffer)

   204         Kern::Free(iTxBuffer);

   205 	if (iBreakStatus)

   206 		Kern::DestroyClientRequest(iBreakStatus);

   207 	if (iSignalsReq)

   208 		Kern::DestroyClientRequest(iSignalsReq);

   209 	if (iPinObjSetConfig)

   210 		Kern::DestroyVirtualPinObject(iPinObjSetConfig);

   211 	Kern::SafeClose((DObject*&)iClient, NULL);

   212 	}

   213 

   214 

   215 void DChannelComm::Complete(TInt aMask, TInt aReason)

   216 	{

   217 	LOG(("Complete(aMask=%x aReason=%d)", aMask, aReason));

   218 	if (aMask & ERx)

   219 		iRxBufReq.Complete(iClient, aReason);

   220 	if (aMask & ETx)

   221 		iTxBufReq.Complete(iClient, aReason);

   222 	if (aMask & ESigChg)

   223 		Kern::QueueRequestComplete(iClient, iSignalsReq, aReason);

   224 	if ((aMask & EBreak) && iBreakStatus && iBreakStatus->IsReady())

   225 		Kern::QueueRequestComplete(iClient, iBreakStatus, aReason);

   226 	}

   227 

   228 TInt DChannelComm::Shutdown()

   229 	{

   230 	__KTRACE_OPT(KPOWER,Kern::Printf("DChannelComm::Shutdown()"));

   231 	LOG(("Shutdown()"));

   232 

   233     if (iStatus == EActive)

   234         Stop(EStopPwrDown);

   235 

   236     Complete(EAll, KErrAbort);

   237 

   238 	// UART interrupts are disabled; must make sure DFCs are not queued.

   239 	iRxDrainDfc.Cancel();

   240 	iRxCompleteDfc.Cancel();

   241 	iTxFillDfc.Cancel();

   242 	iTxCompleteDfc.Cancel();

   243 	iTimer.Cancel();

   244 	iTurnaroundTimer.Cancel();

   245 	iTurnaroundDfc.Cancel();

   246 	iTimerDfc.Cancel();

   247 	iSigNotifyDfc.Cancel();

   248 	iPowerUpDfc.Cancel();

   249 	iPowerDownDfc.Cancel();

   250 	iBreakTimer.Cancel();

   251 	iBreakDfc.Cancel();

   252 	

   253 	if (iPdd)

   254 		SetSignals(0,iFlowControlSignals|iAutoSignals);

   255 

   256 	return KErrCompletion;

   257 	}

   258 

   259 TInt DChannelComm::DoCreate(TInt aUnit, const TDesC8* /*anInfo*/, const TVersion &aVer)

   260 //

   261 // Create the channel from the passed info.

   262 //

   263 	{

   264 	LOG(("DoCreate(aUnit=%d,...)", aUnit));

   265 	if(!Kern::CurrentThreadHasCapability(ECapabilityCommDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by ECOMM.LDD (Comm Driver)")))

   266 		return KErrPermissionDenied;

   267 	if (!Kern::QueryVersionSupported(TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber),aVer))

   268 		return KErrNotSupported;

   269 

   270 	// set up the correct DFC queue

   271 	SetDfcQ(((DComm*)iPdd)->DfcQ(aUnit));

   272 	iPowerUpDfc.SetDfcQ(iDfcQ);

   273 	iPowerDownDfc.SetDfcQ(iDfcQ);

   274 	iRxDrainDfc.SetDfcQ(iDfcQ);

   275 	iRxCompleteDfc.SetDfcQ(iDfcQ);

   276 	iTxFillDfc.SetDfcQ(iDfcQ);

   277 	iTxCompleteDfc.SetDfcQ(iDfcQ);

   278 	iTimerDfc.SetDfcQ(iDfcQ);

   279 	iSigNotifyDfc.SetDfcQ(iDfcQ);

   280 	iTurnaroundDfc.SetDfcQ(iDfcQ);

   281 	iBreakDfc.SetDfcQ(iDfcQ);

   282 	iMsgQ.Receive();

   283 

   284 	// initialise the TX buffer

   285 	iTxBufSize=KTxBufferSize;

   286 	iTxBuffer=(TUint8*)Kern::Alloc(iTxBufSize);

   287 	if (!iTxBuffer)

   288 		return KErrNoMemory;

   289 	iTxFillThreshold=iTxBufSize>>1;

   290 

   291 	// initialise the RX buffer

   292 	iRxBufSize=KDefaultRxBufferSize;

   293 	iRxCharBuf=(TUint8*)Kern::Alloc(iRxBufSize<<1);

   294 	if (!iRxCharBuf)

   295 		return KErrNoMemory;

   296 	iRxErrorBuf=iRxCharBuf+iRxBufSize;

   297 	iFlowControlLowerThreshold=iRxBufSize>>2;

   298 	iFlowControlUpperThreshold=3*iRxBufSize>>2;

   299 	iRxDrainThreshold=iRxBufSize>>1;

   300 

   301 	// Create request objects

   302 	TInt r = Kern::CreateClientDataRequest(iSignalsReq);

   303 	if (r==KErrNone)

   304 		r = Kern::CreateClientRequest(iBreakStatus);

   305 	if (r==KErrNone)

   306 		r = iRxBufReq.Create();

   307 	if (r==KErrNone)

   308 		r = iTxBufReq.Create();

   309 	if (r==KErrNone)

   310 		r = Kern::CreateVirtualPinObject(iPinObjSetConfig);

   311 	if (r != KErrNone)

   312 		return r;

   313 

   314 	((DComm *)iPdd)->iLdd=this;

   315 	PddCheckConfig(iConfig);

   316 	iFailSignals=FailSignals(iConfig.iHandshake);

   317 	iHoldSignals=HoldSignals(iConfig.iHandshake);

   318 	iFlowControlSignals=FlowControlSignals(iConfig.iHandshake);

   319 	iAutoSignals=AutoSignals(iConfig.iHandshake);

   320 

   321 	// create the power handler

   322 	iPowerHandler=new DCommPowerHandler(this);

   323 	if (!iPowerHandler)

   324 		return KErrNoMemory;

   325 	iPowerHandler->Add();

   326 	DoPowerUp();

   327 

   328 	return KErrNone;

   329 	}

   330 

   331 TInt DChannelComm::RequestUserHandle(DThread* aThread, TOwnerType aType)

   332 	{

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

   334 	return (aThread!=iClient) ?  KErrAccessDenied : KErrNone;

   335 	}

   336 

   337 void DChannelComm::MsCallBack(TAny* aPtr)

   338 	{

   339 	// called from ISR when timer completes

   340 	DChannelComm *pC=(DChannelComm*)aPtr;

   341 	pC->iTimerDfc.Add();

   342 	}

   343 

   344 void DChannelComm::TimerDfcFn(TAny* aPtr)

   345 	{

   346 	DChannelComm *pC=(DChannelComm*)aPtr;

   347 	pC->TimerDfc();

   348 	}

   349 

   350 void DChannelComm::TimerDfc()

   351 	{

   352 	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   353 	if (iRxOutstanding)

   354 		{

   355 		if (iRxGetIndex==iRxPutIndex)

   356 			{

   357 			// buffer empty after timeout period, so complete

   358 			iRxBufCompleteIndex=iRxPutIndex;

   359 			iRxOutstanding=EFalse;

   360 			iRxOneOrMore=0;

   361 			__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   362 			DoCompleteRx();

   363 			return;

   364 			}

   365 		// buffer not empty, so drain buffer and requeue timer

   366 		__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   367 		DoDrainRxBuffer(iRxPutIndex);

   368 		return;

   369 		}

   370 	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   371 	}

   372 

   373 void DChannelComm::DrainRxDfc(TAny* aPtr)

   374 	{

   375 	DChannelComm *pC=(DChannelComm*)aPtr;

   376 	pC->DoDrainRxBuffer(pC->iRxPutIndex);

   377 	}

   378 

   379 // Drain RX buffer in a DFC

   380 void DChannelComm::DoDrainRxBuffer(TInt aEndIndex)

   381 	{

   382 	// if RX completion DFC is queued, leave buffer draining to it

   383 	if (iRxCompleteDfc.Queued())

   384 		return;

   385 

   386 	LOG(("DoDrainRxBuffer(aEndIndex=%d) iRxDesPos=%d iRxBufReq.iLen=%d", aEndIndex, iRxDesPos, iRxBufReq.iLen));

   387     

   388 	// If there's an Rx request with bytes outstanding...

   389 	if (iRxBufReq.iBuf && iRxDesPos<iRxBufReq.iLen)

   390         {

   391         TInt space=iRxBufReq.iLen-iRxDesPos; // the amount of the client buffer left to fill

   392         TInt avail=aEndIndex-iRxGetIndex;	 // the amount of data in the Rx buffer to copy to the client buffer

   393         if (avail<0) // true if the data to drain wraps around the end of the buffer (i.e. the last byte to copy has a linear address less than that of the first byte)

   394             avail+=iRxBufSize;

   395         TInt len=Min(space,avail); // total number of bytes to drain

   396 

   397 		// Drain up to (but not beyond) the end of the Rx buffer

   398         TInt len1=Min(len,iRxBufSize-iRxGetIndex);  // number of bytes to the end of the buffer

   399         TPtrC8 des(iRxCharBuf+iRxGetIndex,len1);

   400 

   401 		TInt r = Kern::ThreadBufWrite(iClient, iRxBufReq.iBuf, des, iRxDesPos, KChunkShiftBy0, iClient);

   402         if (r != KErrNone)

   403             {

   404             iRxError=r;

   405             DoCompleteRx();

   406             return;

   407             }

   408 

   409 		// Update the client buffer offset and the Rx buffer read pointer with what we've done so far

   410         TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   411         iRxDesPos += len1;

   412         iRxGetIndex+=len1;

   413         if (iRxGetIndex>=iRxBufSize)

   414             iRxGetIndex-=iRxBufSize;

   415         __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   416 

   417 		// If the data wraps around the end of the Rx buffer, now write out the second part

   418 		// which starts at the beginning of the Rx buffer.

   419         len-=len1;

   420         if (len)

   421             {

   422             des.Set(iRxCharBuf,len);

   423 			r=Kern::ThreadBufWrite(iClient, iRxBufReq.iBuf, des, iRxDesPos, KChunkShiftBy0, iClient);

   424             if (r != KErrNone)

   425                 {

   426                 iRxError=r;

   427                 DoCompleteRx();

   428                 return;

   429                 }

   430 

   431 			// Update client buffer offset and Rx buffer read offset

   432             irq = __SPIN_LOCK_IRQSAVE(iLock);

   433             iRxDesPos += len;

   434             iRxGetIndex+=len;

   435             __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   436             }

   437 

   438         // release flow control if necessary

   439         if (iInputHeld && RxCount()<=iFlowControlLowerThreshold)

   440             ReleaseFlowControl();

   441 

   442         // if we are doing ReadOneOrMore, start the timer

   443         if (iRxOneOrMore>0)

   444             {

   445             iTimer.OneShot(iTimeout);

   446             }

   447         }

   448     }

   449 

   450 

   451 void DChannelComm::RxComplete()

   452 {

   453 	if (NKern::CurrentContext()==NKern::EInterrupt)

   454 		iRxCompleteDfc.Add();

   455 	else

   456 		DoCompleteRx();			

   457 }

   458 

   459 

   460 void DChannelComm::CompleteRxDfc(TAny* aPtr)

   461 	{

   462 	DChannelComm *pC=(DChannelComm*)aPtr;

   463 	pC->DoCompleteRx();

   464 	}

   465 

   466 void DChannelComm::DoCompleteRx()

   467 	{

   468     LOG(("DoCompleteRx()"));

   469 	if (iRxOneOrMore>0)

   470 		iTimer.Cancel();

   471 	if (iRxBufReq.iLen)

   472         {

   473         iRxOneOrMore=0;

   474         DoDrainRxBuffer(iRxBufCompleteIndex);

   475 		iRxBufReq.Complete(iClient, iRxError);

   476 		iRxDesPos=0;

   477 

   478         iRxError=KErrNone;

   479         // start Turnaround timer (got here because it received all data, timed out on a ReadOneOrMore or was terminated

   480         // early by FailSignals)

   481         RestartTurnaroundTimer();

   482         }

   483     else

   484         {

   485         Complete(ERx,KErrNone);

   486         // do not start Turnaround (got here on a request Data Available Notification)

   487         }

   488     }

   489 

   490 

   491 void DChannelComm::TxComplete()

   492 {

   493 	if (NKern::CurrentContext()==NKern::EInterrupt)

   494 		iTxCompleteDfc.Add(); 

   495 	else

   496 		DoCompleteTx();			

   497 }

   498 

   499 

   500 void DChannelComm::FillTxDfc(TAny* aPtr)

   501 	{

   502 	DChannelComm *pC=(DChannelComm*)aPtr;

   503 	pC->DoFillTxBuffer();

   504 	}

   505 

   506 // Fill TX buffer in a DFC

   507 void DChannelComm::DoFillTxBuffer()

   508 	{

   509     LOG(("DFTB %d =%d",iTxDesPos,iTxBufReq.iLen));

   510 	if (iTxBufReq.iBuf && iTxDesPos<iTxBufReq.iLen)

   511         {

   512         TInt space=iTxBufSize-TxCount()-1;

   513         TInt remaining=iTxBufReq.iLen-iTxDesPos;

   514         TInt len=Min(space,remaining);              // number of chars to transfer

   515         TInt len1=Min(len,iTxBufSize-iTxPutIndex);  // number of chars to wrap point

   516         TPtr8 des(iTxBuffer+iTxPutIndex,len1,len1);

   517         LOG(("DFTxB sp = %d rem = %d iOPH = %d",space, remaining,iOutputHeld));

   518 		TInt r=Kern::ThreadBufRead(iClient, iTxBufReq.iBuf, des, iTxDesPos, KChunkShiftBy0);

   519         if (r != KErrNone)

   520             {

   521             iTxError=r;

   522             DoCompleteTx();

   523             return;

   524             }

   525 

   526         TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   527         iTxDesPos+=len1;

   528         iTxPutIndex+=len1;

   529         if (iTxPutIndex>=iTxBufSize)

   530             iTxPutIndex-=iTxBufSize;

   531         __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   532 

   533         len-=len1;

   534         if (len)

   535             {

   536             des.Set(iTxBuffer,len,len);

   537 			r=Kern::ThreadBufRead(iClient, iTxBufReq.iBuf, des, iTxDesPos, KChunkShiftBy0);

   538             if (r != KErrNone)

   539                 {

   540                 iTxError=r;

   541                 DoCompleteTx();

   542                 return;

   543                 }

   544 

   545             irq = __SPIN_LOCK_IRQSAVE(iLock);

   546             iTxDesPos+=len;

   547             iTxPutIndex+=len;

   548             __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   549             }

   550         if (iTxDesPos==iTxBufReq.iLen)

   551             {

   552             // we have used up the client descriptor

   553             if (iConfig.iHandshake & KConfigWriteBufferedComplete)

   554                 {

   555                 iTxOutstanding=EFalse;

   556                 DoCompleteTx();

   557                 }

   558             }

   559         // if TX buffer not empty and not flow controlled, make sure TX is enabled

   560         if (iTxPutIndex!=iTxGetIndex  && (!iOutputHeld))

   561             {

   562             LOG(("Calling - DoTxBuff->ETx"));

   563             EnableTransmit();

   564             }

   565         }

   566     }

   567 

   568 void DChannelComm::CompleteTxDfc(TAny* aPtr)

   569 	{

   570 	DChannelComm *pC=(DChannelComm*)aPtr;

   571 	pC->DoCompleteTx();

   572 	}

   573 

   574 void DChannelComm::DoCompleteTx()

   575 	{

   576 	Complete(ETx,iTxError);

   577 	iTxError=KErrNone;

   578 	}

   579 

   580 void DChannelComm::Start()

   581 //

   582 // Start the driver receiving.

   583 //

   584 	{

   585 	LOG(("Start()"));

   586 	if (iStatus!=EClosed)

   587 		{

   588 		PddConfigure(iConfig);

   589 		PddStart();

   590 		iStatus=EActive;

   591 		if ((iConfig.iHandshake & KConfigSendXoff) && iJamChar>=0)

   592 			EnableTransmit(); // Send XOn if there is one

   593 		}

   594 	}

   595 

   596 void DChannelComm::BreakOn()

   597 //

   598 // Start the driver breaking.

   599 //

   600 	{

   601 	LOG(("BreakOn()"));

   602 	iFlags&=(~KBreakPending);

   603 	iFlags|=KBreaking;

   604 	PddBreak(ETrue);

   605 	iBreakTimer.OneShot(iBreakTimeMicroSeconds, DChannelComm::FinishBreak, this);

   606 	}

   607 

   608 void DChannelComm::BreakOff()

   609 //

   610 // Stop the driver breaking.

   611 //

   612 	{

   613 	LOG(("BreakOff()"));

   614 	PddBreak(EFalse);

   615 	iFlags&=(~(KBreakPending|KBreaking));

   616 	}

   617 

   618 void DChannelComm::AssertFlowControl()

   619 	{

   620 	iInputHeld=ETrue;

   621 	SetSignals(0,iFlowControlSignals);

   622 	if (iConfig.iHandshake&KConfigSendXoff)		// Doing input XON/XOFF

   623 		{

   624 		iJamChar=iConfig.iXoffChar;				// set up to send Xoff

   625 		EnableTransmit();						// Make sure we are transmitting

   626 		}

   627 	}

   628 

   629 void DChannelComm::ReleaseFlowControl()

   630 	{

   631 	iInputHeld=EFalse;

   632 	SetSignals(iFlowControlSignals,0);

   633 	if (iConfig.iHandshake&KConfigSendXoff)		// Doing input XON/XOFF

   634 		{

   635 		iJamChar=iConfig.iXonChar;				// set up to send Xon

   636 		EnableTransmit();						// Make sure we are transmitting

   637 		}

   638 	}

   639 

   640 TInt DChannelComm::SetRxBufferSize(TInt aSize)

   641 //

   642 // Set the receive buffer size.

   643 //

   644 	{

   645 	LOG(("SetRxBufferSize(aSize=0x%X)", aSize));

   646 	aSize=(aSize+3)&~3;

   647 	TUint8 *newBuf=(TUint8*)Kern::ReAlloc(iRxCharBuf,aSize<<1);

   648 	if (!newBuf)

   649 		return KErrNoMemory;

   650 	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   651 	iRxCharBuf=newBuf;

   652 	iRxErrorBuf=newBuf+aSize;

   653 	iRxBufSize=aSize;

   654 	iFlowControlLowerThreshold=aSize>>2;

   655 	iFlowControlUpperThreshold=3*aSize>>2;

   656 	iRxDrainThreshold=aSize>>1;

   657 	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   658 	ResetBuffers(EFalse);

   659 	return KErrNone;

   660 	}

   661 

   662 TInt DChannelComm::TurnaroundSet(TUint aNewTurnaroundMilliSeconds)

   663 	{

   664 	LOG(("TurnaroundSet(val=0x%X)", aNewTurnaroundMilliSeconds));

   665 	TInt r = KErrNone;

   666 	iTurnaroundMinMilliSeconds = aNewTurnaroundMilliSeconds;

   667 	return r;

   668 	}

   669 

   670 TBool DChannelComm::TurnaroundStopTimer()

   671 // Stop the timer and DFC

   672 	{

   673 	LOG(("TurnaroundStopTimer()"));

   674 	

   675 	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   676 	TBool result = iTurnaroundTimerRunning;

   677 	if(result)

   678 		iTurnaroundTimerRunning = EFalse;	

   679 	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   680 

   681 	if (result)

   682 		{

   683 		iTurnaroundTimer.Cancel();

   684 		iTurnaroundDfc.Cancel();

   685 		}

   686 	return result;

   687 	}

   688 

   689 TInt DChannelComm::TurnaroundClear()

   690 // Clear any old timer and start timer based on new turnaround timer

   691 // Called for any change: from T > 0 to T == 0 or (T = t1 > 0) to (T = t2 > 0)

   692 // POLICY: If a write has already been delayed, it will be started immediately if the requested 

   693 // turnaround time is elapsed else will only start after it is elapsed.

   694 	{

   695 	LOG(("TurnaroundClear()"));

   696 	TInt r = KErrNone;

   697 	TUint delta = 0;

   698 

   699 	if(iTurnaroundTimerStartTimeValid == 1)

   700 		{

   701 		//Calculate the turnaround time elapsed so far.

   702 		delta = (NKern::TickCount() - iTurnaroundTimerStartTime) * NKern::TickPeriod();

   703 		}

   704     if(delta < iTurnaroundMicroSeconds)

   705 		{

   706         iTurnaroundMinMilliSeconds = (iTurnaroundMicroSeconds - delta)/1000;

   707         iTurnaroundTimerStartTimeValid = 3; //Just to make sure that the turnaround timer start time is not captured.

   708         RestartTurnaroundTimer();

   709 		}

   710     else

   711 		{

   712 		if(TurnaroundStopTimer())

   713 			{

   714 			// if a write is waiting, start a DFC to run it

   715 			TurnaroundStartDfcImplementation(EFalse);

   716 			}

   717 		}

   718 	iTurnaroundMinMilliSeconds = 0;

   719 	return r;

   720 	}

   721 

   722 TInt DChannelComm::RestartTurnaroundTimer()

   723 	{

   724 	LOG(("RestartTurnaroundTimer()"));

   725 	TInt r=KErrNone;

   726 

   727 	// POLICY: if timer is running from a previous read, stop it and re-start it

   728 	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   729 	TBool cancelDfcs = (iTurnaroundMinMilliSeconds > 0) && iTurnaroundTimerRunning;

   730 	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   731 	if (cancelDfcs) 

   732 		{

   733 		iTurnaroundTimer.Cancel();

   734 		iTurnaroundDfc.Cancel();

   735 		}

   736 

   737 	// Start the timer & update driver state to reflect that the timer is running

   738 	TInt timeout = 0;

   739 	irq = __SPIN_LOCK_IRQSAVE(iLock);

   740 	if(iTurnaroundMinMilliSeconds > 0)

   741 		{

   742 		iTurnaroundTimerRunning = ETrue;

   743 		timeout = NKern::TimerTicks(iTurnaroundMinMilliSeconds);

   744 		//Record the time stamp of turnaround timer start

   745 		if(iTurnaroundTimerStartTimeValid != 3)

   746 		    iTurnaroundTimerStartTime = NKern::TickCount();

   747 		iTurnaroundTimerStartTimeValid = 1;

   748 		}

   749 	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   750 	if (timeout)

   751 		r=iTurnaroundTimer.OneShot(timeout);

   752 	return r;

   753 	}

   754 

   755 void DChannelComm::TurnaroundStartDfc(TAny* aSelf)

   756 	{

   757 	DChannelComm* self = (DChannelComm*)aSelf;

   758 	self->TurnaroundStartDfcImplementation(ETrue);		// in ISR so Irqs are already disabled

   759 	}

   760 

   761 void DChannelComm::TurnaroundStartDfcImplementation(TBool aInIsr)

   762 	{

   763 	LOG(("TurnaroundStartDfcImplementation(inIsr=%d)", aInIsr));

   764 	TInt irq=0;

   765     if(!aInIsr)

   766 		irq = __SPIN_LOCK_IRQSAVE(iLock);

   767 	else 

   768 		__SPIN_LOCK(iLock);

   769 

   770 	iTurnaroundTimerRunning = EFalse;

   771 	if(iTurnaroundTransmitDelayed || iTurnaroundBreakDelayed)

   772 		{

   773         if(aInIsr)

   774 			iTurnaroundDfc.Add();

   775 		else

   776 			{

   777 			if(!aInIsr)

   778 				__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   779 			else 

   780 				__SPIN_UNLOCK(iLock);

   781 			iTurnaroundDfc.Enque();

   782 			return;

   783 			}

   784 		}

   785     if(!aInIsr)

   786 		__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   787 	else 

   788 		__SPIN_UNLOCK(iLock);

   789 	}

   790 

   791 void DChannelComm::TurnaroundTimeout(TAny* aSelf)

   792 	{

   793 	DChannelComm* self = (DChannelComm*)aSelf;

   794 	self->TurnaroundTimeoutImplementation();

   795 	}

   796 

   797 void DChannelComm::TurnaroundTimeoutImplementation()

   798 	{

   799 	LOG(("TurnaroundTimeoutImplementation()"));

   800 	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   801 	

   802 	if(iTurnaroundBreakDelayed)

   803 		{

   804 		iTurnaroundBreakDelayed=EFalse;

   805 		if (iStatus==EClosed)

   806 			{

   807             __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   808 			Complete(EBreak, KErrNotReady);

   809 			return;

   810 			}

   811 		else if(IsLineFail(iFailSignals))	// have signals changed in the meantime?

   812 			{

   813             __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   814 			Complete(EBreak, KErrCommsLineFail);	// protected -> changed in signals ISR

   815 			return;

   816 			}

   817 		if (iTurnaroundTransmitDelayed)

   818 			{

   819 			//delay write by break instead of turnaround

   820 			iBreakDelayedTx = ETrue;

   821 			iTurnaroundTransmitDelayed=EFalse;

   822 			}

   823 		__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   824         BreakOn();

   825 		}

   826 	else if(iTurnaroundTransmitDelayed)

   827 		{

   828 		iTurnaroundTransmitDelayed = EFalse;		// protected -> prevent reentrant ISR

   829 		__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   830 		

   831 		RestartDelayedTransmission();

   832 		}

   833 	else 

   834 		__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   835 	}

   836 

   837 void DChannelComm::ResetBuffers(TBool aResetTx)

   838 //

   839 // Reset the receive and maybe the transmit buffer.

   840 //

   841 	{

   842 	LOG(("ResetBuffers(aResetTx=%d)", aResetTx));

   843 	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

   844 	iRxPutIndex=0;

   845 	iRxGetIndex=0;

   846 	iRxBufCompleteIndex=0;

   847 	if (aResetTx)

   848 		{

   849 		iTxPutIndex=0;

   850 		iTxGetIndex=0;

   851 		}

   852 	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

   853 

   854 	if (iStatus==EActive)

   855 		ReleaseFlowControl();

   856 	iInputHeld=EFalse;

   857 	}

   858 

   859 TInt DChannelComm::TransmitIsr()

   860 //

   861 // Return the next character to be transmitted to the ISR

   862 //

   863 	{

   864 	TInt tChar=iJamChar;			// Look for control character to jam in

   865     if (tChar>=0)					// Control character to send

   866         {

   867 		iJamChar=KTxNoChar;

   868 		}

   869     else if (!iOutputHeld && iTxGetIndex!=iTxPutIndex)

   870         {

   871 		// Get spinlock, disable interrupts to ensure we can reach the unlock 

   872 		// statement. An FIQ before unlock that attempted to get lock would 

   873 		// lead to CPU deadlock

   874 		TInt irqstate = __SPIN_LOCK_IRQSAVE(iLock);

   875 		

   876 		// output not held and buffer not empty, get next char

   877 		tChar=iTxBuffer[iTxGetIndex++];

   878 		if (iTxGetIndex==iTxBufSize)

   879 			iTxGetIndex=0;

   880 			

   881 		__SPIN_UNLOCK_IRQRESTORE(iLock, irqstate);

   882 		}

   883 

   884 	return tChar;

   885 	}

   886 

   887 void DChannelComm::ReceiveIsr(TUint* aChar, TInt aCount, TInt aXonXoff)

   888 //

   889 // Handle received character block from the ISR.

   890 // aChar points to received characters, aCount=number received,

   891 // aXonXoff=1 if XON received, -1 if XOFF received, 0 if neither

   892 //

   893 	{

   894 	if (aXonXoff>0)

   895 		{

   896 		iOutputHeld &= ~KXoffSignal;	// Mark output ok. for XON/XOFF

   897 		if (iOutputHeld==0)

   898 			EnableTransmit();

   899 		}

   900 	else if (aXonXoff<0)

   901 		{

   902 		iOutputHeld |= KXoffSignal;		// Mark output held for XON/XOFF

   903 		}

   904 	if (aCount==0)						// if only XON or XOFF received

   905 		return;

   906 

   907 	// Get spinlock, disable interrupts to ensure we can reach the unlock 

   908 	// statement. An FIQ before unlock that attempted to get lock would 

   909 	// lead to CPU deadlock

   910 	TInt irqstate = __SPIN_LOCK_IRQSAVE(iLock);

   911 

   912 	TInt count = RxCount();

   913 	iReceived++;

   914 

   915 	// At or above the high water mark send xoff every other character

   916     if (count>=iFlowControlUpperThreshold && ((count&1)!=0 || aCount>1))

   917 		AssertFlowControl();

   918 

   919 	TUint* pE=aChar+aCount;

   920 	TInt e=KErrNone;

   921 	TInt i=iRxPutIndex;

   922 	TInt g=iRxGetIndex;

   923 	TInt s=iRxBufSize;

   924 	g=g?g-1:s-1;

   925 	TInt p=iRxOutstanding?-1:0;

   926     TInt thresh=iRxBufReq.iLen-iRxDesPos;

   927 	while(aChar<pE)

   928 		{

   929 		TUint c=*aChar++;

   930 

   931 		// Check for parity errors and replace char if so configured.

   932 		if (c & KReceiveIsrParityError)

   933 			{

   934 			// Replace bad character

   935 			if (iConfig.iParityError==KConfigParityErrorReplaceChar)

   936 				c = c & ~(0xff|KReceiveIsrParityError) | iConfig.iParityErrorChar;

   937 			// Ignore parity error

   938 			if (iConfig.iParityError==KConfigParityErrorIgnore)

   939 				c = c & ~KReceiveIsrParityError;

   940 			}

   941 		

   942 		if (i!=g)

   943 			{

   944 			iRxCharBuf[i]=(TUint8)c;

   945 			iRxErrorBuf[i]=(TUint8)(c>>24);

   946 

   947 			if (c & KReceiveIsrMaskError)

   948 				{

   949 				__UART_RX_ERROR(c);

   950 				if (c & KReceiveIsrOverrunError)

   951 					e = KErrCommsOverrun;

   952 				else if (c & KReceiveIsrBreakError)

   953 					e = KErrCommsBreak;

   954 				else if (c & KReceiveIsrFrameError)

   955 					e = KErrCommsFrame;

   956 				else if (c & KReceiveIsrParityError)

   957 					e = KErrCommsParity;

   958 				}

   959 			count++;

   960 			if (++i==s)

   961 				i=0;

   962 			if (p<0)

   963 				{

   964 				if (e || IsTerminator(TUint8(c)) || count==thresh)

   965 					{

   966 					// need to complete client request

   967 					iRxError = e;

   968 					p=i;

   969 					}

   970 				}

   971 			}

   972 		else

   973 			{

   974 			__OVERRUN();

   975 			// buffer overrun, discard character

   976 			e=KErrCommsOverrun;

   977 

   978 			// make sure client is informed of overrun error

   979 			iRxError=e;

   980 

   981 			// discard remaining characters and complete

   982 			p=i;

   983 			break;

   984 			}

   985 		}

   986 	iRxPutIndex=i;

   987 

   988 	if (iRxOutstanding)

   989 		{

   990 		if (p>=0)

   991 			{

   992 			// need to complete client request

   993 			iRxBufCompleteIndex=p;

   994 			iRxOutstanding=EFalse;

   995             RxComplete();

   996 			}

   997 		else if (count>=iRxDrainThreshold)

   998 			{

   999 			// drain buffer but don't complete

  1000 			DrainRxBuffer();

  1001 			}

  1002 		else if (iRxOneOrMore<0)

  1003 			{

  1004 			// doing read one or more - drain the buffer

  1005 			// this will start the timer

  1006 			iRxOneOrMore=1;

  1007 			DrainRxBuffer();

  1008 			}

  1009 		}

  1010 

  1011 	__SPIN_UNLOCK_IRQRESTORE(iLock, irqstate);

  1012 

  1013 	if (iNotifyData)

  1014 		{

  1015 		iNotifyData=EFalse;

  1016         RxComplete();

  1017 		}

  1018 	}

  1019 

  1020 void DChannelComm::CheckTxBuffer()

  1021 	{

  1022 	// if buffer count < threshold, fill from client buffer

  1023 	TInt count=TxCount();

  1024     if (iTxOutstanding && iTxDesPos<iTxBufReq.iLen && count<iTxFillThreshold)

  1025 		iTxFillDfc.Add();

  1026 	else if (count==0)

  1027 		{

  1028 		// TX buffer is now empty - see if we need to complete anything

  1029 		if (iTxOutstanding)

  1030 			{

  1031             if (iTxBufReq.iLen==0)

  1032 				{

  1033 				// request was a zero-length write - complete if hardware flow control

  1034 				// is not asserted

  1035 				if ((~iSignals & iHoldSignals)==0)

  1036 					{

  1037 					iTxOutstanding=EFalse;

  1038                     TxComplete();

  1039 					}

  1040 				}

  1041 			else

  1042 				{

  1043 				// request was normal TX - complete now if not doing early completion

  1044 				if (!(iConfig.iHandshake&KConfigWriteBufferedComplete))

  1045 					{

  1046 					iTxOutstanding=EFalse;

  1047 					TxComplete();

  1048 					}

  1049 				}

  1050 			}

  1051 		}

  1052 	}

  1053 

  1054 

  1055 //

  1056 // Pdd callback

  1057 //

  1058 void DChannelComm::UpdateSignals(TUint aSignals)

  1059 	{

  1060     __KTRACE_OPT(KHARDWARE,Kern::Printf("CommSig: Upd %08x",aSignals));

  1061     iSignals=(iSignals&~KDTEInputSignals)|(aSignals&KDTEInputSignals);

  1062     DoSigNotify();	

  1063 	}

  1064 

  1065 

  1066 

  1067 /**

  1068  Handle a state change from the PDD. Called in ISR or DFC context.

  1069  */

  1070 void DChannelComm::StateIsr(TUint aSignals)

  1071     {

  1072     iSignals=(iSignals&~KDTEInputSignals)|(aSignals&KDTEInputSignals);

  1073     if (iSignalsReq->IsReady() && ((iSignals^iNotifiedSignals)&iSigNotifyMask) )

  1074         {

  1075         iSigNotifyDfc.Add();

  1076         }

  1077     if (IsLineFail(iFailSignals))

  1078         {

  1079         if (iRxOutstanding)

  1080             {

  1081             iRxError=KErrCommsLineFail;

  1082             iRxBufCompleteIndex=iRxPutIndex;

  1083             iRxOutstanding=EFalse;

  1084 			RxComplete();				

  1085             }

  1086         if (iTxOutstanding)

  1087             {

  1088             iTxError = KErrCommsLineFail;

  1089             iTxOutstanding=EFalse;

  1090 			TxComplete();

  1091 			}

  1092         }

  1093 

  1094 	//

  1095 	// Now we must determine if output is to be held

  1096 	//

  1097     TUint status = ~iSignals & iHoldSignals;

  1098     if (iOutputHeld & KXoffSignal)

  1099         status |= KXoffSignal;      // Leave the xon/xoff handshake bit

  1100 

  1101     LOG(("State - ISR - 0x%x",status));

  1102     iOutputHeld=status;             // record new flow control state

  1103     if (iTxGetIndex==iTxPutIndex)

  1104         {

  1105         // Tx buffer is empty

  1106         if (iTxOutstanding && iTxBufReq.iLen==0 && (status&~KXoffSignal)==0)

  1107             {

  1108             // if hardware flow control released, complete zero-length write

  1109             iTxOutstanding=EFalse;

  1110 			TxComplete();

  1111 			}

  1112         }

  1113     else if (status==0)

  1114         {

  1115         // Tx buffer not empty and flow control released, so restart transmission

  1116         LOG(("Calling LDD:EnTx"));

  1117         EnableTransmit();

  1118         }

  1119     }

  1120 

  1121 // check if transmitter is flow controlled

  1122 void DChannelComm::CheckOutputHeld()

  1123 	{

  1124 	iOutputHeld=(iOutputHeld & KXoffSignal) | (~iSignals & iHoldSignals);

  1125     LOG(("CheckOPH IOH = %d",iOutputHeld));

  1126 	}

  1127 

  1128 void DChannelComm::HandleMsg(TMessageBase* aMsg)

  1129 	{

  1130 

  1131 	if (iStandby)

  1132 		{ // postpone message handling to transition from standby

  1133 		iMsgHeld=ETrue;

  1134 		return;