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 118static __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 170typedef struct _heap _heap; 171struct _heap { 172 _heap* pPrev; 173 const char* loc; 174 uint64_t buf; 175}; 176 177typedef struct _allocator { 178 _heap* pheap; 179 uint8_t* stack; 180 uint8_t* stackEnd; 181 int nSize; 182} _allocator; 183 184_ATTRIBUTE_UNUSED 185static __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 201static __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 222static __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 234static __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 285typedef 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 319typedef struct UnionType UnionType; 320typedef struct StructType StructType; 321typedef struct SequenceType SequenceType; 322struct Type { 323 INHERIT_TYPE; 324}; 325 326struct 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 341typedef union CaseValuePtr CaseValuePtr; 342union 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 352struct 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 370struct 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 381typedef struct Parameter Parameter; 382struct 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 391typedef struct Method Method; 392struct 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 403typedef struct Interface Interface; 404 405struct 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 431static const Type types[1]; 432static const Type types[1] = {{0x1,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x1}}; 433static 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}}; 434static const Parameter* const parameterArrays[3] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2]))}; 435static 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}}; 436static const Method* const methodArrays[6] = {&(methods[0]),&(methods[0]),&(methods[0]),&(methods[0]),&(methods[1]),&(methods[2])}; 437static 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"; 438static const uint16_t methodStrings[9] = {53,137,118,27,129,106,0,73,93}; 439static 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 443extern "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 450static 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 458static 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 469extern 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 471extern 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 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 491uint32_t _chre_slpi_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare); 492 493#ifdef _WIN32 494#include "Windows.h" 495uint32_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__ 499uint32_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 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 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 534extern "C" { 535#endif 536static __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} 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} 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} 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} 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} 559static __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} 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} 586static __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} 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