1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  An example implementation for ISC Driver Reference

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <kern_priv.h>

    22 #include <IscDataTransmissionBase.h>

    23 #include "IscChannel.h"

    24 #include "IscDevice.h"

    25 #include "IscChannelContainer.h"

    26 #include "IscQueue.h"

    27 #include "IscTrace.h"

    28 

    29 // EXTERNAL DATA STRUCTURES

    30 

    31 // EXTERNAL FUNCTION PROTOTYPES  

    32 

    33 // CONSTANTS

    34 _LIT( KIscDriver, "IscDriver" );

    35 

    36 // MACROS

    37 

    38 // LOCAL CONSTANTS AND MACROS

    39 const TInt KIscInitializeDfcPriority( 1 );

    40 const TInt KOneParam( 1 );

    41 const TInt KTwoParams( 2 );

    42 const TInt KThreeParams( 3 );

    43 const TInt KFirstParam( 0 );

    44 const TInt KSecondParam( 1 );

    45 const TInt KThirdParam( 2 );

    46 const TInt KMultiplyByOne( KSecondParam );

    47 const TInt KMultiplyByThree( KThreeParams );

    48 const TInt KDivideByFour( 4 );

    49 

    50 // MODULE DATA STRUCTURES

    51 

    52 // LOCAL FUNCTION PROTOTYPES

    53 

    54 // FORWARD DECLARATIONS

    55 

    56 

    57 // ============================ MEMBER FUNCTIONS ===============================

    58 

    59 

    60 // -----------------------------------------------------------------------------

    61 // DIscChannel::DIscChannel

    62 // C++ default constructor.

    63 // ( other items were commented in a header ).

    64 // -----------------------------------------------------------------------------

    65 //

    66 EXPORT_C DIscChannel::DIscChannel( DLogicalDevice* aDevice ) 

    67     : iInitializeDfc( NULL ),

    68     iDataTransmissionIniData( NULL ),

    69     iMultiplexerIniData( NULL ),

    70     iMultiplexerBuffer( NULL ),

    71     iDataTransmissionBuffer( NULL ),

    72     iIscDevice( NULL ),

    73     iIscConnectionStatusPtr( NULL ),

    74     iIscFlowControlStatusPtr( NULL ),

    75     iReceiveBufPtr( NULL ),

    76     iDataReceiveBufPtr( NULL ),

    77     iNeededBufLen( NULL ),

    78     iNeededDataBufLen( NULL ),

    79     iChannelNumber( 0 ),

    80     iChannelOpen( EFalse ),

    81     iFrameRx( NULL ),

    82     iFrameRxQueue( NULL ),    

    83     iDataFrameRx( NULL ),

    84     iDataFrameRxQueue( NULL ),

    85     iULFlowControlStatus( EIscFlowControlOff ),

    86     iDLFlowControlStatus( EIscFlowControlOff ),

    87     iLastNotifiedULFlowstatus( EIscFlowControlOff ),

    88     iIscChannelHighWaterMark( 0 ),

    89     iIscChannelLowWaterMark( 0 ),

    90     iOverFlow( EFalse ),

    91     iClientPanic( EFalse ),

    92     iDataTransmissionErrorCode( KErrNone )

    93     {

    94     

    95     iIscDevice = ( DIscDevice * )aDevice;

    96     for ( TInt i( KErrNone ); i < EIscAsyncLast; i++ )

    97         {

    98         iIscRequests[i] = NULL;

    99         }

   100     iThread = &Kern::CurrentThread();   

   101     TInt r = iThread->Open();

   102     TRACE_ASSERT( r == KErrNone );

   103 

   104     }

   105 

   106 

   107 // -----------------------------------------------------------------------------

   108 // DIscChannel::~DIscChannel

   109 // Destructor

   110 // ( other items were commented in a header ).

   111 // -----------------------------------------------------------------------------

   112 //

   113 DIscChannel::~DIscChannel()

   114     {

   115     C_TRACE( ( _T( "DIscChannel::~DIscChannel()" ) ) );

   116     

   117     if ( iChannelNumber < KIscNumberOfUnits )

   118         {

   119         IscChannelContainer::RemoveChannel( this );

   120         }

   121     else 

   122         {

   123         C_TRACE( ( _T( "DIscChannel::~DIscChannel() re-open" ) ) );

   124         }

   125 

   126     ChannelDestruction();    

   127     Kern::SafeClose( ( DObject*& )iThread, NULL );

   128     C_TRACE( ( _T( "DIscChannel::~DIscChannel() SafeClose called" ) ) );

   129 

   130     }

   131 

   132 // -----------------------------------------------------------------------------

   133 // DIscChannel::ChannelDestruction

   134 // Destructor

   135 // ( other items were commented in a header ).

   136 // -----------------------------------------------------------------------------

   137 //

   138 void DIscChannel::ChannelDestruction()

   139     {

   140     C_TRACE( ( _T( "DIscChannel::ChannelDestruction() iChannelNumber (0x%x)" ),iChannelNumber ) );

   141 

   142     // call DIscMultiplexerBase::CloseDLC and DLFlowControlNotify in case the channel has not been

   143     // properly closed ( e.g. client thread panic etc. )

   144     if ( iChannelOpen )

   145         {

   146         iIscDevice->CancelSending( iChannelNumber, this );// Delete pending send frames

   147         iIscDevice->iIscMultiplexerInterface->CloseDLC( iChannelNumber, this );

   148         iIscDevice->DLFlowControlNotify( EIscFlowControlOff, iChannelNumber, this );

   149         }

   150 

   151     if ( iFrameRxQueue )

   152         {

   153         while ( !iFrameRxQueue->Empty() )

   154             {

   155             TDes8* tempPtr = ( TDes8* ) iFrameRxQueue->GetFirst();

   156             iFrameRxQueue->DeleteFirst();

   157             iIscDevice->ReleaseMemoryBlock( tempPtr );

   158             }

   159         delete iFrameRxQueue;

   160         iFrameRxQueue = NULL;

   161         }

   162 

   163     if ( iFrameRx )

   164             {

   165             delete [] iFrameRx;

   166             iFrameRx = NULL;

   167             }

   168 

   169     if ( iDataFrameRxQueue )

   170         {

   171         while ( !iDataFrameRxQueue->Empty() )

   172             {

   173             TDes8* tempPtr = ( TDes8* ) iDataFrameRxQueue->GetFirst();

   174             iDataFrameRxQueue->DeleteFirst();

   175             iIscDevice->ReleaseMemoryBlock( tempPtr );        

   176             }

   177         delete iDataFrameRxQueue;

   178         iDataFrameRxQueue = NULL;        

   179         }

   180 

   181     if ( iDataFrameRx )

   182             {

   183             delete [] iDataFrameRx;

   184             iDataFrameRx = NULL;

   185             }

   186     

   187     if ( iInitializeDfc )

   188         {        

   189         delete iInitializeDfc;

   190         iInitializeDfc = NULL;

   191         }    

   192 

   193     if ( iDataTransmissionIniData )

   194         {

   195         Kern::Free( iDataTransmissionBuffer );

   196         delete iDataTransmissionIniData;

   197         iDataTransmissionIniData = NULL;

   198         }

   199 

   200     if ( iMultiplexerIniData )

   201         {

   202         Kern::Free( iMultiplexerBuffer );

   203         delete iMultiplexerIniData;

   204         iMultiplexerIniData = NULL;

   205         }

   206 

   207     C_TRACE( ( _T( "DIscChannel::ChannelDestruction - return void" ) ) );

   208     }

   209 

   210 // -----------------------------------------------------------------------------

   211 // DIscChannel::HandleMsg

   212 // Message handling ( kernel server context ).

   213 // ( other items were commented in a header ).

   214 // -----------------------------------------------------------------------------

   215 //

   216 void DIscChannel::HandleMsg( 

   217     TMessageBase* aMsg )

   218     {

   219     C_TRACE( ( _T( "DIscChannel::HandleMsg(0x%x)" ), aMsg ) );

   220     TThreadMessage& m=*( TThreadMessage* )aMsg;

   221     TInt id( m.iValue );

   222 

   223     if ( id==( TInt )ECloseMsg )

   224         {

   225         C_TRACE( ( _T( "DIscChannel::HandleMsg ECloseMsg" ) ) );

   226         m.Complete( KErrNone,EFalse );

   227         return;

   228         }

   229 

   230     else if ( id==KMaxTInt )

   231         {

   232         // DoCancel

   233         // Should not come here ever

   234         ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscNotAllowedCallToDoCancel );

   235         }

   236 

   237     else if ( id<0 )

   238         {

   239         // DoRequest

   240         // should not come here ever

   241         ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscNotAllowedCallToDoRequest );

   242         }

   243     

   244     else

   245         {

   246         // DoControl

   247         TUint32 a1[ KThreeParams ];

   248         TInt r( KErrNone );

   249         if ( id != EIscSyncClose )

   250             {

   251             TInt amountOfParams( KErrNone );

   252             switch( id )

   253                 {

   254                 case EIscAsyncInitializeModemInterface:

   255                 case EIscAsyncOpen:

   256                     amountOfParams = KThreeParams;

   257                     break;

   258                 default:

   259                     ASSERT_RESET_ALWAYS( 0, "NokiaISCDriver", EIscUnknownCommand );

   260                 break;

   261                 }

   262             r = Kern::ThreadRawRead( iThread, ( TAny* )m.Ptr0(), a1,

   263                                      amountOfParams * sizeof( TAny* ) );

   264             TRACE_ASSERT( r == KErrNone );

   265             }

   266         if( r == KErrNone )

   267             {

   268             r=HandleRequest( id,a1,m.Ptr1() );

   269             }

   270 

   271         m.Complete( r,ETrue );

   272         }

   273     }

   274 

   275 // -----------------------------------------------------------------------------

   276 // DIscChannel::Request

   277 // Message handling ( user thread context ).

   278 // ( other items were commented in a header ).

   279 // -----------------------------------------------------------------------------

   280 //

   281 #ifndef COMPONENT_TRACE_FLAG

   282 TInt DIscChannel::Request( TInt aReqNo, TAny* a1, TAny* )

   283 #else 

   284 TInt DIscChannel::Request( TInt aReqNo, TAny* a1, TAny* a2)

   285 #endif

   286     {

   287     C_TRACE( ( _T( "DIscChannel::Request(0x%x, 0x%x, 0x%x)" ), aReqNo, a1, a2 ) );

   288 

   289     TInt r( KErrNotFound );

   290 

   291     if ( aReqNo<( TInt )EMinRequestId )

   292         C_TRACE( ( _T( "DIscChannel::Request ERROR: False aReqNo %d" ), aReqNo ) );

   293     

   294     if ( aReqNo >= 0 && aReqNo < EIscAsyncLastKernelServerContext ||

   295          aReqNo >= EIscAsyncLast && aReqNo < EIscSyncLastKernelServerContext )

   296         {

   297         TThreadMessage& m=Kern::Message();

   298         m.iValue=aReqNo;

   299         m.iArg[ KFirstParam ]=a1;

   300         m.iArg[ KSecondParam ]=NULL;

   301         r = m.SendReceive( &iMsgQ );

   302         }

   303     else

   304         {

   305         TInt ulen( KErrNotFound );

   306         switch ( aReqNo )

   307             {

   308             case EIscCancelAsyncInitialize:

   309             case EIscCancelAsyncReceive:

   310             case EIscCancelAsyncDataReceive:

   311             case EIscSyncGetConnectionStatus:

   312             case EIscCancelAsyncNotifyConnection:

   313             case EIscSyncGetFlowControlStatus:

   314             case EIscCancelAsyncNotifyFlowControl:

   315             case EIscSyncGetMaximunDataSize:

   316             case EIscCancelAsyncCustomOperation1:

   317             case EIscCancelAsyncCustomOperation2:

   318             case EIscCancelAsyncCustomOperation3:

   319             case EIscCancelAsyncCustomOperation4:

   320             case EIscCancelAsyncCustomOperation5:

   321             case EIscCancelAsyncOpen:

   322             case EIscSyncResetBuffers:

   323             case EIscCancelAsyncSend:

   324             case EIscCancelAsyncDataSend:

   325                 {

   326                 ulen = KErrNone;

   327                 break;

   328                 }

   329             case EIscSyncSend:

   330             case EIscSyncDataSend:

   331             case EIscSyncCustomOperation1:

   332             case EIscSyncCustomOperation2:

   333             case EIscSyncCustomOperation3:

   334             case EIscSyncCustomOperation4:

   335             case EIscSyncCustomOperation5:

   336             case EIscAsyncClose:

   337                 {

   338                 ulen = KOneParam;

   339                 break;

   340                 }

   341             case EIscAsyncSend:

   342             case EIscAsyncDataSend:

   343             case EIscSyncGetChannelInfo:

   344             case EIscAsyncNotifyConnectionStatus:

   345             case EIscAsyncNotifyFlowControlStatus:

   346             case EIscAsyncCustomOperation1:

   347             case EIscAsyncCustomOperation2:

   348             case EIscAsyncCustomOperation3:

   349             case EIscAsyncCustomOperation4:

   350             case EIscAsyncCustomOperation5:

   351                 {

   352                 ulen = KTwoParams;

   353                 break;

   354                 }

   355             case EIscAsyncReceive:

   356             case EIscAsyncDataReceive:

   357                 {

   358                 ulen = KThreeParams;

   359                 break;

   360                 }

   361             default:

   362                 {

   363                 TRACE_ASSERT_ALWAYS;

   364                 }

   365             }

   366         ASSERT_RESET_ALWAYS( KErrNotFound != ulen, "ISCDriver", EIscUnknownCommand );

   367         // Maximum number of elements is three!!!

   368         TAny* kptr[ KThreeParams ] = { KErrNone }; 

   369         if( ulen > KErrNone )

   370             {

   371             C_TRACE( ( _T( "DIscChannel::Request ISC kumemget32" ) ) );

   372             kumemget32( kptr , a1, ( sizeof( TAny* ) ) * ulen ); 

   373             }

   374         r = HandleRequest( aReqNo, kptr, NULL );

   375         }

   376     C_TRACE( ( _T( "DIscChannel::Request ISC return %d CH 0x%x" ), r, iChannelNumber ) );

   377     return r;        

   378 

   379     }

   380 

   381 // -----------------------------------------------------------------------------

   382 // DIscChannel::DoControl

   383 // Handles requests.

   384 // ( other items were commented in a header ).

   385 // -----------------------------------------------------------------------------

   386 //

   387 TInt DIscChannel::HandleRequest( 

   388     TInt aFunction, 

   389     TAny* a1, 

   390     TAny* /*a2*/ )

   391     {

   392     C_TRACE( ( _T( "DIscChannel::DoControl(0x%x, 0x%x) iChannelNumber 0x%x channelPtr 0x%x" ), aFunction, a1, iChannelNumber, this ) );

   393 

   394     TInt error( KErrNone );

   395     

   396 #ifdef _DEBUG

   397     // Check if control frame buffer overflow -> panic

   398     if ( iClientPanic )

   399         {

   400         C_TRACE( ( _T( "DIscChannel::DoControl() BUFFER OVERFLOW: PANIC CLIENT 0x%x" ), iChannelNumber ) );

   401         TRACE_ASSERT_ALWAYS;

   402         // This panic the user thread only.

   403 		Kern::ThreadKill( iThread, EExitPanic, EIscControlBufferOverflow, KIscDriver );

   404         }

   405 #endif // _DEBUG

   406 

   407     // Handle asynchronous requests

   408     if ( aFunction >= EIscAsyncInitializeModemInterface &&

   409          aFunction < EIscAsyncLast )

   410         {

   411         // if request is already active

   412         if ( iIscRequests[aFunction] )

   413             {

   414             TUint32* tablePtr = ( TUint32* )a1;

   415             TRequestStatus* requestStatus = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   416             Kern::RequestComplete( iThread, requestStatus, KErrAlreadyExists );

   417             }

   418         else

   419             {

   420             HandleAsyncRequest( aFunction, a1 );

   421             }

   422         }

   423     // Handle synchronous requests.

   424     else if ( aFunction >= EIscAsyncLast &&

   425               aFunction < EIscSyncLast )

   426         {

   427         error = HandleSyncRequest( aFunction, a1 );

   428         }

   429     // Handle cancellation requests.

   430     else if ( aFunction >= EIscSyncLast &&

   431               aFunction < EIscCancelLast )

   432         {

   433         error = HandleCancelRequest( aFunction, a1 );

   434         }

   435     // Undefined request, panic current thread. 

   436     else

   437         {

   438         // This panic the user thread only.

   439 		Kern::ThreadKill( iThread, EExitPanic, EIscControlBufferOverflow, KIscDriver );

   440         }

   441         

   442     C_TRACE( ( _T( "DIscChannel::DoControl - return %d" ), error ) );

   443 

   444     return error;

   445     }

   446 

   447    

   448 // -----------------------------------------------------------------------------

   449 // DIscChannel::HandleAsyncRequests

   450 // Handles asynchronous client requests

   451 // ( other items were commented in a header ).

   452 // -----------------------------------------------------------------------------

   453 //

   454 void DIscChannel::HandleAsyncRequest( 

   455     TInt aFunction, 

   456     TAny* a1 )

   457     {

   458     C_TRACE( ( _T( "DIscChannel::HandleAsyncRequest(0x%x, 0x%x) channelPtr 0x%x" ), aFunction, a1, this ) );

   459 

   460     TUint32* tablePtr = ( TUint32* )a1;

   461 

   462     switch ( aFunction )

   463         {

   464         case EIscAsyncInitializeModemInterface:

   465             {    

   466             TInt r = KErrNotFound;

   467             iIscRequests[EIscAsyncInitializeModemInterface] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   468            

   469             iInitializeDfc = new TDfc( InitializeComplete, this, Kern::DfcQue0(), KIscInitializeDfcPriority );            

   470             ASSERT_RESET_ALWAYS( iInitializeDfc, "IscDriver",EIscMemoryAllocationFailure );

   471 

   472             // Get Data Transmission Driver initialization string

   473             TDesC8* tempPtr = ( TDesC8* )tablePtr[ KThirdParam ];

   474             iDataTransmissionBuffer = ( TUint8* )Kern::Alloc( KIscIniLineLength );

   475             ASSERT_RESET_ALWAYS( iDataTransmissionBuffer, "IscDriver",EIscMemoryAllocationFailure );

   476 

   477             iDataTransmissionIniData = new ( TPtr8 )( iDataTransmissionBuffer, KIscIniLineLength );

   478             ASSERT_RESET_ALWAYS( iDataTransmissionIniData, "IscDriver",EIscMemoryAllocationFailure );

   479 

   480             r = Kern::ThreadDesRead( iThread, tempPtr, *iDataTransmissionIniData, 0, KChunkShiftBy0 );

   481             ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMemoryAllocationFailure );

   482 

   483             // Get Multiplexer initialization string

   484             tempPtr = ( TDesC8* )tablePtr[1];

   485             iMultiplexerBuffer = ( TUint8* )Kern::Alloc( KIscIniLineLength );

   486             ASSERT_RESET_ALWAYS( iMultiplexerBuffer, "IscDriver",EIscMemoryAllocationFailure );

   487 

   488             iMultiplexerIniData = new ( TPtr8 )( iMultiplexerBuffer, KIscIniLineLength );

   489             ASSERT_RESET_ALWAYS( iDataTransmissionIniData, "IscDriver",EIscMemoryAllocationFailure );

   490 

   491             r = Kern::ThreadDesRead( iThread, tempPtr, *iMultiplexerIniData, 0, KChunkShiftBy0 );

   492             ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMemoryAllocationFailure );

   493 

   494             // If buffer configuration is given from isc_config.ini as multiplexer configuration string, multiplexer 

   495             // needs configuration before datatransmissin driver is initialized

   496             iIscDevice->iIscMultiplexerInterface->SetInitializationParameters( *iMultiplexerIniData );

   497 

   498             // Allocate buffers and receive queues

   499             iIscDevice->Initialize();

   500 

   501             iIscDevice->iIscDataTransmissionInterface->InitializeDataTransmission( *iDataTransmissionIniData, 

   502                                                                                    iInitializeDfc,

   503                                                                                    iDataTransmissionErrorCode );            

   504             break;

   505             }

   506             

   507         case EIscAsyncOpen:

   508             {

   509             iIscRequests[EIscAsyncOpen] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   510             if ( iIscDevice->ConnectionStatus() == EIscConnectionOk )

   511                 {

   512                 TDesC8* openInfo = ( TDesC8* )tablePtr[ KThirdParam ];

   513                 // Channel info parameter has to be copied from user side in Epoc Kernel Architecture 2

   514                 TInt length = Kern::ThreadGetDesLength( iThread, ( TDesC8* )tablePtr[ KThirdParam ] );

   515                 TUint8* buffer = NULL;

   516                 TPtr8* bufferPtr = NULL;

   517                 if ( length > KErrNone )

   518                     {

   519                     C_TRACE( ( _T( "DIscChannel::HandleAsyncRequest EIscAsyncOpen channel info got" ) ) );

   520                     buffer = ( TUint8* )Kern::Alloc( length );

   521                     bufferPtr = new ( TPtr8 )( buffer, length );

   522                     TInt r = Kern::ThreadDesRead( iThread, openInfo, *bufferPtr, 0, KChunkShiftBy0 );

   523                     ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMemoryAllocationFailure );

   524                     openInfo = ( TDesC8* )bufferPtr;

   525                     }

   526                 iIscDevice->iIscMultiplexerInterface->OpenDLC( ( TUint16 )tablePtr[ KSecondParam ], 

   527                                                                openInfo,

   528                                                                this );

   529 

   530                 if ( buffer )

   531                     Kern::Free( buffer );

   532                 if ( bufferPtr )

   533                     {

   534                     delete bufferPtr;

   535                     bufferPtr = NULL;

   536                     }

   537                 }

   538             else

   539                 {

   540                 CompleteRequest( aFunction, KErrNotReady );

   541                 }

   542             break;

   543             }

   544         case EIscAsyncSend:

   545             {

   546             iIscRequests[EIscAsyncSend] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   547             if ( iIscDevice->ConnectionStatus() == EIscConnectionOk

   548                 && iULFlowControlStatus == EIscFlowControlOff )

   549                 {

   550                 TDesC8* ptr = ( TDesC8* ) tablePtr[ KSecondParam ];

   551 

   552                 // No return values check needed. Request completed with error value by multiplexer

   553                 iIscDevice->iIscMultiplexerInterface->Send( ( TUint16 )aFunction,

   554                                                             iChannelNumber, 

   555                                                             *ptr,

   556                                                             this );

   557                 }

   558             else

   559                 {

   560                 if ( iULFlowControlStatus != EIscFlowControlOff )

   561                     {

   562                     CompleteRequest( aFunction, KErrOverflow );

   563                     }

   564                 else

   565                     {

   566                     CompleteRequest( aFunction, KErrNotReady );

   567                     }

   568                 }

   569             break;

   570             }

   571         case EIscAsyncReceive:

   572             {    

   573             TRACE_ASSERT( tablePtr[ KFirstParam ] );

   574             TRACE_ASSERT( tablePtr[ KSecondParam ] );

   575             TRACE_ASSERT( tablePtr[ KThirdParam ] );

   576             

   577             // check for descriptor validity

   578             TRACE_ASSERT( Kern::ThreadGetDesMaxLength( iThread, (TPtr8* )tablePtr[KSecondParam] ) > 0 ); 

   579             

   580             //Store needed length ptr

   581             iNeededBufLen = ( TPtr8* )tablePtr[ KThirdParam ];

   582             

   583             //Store msg data ptr

   584             iReceiveBufPtr = ( TPtr8* )tablePtr[ KSecondParam ];

   585             

   586             iIscRequests[EIscAsyncReceive] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   587                 

   588             break;

   589             }

   590         case EIscAsyncDataSend:

   591             {

   592             iIscRequests[EIscAsyncDataSend] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   593                 

   594             if ( iIscDevice->ConnectionStatus() == EIscConnectionOk

   595                 && iULFlowControlStatus == EIscFlowControlOff )

   596                 {

   597                 TDesC8* ptr = ( TDesC8* )tablePtr[ KSecondParam ];

   598                 iIscDevice->iIscMultiplexerInterface->DataSend( ( TUint16 )aFunction,

   599                                                                 iChannelNumber,

   600                                                                 *ptr,

   601                                                                 this );

   602                 }

   603             else

   604                 {

   605                 if ( iULFlowControlStatus != EIscFlowControlOff )

   606                     {

   607                     CompleteRequest( aFunction, KErrOverflow );

   608                     }

   609                 else

   610                     {

   611                     CompleteRequest( aFunction, KErrNotReady );

   612                     }

   613                 }

   614             break;

   615             }

   616         case EIscAsyncDataReceive:

   617             {

   618             TRACE_ASSERT( tablePtr[ KFirstParam ] );

   619             TRACE_ASSERT( tablePtr[ KSecondParam ] );

   620             TRACE_ASSERT( tablePtr[ KThirdParam ] );

   621 

   622             // check for descriptor validity

   623             TRACE_ASSERT( Kern::ThreadGetDesMaxLength( iThread, (TPtr8* )tablePtr[KSecondParam] ) > 0 ); 

   624             

   625             //Store needed length ptr

   626             iNeededDataBufLen = ( TPtr8* )tablePtr[ KThirdParam ];

   627             

   628             //Store msg data ptr

   629             iDataReceiveBufPtr = ( TPtr8* )tablePtr[ KSecondParam ];

   630             

   631             iIscRequests[EIscAsyncDataReceive] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   632                 

   633             break;

   634             }

   635         case EIscAsyncNotifyConnectionStatus:

   636             {

   637             iIscConnectionStatusPtr = ( TPtr8* )tablePtr[ KSecondParam ];

   638             iIscRequests[EIscAsyncNotifyConnectionStatus] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   639             break;

   640             }

   641         case EIscAsyncNotifyFlowControlStatus:

   642             {

   643             iIscFlowControlStatusPtr = reinterpret_cast<TPtr8*>( tablePtr[ KSecondParam ] );

   644             iIscRequests[ EIscAsyncNotifyFlowControlStatus ] = reinterpret_cast<TRequestStatus*>( tablePtr[ KFirstParam ] );

   645             C_TRACE( ( _T( "DIscChannel::NotifyFlowControl iLastNotifiedULFlowstatus = %d iULFlowControlStatus = %d" ), iLastNotifiedULFlowstatus, iULFlowControlStatus ) );

   646             

   647             if( iULFlowControlStatus != iLastNotifiedULFlowstatus )

   648                 {

   649                 // Complete immediately.

   650                 C_TRACE( ( _T( "DIscChannel::HandleAsyncRequest iULFlowControlStatus != iLastNotifiedULFlowstatus" ) ) );

   651                 NotifyFlowControl( iULFlowControlStatus );    

   652                 }

   653             else

   654                 {

   655                 // None

   656                 }

   657             break;

   658             }

   659         case EIscAsyncCustomOperation1:

   660         case EIscAsyncCustomOperation2:

   661         case EIscAsyncCustomOperation3:

   662         case EIscAsyncCustomOperation4:

   663         case EIscAsyncCustomOperation5:

   664             {

   665             iIscRequests[aFunction] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   666             TAny* tempPtr = ( TAny* )tablePtr[ KSecondParam ];

   667             iIscDevice->iIscMultiplexerInterface->CustomFunction( iChannelNumber, 

   668                                                              ( TUint16 )aFunction, 

   669                                                              tempPtr,

   670                                                              this );

   671             break;

   672             }

   673         case EIscAsyncClose:

   674             {

   675             iIscRequests[aFunction] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

   676 

   677             ResetBuffers();

   678             

   679             // Cancel all active requests except asynchronous close

   680             for ( TInt i( KErrNone ); i < EIscAsyncLast; i++ )

   681                 {

   682                 // if request is active complete it with KErrCancel

   683                 if ( iIscRequests[i] && i != EIscAsyncClose )

   684                     {

   685                     iIscDevice->iIscMultiplexerInterface->CancelNotify( iChannelNumber, i, this );

   686                     CompleteRequest( i, KErrCancel );

   687                     }

   688                 }            

   689 

   690             iChannelOpen = EFalse;

   691 

   692             iIscDevice->iIscMultiplexerInterface->CloseDLC( iChannelNumber, this );

   693             

   694             break;

   695             }

   696         default:

   697             {

   698             ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscUnknownCommand );

   699             break;

   700             }

   701         }

   702 

   703     IscChannelContainer::AddDfc();

   704     

   705     }

   706 

   707 

   708 // -----------------------------------------------------------------------------

   709 // DIscChannel::HandleSyncRequest

   710 // Handles synchronous client requests

   711 // ( other items were commented in a header ).

   712 // -----------------------------------------------------------------------------

   713 //

   714 TInt DIscChannel::HandleSyncRequest( 

   715         TInt aFunction, 

   716         TAny* a1 )

   717     {

   718     C_TRACE( ( _T( "DIscChannel::HandleSyncRequest(0x%x, 0x%x) channelPtr 0x%x" ), aFunction, a1, this ) );

   719 

   720     TInt error( KErrNone );

   721     TUint32* tablePtr = ( TUint32* )a1;

   722 

   723     switch ( aFunction )

   724         {

   725         case EIscSyncClose:

   726             {

   727             ResetBuffers();

   728             

   729             iIscDevice->iIscMultiplexerInterface->CloseDLC( iChannelNumber, this );

   730             

   731             // Cancel all active requests 

   732             for ( TInt i( KErrNone ); i < EIscAsyncLast; i++ )

   733                 {

   734                 // if request is active complete it with KErrCancel

   735                 if ( iIscRequests[i] )

   736                     {

   737                     iIscDevice->iIscMultiplexerInterface->CancelNotify( iChannelNumber, i, this );

   738                     CompleteRequest( i, KErrCancel );

   739                     }

   740                 }

   741 

   742             error = KErrNone;

   743             iChannelOpen = EFalse;

   744             break;

   745             }

   746         case EIscSyncSend:

   747             {

   748             if ( iIscDevice->ConnectionStatus() == EIscConnectionOk 

   749                 && iULFlowControlStatus == EIscFlowControlOff ) 

   750                 {

   751                 

   752                 TDesC8* ptr = ( TDesC8* ) tablePtr[ KFirstParam ];

   753                 error = iIscDevice->iIscMultiplexerInterface->Send( ( TUint16 )aFunction,

   754                                                             iChannelNumber, 

   755                                                             *ptr,

   756                                                             this );

   757                 }

   758             else

   759                 {

   760                 if ( iULFlowControlStatus != EIscFlowControlOff )

   761                     {

   762                     error = KErrOverflow;

   763                     }

   764                 else

   765                     {

   766                     error = KErrNotReady;

   767                     }

   768                 }

   769             break;

   770             }

   771         case EIscSyncDataSend:

   772             {

   773             if ( iIscDevice->ConnectionStatus() == EIscConnectionOk 

   774                 && iULFlowControlStatus == EIscFlowControlOff ) 

   775                 {

   776                 TDesC8* ptr = ( TDesC8* ) tablePtr[ KFirstParam ];

   777                 error = iIscDevice->iIscMultiplexerInterface->DataSend( ( TUint16 )aFunction,

   778                                                                 iChannelNumber,

   779                                                                 *ptr,

   780                                                                 this );

   781                 }

   782             else

   783                 {

   784                 if ( iULFlowControlStatus != EIscFlowControlOff )

   785                     {

   786                     error = KErrOverflow;

   787                     }

   788                 else

   789                     {

   790                     error = KErrNotReady;

   791                     }

   792                 }

   793             break;

   794             }

   795         case EIscSyncGetConnectionStatus:

   796             {

   797             error = iIscDevice->ConnectionStatus();

   798             break;

   799             }

   800         case EIscSyncGetFlowControlStatus:

   801             {

   802             error = iULFlowControlStatus;

   803             break;

   804             }

   805         case EIscSyncGetChannelInfo:

   806             {

   807             TDes8* tempPtr = ( TDes8* ) tablePtr[1];

   808             error = iIscDevice->iIscMultiplexerInterface->GetChannelInfo( ( TUint16 )tablePtr[ KFirstParam ],

   809                                                                   *tempPtr );

   810             break;

   811             }

   812         case EIscSyncGetMaximunDataSize:

   813             {

   814             error = iIscDevice->iIscMultiplexerInterface->MaximumDataSize( iChannelNumber );

   815             break;

   816             }

   817         case EIscSyncCustomOperation1:

   818         case EIscSyncCustomOperation2:

   819         case EIscSyncCustomOperation3:

   820         case EIscSyncCustomOperation4:

   821         case EIscSyncCustomOperation5:

   822             {

   823             TAny* tempPtr = ( TAny* )tablePtr[ KFirstParam ];

   824             error = iIscDevice->iIscMultiplexerInterface->CustomFunction( iChannelNumber,

   825                                                                      ( TUint16 )aFunction, 

   826                                                                      tempPtr,

   827                                                                      this );

   828             break;

   829             }

   830         case EIscSyncResetBuffers:

   831             {

   832             ResetBuffers();

   833             error = KErrNone;

   834             break;

   835             }

   836         default:

   837             {

   838             ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscUnknownCommand );

   839             break;

   840             }

   841         }

   842     return error;

   843     }

   844 

   845 // -----------------------------------------------------------------------------

   846 // DIscChannel::HandleCancelRequest

   847 // Cancels active request

   848 // ( other items were commented in a header ).

   849 // -----------------------------------------------------------------------------

   850 //

   851 TInt DIscChannel::HandleCancelRequest( 

   852     TInt aFunction, 

   853     TAny* /*a1*/ )

   854     {

   855     C_TRACE( ( _T( "DIscChannel::HandleCancelRequest(0x%x)" ), aFunction ) );

   856 

   857     TUint16 operationToCancel( 0 );

   858     switch ( aFunction )

   859         {

   860         

   861         case EIscCancelAsyncInitialize:

   862             {

   863             if ( iDataTransmissionIniData )

   864                 {

   865                 Kern::Free( iDataTransmissionBuffer );

   866                 delete iDataTransmissionIniData;

   867                 iDataTransmissionIniData = NULL;

   868                 }

   869             if ( iMultiplexerIniData )

   870                 {

   871                 Kern::Free( iMultiplexerBuffer );

   872                 delete iMultiplexerIniData;

   873                 iMultiplexerIniData = NULL; 

   874                 }

   875 

   876             operationToCancel = EIscAsyncInitializeModemInterface;

   877             break;

   878             }

   879         case EIscCancelAsyncOpen:

   880             {

   881             if ( KRequestPending == IsPending( EIscAsyncOpen ) )

   882                 {

   883                 iChannelOpen = EFalse;

   884                 }            

   885             operationToCancel = EIscAsyncOpen;

   886             break;

   887             }

   888         case EIscCancelAsyncSend:

   889             {

   890             operationToCancel = EIscAsyncSend;

   891             // Cancel sending / empty send queues

   892             iIscDevice->CancelSending( iChannelNumber, this );

   893             break;

   894             }

   895         case EIscCancelAsyncDataSend:

   896             {

   897             operationToCancel = EIscAsyncDataSend;

   898             // Cancel sending / empty send queues

   899             iIscDevice->CancelSending( iChannelNumber, this );

   900             break;

   901             }

   902         

   903         case EIscCancelAsyncReceive:

   904             {

   905             iReceiveBufPtr = NULL;

   906             iNeededBufLen = NULL;

   907             operationToCancel = EIscAsyncReceive;

   908             break;

   909             }

   910         

   911         case EIscCancelAsyncDataReceive:

   912             {

   913             iDataReceiveBufPtr = NULL;

   914             iNeededDataBufLen = NULL;

   915             operationToCancel = EIscAsyncDataReceive;

   916             break;

   917             }

   918         

   919         case EIscCancelAsyncNotifyConnection:

   920             {

   921             iIscConnectionStatusPtr = NULL;

   922             operationToCancel = EIscAsyncNotifyConnectionStatus;

   923             break;

   924             }

   925         

   926         case EIscCancelAsyncNotifyFlowControl:

   927             {

   928             iIscFlowControlStatusPtr = NULL;

   929             operationToCancel = EIscAsyncNotifyFlowControlStatus;

   930             break;

   931             }

   932         case EIscCancelAsyncCustomOperation1:

   933             {

   934             operationToCancel = EIscAsyncCustomOperation1;

   935             break;

   936             }

   937         case EIscCancelAsyncCustomOperation2:

   938             {

   939             operationToCancel = EIscAsyncCustomOperation2;

   940             break;

   941             }

   942         case EIscCancelAsyncCustomOperation3:

   943             {

   944             operationToCancel = EIscAsyncCustomOperation3;

   945             break;

   946             }

   947         case EIscCancelAsyncCustomOperation4:

   948             {

   949             operationToCancel = EIscAsyncCustomOperation4;

   950             break;

   951             }

   952         case EIscCancelAsyncCustomOperation5:

   953             {

   954             operationToCancel = EIscAsyncCustomOperation5;

   955             break;

   956             }

   957         case EIscCancelAsyncClose:

   958             {

   959             TRACE_ASSERT_ALWAYS;

   960             operationToCancel = EIscAsyncClose;

   961             break;

   962             }

   963         default:

   964             {

   965             ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscUnknownCommand );

   966             break;

   967             }

   968         }

   969 

   970     iIscDevice->iIscMultiplexerInterface->CancelNotify( iChannelNumber, ( TUint16 )operationToCancel, this );

   971     CompleteRequest( operationToCancel, KErrCancel );

   972 

   973     return KErrNone;

   974     }

   975 

   976 // -----------------------------------------------------------------------------

   977 // DIscChannel::DoCreate

   978 // Secondary initialization of channel

   979 // ( other items were commented in a header ).

   980 // -----------------------------------------------------------------------------

   981 //

   982 TInt DIscChannel::DoCreate( 

   983     TInt aUnit, 

   984     const TDesC8* anInfo, 

   985     const TVersion& /*aVer*/ )

   986     {

   987     C_TRACE( ( _T( "DIscChannel::DoCreate(0x%x, 0x%x, 0x%x)" ), aUnit, anInfo, this ) );

   988     if ( !Kern::CurrentThreadHasCapability( ECapabilityCommDD,__PLATSEC_DIAGNOSTIC_STRING

   989         ( "Checked by ISCDRIVER.LDD ( Inter-System Communication Driver )" ) ) )

   990         {

   991         return KErrPermissionDenied;

   992         }    

   993     TUint16 channelNumber = ( TUint16 )aUnit;

   994     if ( anInfo )

   995         {

   996         // check for channel number inside anInfo

   997         TUint8 channel = ( TUint8 )( *anInfo )[0];

   998         if ( channel >= KIscMaxChannelsInLdd )

   999             {

  1000             channelNumber += KIscMaxChannelsInLdd;

  1001             }

  1002         C_TRACE( ( _T( "DIscChannel::DoCreate channel=0x%x" ), channelNumber ) );

  1003         }

  1004 

  1005     if ( channelNumber != KIscControlChannel )

  1006         {

  1007         TIscConfiguration config;

  1008         iIscDevice->iIscMultiplexerInterface->GetConfiguration( config );

  1009         TInt i( KErrNone );

  1010         iFrameRx = new TUint32*[config.channelRcvQueueSize];

  1011         ASSERT_RESET_ALWAYS( iFrameRx, "IscDriver",EIscMemoryAllocationFailure );

  1012         for ( i = KErrNone; i < config.channelRcvQueueSize; i++ )

  1013             {

  1014             iFrameRx[i] = 0;

  1015             }

  1016 

  1017         iDataFrameRx = new TUint32*[config.channelDataRcvQueueSize];

  1018         ASSERT_RESET_ALWAYS( iDataFrameRx, "IscDriver",EIscMemoryAllocationFailure );

  1019         for ( i = KErrNone; i < config.channelDataRcvQueueSize; i++ )

  1020             {

  1021             iDataFrameRx[i] = 0;

  1022             }

  1023 

  1024         // creating frame queue for incoming frames

  1025         iFrameRxQueue = new  DIscQueue( iFrameRx, config.channelRcvQueueSize );

  1026         ASSERT_RESET_ALWAYS( iFrameRxQueue, "IscDriver",EIscMemoryAllocationFailure );

  1027 

  1028         // creating frame queue for incoming data frames

  1029         iDataFrameRxQueue = new  DIscQueue( iDataFrameRx, config.channelDataRcvQueueSize );

  1030         ASSERT_RESET_ALWAYS( iDataFrameRxQueue, "IscDriver",EIscMemoryAllocationFailure );

  1031     

  1032         // Flowcontrol marks for data frames

  1033         iIscChannelHighWaterMark = ( TUint16 )( ( ( ( TUint16 )config.channelDataRcvQueueSize ) * KMultiplyByThree ) / KDivideByFour );// 75% = multiply with 3, divide by 4 

  1034         iIscChannelLowWaterMark =  ( TUint16 )( ( ( ( TUint16 )config.channelDataRcvQueueSize ) * KMultiplyByOne ) / KDivideByFour );// 25% = multiply with 1, divide by 4 

  1035     

  1036         TRACE_ASSERT( iIscChannelHighWaterMark != 0 );

  1037         }

  1038 

  1039 #ifndef ISC_CHANNEL_SHARING_IN_USE

  1040     // Remove checking if channel already set to enable channel sharing

  1041     //Check if channel already set

  1042     if ( IscChannelContainer::Channel( channelNumber, 0 ) )

  1043         {

  1044         C_TRACE( ( _T( "DIscChannel::DoCreate channel 0x%x already set!!!!" ), channelNumber ) );

  1045         return KErrAlreadyExists;

  1046         }

  1047 #endif //ISC_CHANNEL_SHARING_IN_USE

  1048 

  1049     //Add itself to channel table.

  1050     TInt error = IscChannelContainer::SetChannel( ( DIscChannel* )this, channelNumber );

  1051     if ( KErrNone != error )

  1052         {

  1053         return error;

  1054         }

  1055 

  1056     iChannelOpen = ETrue;

  1057     

  1058     // Store channel number.

  1059     iChannelNumber = channelNumber;    

  1060     SetDfcQ( Kern::DfcQue0() );

  1061     iMsgQ.Receive();

  1062     

  1063     return KErrNone;

  1064 

  1065     }

  1066 

  1067 

  1068 // -----------------------------------------------------------------------------

  1069 // DIscChannel::NotifyFlowControl

  1070 // Notify user side client that uplink flow control is on/off

  1071 // ( other items were commented in a header ).

  1072 // -----------------------------------------------------------------------------

  1073 //

  1074 void DIscChannel::NotifyFlowControl

  1075         ( 

  1076         const TInt aFlowControlStatus

  1077         )

  1078     {

  1079     C_TRACE( ( _T( "DIscChannel::NotifyFlowControl(0x%x) iChannelNumber 0x%x channelPtr 0x%x" ), aFlowControlStatus, iChannelNumber, this ) );

  1080 

  1081     iULFlowControlStatus = aFlowControlStatus;

  1082     if( iIscRequests[ EIscAsyncNotifyFlowControlStatus ]

  1083         && iIscFlowControlStatusPtr )

  1084         {

  1085         TPtr8 tempDes( reinterpret_cast<TUint8*>( &iULFlowControlStatus ), sizeof ( TInt ), sizeof ( TInt ) );

  1086         iLastNotifiedULFlowstatus = aFlowControlStatus;

  1087         TInt r = ThreadWrite( static_cast<TAny*>( iIscFlowControlStatusPtr ), &tempDes, 0 );

  1088         TRACE_ASSERT( r == KErrNone ); 

  1089         CompleteRequest( EIscAsyncNotifyFlowControlStatus, r );

  1090         }

  1091     else

  1092         {

  1093         C_TRACE( ( _T( "DIscChannel::NotifyFlowControl No request pending!" ) ) );        

  1094         }

  1095     }

  1096 

  1097 // -----------------------------------------------------------------------------

  1098 // DIscChannel::NotifyConnectionStatus

  1099 // Notify user side client that connection status has changed

  1100 // ( other items were commented in a header ).

  1101 // -----------------------------------------------------------------------------

  1102 //

  1103 void DIscChannel::NotifyConnectionStatus( 

  1104     const TInt aConnectionStatus ) 

  1105     {

  1106     C_TRACE( ( _T( "DIscChannel::NotifyConnectionStatus(0x%x) channelPtr 0x%x" ), aConnectionStatus, this ) );

  1107 

  1108     if ( iIscRequests[EIscAsyncNotifyConnectionStatus] 

  1109          && iIscConnectionStatusPtr )

  1110         {

  1111         TInt temp = aConnectionStatus;

  1112         TPtr8 tempDes( ( TUint8* )&temp,sizeof ( TInt ),sizeof ( TInt ) );

  1113         TInt r = ThreadWrite( ( TAny* )iIscConnectionStatusPtr, &tempDes, 0 );

  1114         TRACE_ASSERT( r == KErrNone );

  1115 

  1116         CompleteRequest( EIscAsyncNotifyConnectionStatus, r );

  1117         }

  1118     }

  1119 

  1120 // -----------------------------------------------------------------------------

  1121 // DIscChannel::IsPending

  1122 // Check if asynchronous request is active

  1123 // ( other items were commented in a header ).

  1124 // -----------------------------------------------------------------------------

  1125 //

  1126 TInt DIscChannel::IsPending( 

  1127     const TUint16 aReqNumber )

  1128     {

  1129     TInt error( KErrNone );

  1130     if ( iIscRequests[aReqNumber] )

  1131         {

  1132         error = KRequestPending;

  1133         }

  1134     else