1 #ifndef _CHRE_SLPI_STUB_H
2 #define _CHRE_SLPI_STUB_H
3 /**
4 * Defines the FastRPC interface between CHRE running on the SLPI and the host
5 * daemon running on the AP.
6 *
7 * Note that the interface name gets prefixed to the function names in the
8 * generated sources, with an underscore separating them.
9 *
10 * Refer to the implementations of these functions in the CHRE code that runs on
11 * the SLPI for documentation covering the parameters, return values, etc.
12 */
13 #include "chre_slpi.h"
14 #ifndef _QAIC_ENV_H
15 #define _QAIC_ENV_H
16
17 #ifdef __GNUC__
18 #ifdef __clang__
19 #pragma GCC diagnostic ignored "-Wunknown-pragmas"
20 #else
21 #pragma GCC diagnostic ignored "-Wpragmas"
22 #endif
23 #pragma GCC diagnostic ignored "-Wuninitialized"
24 #pragma GCC diagnostic ignored "-Wunused-parameter"
25 #pragma GCC diagnostic ignored "-Wunused-function"
26 #endif
27
28 #ifndef _ATTRIBUTE_UNUSED
29
30 #ifdef _WIN32
31 #define _ATTRIBUTE_UNUSED
32 #else
33 #define _ATTRIBUTE_UNUSED __attribute__ ((unused))
34 #endif
35
36 #endif // _ATTRIBUTE_UNUSED
37
38 #ifndef __QAIC_REMOTE
39 #define __QAIC_REMOTE(ff) ff
40 #endif //__QAIC_REMOTE
41
42 #ifndef __QAIC_HEADER
43 #define __QAIC_HEADER(ff) ff
44 #endif //__QAIC_HEADER
45
46 #ifndef __QAIC_HEADER_EXPORT
47 #define __QAIC_HEADER_EXPORT
48 #endif // __QAIC_HEADER_EXPORT
49
50 #ifndef __QAIC_HEADER_ATTRIBUTE
51 #define __QAIC_HEADER_ATTRIBUTE
52 #endif // __QAIC_HEADER_ATTRIBUTE
53
54 #ifndef __QAIC_IMPL
55 #define __QAIC_IMPL(ff) ff
56 #endif //__QAIC_IMPL
57
58 #ifndef __QAIC_IMPL_EXPORT
59 #define __QAIC_IMPL_EXPORT
60 #endif // __QAIC_IMPL_EXPORT
61
62 #ifndef __QAIC_IMPL_ATTRIBUTE
63 #define __QAIC_IMPL_ATTRIBUTE
64 #endif // __QAIC_IMPL_ATTRIBUTE
65
66 #ifndef __QAIC_STUB
67 #define __QAIC_STUB(ff) ff
68 #endif //__QAIC_STUB
69
70 #ifndef __QAIC_STUB_EXPORT
71 #define __QAIC_STUB_EXPORT
72 #endif // __QAIC_STUB_EXPORT
73
74 #ifndef __QAIC_STUB_ATTRIBUTE
75 #define __QAIC_STUB_ATTRIBUTE
76 #endif // __QAIC_STUB_ATTRIBUTE
77
78 #ifndef __QAIC_SKEL
79 #define __QAIC_SKEL(ff) ff
80 #endif //__QAIC_SKEL__
81
82 #ifndef __QAIC_SKEL_EXPORT
83 #define __QAIC_SKEL_EXPORT
84 #endif // __QAIC_SKEL_EXPORT
85
86 #ifndef __QAIC_SKEL_ATTRIBUTE
87 #define __QAIC_SKEL_ATTRIBUTE
88 #endif // __QAIC_SKEL_ATTRIBUTE
89
90 #ifdef __QAIC_DEBUG__
91 #ifndef __QAIC_DBG_PRINTF__
92 #include <stdio.h>
93 #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
94 #endif
95 #else
96 #define __QAIC_DBG_PRINTF__( ee ) (void)0
97 #endif
98
99
100 #define _OFFSET(src, sof) ((void*)(((char*)(src)) + (sof)))
101
102 #define _COPY(dst, dof, src, sof, sz) \
103 do {\
104 struct __copy { \
105 char ar[sz]; \
106 };\
107 *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\
108 } while (0)
109
110 #define _COPYIF(dst, dof, src, sof, sz) \
111 do {\
112 if(_OFFSET(dst, dof) != _OFFSET(src, sof)) {\
113 _COPY(dst, dof, src, sof, sz); \
114 } \
115 } while (0)
116
117 _ATTRIBUTE_UNUSED
_qaic_memmove(void * dst,void * src,int size)118 static __inline void _qaic_memmove(void* dst, void* src, int size) {
119 int i;
120 for(i = 0; i < size; ++i) {
121 ((char*)dst)[i] = ((char*)src)[i];
122 }
123 }
124
125 #define _MEMMOVEIF(dst, src, sz) \
126 do {\
127 if(dst != src) {\
128 _qaic_memmove(dst, src, sz);\
129 } \
130 } while (0)
131
132
133 #define _ASSIGN(dst, src, sof) \
134 do {\
135 dst = OFFSET(src, sof); \
136 } while (0)
137
138 #define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))
139
140 #include "AEEStdErr.h"
141
142 #define _TRY(ee, func) \
143 do { \
144 if (AEE_SUCCESS != ((ee) = func)) {\
145 __QAIC_DBG_PRINTF__((__FILE__ ":%d:error:%d:%s\n", __LINE__, (int)(ee),#func));\
146 goto ee##bail;\
147 } \
148 } while (0)
149
150 #define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)
151
152 #define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)
153
154 #ifdef __QAIC_DEBUG__
155 #define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
156 #else
157 #define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, 0, size, alignment, (void**)&pv))
158 #endif
159
160
161 #endif // _QAIC_ENV_H
162
163 #include "remote.h"
164 #ifndef _ALLOCATOR_H
165 #define _ALLOCATOR_H
166
167 #include <stdlib.h>
168 #include <stdint.h>
169
170 typedef struct _heap _heap;
171 struct _heap {
172 _heap* pPrev;
173 const char* loc;
174 uint64_t buf;
175 };
176
177 typedef struct _allocator {
178 _heap* pheap;
179 uint8_t* stack;
180 uint8_t* stackEnd;
181 int nSize;
182 } _allocator;
183
184 _ATTRIBUTE_UNUSED
_heap_alloc(_heap ** ppa,const char * loc,int size,void ** ppbuf)185 static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
186 _heap* pn = 0;
187 pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
188 if(pn != 0) {
189 pn->pPrev = *ppa;
190 pn->loc = loc;
191 *ppa = pn;
192 *ppbuf = (void*)&(pn->buf);
193 return 0;
194 } else {
195 return -1;
196 }
197 }
198 #define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))
199
200 _ATTRIBUTE_UNUSED
_allocator_alloc(_allocator * me,const char * loc,int size,unsigned int al,void ** ppbuf)201 static __inline int _allocator_alloc(_allocator* me,
202 const char* loc,
203 int size,
204 unsigned int al,
205 void** ppbuf) {
206 if(size < 0) {
207 return -1;
208 } else if (size == 0) {
209 *ppbuf = 0;
210 return 0;
211 }
212 if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
213 *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
214 me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
215 return 0;
216 } else {
217 return _heap_alloc(&me->pheap, loc, size, ppbuf);
218 }
219 }
220
221 _ATTRIBUTE_UNUSED
_allocator_deinit(_allocator * me)222 static __inline void _allocator_deinit(_allocator* me) {
223 _heap* pa = me->pheap;
224 while(pa != 0) {
225 _heap* pn = pa;
226 const char* loc = pn->loc;
227 (void)loc;
228 pa = pn->pPrev;
229 free(pn);
230 }
231 }
232
233 _ATTRIBUTE_UNUSED
_allocator_init(_allocator * me,uint8_t * stack,int stackSize)234 static __inline void _allocator_init(_allocator* me, uint8_t* stack, int stackSize) {
235 me->stack = stack;
236 me->stackEnd = stack + stackSize;
237 me->nSize = stackSize;
238 me->pheap = 0;
239 }
240
241
242 #endif // _ALLOCATOR_H
243
244 #ifndef SLIM_H
245 #define SLIM_H
246
247 #include <stdint.h>
248
249 //a C data structure for the idl types that can be used to implement
250 //static and dynamic language bindings fairly efficiently.
251 //
252 //the goal is to have a minimal ROM and RAM footprint and without
253 //doing too many allocations. A good way to package these things seemed
254 //like the module boundary, so all the idls within one module can share
255 //all the type references.
256
257
258 #define PARAMETER_IN 0x0
259 #define PARAMETER_OUT 0x1
260 #define PARAMETER_INOUT 0x2
261 #define PARAMETER_ROUT 0x3
262 #define PARAMETER_INROUT 0x4
263
264 //the types that we get from idl
265 #define TYPE_OBJECT 0x0
266 #define TYPE_INTERFACE 0x1
267 #define TYPE_PRIMITIVE 0x2
268 #define TYPE_ENUM 0x3
269 #define TYPE_STRING 0x4
270 #define TYPE_WSTRING 0x5
271 #define TYPE_STRUCTURE 0x6
272 #define TYPE_UNION 0x7
273 #define TYPE_ARRAY 0x8
274 #define TYPE_SEQUENCE 0x9
275
276 //these require the pack/unpack to recurse
277 //so it's a hint to those languages that can optimize in cases where
278 //recursion isn't necessary.
279 #define TYPE_COMPLEX_STRUCTURE (0x10 | TYPE_STRUCTURE)
280 #define TYPE_COMPLEX_UNION (0x10 | TYPE_UNION)
281 #define TYPE_COMPLEX_ARRAY (0x10 | TYPE_ARRAY)
282 #define TYPE_COMPLEX_SEQUENCE (0x10 | TYPE_SEQUENCE)
283
284
285 typedef struct Type Type;
286
287 #define INHERIT_TYPE\
288 int32_t nativeSize; /*in the simple case its the same as wire size and alignment*/\
289 union {\
290 struct {\
291 const uintptr_t p1;\
292 const uintptr_t p2;\
293 } _cast;\
294 struct {\
295 uint32_t iid;\
296 uint32_t bNotNil;\
297 } object;\
298 struct {\
299 const Type *arrayType;\
300 int32_t nItems;\
301 } array;\
302 struct {\
303 const Type *seqType;\
304 int32_t nMaxLen;\
305 } seqSimple; \
306 struct {\
307 uint32_t bFloating;\
308 uint32_t bSigned;\
309 } prim; \
310 const SequenceType* seqComplex;\
311 const UnionType *unionType;\
312 const StructType *structType;\
313 int32_t stringMaxLen;\
314 uint8_t bInterfaceNotNil;\
315 } param;\
316 uint8_t type;\
317 uint8_t nativeAlignment\
318
319 typedef struct UnionType UnionType;
320 typedef struct StructType StructType;
321 typedef struct SequenceType SequenceType;
322 struct Type {
323 INHERIT_TYPE;
324 };
325
326 struct SequenceType {
327 const Type * seqType;
328 uint32_t nMaxLen;
329 uint32_t inSize;
330 uint32_t routSizePrimIn;
331 uint32_t routSizePrimROut;
332 };
333
334 //byte offset from the start of the case values for
335 //this unions case value array. it MUST be aligned
336 //at the alignment requrements for the descriptor
337 //
338 //if negative it means that the unions cases are
339 //simple enumerators, so the value read from the descriptor
340 //can be used directly to find the correct case
341 typedef union CaseValuePtr CaseValuePtr;
342 union CaseValuePtr {
343 const uint8_t* value8s;
344 const uint16_t* value16s;
345 const uint32_t* value32s;
346 const uint64_t* value64s;
347 };
348
349 //these are only used in complex cases
350 //so I pulled them out of the type definition as references to make
351 //the type smaller
352 struct UnionType {
353 const Type *descriptor;
354 uint32_t nCases;
355 const CaseValuePtr caseValues;
356 const Type * const *cases;
357 int32_t inSize;
358 int32_t routSizePrimIn;
359 int32_t routSizePrimROut;
360 uint8_t inAlignment;
361 uint8_t routAlignmentPrimIn;
362 uint8_t routAlignmentPrimROut;
363 uint8_t inCaseAlignment;
364 uint8_t routCaseAlignmentPrimIn;
365 uint8_t routCaseAlignmentPrimROut;
366 uint8_t nativeCaseAlignment;
367 uint8_t bDefaultCase;
368 };
369
370 struct StructType {
371 uint32_t nMembers;
372 const Type * const *members;
373 int32_t inSize;
374 int32_t routSizePrimIn;
375 int32_t routSizePrimROut;
376 uint8_t inAlignment;
377 uint8_t routAlignmentPrimIn;
378 uint8_t routAlignmentPrimROut;
379 };
380
381 typedef struct Parameter Parameter;
382 struct Parameter {
383 INHERIT_TYPE;
384 uint8_t mode;
385 uint8_t bNotNil;
386 };
387
388 #define SLIM_IFPTR32(is32,is64) (sizeof(uintptr_t) == 4 ? (is32) : (is64))
389 #define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)
390
391 typedef struct Method Method;
392 struct Method {
393 uint32_t uScalars; //no method index
394 int32_t primInSize;
395 int32_t primROutSize;
396 int maxArgs;
397 int numParams;
398 const Parameter * const *params;
399 uint8_t primInAlignment;
400 uint8_t primROutAlignment;
401 };
402
403 typedef struct Interface Interface;
404
405 struct Interface {
406 int nMethods;
407 const Method * const *methodArray;
408 int nIIds;
409 const uint32_t *iids;
410 const uint16_t* methodStringArray;
411 const uint16_t* methodStrings;
412 const char* strings;
413 };
414
415
416 #endif //SLIM_H
417
418
419 #ifndef _CHRE_SLPI_SLIM_H
420 #define _CHRE_SLPI_SLIM_H
421 #include "remote.h"
422 #include <stdint.h>
423
424 #ifndef __QAIC_SLIM
425 #define __QAIC_SLIM(ff) ff
426 #endif
427 #ifndef __QAIC_SLIM_EXPORT
428 #define __QAIC_SLIM_EXPORT
429 #endif
430
431 static const Type types[1];
432 static const Type types[1] = {{0x1,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x1}};
433 static const Parameter parameters[3] = {{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(types[0]),(const uintptr_t)0x0}}, 9,SLIM_IFPTR32(0x4,0x8),3,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x4,3,0},{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(types[0]),(const uintptr_t)0x0}}, 9,SLIM_IFPTR32(0x4,0x8),0,0}};
434 static const Parameter* const parameterArrays[3] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2]))};
435 static const Method methods[3] = {{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x0,0x0),0x0,0x0,0,0,0,0x0,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x1,0x2,0x0,0x0),0x4,0x4,4,2,(&(parameterArrays[0])),0x4,0x4},{REMOTE_SCALARS_MAKEX(0,0,0x2,0x0,0x0,0x0),0x4,0x0,2,1,(&(parameterArrays[2])),0x4,0x0}};
436 static const Method* const methodArrays[6] = {&(methods[0]),&(methods[0]),&(methods[0]),&(methods[0]),&(methods[1]),&(methods[2])};
437 static const char strings[144] = "initialize_reverse_monitor\0deliver_message_from_host\0get_message_to_host\0wait_on_thread_exit\0start_thread\0stop_thread\0messageLen\0message\0buffer\0";
438 static const uint16_t methodStrings[9] = {53,137,118,27,129,106,0,73,93};
439 static const uint16_t methodStringsArrays[6] = {8,7,6,5,0,3};
440 __QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(chre_slpi_slim) = {6,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
441 #endif //_CHRE_SLPI_SLIM_H
442 #ifdef __cplusplus
443 extern "C" {
444 #endif
445
446 #ifndef _const_chre_slpi_handle
447 #define _const_chre_slpi_handle ((remote_handle)-1)
448 #endif //_const_chre_slpi_handle
449
_chre_slpi_pls_dtor(void * data)450 static void _chre_slpi_pls_dtor(void* data) {
451 remote_handle* ph = (remote_handle*)data;
452 if(_const_chre_slpi_handle != *ph) {
453 (void)__QAIC_REMOTE(remote_handle_close)(*ph);
454 *ph = _const_chre_slpi_handle;
455 }
456 }
457
_chre_slpi_pls_ctor(void * ctx,void * data)458 static int _chre_slpi_pls_ctor(void* ctx, void* data) {
459 remote_handle* ph = (remote_handle*)data;
460 *ph = _const_chre_slpi_handle;
461 if(*ph == (remote_handle)-1) {
462 return __QAIC_REMOTE(remote_handle_open)((const char*)ctx, ph);
463 }
464 return 0;
465 }
466
467 #if (defined __qdsp6__) || (defined __hexagon__)
468 #pragma weak adsp_pls_add_lookup
469 extern int adsp_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
470 #pragma weak HAP_pls_add_lookup
471 extern int HAP_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
472
_chre_slpi_handle(void)473 __QAIC_STUB_EXPORT remote_handle _chre_slpi_handle(void) {
474 remote_handle* ph;
475 if(adsp_pls_add_lookup) {
476 if(0 == adsp_pls_add_lookup((uint32_t)_chre_slpi_handle, 0, sizeof(*ph), _chre_slpi_pls_ctor, "chre_slpi", _chre_slpi_pls_dtor, (void**)&ph)) {
477 return *ph;
478 }
479 return (remote_handle)-1;
480 } else if(HAP_pls_add_lookup) {
481 if(0 == HAP_pls_add_lookup((uint32_t)_chre_slpi_handle, 0, sizeof(*ph), _chre_slpi_pls_ctor, "chre_slpi", _chre_slpi_pls_dtor, (void**)&ph)) {
482 return *ph;
483 }
484 return (remote_handle)-1;
485 }
486 return(remote_handle)-1;
487 }
488
489 #else //__qdsp6__ || __hexagon__
490
491 uint32_t _chre_slpi_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare);
492
493 #ifdef _WIN32
494 #include "Windows.h"
_chre_slpi_atomic_CompareAndExchange(uint32_t * volatile puDest,uint32_t uExchange,uint32_t uCompare)495 uint32_t _chre_slpi_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
496 return (uint32_t)InterlockedCompareExchange((volatile LONG*)puDest, (LONG)uExchange, (LONG)uCompare);
497 }
498 #elif __GNUC__
_chre_slpi_atomic_CompareAndExchange(uint32_t * volatile puDest,uint32_t uExchange,uint32_t uCompare)499 uint32_t _chre_slpi_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
500 return __sync_val_compare_and_swap(puDest, uCompare, uExchange);
501 }
502 #endif //_WIN32
503
504
_chre_slpi_handle(void)505 __QAIC_STUB_EXPORT remote_handle _chre_slpi_handle(void) {
506 static remote_handle handle = _const_chre_slpi_handle;
507 if((remote_handle)-1 != handle) {
508 return handle;
509 } else {
510 remote_handle tmp;
511 int nErr = _chre_slpi_pls_ctor("chre_slpi", (void*)&tmp);
512 if(nErr) {
513 return (remote_handle)-1;
514 }
515 if(((remote_handle)-1 != handle) || ((remote_handle)-1 != (remote_handle)_chre_slpi_atomic_CompareAndExchange((uint32_t*)&handle, (uint32_t)tmp, (uint32_t)-1))) {
516 _chre_slpi_pls_dtor(&tmp);
517 }
518 return handle;
519 }
520 }
521
522 #endif //__qdsp6__
523
__QAIC_STUB(chre_slpi_skel_invoke)524 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE {
525 return __QAIC_REMOTE(remote_handle_invoke)(_chre_slpi_handle(), _sc, _pra);
526 }
527
528 #ifdef __cplusplus
529 }
530 #endif
531
532
533 #ifdef __cplusplus
534 extern "C" {
535 #endif
_stub_method(remote_handle _handle,uint32_t _mid)536 static __inline int _stub_method(remote_handle _handle, uint32_t _mid) {
537 remote_arg* _pra = 0;
538 int _nErr = 0;
539 _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 0, 0, 0), _pra));
540 _CATCH(_nErr) {}
541 return _nErr;
542 }
__QAIC_STUB(chre_slpi_start_thread)543 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_start_thread)(void) __QAIC_STUB_ATTRIBUTE {
544 uint32_t _mid = 0;
545 return _stub_method(_chre_slpi_handle(), _mid);
546 }
__QAIC_STUB(chre_slpi_wait_on_thread_exit)547 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_wait_on_thread_exit)(void) __QAIC_STUB_ATTRIBUTE {
548 uint32_t _mid = 1;
549 return _stub_method(_chre_slpi_handle(), _mid);
550 }
__QAIC_STUB(chre_slpi_initialize_reverse_monitor)551 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_initialize_reverse_monitor)(void) __QAIC_STUB_ATTRIBUTE {
552 uint32_t _mid = 2;
553 return _stub_method(_chre_slpi_handle(), _mid);
554 }
__QAIC_STUB(chre_slpi_stop_thread)555 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_stop_thread)(void) __QAIC_STUB_ATTRIBUTE {
556 uint32_t _mid = 3;
557 return _stub_method(_chre_slpi_handle(), _mid);
558 }
_stub_method_1(remote_handle _handle,uint32_t _mid,char * _rout0[1],uint32_t _rout0Len[1],uint32_t _rout1[1])559 static __inline int _stub_method_1(remote_handle _handle, uint32_t _mid, char* _rout0[1], uint32_t _rout0Len[1], uint32_t _rout1[1]) {
560 int _numIn[1];
561 remote_arg _pra[3];
562 uint32_t _primIn[1];
563 uint32_t _primROut[1];
564 remote_arg* _praIn;
565 remote_arg* _praROut;
566 int _nErr = 0;
567 _numIn[0] = 0;
568 _pra[0].buf.pv = (void*)_primIn;
569 _pra[0].buf.nLen = sizeof(_primIn);
570 _pra[(_numIn[0] + 1)].buf.pv = (void*)_primROut;
571 _pra[(_numIn[0] + 1)].buf.nLen = sizeof(_primROut);
572 _COPY(_primIn, 0, _rout0Len, 0, 4);
573 _praIn = (_pra + 1);
574 _praROut = (_praIn + _numIn[0] + 1);
575 _praROut[0].buf.pv = _rout0[0];
576 _praROut[0].buf.nLen = (1 * _rout0Len[0]);
577 _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 1, 2, 0, 0), _pra));
578 _COPY(_rout1, 0, _primROut, 0, 4);
579 _CATCH(_nErr) {}
580 return _nErr;
581 }
__QAIC_STUB(chre_slpi_get_message_to_host)582 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_get_message_to_host)(unsigned char* buffer, int bufferLen, unsigned int* messageLen) __QAIC_STUB_ATTRIBUTE {
583 uint32_t _mid = 4;
584 return _stub_method_1(_chre_slpi_handle(), _mid, (char**)&buffer, (uint32_t*)&bufferLen, (uint32_t*)messageLen);
585 }
_stub_method_2(remote_handle _handle,uint32_t _mid,char * _in0[1],uint32_t _in0Len[1])586 static __inline int _stub_method_2(remote_handle _handle, uint32_t _mid, char* _in0[1], uint32_t _in0Len[1]) {
587 remote_arg _pra[2];
588 uint32_t _primIn[1];
589 remote_arg* _praIn;
590 int _nErr = 0;
591 _pra[0].buf.pv = (void*)_primIn;
592 _pra[0].buf.nLen = sizeof(_primIn);
593 _COPY(_primIn, 0, _in0Len, 0, 4);
594 _praIn = (_pra + 1);
595 _praIn[0].buf.pv = _in0[0];
596 _praIn[0].buf.nLen = (1 * _in0Len[0]);
597 _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 2, 0, 0, 0), _pra));
598 _CATCH(_nErr) {}
599 return _nErr;
600 }
__QAIC_STUB(chre_slpi_deliver_message_from_host)601 __QAIC_STUB_EXPORT int __QAIC_STUB(chre_slpi_deliver_message_from_host)(const unsigned char* message, int messageLen) __QAIC_STUB_ATTRIBUTE {
602 uint32_t _mid = 5;
603 return _stub_method_2(_chre_slpi_handle(), _mid, (char**)&message, (uint32_t*)&messageLen);
604 }
605 #ifdef __cplusplus
606 }
607 #endif
608 #endif //_CHRE_SLPI_STUB_H
609