1 /*

     1 /*

     3 * All rights reserved.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     6 * which accompanies this distribution, and is available

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

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

    14 * Description:

    14 * Description:

    15 *

    15 *

    16 */

    16 */

    17 

    17 

    18 #include <acminterface.h>

    18 #include <acminterface.h>

    19 #include "AcmPort.h"

    20 #include "AcmPort.h"

    20 #include "AcmPortFactory.h"

    21 #include "AcmPortFactory.h"

    21 #include "AcmUtils.h"

    22 #include "AcmUtils.h"

    22 #include "AcmWriter.h"

    23 #include "AcmWriter.h"

    23 #include "AcmReader.h"

    24 #include "AcmReader.h"

    24 #include "AcmPanic.h"

    25 #include "AcmPanic.h"

    28 #endif

    29 #endif

    29 

    30 

    30 const TUint KCapsRate=(   KCapsBps50

    31 const TUint KCapsRate=(   KCapsBps50

    31 						| KCapsBps75

    32 						| KCapsBps75

    32 						| KCapsBps110

    33 						| KCapsBps110

    91  * closes.

    92  * closes.

    92  * @param aUnit The port number.

    93  * @param aUnit The port number.

    93  * @return Ownership of a newly created CAcmPort object

    94  * @return Ownership of a newly created CAcmPort object

    94  */

    95  */

    95 	{

    96 	{

    98 	CAcmPort* self = new(ELeave) CAcmPort(aUnit, aFactory);

    99 	CAcmPort* self = new(ELeave) CAcmPort(aUnit, aFactory);

    99 	CleanupClosePushL(*self);

   100 	CleanupClosePushL(*self);

   100 	self->ConstructL();

   101 	self->ConstructL();

   101 	CleanupStack::Pop();

   102 	CleanupStack::Pop();

   103 	return self;

   103 	return self;

   104 	}

   104 	}

   105 

   105 

   106 void CAcmPort::ConstructL()

   106 void CAcmPort::ConstructL()

   107 /**

   107 /**

   108  * Standard second phase constructor. Create owned classes and initialise the 

   108  * Standard second phase constructor. Create owned classes and initialise the 

   109  * port.

   109  * port.

   110  */

   110  */

   111 	{

   111 	{

   114 	iReader = CAcmReader::NewL(*this, KDefaultBufferSize);

   112 	iReader = CAcmReader::NewL(*this, KDefaultBufferSize);

   115 	iWriter = CAcmWriter::NewL(*this, KDefaultBufferSize);

   113 	iWriter = CAcmWriter::NewL(*this, KDefaultBufferSize);

   116 

   114 

   117 	TName name;

   115 	TName name;

   119 	name.Num(iUnit);

   116 	name.Num(iUnit);

   126 

   118 

   127 	iCommServerConfig.iBufFlags = 0;

   119 	iCommServerConfig.iBufFlags = 0;

   128 	iCommServerConfig.iBufSize = iReader->BufSize();

   120 	iCommServerConfig.iBufSize = iReader->BufSize();

   129 

   121 

   130 	iCommConfig.iRate			= KDefaultDataRate;

   122 	iCommConfig.iRate			= KDefaultDataRate;

   139 	iCommConfig.iXonChar		= KDefaultXon;

   131 	iCommConfig.iXonChar		= KDefaultXon;

   140 	iCommConfig.iXoffChar		= KDefaultXoff;

   132 	iCommConfig.iXoffChar		= KDefaultXoff;

   141 	iCommConfig.iParityErrorChar= 0;

   133 	iCommConfig.iParityErrorChar= 0;

   142 	iCommConfig.iSIREnable		= ESIRDisable;

   134 	iCommConfig.iSIREnable		= ESIRDisable;

   143 	iCommConfig.iSIRSettings	= 0;

   135 	iCommConfig.iSIRSettings	= 0;

   145 	}

   136 	}

   146 

   137 

   147 CAcmPort::CAcmPort(const TUint aUnit, MAcmPortObserver& aObserver) 

   138 CAcmPort::CAcmPort(const TUint aUnit, MAcmPortObserver& aObserver) 

   148  :	iCommNotification(iCommNotificationDes()),

   139  :	iCommNotification(iCommNotificationDes()),

   149 	iObserver(aObserver),

   140 	iObserver(aObserver),

   154  * @param aObserver The observer of the port, to be notified when the port 

   145  * @param aObserver The observer of the port, to be notified when the port 

   155  * closes.

   146  * closes.

   156  * @param aUnit The port number.

   147  * @param aUnit The port number.

   157  */

   148  */

   158 	{

   149 	{

   161 	}

   150 	}

   162 

   151 

   163 void CAcmPort::StartRead(const TAny* aClientBuffer, TInt aLength)

   152 void CAcmPort::StartRead(const TAny* aClientBuffer, TInt aLength)

   164 /**

   153 /**

   165  * Downcall from C32. Queue a read.

   154  * Downcall from C32. Queue a read.

   166  *

   155  *

   167  * @param aClientBuffer pointer to the client's buffer

   156  * @param aClientBuffer pointer to the client's buffer

   168  * @param aLength number of bytes to read

   157  * @param aLength number of bytes to read

   169  */

   158  */

   170 	{

   159 	{

   177 		ReadCompleted(KErrAccessDenied);

   168 		ReadCompleted(KErrAccessDenied);

   179 		return;

   169 		return;

   180 		}

   170 		}

   181 

   171 

   182 	// Analyse the request and call the relevant API on the data reader. NB We 

   172 	// Analyse the request and call the relevant API on the data reader. NB We 

   183 	// do not pass requests for zero bytes to the data reader. They are an 

   173 	// do not pass requests for zero bytes to the data reader. They are an 

   184 	// RComm oddity we should handle here.

   174 	// RComm oddity we should handle here.

   190 

   176 

   191 	if(iReader->IsNotifyDataAvailableQueryPending())

   177 	if(iReader->IsNotifyDataAvailableQueryPending())

   192 		{

   178 		{

   193 		ReadCompleted(KErrInUse);

   179 		ReadCompleted(KErrInUse);

   195 		return;

   180 		return;

   196 		}

   181 		}

   197 

   182 

   198 	if ( aLength < 0 )

   183 	if ( aLength < 0 )

   199 		{

   184 		{

   205 		}

   190 		}

   206 	else

   191 	else

   207 		{

   192 		{

   208 		// Obscure RComm API feature- complete zero-length Read immediately, 

   193 		// Obscure RComm API feature- complete zero-length Read immediately, 

   209 		// to indicate that the hardware is powered up.

   194 		// to indicate that the hardware is powered up.

   211 		ReadCompleted(KErrNone);

   196 		ReadCompleted(KErrNone);

   212 		}

   197 		}

   214 	}

   198 	}

   215 

   199 

   216 void CAcmPort::ReadCancel()

   200 void CAcmPort::ReadCancel()

   217 /**

   201 /**

   218  * Downcall from C32. Cancel a read.

   202  * Downcall from C32. Cancel a read.

   219  */

   203  */

   220 	{

   204 	{

   226 		return;

   211 		return;

   227 		}

   212 		}

   228 

   213 

   234 	iReader->ReadCancel();

   215 	iReader->ReadCancel();

   236 	}

   216 	}

   237 

   217 

   238 TInt CAcmPort::QueryReceiveBuffer(TInt& aLength) const

   218 TInt CAcmPort::QueryReceiveBuffer(TInt& aLength) const

   239 /**

   219 /**

   240  * Downcall from C32. Get the amount of data in the receive buffer.

   220  * Downcall from C32. Get the amount of data in the receive buffer.

   241  *

   221  *

   242  * @param aLength reference to where the amount will be written to

   222  * @param aLength reference to where the amount will be written to

   243  * @return Error.

   223  * @return Error.

   244  */

   224  */

   245 	{

   225 	{

   247 	

   228 	

   248 	if ( !iAcm )

   229 	if ( !iAcm )

   249 		{

   230 		{

   252 		return KErrAccessDenied;

   232 		return KErrAccessDenied;

   253 		}

   233 		}

   254 

   234 

   260 	aLength = static_cast<TInt>(iReader->BufLen());

   236 	aLength = static_cast<TInt>(iReader->BufLen());

   263 	return KErrNone;

   238 	return KErrNone;

   264 	}

   239 	}

   265 

   240 

   266 void CAcmPort::ResetBuffers(TUint aFlags)

   241 void CAcmPort::ResetBuffers(TUint aFlags)

   267 /**

   242 /**

   268  * Downcall from C32. Reset zero or more of the Tx and Rx buffers.

   243  * Downcall from C32. Reset zero or more of the Tx and Rx buffers.

   269  *

   244  *

   270  * @param aFlags Flags indicating which buffer(s) to reset.

   245  * @param aFlags Flags indicating which buffer(s) to reset.

   271  */

   246  */

   272 	{

   247 	{

   275 

   250 

   276 	if ( aFlags & KCommResetRx )

   251 	if ( aFlags & KCommResetRx )

   277 		{

   252 		{

   284 		iReader->ResetBuffer();

   255 		iReader->ResetBuffer();

   285 		}

   256 		}

   286 

   257 

   287 	if ( aFlags & KCommResetTx )

   258 	if ( aFlags & KCommResetTx )

   288 		{

   259 		{

   295 		iWriter->ResetBuffer();

   262 		iWriter->ResetBuffer();

   296 		}

   263 		}

   297 

   264 

   299 	}

   266 	}

   300 

   267 

   301 void CAcmPort::StartWrite(const TAny* aClientBuffer, TInt aLength)

   268 void CAcmPort::StartWrite(const TAny* aClientBuffer, TInt aLength)

   302 /**

   269 /**

   303  * Downcall from C32. Queue a write

   270  * Downcall from C32. Queue a write

   304  *

   271  *

   305  * @param aClientBuffer pointer to the Client's buffer

   272  * @param aClientBuffer pointer to the Client's buffer

   306  * @param aLength number of bytes to write

   273  * @param aLength number of bytes to write

   307  */

   274  */

   308 	{

   275 	{

   315 		WriteCompleted(KErrAccessDenied);

   284 		WriteCompleted(KErrAccessDenied);

   317 		return;

   285 		return;

   318 		}

   286 		}

   319 

   287 

   320 	if ( aLength < 0 )

   288 	if ( aLength < 0 )

   321 		{

   289 		{

   322 		// Negative length makes no sense.

   290 		// Negative length makes no sense.

   324 		WriteCompleted(KErrArgument);

   293 		WriteCompleted(KErrArgument);

   326 		return;

   294 		return;

   327 		}

   295 		}

   328 

   296 

   329 	// NB We pass zero-byte writes down to the LDD as normal. This results in 

   297 	// NB We pass zero-byte writes down to the LDD as normal. This results in 

   330 	// a zero-length packet being sent to the host.

   298 	// a zero-length packet being sent to the host.

   336 	iWriter->Write(aClientBuffer, static_cast<TUint>(aLength));

   301 	iWriter->Write(aClientBuffer, static_cast<TUint>(aLength));

   338 	}

   302 	}

   339 

   303 

   340 void CAcmPort::WriteCancel()

   304 void CAcmPort::WriteCancel()

   341 /**

   305 /**

   342  * Downcall from C32. Cancel a pending write

   306  * Downcall from C32. Cancel a pending write

   343  */

   307  */

   344 	{

   308 	{

   346 	

   311 	

   347 	if ( !iAcm )

   312 	if ( !iAcm )

   348 		{

   313 		{

   351 		return;

   315 		return;

   352 		}

   316 		}

   353 

   317 

   359 	iWriter->WriteCancel();

   319 	iWriter->WriteCancel();

   361 	}

   320 	}

   362 

   321 

   363 void CAcmPort::Break(TInt aTime)

   322 void CAcmPort::Break(TInt aTime)

   364 /**

   323 /**

   365  * Downcall from C32. Send a break signal to the host.

   324  * Downcall from C32. Send a break signal to the host.

   367  * break signals sent from the host.

   326  * break signals sent from the host.

   368  *

   327  *

   369  * @param aTime Length of break in microseconds

   328  * @param aTime Length of break in microseconds

   370  */

   329  */

   371 	{

   330 	{

   379 		return;

   338 		return;

   380 		}

   339 		}

   381 

   340 

   382 	iBreak = ETrue;

   341 	iBreak = ETrue;

   383 	iCancellingBreak = EFalse;

   342 	iCancellingBreak = EFalse;

   385 	// Use the time value directly as microseconds are given. We are a USB 

   344 	// Use the time value directly as microseconds are given. We are a USB 

   386 	// 'device' so the RComm client is always on the device side.

   345 	// 'device' so the RComm client is always on the device side.

   387 	TInt err = iAcm->BreakRequest(CBreakController::EDevice,

   346 	TInt err = iAcm->BreakRequest(CBreakController::EDevice,

   388 		CBreakController::ETiming,

   347 		CBreakController::ETiming,

   389 		TTimeIntervalMicroSeconds32(aTime));

   348 		TTimeIntervalMicroSeconds32(aTime));

   391 	// Note that the break controller may refuse our request if a host-driven 

   350 	// Note that the break controller may refuse our request if a host-driven 

   392 	// break is outstanding.

   351 	// break is outstanding.

   393 	if ( err )

   352 	if ( err )

   394 		{

   353 		{

   396 		iBreak = EFalse;

   355 		iBreak = EFalse;

   397 		BreakCompleted(err);

   356 		BreakCompleted(err);

   398 		}						

   357 		}						

   400 	}

   358 	}

   401 

   359 

   402 void CAcmPort::BreakCancel()

   360 void CAcmPort::BreakCancel()

   403 /**

   361 /**

   404  * Downcall from C32. Cancel a pending break.

   362  * Downcall from C32. Cancel a pending break.

   405  */

   363  */

   406 	{

   364 	{

   412 		return;

   371 		return;

   413 		}

   372 		}

   414 	

   373 	

   415 	iCancellingBreak = ETrue;

   374 	iCancellingBreak = ETrue;

   416 	TInt err = iAcm->BreakRequest(CBreakController::EDevice,

   376 	TInt err = iAcm->BreakRequest(CBreakController::EDevice,

   417 		CBreakController::EInactive);

   377 		CBreakController::EInactive);

   418 	// Note that the device cannot turn off a break if there's a host-driven 

   378 	// Note that the device cannot turn off a break if there's a host-driven 

   419 	// break in progress.

   379 	// break in progress.

   421 	if ( err )

   381 	if ( err )

   422 		{

   382 		{

   423 		iCancellingBreak = EFalse;

   383 		iCancellingBreak = EFalse;

   424 		}

   384 		}

   425 

   385 

   426 	// Whether BreakOff worked or not, reset our flag saying we're no longer 

   386 	// Whether BreakOff worked or not, reset our flag saying we're no longer 

   427 	// interested in any subsequent completion anyway.

   387 	// interested in any subsequent completion anyway.

   428 	iBreak = EFalse;

   388 	iBreak = EFalse;

   430 	}

   389 	}

   431 

   390 

   432 TInt CAcmPort::GetConfig(TDes8& aDes) const

   391 TInt CAcmPort::GetConfig(TDes8& aDes) const

   433 /**

   392 /**

   434  * Downcall from C32. Pass a config request. Only supports V01.

   393  * Downcall from C32. Pass a config request. Only supports V01.

   435  *

   394  *

   436  * @param aDes config will be written to this descriptor 

   395  * @param aDes config will be written to this descriptor 

   437  * @return Error.

   396  * @return Error.

   438  */

   397  */

   439 	{

   398 	{

   445 		return KErrAccessDenied;

   405 		return KErrAccessDenied;

   446 		}

   406 		}

   447 

   407 

   448 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommConfigV01)) )

   408 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommConfigV01)) )

   449 		{

   409 		{

   452 		return KErrNotSupported;

   411 		return KErrNotSupported;

   453 		}

   412 		}

   454 

   413 

   455 	TCommConfig commConfigPckg;

   414 	TCommConfig commConfigPckg;

   456 	TCommConfigV01& commConfig = commConfigPckg();

   415 	TCommConfigV01& commConfig = commConfigPckg();

   457 	commConfig = iCommConfig;

   416 	commConfig = iCommConfig;

   458 	aDes.Copy(commConfigPckg);

   418 	aDes.Copy(commConfigPckg);

   473 	return KErrNone;

   436 	return KErrNone;

   474 	}

   437 	}

   475 

   438 

   476 TInt CAcmPort::SetConfig(const TDesC8& aDes)

   439 TInt CAcmPort::SetConfig(const TDesC8& aDes)

   477 /**

   440 /**

   479  *

   442  *

   480  * @param aDes descriptor containing the new config

   443  * @param aDes descriptor containing the new config

   481  * @return Error

   444  * @return Error

   482  */

   445  */

   483 	{

   446 	{

   489 		return KErrAccessDenied;

   453 		return KErrAccessDenied;

   490 		}

   454 		}

   491 

   455 

   494 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommConfigV01)) )

   462 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommConfigV01)) )

   495 		{

   463 		{

   498 		return KErrNotSupported;

   465 		return KErrNotSupported;

   499 		}

   466 		}

   500 

   467 

   501 	TCommConfig configPckg;

   468 	TCommConfig configPckg;

   502 	configPckg.Copy(aDes);

   469 	configPckg.Copy(aDes);

   503 	TCommConfigV01& config = configPckg();

   470 	TCommConfigV01& config = configPckg();

   504 

   471 

   516 

   484 

   517 	// Tell the reader object about the new terminators. Pass the whole config 

   485 	// Tell the reader object about the new terminators. Pass the whole config 

   518 	// struct by reference for ease.

   486 	// struct by reference for ease.

   519 	iReader->SetTerminators(config);

   487 	iReader->SetTerminators(config);

   520 

   488 

   523 		config.iParity,

   491 		config.iParity,

   524 		config.iStopBits,

   492 		config.iStopBits,

   525 		config.iHandshake);

   493 		config.iHandshake);

   526 	iCommConfig = config;

   494 	iCommConfig = config;

   527 

   495 

   529 	return KErrNone;

   496 	return KErrNone;

   530 	}

   497 	}

   531 

   498 

   532 void CAcmPort::HandleConfigNotification(TBps aRate,

   499 void CAcmPort::HandleConfigNotification(TBps aRate,

   533 										TDataBits aDataBits,

   500 										TDataBits aDataBits,

   541  * @param aParity		New parity check setting

   508  * @param aParity		New parity check setting

   542  * @param aStopBits 	New stop bit setting

   509  * @param aStopBits 	New stop bit setting

   543  * @param aHandshake	New handshake setting

   510  * @param aHandshake	New handshake setting

   544  */

   511  */

   545 	{

   512 	{

   554 			

   519 			

   555 	iCommNotification.iChangedMembers = 0;

   520 	iCommNotification.iChangedMembers = 0;

   556 

   521 

   557 	iCommNotification.iRate = aRate;

   522 	iCommNotification.iRate = aRate;

   558 	if ( iCommConfig.iRate != aRate )

   523 	if ( iCommConfig.iRate != aRate )

   584 		iCommNotification.iChangedMembers |= KHandshakeChanged;

   549 		iCommNotification.iChangedMembers |= KHandshakeChanged;

   585 		}

   550 		}

   586 

   551 

   587 	if ( iCommNotification.iChangedMembers )

   552 	if ( iCommNotification.iChangedMembers )

   588 		{

   553 		{

   590 		ConfigChangeCompleted(iCommNotificationDes,KErrNone);

   555 		ConfigChangeCompleted(iCommNotificationDes,KErrNone);

   591 		iNotifyConfigChange = EFalse;

   556 		iNotifyConfigChange = EFalse;

   592 		}

   557 		}

   593 

   558 

   595 	}

   560 	}

   596 

   561 

   597 TInt CAcmPort::SetServerConfig(const TDesC8& aDes)

   562 TInt CAcmPort::SetServerConfig(const TDesC8& aDes)

   598 /**

   563 /**

   599  * Downcall from C32. Set server config using a TCommServerConfigV01 package.

   564  * Downcall from C32. Set server config using a TCommServerConfigV01 package.

   600  *

   565  *

   601  * @param aDes package with new server configurations

   566  * @param aDes package with new server configurations

   602  * @return Error.

   567  * @return Error.

   603  */

   568  */

   604 	{

   569 	{

   610 		return KErrAccessDenied;

   576 		return KErrAccessDenied;

   611 		}

   577 		}

   612 

   578 

   613 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommServerConfigV01)) )

   579 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommServerConfigV01)) )

   614 		{

   580 		{

   617 		return KErrNotSupported;

   582 		return KErrNotSupported;

   618 		}

   583 		}

   619 

   584 

   620 	TCommServerConfig serverConfigPckg;

   585 	TCommServerConfig serverConfigPckg;

   621 	serverConfigPckg.Copy(aDes);

   586 	serverConfigPckg.Copy(aDes);

   622 	TCommServerConfigV01& serverConfig = serverConfigPckg();

   587 	TCommServerConfigV01& serverConfig = serverConfigPckg();

   623 

   588 

   624 	if ( serverConfig.iBufFlags != KCommBufferFull )

   589 	if ( serverConfig.iBufFlags != KCommBufferFull )

   625 		{

   590 		{

   628 		return KErrNotSupported;

   592 		return KErrNotSupported;

   629 		}

   593 		}

   630 

   594 

   631 	// Apply the buffer size setting to Rx and Tx buffers. 

   595 	// Apply the buffer size setting to Rx and Tx buffers. 

   632 	TInt err = DoSetBufferLengths(serverConfig.iBufSize);

   596 	TInt err = DoSetBufferLengths(serverConfig.iBufSize);

   633 	if ( err )

   597 	if ( err )

   634 		{

   598 		{

   635 		// Failure- the buffer lengths will have been left as they were, so 

   599 		// Failure- the buffer lengths will have been left as they were, so 

   636 		// just return error.

   600 		// just return error.

   639 		return err;

   602 		return err;

   640 		}

   603 		}

   641 

   604 

   642 	// Changed buffer sizes OK. Note that new config.

   605 	// Changed buffer sizes OK. Note that new config.

   643 	iCommServerConfig = serverConfig;

   606 	iCommServerConfig = serverConfig;

   645 	return KErrNone;

   607 	return KErrNone;

   646 	}

   608 	}

   647 

   609 

   648 TInt CAcmPort::GetServerConfig(TDes8& aDes)

   610 TInt CAcmPort::GetServerConfig(TDes8& aDes)

   649 /**

   611 /**

   651  *

   613  *

   652  * @param aDes server configs will be written to this descriptor

   614  * @param aDes server configs will be written to this descriptor

   653  * @return Error.

   615  * @return Error.

   654  */

   616  */

   655 	{

   617 	{

   661 		return KErrAccessDenied;

   624 		return KErrAccessDenied;

   662 		}

   625 		}

   663 

   626 

   664 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommServerConfigV01)) )

   627 	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommServerConfigV01)) )

   665 		{

   628 		{

   668 		return KErrNotSupported;

   630 		return KErrNotSupported;

   669 		}

   631 		}

   670 

   632 

   671 	TCommServerConfig* serverConfigPckg = 

   633 	TCommServerConfig* serverConfigPckg = 

   672 		reinterpret_cast<TCommServerConfig*>(&aDes);

   634 		reinterpret_cast<TCommServerConfig*>(&aDes);

   673 	TCommServerConfigV01& serverConfig = (*serverConfigPckg)();

   635 	TCommServerConfigV01& serverConfig = (*serverConfigPckg)();

   674 

   636 

   675 	serverConfig = iCommServerConfig;

   637 	serverConfig = iCommServerConfig;

   677 	return KErrNone;

   638 	return KErrNone;

   678 	}

   639 	}

   679 

   640 

   680 TInt CAcmPort::GetCaps(TDes8& aDes)

   641 TInt CAcmPort::GetCaps(TDes8& aDes)

   681 /**

   642 /**

   683  *

   644  *

   684  * @param aDes caps will be written to this descriptor

   645  * @param aDes caps will be written to this descriptor

   685  * @return Error.

   646  * @return Error.

   686  */

   647  */

   687 	{

   648 	{

   694 		return KErrAccessDenied;

   655 		return KErrAccessDenied;

   695 		}

   656 		}

   696 

   657 

   697 	TCommCaps2 capsPckg;

   658 	TCommCaps2 capsPckg;

   698 	TCommCapsV02& caps = capsPckg();

   659 	TCommCapsV02& caps = capsPckg();

   718 		caps.iSIR = KCapsSIR;

   679 		caps.iSIR = KCapsSIR;

   719 		}

   680 		}

   720 		break;

   681 		break;

   721 	default:

   682 	default:

   722 		{

   683 		{

   725 		return KErrArgument;

   685 		return KErrArgument;

   726 		}

   686 		}

   727 		}

   687 		}

   728 

   688 

   729 	aDes.Copy(capsPckg.Left(aDes.Length()));

   689 	aDes.Copy(capsPckg.Left(aDes.Length()));

   730 

   690 

   732 	return KErrNone;

   691 	return KErrNone;

   733 	}

   692 	}

   734 

   693 

   735 TInt CAcmPort::GetSignals(TUint& aSignals)

   694 TInt CAcmPort::GetSignals(TUint& aSignals)

   736 /**

   695 /**

   738  *

   697  *

   739  * @param aSignals signals will be written to this descriptor

   698  * @param aSignals signals will be written to this descriptor

   740  * @return Error.

   699  * @return Error.

   741  */

   700  */

   742 	{

   701 	{

   748 		return KErrAccessDenied;

   708 		return KErrAccessDenied;

   749 		}

   709 		}

   750 

   710 

   751 	aSignals = ConvertSignals(iSignals);

   711 	aSignals = ConvertSignals(iSignals);

   752 

   712 

   755 	return KErrNone;

   715 	return KErrNone;

   756 	}

   716 	}

   757 

   717 

   758 TInt CAcmPort::SetSignalsToMark(TUint aSignals)

   718 TInt CAcmPort::SetSignalsToMark(TUint aSignals)

   759 /**

   719 /**

   761  *

   721  *

   762  * @param aSignals bitmask with the signals to be set

   722  * @param aSignals bitmask with the signals to be set

   763  * @return Error.

   723  * @return Error.

   764  */

   724  */

   765 	{

   725 	{

   771 		return KErrAccessDenied;

   732 		return KErrAccessDenied;

   772 		}

   733 		}

   773 

   734 

   774 	TUint32 newSignals = iSignals | ConvertAndFilterSignals(aSignals);

   735 	TUint32 newSignals = iSignals | ConvertAndFilterSignals(aSignals);

   775 	TInt err = SetSignals(newSignals);

   736 	TInt err = SetSignals(newSignals);

   776 	if ( err )

   737 	if ( err )

   777 		{

   738 		{

   780 		return err;

   740 		return err;

   781 		}

   741 		}

   782 

   742 

   785 	return KErrNone;

   745 	return KErrNone;

   786 	}

   746 	}

   787 

   747 

   788 TInt CAcmPort::SetSignalsToSpace(TUint aSignals)

   748 TInt CAcmPort::SetSignalsToSpace(TUint aSignals)

   789 /**

   749 /**

   791  *

   751  *

   792  * @param aSignals bitmask with the signals to be cleared

   752  * @param aSignals bitmask with the signals to be cleared

   793  * @return Error.

   753  * @return Error.

   794  */

   754  */

   795 	{

   755 	{

   801 		return KErrAccessDenied;

   762 		return KErrAccessDenied;

   802 		}

   763 		}

   803 

   764 

   804 	TUint32 newSignals = iSignals & ~ConvertAndFilterSignals(aSignals);

   765 	TUint32 newSignals = iSignals & ~ConvertAndFilterSignals(aSignals);

   805 	TInt err = SetSignals(newSignals);

   766 	TInt err = SetSignals(newSignals);

   806 	if ( err )

   767 	if ( err )

   807 		{

   768 		{

   810 		return err;

   770 		return err;

   811 		}

   771 		}

   812 

   772 

   815 	return KErrNone;

   775 	return KErrNone;

   816 	}

   776 	}

   817 

   777 

   818 TInt CAcmPort::SetSignals(TUint32 aNewSignals)

   778 TInt CAcmPort::SetSignals(TUint32 aNewSignals)

   819 /**

   779 /**

   823  *

   783  *

   824  * @param aSignals bitmask with the signals to be set

   784  * @param aSignals bitmask with the signals to be set

   825  * @return Error.

   785  * @return Error.

   826  */

   786  */

   827 	{

   787 	{

   829 

   789 

   830 	TBool ring =((aNewSignals & KSignalRNG)==KSignalRNG);

   790 	TBool ring =((aNewSignals & KSignalRNG)==KSignalRNG);

   831 	TBool dsr  =((aNewSignals & KSignalDSR)==KSignalDSR);

   791 	TBool dsr  =((aNewSignals & KSignalDSR)==KSignalDSR);

   832 	TBool dcd  =((aNewSignals & KSignalDCD)==KSignalDCD);

   792 	TBool dcd  =((aNewSignals & KSignalDCD)==KSignalDCD);

   833  

   793  

   834  	if ( !iAcm )

   795  	if ( !iAcm )

   835 		{

   796 		{

   838 		return KErrAccessDenied;

   798 		return KErrAccessDenied;

   839 		}

   799 		}

   840 

   800 

   841 	TInt err = iAcm->SendSerialState(ring,dsr,dcd);

   801 	TInt err = iAcm->SendSerialState(ring,dsr,dcd);

   842 	if ( err )

   802 	if ( err )

   843 		{

   803 		{

   846 		return err;

   805 		return err;

   847 		}

   806 		}

   848 

   807 

   849 	// Report the new signals if they have changed and notification mask shows

   808 	// Report the new signals if they have changed and notification mask shows

   850 	// the upper layer wanted to be sensitive to these signals

   809 	// the upper layer wanted to be sensitive to these signals

   870 				{

   829 				{

   871 				changedSignalsMask |= KDSRChanged;

   830 				changedSignalsMask |= KDSRChanged;

   872 				}

   831 				}

   873 

   832 

   874 			// Report correctly mapped signals that client asked for

   833 			// Report correctly mapped signals that client asked for

   876 			TUint32 signals = ConvertSignals ( changedSignalsMask | ( aNewSignals & iNotifySignalMask ) );

   835 			TUint32 signals = ConvertSignals ( changedSignalsMask | ( aNewSignals & iNotifySignalMask ) );

   877 			SignalChangeCompleted ( signals, KErrNone );

   836 			SignalChangeCompleted ( signals, KErrNone );

   878 			iNotifySignalChange = EFalse;

   837 			iNotifySignalChange = EFalse;

   879 			}

   838 			}

   880 		}

   839 		}

   881 

   840 

   882 	// Store new signals in iSignals

   841 	// Store new signals in iSignals

   883 	iSignals = aNewSignals;

   842 	iSignals = aNewSignals;

   885 	return KErrNone;

   844 	return KErrNone;

   886 	}

   845 	}

   887 

   846 

   888 TUint32 CAcmPort::ConvertAndFilterSignals(TUint32 aSignals) const

   847 TUint32 CAcmPort::ConvertAndFilterSignals(TUint32 aSignals) const

   889 /**

   848 /**

   898  * @param aSignals Input signals.

   857  * @param aSignals Input signals.

   899  * @return The signals, with the lines switched round according to the port's 

   858  * @return The signals, with the lines switched round according to the port's 

   900  * role.

   859  * role.

   901  */

   860  */

   902 	{

   861 	{

   905 	TUint32 signals = 0;

   864 	TUint32 signals = 0;

   906 	// note that this never allows the client to use this method

   866 	// note that this never allows the client to use this method

   907 	// to diddle the BREAK state

   867 	// to diddle the BREAK state

   908 

   868 

   909 	// handle role-specific mapping

   869 	// handle role-specific mapping

   910 	if ( iRole == ECommRoleDTE )

   870 	if ( iRole == ECommRoleDTE )

   932 			|	KSignalCTS

   892 			|	KSignalCTS

   933 			|	KSignalDCD

   893 			|	KSignalDCD

   934 			|	KSignalRNG);

   894 			|	KSignalRNG);

   935 		}

   895 		}

   936 

   896 

   938 	return signals;

   897 	return signals;

   939 	}

   898 	}

   940 

   899 

   941 TUint32 CAcmPort::ConvertSignals(TUint32 aSignals) const

   900 TUint32 CAcmPort::ConvertSignals(TUint32 aSignals) const

   942 /**

   901 /**

   955  * @param aSignals Input signals (internal or client).

   914  * @param aSignals Input signals (internal or client).

   956  * @return Output signals.

   915  * @return Output signals.

   957  * port is.

   916  * port is.

   958  */

   917  */

   959 	{

   918 	{

   962 	// Swap signals around if the client is expecting DTE signalling

   921 	// Swap signals around if the client is expecting DTE signalling

   963 	if ( iRole == ECommRoleDTE )

   922 	if ( iRole == ECommRoleDTE )

   964 		{

   923 		{

   965 		TUint32 swappedSignals = 0;

   924 		TUint32 swappedSignals = 0;

   966 

   925 

  1004 		const TUint32 KSwapSignals = KSignalDSR | KSignalDTR | KSignalCTS | KSignalRTS

   963 		const TUint32 KSwapSignals = KSignalDSR | KSignalDTR | KSignalCTS | KSignalRTS

  1005 									| KDSRChanged | KDTRChanged | KCTSChanged | KRTSChanged;

   964 									| KDSRChanged | KDTRChanged | KCTSChanged | KRTSChanged;

  1006 		aSignals = ( aSignals & ~KSwapSignals ) | swappedSignals;

   965 		aSignals = ( aSignals & ~KSwapSignals ) | swappedSignals;

  1007 		}

   966 		}

  1008 

   967 

  1010 	return aSignals;

   968 	return aSignals;

  1011 	}

   969 	}

  1012 

   970 

  1013 TInt CAcmPort::GetReceiveBufferLength(TInt& aLength) const

   971 TInt CAcmPort::GetReceiveBufferLength(TInt& aLength) const

  1014 /**

   972 /**

  1019  *

   977  *

  1020  * @param aLength reference to where the length will be written to

   978  * @param aLength reference to where the length will be written to

  1021  * @return Error.

   979  * @return Error.

  1022  */

   980  */

  1023 	{

   981 	{

  1030 		return KErrAccessDenied;

   988 		return KErrAccessDenied;

  1031 		}

   989 		}

  1032 

   990 

  1038 	aLength = static_cast<TInt>(iReader->BufSize());

   992 	aLength = static_cast<TInt>(iReader->BufSize());

  1041 	return KErrNone;

   994 	return KErrNone;

  1042 	}

   995 	}

  1043 

   996 

  1044 TInt CAcmPort::DoSetBufferLengths(TUint aLength)

   997 TInt CAcmPort::DoSetBufferLengths(TUint aLength)

  1045 /**

   998 /**

  1048  *

  1001  *

  1049  * @param aLength The size required.

  1002  * @param aLength The size required.

  1050  * @return Error.

  1003  * @return Error.

  1051  */

  1004  */

  1052 	{

  1005 	{

  1061 	// Sart trying to resize buffers. Start with the reader. 

  1010 	// Sart trying to resize buffers. Start with the reader. 

  1062 	// Before we start though, set some stuff up we may need later (see 

  1011 	// Before we start though, set some stuff up we may need later (see 

  1063 	// comments below).

  1012 	// comments below).

  1064 	const TUint oldSize = iReader->BufSize();

  1013 	const TUint oldSize = iReader->BufSize();

  1065 	HBufC* dummyBuffer = HBufC::New(static_cast<TInt>(oldSize));

  1014 	HBufC* dummyBuffer = HBufC::New(static_cast<TInt>(oldSize));

  1066 	if ( !dummyBuffer )

  1015 	if ( !dummyBuffer )

  1067 		{

  1016 		{

  1068 		// If we can't allocate the dummy buffer, we can't guarantee that we 

  1017 		// If we can't allocate the dummy buffer, we can't guarantee that we 

  1069 		// can roll back this API safely if it fails halfway through. So abort 

  1018 		// can roll back this API safely if it fails halfway through. So abort 

  1070 		// the entire operation.

  1019 		// the entire operation.

  1073 		return KErrNoMemory;

  1022 		return KErrNoMemory;

  1074 		}

  1023 		}

  1075 

  1024 

  1076 	TInt ret = iReader->SetBufSize(aLength);

  1025 	TInt ret = iReader->SetBufSize(aLength);

  1077 	if ( ret )

  1026 	if ( ret )

  1078 		{

  1027 		{

  1079 		// A failure in SetBufSize will have maintained the old buffer 

  1028 		// A failure in SetBufSize will have maintained the old buffer 

  1080 		// (i.e. at its old size). This is a safe failure case- simply 

  1029 		// (i.e. at its old size). This is a safe failure case- simply 

  1081 		// clean up and return the error to the client.

  1030 		// clean up and return the error to the client.

  1082 		delete dummyBuffer;

  1031 		delete dummyBuffer;

  1085 		return ret;

  1033 		return ret;

  1086 		}

  1034 		}

  1087 

  1035 

  1088 	// OK, the Rx buffer has been resized, now for the Tx buffer...

  1036 	// OK, the Rx buffer has been resized, now for the Tx buffer...

  1094 	ret = iWriter->SetBufSize(aLength);

  1038 	ret = iWriter->SetBufSize(aLength);

  1095 	if ( ret )

  1039 	if ( ret )

  1096 		{

  1040 		{

  1097 		// Failure! The Tx buffer is still safe, at its old size. However, 

  1041 		// Failure! The Tx buffer is still safe, at its old size. However, 

  1098 		// to maintain the integrity of the API we need to reset the Rx 

  1042 		// to maintain the integrity of the API we need to reset the Rx 

  1099 		// buffer back to the old size. To make sure that this will work, free 

  1043 		// buffer back to the old size. To make sure that this will work, free 

  1100 		// the dummy buffer we initially allocated.

  1044 		// the dummy buffer we initially allocated.

  1101 		delete dummyBuffer;

  1045 		delete dummyBuffer;

  1103 		TInt err = iReader->SetBufSize(oldSize);

  1047 		TInt err = iReader->SetBufSize(oldSize);

  1109 		static_cast<void>(err);

  1049 		static_cast<void>(err);

  1110 		// Now both buffers are at the size they started at, and the 

  1050 		// Now both buffers are at the size they started at, and the 

  1111 		// request failed with error code 'ret'.

  1051 		// request failed with error code 'ret'.

  1113 		return ret;

  1052 		return ret;

  1114 		}

  1053 		}

  1115 

  1054 

  1116 	// We seem to have successfully resized both buffers... clean up and 

  1055 	// We seem to have successfully resized both buffers... clean up and 

  1117 	// return.

  1056 	// return.

  1118 	delete dummyBuffer;

  1057 	delete dummyBuffer;

  1121 	return KErrNone;

  1060 	return KErrNone;

  1122 	}

  1061 	}

  1123 

  1062 

  1124 TInt CAcmPort::SetReceiveBufferLength(TInt aLength)

  1063 TInt CAcmPort::SetReceiveBufferLength(TInt aLength)

  1125 /**

  1064 /**

  1129  *

  1068  *

  1130  * @param aLength new length of Tx and Rx buffer

  1069  * @param aLength new length of Tx and Rx buffer

  1131  * @return Error.

  1070  * @return Error.

  1132  */

  1071  */

  1133 	{

  1072 	{

  1140 		return KErrAccessDenied;

  1080 		return KErrAccessDenied;

  1141 		}

  1081 		}

  1142 

  1082 

  1143 	TInt ret = DoSetBufferLengths(static_cast<TUint>(aLength));

  1083 	TInt ret = DoSetBufferLengths(static_cast<TUint>(aLength));

  1146 	return ret;

  1086 	return ret;

  1147 	}

  1087 	}

  1148 

  1088 

  1149 void CAcmPort::Destruct()

  1089 void CAcmPort::Destruct()

  1150 /**

  1090 /**

  1151  * Downcall from C32. Destruct - we must (eventually) call delete this

  1091  * Downcall from C32. Destruct - we must (eventually) call delete this

  1152  */

  1092  */

  1153 	{

  1093 	{

  1155 	delete this;

  1096 	delete this;

  1157 	}

  1097 	}

  1158 

  1098 

  1159 void CAcmPort::FreeMemory()

  1099 void CAcmPort::FreeMemory()

  1160 /**

  1100 /**

  1161  * Downcall from C32. Attempt to reduce our memory foot print.

  1101  * Downcall from C32. Attempt to reduce our memory foot print.

  1162  * Implemented to do nothing.

  1102  * Implemented to do nothing.

  1163  */

  1103  */

  1164 	{

  1104 	{

  1167 	}

  1107 	}

  1168 

  1108 

  1169 void CAcmPort::NotifyDataAvailable()

  1109 void CAcmPort::NotifyDataAvailable()

  1170 /**

  1110 /**

  1171  * Downcall from C32. Notify client when data is available. 

  1111  * Downcall from C32. Notify client when data is available. 

  1172  */

  1112  */

  1173 	{

  1113 	{

  1178 		NotifyDataAvailableCompleted(KErrAccessDenied);

  1120 		NotifyDataAvailableCompleted(KErrAccessDenied);

  1180 		return;

  1121 		return;

  1181 		}

  1122 		}

  1188 	iReader->NotifyDataAvailable();		

  1125 	iReader->NotifyDataAvailable();		

  1190 	}

  1126 	}

  1191 

  1127 

  1192 void CAcmPort::NotifyDataAvailableCancel()

  1128 void CAcmPort::NotifyDataAvailableCancel()

  1193 /**

  1129 /**

  1194  * Downcall from C32. Cancel an outstanding data available notification. Note 

  1130  * Downcall from C32. Cancel an outstanding data available notification. Note 

  1195  * that C32 actually completes the client's request for us.

  1131  * that C32 actually completes the client's request for us.

  1196  */

  1132  */

  1197 	{

  1133 	{

  1204 		return;

  1140 		return;

  1205 		}

  1141 		}

  1212 	iReader->NotifyDataAvailableCancel();

  1144 	iReader->NotifyDataAvailableCancel();

  1214 	}

  1145 	}

  1215 

  1146 

  1216 TInt CAcmPort::GetFlowControlStatus(TFlowControl& /*aFlowControl*/)

  1147 TInt CAcmPort::GetFlowControlStatus(TFlowControl& /*aFlowControl*/)

  1217 /**

  1148 /**

  1218  * Downcall from C32. Get the flow control status. NB This is not supported.

  1149  * Downcall from C32. Get the flow control status. NB This is not supported.

  1219  *

  1150  *

  1220  * @param aFlowControl flow control status will be written to this descriptor

  1151  * @param aFlowControl flow control status will be written to this descriptor

  1221  * @return Error.

  1152  * @return Error.

  1222  */

  1153  */

  1223 	{

  1154 	{

  1230 		return KErrAccessDenied;

  1161 		return KErrAccessDenied;

  1231 		}

  1162 		}

  1232 

  1163 

  1235 	return KErrNotSupported;

  1165 	return KErrNotSupported;

  1236 	}

  1166 	}

  1237 

  1167 

  1238 void CAcmPort::NotifyOutputEmpty()

  1168 void CAcmPort::NotifyOutputEmpty()

  1239 /**

  1169 /**

  1241  * that this is not supported. Write requests only complete when the data has 

  1171  * that this is not supported. Write requests only complete when the data has 

  1242  * been sent to the LDD (KConfigWriteBufferedComplete is not supported) so 

  1172  * been sent to the LDD (KConfigWriteBufferedComplete is not supported) so 

  1243  * it's not very useful.

  1173  * it's not very useful.

  1244  */

  1174  */

  1245 	{

  1175 	{

  1251 		NotifyOutputEmptyCompleted(KErrAccessDenied);

  1182 		NotifyOutputEmptyCompleted(KErrAccessDenied);

  1253 		return;

  1183 		return;

  1254 		}

  1184 		}

  1255 

  1185 

  1257 	NotifyOutputEmptyCompleted(KErrNotSupported);

  1187 	NotifyOutputEmptyCompleted(KErrNotSupported);

  1259 	}

  1188 	}

  1260 

  1189 

  1261 void CAcmPort::NotifyOutputEmptyCancel()

  1190 void CAcmPort::NotifyOutputEmptyCancel()

  1262 /**

  1191 /**

  1263  * Downcall from C32. Cancel a pending request to be notified when the output 

  1192  * Downcall from C32. Cancel a pending request to be notified when the output 

  1264  * buffer is empty. Note that C32 actually completes the client's request for 

  1193  * buffer is empty. Note that C32 actually completes the client's request for 

  1265  * us.

  1194  * us.

  1266  */

  1195  */

  1267 	{

  1196 	{

  1270 	}

  1199 	}

  1271 

  1200 

  1272 void CAcmPort::NotifyBreak()

  1201 void CAcmPort::NotifyBreak()

  1273 /**

  1202 /**

  1274  * Downcall from C32. Notify a client of a host-driven break on the serial 

  1203  * Downcall from C32. Notify a client of a host-driven break on the serial 

  1275  * line.

  1204  * line.

  1276  */

  1205  */

  1277 	{

  1206 	{

  1283 		BreakNotifyCompleted(KErrAccessDenied);

  1213 		BreakNotifyCompleted(KErrAccessDenied);

  1285 		return;

  1214 		return;

  1286 		}

  1215 		}

  1287 

  1216 

  1288 	// C32 protects us against this.

  1217 	// C32 protects us against this.

  1294 

  1220 

  1295 	iNotifyBreak = ETrue;

  1221 	iNotifyBreak = ETrue;

  1297 	}

  1222 	}

  1298 

  1223 

  1299 void CAcmPort::NotifyBreakCancel()

  1224 void CAcmPort::NotifyBreakCancel()

  1300 /**

  1225 /**

  1301  * Downcall from C32. Cancel a pending notification of a serial line break. 

  1226  * Downcall from C32. Cancel a pending notification of a serial line break. 

  1302  * Note that C32 actually completes the client's request for us.

  1227  * Note that C32 actually completes the client's request for us.

  1303  */

  1228  */

  1304 	{

  1229 	{

  1310 		return;

  1236 		return;

  1311 		}

  1237 		}

  1312 

  1238 

  1313 	iNotifyBreak = EFalse;

  1239 	iNotifyBreak = EFalse;

  1315 	}

  1240 	}

  1316 

  1241 

  1317 void CAcmPort::BreakRequestCompleted()

  1242 void CAcmPort::BreakRequestCompleted()

  1318 /**

  1243 /**

  1319  * Callback for completion of a break request. 

  1244  * Callback for completion of a break request. 

  1320  * This is called when the break state next goes inactive after a break has 

  1245  * This is called when the break state next goes inactive after a break has 

  1321  * been requested from the ACM port. 

  1246  * been requested from the ACM port. 

  1322  * This is implemented to complete the RComm client's Break request.

  1247  * This is implemented to complete the RComm client's Break request.

  1323  */

  1248  */

  1324  	{

  1249  	{

  1327 

  1251 

  1328 	if ( !iCancellingBreak )

  1252 	if ( !iCancellingBreak )

  1329 		{

  1253 		{

  1331 		BreakCompleted(KErrNone);

  1255 		BreakCompleted(KErrNone);

  1332 		}

  1256 		}

  1333 	else

  1257 	else

  1334 		{

  1258 		{

  1336 		}

  1261 		}

  1337 	// In the event of an RComm::BreakCancel, this function is called 

  1262 	// In the event of an RComm::BreakCancel, this function is called 

  1338 	// sychronously with CAcmPort::BreakCancel, and C32 will complete the 

  1263 	// sychronously with CAcmPort::BreakCancel, and C32 will complete the 

  1339 	// original RComm::Break request with KErrCancel when that returns. So we 

  1264 	// original RComm::Break request with KErrCancel when that returns. So we 

  1340 	// only need to complete it if there isn't a cancel going on.

  1265 	// only need to complete it if there isn't a cancel going on.

  1341 	iBreak = EFalse;

  1266 	iBreak = EFalse;

  1342 	iCancellingBreak = EFalse;

  1267 	iCancellingBreak = EFalse;

  1344 	}

  1268 	}

  1345 

  1269 

  1346 void CAcmPort::BreakStateChange()