author | mikaruus |
Tue, 19 Oct 2010 13:16:20 +0300 | |
changeset 9 | 8486d82aef45 |
parent 8 | 6295dc2169f3 |
permissions | -rw-r--r-- |
0 | 1 |
/* |
9 | 2 |
* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies). |
0 | 3 |
* All rights reserved. |
4 |
* This component and the accompanying materials are made available |
|
5 |
* under the terms of the License "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: |
|
15 |
* |
|
16 |
*/ |
|
17 |
||
18 |
||
19 |
||
20 |
#include <e32std.h> |
|
21 |
#include <iscapi.h> |
|
22 |
#include <iscnokiadefinitions.h> |
|
23 |
#include <pn_const.h> |
|
24 |
#include <nsisi.h> |
|
25 |
#include <pipeisi.h> |
|
26 |
#include <pipe_sharedisi.h> |
|
27 |
#include <tisi.h> |
|
28 |
#include <at_modemisi.h> |
|
29 |
#include "cmodemathandler.h" |
|
30 |
#include "cmodematpipecontroller.h" |
|
31 |
#include "modemattrace.h" |
|
32 |
#include "cmodematsrv.h" |
|
9 | 33 |
#include "OstTraceDefinitions.h" |
34 |
#ifdef OST_TRACE_COMPILER_IN_USE |
|
35 |
#include "cmodemathandlerTraces.h" |
|
36 |
#endif |
|
37 |
||
0 | 38 |
|
39 |
#define KCommandBits 0x0f |
|
40 |
#define KTransactionIdBitsShift 4 |
|
41 |
#define KFiller 0 |
|
42 |
#define KIndicationOrderMsgLength 14 |
|
43 |
#define KObjectIdLength 2 |
|
44 |
#define KEightBits 8 |
|
45 |
#define KDefaultTId 0 |
|
46 |
||
47 |
const TInt KUnsubscribeFourEvents(4); |
|
48 |
const TInt KAlignToFourBytes(4); |
|
9 | 49 |
const TInt KSessionIndLimit(1); // AT_MODEM_SIGNAL_IND is not handled if only one session is connected |
50 |
const TInt KEscapeDataLength(2); |
|
51 |
const TInt KFlowCtrlDataLength(3); |
|
52 |
const TUint8 KReservedDteId( 255 ); |
|
0 | 53 |
|
54 |
#ifdef __WINSCW__ |
|
55 |
#define KEmulatedReplyMsgLength 50 |
|
56 |
#endif |
|
57 |
||
9 | 58 |
CModemAtHandler* CModemAtHandler::NewL( |
59 |
CModemAtSrv& aServer, |
|
60 |
TInt aChannel ) |
|
0 | 61 |
{ |
9 | 62 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_NEWL, "CModemAtHandler::NewL" ); |
63 |
CModemAtHandler* self = new (ELeave) CModemAtHandler( aServer, aChannel ); |
|
0 | 64 |
CleanupStack::PushL( self ); |
65 |
self->ConstructL(); |
|
66 |
CleanupStack::Pop( self ); |
|
67 |
return self; |
|
68 |
} |
|
69 |
||
70 |
CModemAtHandler::~CModemAtHandler() |
|
71 |
{ |
|
9 | 72 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_CMODEMATHANDLER, "CModemAtHandler::~CModemAtHandler" ); |
0 | 73 |
C_TRACE(( _T("CModemAtHandler::~CModemAtHandler()") )); |
74 |
TBuf8<KUnsubscribeFourEvents> events; |
|
75 |
events.Append( KFiller ); |
|
76 |
events.Append( KFiller ); |
|
77 |
events.Append( KFiller ); |
|
78 |
events.Append( KFiller ); |
|
79 |
||
80 |
if( iIscApi ) |
|
81 |
{ |
|
82 |
iIscApi->CustomFunction( EIscNokiaEventSubscribe, &events ); |
|
83 |
} |
|
84 |
||
85 |
if(iPipeController) |
|
86 |
{ |
|
87 |
delete iPipeController; |
|
88 |
iPipeController = NULL; |
|
89 |
} |
|
90 |
Cancel(); |
|
91 |
||
92 |
if( iIscApi ) |
|
93 |
{ |
|
9 | 94 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_CMODEMATHANDLER, "CModemAtHandler::~CModemAtHandler - closing isc api" ); |
95 |
C_TRACE(( _T("CModemAtHandler::~CModemAtHandler() closing isc api") )); |
|
0 | 96 |
iIscApi->Close(); |
97 |
delete iIscApi; |
|
98 |
} |
|
99 |
} |
|
100 |
||
9 | 101 |
CModemAtHandler::CModemAtHandler( CModemAtSrv& aServer, TInt aChannel ) |
0 | 102 |
: CActive( EPriorityHigh ), |
103 |
iServer( aServer ), |
|
104 |
iIscApi( NULL ), |
|
105 |
iReceivedMessageBuffer( NULL ), |
|
106 |
iMessageBufferSize( KMaxBufferLength ), |
|
107 |
iReceivePtr( 0, 0 ), |
|
108 |
iReceiveMessageLength( 0 ), |
|
109 |
iReceivedMessage( NULL ), |
|
110 |
iPepObjId(0), |
|
9 | 111 |
iDataportObjId(0), |
0 | 112 |
iPipeController(NULL), |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
113 |
iLastTransactionId( 0 ), |
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
114 |
iDisconnected( EFalse ), |
9 | 115 |
iModemAtExistInCmt( EFalse ), |
116 |
iTextMessageMode( EFalse ), |
|
117 |
iChannel( aChannel ) |
|
0 | 118 |
{ |
9 | 119 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_CMODEMATHANDLER, "CModemAtHandler::CModemAtHandler" ); |
0 | 120 |
C_TRACE (( _T("CModemAtHandler::CModemAtHandler") )); |
121 |
} |
|
122 |
||
123 |
void CModemAtHandler::DoCancel() |
|
124 |
{ |
|
9 | 125 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_DOCANCEL, "CModemAtHandler::DoCancel" ); |
0 | 126 |
C_TRACE (( _T("CModemAtHandler::DoCancel()") )); |
127 |
iIscApi->ReceiveCancel(); |
|
128 |
} |
|
129 |
||
130 |
||
131 |
void CModemAtHandler::RunL() |
|
132 |
{ |
|
9 | 133 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL" ); |
134 |
C_TRACE (( _T("CModemAtHandler::RunL() %d"), iDteId )); |
|
0 | 135 |
|
136 |
if( iStatus == KErrNone ) |
|
137 |
{ |
|
138 |
TIsiReceiveC receiveMessage = TIsiReceiveC( *iReceivedMessageBuffer ); |
|
9 | 139 |
OstTraceExt1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - message dump;iReceivePtr=%s", iReceivePtr ); |
0 | 140 |
DUMP_MESSAGE( iReceivePtr ); |
141 |
||
142 |
if( iReceivedMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID ) |
|
143 |
{ |
|
144 |
switch(receiveMessage.Get8bit(ISI_HEADER_OFFSET_RESOURCEID)) |
|
145 |
{ |
|
146 |
case PN_AT_MODEM: //AT MODEM COMMANDS |
|
9 | 147 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - PN_AT_MODEM" ); |
0 | 148 |
C_TRACE(_L("PN_AT_MODEM")); |
149 |
||
150 |
switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) ) |
|
151 |
{ |
|
152 |
case AT_MODEM_CONNECT_RESP: |
|
153 |
HandleModemConnectResp( receiveMessage ); |
|
154 |
break; |
|
155 |
||
156 |
case AT_MODEM_DISCONNECT_RESP: |
|
9 | 157 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_DISCONNECT_RESP" ); |
0 | 158 |
C_TRACE(_L("AT_MODEM_DISCONNECT_RESP")); |
159 |
break; |
|
160 |
||
161 |
case AT_MODEM_CMD_RESP: |
|
162 |
HandleATResponse( receiveMessage ); |
|
163 |
break; |
|
164 |
||
165 |
case AT_MODEM_SIGNAL_IND: |
|
166 |
HandleSignalInd( receiveMessage ); |
|
167 |
break; |
|
168 |
||
169 |
case AT_MODEM_UNSOLICITED_DATA_IND: |
|
9 | 170 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_UNSOLICITED_DATA_IND" ); |
171 |
C_TRACE(_L("AT_MODEM_UNSOLICITED_DATA_IND")); |
|
0 | 172 |
HandleUnsolicitedData( receiveMessage ); |
173 |
break; |
|
174 |
||
175 |
case AT_MODEM_INTERMEDIATE_DATA_IND: |
|
176 |
HandleIntermediateDataInd( receiveMessage ); |
|
177 |
break; |
|
178 |
||
179 |
case AT_MODEM_DATA_REDIRECT_IND: |
|
180 |
HandleRedirectInd( receiveMessage ); |
|
181 |
break; |
|
182 |
||
183 |
case AT_MODEM_DATA_REDIRECT_RESULT_RESP: |
|
9 | 184 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_DATA_REDIRECT_RESULT_RESP" ); |
0 | 185 |
C_TRACE((_L("AT_MODEM_DATA_REDIRECT_RESULT_RESP"))); |
186 |
HandleRedirectResultResp( receiveMessage ); |
|
187 |
break; |
|
188 |
||
189 |
case AT_MODEM_SIGNAL_DETECTED_RESP: |
|
9 | 190 |
OstTrace0( TRACE_NORMAL, DUP6_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_SIGNAL_DETECTED_RESP" ); |
0 | 191 |
C_TRACE((_L("AT_MODEM_SIGNAL_DETECTED_RESP"))); |
192 |
HandleSignalDetectedResp( receiveMessage ); |
|
193 |
break; |
|
194 |
default: |
|
9 | 195 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - Not a valid message" ); |
0 | 196 |
C_TRACE(_L("CModemAtHandler::RunL: Not a valid message")) ; |
197 |
TRACE_ASSERT_ALWAYS; |
|
198 |
break; |
|
199 |
} //switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) ) |
|
200 |
||
201 |
break; //case PN_AT_MODEM: //AT MODEM COMMANDS |
|
202 |
||
9 | 203 |
case PN_NAMESERVICE: |
204 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - PN_NAMESERVICE" ); |
|
205 |
C_TRACE(_L("PN_NAMESERVICE")); |
|
206 |
iPipeController->HandleNameServiceMessage( receiveMessage ); |
|
0 | 207 |
break; |
208 |
||
209 |
case PN_PIPE: |
|
9 | 210 |
OstTrace0( TRACE_NORMAL, DUP9_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - PN_PIPE" ); |
211 |
C_TRACE(_L("PN_PIPE")); |
|
212 |
iPipeController->HandlePipeServiceMessage( receiveMessage ); |
|
0 | 213 |
break; |
214 |
default: |
|
9 | 215 |
OstTrace0( TRACE_NORMAL, DUP10_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - Unknown resource id" ); |
0 | 216 |
C_TRACE((_L("Unknown resource id"))); |
217 |
TRACE_ASSERT_ALWAYS; |
|
218 |
break; |
|
219 |
} |
|
9 | 220 |
|
0 | 221 |
} //if( receiveMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID ) |
222 |
else |
|
223 |
{ |
|
9 | 224 |
OstTrace0( TRACE_NORMAL, DUP11_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - ISI message is too short" ); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
225 |
C_TRACE(_L("ISI message is too short")); |
0 | 226 |
TRACE_ASSERT_ALWAYS; |
227 |
} |
|
228 |
||
229 |
//Start receiving ISI messages again |
|
230 |
iReceivePtr.Set( iReceivedMessageBuffer->Des() ); |
|
231 |
iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength ); |
|
232 |
SetActive(); |
|
233 |
} // if( iStatus == KErrNone ) |
|
234 |
else |
|
235 |
{ |
|
236 |
TRACE_ASSERT_ALWAYS; |
|
237 |
} |
|
238 |
} |
|
239 |
||
240 |
||
241 |
void CModemAtHandler::ConstructL() |
|
242 |
{ |
|
9 | 243 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_CONSTRUCTL, "CModemAtHandler::ConstructL" ); |
0 | 244 |
C_TRACE (( _T("CModemAtHandler::ConstructL()") )); |
245 |
||
246 |
CActiveScheduler::Add( this ); |
|
247 |
||
248 |
iIscApi = new ( ELeave ) RIscApi; |
|
9 | 249 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_CONSTRUCTL, "CModemAtHandler::ConstructL - RIscApi created" ); |
0 | 250 |
C_TRACE(_L("RIscApi created")); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
251 |
|
0 | 252 |
#ifndef __WINSCW__ |
253 |
OpenChannelL(); |
|
9 | 254 |
if( iChannel == EIscNokiaAtController ) |
255 |
{ |
|
256 |
iPipeController->QueryModemAtFromNameService(); |
|
257 |
} |
|
258 |
else |
|
259 |
{ |
|
260 |
SetModemAtExistsInCmt( ETrue ); |
|
261 |
} |
|
0 | 262 |
#else |
263 |
iEmulatedValue = 0; |
|
264 |
#endif |
|
265 |
||
266 |
} |
|
267 |
||
9 | 268 |
TInt CModemAtHandler::SendATCommand( |
0 | 269 |
const TATPluginInterface aPluginType, |
270 |
const TUint8 aMessageType, |
|
271 |
const TDesC8& aCmd) |
|
272 |
{ |
|
9 | 273 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand;iDteId=%d", iDteId ); |
274 |
C_TRACE (( _T(">>CModemAtHandler::SendATCommand() %d"), iDteId )); |
|
0 | 275 |
|
276 |
TInt err = KErrNone; |
|
277 |
// aMessageType contains normal AT-cmd (0) or Nvram-query (1) |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
278 |
TUint transactionId = ( aPluginType << KTransactionIdBitsShift ) | aMessageType; |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
279 |
// used with intermediate data ind |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
280 |
// can be removed, when AT_MODEM_INTERMEDIATE_DATA_IND supports transactionid |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
281 |
iLastTransactionId = transactionId; //messages are routed to correct plugin by transaction id |
9 | 282 |
OstTraceExt4( TRACE_NORMAL, DUP1_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand;transactionId=%d;aPluginType=%d;aMessageType=%d;iLastTransactionId=%d", transactionId, aPluginType, aMessageType, iLastTransactionId ); |
0 | 283 |
C_TRACE((_L("transaction id %d, plugintype %d, aMessageType %d"), transactionId, aPluginType, aMessageType)); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
284 |
C_TRACE((_L("iLastTransctionId = %d "), iLastTransactionId )); |
0 | 285 |
|
286 |
TInt size = ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + aCmd.Length(); |
|
287 |
||
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
288 |
TInt sizeWithFillers = size; |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
289 |
while( sizeWithFillers % KAlignToFourBytes ) |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
290 |
{ |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
291 |
sizeWithFillers++; |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
292 |
} |
9 | 293 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - Message length;sizeWithFillers=%d", sizeWithFillers ); |
0 | 294 |
C_TRACE((_L("Message length %d"), sizeWithFillers)); |
295 |
||
296 |
HBufC8* message = HBufC8::New( sizeWithFillers ); |
|
297 |
if( message ) |
|
298 |
{ |
|
299 |
TPtr8 messageptr = message->Des(); |
|
300 |
TIsiSend isimessage( messageptr, sizeWithFillers ); |
|
301 |
isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM ); |
|
302 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_TID, transactionId ); |
|
303 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_MESSAGEID, AT_MODEM_CMD_REQ ); |
|
9 | 304 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_DTEID, iDteId ); |
0 | 305 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_FILLERBYTE1, 0 ); |
9 | 306 |
OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - AT command length:;aCmd.Length()=%d", aCmd.Length() ); |
0 | 307 |
C_TRACE((_L("AT command length: %d"), aCmd.Length())); |
308 |
isimessage.Set16bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_LENGTH, (TUint16) aCmd.Length() ); |
|
309 |
||
310 |
const TUint8* ptr = aCmd.Ptr(); |
|
311 |
for ( TInt i = 0; i < aCmd.Length(); i++ ) |
|
312 |
{ |
|
9 | 313 |
OstTraceExt3( TRACE_NORMAL, DUP4_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - message;i=%d;ptr[i]=%x;charptr[i]=%c", i, ptr[i], ptr[i] ); |
0 | 314 |
C_TRACE((_L("message %d, 0x%x '%c'"), i, ptr[i], ptr[i])); |
315 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + i, ptr[i]); |
|
316 |
} |
|
317 |
||
318 |
for( TInt j = sizeWithFillers; j < size; j++ ) |
|
319 |
{ |
|
9 | 320 |
OstTrace1( TRACE_NORMAL, DUP5_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - Add filler;j=%d", j ); |
0 | 321 |
C_TRACE((_L("Add filler [%d]"), j)); |
322 |
isimessage.Set8bit( j , KFiller ); |
|
323 |
} |
|
324 |
||
325 |
isimessage.Complete(); |
|
9 | 326 |
OstTraceExt1( TRACE_NORMAL, DUP6_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - Created ISI-message;messageptr=%s", messageptr ); |
0 | 327 |
C_TRACE(_L("Created ISI-message")); |
328 |
DUMP_MESSAGE( messageptr ); |
|
329 |
||
330 |
err = iIscApi->Send( messageptr ); |
|
331 |
TRACE_ASSERT( err == KErrNone ); |
|
332 |
delete message; |
|
333 |
message = NULL; |
|
334 |
} |
|
335 |
else |
|
336 |
{ |
|
9 | 337 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - No memory - error in sending ISI message from heap" ); |
0 | 338 |
C_TRACE(_L("No memory - error in sending ISI message from heap")); |
339 |
TRACE_ASSERT_ALWAYS; |
|
340 |
} |
|
9 | 341 |
|
342 |
OstTrace1( TRACE_NORMAL, DUP8_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand;err=%d", err ); |
|
0 | 343 |
C_TRACE (( _T("<<CModemAtHandler::SendATCommand() err: %d"), err )); |
344 |
return err; |
|
345 |
} |
|
346 |
||
347 |
void CModemAtHandler::OpenChannelL() |
|
348 |
{ |
|
9 | 349 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL" ); |
0 | 350 |
C_TRACE (( _T("CModemAtHandler::OpenChannelL()") )); |
351 |
TRequestStatus openStatus; |
|
352 |
||
9 | 353 |
iIscApi->Open( iChannel, openStatus, EOwnerThread ); |
0 | 354 |
User::WaitForRequest( openStatus ); |
355 |
||
356 |
TRACE_ASSERT( !openStatus.Int()); |
|
357 |
||
358 |
if( iReceivedMessageBuffer ) |
|
359 |
{ |
|
360 |
delete iReceivedMessageBuffer; |
|
361 |
iReceivedMessageBuffer = NULL; |
|
362 |
} |
|
363 |
||
364 |
iReceivedMessageBuffer = HBufC8::NewL(iMessageBufferSize); |
|
365 |
TRACE_ASSERT(iReceivedMessageBuffer); |
|
366 |
iReceivePtr.Set( iReceivedMessageBuffer->Des() ); |
|
367 |
||
9 | 368 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - Start receive ISI messages" ); |
0 | 369 |
C_TRACE(_L("Start receive ISI messages")); |
370 |
iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength ); |
|
371 |
||
372 |
SetActive(); |
|
373 |
||
9 | 374 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - Start receive indications" ); |
0 | 375 |
C_TRACE(_L("Start receive indications")); |
376 |
TBuf8<KIndicationOrderMsgLength> events; |
|
377 |
events.Append( PN_AT_MODEM ); |
|
378 |
events.Append( AT_MODEM_INTERMEDIATE_DATA_IND ); |
|
379 |
events.Append( PN_AT_MODEM ); |
|
380 |
events.Append( AT_MODEM_SIGNAL_IND ); |
|
381 |
events.Append( PN_AT_MODEM ); |
|
382 |
events.Append( AT_MODEM_UNSOLICITED_DATA_IND ); |
|
383 |
events.Append( PN_AT_MODEM ); |
|
384 |
events.Append( AT_MODEM_DATA_REDIRECT_IND ); |
|
385 |
||
9 | 386 |
#ifndef PIPECAMP_UNSUBSCRIBE_PNS_PEP_STATUS_IND |
387 |
events.Append( PN_PIPE ); |
|
388 |
events.Append( PNS_PEP_STATUS_IND ); |
|
389 |
#endif |
|
0 | 390 |
//name add ind |
391 |
events.Append( PN_NAMESERVICE ); |
|
392 |
events.Append( PNS_NAME_ADD_IND ); |
|
393 |
events.Append( PN_NAMESERVICE ); |
|
394 |
events.Append( PNS_NAME_REMOVE_IND ); |
|
395 |
||
9 | 396 |
iIscApi->CustomFunction( EIscNokiaEventSubscribe, &events ); |
0 | 397 |
TBuf8<KObjectIdLength> objId; |
9 | 398 |
iIscApi->GetChannelInfo( iChannel, objId ); |
399 |
||
0 | 400 |
iPepObjId = (((TUint16)(objId[0]))<<KEightBits) + objId[1]; |
9 | 401 |
OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL;iPepObjId=%x", iPepObjId ); |
0 | 402 |
C_TRACE((_L("PepObjId 0x%x"),iPepObjId)); |
403 |
iPipeController = CModemAtPipeController::NewL(*iIscApi, iPepObjId, *this); |
|
9 | 404 |
OstTraceExt1( TRACE_NORMAL, DUP4_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL;iPipeController=%p", iPipeController ); |
0 | 405 |
C_TRACE((_L("iPipeController 0x%x"),iPipeController )); |
406 |
ASSERT_PANIC_ALWAYS( iPipeController ); |
|
9 | 407 |
|
408 |
TBuf8<KObjectIdLength> dpObjId; |
|
409 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - GetChannelInfo(EIscNokiaDataport2)" ); |
|
410 |
C_TRACE(( _T("GetChannelInfo() EIscNokiaDataport2") )); |
|
411 |
iIscApi->GetChannelInfo( EIscNokiaDataport2, dpObjId ); |
|
412 |
||
413 |
OstTrace0( TRACE_NORMAL, DUP6_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - GetChannelInfo() done" ); |
|
414 |
C_TRACE(( _T("GetChannelInfo() done") )); |
|
415 |
iDataportObjId = (((TUint16)(dpObjId[0])) << KEightBits) + dpObjId[1]; |
|
416 |
OstTrace1( TRACE_NORMAL, DUP7_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL;iDataportObjId=%x", iDataportObjId ); |
|
417 |
C_TRACE((_L("DataportObjId 0x%x"), iDataportObjId)); |
|
0 | 418 |
} |
419 |
||
420 |
||
421 |
void CModemAtHandler::HandleATResponse( const TIsiReceiveC& aMessage ) |
|
422 |
{ |
|
9 | 423 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse" ); |
0 | 424 |
C_TRACE (( _T("CModemAtHandler::HandleATResponse()") )); |
425 |
||
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
426 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_DTEID ) ; |
0 | 427 |
TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID ); |
428 |
TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query |
|
9 | 429 |
TInt length = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_LENGTH ); |
430 |
OstTraceExt3( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse;dteId=%d;AT (0) or nvram command (1):;command=%d;Response length;length=%d", dteId, command, length ); |
|
0 | 431 |
C_TRACE(( _L("DteId: %d AT (0) or nvram command (1): %d Response length %d"), dteId, command, length )); |
432 |
||
433 |
/** |
|
434 |
* Plugintype can be read from transaction id: |
|
435 |
* TUint8 pluginType = transactionId >> KTransactionIdBitsShift; |
|
436 |
* (TATPluginInterface) pluginType |
|
437 |
* |
|
438 |
* Current implementation uses first in first out response completion |
|
439 |
* so plugintype is not needed. |
|
440 |
*/ |
|
9 | 441 |
OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse - ;Plugintype=%d", transactionId >> KTransactionIdBitsShift ); |
0 | 442 |
C_TRACE(( _L("Plugintype: %d"), transactionId >> KTransactionIdBitsShift )); |
443 |
||
9 | 444 |
iServer.HandleATResponse( |
445 |
dteId, |
|
446 |
this, |
|
0 | 447 |
aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_CMDLINEBUFFER, length), |
448 |
command ); |
|
449 |
} |
|
450 |
||
451 |
#ifdef __WINSCW__ |
|
452 |
void CModemAtHandler::HandleATResponse( ) |
|
453 |
{ |
|
9 | 454 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse;iDteId=%d", iDteId ); |
455 |
C_TRACE (( _T("CModemAtHandler::HandleATResponse() %d"), iDteId )); |
|
0 | 456 |
//reply back immediately |
457 |
const TInt KReplyLength(50); |
|
458 |
TBuf8<KReplyLength> replyEmulated = _L8("\r\nAT TEST REPLY"); |
|
459 |
replyEmulated.AppendNum(iEmulatedValue++); |
|
460 |
replyEmulated.Append(_L8("\r\n")); |
|
9 | 461 |
iServer.HandleATResponse( iDteId, this, replyEmulated, 0 /* 0 = AT-cmd, 1 = nvram */); |
0 | 462 |
} |
463 |
#endif |
|
464 |
||
465 |
||
9 | 466 |
TInt CModemAtHandler::Connect( TUint8 aDevId, TUint8 aObjId ) |
0 | 467 |
{ |
9 | 468 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_CONNECT, "CModemAtHandler::Connect;aDevId=%hhx;aObjId=%hhx", aDevId, aObjId ); |
469 |
C_TRACE (( _T("CModemAtHandler::Connect() dev id: 0x%x, obj id: 0x%x"), aDevId, aObjId )); |
|
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
470 |
|
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
471 |
if( !iModemAtExistInCmt ) |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
472 |
{ |
9 | 473 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_CONNECT, "CModemAtHandler::Connect - Connection failed, PN_AT_MODEM is not in CMT" ); |
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
474 |
C_TRACE((_T("Connection failed, PN_AT_MODEM is not in CMT"))); |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
475 |
TRACE_ASSERT_ALWAYS; |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
476 |
return KErrNotFound; |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
477 |
} |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
478 |
SetDisconnected( EFalse ); |
0 | 479 |
|
9 | 480 |
iPipeController->SendCreatePipeMessage( aDevId, aObjId ); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
481 |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
482 |
return KErrNone; |
0 | 483 |
} |
484 |
||
485 |
void CModemAtHandler::SetDisconnected( TBool aIsDisconnected ) |
|
486 |
{ |
|
9 | 487 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SETDISCONNECTED, "CModemAtHandler::SetDisconnected;aIsDisconnected=%d", aIsDisconnected ); |
0 | 488 |
C_TRACE (( _T("CModemAtHandler::SetDisconnected(%d)"),aIsDisconnected )); |
489 |
iDisconnected = aIsDisconnected; |
|
490 |
} |
|
491 |
||
492 |
TBool CModemAtHandler::IsDisconnected() |
|
493 |
{ |
|
9 | 494 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_ISDISCONNECTED, "CModemAtHandler::IsDisconnected;iDisconnected=%d", iDisconnected ); |
0 | 495 |
C_TRACE (( _T("CModemAtHandler::IsDisconnected(%d)"),iDisconnected )); |
496 |
return iDisconnected; |
|
497 |
} |
|
498 |
||
499 |
TBool CModemAtHandler::IsPluginConnected() |
|
500 |
{ |
|
9 | 501 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_ISPLUGINCONNECTED, "CModemAtHandler::IsPluginConnected;iServer.SessionCount()=%d", iServer.SessionCount() ); |
0 | 502 |
C_TRACE (( _T("CModemAtHandler::IsPluginConnected() sessions: %d"), iServer.SessionCount() )); |
503 |
return iServer.SessionCount() > 0; |
|
504 |
} |
|
505 |
||
9 | 506 |
void CModemAtHandler::RemovePipe() |
0 | 507 |
{ |
9 | 508 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_REMOVEPIPE, "CModemAtHandler::RemovePipe;iDteId=%d", iDteId ); |
509 |
C_TRACE(( _T("CModemAtHandler::RemovePipe() %d"), iDteId )); |
|
0 | 510 |
iDisconnected = ETrue; |
9 | 511 |
iPipeController->RemovePipe(); |
0 | 512 |
} |
513 |
||
9 | 514 |
TInt CModemAtHandler::Disconnect() |
0 | 515 |
{ |
9 | 516 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_DISCONNECT, "CModemAtHandler::Disconnect;iDteId=%d", iDteId ); |
517 |
C_TRACE (( _T("CModemAtHandler::Disconnect(%d)"),iDteId )); |
|
0 | 518 |
|
519 |
TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_DISCONNECT_REQ; |
|
520 |
HBufC8* message = HBufC8::New( size ); |
|
521 |
TRACE_ASSERT( message ); |
|
522 |
TPtr8 messageptr = message->Des(); |
|
523 |
TIsiSend isimessage( messageptr, size ); |
|
524 |
isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID,PN_AT_MODEM); |
|
525 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_TID, 0); |
|
526 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_MESSAGEID, |
|
527 |
AT_MODEM_DISCONNECT_REQ); |
|
9 | 528 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_DTEID, iDteId); |
0 | 529 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_FILLERBYTE1, KFiller); |
530 |
isimessage.Complete(); |
|
531 |
||
9 | 532 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_DISCONNECT, "CModemAtHandler::Disconnect - Sending AT_MODEM_DISCONNECT_REQ" ); |
0 | 533 |
C_TRACE (( _T("CModemAtHandler::Disconnect Sending AT_MODEM_DISCONNECT_REQ"))); |
534 |
TInt err = iIscApi->Send(messageptr); |
|
535 |
TRACE_ASSERT( err == KErrNone ); |
|
536 |
delete message; |
|
537 |
return err; |
|
538 |
} |
|
539 |
||
540 |
||
541 |
||
542 |
void CModemAtHandler::HandleModemConnectResp( const TIsiReceiveC& aMessage ) |
|
543 |
{ |
|
9 | 544 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEMODEMCONNECTRESP, "CModemAtHandler::HandleModemConnectResp;iDteId=%d", iDteId ); |
545 |
C_TRACE (( _T("CModemAtHandler::HandleModemConnectResp() %d"), iDteId )); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
546 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CONNECT_RESP_OFFSET_DTEID ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
547 |
TInt status = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CONNECT_RESP_OFFSET_RESULT ); |
0 | 548 |
TInt err = KErrGeneral; |
549 |
if( status == AT_MODEM_RESULT_OK ) |
|
550 |
{ |
|
9 | 551 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEMODEMCONNECTRESP, "CModemAtHandler::HandleModemConnectResp - Connected ok, AT_MODEM_RESULT_OK received" ); |
0 | 552 |
C_TRACE(_L("Connected ok, AT_MODEM_RESULT_OK received")); |
553 |
err = KErrNone; |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
554 |
} |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
555 |
else |
0 | 556 |
{ |
9 | 557 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEMODEMCONNECTRESP, "CModemAtHandler::HandleModemConnectResp - Connection failed, AT_MODEM_RESULT_ERROR received;status=%d", status ); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
558 |
C_TRACE((_L("Connection failed, AT_MODEM_RESULT_ERROR received (%d)"), status)); |
0 | 559 |
} |
560 |
||
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
561 |
iServer.SetDteIdAndConnect( dteId, err ); |
0 | 562 |
} |
563 |
||
564 |
||
565 |
void CModemAtHandler::HandleSignalInd( const TIsiReceiveC& aMessage ) |
|
566 |
{ |
|
9 | 567 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;iDteId=%d", iDteId ); |
568 |
C_TRACE (( _T("CModemAtHandler::HandleSignalInd() (%d)"), iDteId )); |
|
569 |
||
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
570 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_IND_OFFSET_DTEID ); |
9 | 571 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;dteId=%x", dteId ); |
572 |
C_TRACE(( _L("dteId: 0x%x"), dteId )); |
|
573 |
||
574 |
if( iDteId != dteId ) |
|
575 |
{ |
|
576 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND is ignored because of it's received from diffrent dte." ); |
|
577 |
C_TRACE (( _T("AT_MODEM_SIGNAL_IND is ignored because of it's received from diffrent dte.") )); |
|
578 |
return; |
|
579 |
} |
|
580 |
||
581 |
if( IsTextMessageMode() ) |
|
582 |
{ |
|
583 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND is ignored during text message mode." ); |
|
584 |
C_TRACE (( _T("AT_MODEM_SIGNAL_IND is ignored during text message mode.") )); |
|
585 |
return; |
|
586 |
} |
|
587 |
||
588 |
// Go through indications. Note that common plugin handles only these: |
|
589 |
// echo, verbose, quiet, escape char, linefeed char and backspace char. |
|
590 |
||
591 |
||
592 |
||
593 |
TUint8 count = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_IND_OFFSET_NOOFSUBBLOCKS ); |
|
594 |
OstTrace1( TRACE_NORMAL, DUP4_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - subblock;count=%d", count ); |
|
595 |
C_TRACE(( _L("subblock count: 0x%x"), count )); |
|
596 |
if( count > 0 ) |
|
597 |
{ |
|
598 |
TInt length( ISI_HEADER_SIZE + SIZE_AT_MODEM_SIGNAL_IND ); |
|
599 |
TUint8 messageId( 0 ); |
|
600 |
TUint8 echoValue( KInitialValue ); |
|
601 |
TUint8 escapeChar( KInitialValue ); |
|
602 |
TUint8 flowControlOutward( AT_MODEM_FLOW_CONTROL_SW ); |
|
603 |
TUint8 flowControlInward( AT_MODEM_FLOW_CONTROL_SW ); |
|
604 |
TUint8 flowControlExtract( AT_MODEM_WITH_EXTRACT ); |
|
605 |
TUint8 dcdValue( AT_MODEM_DCD_OFF ); |
|
606 |
TUint8 dsrValue( AT_MODEM_DSR_OFF ); |
|
607 |
for( TInt i = 0; i < count; i++ ) |
|
608 |
{ |
|
609 |
messageId = aMessage.Get8bit( length ); |
|
610 |
OstTrace1( TRACE_NORMAL, DUP5_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;messageId=%x", messageId ); |
|
611 |
C_TRACE((_L("messageId: 0x%x"), messageId)); |
|
612 |
||
613 |
switch( messageId ) |
|
614 |
{ |
|
615 |
case AT_MODEM_SB_ECHO_VALUE: |
|
616 |
{ |
|
617 |
echoValue = aMessage.Get8bit( length + |
|
618 |
AT_MODEM_SB_ECHO_VALUE_OFFSET_ECHOVALUE ); |
|
619 |
OstTrace1( TRACE_NORMAL, DUP6_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;echoValue=%x", echoValue ); |
|
620 |
C_TRACE(( _L("echo value: 0x%x"), echoValue)); |
|
621 |
length += SIZE_AT_MODEM_SB_ECHO_VALUE; |
|
622 |
break; |
|
623 |
} |
|
624 |
case AT_MODEM_SB_DTE_PARAMS: |
|
625 |
{ |
|
626 |
length += SIZE_AT_MODEM_SB_DTE_PARAMS; |
|
627 |
break; |
|
628 |
} |
|
629 |
case AT_MODEM_SB_FLOW_CTRL: |
|
630 |
{ |
|
631 |
flowControlOutward = aMessage.Get8bit( length + |
|
632 |
AT_MODEM_SB_FLOW_CTRL_OFFSET_FLOWCTRLOUTWARDDCE ); |
|
633 |
C_TRACE(( _L("Flow control outward used by DCE towards DTE: 0x%x"), flowControlOutward )); |
|
634 |
||
635 |
flowControlInward = aMessage.Get8bit( length + |
|
636 |
AT_MODEM_SB_FLOW_CTRL_OFFSET_FLOWCTRLINWARDDTE ); |
|
637 |
C_TRACE(( _L("Flow control inward from DTE: 0x%x"), flowControlInward )); |
|
638 |
||
639 |
flowControlExtract = aMessage.Get8bit( length + |
|
640 |
AT_MODEM_SB_FLOW_CTRL_OFFSET_EXTRACT ); |
|
641 |
C_TRACE(( _L("extract: 0x%x"), flowControlExtract )); |
|
642 |
||
643 |
TBuf8<KFlowCtrlDataLength> data; |
|
644 |
switch( flowControlOutward ) |
|
645 |
{ |
|
646 |
case AT_MODEM_FLOW_CONTROL_SW: |
|
647 |
data.Append( PEP_COMM_FLOW_CTRL_SW ); |
|
648 |
break; |
|
649 |
case AT_MODEM_FLOW_CONTROL_NONE: |
|
650 |
data.Append( PEP_COMM_FLOW_CTRL_NONE ); |
|
651 |
break; |
|
652 |
case AT_MODEM_FLOW_CONTROL_HW: |
|
653 |
data.Append( PEP_COMM_FLOW_CTRL_HW ); |
|
654 |
break; |
|
655 |
default: |
|
656 |
data.Append( PEP_COMM_FLOW_CTRL_SW ); |
|
657 |
break; |
|
658 |
} |
|
659 |
switch( flowControlInward ) |
|
660 |
{ |
|
661 |
case AT_MODEM_FLOW_CONTROL_SW: |
|
662 |
data.Append( PEP_COMM_FLOW_CTRL_SW ); |
|
663 |
break; |
|
664 |
case AT_MODEM_FLOW_CONTROL_NONE: |
|
665 |
data.Append( PEP_COMM_FLOW_CTRL_NONE ); |
|
666 |
break; |
|
667 |
case AT_MODEM_FLOW_CONTROL_HW: |
|
668 |
data.Append( PEP_COMM_FLOW_CTRL_HW ); |
|
669 |
break; |
|
670 |
default: |
|
671 |
data.Append( PEP_COMM_FLOW_CTRL_SW ); |
|
672 |
break; |
|
673 |
} |
|
674 |
switch( flowControlExtract ) |
|
675 |
{ |
|
676 |
case AT_MODEM_NO_EXTRACT: |
|
677 |
data.Append( PEP_COMM_FLOW_CTRL_NO_EXTRACT ); |
|
678 |
break; |
|
679 |
case AT_MODEM_WITH_EXTRACT: |
|
680 |
data.Append( PEP_COMM_FLOW_CTRL_EXTRACT ); |
|
681 |
break; |
|
682 |
default: |
|
683 |
data.Append( PEP_COMM_FLOW_CTRL_EXTRACT ); |
|
684 |
break; |
|
685 |
} |
|
686 |
||
687 |
TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState(); |
|
688 |
if( pipeState != TPipeInfo::EPipeNoPipe && |
|
689 |
pipeState != TPipeInfo::EPipeRemoving ) |
|
690 |
{ |
|
691 |
iPipeController->SendPepCtrlReq( PEP_COMM_CTRL_ID_FLOW_CTRL, data ); |
|
692 |
} |
|
693 |
length += SIZE_AT_MODEM_SB_FLOW_CTRL; |
|
694 |
break; |
|
695 |
} |
|
696 |
case AT_MODEM_SB_ESCAPE_PARAMS: |
|
697 |
{ |
|
698 |
escapeChar = aMessage.Get8bit( length + |
|
699 |
AT_MODEM_SB_ESCAPE_PARAMS_OFFSET_ESCAPECHAR ); |
|
700 |
OstTrace1( TRACE_NORMAL, DUP7_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;escapeChar=%x", escapeChar ); |
|
701 |
C_TRACE(( _L("escape character: 0x%x"), escapeChar )); |
|
702 |
length += SIZE_AT_MODEM_SB_ESCAPE_PARAMS; |
|
703 |
break; |
|
704 |
} |
|
705 |
case AT_MODEM_SB_AUTOBAUD: |
|
706 |
{ |
|
707 |
length += SIZE_AT_MODEM_SB_AUTOBAUD; |
|
708 |
break; |
|
709 |
} |
|
710 |
case AT_MODEM_SB_DTE_SIGNALS: |
|
711 |
{ |
|
712 |
dcdValue = aMessage.Get8bit( length + |
|
713 |
AT_MODEM_SB_DTE_SIGNALS_OFFSET_DCDSIGNAL ); |
|
714 |
OstTrace1( TRACE_NORMAL, DUP8_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;dcdValue=%x", dcdValue ); |
|
715 |
C_TRACE(( _L("DCD value: 0x%x"), dcdValue)); |
|
716 |
||
717 |
dsrValue = aMessage.Get8bit( length + |
|
718 |
AT_MODEM_SB_DTE_SIGNALS_OFFSET_DSRSIGNAL ); |
|
719 |
OstTrace1( TRACE_NORMAL, DUP9_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;dsrValue=%x", dsrValue ); |
|
720 |
C_TRACE(( _L("DSR value: 0x%x"), dsrValue)); |
|
721 |
TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState(); |
|
722 |
if( pipeState != TPipeInfo::EPipeNoPipe && |
|
723 |
pipeState != TPipeInfo::EPipeRemoving ) |
|
724 |
{ |
|
725 |
if( AT_MODEM_DCD_OFF == dcdValue ) |
|
726 |
{ |
|
727 |
iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DCD_OFF ); |
|
728 |
} |
|
729 |
else if( AT_MODEM_DCD_ON == dcdValue ) |
|
730 |
{ |
|
731 |
iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DCD_ON ); |
|
732 |
} |
|
733 |
||
734 |
if( AT_MODEM_DSR_OFF == dsrValue ) |
|
735 |
{ |
|
736 |
iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DSR_OFF ); |
|
737 |
} |
|
738 |
else if( AT_MODEM_DSR_ON == dsrValue ) |
|
739 |
{ |
|
740 |
iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DSR_ON ); |
|
741 |
} |
|
742 |
} |
|
743 |
length += SIZE_AT_MODEM_SB_DTE_SIGNALS; |
|
744 |
break; |
|
745 |
} |
|
746 |
default: |
|
747 |
{ |
|
748 |
TRACE_ASSERT_ALWAYS; |
|
749 |
break; |
|
750 |
} |
|
751 |
} |
|
752 |
} |
|
753 |
||
754 |
if( escapeChar != KInitialValue ) |
|
755 |
{ |
|
756 |
OstTrace0( TRACE_NORMAL, DUP10_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - Escape char received, it will be sent to dataport." ); |
|
757 |
C_TRACE(( _T("Escape char received, it will be sent to dataport.") )); |
|
758 |
||
759 |
// Dataport should have the pipehandle and escape character. It defaults to handle 0xff and escape char '+'. |
|
760 |
TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState(); |
|
761 |
if( pipeState != TPipeInfo::EPipeNoPipe && |
|
762 |
pipeState != TPipeInfo::EPipeRemoving ) |
|
763 |
{ |
|
764 |
TBuf8<KEscapeDataLength> data; |
|
765 |
data.Append( escapeChar ); |
|
766 |
data.Append( KEscapeTime ); |
|
767 |
iPipeController->SendPepCtrlReq( PEP_COMM_CTRL_ID_ESCAPE, data ); |
|
768 |
} |
|
769 |
||
770 |
} |
|
771 |
if( IsPipeInDataMode() ) |
|
772 |
{ |
|
773 |
OstTrace0( TRACE_NORMAL, DUP11_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND is ignored during data mode (exception: escape char is allowed)" ); |
|
774 |
C_TRACE (( _T("AT_MODEM_SIGNAL_IND is ignored during data mode (exception: escape char is allowed)") )); |
|
775 |
return; |
|
776 |
} |
|
777 |
||
778 |
if( echoValue == KInitialValue ) |
|
779 |
{ |
|
780 |
OstTrace0( TRACE_NORMAL, DUP12_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled (no echo changes)" ); |
|
781 |
C_TRACE(( _T("AT_MODEM_SIGNAL_IND not handled (no echo changes)") )); |
|
782 |
return; |
|
783 |
} |
|
784 |
TInt sessionCount = iServer.SessionCount(); |
|
785 |
if( sessionCount == KSessionIndLimit ) |
|
786 |
{ |
|
787 |
OstTrace0( TRACE_NORMAL, DUP13_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled (connect ongoing)" ); |
|
788 |
C_TRACE(( _T("AT_MODEM_SIGNAL_IND not handled (connect ongoing)") )); |
|
789 |
return; |
|
790 |
} |
|
791 |
if( iServer.IsSettingQueryOngoing() ) |
|
792 |
{ |
|
793 |
// V, Q or E command is not ongoing, handle AT_MODEM_SIGNAL_IND always. |
|
794 |
OstTrace0( TRACE_NORMAL, DUP14_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled (Q, V or E query ongoing)" ); |
|
795 |
C_TRACE(( _T("AT_MODEM_SIGNAL_IND not handled (Q, V or E query ongoing)") )); |
|
796 |
return; |
|
797 |
} |
|
798 |
||
799 |
if( !iServer.IsEchoNotified( echoValue ) ) |
|
800 |
{ |
|
801 |
OstTrace0( TRACE_NORMAL, DUP15_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - Handling AT_MODEM_SIGNAL_IND (new echo value received, more than 1 session open)" ); |
|
802 |
C_TRACE(( _T("Handling AT_MODEM_SIGNAL_IND (new echo value received, more than 1 session open)") )); |
|
803 |
iServer.HandleSignalInd( dteId, KErrNone ); |
|
804 |
return; |
|
805 |
} |
|
806 |
||
807 |
OstTrace1( TRACE_NORMAL, DUP16_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled.;sessionCount=%d", sessionCount ); |
|
808 |
C_TRACE(( _L("AT_MODEM_SIGNAL_IND not handled. sessionCount: %d"), sessionCount )); |
|
809 |
} |
|
810 |
// no else |
|
0 | 811 |
} |
812 |
||
813 |
void CModemAtHandler::HandleUnsolicitedData( const TIsiReceiveC& aMessage ) |
|
814 |
{ |
|
9 | 815 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE+AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_DTEID ); |
0 | 816 |
TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH ); |
9 | 817 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_HANDLEUNSOLICITEDDATA, "CModemAtHandler::HandleUnsolicitedData;dteId=%d;iDteId=%d", dteId, iDteId ); |
818 |
C_TRACE (( _T("CModemAtHandler::HandleUnsolicitedData() %d %d"), dteId, iDteId )); |
|
819 |
if( iDteId == dteId || |
|
820 |
KReservedDteId == dteId ) |
|
821 |
{ |
|
822 |
iServer.HandleUnsolicitedData( dteId, |
|
823 |
aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_UNSOLICITEDDATABUFFER, |
|
824 |
length ) ); |
|
825 |
} |
|
826 |
// no else |
|
0 | 827 |
} |
828 |
||
829 |
||
830 |
void CModemAtHandler::HandleIntermediateDataInd( const TIsiReceiveC& aMessage ) |
|
831 |
{ |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
832 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_DTEID ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
833 |
TInt length = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_LENGTH ); |
9 | 834 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd;iDteId=%d", iDteId ); |
835 |
C_TRACE (( _T("CModemAtHandler::HandleIntermediateDataInd() %d"), iDteId )); |
|
836 |
||
837 |
if( iDteId == dteId ) |
|
838 |
{ |
|
839 |
TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID ); |
|
840 |
||
841 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd - transactionId from;transactionId=%d", transactionId ); |
|
842 |
C_TRACE((_L("transactionId from %d"), transactionId)); |
|
843 |
transactionId = iLastTransactionId; |
|
844 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd - transactionId after setting it to iLastTransactionId:;transactionId=%d", transactionId ); |
|
845 |
C_TRACE((_L("transactionId after setting it to iLastTransactionId: %d"), transactionId)); |
|
846 |
||
847 |
TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query |
|
848 |
TUint8 pluginType = transactionId >> KTransactionIdBitsShift; |
|
849 |
OstTraceExt4( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd;dteId=%d;command=%d;(AT=0,NVRAM=1);pluginType=%d;(atext=0,common=1);iDteId=%d", dteId, command, pluginType, iDteId ); |
|
850 |
C_TRACE((_L("dteId %d, command %d (AT=0,NVRAM=1), pluginType = %d (atext=0,common=1)"), dteId, command, pluginType)); |
|
851 |
||
852 |
iServer.HandleIntermediateDataInd( dteId, |
|
853 |
(TATPluginInterface) pluginType, |
|
854 |
aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_INTERMEDIATEDATABUFFER, |
|
855 |
length), |
|
856 |
command ); |
|
857 |
} |
|
0 | 858 |
} |
859 |
||
860 |
||
861 |
void CModemAtHandler::HandleRedirectInd( const TIsiReceiveC& aMessage ) |
|
862 |
{ |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
863 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_DTEID ); |
9 | 864 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEREDIRECTIND, "CModemAtHandler::HandleRedirectInd;iChannel=%d", iChannel ); |
865 |
C_TRACE (( _T("CModemAtHandler::HandleRedirectInd() %d %d"), iDteId, iChannel )); |
|
866 |
if( iDteId == dteId ) |
|
867 |
{ |
|
868 |
TInt newSecondDevId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_DEVICEID ); |
|
869 |
TInt newSecondObjId = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_SERVERID ); |
|
870 |
iPipeController->RedirectPipe( newSecondDevId, newSecondObjId ); |
|
871 |
} |
|
872 |
else |
|
873 |
{ |
|
874 |
TRACE_ASSERT_ALWAYS; |
|
875 |
} |
|
0 | 876 |
} |
877 |
||
9 | 878 |
void CModemAtHandler::SendAtModemDataRedirectResultReq( const TUint aResult ) |
0 | 879 |
{ |
9 | 880 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler::SendAtModemDataRedirectResultReq" ); |
0 | 881 |
C_TRACE (( _T("CModemAtHandler::SendAtModemDataRedirectResultReq()") )); |
882 |
HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ ); |
|
9 | 883 |
OstTraceExt2( TRACE_NORMAL, DUP1_CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler::SendAtModemDataRedirectResultReq - Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ;iDteId=%d;aResult=%d", (TUint)iDteId, aResult ); |
884 |
C_TRACE((_L("Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ dteid %d result %d"), iDteId, aResult)); |
|
0 | 885 |
|
886 |
TPtr8 messageptr = message->Des(); |
|
887 |
TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ ); |
|
888 |
isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM); |
|
889 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_TID, 0 ); |
|
890 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_MESSAGEID, |
|
891 |
AT_MODEM_DATA_REDIRECT_RESULT_REQ ); |
|
9 | 892 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_DTEID ,iDteId ); |
0 | 893 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_RESULT ,aResult ); |
894 |
isimessage.Complete(); |
|
895 |
||
9 | 896 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler::SendAtModemDataRedirectResultReq - Created ISI-message" ); |
0 | 897 |
C_TRACE(_L("Created ISI-message")); |
898 |
for( TInt i = 0 ; i < (ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ); i++ ) |
|
899 |
{ |
|
9 | 900 |
OstTraceExt2( TRACE_NORMAL, DUP3_CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler - ;i=%d;%x", (TUint)i, (TUint)((*message)[i]) ); |
0 | 901 |
C_TRACE((_L("[%d] 0x%x"),i ,(*message)[i]) ); |
902 |
} |
|
903 |
||
904 |
TInt err = iIscApi->Send( messageptr ); |
|
905 |
TRACE_ASSERT( err == KErrNone ); |
|
906 |
delete message; |
|
907 |
message = NULL; |
|
908 |
} |
|
909 |
||
910 |
||
911 |
void CModemAtHandler::HandleRedirectResultResp(const TIsiReceiveC& aMessage) |
|
912 |
{ |
|
9 | 913 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp;iDteId=%d", iDteId ); |
914 |
C_TRACE (( _T("CModemAtHandler::HandleRedirectResultResp() %d"), iDteId )); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
915 |
TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_DTEID ); |
0 | 916 |
TInt error = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_RESULT ); |
9 | 917 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp;dteId=%d", dteId ); |
0 | 918 |
C_TRACE((_L("CModemAtHandler::HandleRedirectResultResp() dte %d"), dteId)); |
919 |
||
920 |
if( error == AT_MODEM_RESULT_ERROR ) |
|
921 |
{ |
|
9 | 922 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp - AT_MODEM_RESULT_ERROR -> COMMAND MODE" ); |
923 |
C_TRACE(_L("AT_MODEM_RESULT_ERROR -> COMMAND MODE")); |
|
924 |
iServer.HandleCommandModeChange( dteId, ECommandMode ); |
|
0 | 925 |
} |
926 |
else |
|
927 |
{ |
|
9 | 928 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp - redirect OK, enable pipe" ); |
0 | 929 |
C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() redirect OK")); |
9 | 930 |
TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState(); |
931 |
OstTrace1( TRACE_NORMAL, DUP4_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp;pipeState=%d", pipeState ); |
|
932 |
C_TRACE((_L("CModemAtHandler::HandleRedirectResultResp() pipe state %d"), pipeState)); |
|
933 |
if( pipeState != TPipeInfo::EPipeDisabled ) |
|
934 |
{ |
|
935 |
iPipeController->SendEnablePipeReq(); |
|
936 |
} |
|
0 | 937 |
} |
938 |
} |
|
9 | 939 |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
940 |
void CModemAtHandler::HandleCommandModeChange( TCommandMode aMode ) |
0 | 941 |
{ |
9 | 942 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_HANDLECOMMANDMODECHANGE, "CModemAtHandler::HandleCommandModeChange;aMode=%d;iDteId=%d", (TUint)aMode, (TUint)iDteId ); |
943 |
C_TRACE(( _T("CModemAtHandler::HandleCommandModeChange() aMode: %d dteId: %d"), (TInt) aMode, iDteId )); |
|
944 |
iServer.HandleCommandModeChange( iDteId, aMode ); |
|
0 | 945 |
} |
946 |
||
9 | 947 |
TInt CModemAtHandler::SendSignalDetection( const TUint8 aSignal ) |
0 | 948 |
{ |
9 | 949 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SENDSIGNALDETECTION, "CModemAtHandler::SendSignalDetection;iDteId=%d", iDteId ); |
950 |
C_TRACE((_T("CModemAtHandler::SendSignalDetection( dteId: %d, aSignal: 0x%x)"), iDteId, aSignal )); |
|
951 |
||
0 | 952 |
TInt error( KErrGeneral ); |
953 |
TUint msgSize( ISI_HEADER_SIZE + SIZE_AT_MODEM_SIGNAL_DETECTED_REQ ); |
|
954 |
TUint size( msgSize + SIZE_AT_MODEM_SB_SIGNAL_DETECTED ); |
|
955 |
HBufC8* message = HBufC8::New( size ); |
|
956 |
if( message ) |
|
9 | 957 |
{ |
958 |
TPtr8 messageptr = message->Des(); |
|
959 |
TIsiSend isimessage( messageptr, size ); |
|
960 |
isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM ); |
|
961 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_TID, 0x00 ); |
|
962 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_MESSAGEID, |
|
963 |
AT_MODEM_SIGNAL_DETECTED_REQ ); |
|
964 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_DTEID, iDteId ); |
|
965 |
isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_NOOFSUBBLOCKS, 0x01 ); |
|
966 |
isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKID, |
|
967 |
AT_MODEM_SB_SIGNAL_DETECTED ); |
|
968 |
isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKLENGTH, |
|
969 |
SIZE_AT_MODEM_SB_SIGNAL_DETECTED ); |
|
970 |
isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_TYPEOFSIGNALDETECTED, |
|
971 |
aSignal ); |
|
972 |
isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_FILLERBYTE1, 0x00 ); |
|
973 |
isimessage.Complete(); |
|
974 |
error = iIscApi->Send(messageptr); |
|
975 |
TRACE_ASSERT( error == KErrNone ); |
|
976 |
delete message; |
|
977 |
message = NULL; |
|
978 |
} |
|
0 | 979 |
else |
9 | 980 |
{ |
981 |
ASSERT_ALWAYS; |
|
982 |
error = KErrNoMemory; |
|
983 |
} |
|
0 | 984 |
return error; |
985 |
} |
|
986 |
||
987 |
||
988 |
void CModemAtHandler::HandleSignalDetectedResp( const TIsiReceiveC& aMessage ) |
|
989 |
{ |
|
9 | 990 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_HANDLESIGNALDETECTEDRESP, "CModemAtHandler::HandleSignalDetectedResp() - escape sequence detect response received from cellmo" ); |
991 |
C_TRACE (( _T("CModemAtHandler::HandleSignalDetectedResp()") )); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
992 |
TUint8 dteId( aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_DTEID ) ); |
0 | 993 |
TInt result = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_RESULT ); |
9 | 994 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLESIGNALDETECTEDRESP, "CModemAtHandler::HandleSignalDetectedResp;dteId=%d", dteId ); |
0 | 995 |
C_TRACE((_L("CModemAtHandler::HandleSignalDetectedResp() dteId %d"), dteId)); |
996 |
TRACE_ASSERT( result == AT_MODEM_RESULT_OK ); |
|
997 |
} |
|
998 |
||
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
999 |
void CModemAtHandler::SetModemAtExistsInCmt( TBool aModemAtExistsInCmt ) |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
1000 |
{ |
9 | 1001 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SETMODEMATEXISTSINCMT, "CModemAtHandler::SetModemAtExistsInCmt;aModemAtExistsInCmt=%d", (TInt)aModemAtExistsInCmt ); |
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
1002 |
C_TRACE((_T("CModemAtHandler::SetModemAtExistsInCmt(%d)"), (TInt)aModemAtExistsInCmt)); |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
1003 |
iModemAtExistInCmt = aModemAtExistsInCmt; |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
1004 |
} |
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
1005 |
|
9 | 1006 |
TInt CModemAtHandler::SendAtModemConnectReq() |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1007 |
{ |
9 | 1008 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SENDATMODEMCONNECTREQ, "CModemAtHandler::SendAtModemConnectReq;iDteId=%d", iDteId ); |
1009 |
C_TRACE (( _T("CModemAtHandler::SendAtModemConnectReq() %d"), iDteId )); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1010 |
TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_CONNECT_REQ; |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1011 |
HBufC8* message = HBufC8::New( size ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1012 |
TRACE_ASSERT( message ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1013 |
TPtr8 messageptr = message->Des(); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1014 |
TIsiSend isimessage( messageptr, size ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1015 |
isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1016 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_TID, KDefaultTId); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1017 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_MESSAGEID, AT_MODEM_CONNECT_REQ); |
9 | 1018 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_DTEID, iDteId); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1019 |
isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_FILLERBYTE1, KFiller); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1020 |
isimessage.Complete(); |
9 | 1021 |
OstTraceExt1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_SENDATMODEMCONNECTREQ, "CModemAtHandler::SendAtModemConnectReq - message dump;messageptr=%s", messageptr ); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1022 |
DUMP_MESSAGE( messageptr ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1023 |
TInt err = iIscApi->Send( messageptr ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1024 |
TRACE_ASSERT( err == KErrNone ); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1025 |
delete message; |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1026 |
message = NULL; |
9 | 1027 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_SENDATMODEMCONNECTREQ, "CModemAtHandler::SendAtModemConnectReq - return;err=%d", err ); |
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1028 |
C_TRACE (( _T("CModemAtHandler::SendAtModemConnectReq()<< returned: %d"), err )); |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1029 |
return err; |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1030 |
} |
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
1031 |
|
9 | 1032 |
TBool CModemAtHandler::IsPipeInDataMode() |
1033 |
{ |
|
1034 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_ISPIPEINDATAMODE, "CModemAtHandler::IsPipeInDataMode;iDteId=%d", iDteId ); |
|
1035 |
C_TRACE(( _T("CModemAtHandler::IsPipeInDataMode() dteId: %d"), iDteId )); |
|
1036 |
TPipeInfo::EPipeState pipeState( iPipeController->GetPipeState() ); |
|
1037 |
if( pipeState == TPipeInfo::EPipeEnabled || |
|
1038 |
pipeState == TPipeInfo::EPipeRedirected ) |
|
1039 |
{ |
|
1040 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_ISPIPEINDATAMODE, "CModemAtHandler::IsPipeInDataMode - True" ); |
|
1041 |
C_TRACE(( _T("CModemAtHandler::IsPipeInDataMode() True") )); |
|
1042 |
return ETrue; |
|
1043 |
} |
|
1044 |
else |
|
1045 |
{ |
|
1046 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_ISPIPEINDATAMODE, "CModemAtHandler::IsPipeInDataMode - False" ); |
|
1047 |
C_TRACE(( _T("CModemAtHandler::IsPipeInDataMode() False") )); |
|
1048 |
return EFalse; |
|
1049 |
} |
|
1050 |
} |
|
1051 |
||
1052 |
||
1053 |
void CModemAtHandler::SetTextMessageMode( TBool aTextMode ) |
|
1054 |
{ |
|
1055 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_SETTEXTMESSAGEMODE, "CModemAtHandler::SetTextMessageMode(;aTextMode=%d;);iDteId=%d", (TUint)aTextMode, (TUint)iDteId ); |
|
1056 |
C_TRACE (( _T("CModemAtHandler::SetTextMessageMode( aTextMode: %d ) dte id: %d"), (TInt) aTextMode, iDteId )); |
|
1057 |
iTextMessageMode = aTextMode; |
|
1058 |
} |
|
1059 |
||
1060 |
TBool CModemAtHandler::IsTextMessageMode() |
|
1061 |
{ |
|
1062 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_ISTEXTMESSAGEMODE, "CModemAtHandler::IsTextMessageMode;iTextMessageMode=%d;iDteId=%d", (TUint)iTextMessageMode, (TUint)iDteId ); |
|
1063 |
C_TRACE (( _T("CModemAtHandler::IsTextMessageMode() iTextMessageMode: %d dte id: %d"), (TInt) iTextMessageMode, iDteId )); |
|
1064 |
return iTextMessageMode; |
|
1065 |
} |
|
1066 |
||
1067 |
void CModemAtHandler::PipeCreated( TUint8 aPipeHandle, TInt aError ) |
|
1068 |
{ |
|
1069 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_PIPECREATED, "CModemAtHandler::PipeCreated;aPipeHandle=%d", aPipeHandle ); |
|
1070 |
C_TRACE(( _T("CModemAtHandler::PipeCreated() pipehandle: %d"), aPipeHandle )); |
|
1071 |
||
1072 |
iDteId = aPipeHandle; |
|
1073 |
||
1074 |
if( KErrNone == aError ) |
|
1075 |
{ |
|
1076 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_PIPECREATED, "CModemAtHandler::PipeCreated - pipe created, let's connect to modem" ); |
|
1077 |
C_TRACE(( _T("CModemAtHandler::pipeCreated(): pipe created, let's connect to modem") )); |
|
1078 |
SendAtModemConnectReq(); |
|
1079 |
} |
|
1080 |
else |
|
1081 |
{ |
|
1082 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_PIPECREATED, "CModemAtHandler::PipeCreated - pipe creation has failed, connect is aborted" ); |
|
1083 |
C_TRACE(( _T("CModemAtHandler::pipeCreated(): pipe creation has failed, connect is aborted") )); |
|
1084 |
iServer.SetDteIdAndConnect( KInvalidPipeHandle, aError ); |
|
1085 |
} |
|
1086 |
} |
|
1087 |
||
1088 |
||
1089 |
void CModemAtHandler::AddDevice( TUint8 aDevId, TUint8 aObjId ) |
|
1090 |
{ |
|
1091 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_ADDDEVICE, "CModemAtHandler::AddDevice;aDevId=%x;aObjId=%x", aDevId, aObjId ); |
|
1092 |
C_TRACE(( _T("CModemAtHandler::AddDevice() aDevId: 0x%x, aObjId: 0x%x"), aDevId, aObjId )); |
|
1093 |
iServer.AddDevice( aDevId, aObjId ); |
|
1094 |
} |
|
1095 |
||
1096 |
||
1097 |
void CModemAtHandler::RemoveDevice( TUint8 aDevId, TUint8 aObjId ) |
|
1098 |
{ |
|
1099 |
OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_REMOVEDEVICE, "CModemAtHandler::RemoveDevice;aDevId=%hhu;aObjId=%hhu", aDevId, aObjId ); |
|
1100 |
C_TRACE(( _T("CModemAtHandler::RemoveDevice() aDevId: 0x%x, aObjId: 0x%x"), aDevId, aObjId )); |
|
1101 |
iServer.RemoveDevice( aDevId, aObjId ); |
|
1102 |
} |
|
1103 |
||
1104 |
void CModemAtHandler::GetDataportObjectId( TUint& aObjId ) |
|
1105 |
{ |
|
1106 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_GETDATAPORTOBJECTID, "CModemAtHandler::GetDataportObjectId" ); |
|
1107 |
C_TRACE(( _T("CModemAtHandler::GetDataportObjectId()") )); |
|
1108 |
aObjId = iDataportObjId; |
|
1109 |
} |
|
1110 |
||
1111 |
void CModemAtHandler::GetSecondaryDataportObjectId( TUint& aObjId ) |
|
1112 |
{ |
|
1113 |
OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId" ); |
|
1114 |
C_TRACE(( _T("CModemAtHandler::GetScondaryDataportObjectId()") )); |
|
1115 |
TBuf8<KObjectIdLength> dpObjId; |
|
1116 |
||
1117 |
if( iIscApi ) |
|
1118 |
{ |
|
1119 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId - call GetChannelInfo(EIscNokiaDataport4) " ); |
|
1120 |
C_TRACE(( _T("GetChannelInfo() EIscNokiaDataport4") )); |
|
1121 |
iIscApi->GetChannelInfo( EIscNokiaDataport4, dpObjId ); |
|
1122 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId - GetChannelInfo() done" ); |
|
1123 |
C_TRACE(( _T("GetChannelInfo() done") )); |
|
1124 |
aObjId = (((TUint16)(dpObjId[0])) << KEightBits) + dpObjId[1]; |
|
1125 |
OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId;aObjId=%d", aObjId ); |
|
1126 |
C_TRACE((_L("DataportObjId 0x%x"), aObjId )); |
|
1127 |
} |
|
1128 |
else |
|
1129 |
{ |
|
1130 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId - No IscApi found, using default dataport object id" ); |
|
1131 |
C_TRACE(( _T("No IscApi found, using default dataport object id") )); |
|
1132 |
} |
|
1133 |
} |
|
1134 |
||
1135 |
||
1136 |
TInt CModemAtHandler::GetChannelId() |
|
1137 |
{ |
|
1138 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_GETCHANNELID, "CModemAtHandler::GetChannelId;iChannel=%x", iChannel ); |
|
1139 |
OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_GETCHANNELID, "CModemAtHandler::GetChannelId;this=%x", this ); |
|
1140 |
C_TRACE(( _T("CModemAtHandler::GetChannelId() handler: 0x%x, channel id: 0x%x"), this, iChannel )); |
|
1141 |
return iChannel; |
|
1142 |
} |
|
1143 |