Mercurial Mercurial > oss > FCL > sf > incubator > modemadaptation / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
connectivitylayer/usbphonetlink/usbpnserver_exe/src/cusbpnisasender.cpp
changeset 7 fa67e03b87df
parent 5 8ccc39f9d787
child 9 8486d82aef45
equal deleted inserted replaced
6:942573423a60 7:fa67e03b87df 
    27 #include "cusbpnisasenderTraces.h"
 
    27 #include "cusbpnisasenderTraces.h"
 
    28 #endif
 
    28 #endif
 
    29 
    29 
    30 #include <iscapi.h>                 // For RIscApi
 
    30 #include <iscapi.h>                 // For RIscApi
 
    31 
    31 
    32 // EXTERNAL DATA STRUCTURES
 
       
    33 // EXTERNAL FUNCTION PROTOTYPES
 
       
    34 // CONSTANTS
 
       
    35 // MACROS
 
       
    36 // LOCAL CONSTANTS AND MACROS
 
    32 // LOCAL CONSTANTS AND MACROS
 
    37 // MODULE DATA STRUCTURES
 
    33 const TInt KTotalIsaPacketCount( KPnIsaPacketCount + 1 );
 
    38 // LOCAL FUNCTION PROTOTYPES
 
    34 
    39 // FORWARD DECLARATIONS
 
       
    40 
       
    41 // ============================= LOCAL FUNCTIONS ===============================
 
       
    42 // ============================ MEMBER FUNCTIONS ===============================
 
    35 // ============================ MEMBER FUNCTIONS ===============================
 
    43 
    36 
    44 // -----------------------------------------------------------------------------
 
    37 // -----------------------------------------------------------------------------
 
    45 // CUsbPnIsaSender::CUsbPnIsaSender
 
    38 // CUsbPnIsaSender::CUsbPnIsaSender
 
    46 // C++ default constructor can NOT contain any code, that
 
    39 // C++ default constructor can NOT contain any code, that
 
    70 void CUsbPnIsaSender::ConstructL()
 
    63 void CUsbPnIsaSender::ConstructL()
 
    71     {
 
    64     {
 
    72     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_CONSTRUCTL_ENTRY, "CUsbPnIsaSender::ConstructL" );
 
    65     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_CONSTRUCTL_ENTRY, "CUsbPnIsaSender::ConstructL" );
 
    73     C_TRACE( ( _T( "CUsbPnIsaSender::ConstructL()" ) ) );
 
    66     C_TRACE( ( _T( "CUsbPnIsaSender::ConstructL()" ) ) );
 
    74 
    67 
    75     // Create circular buffer objects
 
    68     for(TUint i = 1; i < KTotalIsaPacketCount; i++)
 
    76     for(TUint i = 1; i < (KPnIsaPacketCount + 1); i++)
 
       
    77         {
 
    69         {
 
    78         AddPacketBufferL(i);
 
    70         AddPacketBufferL(i);
 
    79         }
 
    71         }
 
    80     iCurrentPacket = iPacket;
 
    72     iCurrentPacket = iPacket;
 
    81 
    73 
   111     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_CUSBPNISASENDER_DESTRUCTOR_ENTRY, "CUsbPnIsaSender::~CUsbPnIsaSender" );
 
   103     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_CUSBPNISASENDER_DESTRUCTOR_ENTRY, "CUsbPnIsaSender::~CUsbPnIsaSender" );
 
   112     C_TRACE( ( _T( "CUsbPnIsaSender::~CUsbPnIsaSender()" ) ) );
 
   104     C_TRACE( ( _T( "CUsbPnIsaSender::~CUsbPnIsaSender()" ) ) );
 
   113 
   105 
   114     Cancel();
 
   106     Cancel();
 
   115 
   107 
   116     // Delete circular buffer objects
 
   108     DeletePackets();
 
   117     CUsbPnPacket* packet;
 
   109 
       
   110     iCurrentPacket = NULL;
 
       
   111     iPacket = NULL;
 
       
   112 
       
   113     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_CUSBPNISASENDER_DESTRUCTOR_EXIT, "CUsbPnIsaSender::~CUsbPnIsaSender - return" );
 
       
   114     C_TRACE( ( _T( "CUsbPnIsaSender::~CUsbPnIsaSender() - return" ) ) );
 
       
   115     }
 
       
   116 
       
   117 // -----------------------------------------------------------------------------
 
       
   118 // CUsbPnIsaSender::DeletePackets
 
       
   119 // -----------------------------------------------------------------------------
 
       
   120 void CUsbPnIsaSender::DeletePackets( )
 
       
   121     {
 
       
   122     OstTrace0( TRACE_API, CUSBPNISASENDER_DELETEPACKETS_ENTRY, "CUsbPnIsaSender::DeletePackets" );
 
       
   123     A_TRACE( ( _T( "CUsbPnIsaSender::DeletePackets()" ) ) );
 
       
   124     CUsbPnPacket* packet = NULL;
 
   118     while(iPacketCount > 0)
 
   125     while(iPacketCount > 0)
 
   119         {
 
   126         {
 
   120         iPacketCount--;
 
   127         iPacketCount--;
 
   121         packet = &iPacket->NextPacket();
 
   128         packet = &iPacket->NextPacket();
 
   122         delete iPacket;
 
   129         delete iPacket;
 
   123         iPacket = packet;
 
   130         iPacket = packet;
 
   124         }
 
   131         }
 
   125     iCurrentPacket = NULL;
 
   132     OstTrace0( TRACE_API, CUSBPNISASENDER_DELETEPACKETS_EXIT, "CUsbPnIsaSender::DeletePackets - return void" );
 
   126     iPacket = NULL;
 
   133     A_TRACE( ( _T( "CUsbPnIsaSender::DeletePackets() - return void" ) ) );
 
   127 
       
   128     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_CUSBPNISASENDER_DESTRUCTOR_EXIT, "CUsbPnIsaSender::~CUsbPnIsaSender - return" );
 
       
   129     C_TRACE( ( _T( "CUsbPnIsaSender::~CUsbPnIsaSender() - return" ) ) );
 
       
   130     }
 
   134     }
 
   131 
   135 
   132 // -----------------------------------------------------------------------------
 
   136 // -----------------------------------------------------------------------------
 
   133 // CUsbPnIsaSender::AddPacketBuffer
 
   137 // CUsbPnIsaSender::AddPacketBuffer
 
   134 // -----------------------------------------------------------------------------
 
   138 // -----------------------------------------------------------------------------
 
   135 void CUsbPnIsaSender::AddPacketBufferL( TInt aIndex )
 
   139 void CUsbPnIsaSender::AddPacketBufferL( TInt aIndex )
 
   136     {
 
   140     {
 
   137     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_ADDPACKETBUFFERL_ENTRY, "CUsbPnIsaSender::AddPacketBufferL" );
 
   141     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_ADDPACKETBUFFERL_ENTRY, "CUsbPnIsaSender::AddPacketBufferL" );
 
   138     C_TRACE((_T("CUsbPnIsaSender::AddPacketBuffer()")));
 
   142     C_TRACE((_T("CUsbPnIsaSender::AddPacketBuffer()")));
 
   139 
   143 
   140     iPacketCount++;
 
   144     if( aIndex <= KTotalIsaPacketCount )
 
   141     iPacket = CUsbPnPacket::NewL( iPacket, aIndex );
 
   145         {
 
       
   146         iPacketCount++;
 
       
   147         iPacket = CUsbPnPacket::NewL( iPacket, aIndex );
 
       
   148         }
 
       
   149     else
 
       
   150         {
 
       
   151         TRACE_ASSERT_ALWAYS;
 
       
   152         }
 
   142 
   153 
   143     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_ADDPACKETBUFFERL_EXIT, "CUsbPnIsaSender::AddPacketBufferL - return void" );
 
   154     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_ADDPACKETBUFFERL_EXIT, "CUsbPnIsaSender::AddPacketBufferL - return void" );
 
   144     C_TRACE((_T("CUsbPnIsaSender::AddPacketBuffer - return void")));
 
   155     C_TRACE((_T("CUsbPnIsaSender::AddPacketBuffer - return void")));
 
   145     }
 
   156     }
 
   146 
   157 
   147 // -----------------------------------------------------------------------------
 
   158 // -----------------------------------------------------------------------------
 
   148 // CUsbPnIsaSender::DoCancel
 
   159 // CUsbPnIsaSender::DoCancel
 
   149 // ?implementation_description
 
       
   150 // (other items were commented in a header).
 
       
   151 // -----------------------------------------------------------------------------
 
   160 // -----------------------------------------------------------------------------
 
   152 //
 
   161 //
 
   153 void CUsbPnIsaSender::DoCancel( )
 
   162 void CUsbPnIsaSender::DoCancel( )
 
   154     {
 
   163     {
 
   155     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_DOCANCEL_ENTRY, "CUsbPnIsaSender::DoCancel" );
 
   164     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_DOCANCEL_ENTRY, "CUsbPnIsaSender::DoCancel" );
 
   161     C_TRACE( ( _T( "CUsbPnIsaSender::DoCancel() - return void" ) ) );
 
   170     C_TRACE( ( _T( "CUsbPnIsaSender::DoCancel() - return void" ) ) );
 
   162     }
 
   171     }
 
   163 
   172 
   164 // -----------------------------------------------------------------------------
 
   173 // -----------------------------------------------------------------------------
 
   165 // CUsbPnIsaSender::RunL
 
   174 // CUsbPnIsaSender::RunL
 
   166 // ?implementation_description
 
       
   167 // (other items were commented in a header).
 
       
   168 // -----------------------------------------------------------------------------
 
   175 // -----------------------------------------------------------------------------
 
   169 //
 
   176 //
 
   170 void CUsbPnIsaSender::RunL( )
 
   177 void CUsbPnIsaSender::RunL( )
 
   171     {
 
   178     {
 
   172     OstTrace1( TRACE_API, CUSBPNISASENDER_RUNL_ENTRY, "CUsbPnIsaSender::RunL;iStatus=%d", iStatus.Int() );
 
   179     OstTrace1( TRACE_API, CUSBPNISASENDER_RUNL_ENTRY, "CUsbPnIsaSender::RunL;iStatus=%d", iStatus.Int() );
 
   174 
   181 
   175     User::LeaveIfError( iStatus.Int() );
 
   182     User::LeaveIfError( iStatus.Int() );
 
   176 
   183 
   177     iCurrentPacket->ReleaseL();
 
   184     iCurrentPacket->ReleaseL();
 
   178 
   185 
   179     iBufferListener.Receive( ETrue/*dummy*/ );
 
   186     iBufferListener.Receive( ETrue );
 
   180 
   187 
   181     iCurrentPacket = &iCurrentPacket->NextPacket();
 
   188     iCurrentPacket = &iCurrentPacket->NextPacket();
 
   182     OstTraceExt2( TRACE_DETAILED, CUSBPNISASENDER_RUNL, "CUsbPnIsaSender::RunL;tail:%d,head:%d", iCurrentPacket->PacketNumber(), iPacket->PacketNumber() );
 
   189     OstTraceExt2( TRACE_DETAILED, CUSBPNISASENDER_RUNL, "CUsbPnIsaSender::RunL;tail:%d,head:%d", iCurrentPacket->PacketNumber(), iPacket->PacketNumber() );
 
   183     E_TRACE( ( _T( "CUsbPnIsaSender::RunL() - tail:%d,head:%d " ), iCurrentPacket->PacketNumber(), iPacket->PacketNumber()));
 
   190     E_TRACE( ( _T( "CUsbPnIsaSender::RunL() - tail:%d,head:%d " ), iCurrentPacket->PacketNumber(), iPacket->PacketNumber()));
 
   184 
   191 
   194     A_TRACE( ( _T( "CUsbPnIsaSender::RunL() - return void" ) ) );
 
   201     A_TRACE( ( _T( "CUsbPnIsaSender::RunL() - return void" ) ) );
 
   195     }
 
   202     }
 
   196 
   203 
   197 // -----------------------------------------------------------------------------
 
   204 // -----------------------------------------------------------------------------
 
   198 // CUsbPnIsaSender::RunError
 
   205 // CUsbPnIsaSender::RunError
 
   199 // ?implementation_description
 
       
   200 // (other items were commented in a header).
 
       
   201 // -----------------------------------------------------------------------------
 
   206 // -----------------------------------------------------------------------------
 
   202 //
 
   207 //
 
   203 TInt CUsbPnIsaSender::RunError( TInt aError )
 
   208 TInt CUsbPnIsaSender::RunError( TInt aError )
 
   204     {
 
   209     {
 
   205     OstTrace1( TRACE_API, CUSBPNISASENDER_RUNERROR_ENTRY, "CUsbPnIsaSender::RunError;aError=%d", aError );
 
   210     OstTrace1( TRACE_API, CUSBPNISASENDER_RUNERROR_ENTRY, "CUsbPnIsaSender::RunError;aError=%d", aError );
 
   211         case KErrBadDescriptor:
 
   216         case KErrBadDescriptor:
 
   212         case KErrUnderflow:
 
   217         case KErrUnderflow:
 
   213             {
 
   218             {
 
   214             TRACE_ASSERT_ALWAYS;
 
   219             TRACE_ASSERT_ALWAYS;
 
   215             CActiveScheduler::Stop();
 
   220             CActiveScheduler::Stop();
 
   216             aError = KErrNone;
 
       
   217             break;
 
   221             break;
 
   218             }
 
   222             }
 
   219         default:
 
   223         default:
 
   220             {
 
   224             {
 
   221             TRACE_ASSERT_ALWAYS;
 
   225             TRACE_ASSERT_ALWAYS;
 
   224             }
 
   228             }
 
   225         }
 
   229         }
 
   226 
   230 
   227     OstTrace1( TRACE_NORMAL, CUSBPNISASENDER_RUNERROR_EXIT, "CUsbPnIsaSender::RunError - return;aError=%d", aError );
 
   231     OstTrace1( TRACE_NORMAL, CUSBPNISASENDER_RUNERROR_EXIT, "CUsbPnIsaSender::RunError - return;aError=%d", aError );
 
   228     C_TRACE( ( _T( "CUsbPnIsaSender::RunError() return - aError:%d )" ), aError ) );
 
   232     C_TRACE( ( _T( "CUsbPnIsaSender::RunError() return - aError:%d )" ), aError ) );
 
   229     return aError;
 
   233     return KErrNone;
 
   230     }
 
   234     }
 
   231 // -----------------------------------------------------------------------------
 
   235 // -----------------------------------------------------------------------------
 
   232 // CUsbPnIsaSender::Packet
 
   236 // CUsbPnIsaSender::GetNextPacketL
 
   233 // ?implementation_description
 
   237 // -----------------------------------------------------------------------------
 
   234 // (other items were commented in a header).
 
   238 //
 
   235 // -----------------------------------------------------------------------------
 
   239 CUsbPnPacket& CUsbPnIsaSender::GetNextPacketL()
 
   236 //
 
   240     {
 
   237 CUsbPnPacket& CUsbPnIsaSender::PacketL()
 
   241     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_GETNEXTPACKETL_ENTRY, "CUsbPnIsaSender::GetNextPacketL" );
 
   238     {
 
   242     C_TRACE( ( _T( "CUsbPnIsaSender::GetNextPacketL()" ) ) );
 
   239     OstTrace0( TRACE_NORMAL, CUSBPNISASENDER_PACKETL_ENTRY, "CUsbPnIsaSender::PacketL" );
 
       
   240     C_TRACE( ( _T( "CUsbPnIsaSender::PacketL()" ) ) );
 
       
   241 
   243 
   242     CUsbPnPacket& packet( iPacket->NextPacket() );
 
   244     CUsbPnPacket& packet( iPacket->NextPacket() );
 
   243     TBool err = packet.PacketInUse();
 
   245     TBool err = packet.PacketInUse();
 
   244     if (EFalse != err)
 
   246     if (EFalse != err)
 
   245         {
 
   247         {
 
   246         User::Leave( err );
 
   248         User::Leave( err );
 
   247         }
 
   249         }
 
   248 
   250 
   249     OstTrace1( TRACE_NORMAL, CUSBPNISASENDER_PACKETL_EXIT, "CUsbPnIsaSender::PacketL - return;packet=%d", packet.PacketNumber() );
 
   251     OstTrace1( TRACE_NORMAL, CUSBPNISASENDER_GETNEXTPACKETL_EXIT, "CUsbPnIsaSender::GetNextPacketL - return;packet=%d", packet.PacketNumber() );
 
   250     C_TRACE((_T("CUsbPnIsaSender::PacketL() - return packet:%d"), packet.PacketNumber()));
 
   252     C_TRACE((_T("CUsbPnIsaSender::GetNextPacketL() - return packet:%d"), packet.PacketNumber()));
 
   251 
   253 
   252     return packet;
 
   254     return packet;
 
   253     }
 
   255     }
 
   254 
   256 
   255 // -----------------------------------------------------------------------------
 
   257 // -----------------------------------------------------------------------------
 
   256 // CUsbPnIsaSender::Send
 
   258 // CUsbPnIsaSender::AddPacketToSendingQueue
 
   257 // ?implementation_description
 
   259 // -----------------------------------------------------------------------------
 
   258 // (other items were commented in a header).
 
   260 //
 
   259 // -----------------------------------------------------------------------------
 
   261 void CUsbPnIsaSender::AddPacketToSendingQueue( CUsbPnPacket& aPacket )
 
   260 //
 
   262     {
 
   261 void CUsbPnIsaSender::Send( CUsbPnPacket& aPacket )
 
   263     ASSERT( &aPacket );
 
   262     {
 
   264     OstTrace1( TRACE_API, CUSBPNISASENDER_ADDPACKETTOSENDINGQUEUE_ENTRY, "CUsbPnIsaSender::AddPacketToSendingQueue;aPacket=%x", ( TUint )&( aPacket ) );
 
   263     OstTrace1( TRACE_API, CUSBPNISASENDER_SEND_ENTRY, "CUsbPnIsaSender::Send;aPacket=%x", ( TUint )&( aPacket ) );
 
   265     A_TRACE( ( _T( "CUsbPnIsaSender::AddPacketToSendingQueue( aPacket:0x%x)" ), &aPacket ) );
 
   264     A_TRACE( ( _T( "CUsbPnIsaSender::Send( aPacket:0x%x)" ), &aPacket ) );
 
       
   265 
   266 
   266     CUsbPnPacket& packet( iPacket->NextPacket() );
 
   267     CUsbPnPacket& packet( iPacket->NextPacket() );
 
   267     if( &packet == &aPacket )
 
   268     if( &packet == &aPacket )
 
   268         {
 
   269         {
 
   269         iPacket = &packet;
 
   270         iPacket = &packet;
 
   270         OstTrace1( TRACE_DETAILED, CUSBPNISASENDER_SEND, "CUsbPnIsaSender::Send;packet number:%d", iPacket->PacketNumber() );
 
   271         OstTrace1( TRACE_DETAILED, CUSBPNISASENDER_ADDPACKETTOSENDINGQUEUE, "CUsbPnIsaSender::AddPacketToSendingQueue;packet number:%d", iPacket->PacketNumber() );
 
   271         E_TRACE( ( _T( "CUsbPnIsaSender::Send() - packet number:%d" ), iPacket->PacketNumber() ) );
 
   272         E_TRACE( ( _T( "CUsbPnIsaSender::AddPacketToSendingQueue() - packet number:%d" ), iPacket->PacketNumber() ) );
 
   272 
   273 
   273         TryToSendPacket( *iPacket );
 
   274         TryToSendPacket( *iPacket );
 
   274         }
 
   275         }
 
   275     else
 
   276     else
 
   276         {
 
   277         {
 
   277         TRACE_ASSERT_ALWAYS;
 
   278         TRACE_ASSERT_ALWAYS;
 
   278         User::Panic(_L("USBPNSERVER"), KErrTotalLossOfPrecision);
 
   279         User::Panic(_L("USBPNSERVER"), KErrTotalLossOfPrecision);
 
   279         }
 
   280         }
 
   280 
   281 
   281     OstTrace0( TRACE_API, CUSBPNISASENDER_SEND_EXIT, "CUsbPnIsaSender::Send - return void" );
 
   282     OstTrace0( TRACE_API, CUSBPNISASENDER_ADDPACKETTOSENDINGQUEUE_EXIT, "CUsbPnIsaSender::AddPacketToSendingQueue - return void" );
 
   282     A_TRACE( ( _T( "CUsbPnIsaSender::Send() - return void" ) ) );
 
   283     A_TRACE( ( _T( "CUsbPnIsaSender::AddPacketToSendingQueue() - return void" ) ) );
 
   283     }
 
   284     }
 
   284 
   285 
   285 
   286 
   286 // -----------------------------------------------------------------------------
 
   287 // -----------------------------------------------------------------------------
 
   287 // CUsbPnIsaSender::TryToSendPacket
 
   288 // CUsbPnIsaSender::TryToSendPacket
 
   288 // ?implementation_description
 
       
   289 // (other items were commented in a header).
 
       
   290 // -----------------------------------------------------------------------------
 
   289 // -----------------------------------------------------------------------------
 
   291 //
 
   290 //
 
   292 void CUsbPnIsaSender::TryToSendPacket( CUsbPnPacket& aPacket )
 
   291 void CUsbPnIsaSender::TryToSendPacket( CUsbPnPacket& aPacket )
 
   293     {
 
   292     {
 
       
   293     ASSERT( &aPacket );
 
   294     OstTrace1( TRACE_API, CUSBPNISASENDER_TRYTOSENDPACKET_ENTRY, "CUsbPnIsaSender::TryToSendPacket;aPacket=%x", ( TUint )&( aPacket ) );
 
   294     OstTrace1( TRACE_API, CUSBPNISASENDER_TRYTOSENDPACKET_ENTRY, "CUsbPnIsaSender::TryToSendPacket;aPacket=%x", ( TUint )&( aPacket ) );
 
   295     A_TRACE( ( _T( "CUsbPnIsaSender::TryToSendPacket( aPacket:0x%x )" ), &aPacket ) );
 
   295     A_TRACE( ( _T( "CUsbPnIsaSender::TryToSendPacket( aPacket:0x%x )" ), &aPacket ) );
 
   296 
   296 
   297     if(!IsActive())
 
   297     if(!IsActive())
 
   298         {
 
   298         {
 
   299         if( &aPacket == &iCurrentPacket->NextPacket() || &aPacket == iCurrentPacket )
 
   299         if( &aPacket == ( &iCurrentPacket->NextPacket() )
 
       
   300             || &aPacket == iCurrentPacket )
 
   300             {
 
   301             {
 
   301             OstTrace0( TRACE_DETAILED, CUSBPNISASENDER_TRYTOSENDPACKET, "CUsbPnIsaSender::TryToSendPacket - Send to ISA" );
 
   302             OstTrace0( TRACE_DETAILED, CUSBPNISASENDER_TRYTOSENDPACKET, "CUsbPnIsaSender::TryToSendPacket - Send to ISA" );
 
   302             E_TRACE( ( _T( "CUsbPnIsaSender::TryToSendPacket() - Send to ISA")));
 
   303             E_TRACE( ( _T( "CUsbPnIsaSender::TryToSendPacket() - Send to ISA")));
 
   303 
   304 
       
   305             
   304 #ifdef EXTENDED_TRACE_FLAG
 
   306 #ifdef EXTENDED_TRACE_FLAG
 
   305             TInt i(0);
 
   307 
   306             HBufC8& data(aPacket.Buffer());
 
   308 			HBufC8& data(aPacket.Buffer());
 
   307             while(i < data.Length() )
 
   309             TInt length( data.Length() );
 
       
   310             for( TInt i = 0; i < length; i++ )
 
   308                 {
 
   311                 {
 
   309                 OstTraceExt2( TRACE_DETAILED, CUSBPNISASENDER_TRYTOSENDPACKET_DUP1, "CUsbPnIsaSender::Send([%d] = %x )", i, data[i] );
 
   312                 OstTraceExt2( TRACE_DETAILED, CUSBPNISASENDER_TRYTOSENDPACKET_DUP1, "CUsbPnIsaSender::Send([%d] = %x )", i, data[i] );
 
   310                 E_TRACE( ( _T( "CUsbPnIsaSender::Send([%d] = %x )" ), i, data[i] ) );
 
   313                 E_TRACE( ( _T( "CUsbPnIsaSender::Send([%d] = %x )" ), i, data[i] ) );
 
   311                 i++;
 
   314                 i++;
 
   312                 }
 
   315                 }
FCL/sf/incubator/modemadaptation