|
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 * Implementation of DMC logical channel. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include <kern_priv.h> // class DThread |
|
22 #include "dmc_extension.h" // iDmcDfcQueuePtrv |
|
23 #include "dmc_user_if.h" |
|
24 #include "dmc_logical_channel.h" |
|
25 #include "dmc_logical_device.h" |
|
26 #include "dmc_trace.h" |
|
27 |
|
28 #include "osttracedefinitions.h" |
|
29 #ifdef OST_TRACE_COMPILER_IN_USE |
|
30 #include "dmc_logical_channelTraces.h" |
|
31 #endif |
|
32 |
|
33 // EXTERNAL DATA STRUCTURES |
|
34 // EXTERNAL FUNCTION PROTOTYPES |
|
35 // FORWARD DECLARATIONS |
|
36 // CONSTANTS |
|
37 // MACROS |
|
38 // LOCAL CONSTANTS AND MACROS |
|
39 // MODULE DATA STRUCTURES |
|
40 |
|
41 // LOCAL FUNCTION PROTOTYPES |
|
42 |
|
43 |
|
44 // ==================== LOCAL FUNCTIONS ==================== |
|
45 // ================= OTHER EXPORTED FUNCTIONS ============== |
|
46 |
|
47 // ================= MEMBER FUNCTIONS ======================= |
|
48 |
|
49 //----------------------------------------------------------- |
|
50 // DDmcLogicalChannel::DDmcLogicalChannel |
|
51 //----------------------------------------------------------- |
|
52 DDmcLogicalChannel::DDmcLogicalChannel(DLogicalDevice* aLogicalDevicePtr) |
|
53 : DLogicalChannel() |
|
54 , iDmcLogicalDevPtr(NULL) |
|
55 , iClientThreadPtr(NULL) |
|
56 , iClientStatusPtr(NULL) |
|
57 , iClientEventBufferPtr(NULL) |
|
58 { |
|
59 OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DDMC_LOGICAL_CHANNEL_ENTRY, |
|
60 "DMC:LOGIC_CHNL: DDmcLogicalChannel() # IN - aLogicalDevicePtr, 0x%x:", |
|
61 aLogicalDevicePtr); |
|
62 DMC_TRACE((("DMC:LOGIC_CHNL: DDmcLogicalChannel() # IN - aLogicalDevicePtr, 0x%x:"), |
|
63 aLogicalDevicePtr)); |
|
64 |
|
65 DMC_TRACE_ASSERT(aLogicalDevicePtr); |
|
66 |
|
67 iDmcLogicalDevPtr = reinterpret_cast<DDmcLogicalDevice*>(aLogicalDevicePtr); |
|
68 |
|
69 iClientThreadPtr = &Kern::CurrentThread(); |
|
70 TInt result = ((DObject*)iClientThreadPtr)->Open(); |
|
71 |
|
72 DMC_TRACE_ASSERT(result == KErrNone); |
|
73 |
|
74 OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DDMC_LOGICAL_CHANNEL_RETURN, |
|
75 "DMC:LOGIC_CHNL: DDmcLogicalChannel() # OUT"); |
|
76 DMC_TRACE(("DMC:LOGIC_CHNL: DDmcLogicalChannel() # OUT")); |
|
77 } |
|
78 |
|
79 |
|
80 //----------------------------------------------------------- |
|
81 // DDmcLogicalChannel::~DDmcLogicalChannel |
|
82 //----------------------------------------------------------- |
|
83 DDmcLogicalChannel::~DDmcLogicalChannel() |
|
84 { |
|
85 OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL__DDMC_LOGICAL_CHANNEL_ENTRY, |
|
86 "DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # IN"); |
|
87 DMC_TRACE(("DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # IN")); |
|
88 |
|
89 // Calling of Kern::SafeClose must be in a critical section |
|
90 NKern::ThreadEnterCS(); |
|
91 |
|
92 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DDMC_LOGICAL_CHANNEL_1, |
|
93 "DMC:LOGIC_CHNL: ~DDmcLogicalChannel() - call Kern::SafeClose"); |
|
94 DMC_TRACE(("DMC:LOGIC_CHNL: ~DDmcLogicalChannel() - call Kern::SafeClose")); |
|
95 |
|
96 // Close our reference on the client thread |
|
97 Kern::SafeClose((DObject*&)iClientThreadPtr, NULL); |
|
98 |
|
99 NKern::ThreadLeaveCS(); |
|
100 |
|
101 // Cancel reset and power off events |
|
102 iDmcLogicalDevPtr->UnsubscribeEvents(this); |
|
103 |
|
104 if (iDmcLogicalDevPtr) |
|
105 { |
|
106 iDmcLogicalDevPtr = NULL; |
|
107 } |
|
108 |
|
109 if (iClientThreadPtr) |
|
110 { |
|
111 iClientThreadPtr = NULL; |
|
112 } |
|
113 |
|
114 if (iClientStatusPtr) |
|
115 { |
|
116 iClientStatusPtr = NULL; |
|
117 } |
|
118 |
|
119 if (iClientEventBufferPtr) |
|
120 { |
|
121 iClientEventBufferPtr = NULL; |
|
122 } |
|
123 |
|
124 OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL__DDMC_LOGICAL_CHANNEL_RETURN, |
|
125 "DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # OUT"); |
|
126 DMC_TRACE(("DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # OUT")); |
|
127 } |
|
128 |
|
129 |
|
130 // ----------------------------------------------------------------------------- |
|
131 // DDmcLogicalChannel::DoCreate |
|
132 // ----------------------------------------------------------------------------- |
|
133 TInt DDmcLogicalChannel::DoCreate(TInt /* aUnit */, const TDesC8* /* aInfo */, const TVersion& aVer) |
|
134 { |
|
135 OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CREATE_ENTRY, |
|
136 "DMC:LOGIC_CHNL: DoCreate() # IN - aVer: 0x%x", (TUint)&(aVer)); |
|
137 DMC_TRACE((("DMC:LOGIC_CHNL: DoCreate() # IN - aVer: 0x%x "), &aVer)); |
|
138 |
|
139 TInt retVal(KErrNone); |
|
140 |
|
141 // capability security check |
|
142 if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD, |
|
143 __PLATSEC_DIAGNOSTIC_STRING("Checked by dmc.ldd") ) ) |
|
144 { |
|
145 DMC_TRACE_ALWAYS_ASSERT; |
|
146 |
|
147 retVal = KErrPermissionDenied; |
|
148 } |
|
149 |
|
150 // Check version |
|
151 if (retVal == KErrNone) |
|
152 { |
|
153 if (!Kern::QueryVersionSupported(TVersion(RDmc::EMajorVersionNumber, |
|
154 RDmc::EMinorVersionNumber, |
|
155 RDmc::EBuildVersionNumber), |
|
156 aVer)) |
|
157 { |
|
158 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CREATE_1, |
|
159 "DMC:LOGIC_CHNL: DoCreate() - KErrNotSupported"); |
|
160 DMC_TRACE_ALWAYS_ASSERT; |
|
161 |
|
162 retVal = KErrNotSupported; |
|
163 } |
|
164 } |
|
165 |
|
166 // check user's Vendor ID to ensure that only known client are accessing |
|
167 if (retVal == KErrNone) |
|
168 { |
|
169 TUint32 vendorId = Kern::CurrentThread().iOwningProcess->iS.iVendorId; |
|
170 |
|
171 OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CREATE_2, |
|
172 "DMC:LOGIC_CHNL: DoCreate() - vendorId: 0x%x", vendorId); |
|
173 DMC_TRACE((("DMC:LOGIC_CHNL: DoCreate() - vendorId: 0x%x "), vendorId)); |
|
174 |
|
175 if (vendorId != VID_DEFAULT) |
|
176 { |
|
177 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CREATE_3, |
|
178 "DMC:LOGIC_CHNL: DoCreate() - VID check FAILED !"); |
|
179 DMC_TRACE(("DMC:LOGIC_CHNL: DoCreate() - VID check FAILED !")); |
|
180 |
|
181 DMC_TRACE_ALWAYS_ASSERT; |
|
182 |
|
183 retVal = KErrAccessDenied; |
|
184 } |
|
185 } |
|
186 |
|
187 // Initialize DFC queue |
|
188 DMC_TRACE_ASSERT_RESET(iDmcLogicalDevPtr->GetDynamicDfcQueue(), |
|
189 "DMC:LOGIC_CHNL: DoCreate() - iDmcLogicalDevPtr->GetDynamicDfcQueue()", |
|
190 KErrNoMemory); |
|
191 |
|
192 SetDfcQ(iDmcLogicalDevPtr->GetDynamicDfcQueue()); |
|
193 iMsgQ.Receive(); |
|
194 |
|
195 OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CREATE_RETURN, |
|
196 "DMC:LOGIC_CHNL: DoCreate() # OUT - retVal: %d", retVal); |
|
197 DMC_TRACE((("DMC:LOGIC_CHNL: DoCreate() # OUT - retVal: %d "), retVal)); |
|
198 |
|
199 return retVal; |
|
200 } |
|
201 |
|
202 |
|
203 // --------------------------------------------------------- |
|
204 // DDmcLogicalChannel::HandleMsg |
|
205 // --------------------------------------------------------- |
|
206 void DDmcLogicalChannel::HandleMsg(TMessageBase* aMsg) |
|
207 { |
|
208 OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_ENTRY, |
|
209 "DMC:LOGIC_CHNL: HandleMsg() # IN - aMsg: 0x%x", |
|
210 (TUint)(aMsg)); |
|
211 DMC_TRACE((("DMC:LOGIC_CHNL: HandleMsg() # IN - aMsg: 0x%x "), aMsg)); |
|
212 |
|
213 DMC_TRACE_ASSERT_RESET(aMsg, |
|
214 "DMC:LOGIC_CHNL: HandleMsg() - aMsg", |
|
215 KErrNoMemory); |
|
216 |
|
217 TThreadMessage& m = *reinterpret_cast<TThreadMessage*>(aMsg); |
|
218 |
|
219 // Get message type |
|
220 TInt msgId(m.iValue); |
|
221 |
|
222 OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_1, |
|
223 "DMC:LOGIC_CHNL: HandleMsg() - msgId: 0x%x", |
|
224 (TUint)(msgId)); |
|
225 DMC_TRACE((("DMC:LOGIC_CHNL: HandleMsg() - msgId: 0x%x "), msgId)); |
|
226 |
|
227 // close request |
|
228 if (msgId == static_cast<TInt>(ECloseMsg)) |
|
229 { |
|
230 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_3, |
|
231 "DMC:LOGIC_CHNL: HandleMsg() - ECloseMsg"); |
|
232 DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - ECloseMsg)")); |
|
233 |
|
234 m.Complete(KErrNone, EFalse); |
|
235 } |
|
236 else if (msgId == KMaxTInt) |
|
237 { |
|
238 // cancel request |
|
239 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_4, |
|
240 "DMC:LOGIC_CHNL: HandleMsg() - KMaxTInt, DoCancel"); |
|
241 DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - KMaxTInt, DoCancel")); |
|
242 |
|
243 m.Complete(KErrNone, ETrue); |
|
244 } |
|
245 else if (msgId >= 0) |
|
246 { |
|
247 // sync request |
|
248 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_5, |
|
249 "DMC:LOGIC_CHNL: HandleMsg() - DoControl"); |
|
250 DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - DoControl")); |
|
251 |
|
252 // DoControl |
|
253 TInt retStatus(DoControl(msgId, m.Ptr0())); |
|
254 m.Complete(retStatus, ETrue); |
|
255 } |
|
256 else |
|
257 { |
|
258 // async request |
|
259 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_6, |
|
260 "DMC:LOGIC_CHNL: HandleMsg() - DoRequest"); |
|
261 DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - DoRequest")); |
|
262 |
|
263 // DoRequest |
|
264 TRequestStatus* usrReqStatPtr = (TRequestStatus *)m.Ptr0(); |
|
265 |
|
266 TInt retStatus(DoRequest(~msgId, usrReqStatPtr, m.Ptr1())); |
|
267 |
|
268 if (retStatus != KErrNone) |
|
269 { |
|
270 Kern::RequestComplete(iClientThreadPtr, usrReqStatPtr, retStatus); |
|
271 } |
|
272 |
|
273 m.Complete(KErrNone, ETrue); |
|
274 } |
|
275 |
|
276 OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_RETURN, |
|
277 "DMC:LOGIC_CHNL: HandleMsg() # OUT "); |
|
278 DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() # OUT")); |
|
279 } |
|
280 |
|
281 |
|
282 // ----------------------------------------------------------------------------- |
|
283 // DDmcLogicalChannel::SendEvent |
|
284 // ----------------------------------------------------------------------------- |
|
285 void DDmcLogicalChannel::SendEvent(const RDmc::TEvent& aEvent) |
|
286 { |
|
287 OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_SEND_EVENT_ENTRY, |
|
288 "DMC:LOGIC_CHNL: SendEvent() # IN - aEvent: %d", aEvent); |
|
289 DMC_TRACE((("DMC:LOGIC_CHNL: SendEvent() # IN - aEvent: %d"), aEvent)); |
|
290 |
|
291 // Make sure that a client has subscribed events. |
|
292 if (iClientStatusPtr) |
|
293 { |
|
294 OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_SEND_1, |
|
295 "DMC:LOGIC_CHNL: SendEvent() - KErrNone: %d", KErrNone); |
|
296 DMC_TRACE((("DMC:LOGIC_CHNL: SendEvent() - KErrNone: %d"), KErrNone)); |
|
297 |
|
298 TInt retStatus = Kern::ThreadRawWrite(iClientThreadPtr, |
|
299 iClientEventBufferPtr, |
|
300 &aEvent, |
|
301 sizeof(aEvent)); |
|
302 |
|
303 OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_SEND_EVENT_1, |
|
304 "DMC:LOGIC_CHNL: SendEvent() # IN - retStatus: %d", retStatus); |
|
305 DMC_TRACE((("DMC:LOGIC_CHNL: SendEvent() # IN - retStatus: %d, iClientStatusPtr: 0x%x"), |
|
306 retStatus, iClientStatusPtr)); |
|
307 |
|
308 Kern::RequestComplete(iClientThreadPtr, iClientStatusPtr, retStatus); |
|
309 } |
|
310 |
|
311 OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_SEND_EVENT_RETURN, |
|
312 "DMC:LOGIC_CHNL: SendEvent() # OUT "); |
|
313 DMC_TRACE(("DMC:LOGIC_CHNL: SendEvent() # OUT")); |
|
314 } |
|
315 |
|
316 |
|
317 // ----------------------------------------------------------------------------- |
|
318 // DDmcLogicalChannel::DoControl |
|
319 // ----------------------------------------------------------------------------- |
|
320 TInt DDmcLogicalChannel::DoControl(const TInt aFunction, TAny* a1) |
|
321 { |
|
322 OstTraceExt2(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CONTROL_ENTRY, |
|
323 "DMC:LOGIC_CHNL: DoControl() # IN - aFunction: 0x%x, a1: 0x%x", |
|
324 (TUint)(aFunction), (TUint)(a1)); |
|
325 DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() # IN - aFunction: 0x%x, a1: 0x%x"), aFunction, a1)); |
|
326 |
|
327 TInt retStatus(KErrBadHandle); |
|
328 |
|
329 if (iDmcLogicalDevPtr) |
|
330 { |
|
331 retStatus = KErrNone; |
|
332 |
|
333 switch (aFunction) |
|
334 { |
|
335 case RDmc::EGetTargetStartUpMode: |
|
336 { |
|
337 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_1, |
|
338 "DMC:LOGIC_CHNL: DoControl() - EGetTargetStartUpMode"); |
|
339 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EGetTargetStartUpMode")); |
|
340 |
|
341 RDmc::TTargetStartupMode targetStartUpMode; |
|
342 |
|
343 retStatus = iDmcLogicalDevPtr->GetTargetStartUpMode(targetStartUpMode); |
|
344 |
|
345 DMC_TRACE_ASSERT(retStatus == KErrNone); |
|
346 |
|
347 if (retStatus == KErrNone) |
|
348 { |
|
349 retStatus = Kern::ThreadRawWrite(iClientThreadPtr, |
|
350 a1, |
|
351 &targetStartUpMode, |
|
352 sizeof(targetStartUpMode)); |
|
353 |
|
354 OstTraceExt2(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_2, |
|
355 "DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d", |
|
356 retStatus, targetStartUpMode); |
|
357 DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d"), |
|
358 retStatus, targetStartUpMode)); |
|
359 } |
|
360 } |
|
361 break; |
|
362 |
|
363 case RDmc::EGenerateReset: |
|
364 { |
|
365 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_3, |
|
366 "DMC:LOGIC_CHNL: DoControl() - EGenerateReset"); |
|
367 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EGenerateReset")); |
|
368 |
|
369 RDmc::TTargetStartupMode targetStartUpMode; |
|
370 |
|
371 retStatus = Kern::ThreadRawRead(iClientThreadPtr, |
|
372 a1, |
|
373 &targetStartUpMode, |
|
374 sizeof(targetStartUpMode)); |
|
375 |
|
376 DMC_TRACE_ASSERT(retStatus == KErrNone); |
|
377 OstTraceExt2(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_4, |
|
378 "DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d", |
|
379 retStatus, targetStartUpMode); |
|
380 DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d"), |
|
381 retStatus, targetStartUpMode)); |
|
382 |
|
383 if (retStatus == KErrNone) |
|
384 { |
|
385 retStatus = iDmcLogicalDevPtr->GenerateReset(targetStartUpMode); |
|
386 } |
|
387 |
|
388 DMC_TRACE_ASSERT(retStatus == KErrNone); |
|
389 } |
|
390 break; |
|
391 |
|
392 case RDmc::EPowerOff: |
|
393 { |
|
394 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_5, |
|
395 "DMC:LOGIC_CHNL: DoControl() - EPowerOff"); |
|
396 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EPowerOff")); |
|
397 |
|
398 retStatus = iDmcLogicalDevPtr->PowerOff(); |
|
399 |
|
400 DMC_TRACE_ASSERT(retStatus == KErrNone); |
|
401 } |
|
402 break; |
|
403 |
|
404 |
|
405 case RDmc::EIsHiddenReset: |
|
406 { |
|
407 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_6, |
|
408 "DMC:LOGIC_CHNL: DoControl() - EIsHiddenReset"); |
|
409 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EIsHiddenReset")); |
|
410 |
|
411 TBool hiddenStatus; |
|
412 |
|
413 retStatus = iDmcLogicalDevPtr->IsHiddenReset(hiddenStatus); |
|
414 |
|
415 DMC_TRACE_ASSERT(retStatus == KErrNone); |
|
416 |
|
417 if (retStatus == KErrNone) |
|
418 { |
|
419 retStatus = Kern::ThreadRawWrite(iClientThreadPtr, |
|
420 a1, |
|
421 &hiddenStatus, |
|
422 sizeof(hiddenStatus)); |
|
423 |
|
424 OstTraceExt2(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_7, |
|
425 "DMC:LOGIC_CHNL: DoControl() - retStatus: %d, hiddenStatus: %d", |
|
426 retStatus, hiddenStatus); |
|
427 DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() - retStatus: %d, hiddenStatus: %d"), |
|
428 retStatus, hiddenStatus)); |
|
429 } |
|
430 } |
|
431 break; |
|
432 |
|
433 default: |
|
434 { |
|
435 DMC_TRACE_ALWAYS_ASSERT; |
|
436 |
|
437 retStatus = KErrNotSupported; |
|
438 } |
|
439 break; |
|
440 } |
|
441 } |
|
442 |
|
443 OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CONTROL_RETURN, |
|
444 "DMC:LOGIC_CHNL: DoControl() # OUT - retStatus %d:", retStatus); |
|
445 DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() # OUT - retStatus: %d"), retStatus)); |
|
446 |
|
447 return retStatus; |
|
448 } |
|
449 |
|
450 |
|
451 // ----------------------------------------------------------------------------- |
|
452 // DDmcLogicalChannel::DoRequest |
|
453 // ----------------------------------------------------------------------------- |
|
454 TInt DDmcLogicalChannel::DoRequest(const TInt aReqId, TRequestStatus* const aStatusPtr, TAny* const a1) |
|
455 { |
|
456 OstTraceExt3(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_REQUEST_ENTRY, |
|
457 "DMC:LOGIC_CHNL: DoRequest() # IN - aRegId: 0x%x, aStatusPtr: 0x%x, a1: 0x%x", |
|
458 (TUint)(aReqId), (TUint)aStatusPtr, (TUint)(a1)); |
|
459 DMC_TRACE((("DMC:LOGIC_CHNL: DoRequest() # IN - aReqId: 0x%x, aStatusPtr: 0x%x, a1: 0x%x"), |
|
460 aReqId, aStatusPtr, a1)); |
|
461 DMC_TRACE_ASSERT_RESET(a1, "DMC:LOG_DEVICE: DDmcLogicalDevice() - a1", KErrNoMemory); |
|
462 |
|
463 iClientStatusPtr = aStatusPtr; |
|
464 iClientEventBufferPtr = static_cast<RDmc::TEvent*>(a1); |
|
465 |
|
466 iDmcLogicalDevPtr->SubscribeEvents(this); |
|
467 |
|
468 OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_REQUEST_RETURN, |
|
469 "DMC:LOGIC_CHNL: DoRequest() # OUT"); |
|
470 DMC_TRACE(("DMC:LOGIC_CHNL: DoRequest() # OUT")); |
|
471 |
|
472 return KErrNone; |
|
473 } |
|
474 |
|
475 // End of File |