1 /*---------------------------------------------------------------------------*
2   Project:  Horizon
3   File:     ndm_Interface.cpp
4 
5   Copyright (C)2009 Nintendo Co., Ltd.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law.  They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13   $Rev: 23799 $
14  *---------------------------------------------------------------------------*/
15 
16 //
17 // このファイルを編集しないでください。
18 // このファイルは自動生成されます。
19 //
20 
21 #include <nn/ndm/CTR/ndm_Interface.h>
22 #include <nn/os/ipc/os_SessionMessage.h>
23 #include <nn/svc/svc_Stub.h>
24 #include <cstring>
25 
26 
27 
28 
29 #ifdef NN_HARDWARE_CTR_LEGACY
30     #include "..\..\..\processes\ndm\CTR\ndm_InterfaceImpl.h"
31 #endif   // ifdef NN_HARDWARE_CTR_LEGACY
32 using namespace nn::svc;
33 using namespace nn::os::ipc;
34 
35 namespace nn {
36 namespace ndm {
37 namespace CTR {
38 namespace detail {
39 
40 Handle Interface::s_Session;
41 
EnterExclusiveState(s32 mode)42 nn::Result Interface::EnterExclusiveState( s32 mode )
43 {
44 #ifdef NN_HARDWARE_CTR_LEGACY
45     return reinterpret_cast<InterfaceImpl*&>(s_Session)->EnterExclusiveState(0, mode);
46 #else    // ifdef NN_HARDWARE_CTR_LEGACY
47     MessageBuffer ipcMsg(GetMessageBuffer());
48     ipcMsg.SetHeader(TAG_ENTER_EXCLUSIVE_STATE, 1, 2, 0);
49     ipcMsg.SetRaw(1, mode);
50     ipcMsg.SetProcessIdHeader(2);
51 
52 
53     nn::Result ipcResult = SendSyncRequest(s_Session);
54     if( ipcResult.IsFailure() )
55     {
56         return ipcResult;
57     }
58 
59     return ipcMsg.GetRaw<nn::Result>(1);
60 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
61 }
LeaveExclusiveState()62 nn::Result Interface::LeaveExclusiveState()
63 {
64 #ifdef NN_HARDWARE_CTR_LEGACY
65     return reinterpret_cast<InterfaceImpl*&>(s_Session)->LeaveExclusiveState(0);
66 #else    // ifdef NN_HARDWARE_CTR_LEGACY
67     MessageBuffer ipcMsg(GetMessageBuffer());
68     ipcMsg.SetHeader(TAG_LEAVE_EXCLUSIVE_STATE, 0, 2, 0);
69     ipcMsg.SetProcessIdHeader(1);
70 
71 
72     nn::Result ipcResult = SendSyncRequest(s_Session);
73     if( ipcResult.IsFailure() )
74     {
75         return ipcResult;
76     }
77 
78     return ipcMsg.GetRaw<nn::Result>(1);
79 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
80 }
QueryExclusiveMode(s32 * pMode)81 nn::Result Interface::QueryExclusiveMode( s32* pMode )
82 {
83 #ifdef NN_HARDWARE_CTR_LEGACY
84     return reinterpret_cast<InterfaceImpl*&>(s_Session)->QueryExclusiveMode(pMode);
85 #else    // ifdef NN_HARDWARE_CTR_LEGACY
86     MessageBuffer ipcMsg(GetMessageBuffer());
87     ipcMsg.SetHeader(TAG_QUERY_EXCLUSIVE_MODE, 0, 0, 0);
88 
89 
90     nn::Result ipcResult = SendSyncRequest(s_Session);
91     if( ipcResult.IsFailure() )
92     {
93         return ipcResult;
94     }
95 
96     *pMode = ipcMsg.GetRaw<s32>(2);
97 
98     return ipcMsg.GetRaw<nn::Result>(1);
99 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
100 }
LockState()101 nn::Result Interface::LockState()
102 {
103 #ifdef NN_HARDWARE_CTR_LEGACY
104     return reinterpret_cast<InterfaceImpl*&>(s_Session)->LockState(0);
105 #else    // ifdef NN_HARDWARE_CTR_LEGACY
106     MessageBuffer ipcMsg(GetMessageBuffer());
107     ipcMsg.SetHeader(TAG_LOCK_STATE, 0, 2, 0);
108     ipcMsg.SetProcessIdHeader(1);
109 
110 
111     nn::Result ipcResult = SendSyncRequest(s_Session);
112     if( ipcResult.IsFailure() )
113     {
114         return ipcResult;
115     }
116 
117     return ipcMsg.GetRaw<nn::Result>(1);
118 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
119 }
UnlockState()120 nn::Result Interface::UnlockState()
121 {
122 #ifdef NN_HARDWARE_CTR_LEGACY
123     return reinterpret_cast<InterfaceImpl*&>(s_Session)->UnlockState(0);
124 #else    // ifdef NN_HARDWARE_CTR_LEGACY
125     MessageBuffer ipcMsg(GetMessageBuffer());
126     ipcMsg.SetHeader(TAG_UNLOCK_STATE, 0, 2, 0);
127     ipcMsg.SetProcessIdHeader(1);
128 
129 
130     nn::Result ipcResult = SendSyncRequest(s_Session);
131     if( ipcResult.IsFailure() )
132     {
133         return ipcResult;
134     }
135 
136     return ipcMsg.GetRaw<nn::Result>(1);
137 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
138 }
SuspendDaemons(bit32 mask)139 nn::Result Interface::SuspendDaemons( bit32 mask )
140 {
141 #ifdef NN_HARDWARE_CTR_LEGACY
142     return reinterpret_cast<InterfaceImpl*&>(s_Session)->SuspendDaemons(mask);
143 #else    // ifdef NN_HARDWARE_CTR_LEGACY
144     MessageBuffer ipcMsg(GetMessageBuffer());
145     ipcMsg.SetHeader(TAG_SUSPEND_DAEMONS, 1, 0, 0);
146     ipcMsg.SetRaw(1, mask);
147 
148 
149     nn::Result ipcResult = SendSyncRequest(s_Session);
150     if( ipcResult.IsFailure() )
151     {
152         return ipcResult;
153     }
154 
155     return ipcMsg.GetRaw<nn::Result>(1);
156 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
157 }
ResumeDaemons(bit32 mask)158 nn::Result Interface::ResumeDaemons( bit32 mask )
159 {
160 #ifdef NN_HARDWARE_CTR_LEGACY
161     return reinterpret_cast<InterfaceImpl*&>(s_Session)->ResumeDaemons(mask);
162 #else    // ifdef NN_HARDWARE_CTR_LEGACY
163     MessageBuffer ipcMsg(GetMessageBuffer());
164     ipcMsg.SetHeader(TAG_RESUME_DAEMONS, 1, 0, 0);
165     ipcMsg.SetRaw(1, mask);
166 
167 
168     nn::Result ipcResult = SendSyncRequest(s_Session);
169     if( ipcResult.IsFailure() )
170     {
171         return ipcResult;
172     }
173 
174     return ipcMsg.GetRaw<nn::Result>(1);
175 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
176 }
SuspendScheduler(bool bAsync)177 nn::Result Interface::SuspendScheduler( bool bAsync )
178 {
179 #ifdef NN_HARDWARE_CTR_LEGACY
180     return reinterpret_cast<InterfaceImpl*&>(s_Session)->SuspendScheduler(bAsync);
181 #else    // ifdef NN_HARDWARE_CTR_LEGACY
182     MessageBuffer ipcMsg(GetMessageBuffer());
183     ipcMsg.SetHeader(TAG_SUSPEND_SCHEDULER, 1, 0, 0);
184     ipcMsg.SetRaw(1, bAsync);
185 
186 
187     nn::Result ipcResult = SendSyncRequest(s_Session);
188     if( ipcResult.IsFailure() )
189     {
190         return ipcResult;
191     }
192 
193     return ipcMsg.GetRaw<nn::Result>(1);
194 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
195 }
ResumeScheduler()196 nn::Result Interface::ResumeScheduler()
197 {
198 #ifdef NN_HARDWARE_CTR_LEGACY
199     return reinterpret_cast<InterfaceImpl*&>(s_Session)->ResumeScheduler();
200 #else    // ifdef NN_HARDWARE_CTR_LEGACY
201     MessageBuffer ipcMsg(GetMessageBuffer());
202     ipcMsg.SetHeader(TAG_RESUME_SCHEDULER, 0, 0, 0);
203 
204 
205     nn::Result ipcResult = SendSyncRequest(s_Session);
206     if( ipcResult.IsFailure() )
207     {
208         return ipcResult;
209     }
210 
211     return ipcMsg.GetRaw<nn::Result>(1);
212 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
213 }
GetCurrentState(s32 * pState)214 nn::Result Interface::GetCurrentState( s32* pState )
215 {
216 #ifdef NN_HARDWARE_CTR_LEGACY
217     return reinterpret_cast<InterfaceImpl*&>(s_Session)->GetCurrentState(pState);
218 #else    // ifdef NN_HARDWARE_CTR_LEGACY
219     MessageBuffer ipcMsg(GetMessageBuffer());
220     ipcMsg.SetHeader(TAG_GET_CURRENT_STATE, 0, 0, 0);
221 
222 
223     nn::Result ipcResult = SendSyncRequest(s_Session);
224     if( ipcResult.IsFailure() )
225     {
226         return ipcResult;
227     }
228 
229     *pState = ipcMsg.GetRaw<s32>(2);
230 
231     return ipcMsg.GetRaw<nn::Result>(1);
232 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
233 }
GetTargetState(s32 * pState)234 nn::Result Interface::GetTargetState( s32* pState )
235 {
236 #ifdef NN_HARDWARE_CTR_LEGACY
237     return reinterpret_cast<InterfaceImpl*&>(s_Session)->GetTargetState(pState);
238 #else    // ifdef NN_HARDWARE_CTR_LEGACY
239     MessageBuffer ipcMsg(GetMessageBuffer());
240     ipcMsg.SetHeader(TAG_GET_TARGET_STATE, 0, 0, 0);
241 
242 
243     nn::Result ipcResult = SendSyncRequest(s_Session);
244     if( ipcResult.IsFailure() )
245     {
246         return ipcResult;
247     }
248 
249     *pState = ipcMsg.GetRaw<s32>(2);
250 
251     return ipcMsg.GetRaw<nn::Result>(1);
252 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
253 }
GetStateChangedEvent(nn::Handle * hEvent)254 nn::Result Interface::GetStateChangedEvent( nn::Handle* hEvent )
255 {
256 #ifdef NN_HARDWARE_CTR_LEGACY
257     Handle duplicated_hEvent;
258     Result ipcResult = reinterpret_cast<InterfaceImpl*&>(s_Session)->GetStateChangedEvent(&duplicated_hEvent);
259 
260     nn::svc::DuplicateHandle(hEvent, duplicated_hEvent);
261 
262     return ipcResult;
263 #else    // ifdef NN_HARDWARE_CTR_LEGACY
264     MessageBuffer ipcMsg(GetMessageBuffer());
265     ipcMsg.SetHeader(TAG_GET_STATE_CHANGED_EVENT, 0, 0, 0);
266 
267 
268     nn::Result ipcResult = SendSyncRequest(s_Session);
269     if( ipcResult.IsFailure() )
270     {
271         return ipcResult;
272     }
273 
274     *hEvent = ipcMsg.GetHandle(3);
275 
276     return ipcMsg.GetRaw<nn::Result>(1);
277 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
278 }
QueryStatus(nn::ndm::CTR::DaemonName name,s32 * pStatus)279 nn::Result Interface::QueryStatus( nn::ndm::CTR::DaemonName name, s32* pStatus )
280 {
281 #ifdef NN_HARDWARE_CTR_LEGACY
282     return reinterpret_cast<InterfaceImpl*&>(s_Session)->QueryStatus(name, pStatus);
283 #else    // ifdef NN_HARDWARE_CTR_LEGACY
284     MessageBuffer ipcMsg(GetMessageBuffer());
285     ipcMsg.SetHeader(TAG_QUERY_STATUS, 1, 0, 0);
286     ipcMsg.SetRaw(1, name);
287 
288 
289     nn::Result ipcResult = SendSyncRequest(s_Session);
290     if( ipcResult.IsFailure() )
291     {
292         return ipcResult;
293     }
294 
295     *pStatus = ipcMsg.GetRaw<s32>(2);
296 
297     return ipcMsg.GetRaw<nn::Result>(1);
298 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
299 }
GetDaemonDisableCount(nn::ndm::CTR::DaemonName name,s32 * pCount,s32 * pCountTotal)300 nn::Result Interface::GetDaemonDisableCount( nn::ndm::CTR::DaemonName name, s32* pCount, s32* pCountTotal )
301 {
302 #ifdef NN_HARDWARE_CTR_LEGACY
303     return reinterpret_cast<InterfaceImpl*&>(s_Session)->GetDaemonDisableCount(name, pCount, pCountTotal);
304 #else    // ifdef NN_HARDWARE_CTR_LEGACY
305     MessageBuffer ipcMsg(GetMessageBuffer());
306     ipcMsg.SetHeader(TAG_GET_DAEMON_DISABLE_COUNT, 1, 0, 0);
307     ipcMsg.SetRaw(1, name);
308 
309 
310     nn::Result ipcResult = SendSyncRequest(s_Session);
311     if( ipcResult.IsFailure() )
312     {
313         return ipcResult;
314     }
315 
316     *pCount = ipcMsg.GetRaw<s32>(2);
317     *pCountTotal = ipcMsg.GetRaw<s32>(3);
318 
319     return ipcMsg.GetRaw<nn::Result>(1);
320 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
321 }
GetSchedulerDisableCount(s32 * pCount,s32 * pCountTotal)322 nn::Result Interface::GetSchedulerDisableCount( s32* pCount, s32* pCountTotal )
323 {
324 #ifdef NN_HARDWARE_CTR_LEGACY
325     return reinterpret_cast<InterfaceImpl*&>(s_Session)->GetSchedulerDisableCount(pCount, pCountTotal);
326 #else    // ifdef NN_HARDWARE_CTR_LEGACY
327     MessageBuffer ipcMsg(GetMessageBuffer());
328     ipcMsg.SetHeader(TAG_GET_SCHEDULER_DISABLE_COUNT, 0, 0, 0);
329 
330 
331     nn::Result ipcResult = SendSyncRequest(s_Session);
332     if( ipcResult.IsFailure() )
333     {
334         return ipcResult;
335     }
336 
337     *pCount = ipcMsg.GetRaw<s32>(2);
338     *pCountTotal = ipcMsg.GetRaw<s32>(3);
339 
340     return ipcMsg.GetRaw<nn::Result>(1);
341 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
342 }
SetScanInterval(s32 interval)343 nn::Result Interface::SetScanInterval( s32 interval )
344 {
345 #ifdef NN_HARDWARE_CTR_LEGACY
346     return reinterpret_cast<InterfaceImpl*&>(s_Session)->SetScanInterval(interval);
347 #else    // ifdef NN_HARDWARE_CTR_LEGACY
348     MessageBuffer ipcMsg(GetMessageBuffer());
349     ipcMsg.SetHeader(TAG_SET_SCAN_INTERVAL, 1, 0, 0);
350     ipcMsg.SetRaw(1, interval);
351 
352 
353     nn::Result ipcResult = SendSyncRequest(s_Session);
354     if( ipcResult.IsFailure() )
355     {
356         return ipcResult;
357     }
358 
359     return ipcMsg.GetRaw<nn::Result>(1);
360 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
361 }
GetScanInterval(s32 * pInterval)362 nn::Result Interface::GetScanInterval( s32* pInterval )
363 {
364 #ifdef NN_HARDWARE_CTR_LEGACY
365     return reinterpret_cast<InterfaceImpl*&>(s_Session)->GetScanInterval(pInterval);
366 #else    // ifdef NN_HARDWARE_CTR_LEGACY
367     MessageBuffer ipcMsg(GetMessageBuffer());
368     ipcMsg.SetHeader(TAG_GET_SCAN_INTERVAL, 0, 0, 0);
369 
370 
371     nn::Result ipcResult = SendSyncRequest(s_Session);
372     if( ipcResult.IsFailure() )
373     {
374         return ipcResult;
375     }
376 
377     *pInterval = ipcMsg.GetRaw<s32>(2);
378 
379     return ipcMsg.GetRaw<nn::Result>(1);
380 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
381 }
SetRetryInterval(s32 interval)382 nn::Result Interface::SetRetryInterval( s32 interval )
383 {
384 #ifdef NN_HARDWARE_CTR_LEGACY
385     return reinterpret_cast<InterfaceImpl*&>(s_Session)->SetRetryInterval(interval);
386 #else    // ifdef NN_HARDWARE_CTR_LEGACY
387     MessageBuffer ipcMsg(GetMessageBuffer());
388     ipcMsg.SetHeader(TAG_SET_RETRY_INTERVAL, 1, 0, 0);
389     ipcMsg.SetRaw(1, interval);
390 
391 
392     nn::Result ipcResult = SendSyncRequest(s_Session);
393     if( ipcResult.IsFailure() )
394     {
395         return ipcResult;
396     }
397 
398     return ipcMsg.GetRaw<nn::Result>(1);
399 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
400 }
GetRetryInterval(s32 * pInterval)401 nn::Result Interface::GetRetryInterval( s32* pInterval )
402 {
403 #ifdef NN_HARDWARE_CTR_LEGACY
404     return reinterpret_cast<InterfaceImpl*&>(s_Session)->GetRetryInterval(pInterval);
405 #else    // ifdef NN_HARDWARE_CTR_LEGACY
406     MessageBuffer ipcMsg(GetMessageBuffer());
407     ipcMsg.SetHeader(TAG_GET_RETRY_INTERVAL, 0, 0, 0);
408 
409 
410     nn::Result ipcResult = SendSyncRequest(s_Session);
411     if( ipcResult.IsFailure() )
412     {
413         return ipcResult;
414     }
415 
416     *pInterval = ipcMsg.GetRaw<s32>(2);
417 
418     return ipcMsg.GetRaw<nn::Result>(1);
419 #endif   // ifdef NN_HARDWARE_CTR_LEGACY else
420 }
421 
422 } // end of namespace detail
423 } // end of namespace CTR
424 } // end of namespace ndm
425 } // end of namespace nn
426 
427 
428 
429 
430 
431