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 //

    15 

    16 

    17 

    18 /** @file

    19  *

    20  * Implements the v2 extensions of CPort

    21  */

    22 

    23 #include "CS_STD.H"

    24 #include "C32LOG.H"

    25 

    26 void CPort::CommNotifySignalChange(const RMessage2& aMessage, CCommSession* aClient)

    27 /**

    28  * Set DCE/DTE signal notifying on

    29  *

    30  * @param aMessage handle to the IPC message from the client

    31  * @param aClient pointer to the Comm session

    32  */

    33 	{ 

    34 	C32LOG2(KC32Player, _L8("CPort::CommNotifySignalChange(), Client 0x%x"), aClient);

    35 	if (TakeOwnershipForSignals(aMessage,aClient))

    36 		{

    37 		iBlockedSignalChange=aMessage;

    38 		if (aMessage.Int1()>0)

    39 			{

    40 			// We give signal mask as a parameter

    41 			NotifySignalChange(aMessage.Int1());

    42 			}

    43 		else

    44 			{

    45 			// Bad signal mask, we give up.

    46 			SafeComplete(aMessage, KErrArgument);

    47 			}

    48 		}	

    49 	else if (aClient!=iSignalOwner)

    50 		{

    51 		SafeComplete(aMessage, KErrInUse);

    52 		}

    53 	}

    54 

    55 

    56 EXPORT_C void CPort::SignalChangeCompleted(const TUint& aSignals, TInt aError)

    57 /** Tells the comms server that a request initiated through NotifySignalChange() 

    58 is complete. 

    59 

    60 The comms server will then notify the client that its request is complete. 

    61 

    62 Called by the CSY module.

    63 	

    64 @param aSignals The new signals value to pass to the client. 

    65 @param anError An error code. */

    66 	{

    67 	C32LOG1(KC32Player, _L8("CPort::SignalChangeCompleted()"));

    68 	if (iSignalOwner)

    69 		{

    70 		if (aError!=KErrCancel)

    71 			{

    72 			TPtr8 sigDes((TUint8*)&aSignals,sizeof(TUint),sizeof(TUint));

    73 			TInt ret = iSignalOwner->Write(0,iBlockedSignalChange,sigDes);

    74 			if (ret!=KErrNone)

    75 				{

    76 				aError=ret;

    77 				}

    78 			}

    79 		SafeComplete(iBlockedSignalChange, aError);

    80 		}

    81 	iSignalOwner = 0;

    82 	}

    83 

    84 

    85 TBool CPort::TakeOwnershipForSignals(const RMessage2& aMessage, CCommSession* aClient)

    86 /**

    87  * We check that signal notifying is not called twice at the same time

    88  *

    89  * @param aClient pointer to the Comm session

    90  * @return ETrue if not owner, EFalse if owner

    91  */

    92 	{

    93 	C32LOG2(KC32Player, _L8("CPort::TakeOwnershipForSignals(), Client 0x%x"), aClient);

    94 	if (!iSignalOwner)

    95 		{

    96 		iSignalOwner=aClient;

    97 		iSignalOwnerHandle=aMessage.Int3();

    98 		return ETrue;

    99 		}

   100 	else

   101 		{

   102 		if (aClient==iSignalOwner)

   103 			{

   104 			PanicClient(ENotifySignalTwice,aMessage);

   105 			}

   106 		return EFalse;

   107 		}

   108 	}

   109 

   110 

   111 void CPort::CommNotifySignalChangeCancel(TInt aHandle, CCommSession* aClient)

   112 /**

   113  * Cancel outstanding signal notification

   114  *

   115  * @param aHandle Handle to the session

   116  * @param aClient pointer to the Comm session

   117  */

   118 	{

   119 	C32LOG2(KC32Player, _L8("CPort::CommNotifySignalChangeCancel(), Client 0x%x"), aClient);

   120 	if (iSignalOwner==aClient && (!aHandle || aHandle==iSignalOwnerHandle))

   121 		{

   122 		NotifySignalChangeCancel();

   123 		SignalChangeCompleted(0,KErrCancel);

   124 		}

   125 	}

   126 

   127 

   128 void CPort::CommNotifyFlowControlChange(const RMessage2& aMessage, CCommSession* aClient)

   129 /**

   130  * Set flow control notifying on

   131  *

   132  * @param aMessage handle to the IPC message from the client

   133  * @param aClient pointer to the Comm session

   134  */

   135 	{ 

   136 	C32LOG2(KC32Player, _L8("CPort::CommNotifyFlowControlChange(), Client 0x%x"), aClient);

   137 	if (TakeOwnershipForFlowControl(aMessage,aClient))

   138 		{

   139 		iBlockedFlowControlChange = aMessage;

   140 		NotifyFlowControlChange();

   141 		}	

   142 	else if(aClient!= iFlowControlOwner)

   143 		{

   144 		SafeComplete(aMessage, KErrInUse);

   145 		}

   146 	}

   147 

   148 

   149 EXPORT_C void CPort::FlowControlChangeCompleted(const TFlowControl& aFlowControl, TInt aError)

   150 /** Tells the comms server that a request initiated through NotifyFlowControlChange() 

   151 is complete. 

   152 

   153 The comms server will then notify the client that its request is complete. 

   154 

   155 Called by the CSY module.

   156 	

   157 @param aFlowControl Flow control to pass to client 

   158 @param anError Error code */

   159 	{

   160 	C32LOG1(KC32Player, _L8("CPort::FlowControlChangeCompleted()"));

   161 	if (iFlowControlOwner)

   162 		{

   163 		if (aError!=KErrCancel)

   164 			{

   165 			TPckg<TFlowControl> len(aFlowControl);

   166 			TInt ret = iFlowControlOwner->Write(0,iBlockedFlowControlChange,len,0);

   167 			if (ret!=KErrNone)

   168 				{

   169 				aError=ret;

   170 				}

   171 			}

   172 		SafeComplete(iBlockedFlowControlChange, aError);

   173 		}		

   174 	iFlowControlOwner = 0;

   175 	}

   176 

   177 

   178 TBool CPort::TakeOwnershipForFlowControl(const RMessage2& aMessage,CCommSession* aClient)

   179 /**

   180  * We check that flowcontrol notifying is not called twice at the same time

   181  *

   182  * @param aClient pointer to the Comm session

   183  * @return ETrue if not owner, EFalse if owner

   184  */

   185 	{

   186 	C32LOG2(KC32Player, _L8("CPort::TakeOwnershipForFlowControl(), Client 0x%x"), aClient);

   187 	if (!iFlowControlOwner)

   188 		{

   189 		iFlowControlOwner=aClient;

   190 		iFlowControlOwnerHandle=aMessage.Int3();

   191 		return ETrue;

   192 		}

   193 	else

   194 		{

   195 		if (aClient==iFlowControlOwner)

   196 			{

   197 			PanicClient(ENotifyFlowControlTwice,aMessage);

   198 			}

   199 		return EFalse;

   200 		}

   201 	}

   202 

   203 

   204 void CPort::CommNotifyFlowControlChangeCancel(TInt aHandle, CCommSession* aClient)

   205 /**

   206  * Cancel outstanding flow control notification

   207  *

   208  * @param aHandle Handle to the session

   209  * @param aClient pointer to the Comm session

   210  */

   211 	{

   212 	C32LOG2(KC32Player, _L8("CPort::CommNotifyFlowControlChangeCancel(), Client 0x%x"), aClient);

   213 	if (iFlowControlOwner==aClient && (!aHandle || aHandle==iFlowControlOwnerHandle))

   214 		{

   215 		NotifyFlowControlChangeCancel();

   216 		FlowControlChangeCompleted((TFlowControl)0,KErrCancel);

   217 		}

   218 	}

   219 

   220 

   221 void CPort::CommNotifyConfigChange(const RMessage2& aMessage, CCommSession* aClient)

   222 /**

   223  * Set configuration change (data format, speed, ...) notifying on

   224  *

   225  * @param aMessage handle to the IPC message from the client

   226  * @param aClient pointer to the Comm session

   227  */

   228 	{ 

   229 	C32LOG2(KC32Player, _L8("CPort::CommNotifyConfigChange(), Client 0x%x"), aClient);

   230 	if (TakeOwnershipForConfig(aMessage,aClient))

   231 		{

   232 		iBlockedConfigChange=aMessage;

   233 		NotifyConfigChange();

   234 		}	

   235 	else if(aClient!=iConfigOwner)

   236 		SafeComplete(aMessage, KErrInUse);

   237 	}

   238 

   239 

   240 EXPORT_C void CPort::ConfigChangeCompleted(const TDesC8& aNewConfig, TInt aError)

   241 /** Tells the comms server that a request initiated through NotifyConfigChange() 

   242 is complete. 

   243 

   244 The comms server will then notify the client that its request is complete. 

   245 	

   246 Called by the CSY module.

   247 	

   248 @param aNewConfig Configuration value to pass to client 

   249 @param anError Error code */

   250 	{

   251 	C32LOG1(KC32Player, _L8("CPort::ConfigChangeCompleted()"));

   252 	if (iConfigOwner)

   253 		{

   254 		if (aError!=KErrCancel)

   255 			{

   256 			TInt ret = iConfigOwner->Write(0,iBlockedConfigChange,aNewConfig);

   257 			if (ret!=KErrNone)

   258 				aError=ret;

   259 			}

   260 		SafeComplete(iBlockedConfigChange, aError);

   261 		}

   262 	iConfigOwner = 0;

   263 	}

   264 

   265 

   266 TBool CPort::TakeOwnershipForConfig(const RMessage2& aMessage,CCommSession* aClient)

   267 /**

   268  * We check that config change notifying is not called twice at the same time

   269  *

   270  * @param aClient pointer to the Comm session

   271  * @return ETrue if not owner, EFalse if owner

   272  */

   273 	{

   274 	C32LOG2(KC32Player, _L8("CPort::TakeOwnershipForConfig(), Client 0x%x"), aClient);

   275 	if (!iConfigOwner)

   276 		{

   277 		iConfigOwner=aClient;

   278 		iConfigOwnerHandle=aMessage.Int3();

   279 		return ETrue;

   280 		}

   281 	else

   282 		{

   283 		if (aClient==iConfigOwner)

   284 			PanicClient(ENotifyConfigTwice,aMessage);

   285 		return EFalse;

   286 		}

   287 	}

   288 

   289 

   290 void CPort::CommNotifyConfigChangeCancel(TInt aHandle, CCommSession* aClient)

   291 /**

   292  * Cancel outstanding configuration change notification

   293  *

   294  * @param aHandle Handle to the session

   295  * @param aClient pointer to the Comm session

   296  */

   297 	{

   298 	C32LOG2(KC32Player, _L8("CPort::CommNotifyConfigChangeCancel(), Client 0x%x"), aClient);

   299 	if (iConfigOwner==aClient && (!aHandle || aHandle==iConfigOwnerHandle))

   300 		{

   301 		NotifyConfigChangeCancel();

   302 		TPtr8 dummy(NULL,0,0);

   303 		ConfigChangeCompleted(dummy,KErrCancel);

   304 		}

   305 	}

   306 

   307 

   308 void CPort::CommNotifyBreak(const RMessage2& aMessage, CCommSession* aClient)

   309 /**

   310  * Set break signal notifying on

   311  *

   312  * @param aMessage handle to the IPC message from the client

   313  * @param aClient pointer to the Comm session

   314  */

   315 	{ 

   316 	C32LOG2(KC32Player, _L8("CPort::CommNotifyBreak(), Client 0x%x"), aClient);

   317 	if (TakeOwnershipForBreak(aMessage,aClient))

   318 		{

   319 		iBlockedBreakNotify=aMessage;

   320 		NotifyBreak();

   321 		}

   322 	else if(aClient!=iBreakNotifyOwner)

   323 		SafeComplete(aMessage, KErrInUse);		

   324 	}

   325 

   326 

   327 EXPORT_C void CPort::BreakNotifyCompleted(TInt aError)

   328 /** Tells the comms server that a request initiated through NotifyBreak()

   329 is complete. 

   330 

   331 The comms server will then notify the client that its request is complete. 

   332 	

   333 Called by the CSY module.

   334 	

   335 @param anError Error code */

   336 	{

   337 	C32LOG1(KC32Player, _L8("CPort::BreakNotifyCompleted()"));

   338 	if (iBreakNotifyOwner)

   339 		SafeComplete(iBlockedBreakNotify, aError);		

   340 	iBreakNotifyOwner = 0;

   341 	}

   342 

   343 

   344 TBool CPort::TakeOwnershipForBreak(const RMessage2& aMessage,CCommSession* aClient)

   345 /**

   346  * We check that break notifying is not called twice at the same time

   347  *

   348  * @param aClient pointer to the Comm session

   349  * @return ETrue if not owner, EFalse if owner

   350  */

   351 	{

   352 	C32LOG2(KC32Player, _L8("CPort::TakeOwnershipForBreak(), Client 0x%x"), aClient);

   353 	if (!iBreakNotifyOwner)

   354 		{

   355 		iBreakNotifyOwner=aClient;

   356 		iBreakNotifyOwnerHandle=aMessage.Int3();

   357 		return ETrue;

   358 		}

   359 	else

   360 		{

   361 		if (aClient==iBreakNotifyOwner)

   362 			PanicClient(ENotifyBreakTwice,aMessage);

   363 		return EFalse;

   364 		}

   365 	}

   366 

   367 

   368 void CPort::CommNotifyBreakCancel(TInt aHandle, CCommSession* aClient)

   369 /**

   370  * Cancel outstanding break notification

   371  *

   372  * @param aHandle Handle to the session

   373  * @param aClient pointer to the Comm session

   374  */

   375 	{

   376 	C32LOG2(KC32Player, _L8("CPort::CommNotifyBreakCancel(), Client 0x%x"), aClient);

   377 	if (iBreakNotifyOwner==aClient && (!aHandle || aHandle==iBreakNotifyOwnerHandle))

   378 		{

   379 		NotifyBreakCancel();

   380 		BreakNotifyCompleted(KErrCancel);

   381 		}

   382 	}

   383 

   384 

   385 void CPort::CommNotifyDataAvailable(const RMessage2& aMessage, CCommSession* aClient)

   386 /**

   387  * Set input buffer data notifying on

   388  *

   389  * @param aMessage handle to the IPC message from the client

   390  * @param aClient pointer to the Comm session

   391  */

   392 	{ 

   393 	C32LOG2(KC32Player, _L8("CPort::CommNotifyDataAvailable(), Client 0x%x"), aClient);

   394 	if (TakeOwnershipForNotifyDataAvailable(aMessage,aClient))

   395 		{

   396 		iBlockedNotifyDataAvailable=aMessage;

   397 		NotifyDataAvailable();

   398 		}

   399 	else if(aClient!=iNotifyDataAvailableOwner)

   400 		SafeComplete(aMessage, KErrInUse);		

   401 	}

   402 

   403 

   404 EXPORT_C void CPort::NotifyDataAvailableCompleted(TInt aError)

   405 /** Tells the comms server that a request initiated through NotifyDataAvailable() 

   406 is complete. 

   407 

   408 The comms server will then notify the client that its request is complete. 

   409 

   410 Called by the CSY module.

   411 	

   412 @param anError Error code */

   413 	{

   414 	C32LOG1(KC32Player, _L8("CPort::NotifyDataAvailableCompleted()"));

   415 	if (iNotifyDataAvailableOwner)

   416 		SafeComplete(iBlockedNotifyDataAvailable, aError);

   417 	iNotifyDataAvailableOwner = 0;

   418 	}

   419 

   420 

   421 TBool CPort::TakeOwnershipForNotifyDataAvailable(const RMessage2& aMessage,CCommSession* aClient)

   422 /**

   423  * We check that input buffer data notifying is not called twice at the same time

   424  *

   425  * @param aClient pointer to the Comm session

   426  * @return ETrue if not owner, EFalse if owner

   427  */

   428 	{

   429 	C32LOG2(KC32Player, _L8("CPort::TakeOwnershipForNotifyDataAvailable(), Client 0x%x"), aClient);

   430 	if (!iNotifyDataAvailableOwner)

   431 		{

   432 		iNotifyDataAvailableOwner=aClient;

   433 		iNotifyDataAvailableOwnerHandle=aMessage.Int3();

   434 		return ETrue;

   435 		}

   436 	else

   437 		{

   438 		if (aClient==iNotifyDataAvailableOwner)

   439 			PanicClient(ENotifyDataAvailableTwice,aMessage);

   440 		return EFalse;

   441 		}

   442 	}

   443 

   444 

   445 void CPort::CommNotifyDataAvailableCancel(TInt aHandle, CCommSession* aClient)

   446 /**

   447  * Cancel outstanding input buffer data notification

   448  *

   449  * @param aHandle Handle to the session

   450  * @param aClient pointer to the Comm session

   451  */

   452 	{

   453 	C32LOG2(KC32Player, _L8("CPort::CommNotifyDataAvailableCancel(), Client 0x%x"), aClient);

   454 	if (iNotifyDataAvailableOwner==aClient && (!aHandle || aHandle==iNotifyDataAvailableOwnerHandle))

   455 		{

   456 		NotifyDataAvailableCancel();

   457 		NotifyDataAvailableCompleted(KErrCancel);

   458 		}

   459 	}

   460 

   461 

   462 void CPort::CommNotifyOutputEmpty(const RMessage2& aMessage, CCommSession* aClient)

   463 /**

   464  * Set output buffer empty notifying on

   465  *

   466  * @param aMessage handle to the IPC message from the client

   467  * @param aClient pointer to the Comm session

   468  */

   469 	{ 

   470 	C32LOG2(KC32Player, _L8("CPort::CommNotifyOutputEmpty(), Client 0x%x"), aClient);

   471 	if (TakeOwnershipForNotifyOutputEmpty(aMessage,aClient))

   472 		{

   473 		iBlockedNotifyOutputEmpty=aMessage;

   474 		NotifyOutputEmpty();

   475 		}

   476 	else if(aClient!=iNotifyOutputEmptyOwner)

   477 		SafeComplete(aMessage, KErrInUse);

   478 	}

   479 

   480 

   481 EXPORT_C void CPort::NotifyOutputEmptyCompleted(TInt aError)

   482 /** Tells the comms server that a request initiated through NotifyOutputEmpty() 

   483 is complete. 

   484 

   485 The comms server will then notify the client that its request is complete. 

   486 

   487 Called by the CSY module.

   488 	

   489 @param anError Error code */

   490 	{

   491 	C32LOG1(KC32Player, _L8("CPort::NotifyOutputEmptyCompleted()"));

   492 	if (iNotifyOutputEmptyOwner)

   493 		SafeComplete(iBlockedNotifyOutputEmpty, aError);

   494 	iNotifyOutputEmptyOwner = 0;

   495 	}

   496 

   497 

   498 TBool CPort::TakeOwnershipForNotifyOutputEmpty(const RMessage2& aMessage,CCommSession* aClient)

   499 /**

   500  * We check that output buffer empty notifying is not called twice at the same time

   501  *

   502  * @param aClient pointer to the Comm session

   503  * @return ETrue if not owner, EFalse if owner

   504  */

   505 	{

   506 	C32LOG2(KC32Player, _L8("CPort::TakeOwnershipForNotifyOutputEmpty(), Client 0x%x"), aClient);

   507 	if (!iNotifyOutputEmptyOwner)

   508 		{

   509 		iNotifyOutputEmptyOwner=aClient;

   510 		iNotifyOutputEmptyOwnerHandle=aMessage.Int3();

   511 		return ETrue;

   512 		}

   513 	else

   514 		{

   515 		if (aClient==iNotifyOutputEmptyOwner)

   516 			PanicClient(ENotifyOutputTwice,aMessage);

   517 		return EFalse;

   518 		}

   519 	}

   520 

   521 

   522 void CPort::CommNotifyOutputEmptyCancel(TInt aHandle, CCommSession* aClient)

   523 /**

   524  * Cancel outstanding output buffer empty notification

   525  *

   526  * @param aHandle Handle to the session

   527  * @param aClient pointer to the Comm session

   528  */

   529 	{

   530 	C32LOG2(KC32Player, _L8("CPort::CommNotifyOutputEmptyCancel(), Client 0x%x"), aClient);

   531 	if (iNotifyOutputEmptyOwner==aClient && (!aHandle || aHandle==iNotifyOutputEmptyOwnerHandle))

   532 		{

   533 		NotifyOutputEmptyCancel();

   534 		NotifyOutputEmptyCompleted(KErrCancel);

   535 		}

   536 	}

   537 

   538 

   539 void CPort::CommGetRole(const RMessage2& aMessage, CCommSession* aClient)

   540 /**

   541  * Get role DCE/DTE from CSY module

   542  *

   543  * @param aMessage handle to the IPC message from the client

   544  * @param aClient pointer to the Comm session

   545  */

   546 	{

   547 	(void)aClient;		// to disable urel warnings

   548 	C32LOG2(KC32Player, _L8("CPort::CommGetRole(), Client 0x%x"), aClient);

   549 	TCommRole tempRole;

   550 	TInt ret=GetRole(tempRole);

   551 	TPckg<TCommRole> len(tempRole);

   552 	if (ret==KErrNone)

   553 		{

   554 		ret = aMessage.Write(0, len, 0);

   555 		if (ret!=KErrNone)

   556 			{

   557 			PanicClient(EBadDescriptor,aMessage);

   558 			}

   559 		}

   560 	SafeComplete(aMessage, ret);

   561 	}

   562 

   563 

   564 void CPort::CommGetFlowControlStatus(const RMessage2& aMessage, CCommSession* aClient)

   565 /**

   566  * Get flow control state ON/OFF from CSY module

   567  *

   568  * @param aMessage handle to the IPC message from the client

   569  * @param aClient pointer to the Comm session

   570  */

   571 	{

   572 	(void)aClient;		// to disable urel warnings

   573 	C32LOG2(KC32Player, _L8("CPort::CommGetFlowControlStatus(), Client 0x%x"), aClient);

   574 	TFlowControl tempFlow;

   575 	TPckg<TFlowControl> len(tempFlow);

   576 	TInt ret=GetFlowControlStatus(tempFlow);

   577 	if (ret==KErrNone)

   578 		{

   579 		ret = aMessage.Write(0, len, 0);

   580 		if (ret!=KErrNone)

   581 			{

   582 			PanicClient(EBadDescriptor,aMessage);

   583 			}

   584 		}

   585 	SafeComplete(aMessage, ret);

   586 	}

   587 

   588 

   589 // EOF - CS_V02.CPP