|
1 /* |
|
2 * Copyright (c) 2009 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 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 #include <phonetisi.h> // For ISI_HEADER_SIZE |
|
20 #include <pn_const.h> // For PN_HEADER_SIZE |
|
21 #include <pipeisi.h> // For PNS_PIPE_DATA_OFFSET_DATA |
|
22 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
23 #include <mediaisi.h> // For PNS_MEDIA_SPECIFIC_REQ/RESP |
|
24 #include <nsisi.h> // For PNS_NAME... |
|
25 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
26 #include <commisi.h> // For SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP |
|
27 #include "router.h" |
|
28 #include "iadtrace.h" // For C_TRACE.. |
|
29 #include "isaaccessextension.h" // For DIsaAccessExtension |
|
30 #include "indicationhandler.h" // For DIndicationHandler |
|
31 #include "queue.h" // For DQueue |
|
32 #include "iadinternaldefinitions.h" // For EIADAsync... |
|
33 #include "iadhelpers.h" // For GET_RECEIVER |
|
34 |
|
35 #include "pipehandler.h" // For PipeHandler |
|
36 #include "OstTraceDefinitions.h" |
|
37 #ifdef OST_TRACE_COMPILER_IN_USE |
|
38 #include "routerTraces.h" |
|
39 #endif |
|
40 |
|
41 //#define MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD // TODO: to be removed when Bridge Modem SW is ok |
|
42 |
|
43 // ISCE |
|
44 #include "memapi.h" // For MemApi |
|
45 #include "trxdefs.h" // For ETrx... |
|
46 // ISCE |
|
47 // ISCE #include "miad2istapi.h" // For MIAD2ISTApi |
|
48 |
|
49 |
|
50 |
|
51 // CONSTS |
|
52 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
53 |
|
54 // TODO : spec this to some document |
|
55 /**** IAD<->SOS_MM ****/ |
|
56 const TUint8 KIADObjId( 0xfe ); |
|
57 /* CTRL CONF REQ START * |
|
58 [0] media, PN_MEDIA_SOS; |
|
59 [1] recdev, PN_MEDIA_ROUTING_REQ |
|
60 [2] senderdev, PN_DEV_SOS |
|
61 [3] function, PN_MEDIA_CONTROL |
|
62 [4,5] length, 8 |
|
63 [6] recobj, PN_OBJ_ROUTER |
|
64 [7] senderobj, KIADObjId |
|
65 [8] transaction 0x00 |
|
66 [9] messageid PNS_MEDIA_SPECIFIC_REQ |
|
67 [10] media2control PN_MEDIA_SOS |
|
68 [11] ctrl msg id KIADCtrlConfReq (0x05) |
|
69 [12] filler 0x00 |
|
70 [13] filler 0x00 |
|
71 * CTRL CONF REQ END */ |
|
72 const TUint8 KIADCtrlConfReq( 0x5 ); |
|
73 /* CTRL CONF RESP START * |
|
74 [0] media, PN_MEDIA_SOS; |
|
75 [1] recdev, PN_DEV_SOS |
|
76 [2] senderdev, PN_MEDIA_ROUTING_REQ |
|
77 [3] function, PN_MEDIA_CONTROL |
|
78 [4,5] length, 10 |
|
79 [6] recobj, KIADObjId |
|
80 [7] senderobj, PN_OBJ_ROUTER |
|
81 [8] transaction 0x00 |
|
82 [9] messageid PNS_MEDIA_SPECIFIC_REQ |
|
83 [10] media2control PN_MEDIA_SOS |
|
84 [11] media error PN_MCTRL_NO_ERROR |
|
85 [12] ctrl msg id KIADCtrlConfResp (0x06) |
|
86 [13] conf size 8 bytes |
|
87 [14] conf size 8 bytes |
|
88 [15] filler 0x00 |
|
89 * CTRL CONF RESP END */ |
|
90 const TUint8 KIADCtrlConfResp( 0x6 ); |
|
91 /* CTRL DRM REQ START * |
|
92 [0] media, PN_MEDIA_SOS; |
|
93 [1] recdev, PN_MEDIA_ROUTING_REQ |
|
94 [2] senderdev, PN_DEV_SOS |
|
95 [3] function, PN_MEDIA_CONTROL |
|
96 [4,5] length, 8 ( + 6 = KIADCtrlDrmReqLength ) |
|
97 [6] recobj, PN_OBJ_ROUTER |
|
98 [7] senderobj, KIADObjId |
|
99 [8] channel number IAD client's channel number |
|
100 [9] messageid PNS_MEDIA_SPECIFIC_REQ |
|
101 [10] mediatocontrol PN_MEDIA_SOS |
|
102 [11] ctrl msg id KIADCtrlDrmReq (0x07) |
|
103 [12] ch is 2 be reg IAD client's channel number |
|
104 [13] filler 0x00 |
|
105 * CTRL DRM REQ END */ |
|
106 const TUint8 KIADCtrlDrmReq( 0x7 ); |
|
107 const TInt KIADCtrlDrmReqLength( 14 ); |
|
108 /* CTRL DRM RESP START * |
|
109 [0] media, PN_MEDIA_SOS; |
|
110 [1] recdev, PN_DEV_SOS |
|
111 [2] senderdev, PN_MEDIA_ROUTING_REQ |
|
112 [3] function, PN_MEDIA_CONTROL |
|
113 [4,5] length, 8 |
|
114 [6] recobj, KIADObjId |
|
115 [7] senderobj, PN_OBJ_ROUTER |
|
116 [8] channel number IAD client's channel number |
|
117 [9] messageid PNS_MEDIA_SPECIFIC_RESP |
|
118 [10] mediatocontrol PN_MEDIA_SOS |
|
119 [11] media error PN_MCTRL_NO_ERROR |
|
120 [12] ctrl msg id KIADCtrlDrmResp (0x08) |
|
121 [13] filler 0x00 |
|
122 * CTRL DRM REQ END */ |
|
123 const TUint8 KIADCtrlDrmResp( 0x8 ); |
|
124 |
|
125 #define CTRL_REQ_OFFSET_MESSAGEID ( ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_DATA ) |
|
126 #define CTRL_RESP_OFFSET_MESSAGEID ( ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_RESP_OFFSET_DATA ) |
|
127 #define CTRL_CONF_RESP_OFFSET_SIZE_BYTE1 ( CTRL_RESP_OFFSET_MESSAGEID + 1 ) |
|
128 #define CTRL_CONF_RESP_OFFSET_SIZE_BYTE2 ( CTRL_CONF_RESP_OFFSET_SIZE_BYTE1 + 1 ) |
|
129 #define CTR_DRM_REQ_RESP_OFFSET_CHANNEL_ID ( ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_RESP_OFFSET_UTID ) |
|
130 #define CTRL_DRM_REQ_OFFSET_REQUIRED_CHANNEL_ID ( CTRL_REQ_OFFSET_MESSAGEID + 1 ) |
|
131 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
132 |
|
133 // TODO: change this to use UnuqueID instead and to extension.. |
|
134 void DRouter::CheckDfc() |
|
135 { |
|
136 OstTrace0( TRACE_NORMAL, DROUTER_CHECKDFC_ENTRY, ">DRouter::CheckDfc" ); |
|
137 |
|
138 DObject* tempObj = reinterpret_cast<DObject*>( &Kern::CurrentThread() ); |
|
139 TUint8* buffer = ( TUint8* )Kern::Alloc( 100 ); |
|
140 TPtr8* bufferPtr = new ( TPtr8 )( buffer, 100 ); |
|
141 tempObj->Name( *bufferPtr ); |
|
142 C_TRACE( ( _T( "DRouter::CheckDfc" ) ) ); |
|
143 if ( bufferPtr->Compare( KIADExtensionDfc ) != KErrNone ) |
|
144 { |
|
145 for( TInt i( 0 );i < bufferPtr->Length(); ++i ) |
|
146 { |
|
147 Kern::Printf( "%c", i, bufferPtr->Ptr()[ i ]); |
|
148 } |
|
149 ASSERT_RESET_ALWAYS( 0, EIADWrongDFCQueueUsed | EIADFaultIdentifier2 << KFaultIdentifierShift ); |
|
150 } |
|
151 Kern::Free( buffer ); |
|
152 delete bufferPtr; |
|
153 bufferPtr = NULL; |
|
154 |
|
155 OstTrace0( TRACE_NORMAL, DROUTER_CHECKDFC_EXIT, "<DRouter::CheckDfc" ); |
|
156 } |
|
157 |
|
158 #ifdef _DEBUG |
|
159 #define ASSERT_DFCTHREAD_INEXT() CheckDfc() |
|
160 #else |
|
161 #define ASSERT_DFCTHREAD_INEXT() |
|
162 #endif |
|
163 |
|
164 DRouter::DRouter(): |
|
165 iConnectionStatus( EIADConnectionNotOk ) |
|
166 , iBootDone( EFalse ) |
|
167 { |
|
168 OstTrace0( TRACE_NORMAL, DROUTER_DROUTER_ENTRY, "<DRouter::DRouter" ); |
|
169 |
|
170 C_TRACE( ( _T( "DRouter::DRouter ->" ) ) ); |
|
171 // owned |
|
172 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
173 iPipeHandler = new DPipeHandler( *this ); |
|
174 #endif |
|
175 iIndicationHandler = new DIndicationHandler( *this ); |
|
176 iCommonRxQueue = new DQueue( KIADExtensionRxQueueSize ); |
|
177 ASSERT_RESET_ALWAYS( /*iPipeHandler &&*/ iIndicationHandler && iCommonRxQueue, EIADMemoryAllocationFailure | EIADFaultIdentifier17 << KFaultIdentifierShift ); |
|
178 // Initialize channels to NULL when channel is opened !NULL. |
|
179 for( TInt i( 0 ); i < EIADSizeOfChannels; ++i ) |
|
180 { |
|
181 iChannelTable[ i ].iChannel = NULL; |
|
182 iChannelTable[ i ].iWaitingChannel = NULL; |
|
183 iChannelTable[ i ].iType = ENormalOpen; |
|
184 } |
|
185 |
|
186 iCommonRxDfc = new TDfc( CommonRxDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADExtCommonRxPriori ); |
|
187 // not owned, just using. |
|
188 // Set null when not registered. |
|
189 iInitCmtDfc = new TDfc( InitCmtDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADExtInitCmtPriori ); |
|
190 iConnStatDfc = new TDfc( NotifyObjLayerConnStatDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADExtConnStatPriori ); |
|
191 ASSERT_RESET_ALWAYS( iCommonRxDfc && iInitCmtDfc && iConnStatDfc, EIADMemoryAllocationFailure | EIADFaultIdentifier18 << KFaultIdentifierShift ); |
|
192 iMaxFrameSize = 0x0000; |
|
193 // ISCE |
|
194 iLinksArray = new MISIRouterLinkIf*[ DRouter::EISIAmountOfMedias ]; |
|
195 // TODO: fault codes and ids |
|
196 ASSERT_RESET_ALWAYS( iLinksArray, ( EIADMemoryAllocationFailure | EIADFaultIdentifier17 << KFaultIdentifierShift ) ); |
|
197 // Initialize links |
|
198 for( TInt i( 0 ); i < DRouter::EISIAmountOfMedias; i++ ) |
|
199 { |
|
200 iLinksArray[ i ] = NULL; |
|
201 C_TRACE( ( _T( "DRouter::DRouter %d" ), i ) ); |
|
202 } |
|
203 // Configuration of ISI links. TODO: devices and link configurations for coming platforms are unknown and to be done later. |
|
204 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
205 iLinksArray[ DRouter::EISIMediaSOS ] = MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_SOS, ETrxPartnerOS ); |
|
206 #else |
|
207 // Bridge media = PN_MEDIA_MODEM_HOST_IF |
|
208 iLinksArray[ DRouter::EISIMediaHostSSI ] = MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_MODEM_HOST_IF, ETrxSharedMemory ); |
|
209 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
210 // ISCE |
|
211 C_TRACE( ( _T( "DRouter::DRouter 0x%x <-" ), this ) ); |
|
212 OstTrace1( TRACE_NORMAL, DROUTER_DROUTER_EXIT, "<DRouter::DRouter;this=%x", this ); |
|
213 } |
|
214 |
|
215 DRouter::~DRouter( |
|
216 // None |
|
217 ) |
|
218 { |
|
219 OstTrace0( TRACE_NORMAL, DUP1_DROUTER_DROUTER_ENTRY, "<DRouter::~DRouter" ); |
|
220 //ISCE |
|
221 // owning so deleting |
|
222 for( TInt i( 0 ); i < EISIAmountOfMedias; i++ ) |
|
223 { |
|
224 MISIRouterLinkIf* temp = iLinksArray[ i ]; |
|
225 temp->Release(); |
|
226 temp = NULL; |
|
227 iLinksArray[ i ] = NULL; |
|
228 } |
|
229 //ISCE |
|
230 C_TRACE( ( _T( "DRouter::~DRouter 0x%x ->" ), this ) ); |
|
231 // Initialize channels to NULL when channel is opened !NULL. |
|
232 for( TInt i( 0 ); i < EIADSizeOfChannels; ++i ) |
|
233 { |
|
234 iChannelTable[ i ].iChannel = NULL; |
|
235 iChannelTable[ i ].iWaitingChannel = NULL; |
|
236 iChannelTable[ i ].iType = ENormalOpen; |
|
237 } |
|
238 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
239 if( iPipeHandler ) |
|
240 { |
|
241 delete iPipeHandler; |
|
242 iPipeHandler = NULL; |
|
243 } |
|
244 #endif |
|
245 if( iIndicationHandler ) |
|
246 { |
|
247 delete iIndicationHandler; |
|
248 iIndicationHandler = NULL; |
|
249 } |
|
250 if( iCommonRxQueue ) |
|
251 { |
|
252 delete iCommonRxQueue; |
|
253 iCommonRxQueue = NULL; |
|
254 } |
|
255 if( iCommonRxDfc ) |
|
256 { |
|
257 iCommonRxDfc->Cancel(); |
|
258 delete iCommonRxDfc; |
|
259 iCommonRxDfc = NULL; |
|
260 } |
|
261 if( iInitCmtDfc ) |
|
262 { |
|
263 delete iInitCmtDfc; |
|
264 iInitCmtDfc = NULL; |
|
265 } |
|
266 if( iConnStatDfc ) |
|
267 { |
|
268 delete iConnStatDfc; |
|
269 iConnStatDfc = NULL; |
|
270 } |
|
271 C_TRACE( ( _T( "DRouter::~DRouter 0x%x <-" ), this ) ); |
|
272 |
|
273 OstTrace1( TRACE_NORMAL, DUP1_DROUTER_DROUTER_EXIT, "<DRouter::~DRouter;this=%x", this ); |
|
274 } |
|
275 |
|
276 // From start |
|
277 // Do not call from ISR context!! Can only be called from Extension DFCThread context. |
|
278 EXPORT_C TDes8& DRouter::AllocateBlock( |
|
279 const TUint16 aSize |
|
280 ) |
|
281 { |
|
282 OstTraceExt1( TRACE_NORMAL, DROUTER_ALLOCATEBLOCK_ENTRY, "<>DRouter::AllocateBlock;aSize=%hu", aSize ); |
|
283 |
|
284 C_TRACE( ( _T( "DRouter::AllocateBlock %d <->" ), aSize ) ); |
|
285 ASSERT_CONTEXT_ALWAYS( NKern::EThread, 0 ); |
|
286 ASSERT_DFCTHREAD_INEXT(); |
|
287 ASSERT_RESET_ALWAYS( aSize, EIADWrongParameter | EIADFaultIdentifier9 << KFaultIdentifierShift ); |
|
288 // ISCE |
|
289 // ASSERT_RESET_ALWAYS( iIST, EIADNullParameter | EIADFaultIdentifier17 << KFaultIdentifierShift ); |
|
290 // return iIST->AllocateBlock( aSize );// TODO: Print ptr!!! |
|
291 return MemApi::AllocBlock( aSize ); |
|
292 // ISCE |
|
293 } |
|
294 |
|
295 EXPORT_C TDes8& DRouter::AllocateDataBlock( |
|
296 const TUint16 aSize |
|
297 ) |
|
298 { |
|
299 OstTraceExt1( TRACE_NORMAL, DROUTER_ALLOCATEDATABLOCK_ENTRY, ">DRouter::AllocateDataBlock;aSize=%hu", aSize ); |
|
300 |
|
301 C_TRACE( ( _T( "DRouter::AllocateDataBlock %d <->" ), aSize ) ); |
|
302 TUint32 neededLength( aSize + ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_DATA ); |
|
303 TDes8& tmp = this->AllocateBlock( neededLength ); |
|
304 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
305 tmp.SetLength( neededLength ); |
|
306 TUint8* msgPtr = const_cast<TUint8*>( tmp.Ptr() ); |
|
307 SET_RECEIVER_DEV( msgPtr, PN_DEV_DONT_CARE ); |
|
308 ASSERT_RESET_ALWAYS( neededLength > ISI_HEADER_OFFSET_MESSAGEID, EIADOverTheLimits | EIADFaultIdentifier1 << KFaultIdentifierShift ); |
|
309 msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_PIPE; |
|
310 msgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] = PNS_PIPE_DATA; |
|
311 SET_RECEIVER_OBJ( msgPtr, PN_OBJ_ROUTER ); |
|
312 SET_LENGTH( tmp, ( tmp.Length() - PN_HEADER_SIZE ) ); |
|
313 #endif |
|
314 OstTrace1( TRACE_NORMAL, DROUTER_ALLOCATEDATABLOCK_EXIT, "<DRouter::AllocateDataBlock;tmp=%x",( TUint )&( tmp ) ); |
|
315 return tmp; |
|
316 } |
|
317 |
|
318 |
|
319 EXPORT_C void DRouter::Close( |
|
320 const TUint16 aChannelId |
|
321 ) |
|
322 { |
|
323 |
|
324 OstTraceExt1( TRACE_NORMAL, DROUTER_CLOSE_ENTRY, ">DRouter::Close;aChannelId=%hx", aChannelId ); |
|
325 C_TRACE( ( _T( "DRouter::Close 0x%x ->" ), aChannelId ) ); |
|
326 // Channel must be from appropiate length and although it is sixteenbit value it must contain only 8-bit values. If over 8-bit changes needed. |
|
327 ASSERT_RESET_ALWAYS( aChannelId < EIADSizeOfChannels || aChannelId < 0xff, EIADWrongParameter | EIADFaultIdentifier10 << KFaultIdentifierShift ); |
|
328 ASSERT_DFCTHREAD_INEXT(); |
|
329 // If channel open (!NULL) set as closed (NULL) or if channel open is pending. |
|
330 ASSERT_RESET_ALWAYS( aChannelId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)aChannelId << KChannelNumberShift | EIADFaultIdentifier21 << KFaultIdentifierShift ); |
|
331 if( iChannelTable[ aChannelId ].iChannel || iChannelTable[ aChannelId ].iWaitingChannel ) |
|
332 { |
|
333 C_TRACE( ( _T( "DRouter::Close open->close 0x%x" ), aChannelId ) ); |
|
334 #if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95) |
|
335 if( iChannelTable[ aChannelId ].iType != ELoan ) |
|
336 { |
|
337 #endif |
|
338 iChannelTable[ aChannelId ].iChannel = NULL; |
|
339 iChannelTable[ aChannelId ].iWaitingChannel = NULL; |
|
340 iChannelTable[ aChannelId ].iType = ENormalOpen; |
|
341 const TInt indicationCancelOrderSize( 2 ); |
|
342 TDes8& cancelOrder = AllocateBlock( indicationCancelOrderSize ); |
|
343 cancelOrder.Append( 0x00 ); |
|
344 cancelOrder.Append( 0x00 ); |
|
345 // Order internally, so no return values above ::Close { 0x00, 0x00 } 8-bit cancel indication. |
|
346 TInt error( OrderIndication( cancelOrder, aChannelId, EFalse ) ); |
|
347 C_TRACE( ( _T( "DRouter::Close open->close indication order returned %d 0x%x" ), error, aChannelId ) ); |
|
348 OstTraceExt2( TRACE_NORMAL, DROUTER_CLOSE, "DRouter::Close open->close indication order returned;error=%d;aChannelId=%x", error, aChannelId ); |
|
349 ASSERT_RESET_ALWAYS( KErrNone == error, EIADIndicationOrderFailed | static_cast<TUint8>( ( aChannelId << KChannelNumberShift ) ) ); |
|
350 DeAllocateBlock( cancelOrder ); |
|
351 #if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95) |
|
352 } |
|
353 else |
|
354 { |
|
355 C_TRACE( ( _T( "DRouter::Close open->close loaned channel 0x%x" ), aChannelId ) ); |
|
356 OstTrace1( TRACE_NORMAL, DROUTER_CLOSE_2, "DRouter::Close open->close loaned channel;aChannelId=%x", aChannelId ); |
|
357 iChannelTable[ aChannelId ].iType = ENormalOpen; |
|
358 iChannelTable[ aChannelId ].iChannel = iChannelTable[ aChannelId ].iWaitingChannel; |
|
359 iChannelTable[ aChannelId ].iWaitingChannel = NULL; |
|
360 } |
|
361 #endif |
|
362 } |
|
363 C_TRACE( ( _T( "DRouter::Close 0x%x <-" ), aChannelId ) ); |
|
364 OstTrace0( TRACE_NORMAL, DROUTER_CLOSE_EXIT, "<DRouter::Close" ); |
|
365 |
|
366 } |
|
367 |
|
368 // Do not call from ISR context!! Can only be called from Extension DFCThread context. |
|
369 EXPORT_C void DRouter::DeAllocateBlock( |
|
370 TDes8& aBlock |
|
371 ) |
|
372 { |
|
373 OstTrace1( TRACE_NORMAL, DROUTER_DEALLOCATEBLOCK_ENTRY, ">DRouter::DeAllocateBlock;aBlock=%x", ( TUint )&( aBlock ) ); |
|
374 |
|
375 C_TRACE( ( _T( "DRouter::DeAllocateBlock 0x%x ->" ), &aBlock ) ); |
|
376 ASSERT_CONTEXT_ALWAYS( NKern::EThread, 0 ); |
|
377 ASSERT_DFCTHREAD_INEXT(); |
|
378 // ISCE |
|
379 // ASSERT_RESET_ALWAYS( iIST, EIADNullParameter | EIADFaultIdentifier18 << KFaultIdentifierShift ); |
|
380 // iIST->DeallocateBlock( aBlock ); |
|
381 MemApi::DeallocBlock( aBlock ); |
|
382 // ISCE |
|
383 C_TRACE( ( _T( "DRouter::DeAllocateBlock 0x%x <-" ), &aBlock ) ); |
|
384 |
|
385 OstTrace0( TRACE_NORMAL, DROUTER_DEALLOCATEBLOCK_EXIT, "<DRouter::DeAllocateBlock" ); |
|
386 } |
|
387 |
|
388 EXPORT_C TInt DRouter::GetConnectionStatus( |
|
389 // None |
|
390 ) |
|
391 { |
|
392 OstTrace0( TRACE_NORMAL, DROUTER_GETCONNECTIONSTATUS_ENTRY, "<DRouter::GetConnectionStatus" ); |
|
393 |
|
394 C_TRACE( ( _T( "DRouter::GetConnectionStatus %d <->" ), iConnectionStatus ) ); |
|
395 ASSERT_DFCTHREAD_INEXT(); |
|
396 |
|
397 OstTrace1( TRACE_NORMAL, DROUTER_GETCONNECTIONSTATUS, "<DRouter::GetConnectionStatus;iConnectionStatus=%x", iConnectionStatus ); |
|
398 return iConnectionStatus; |
|
399 } |
|
400 |
|
401 EXPORT_C TInt DRouter::GetFlowControlStatus() |
|
402 { |
|
403 OstTrace0( TRACE_NORMAL, DROUTER_GETFLOWCONTROLSTATUS_ENTRY, "<>DRouter::GetFlowControlStatus" ); |
|
404 ASSERT_DFCTHREAD_INEXT(); |
|
405 return KErrNotSupported; // TODO |
|
406 } |
|
407 |
|
408 EXPORT_C TInt DRouter::GetMaxDataSize( |
|
409 // None |
|
410 ) |
|
411 { |
|
412 OstTrace0( TRACE_NORMAL, DROUTER_GETMAXDATASIZE_ENTRY, ">DRouter::GetMaxDataSize" ); |
|
413 |
|
414 C_TRACE( ( _T( "DRouter::GetMaxDataSize ->" ) ) ); |
|
415 ASSERT_DFCTHREAD_INEXT(); |
|
416 TInt excludeSize( iMaxFrameSize - ( ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_DATA ) ); |
|
417 // Set the data to be divisible by four. |
|
418 TInt allowedCount( excludeSize - ( excludeSize % 4 ) ); |
|
419 C_TRACE( ( _T( "DRouter::GetMaxDataSize %d <-" ), allowedCount ) ); |
|
420 |
|
421 OstTrace1( TRACE_NORMAL, DROUTER_GETMAXDATASIZE_EXIT, "<DRouter::GetMaxDataSize;allowedCount=%d", allowedCount ); |
|
422 return allowedCount; |
|
423 } |
|
424 |
|
425 // KErrNone, channelid with channel object open ok |
|
426 // KErrNotSupported, resource not supported or in use causes name_add_req to fail |
|
427 // KErrInUse, channelid opened by same channel object earlier |
|
428 // KErrAlreadyExists, channel opened by some other channel object earlier |
|
429 // In completechannelreq, set ~channel number as ~~channelnumber only if KErrNone or KErrInUse |
|
430 EXPORT_C void DRouter::Open( |
|
431 const TUint16 aChannel, |
|
432 const TUint16 aRequest, |
|
433 MIAD2ChannelApi* aCallback |
|
434 ) |
|
435 { |
|
436 OstTraceExt3( TRACE_NORMAL, DROUTER_OPEN_ENTRY, ">DRouter::Open;aChannel=%hx;aRequest=%hu;aCallback=%x", aChannel, aRequest, ( TUint )( aCallback ) ); |
|
437 |
|
438 |
|
439 C_TRACE( ( _T( "DRouter::Open 0x%x %d 0x%x ->" ), aChannel, aRequest, aCallback ) ); |
|
440 ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier19 << KFaultIdentifierShift ); |
|
441 ASSERT_DFCTHREAD_INEXT(); |
|
442 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | (TUint8)aChannel << KChannelNumberShift | EIADFaultIdentifier26 << KFaultIdentifierShift ); |
|
443 if( iConnectionStatus == EIADConnectionOk ) |
|
444 { |
|
445 // If not null channel is allready open. |
|
446 if( iChannelTable[ aChannel ].iChannel || |
|
447 iChannelTable[ aChannel ].iWaitingChannel ) |
|
448 { |
|
449 // If another channel tries to open already open channel. |
|
450 TRACE_WARNING( iChannelTable[ aChannel ].iChannel == aCallback, (TUint8)aChannel << KChannelNumberShift ); |
|
451 // If same object calling KErrInUser if other but same channel KErrAlreadyExists |
|
452 aCallback->CompleteChannelRequest( aRequest, ( iChannelTable[ aChannel ].iChannel == aCallback ? KErrInUse : KErrAlreadyExists ) ); |
|
453 } |
|
454 // Null so channel is not open, set !null to mark opened channel. |
|
455 else |
|
456 { |
|
457 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
458 const TBool drmChannel( ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ? ETrue : EFalse ); |
|
459 if( drmChannel ) |
|
460 { |
|
461 C_TRACE( ( _T( "DRouter::Open channel 0x%x drm 0x%x" ), aChannel, aCallback ) ); |
|
462 OstTraceExt1( TRACE_NORMAL, DROUTER_OPEN, "DRouter::Open DRM;aChannel=%hx", aChannel ); |
|
463 iChannelTable[ aChannel ].iWaitingChannel = aCallback; |
|
464 iChannelTable[ aChannel ].iType = EDrmOpen; |
|
465 SendDrmReq( aChannel ); |
|
466 } |
|
467 else |
|
468 { |
|
469 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
470 C_TRACE( ( _T( "DRouter::Open channel 0x%x normal 0x%x" ), aChannel, aCallback ) ); |
|
471 OstTraceExt1( TRACE_NORMAL, DUP1_DROUTER_OPEN, "DRouter::Open normal;aChannel=%hx", aChannel ); |
|
472 iChannelTable[ aChannel ].iChannel = aCallback; |
|
473 aCallback->CompleteChannelRequest( aRequest, KErrNone ); |
|
474 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
475 } |
|
476 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
477 } |
|
478 } |
|
479 else |
|
480 { |
|
481 C_TRACE( ( _T( "DRouter::Open not ready" ) ) ); |
|
482 OstTrace0( TRACE_NORMAL, DUP2_DROUTER_OPEN, "DRouter::Open Not ready" ); |
|
483 ASSERT_RESET_ALWAYS( !iChannelTable[ aChannel ].iWaitingChannel, EIADWrongRequest | EIADFaultIdentifier15 << KFaultIdentifierShift ); |
|
484 iChannelTable[ aChannel ].iWaitingChannel = aCallback; |
|
485 iChannelTable[ aChannel ].iType = ( ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ? |
|
486 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
487 EDrmOpen : ENormalOpen ); |
|
488 #else |
|
489 ENormalOpen : ENormalOpen ); |
|
490 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
491 } |
|
492 C_TRACE( ( _T( "DRouter::Open 0x%x <-" ), aChannel ) ); |
|
493 |
|
494 OstTraceExt1( TRACE_NORMAL, DROUTER_OPEN_EXIT, "<DRouter::Open;aChannel=%hx", aChannel ); |
|
495 |
|
496 } |
|
497 |
|
498 // With resource and media |
|
499 EXPORT_C void DRouter::Open( |
|
500 const TUint16 aChannel, |
|
501 const TUint16 aRequest, |
|
502 const TDesC8& aOpenInfo, |
|
503 MIAD2ChannelApi* aCallback |
|
504 ) |
|
505 { |
|
506 OstTraceExt4( TRACE_NORMAL, DUP1_DROUTER_OPEN_ENTRY, ">DRouter::Open;aChannel=%hx;aRequest=%hu;aOpenInfo=%x;aCallback=%x", aChannel, aRequest, ( TUint )&( aOpenInfo ), ( TUint )( aCallback ) ); |
|
507 //TODO: open with resource: change not to be permit one and in closing pn_name_remove_req. |
|
508 C_TRACE( ( _T( "DRouter::Open 0x%x %d 0x%x 0x%x ->" ), aChannel, aRequest, &aOpenInfo, aCallback ) ); |
|
509 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
510 ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier20 << KFaultIdentifierShift ); |
|
511 ASSERT_DFCTHREAD_INEXT(); |
|
512 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | (TUint8)aChannel << KChannelNumberShift | EIADFaultIdentifier27 << KFaultIdentifierShift ); |
|
513 if( iConnectionStatus == EIADConnectionOk ) |
|
514 { |
|
515 // If not null channel is allready open. |
|
516 if( iChannelTable[ aChannel ].iChannel || |
|
517 iChannelTable[ aChannel ].iWaitingChannel ) |
|
518 { |
|
519 // If another channel tries to open already open channel. |
|
520 OstTrace0( TRACE_NORMAL, DUP4_DROUTER_OPEN, "DRouter::Open already open channel" ); |
|
521 TRACE_WARNING( iChannelTable[ aChannel ].iChannel == aCallback, (TUint8)aChannel << KChannelNumberShift ); |
|
522 aCallback->CompleteChannelRequest( aRequest, ( iChannelTable[ aChannel ].iChannel == aCallback ? KErrInUse : KErrAlreadyExists ) ); |
|
523 } |
|
524 // Null so channel is not open, set !null to mark opened channel. |
|
525 else |
|
526 { |
|
527 OstTrace0( TRACE_NORMAL, DUP3_DROUTER_OPEN, "DRouter::Open with resource" ); |
|
528 C_TRACE( ( _T( "DRouter::Open channel with resource 0x%x 0x%x" ), aChannel, aCallback ) ); |
|
529 iChannelTable[ aChannel ].iWaitingChannel = aCallback; |
|
530 iChannelTable[ aChannel ].iType = ENameAddOpen; |
|
531 SendPnsNameAddReq( aChannel, aOpenInfo ); |
|
532 } |
|
533 } |
|
534 else |
|
535 { |
|
536 C_TRACE( ( _T( "DRouter::Open with resource not ready" ) ) ); |
|
537 // Opening with resource Id is not supported before IAD is initialized. |
|
538 // If needed, client can open channel without resource Id and send PNS_NAME_ADD_REQ after |
|
539 // channel open is actually completed |
|
540 TRACE_ASSERT_INFO( 0, (TUint8)aChannel<<KChannelNumberShift ); |
|
541 ASSERT_RESET_ALWAYS( iBootDone, EIADNotSupported | EIADFaultIdentifier5 << KFaultIdentifierShift | (TUint8)aChannel<<KChannelNumberShift ); |
|
542 } |
|
543 #else // NCP_COMMON_BRIDGE_FAMILY |
|
544 // Some maniac from modem sw decided to remove name service in the last meters, hip-hip hurray inform which clients use resource from open to help debug! |
|
545 TRACE_ASSERT_INFO( 0, (TUint8)aChannel<<KChannelNumberShift ); |
|
546 // Treat as normal open to enable the sending NOTE! resource is not functioning!! |
|
547 Open( aChannel, aRequest, aCallback ); |
|
548 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
549 |
|
550 C_TRACE( ( _T( "DRouter::Open 0x%x <-" ), aChannel ) ); |
|
551 |
|
552 OstTraceExt1( TRACE_NORMAL, DUP1_DROUTER_OPEN_EXIT, "<DRouter::Open;aChannel=%hx", aChannel ); |
|
553 } |
|
554 |
|
555 #if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95) |
|
556 EXPORT_C TInt DRouter::Loan( |
|
557 const TUint16 aChannel, |
|
558 const TUint16 aRequest, |
|
559 MIAD2ChannelApi* aCallback |
|
560 ) |
|
561 { |
|
562 |
|
563 C_TRACE( ( _T( "DRouter::Loan 0x%x %d 0x%x ->" ), aChannel, aRequest, aCallback ) ); |
|
564 OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_LOAN_ENTRY, ">DRouter::Loan;aChannel=%hx;aRequest=%hu;aCallback=%x", aChannel, aRequest, ( TUint )( aCallback ) ); |
|
565 ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier19 << KFaultIdentifierShift );// TODO |
|
566 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | EIADFaultIdentifier11 << KFaultIdentifierShift );// TODO |
|
567 ASSERT_DFCTHREAD_INEXT(); |
|
568 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, aChannel ); |
|
569 TInt error( KErrNone ); |
|
570 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
571 // Is connection lost. |
|
572 error = ( iConnectionStatus == EIADConnectionNotOk ) ? KErrNotSupported : error; |
|
573 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
574 // Is loaning a resticted channel. |
|
575 error = ( KErrNone == error && ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ) ? KErrNotSupported : error; |
|
576 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
577 // Is loaning it self? |
|
578 error = ( KErrNone == error && ( iChannelTable[ aChannel ].iChannel == aCallback ) ) ? KErrNotSupported : error; |
|
579 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
580 // Is loaning currently not open channel. |
|
581 error = ( KErrNone == error && ( !iChannelTable[ aChannel ].iChannel ) ) ? KErrNotSupported : error; |
|
582 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
583 // Is loaning already loaned channel. |
|
584 error = ( KErrNone == error && ( iChannelTable[ aChannel ].iType == ELoan ) ) ? KErrAlreadyExists : error; |
|
585 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
586 if( KErrNone == error ) |
|
587 { |
|
588 // Who is loaning whose channel. |
|
589 C_TRACE( ( _T( "DRouter::Loan loaning ch 0x%x from chObj 0x%x to chObj 0x%x setting previous as waiting" ), aChannel, iChannelTable[ aChannel ].iChannel, aCallback ) ); |
|
590 OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_LOAN, "DRouter::Loan loaning;aChannel=%hx;channelPtr=%hx;callbackPtr=%hx", aChannel, (TUint)iChannelTable[ aChannel ].iChannel, (TUint)aCallback ); |
|
591 iChannelTable[ aChannel ].iWaitingChannel = iChannelTable[ aChannel ].iChannel;// TEST WITH WAITING CHANNEL FIRST |
|
592 iChannelTable[ aChannel ].iType = ELoan; |
|
593 iChannelTable[ aChannel ].iChannel = aCallback; |
|
594 iPipeHandler->PipeLoaned( aChannel, aCallback ); |
|
595 } |
|
596 #endif |
|
597 C_TRACE( ( _T( "DRouter::Loan 0x%x %d<-" ), aChannel, error ) ); |
|
598 OstTraceExt2( TRACE_NORMAL, DUP1_DROUTER_LOAN_EXIT, "<DRouter::Loan;aChannel=%hx;error=%d", aChannel, error ); |
|
599 return error; |
|
600 |
|
601 } |
|
602 |
|
603 EXPORT_C TInt DRouter::ReturnLoan( |
|
604 const TUint16 aChannel, |
|
605 const TUint16 aRequest, |
|
606 MIAD2ChannelApi* aCallback |
|
607 ) |
|
608 { |
|
609 |
|
610 C_TRACE( ( _T( "DRouter::ReturnLoan 0x%x %d 0x%x ->" ), aChannel, aRequest, aCallback ) ); |
|
611 OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_RETURNLOAN_ENTRY, ">DRouter::ReturnLoan;aChannel=%hx;aRequest=%hu;aCallback=%x", aChannel, aRequest, ( TUint )( aCallback ) ); |
|
612 ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier19 << KFaultIdentifierShift );// TODO |
|
613 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | EIADFaultIdentifier11 << KFaultIdentifierShift );// TODO |
|
614 ASSERT_DFCTHREAD_INEXT(); |
|
615 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, aChannel ); |
|
616 TInt error( KErrNone ); |
|
617 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
618 // Is connection lost. |
|
619 error = ( iConnectionStatus == EIADConnectionNotOk ) ? KErrNotSupported : error; |
|
620 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
621 // Is loaning a resticted channel. |
|
622 error = ( KErrNone == error && ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ) ? KErrNotSupported : error; |
|
623 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
624 // Is retuning someone elses loan? |
|
625 error = ( KErrNone == error && ( iChannelTable[ aChannel ].iChannel != aCallback ) ) ? KErrNotSupported : error; |
|
626 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
627 // Is returning currently not open channel. |
|
628 error = ( KErrNone == error && ( !iChannelTable[ aChannel ].iChannel ) ) ? KErrNotSupported : error; |
|
629 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
630 // Is returning a not loaned channel. |
|
631 error = ( KErrNone == error && ( iChannelTable[ aChannel ].iType != ELoan ) ) ? KErrAlreadyExists : error; |
|
632 TRACE_ASSERT_INFO( KErrNone == error, error ); |
|
633 if( KErrNone == error ) |
|
634 { |
|
635 // Who is loaning whose channel. |
|
636 C_TRACE( ( _T( "DRouter::ReturnLoan returning loan ch 0x%x to chObj 0x%x from chObj 0x%x setting previous as waiting" ), aChannel, iChannelTable[ aChannel ].iWaitingChannel, aCallback ) ); |
|
637 OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_RETURNLOAN, "DRouter::Loan loaning;aChannel=%hx;waitingchannelPtr=%hx;callbackPtr=%hx", aChannel, (TUint)iChannelTable[ aChannel ].iWaitingChannel, (TUint)aCallback ); |
|
638 iPipeHandler->PipeLoanReturned( aChannel, iChannelTable[ aChannel ].iWaitingChannel ); |
|
639 } |
|
640 #endif |
|
641 C_TRACE( ( _T( "DRouter::ReturnLoan 0x%x %d<-" ), aChannel, error ) ); |
|
642 OstTraceExt2( TRACE_NORMAL, DUP1_DROUTER_RETURNLOAN_EXIT, "<DRouter::ReturnLoan;aChannel=%hx;error=%d", aChannel, error ); |
|
643 return error; |
|
644 |
|
645 } |
|
646 #endif |
|
647 |
|
648 EXPORT_C TInt DRouter::OrderIndication( |
|
649 TDes8& anOrder, |
|
650 const TUint16 aCh, |
|
651 const TBool a32Bit |
|
652 ) |
|
653 { |
|
654 OstTraceExt3( TRACE_NORMAL, DROUTER_ORDERINDICATION_ENTRY, ">DRouter::OrderIndication;anOrder=%x;aCh=%hx;a32Bit=%d", ( TUint )&( anOrder ), aCh, a32Bit ); |
|
655 |
|
656 C_TRACE( ( _T( "DRouter::OrderIndication 0x%x 0x%x %d ->" ), &anOrder, aCh, a32Bit ) ); |
|
657 ASSERT_DFCTHREAD_INEXT(); |
|
658 TInt orderLength( anOrder.Length() ); |
|
659 TInt msgOk = ( 0 == orderLength ) ? KErrBadDescriptor : KErrNone; |
|
660 TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift ); |
|
661 // Should be divisible by two if not 32 bit. |
|
662 msgOk = ( ( msgOk == KErrNone && ( !a32Bit && 0 != orderLength % 2 ) ) ? KErrBadDescriptor : msgOk ); |
|
663 TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift ); |
|
664 // Should be divisible by five if 32 bit. |
|
665 msgOk = ( ( msgOk == KErrNone && ( a32Bit && 0 != orderLength % 5 ) ) ? KErrBadDescriptor : msgOk ); |
|
666 TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift ); |
|
667 msgOk = ( ( msgOk == KErrNone && ( orderLength > GetMaxDataSize() ) ) ? KErrUnderflow : msgOk ); |
|
668 TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift ); |
|
669 if( KErrNone == msgOk ) |
|
670 { |
|
671 msgOk = iIndicationHandler->Subscribe( anOrder, aCh, a32Bit ); |
|
672 TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift ); |
|
673 } |
|
674 C_TRACE( ( _T( "DRouter::OrderIndication 0x%x 0x%x %d %d <-" ), &anOrder, aCh, a32Bit, msgOk ) ); |
|
675 |
|
676 OstTrace1( TRACE_NORMAL, DROUTER_ORDERINDICATION, "<DRouter::OrderIndication;msgOk=%x", msgOk ); |
|
677 return msgOk; |
|
678 } |
|
679 |
|
680 EXPORT_C TInt DRouter::SendMessage( |
|
681 TDes8& aMessage, |
|
682 const TUint16 aCh |
|
683 ) |
|
684 { |
|
685 |
|
686 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDMESSAGE_ENTRY, "<DRouter::SendMessage;aMessage=%x;aCh=%hx", ( TUint )&( aMessage ), aCh ); |
|
687 OstTraceExt1( TRACE_NORMAL, DUP4_DROUTER_SENDMESSAGE, "DRouter::SendMessage;aCh=%hx", aCh ); |
|
688 C_TRACE( ( _T( "DRouter::SendMessage 0x%x 0x%x ->" ), &aMessage, aCh ) ); |
|
689 ASSERT_RESET_ALWAYS( iMaxFrameSize != 0x0000, EIADCmtConnectionNotInit ); |
|
690 TInt error( ValiDateIsiMessage( aMessage ) ); |
|
691 error = ( KErrNone == error && iConnectionStatus != EIADConnectionOk ) ? KErrNotReady : error; |
|
692 if( KErrNone == error ) |
|
693 { |
|
694 ASSERT_RESET_ALWAYS( aCh != KNotInitializedChannel, EIADWrongParameter | EIADFaultIdentifier12 << KFaultIdentifierShift ); |
|
695 C_TRACE( ( _T( "DRouter::SendMessage sending 0x%x" ), &aMessage ) ); |
|
696 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDMESSAGE, "DRouter::SendMessage;error=%d;aCh=%hx", error, aCh ); |
|
697 |
|
698 SetSenderInfo( aMessage, aCh ); |
|
699 const TUint8* msgBlockPtr( aMessage.Ptr() ); |
|
700 // TODO: Simplify this |
|
701 ASSERT_RESET_ALWAYS( aMessage.Length() > ISI_HEADER_OFFSET_RESOURCEID, EIADOverTheLimits | EIADFaultIdentifier2 << KFaultIdentifierShift ); |
|
702 if( msgBlockPtr[ ISI_HEADER_OFFSET_RESOURCEID ] == PN_PIPE && msgBlockPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == THIS_DEVICE ) |
|
703 { |
|
704 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
705 // This shall send the message and deallocate it too. |
|
706 error = iPipeHandler->SendPipeMessage( aMessage, aCh ); |
|
707 #endif |
|
708 if( error != KErrNone ) |
|
709 { |
|
710 // Deallocate the block. |
|
711 this->DeAllocateBlock( aMessage ); |
|
712 } |
|
713 } |
|
714 else |
|
715 { |
|
716 // Route indication to possible subscribers in this device |
|
717 if( GET_RECEIVER_OBJ( msgBlockPtr ) == PN_OBJ_EVENT_MULTICAST && |
|
718 IS_DEV_HOST( msgBlockPtr[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] ) ) |
|
719 { |
|
720 DATA_DUMP_TRACE( aMessage, ETrue ); |
|
721 OstTraceData( TRACE_ISIMSG, DROUTER_SENDMESSAGE_DATA, "DRouter::SendMsg indication TX: %hx", aMessage.Ptr(), aMessage.Length() ); |
|
722 C_TRACE( ( _T( "DRouter::SendMessage routing indication to device PN_DEV_SOS 0x%x" ), &aMessage ) ); |
|
723 OstTrace0( TRACE_NORMAL, DUP2_DROUTER_SENDMESSAGE, "DRouter::SendMessage indication to PN_DEV_SOS" ); |
|
724 TDes8& tmpIndication = AllocateBlock( aMessage.Length() ); |
|
725 tmpIndication.SetLength( aMessage.Length() ); |
|
726 tmpIndication.Copy( aMessage ); |
|
727 TUint8* indicationPtr = const_cast<TUint8*>( tmpIndication.Ptr() ); |
|
728 SET_RECEIVER_DEV( indicationPtr, THIS_DEVICE ); |
|
729 SET_RECEIVER_OBJ( indicationPtr, KIADEventSubscriptionObjId ); |
|
730 this->MessageReceived( tmpIndication ); |
|
731 } |
|
732 // The IST shall deallocate the block when it's approriate to do. |
|
733 C_TRACE( ( _T( "DRouter::SendMessage sending 0x%x" ), &aMessage ) ); |
|
734 OstTrace1( TRACE_NORMAL, DUP3_DROUTER_SENDMESSAGE, "DRouter::SendMessage;aMessage=%x", (TUint)&(aMessage )); |
|
735 error = SendMsg( aMessage ); |
|
736 }//PIPE |
|
737 } |
|
738 else |
|
739 { |
|
740 C_TRACE( ( _T( "DRouter::SendMessage not sending due error 0x%x %d %d" ), &aMessage, aCh, error ) ); |
|
741 OstTraceExt2( TRACE_NORMAL, DUP1_DROUTER_SENDMESSAGE, "DRouter::SendMessage;aCh=%hx;error=%d", aCh, error ); |
|
742 // Deallocate the block. |
|
743 TRACE_ASSERT_INFO( 0, (TUint8)aCh<<KChannelNumberShift | (TUint8)error ); |
|
744 this->DeAllocateBlock( aMessage ); |
|
745 // TODO: who should NULL the block? IST or IAD |
|
746 } |
|
747 C_TRACE( ( _T( "DRouter::SendMessage 0x%x %d %d <-" ), &aMessage, aCh, error ) ); |
|
748 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDMESSAGE_EXIT, "<DRouter::SendMessage;aCh=%hx;error=%d", aCh, error ); |
|
749 return error; |
|
750 |
|
751 } |
|
752 |
|
753 EXPORT_C TInt DRouter::SendIndication( |
|
754 TDes8& aMessage, |
|
755 const TUint16 aCh |
|
756 ) |
|
757 { |
|
758 |
|
759 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDINDICATION_ENTRY, ">DRouter::SendIndication;aMessage=%x;aCh=%hx", ( TUint )&( aMessage ), aCh ); |
|
760 C_TRACE( ( _T( "DRouter::SendIndication 0x%x 0x%x ->" ), &aMessage, aCh ) ); |
|
761 TUint8* msgPtr = const_cast<TUint8*>( aMessage.Ptr() ); |
|
762 SET_RECEIVER_DEV( msgPtr,OTHER_DEVICE_1 ); |
|
763 SET_RECEIVER_OBJ( msgPtr,PN_OBJ_EVENT_MULTICAST ); |
|
764 TInt error( SendMessage( aMessage, aCh ) ); |
|
765 C_TRACE( ( _T( "DRouter::SendIndication 0x%x 0x%x %d <-" ), &aMessage, aCh, error ) ); |
|
766 OstTrace1( TRACE_NORMAL, DROUTER_SENDINDICATION_EXIT, "<DRouter::SendIndication;error=%d", error ); |
|
767 return error; |
|
768 |
|
769 } |
|
770 |
|
771 // From end |
|
772 |
|
773 void DRouter::NotifyObjLayerConnStatDfc( |
|
774 TAny* aPtr |
|
775 ) |
|
776 { |
|
777 OstTrace1( TRACE_NORMAL, DROUTER_NOTIFYOBJLAYERCONNSTATDFC_ENTRY, ">DRouter::NotifyObjLayerConnStatDfc;aPtr=%x", ( TUint )( aPtr ) ); |
|
778 |
|
779 C_TRACE( ( _T( "DRouter::NotifyObjLayerConnStatDfc ->" ) ) ); |
|
780 DRouter* self = reinterpret_cast<DRouter*>( aPtr ); |
|
781 self->NotifyObjLayerConnStat( self->iConnectionStatus ); |
|
782 C_TRACE( ( _T( "DRouter::NotifyObjLayerConnStatDfc to %d <-" ), self->iConnectionStatus ) ); |
|
783 |
|
784 OstTrace1( TRACE_NORMAL, DROUTER_NOTIFYOBJLAYERCONNSTATDFC_EXIT, "<DRouter::NotifyObjLayerConnStatDfc;self->iConnectionStatus=%x", self->iConnectionStatus ); |
|
785 } |
|
786 |
|
787 void DRouter::NotifyObjLayerConnStat( |
|
788 const TIADConnectionStatus aStatus |
|
789 ) |
|
790 { |
|
791 OstTrace1( TRACE_NORMAL, DROUTER_NOTIFYOBJLAYERCONNSTAT_ENTRY, ">DRouter::NotifyObjLayerConnStat;aStatus=%x", ( TUint )&( aStatus ) ); |
|
792 |
|
793 C_TRACE( ( _T( "DRouter::NotifyObjLayerConnStat %d ->" ), aStatus ) ); |
|
794 ASSERT_DFCTHREAD_INEXT(); |
|
795 for( TUint16 i( 0 ); i < EIADSizeOfChannels; ++i ) |
|
796 { |
|
797 if( iChannelTable[ i ].iChannel ) |
|
798 { |
|
799 C_TRACE( ( _T( "DRouter::NotifyObjLayerConnStat ch %d ptr 0x%x" ), i, iChannelTable[ i ].iChannel ) ); |
|
800 OstTraceExt2( TRACE_NORMAL, DUP1_DROUTER_NOTIFYOBJLAYERCONNSTAT, "DRouter::NotifyObjLayerConnStat;i=%hx;iChannelTable[ i ].iChannel=%x", i,( TUint ) ( iChannelTable[ i ].iChannel ) ); |
|
801 iChannelTable[ i ].iChannel->NotifyConnectionStatus( aStatus ); |
|
802 } |
|
803 // TODO: If we need open to be waiting until connection status is ok, set waiting here. |
|
804 } |
|
805 C_TRACE( ( _T( "DRouter::NotifyObjLayerConnStat %d <-" ), aStatus ) ); |
|
806 OstTrace0( TRACE_NORMAL, DROUTER_NOTIFYOBJLAYERCONNSTAT_EXIT, "<DRouter::NotifyObjLayerConnStat" ); |
|
807 } |
|
808 |
|
809 // Used internally in IAD. |
|
810 // Can be called in 1..N thread contextes and returns immediately. |
|
811 void DRouter::MessageReceived( |
|
812 TDes8& aMsg |
|
813 ) |
|
814 { |
|
815 |
|
816 OstTrace1( TRACE_NORMAL, DROUTER_MESSAGERECEIVED_ENTRY, ">DRouter::MessageReceived;aMsg=%x", ( TUint )&( aMsg ) ); |
|
817 C_TRACE( ( _T( "DRouter::MessageReceived 0x%x ->" ), &aMsg ) ); |
|
818 // Let MaxLength to be the length of the allocated block. (IST (SSI&SISA) can work differently. |
|
819 // SISA set length and maxlength according to ISI msg length, but SSI set length according to block length |
|
820 // Block length in SSI at the moment always %4. |
|
821 // Set the length of the descriptor to ISI message length + PN_HEADER_SIZE |
|
822 // TODO : harmonize these IST differencies. |
|
823 TInt len( GET_LENGTH( aMsg ) ); |
|
824 len += PN_HEADER_SIZE; |
|
825 aMsg.SetLength( len ); |
|
826 iCommonRxQueue->Add( aMsg ); |
|
827 iCommonRxDfc->Enque(); |
|
828 C_TRACE( ( _T( "DRouter::MessageReceived 0x%x <-" ), &aMsg ) ); |
|
829 OstTrace0( TRACE_NORMAL, DROUTER_MESSAGERECEIVED_EXIT, "<DRouter::MessageReceived" ); |
|
830 |
|
831 } |
|
832 |
|
833 //PRIVATES |
|
834 |
|
835 void DRouter::HandleIsiMessage( |
|
836 TDes8& aMsg |
|
837 ) |
|
838 { |
|
839 OstTrace1( TRACE_NORMAL, DROUTER_HANDLEISIMESSAGE_ENTRY, ">DRouter::HandleIsiMessage;aMsg=%x", ( TUint )&( aMsg ) ); |
|
840 |
|
841 C_TRACE( ( _T( "DRouter::HandleIsiMessage 0x%x ->" ), &aMsg ) ); |
|
842 const TUint16 rcvObjId( GET_RECEIVER_OBJ( aMsg ) ); |
|
843 C_TRACE( ( _T( "DRouter::HandleIsiMessage rcvObjId 0x%x" ), rcvObjId ) ); |
|
844 ASSERT_RESET_ALWAYS( rcvObjId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)rcvObjId << KChannelNumberShift | EIADFaultIdentifier22 << KFaultIdentifierShift ); |
|
845 if( iChannelTable[ rcvObjId ].iChannel ) |
|
846 { |
|
847 iChannelTable[ rcvObjId ].iChannel->ReceiveMsg( aMsg ); |
|
848 // DeAllocation done by the channel after writing to client's address space. |
|
849 } |
|
850 else |
|
851 { |
|
852 SendCommIsaEntityNotReachableResp( aMsg ); |
|
853 // Not going to anywhere deallocate. |
|
854 DeAllocateBlock( aMsg ); |
|
855 } |
|
856 C_TRACE( ( _T( "DRouter::HandleIsiMessage 0x%x <-" ), &aMsg ) ); |
|
857 |
|
858 OstTrace0( TRACE_NORMAL, DROUTER_HANDLEISIMESSAGE_EXIT, "<DRouter::HandleIsiMessage" ); |
|
859 } |
|
860 |
|
861 |
|
862 void DRouter::HandlePipeMessage( |
|
863 TDes8& aMsg |
|
864 ) |
|
865 { |
|
866 OstTrace1( TRACE_NORMAL, DROUTER_HANDLEPIPEMESSAGE_ENTRY, ">DRouter::HandlePipeMessage;aMsg=%x", ( TUint )&( aMsg ) ); |
|
867 |
|
868 C_TRACE( ( _T( "DRouter::HandlePipeMessage 0x%x ->" ), &aMsg ) ); |
|
869 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
870 const TUint16 rcvObjId( GET_RECEIVER_OBJ( aMsg ) ); |
|
871 C_TRACE( ( _T( "DRouter::HandlePipeMessage rcvObjId 0x%x" ), rcvObjId ) ); |
|
872 ASSERT_RESET_ALWAYS( rcvObjId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)rcvObjId << KChannelNumberShift| EIADFaultIdentifier25 << KFaultIdentifierShift ); |
|
873 MIAD2ChannelApi* openChannel = iChannelTable[ rcvObjId ].iChannel; |
|
874 if( openChannel ) |
|
875 { |
|
876 // TODO: is it ok to give channel from here? |
|
877 iPipeHandler->ReceivePipeMessage( aMsg, openChannel ); |
|
878 // DeAllocation done by the pipehandler or someone who it frwd's the message. |
|
879 } |
|
880 else |
|
881 { |
|
882 // COMM_ISA_ENTITY_NOT_REACHABLE_RESP NOT SEND TO PIPE MESSAGES |
|
883 TRACE_ASSERT_INFO( 0, (TUint8)rcvObjId<<KChannelNumberShift ); |
|
884 // Not going to anywhere deallocate. |
|
885 for( TInt i( 0 ); i < aMsg.Length(); i++ ) |
|
886 { |
|
887 Kern::Printf( "%d 0x%x", i, aMsg.Ptr()[ i ] ); |
|
888 } |
|
889 DeAllocateBlock( aMsg ); |
|
890 } |
|
891 #endif |
|
892 C_TRACE( ( _T( "DRouter::HandlePipeMessage 0x%x <-" ), &aMsg ) ); |
|
893 |
|
894 OstTrace0( TRACE_NORMAL, DROUTER_HANDLEPIPEMESSAGE_EXIT, "<DRouter::HandlePipeMessage" ); |
|
895 } |
|
896 |
|
897 void DRouter::HandleMediaMessage( |
|
898 TDes8& aMsg |
|
899 ) |
|
900 { |
|
901 OstTrace1( TRACE_NORMAL, DROUTER_HANDLEMEDIAMESSAGE_ENTRY, ">DRouter::HandleMediaMessage;aMsg=%x", ( TUint )&( aMsg ) ); |
|
902 |
|
903 C_TRACE( ( _T( "DRouter::HandleMediaMessage 0x%x ->" ), &aMsg ) ); |
|
904 TUint8 rcvObjId( 0x00); |
|
905 ASSERT_RESET_ALWAYS( aMsg.Length() > ISI_HEADER_OFFSET_MEDIA, EIADOverTheLimits | EIADFaultIdentifier3 << KFaultIdentifierShift ); |
|
906 switch( aMsg[ ISI_HEADER_OFFSET_MEDIA ] ) |
|
907 { |
|
908 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
909 case PN_MEDIA_USB: |
|
910 { |
|
911 C_TRACE( ( _T( "DRouter::HandleMediaMessage USB" ) ) ); |
|
912 OstTrace0( TRACE_NORMAL, DROUTER_HANDLEMEDIAMESSAGE_USB, "DRouter::HandleMediaMessage USB" ); |
|
913 rcvObjId = EIADNokiaUsbPhonetLink; |
|
914 break; |
|
915 } |
|
916 case PN_MEDIA_BT: |
|
917 { |
|
918 C_TRACE( ( _T( "DRouter::HandleMediaMessage BT" ) ) ); |
|
919 OstTrace0( TRACE_NORMAL, DROUTER_HANDLEMEDIAMESSAGE_BT, "DRouter::HandleMediaMessage BT" ); |
|
920 rcvObjId = EIADNokiaBtPhonetLink; |
|
921 break; |
|
922 } |
|
923 //TBR AFTER CMT ERROR CORRECTION : wk49 cellmo has correction, so remove this later on |
|
924 case PN_MEDIA_ROUTING_REQ: |
|
925 { |
|
926 // TODO: write an error! Someone is sending to APE with wrong media. |
|
927 // USB PDD |
|
928 TRACE_ASSERT_ALWAYS; |
|
929 rcvObjId = GET_RECEIVER_OBJ( aMsg ); |
|
930 Kern::Printf("Unknown message 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", aMsg[ 0 ], aMsg[ 1 ], aMsg[ 2 ], aMsg[ 3 ], aMsg[ 4 ], aMsg[ 5 ], aMsg[ 6 ], aMsg[ 7 ], aMsg[ 8 ], aMsg[ 9 ] ); |
|
931 break; |
|
932 } |
|
933 #endif |
|
934 //TBR AFTER CMT ERROR CORRECTION |
|
935 default: |
|
936 { |
|
937 rcvObjId = GET_RECEIVER_OBJ( aMsg ); |
|
938 ASSERT_RESET_ALWAYS( 0, EIADUnkownMedia | ( rcvObjId << KChannelNumberShift ) ); |
|
939 break; |
|
940 } |
|
941 } |
|
942 // TODO: UNIQUE |
|
943 ASSERT_RESET_ALWAYS( rcvObjId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)rcvObjId << KChannelNumberShift | EIADFaultIdentifier3 << KFaultIdentifierShift ); |
|
944 if( iChannelTable[ rcvObjId ].iChannel ) |
|
945 { |
|
946 iChannelTable[ rcvObjId ].iChannel->ReceiveMsg( aMsg ); |
|
947 // DeAllocation done by the channel after writing to client's address space. |
|
948 } |
|
949 else |
|
950 { |
|
951 SendCommIsaEntityNotReachableResp( aMsg ); |
|
952 // Not going to anywhere deallocate. |
|
953 DeAllocateBlock( aMsg ); |
|
954 } |
|
955 C_TRACE( ( _T( "DRouter::HandleMediaMessage 0x%x <-" ), &aMsg ) ); |
|
956 |
|
957 OstTrace0( TRACE_NORMAL, DROUTER_HANDLEMEDIAMESSAGE_EXIT, "<DRouter::HandleMediaMessage" ); |
|
958 } |
|
959 |
|
960 void DRouter::HandleControlMessage( |
|
961 TDes8& aMsg |
|
962 ) |
|
963 { |
|
964 OstTrace1( TRACE_NORMAL, DROUTER_HANDLECONTROLMESSAGE_ENTRY, ">DRouter::HandleControlMessage;aMsg=%x", ( TUint )&( aMsg ) ); |
|
965 |
|
966 C_TRACE( ( _T( "DRouter::HandleControlMessage 0x%x ->" ), &aMsg ) ); |
|
967 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
968 const TUint8* msgPtr( aMsg.Ptr() ); |
|
969 // Check legal msgs |
|
970 ASSERT_RESET_ALWAYS( msgPtr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_RESP_OFFSET_SUBFUNCTION ] == PNS_MEDIA_SPECIFIC_RESP, EIADInvalidCtrlMessage | EIADFaultIdentifier1 << KFaultIdentifierShift ); |
|
971 ASSERT_RESET_ALWAYS( msgPtr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_RESP_OFFSET_MEDIATOCTRL ] == PN_MEDIA_SOS, EIADInvalidCtrlMessage | EIADFaultIdentifier2 << KFaultIdentifierShift ); |
|
972 ASSERT_RESET_ALWAYS( msgPtr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_RESP_OFFSET_ERRORCODE ] == PN_MCTRL_NO_ERROR, EIADInvalidCtrlMessage | EIADFaultIdentifier3 << KFaultIdentifierShift ); |
|
973 ASSERT_RESET_ALWAYS( aMsg.Length() > CTRL_RESP_OFFSET_MESSAGEID, EIADOverTheLimits | EIADFaultIdentifier4 << KFaultIdentifierShift ); |
|
974 switch( msgPtr[ CTRL_RESP_OFFSET_MESSAGEID ] ) |
|
975 { |
|
976 case KIADCtrlConfResp: |
|
977 { |
|
978 // In MINI_OS case take the maximumdatasize amount from configuration message if bigger than "hat" constant. |
|
979 iMaxFrameSize = KIADMaxIsiMsgSize; |
|
980 #ifdef NCP_COMMON_MINIOS |
|
981 TUint16 confMsgSize = ( ( ( ( TUint16 )( msgPtr[ CTRL_CONF_RESP_OFFSET_SIZE_BYTE1 ] ) ) << 8 ) | ( ( TUint16 )( msgPtr[ CTRL_CONF_RESP_OFFSET_SIZE_BYTE2 ] ) ) ); |
|
982 // NOTE! This hat constant has relation to cmt side (sos_mm) if the const is changed in either place harmonize!! |
|
983 const TUint16 KSosProxyHatConst( 2140 ); |
|
984 iMaxFrameSize = ( confMsgSize > KSosProxyHatConst ? confMsgSize : KIADMaxIsiMsgSize ); |
|
985 ASSERT_RESET_ALWAYS( iMaxFrameSize <= confMsgSize, EIADConfigurationInvalid ); |
|
986 #endif |
|
987 // Datalink layer initialized, router layer is this and knows it, now inform obj layer clients. |
|
988 iConnectionStatus = EIADConnectionOk; |
|
989 iBootDone = ETrue; |
|
990 // Could call straight cause the context is the same thread (extension dfc) |
|
991 NotifyObjLayerConnStat( EIADConnectionOk ); |
|
992 // TODO: pns_name_add_req |
|
993 // Initialize channels to NULL when channel is opened !NULL. |
|
994 for( TInt i( 0 ); i < EIADSizeOfChannels; ++i ) |
|
995 { |
|
996 ASSERT_RESET_ALWAYS( !iChannelTable[ i ].iChannel, EIADChannelOpenedBeforePhysicalLayerInit ); |
|
997 C_TRACE( ( _T( "DRouter::HandleControlMessage loop TBR 0x%x" ), i ) ); |
|
998 if( iChannelTable[ i ].iWaitingChannel ) |
|
999 { |
|
1000 switch( iChannelTable[ i ].iType ) |
|
1001 { |
|
1002 case ENormalOpen: |
|
1003 { |
|
1004 C_TRACE( ( _T( "DRouter::HandleControlMessage booting ENormalOpen 0x%x" ), i ) ); |
|
1005 OstTrace1( TRACE_NORMAL, DROUTER_HANDLECONTROLMESSAGE_NORMAL_OPEN, "DRouter::HandleControlMessage;i=%x", i ); |
|
1006 |
|
1007 MIAD2ChannelApi* tmpChannel = iChannelTable[ i ].iWaitingChannel; |
|
1008 iChannelTable[ i ].iChannel = tmpChannel; |
|
1009 iChannelTable[ i ].iWaitingChannel = NULL; |
|
1010 iChannelTable[ i ].iChannel->CompleteChannelRequest( EIADAsyncOpen, KErrNone ); |
|
1011 break; |
|
1012 } |
|
1013 case EDrmOpen: |
|
1014 { |
|
1015 C_TRACE( ( _T( "DRouter::HandleControlMessage booting EDrmOpen 0x%x" ), i ) ); |
|
1016 OstTrace1( TRACE_NORMAL, DROUTER_HANDLECONTROLMESSAGE_DRM_OPEN, "DRouter::HandleControlMessage EDrmOpen;i=%x", i ); |
|
1017 |
|
1018 SendDrmReq( i ); |
|
1019 break; |
|
1020 } |
|
1021 case ENameAddOpen: |
|
1022 { |
|
1023 C_TRACE( ( _T( "DRouter::HandleControlMessage booting ENameAddOpen 0x%x" ), i ) ); |
|
1024 OstTrace1( TRACE_NORMAL, DROUTER_HANDLECONTROLMESSAGE_NAMEADD_OPEN, "DRouter::HandleControlMessage ENameAddOpen;i=%x", i ); |
|
1025 |
|
1026 // TODO: Not done yet, problem info get as param, channel to allocate deallocate after open complete? |
|
1027 ASSERT_RESET_ALWAYS( 0, EIADWrongParameter | EIADFaultIdentifier13 << KFaultIdentifierShift ); |
|
1028 break; |
|
1029 } |
|
1030 default: |
|
1031 { |
|
1032 ASSERT_RESET_ALWAYS( 0, EIADWrongParameter | EIADFaultIdentifier14 << KFaultIdentifierShift ); |
|
1033 break; |
|
1034 } |
|
1035 } |
|
1036 } |
|
1037 } |
|
1038 C_TRACE( ( _T( "DRouter::HandleControlMessage conf %d" ), iMaxFrameSize ) ); |
|
1039 break; |
|
1040 } |
|
1041 case KIADCtrlDrmResp: |
|
1042 { |
|
1043 const TUint16 channelId( msgPtr[ CTR_DRM_REQ_RESP_OFFSET_CHANNEL_ID ] ); |
|
1044 C_TRACE( ( _T( "DRouter::HandleControlMessage drm resp 0x%x" ), channelId ) ); |
|
1045 OstTrace0( TRACE_NORMAL, DROUTER_HANDLECONTROLMESSAGE_DRM_RESP, "DRouter::HandleControlMessage drm resp"); |
|
1046 |
|
1047 // Check is this waiting |
|
1048 ASSERT_RESET_ALWAYS( channelId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)channelId << KChannelNumberShift | EIADFaultIdentifier28 << KFaultIdentifierShift ); |
|
1049 TRACE_ASSERT_INFO( iChannelTable[ channelId ].iWaitingChannel, (TUint8)channelId<<KChannelNumberShift ); |
|
1050 TRACE_ASSERT_INFO( !iChannelTable[ channelId ].iChannel, (TUint8)channelId<<KChannelNumberShift ); |
|
1051 ASSERT_RESET_ALWAYS( iChannelTable[ channelId ].iType == EDrmOpen, EIADWrongTypeOfOpenPending | EIADFaultIdentifier1 << KFaultIdentifierShift ); |
|
1052 MIAD2ChannelApi* tmpChannel = iChannelTable[ channelId ].iWaitingChannel; |
|
1053 iChannelTable[ channelId ].iChannel = tmpChannel; |
|
1054 iChannelTable[ channelId ].iWaitingChannel = NULL; |
|
1055 C_TRACE( ( _T( "DRouter::HandleControlMessage drm resp 0x%x 0x%x 0x%x 0x%x" ), channelId, tmpChannel, iChannelTable[ channelId ].iChannel, &aMsg ) ); |
|
1056 iChannelTable[ channelId ].iChannel->CompleteChannelRequest( EIADAsyncOpen, KErrNone ); |
|
1057 break; |
|
1058 } |
|
1059 default: |
|
1060 { |
|
1061 // If wrong message reset! IF changed take care of completion of requests. |
|
1062 ASSERT_RESET_ALWAYS( 0, EIADInvalidCtrlMessage | EIADFaultIdentifier5 << KFaultIdentifierShift ); |
|
1063 break; |
|
1064 } |
|
1065 } // switch |
|
1066 #endif |
|
1067 // De-allocate cause not going anywhere else. |
|
1068 DeAllocateBlock( aMsg ); |
|
1069 C_TRACE( ( _T( "DRouter::HandleControlMessage 0x%x <-" ), &aMsg ) ); |
|
1070 |
|
1071 OstTrace0( TRACE_NORMAL, DROUTER_HANDLECONTROLMESSAGE_EXIT, "<DRouter::HandleControlMessage" ); |
|
1072 } |
|
1073 |
|
1074 // KErrBadDescriptor, if message length too small |
|
1075 // KErrUnderFlow, if message length too big. |
|
1076 // KErrCouldNotConnect, if receiver object is out of scope. |
|
1077 TInt DRouter::ValiDateIsiMessage( |
|
1078 TDes8& aMsg |
|
1079 ) |
|
1080 { |
|
1081 OstTrace1( TRACE_NORMAL, DROUTER_VALIDATEISIMESSAGE_ENTRY, ">DRouter::ValiDateIsiMessage;aMsg=%x", ( TUint )&( aMsg ) ); |
|
1082 |
|
1083 C_TRACE( ( _T( "DRouter::ValiDateIsiMessage ->" ) ) ); |
|
1084 const TUint16 descLength( aMsg.Length() ); |
|
1085 TInt msgOk( KErrNone ); |
|
1086 msgOk = ( ISI_HEADER_OFFSET_MESSAGEID >= descLength ) ? KErrBadDescriptor : msgOk; |
|
1087 TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk ); |
|
1088 // Get ISI message length after known that the descriptor is big enough. |
|
1089 const TUint8* msgPtr( aMsg.Ptr() ); |
|
1090 const TUint16 isiMsgLength( GET_LENGTH( msgPtr ) + PN_HEADER_SIZE ); |
|
1091 // TODO: Do we need the underflow information or is it BadDescriptor as good? If so remove msgok == KErrNone... |
|
1092 // If the descriptor length is less than ISI message length. |
|
1093 msgOk = ( ( msgOk == KErrNone && isiMsgLength > descLength ) ? KErrUnderflow : msgOk ); |
|
1094 TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk ); |
|
1095 // If the ISI message length is bigger that the largest supported. |
|
1096 msgOk = ( ( msgOk == KErrNone && isiMsgLength > KIADMaxIsiMsgSize ) ? KErrUnderflow : msgOk ); |
|
1097 TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk ); |
|
1098 // If the ISI message length with PN_HEADER_SIZE is less or equal than ISI_HEADER_OFFSET_MESSAGEID. |
|
1099 msgOk = ( ( msgOk == KErrNone && isiMsgLength <= ISI_HEADER_OFFSET_MESSAGEID ) ? KErrUnderflow : msgOk ); |
|
1100 TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk ); |
|
1101 TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk ); |
|
1102 TRACE_ASSERT_INFO( msgOk == KErrNone, isiMsgLength ); |
|
1103 TRACE_ASSERT_INFO( msgOk == KErrNone, descLength ); |
|
1104 |
|
1105 // Check is receiver object valid if going from SOS<->SOS. |
|
1106 msgOk = ( ( msgOk == KErrNone && ( GET_RECEIVER_DEV( msgPtr ) == THIS_DEVICE && GET_RECEIVER_OBJ( msgPtr ) > EIADSizeOfChannels ) ) ? KErrCouldNotConnect : msgOk ); |
|
1107 TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk ); |
|
1108 // TODO: checking that receiver object is ok in SOS<->ISA cases. |
|
1109 C_TRACE( ( _T( "DRouter::ValiDateIsiMessage <- %d" ), msgOk ) ); |
|
1110 |
|
1111 |
|
1112 OstTrace1( TRACE_NORMAL, DROUTER_VALIDATEISIMESSAGE_EXIT, "<DRouter::ValiDateIsiMessage;msgOk=%x", msgOk ); |
|
1113 return msgOk; |
|
1114 } |
|
1115 |
|
1116 void DRouter::CheckRouting( |
|
1117 DRouter& aTmp, |
|
1118 TDes8& aMsg |
|
1119 ) |
|
1120 { |
|
1121 |
|
1122 ASSERT_DFCTHREAD_INEXT(); |
|
1123 const TUint8* msg( aMsg.Ptr() ); |
|
1124 OstTrace1( TRACE_NORMAL, DROUTER_CHECKROUTING_ENTRY, ">DRouter::CheckRouting;aMsg=%x", ( TUint )( msg ) ); |
|
1125 C_TRACE( ( _T( "DRouter::CheckRouting 0x%x 0x%x ->" ), msg, msg[ ISI_HEADER_OFFSET_RESOURCEID ] ) ); |
|
1126 TRoutingRule route( ENotKnownMsg ); |
|
1127 // Message to symbian side (media sos). |
|
1128 if( msg[ ISI_HEADER_OFFSET_MEDIA ] == PN_MEDIA_SOS ) |
|
1129 { |
|
1130 if( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] == THIS_DEVICE ) |
|
1131 { |
|
1132 switch( msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] ) |
|
1133 { |
|
1134 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1135 // Router <-> SOSMM |
|
1136 case KIADObjId: |
|
1137 { |
|
1138 // Name add resp, drm or conf |
|
1139 ASSERT_RESET_ALWAYS( msg[ ISI_HEADER_OFFSET_RESOURCEID ] == PN_NAMESERVICE || msg[ ISI_HEADER_OFFSET_RESOURCEID ] == PN_MEDIA_CONTROL, EIADWrongParameter | msg[ ISI_HEADER_OFFSET_RESOURCEID ] ); |
|
1140 route = ( msg[ ISI_HEADER_OFFSET_RESOURCEID ] == PN_NAMESERVICE ) ? EPnNameAddRespMsg : EControlMsg; |
|
1141 break; |
|
1142 } |
|
1143 #endif |
|
1144 // Indication |
|
1145 case KIADEventSubscriptionObjId: |
|
1146 { |
|
1147 ASSERT_RESET_ALWAYS( msg[ ISI_HEADER_OFFSET_RESOURCEID ] != PN_PIPE, EIADWrongParameter | msg[ ISI_HEADER_OFFSET_RESOURCEID ] ); |
|
1148 route = EIndicationMsg; |
|
1149 break; |
|
1150 } |
|
1151 // Any other message. |
|
1152 default: |
|
1153 { |
|
1154 // Indication message. Receiver object equals to event subscription obj id (0xfc). |
|
1155 route = ( msg[ ISI_HEADER_OFFSET_RESOURCEID ] == PN_PIPE ) ? EPipeMsg : EIsiMsg; |
|
1156 break; |
|
1157 } |
|
1158 } |
|
1159 } |
|
1160 else if ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] == PN_DEV_GLOBAL )// TODO: This (PN_DEV_GLOBAL) should be removed from Bridge when modem SW MCE Server is ok |
|
1161 { |
|
1162 #ifdef MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD // TODO: To be removed depends on modem sw version MCE server |
|
1163 if ( aTmp.iBootDone ) |
|
1164 { |
|
1165 #endif // MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD |
|
1166 C_TRACE( ( _T( "DRouter::CheckRouting message to PN_DEV_GLOBAL -> EIndicationMsg" ) ) ); |
|
1167 OstTrace0( TRACE_NORMAL, DROUTER_CHECKROUTING_PN_DEV_GLOBAL, "DRouter::CheckRouting PN_DEV_GLOBAL -> EIndicationMsg"); |
|
1168 TUint8* ptr = const_cast<TUint8*>( msg ); |
|
1169 SET_RECEIVER_DEV( ptr, THIS_DEVICE ); |
|
1170 route = EIndicationMsg; |
|
1171 } |
|
1172 #ifdef MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD |
|
1173 #include <mceisi.h> |
|
1174 else |
|
1175 { |
|
1176 Kern::Printf("0x%x 0x%x", msg[ ISI_HEADER_SIZE + MCE_MODEM_STATE_IND_OFFSET_MESSAGEID ], msg[ ISI_HEADER_SIZE + MCE_MODEM_STATE_IND_OFFSET_ACTION ] ); |
|
1177 if ( ( msg[ ISI_HEADER_SIZE + MCE_MODEM_STATE_IND_OFFSET_MESSAGEID ] == MCE_MODEM_STATE_IND ) && |
|
1178 ( msg[ ISI_HEADER_SIZE + MCE_MODEM_STATE_IND_OFFSET_ACTION ] == MCE_READY ) ) |
|
1179 { |
|
1180 //15:08:55.563 xti: MASTER_ASCII_PRINTF; string:M_HSI: TX common: 26ff60c2 06000014 00000004 ffffffff |
|
1181 Kern::Printf("Connection OK"); |
|
1182 aTmp.InitConnectionOk(); |
|
1183 } |
|
1184 else |
|
1185 { |
|
1186 // just ignore and wait for MCE_READY_IND DEALLOC???? |
|
1187 Kern::Printf("Connection NOK"); |
|
1188 } |
|
1189 } |
|
1190 } |
|
1191 #endif // MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD |
|
1192 else |
|
1193 { |
|
1194 C_TRACE( ( _T( "DRouter::CheckRouting Unknown message" ) ) ); |
|
1195 TRACE_ASSERT_ALWAYS; |
|
1196 Kern::Printf("Unknown message 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", msg[ 0 ], msg[ 1 ], msg[ 2 ], msg[ 3 ], msg[ 4 ], msg[ 5 ], msg[ 6 ], msg[ 7 ], msg[ 8 ], msg[ 9 ] ); |
|
1197 } |
|
1198 } |
|
1199 // Message to other media than sos in symbian side. |
|
1200 else |
|
1201 { |
|
1202 route = EMediaMsg; |
|
1203 } |
|
1204 C_TRACE( ( _T( "DRouter::CheckRouting msg 0x%x route %d" ), msg, route ) ); |
|
1205 OstTraceExt2( TRACE_NORMAL, DROUTER_CHECKROUTING_ROUTE, "DRouter::CheckRouting;aMsg=0x%x;route=%d", ( TUint )msg, route ); |
|
1206 switch( route ) |
|
1207 { |
|
1208 case EIsiMsg: |
|
1209 { |
|
1210 aTmp.HandleIsiMessage( aMsg ); |
|
1211 break; |
|
1212 } |
|
1213 case EPipeMsg: |
|
1214 { |
|
1215 aTmp.HandlePipeMessage( aMsg ); |
|
1216 break; |
|
1217 } |
|
1218 case EMediaMsg: |
|
1219 { |
|
1220 aTmp.HandleMediaMessage( aMsg ); |
|
1221 break; |
|
1222 } |
|
1223 case EIndicationMsg: |
|
1224 { |
|
1225 aTmp.iIndicationHandler->Multicast( aMsg ); |
|
1226 // De-allocate, message is multicasted to subsribers as new |
|
1227 // message and the original is ready to be deallocated. |
|
1228 aTmp.DeAllocateBlock( aMsg ); |
|
1229 break; |
|
1230 } |
|
1231 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1232 case EControlMsg: |
|
1233 { |
|
1234 aTmp.HandleControlMessage( aMsg ); |
|
1235 break; |
|
1236 } |
|
1237 case EPnNameAddRespMsg: |
|
1238 { |
|
1239 aTmp.HandlePnsNameAddResp( aMsg ); |
|
1240 break; |
|
1241 } |
|
1242 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
1243 case ENotKnownMsg: |
|
1244 { |
|
1245 // Not going to anywhere deallocate. |
|
1246 aTmp.DeAllocateBlock( aMsg ); |
|
1247 break; |
|
1248 } |
|
1249 default: |
|
1250 { |
|
1251 ASSERT_RESET_ALWAYS( 0, EIADWrongParameter | EIADFaultIdentifier16 << KFaultIdentifierShift ); |
|
1252 break; |
|
1253 } |
|
1254 } |
|
1255 C_TRACE( ( _T( "DRouter::CheckRouting 0x%x<-" ), msg ) ); |
|
1256 OstTrace1( TRACE_NORMAL, DROUTER_CHECKROUTING_EXIT, "<DRouter::CheckRouting;msg=0x%x", (TUint)msg ); |
|
1257 |
|
1258 } |
|
1259 |
|
1260 void DRouter::CommonRxDfc( |
|
1261 TAny* aPtr // Pointer to this object. |
|
1262 ) |
|
1263 { |
|
1264 |
|
1265 OstTrace1( TRACE_NORMAL, DROUTER_COMMONRXDFC_ENTRY, ">DRouter::CommonRxDfc;aPtr=%x", ( TUint )( aPtr ) ); |
|
1266 C_TRACE( ( _T( "DRouter::CommonRxDfc ->" ) ) ); |
|
1267 DRouter& tmp = *reinterpret_cast<DRouter*>( aPtr ); |
|
1268 ASSERT_DFCTHREAD_INEXT(); |
|
1269 if( tmp.iCommonRxQueue->Count() > KErrNone ) |
|
1270 { |
|
1271 TDes8& msg( tmp.iCommonRxQueue->Get() ); |
|
1272 DATA_DUMP_TRACE( msg, EFalse );// TODO: this causes problems in legacy flowcontrol causing main rx to overflow!! |
|
1273 OstTraceData( TRACE_ISIMSG, DROUTER_COMMONRXDFC_DATA, "DRouter::CommonRxDfc RX: 0x%hx", msg.Ptr(), msg.Length() ); |
|
1274 CheckRouting( tmp, msg ); |
|
1275 // Check here too to avoid unnecessary dfc queuing. |
|
1276 if( tmp.iCommonRxQueue->Count() > KErrNone ) |
|
1277 { |
|
1278 C_TRACE( ( _T( "DRouter::CommonRxDfc enque commonrxdfc" ) ) ); |
|
1279 tmp.iCommonRxDfc->Enque(); |
|
1280 } |
|
1281 } |
|
1282 C_TRACE( ( _T( "DRouter::CommonRxDfc <-" ) ) ); |
|
1283 OstTrace0( TRACE_NORMAL, DROUTER_COMMONRXDFC_EXIT, "<DRouter::CommonRxDfc" ); |
|
1284 |
|
1285 } |
|
1286 |
|
1287 void DRouter::SendCommIsaEntityNotReachableResp( |
|
1288 const TDesC8& aMsg |
|
1289 ) |
|
1290 { |
|
1291 OstTrace1( TRACE_NORMAL, DROUTER_SENDCOMMISAENTITYNOTREACHABLERESP_ENTRY, ">DRouter::SendCommIsaEntityNotReachableResp;aMsg=%x", ( TUint )&( aMsg ) ); |
|
1292 |
|
1293 C_TRACE( ( _T( "DRouter::SendCommIsaEntityNotReachableResp 0x%x ->" ), &aMsg ) ); |
|
1294 // Make channel opening request followinfg COMM specification: 000.026 |
|
1295 // Length is sixteen bytes. |
|
1296 TUint8 length( 16 ); |
|
1297 TDes8& tempPtr = AllocateBlock( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP ); |
|
1298 ASSERT_RESET_ALWAYS( &tempPtr, EIADMemoryAllocationFailure | EIADFaultIdentifier19 << KFaultIdentifierShift ); |
|
1299 ASSERT_RESET_ALWAYS( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP > ISI_HEADER_OFFSET_MESSAGEID, EIADOverTheLimits | EIADFaultIdentifier5 << KFaultIdentifierShift ); |
|
1300 TUint8* ptr = const_cast<TUint8*>( tempPtr.Ptr() ); |
|
1301 // We start to append from transaction id. |
|
1302 tempPtr.SetLength( ISI_HEADER_OFFSET_TRANSID ); |
|
1303 // Get the header until messageid from prev. message. |
|
1304 // Just turn receiver and sender device and object vice versa. |
|
1305 const TUint8* msgTmpPtr( aMsg.Ptr() ); |
|
1306 ptr[ ISI_HEADER_OFFSET_MEDIA ] = msgTmpPtr[ ISI_HEADER_OFFSET_MEDIA ]; |
|
1307 SET_RECEIVER_DEV( ptr, GET_SENDER_DEV( aMsg ) ); |
|
1308 SET_SENDER_DEV ( ptr, GET_RECEIVER_DEV( aMsg ) ); |
|
1309 ptr[ ISI_HEADER_OFFSET_RESOURCEID ] = msgTmpPtr[ ISI_HEADER_OFFSET_RESOURCEID ]; |
|
1310 SET_LENGTH( ptr, length - PN_HEADER_SIZE ); |
|
1311 SET_RECEIVER_OBJ( ptr, GET_SENDER_OBJ( aMsg ) ); |
|
1312 SET_SENDER_OBJ( ptr, GET_RECEIVER_OBJ( aMsg ) ); |
|
1313 // Transactionid. Set to 0x01 since this is the first. |
|
1314 tempPtr.Append( msgTmpPtr[ ISI_HEADER_OFFSET_TRANSID ] ); |
|
1315 // Message ID |
|
1316 tempPtr.Append( 0xF0 ); |
|
1317 // Sub message ID. |
|
1318 tempPtr.Append( 0x14 ); |
|
1319 // Not Delivered Message from original req. |
|
1320 tempPtr.Append( msgTmpPtr[ ISI_HEADER_OFFSET_MESSAGEID ] ); |
|
1321 // Status - COMM_ISA_ENTITY_NOT_AVAILABLE |
|
1322 tempPtr.Append( 0x00 ); |
|
1323 // Filler |
|
1324 tempPtr.Append( 0x00 ); |
|
1325 // Filler |
|
1326 tempPtr.Append( 0x00 ); |
|
1327 // Filler |
|
1328 tempPtr.Append( 0x00 ); |
|
1329 |
|
1330 // ASSERT_RESET_ALWAYS( iConnectionStatus == EIADConnectionOk, EIADCmtConnectionLost | EIADFaultIdentifier2 << KFaultIdentifierShift ); |
|
1331 SendMsg( tempPtr ); |
|
1332 C_TRACE( ( _T( "DRouter::SendCommIsaEntityNotReachableResp 0x%x <-" ), &aMsg ) ); |
|
1333 |
|
1334 OstTrace0( TRACE_NORMAL, DROUTER_SENDCOMMISAENTITYNOTREACHABLERESP_EXIT, "<DRouter::SendCommIsaEntityNotReachableResp" ); |
|
1335 } |
|
1336 |
|
1337 void DRouter::InitCmtDfc( |
|
1338 TAny* aPtr |
|
1339 ) |
|
1340 { |
|
1341 OstTrace1( TRACE_NORMAL, DROUTER_INITCMTDFC_ENTRY, ">DRouter::InitCmtDfc;aPtr=%x", ( TUint )( aPtr ) ); |
|
1342 |
|
1343 C_TRACE( ( _T( "DRouter::InitCmtDfc ->" ) ) ); |
|
1344 DRouter& tmp = *reinterpret_cast<DRouter*>( aPtr ); |
|
1345 if( !tmp.iBootDone ) |
|
1346 { |
|
1347 #ifdef NCP_COMMON_BRIDGE_FAMILY |
|
1348 #ifndef MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD |
|
1349 tmp.InitConnectionOk(); |
|
1350 #endif // MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD |
|
1351 #else |
|
1352 tmp.InitCmtConnection(); |
|
1353 #endif |
|
1354 } |
|
1355 |
|
1356 // ISCE tmp.InitCmtConnection(); |
|
1357 C_TRACE( ( _T( "DRouter::InitCmtDfc <-" ) ) ); |
|
1358 |
|
1359 OstTrace0( TRACE_NORMAL, DROUTER_INITCMTDFC_EXIT, "<DRouter::InitCmtDfc" ); |
|
1360 } |
|
1361 |
|
1362 #ifdef NCP_COMMON_BRIDGE_FAMILY |
|
1363 void DRouter::InitConnectionOk() |
|
1364 { |
|
1365 |
|
1366 C_TRACE( ( _T( "DRouter::InitConnectionOk ->" ) ) ); |
|
1367 iMaxFrameSize = KIADMaxIsiMsgSize; |
|
1368 iConnectionStatus = EIADConnectionOk; |
|
1369 iBootDone = ETrue; |
|
1370 NotifyObjLayerConnStat( EIADConnectionOk ); |
|
1371 // Initialize channels to NULL when channel is opened !NULL. |
|
1372 for( TInt i( 0 ); i < EIADSizeOfChannels; ++i ) |
|
1373 { |
|
1374 ASSERT_RESET_ALWAYS( !iChannelTable[ i ].iChannel, EIADChannelOpenedBeforePhysicalLayerInit ); |
|
1375 C_TRACE( ( _T( "DRouter::InitConnectionOk %d" ), i ) ); |
|
1376 if( iChannelTable[ i ].iWaitingChannel ) |
|
1377 { |
|
1378 switch( iChannelTable[ i ].iType ) |
|
1379 { |
|
1380 case ENormalOpen: |
|
1381 { |
|
1382 C_TRACE( ( _T( "DRouter::InitConnectionOk booting ENormalOpen 0x%x" ), i ) ); |
|
1383 MIAD2ChannelApi* tmpChannel = iChannelTable[ i ].iWaitingChannel; |
|
1384 iChannelTable[ i ].iChannel = tmpChannel; |
|
1385 iChannelTable[ i ].iWaitingChannel = NULL; |
|
1386 iChannelTable[ i ].iChannel->CompleteChannelRequest( EIADAsyncOpen, KErrNone ); |
|
1387 break; |
|
1388 } |
|
1389 default: |
|
1390 { |
|
1391 ASSERT_RESET_ALWAYS( 0, -1111 ); |
|
1392 break; |
|
1393 } |
|
1394 } |
|
1395 } |
|
1396 } |
|
1397 C_TRACE( ( _T( "DRouter::InitConnectionOk <-" ) ) ); |
|
1398 } |
|
1399 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
1400 |
|
1401 void DRouter::InitCmtConnection( |
|
1402 // None |
|
1403 ) |
|
1404 { |
|
1405 OstTrace0( TRACE_NORMAL, DROUTER_INITCMTCONNECTION_ENTRY, ">DRouter::InitCmtConnection" ); |
|
1406 |
|
1407 C_TRACE( ( _T( "DRouter::InitCmtConnection ->" ) ) ); |
|
1408 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1409 |
|
1410 // send configuration request to proxy |
|
1411 const TInt KCtrlConfReqLength( 14 ); |
|
1412 //ASSERT_RESET_ALWAYS( iIST, EIADNullParameter | EIADFaultIdentifier16 << KFaultIdentifierShift ); |
|
1413 TDes8& temp = AllocateBlock( KCtrlConfReqLength ); |
|
1414 ASSERT_RESET_ALWAYS( ( KCtrlConfReqLength > CTRL_REQ_OFFSET_MESSAGEID + 2 ), EIADOverTheLimits | EIADFaultIdentifier6 << KFaultIdentifierShift ); |
|
1415 temp.SetLength( KCtrlConfReqLength ); |
|
1416 TUint8* tmpPtr( const_cast<TUint8*>( temp.Ptr() ) ); |
|
1417 tmpPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS; |
|
1418 SET_RECEIVER_DEV( tmpPtr, PN_MEDIA_ROUTING_REQ ); |
|
1419 SET_SENDER_DEV( tmpPtr, THIS_DEVICE ); |
|
1420 tmpPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_MEDIA_CONTROL; |
|
1421 SET_LENGTH( tmpPtr, ( KCtrlConfReqLength - PN_HEADER_SIZE ) ); |
|
1422 SET_RECEIVER_OBJ( tmpPtr, PN_OBJ_ROUTER ); |
|
1423 SET_SENDER_OBJ( tmpPtr, KIADObjId ); |
|
1424 tmpPtr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_UTID ] = 0x00; |
|
1425 tmpPtr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_SUBFUNCTION ] = PNS_MEDIA_SPECIFIC_REQ; |
|
1426 tmpPtr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_MEDIATOCTRL ] = PN_MEDIA_SOS; |
|
1427 tmpPtr[ CTRL_REQ_OFFSET_MESSAGEID ] = KIADCtrlConfReq; |
|
1428 tmpPtr[ CTRL_REQ_OFFSET_MESSAGEID + 1 ] = 0x00; // Filler |
|
1429 tmpPtr[ CTRL_REQ_OFFSET_MESSAGEID +2 ] = 0x00; // Filler |
|
1430 temp.SetLength( KCtrlConfReqLength ); |
|
1431 SendMsg( temp ); |
|
1432 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
1433 |
|
1434 C_TRACE( ( _T( "DRouter::InitCmtConnection <-" ) ) ); |
|
1435 |
|
1436 OstTrace0( TRACE_NORMAL, DROUTER_INITCMTCONNECTION_EXIT, "<DRouter::InitCmtConnection" ); |
|
1437 } |
|
1438 |
|
1439 void DRouter::SendDrmReq( |
|
1440 const TUint16 aChannelId |
|
1441 ) |
|
1442 { |
|
1443 OstTraceExt1( TRACE_NORMAL, DROUTER_SENDDRMREQ_ENTRY, ">DRouter::SendDrmReq;aChannelId=%hx", aChannelId ); |
|
1444 |
|
1445 C_TRACE( ( _T( "DRouter::SendDrmReq 0x%x ->" ), aChannelId) ); |
|
1446 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1447 // DRM REQ/RESP messages are spec so that only 8-bit values for channelid are possible. |
|
1448 ASSERT_RESET_ALWAYS( aChannelId <= 0xff, EIADTooManyBytesToPresent ); |
|
1449 TDes8& block = AllocateBlock( KIADCtrlDrmReqLength ); |
|
1450 ASSERT_RESET_ALWAYS( ( KIADCtrlDrmReqLength > CTRL_DRM_REQ_OFFSET_REQUIRED_CHANNEL_ID ), EIADOverTheLimits | EIADFaultIdentifier7 << KFaultIdentifierShift );; |
|
1451 block.SetLength( KIADCtrlDrmReqLength ); |
|
1452 TUint8* ptr( const_cast<TUint8*>( block.Ptr() ) ); |
|
1453 ptr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS; |
|
1454 SET_RECEIVER_DEV( ptr, PN_MEDIA_ROUTING_REQ ); |
|
1455 SET_SENDER_DEV( ptr, THIS_DEVICE ); |
|
1456 ptr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_MEDIA_CONTROL; |
|
1457 SET_LENGTH( ptr, ( KIADCtrlDrmReqLength - PN_HEADER_SIZE ) ); |
|
1458 SET_RECEIVER_OBJ( ptr, PN_OBJ_ROUTER ); |
|
1459 SET_SENDER_OBJ( ptr, KIADObjId ); |
|
1460 ptr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_UTID ] = aChannelId; |
|
1461 ptr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_SUBFUNCTION ] = PNS_MEDIA_SPECIFIC_REQ; |
|
1462 ptr[ ISI_HEADER_SIZE + PNS_MEDIA_SPECIFIC_REQ_OFFSET_MEDIATOCTRL ] = PN_MEDIA_SOS; |
|
1463 ptr[ CTRL_REQ_OFFSET_MESSAGEID ] = KIADCtrlDrmReq; |
|
1464 ptr[ CTRL_DRM_REQ_OFFSET_REQUIRED_CHANNEL_ID ] = aChannelId; |
|
1465 ASSERT_RESET_ALWAYS( iConnectionStatus == EIADConnectionOk, EIADCmtConnectionLost | EIADFaultIdentifier3 << KFaultIdentifierShift ); |
|
1466 SendMsg( block ); |
|
1467 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
1468 C_TRACE( ( _T( "DRouter::SendDrmReq 0x%x <-" ), aChannelId) ); |
|
1469 |
|
1470 OstTrace0( TRACE_NORMAL, DROUTER_SENDDRMREQ_EXIT, "<DRouter::SendDrmReq" ); |
|
1471 } |
|
1472 |
|
1473 void DRouter::SendPnsNameAddReq( |
|
1474 const TUint16 aChannel, |
|
1475 const TDesC8& aOpenInfo |
|
1476 ) |
|
1477 { |
|
1478 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDPNSNAMEADDREQ_ENTRY, ">DRouter::SendPnsNameAddReq;aChannel=%hx;aOpenInfo=%x", aChannel, ( TUint )&( aOpenInfo ) ); |
|
1479 |
|
1480 C_TRACE( ( _T( "DRouter::SendPnsNameAddReq 0x%x 0x%x ->" ), aChannel, &aOpenInfo ) ); |
|
1481 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1482 |
|
1483 TUint16 msgLength( ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_REQ ); |
|
1484 TDes8& block = AllocateBlock( msgLength ); |
|
1485 ASSERT_RESET_ALWAYS( ( msgLength > ( ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 7 ) ), EIADOverTheLimits | EIADFaultIdentifier8 << KFaultIdentifierShift ); |
|
1486 block.SetLength( msgLength ); |
|
1487 TUint8* ptr = const_cast<TUint8*>( block.Ptr() ); |
|
1488 |
|
1489 ptr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS; |
|
1490 SET_RECEIVER_DEV( ptr, OTHER_DEVICE_1 ); |
|
1491 SET_SENDER_DEV( ptr, THIS_DEVICE ); |
|
1492 ptr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; |
|
1493 SET_LENGTH( ptr, ( msgLength - PN_HEADER_SIZE ) ); |
|
1494 SET_RECEIVER_OBJ( ptr, PN_OBJ_ROUTER); |
|
1495 SET_SENDER_OBJ( ptr, KIADObjId ); |
|
1496 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_UTID ] = aChannel; |
|
1497 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_SUBFUNCTION ] = PNS_NAME_ADD_REQ; |
|
1498 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_RESERVED1 ] = 0x00; |
|
1499 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_RESERVED2 ] = 0x00; |
|
1500 |
|
1501 TUint8* resourcePtr = const_cast<TUint8*>( aOpenInfo.Ptr() ); |
|
1502 /* |
|
1503 //TBR |
|
1504 for( TInt i( 0 ); i < aOpenInfo.Length(); i++ ) |
|
1505 { |
|
1506 Kern::Printf( "resource[%d]0x%x", i, resourcePtr[i] ); |
|
1507 } |
|
1508 //TBR |
|
1509 */ |
|
1510 switch( aOpenInfo.Length() ) |
|
1511 { |
|
1512 // Resource bigendian 32-bit, TODO : how about winscw? |
|
1513 case 4: |
|
1514 { |
|
1515 C_TRACE( ( _T( "DRouter::SendPnsNameAddReq 32-bit resourceid used 0x%x 0x%x" ), aChannel, &aOpenInfo ) ); |
|
1516 OstTraceExt5( TRACE_NORMAL, DROUTER_SENDPNSNAMEADDREQ_32BIT, "DRouter::SendPnsNameAddReq;aChannel=%hx;resourcePtr[0]=%hhx;resourcePtr[1]=%hhx;resourcePtr[2]=%hhx;resourcePtr[3]=%hhx", aChannel, resourcePtr[0], resourcePtr[1], resourcePtr[2], resourcePtr[3] ); |
|
1517 |
|
1518 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY ] = resourcePtr[ 0 ]; |
|
1519 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 1 ] = resourcePtr[ 1 ]; |
|
1520 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 2 ] = resourcePtr[ 2 ]; |
|
1521 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 3 ] = resourcePtr[ 3 ]; |
|
1522 break; |
|
1523 } |
|
1524 case 1: |
|
1525 { |
|
1526 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY ] = 0x00; |
|
1527 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 1 ] = 0x00; |
|
1528 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 2 ] = 0x00; |
|
1529 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 3 ] = resourcePtr[ 0 ]; |
|
1530 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDPNSNAMEADDREQ_8BIT, "DRouter::SendPnsNameAddReq;aChannel=%hx;resourcePtr[0]=%hhx", aChannel, resourcePtr[0] ); |
|
1531 C_TRACE( ( _T( "DRouter::SendPnsNameAddReq 8-bit resourceid used 0x%x 0x%x" ), aChannel, &aOpenInfo ) ); |
|
1532 break; |
|
1533 } |
|
1534 default: |
|
1535 { |
|
1536 ASSERT_RESET_ALWAYS( 0, EIADWrongParameter | EIADFaultIdentifier17 << KFaultIdentifierShift ); |
|
1537 break; |
|
1538 } |
|
1539 } |
|
1540 // Phonet device id associated with name. |
|
1541 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 4 ] = THIS_DEVICE; |
|
1542 // Phonet object id associated with name. |
|
1543 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 5 ] = aChannel; |
|
1544 // Record flags. This entry cannot be changed. |
|
1545 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 6 ] = PN_NAME_NOCHG; |
|
1546 ptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + 7 ] = 0x00; |
|
1547 ASSERT_RESET_ALWAYS( iConnectionStatus == EIADConnectionOk, EIADCmtConnectionLost | EIADFaultIdentifier4 << KFaultIdentifierShift ); |
|
1548 SendMsg( block ); |
|
1549 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
1550 C_TRACE( ( _T( "DRouter::SendPnsNameAddReq 0x%x 0x%x <-" ), aChannel, &aOpenInfo ) ); |
|
1551 |
|
1552 OstTrace0( TRACE_NORMAL, DROUTER_SENDPNSNAMEADDREQ_EXIT, "<DRouter::SendPnsNameAddReq" ); |
|
1553 } |
|
1554 |
|
1555 void DRouter::HandlePnsNameAddResp( |
|
1556 TDes8& aMsg |
|
1557 ) |
|
1558 { |
|
1559 OstTrace1( TRACE_NORMAL, DROUTER_HANDLEPNSNAMEADDRESP_ENTRY, ">DRouter::HandlePnsNameAddResp;aMsg=%x", ( TUint )&( aMsg ) ); |
|
1560 |
|
1561 C_TRACE( ( _T( "DRouter::HandlePnsNameAddResp 0x%x ->" ), &aMsg ) ); |
|
1562 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1563 |
|
1564 // Channel id from Transaction ID. |
|
1565 const TUint8* cptr( aMsg.Ptr() ); |
|
1566 ASSERT_RESET_ALWAYS( ( ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ) < aMsg.Length(), EIADOverTheLimits | EIADFaultIdentifier9 << KFaultIdentifierShift ); |
|
1567 TUint8 channelId( cptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_UTID ] ); |
|
1568 ASSERT_RESET_ALWAYS( channelId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)channelId << KChannelNumberShift | EIADFaultIdentifier23 << KFaultIdentifierShift ); |
|
1569 if( iChannelTable[ channelId ].iWaitingChannel ) |
|
1570 { |
|
1571 ASSERT_RESET_ALWAYS( iChannelTable[ channelId ].iType == ENameAddOpen, EIADWrongTypeOfOpenPending | EIADFaultIdentifier2 << KFaultIdentifierShift ); |
|
1572 if( cptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] == PN_NAME_OK ) |
|
1573 { |
|
1574 MIAD2ChannelApi* tmpChannel = iChannelTable[ channelId ].iWaitingChannel; |
|
1575 iChannelTable[ channelId ].iChannel = tmpChannel; |
|
1576 iChannelTable[ channelId ].iWaitingChannel = NULL; |
|
1577 C_TRACE( ( _T( "DRouter::HandlePnsNameAddResp name add resp ok 0x%x 0x%x 0x%x 0x%x" ), channelId, tmpChannel, iChannelTable[ channelId ].iChannel, &aMsg ) ); |
|
1578 |
|
1579 OstTraceExt2( TRACE_NORMAL, DROUTER_HANDLEPNSNAMEADDRESP_OK, "DRouter::HandlePnsNameAddResp OK;channelId=%hhx;tmpChannel=%x", channelId, (TUint) ( tmpChannel ) ); |
|
1580 |
|
1581 iChannelTable[ channelId ].iChannel->CompleteChannelRequest( EIADAsyncOpen, KErrNone ); |
|
1582 } |
|
1583 else |
|
1584 { |
|
1585 C_TRACE( ( _T( "DRouter::HandlePnsNameAddResp name add resp NOK 0x%x 0x%x" ), channelId, &aMsg ) ); |
|
1586 OstTraceExt1( TRACE_NORMAL, DROUTER_HANDLEPNSNAMEADDRESP_NOK, "DRouter::HandlePnsNameAddResp;channelId=%hhx", channelId ); |
|
1587 |
|
1588 TRACE_ASSERT( cptr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] == PN_NAME_OK ); |
|
1589 iChannelTable[ channelId ].iWaitingChannel->CompleteChannelRequest( EIADAsyncOpen, KErrNotSupported ); |
|
1590 // Set channel open waiting to null, open was failed. |
|
1591 iChannelTable[ channelId ].iWaitingChannel = NULL; |
|
1592 } |
|
1593 } |
|
1594 else |
|
1595 { |
|
1596 // Check is this waiting |
|
1597 // TODO: Does pns_name_add_resp need to be informed with comm_isa_entity_not_reachable_resp if channel is closed? |
|
1598 TRACE_ASSERT_INFO( !iChannelTable[ channelId ].iChannel, channelId<<KChannelNumberShift ); |
|
1599 TRACE_ASSERT_INFO( iChannelTable[ channelId ].iWaitingChannel, channelId<<KChannelNumberShift ); // TODO: This will come when open cancel called with resource. |
|
1600 } |
|
1601 // De-allocate cause not going anywhere else. |
|
1602 DeAllocateBlock( aMsg ); |
|
1603 #endif // NCP_COMMON_BRIDGE_FAMILY |
|
1604 |
|
1605 C_TRACE( ( _T( "DRouter::HandlePnsNameAddResp 0x%x <-" ), &aMsg ) ); |
|
1606 |
|
1607 OstTrace0( TRACE_NORMAL, DROUTER_HANDLEPNSNAMEADDRESP_EXIT, "<DRouter::HandlePnsNameAddResp" ); |
|
1608 } |
|
1609 |
|
1610 // router and handler (pipe and indication) |
|
1611 TInt DRouter::SendMsg( |
|
1612 TDes8& aMsg |
|
1613 ) |
|
1614 { |
|
1615 OstTrace1( TRACE_NORMAL, DROUTER_SENDMSG_ENTRY, ">DRouter::SendMsg;aMsg=%x", ( TUint )&( aMsg ) ); |
|
1616 |
|
1617 C_TRACE( ( _T( " DRouter::SendMsg 0x%x ->" ), &aMsg ) ); |
|
1618 // The IST shall deallocate the block when it's approriate to do. |
|
1619 DATA_DUMP_TRACE( aMsg, ETrue ); |
|
1620 OstTraceData( TRACE_ISIMSG, DROUTER_SENDMSG_DATA, "DRouter::SendMsg TX: %{hex8[]}", aMsg.Ptr(), aMsg.Length() ); |
|
1621 |
|
1622 //ISCE |
|
1623 //TInt error = iIST->SendMessage( aMsg, MIAD2ISTApi::EISTPriorityDefault );// priority 0 |
|
1624 // TODO error codes and ids |
|
1625 TUint8 linkId = MapMediaToLinkId( aMsg.Ptr()[ ISI_HEADER_OFFSET_MEDIA ] ); |
|
1626 ASSERT_RESET_ALWAYS( linkId < DRouter::EISIAmountOfMedias, -1000 ); |
|
1627 MISIRouterLinkIf* link = iLinksArray[ linkId ]; |
|
1628 ASSERT_RESET_ALWAYS( link, -999 ); |
|
1629 TInt error( KErrNone ); |
|
1630 if( link->TrxPresent() ) |
|
1631 { |
|
1632 link->Send( aMsg ); |
|
1633 } |
|
1634 else |
|
1635 { |
|
1636 TRACE_ASSERT_ALWAYS; |
|
1637 // Discard send block if connection lost |
|
1638 MemApi::DeallocBlock( aMsg ); |
|
1639 error = KErrNotReady; |
|
1640 } |
|
1641 //ISCE |
|
1642 OstTraceExt2( TRACE_NORMAL, DROUTER_SENDMSG_EXIT, "<DRouter::SendMsg;aMsg=%x;error=%d", ( TUint )&( aMsg ), error ); |
|
1643 return error; |
|
1644 } |
|
1645 |
|
1646 //pipehandler |
|
1647 MIAD2ChannelApi* DRouter::GetChannel( |
|
1648 const TUint16 aChannel |
|
1649 ) |
|
1650 { |
|
1651 OstTraceExt1( TRACE_NORMAL, DROUTER_GETCHANNEL_ENTRY, ">DRouter::GetChannel;aChannel=%hx", aChannel ); |
|
1652 |
|
1653 ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | (TUint8)aChannel << KChannelNumberShift | EIADFaultIdentifier24 << KFaultIdentifierShift ); |
|
1654 |
|
1655 MIAD2ChannelApi* channelApi = iChannelTable[ aChannel ].iChannel; |
|
1656 |
|
1657 OstTrace1( TRACE_NORMAL, DROUTER_GETCHANNEL_EXIT, "<DRouter::GetChannel;channelApi=%x", ( TUint )( channelApi ) ); |
|
1658 return channelApi; |
|
1659 } |
|
1660 //pipehandler |
|
1661 |
|
1662 void DRouter::SetSenderInfo( |
|
1663 TDes8& aMessage, |
|
1664 const TUint16 aCh |
|
1665 ) |
|
1666 { |
|
1667 OstTraceExt2( TRACE_NORMAL, DROUTER_SETSENDERINFO_ENTRY, ">DRouter::SetSenderInfo;aMessage=%x;aCh=%hx", ( TUint )&( aMessage ), aCh ); |
|
1668 |
|
1669 C_TRACE( ( _T( "DRouter::SetSenderInfo 0x%x ->" ), &aMessage ) ); |
|
1670 TUint8* msgBlockPtr = const_cast<TUint8*>( aMessage.Ptr() ); |
|
1671 ASSERT_RESET_ALWAYS( aMessage.Length() > ISI_HEADER_OFFSET_MEDIA, EIADOverTheLimits | EIADFaultIdentifier10 << KFaultIdentifierShift ); |
|
1672 switch( aCh ) |
|
1673 { |
|
1674 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1675 case EIADNokiaBtPhonetLink: |
|
1676 { |
|
1677 OstTrace0( TRACE_NORMAL, DROUTER_SETSENDERINFO_BT, "DRouter::SetSenderInfo BT" ); |
|
1678 msgBlockPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_BT; |
|
1679 break; |
|
1680 } |
|
1681 case EIADNokiaUsbPhonetLink: |
|
1682 { |
|
1683 OstTrace0( TRACE_NORMAL, DROUTER_SETSENDERINFO_USB, "DRouter::SetSenderInfo USB" ); |
|
1684 msgBlockPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_USB; |
|
1685 break; |
|
1686 } |
|
1687 #endif |
|
1688 default: |
|
1689 { |
|
1690 msgBlockPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS; |
|
1691 SET_SENDER_DEV( msgBlockPtr, THIS_DEVICE ); |
|
1692 SET_RECEIVER_DEV( msgBlockPtr, OTHER_DEVICE_1 ); |
|
1693 SET_SENDER_OBJ( msgBlockPtr, aCh ); |
|
1694 break; |
|
1695 } |
|
1696 } |
|
1697 C_TRACE( ( _T( "DRouter::SetSenderInfo 0x%x <-" ), &aMessage ) ); |
|
1698 |
|
1699 OstTrace0( TRACE_NORMAL, DROUTER_SETSENDERINFO_EXIT, "<DRouter::SetSenderInfo" ); |
|
1700 } |
|
1701 |
|
1702 void DRouter::CheckSameThreadContext() |
|
1703 { |
|
1704 OstTrace0( TRACE_NORMAL, DROUTER_CHECKSAMETHREADCONTEXT_ENTRY, ">DRouter::CheckSameThreadContext" ); |
|
1705 |
|
1706 DObject* tempObj = reinterpret_cast<DObject*>( &Kern::CurrentThread() ); |
|
1707 // If Null set current thread otherwise ignore |
|
1708 iThreadPtr = !iThreadPtr ? tempObj : iThreadPtr; |
|
1709 |
|
1710 IAD_ASSERT_RESET_ALWAYS( ( iThreadPtr == tempObj ? ETrue : EFalse ) , -1112, "NOTSAMETHREAD" ); |
|
1711 |
|
1712 OstTrace0( TRACE_NORMAL, DROUTER_CHECKSAMETHREADCONTEXT_EXIT, "<DRouter::CheckSameThreadContext" ); |
|
1713 } |
|
1714 |
|
1715 // FM held, must not block and nor acquire locks. |
|
1716 void DRouter::NotifyTrxPresenceEnqueDfc( |
|
1717 TBool aPresent |
|
1718 ) |
|
1719 { |
|
1720 |
|
1721 C_TRACE( ( _T( "DRouter::NotifyTrxPresenceEnqueDfc %d ->" ), aPresent ) ); |
|
1722 if( !iBootDone ) |
|
1723 { |
|
1724 iInitCmtDfc->Enque(); |
|
1725 } |
|
1726 else |
|
1727 { |
|
1728 iConnectionStatus = ( aPresent ) ? EIADConnectionOk : EIADConnectionNotOk;// TODO: atomicity check |
|
1729 iConnStatDfc->Enque(); |
|
1730 } |
|
1731 C_TRACE( ( _T( "DRouter::NotifyTrxPresenceEnqueDfc %d <-" ), aPresent ) ); |
|
1732 |
|
1733 } |
|
1734 |
|
1735 void DRouter::Receive( |
|
1736 TDes8& aMsg |
|
1737 ) |
|
1738 { |
|
1739 |
|
1740 C_TRACE( ( _T( "DRouter::Receive 0x%x ->" ), &aMsg ) ); |
|
1741 MessageReceived( aMsg ); |
|
1742 C_TRACE( ( _T( "DRouter::Receive 0x%x <-" ), &aMsg ) ); |
|
1743 |
|
1744 } |
|
1745 |
|
1746 EXPORT_C void DRouter::DummyDoNothing() |
|
1747 { |
|
1748 |
|
1749 ASSERT_RESET_ALWAYS( 0, -1001 ); |
|
1750 |
|
1751 } |
|
1752 |
|
1753 EXPORT_C void DRouter::DummyDoNothing2() |
|
1754 { |
|
1755 |
|
1756 ASSERT_RESET_ALWAYS( 0, -1000 ); |
|
1757 |
|
1758 } |
|
1759 |
|
1760 |
|
1761 TUint8 DRouter::MapMediaToLinkId( |
|
1762 const TUint8 aMedia |
|
1763 ) |
|
1764 { |
|
1765 |
|
1766 TUint8 linkdId( DRouter::EISIAmountOfMedias ); |
|
1767 switch( aMedia ) |
|
1768 { |
|
1769 case PN_MEDIA_SOS: |
|
1770 { |
|
1771 #ifndef NCP_COMMON_BRIDGE_FAMILY |
|
1772 linkdId = EISIMediaSOS; |
|
1773 #else |
|
1774 linkdId = EISIMediaHostSSI; |
|
1775 #endif |
|
1776 break; |
|
1777 } |
|
1778 // Not supported media |
|
1779 default: |
|
1780 { |
|
1781 ASSERT_RESET_ALWAYS( 0, -998 ); |
|
1782 break; |
|
1783 } |
|
1784 } |
|
1785 return linkdId; |
|
1786 |
|
1787 } |
|
1788 |
|
1789 // End of file. |
|
1790 |