Home | History | Annotate | Download | only in generated
      1 #ifndef _CHRE_SLPI_SKEL_H
      2 #define _CHRE_SLPI_SKEL_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
    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
    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
    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
    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
    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 static __inline int _skel_method(int (*_pfn)(char*, uint32_t), uint32_t _sc, remote_arg* _pra) {
    446    remote_arg* _praEnd;
    447    char* _in0[1];
    448    uint32_t _in0Len[1];
    449    uint32_t* _primIn;
    450    remote_arg* _praIn;
    451    int _nErr = 0;
    452    _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc) + REMOTE_SCALARS_INHANDLES(_sc) + REMOTE_SCALARS_OUTHANDLES(_sc));
    453    _ASSERT(_nErr, (_pra + ((2 + 0) + (0 + 0))) <= _praEnd);
    454    _ASSERT(_nErr, _pra[0].buf.nLen >= 4);
    455    _primIn = _pra[0].buf.pv;
    456    _COPY(_in0Len, 0, _primIn, 0, 4);
    457    _praIn = (_pra + 1);
    458    _ASSERT(_nErr, (int)((_praIn[0].buf.nLen / 1)) >= (int)(_in0Len[0]));
    459    _in0[0] = _praIn[0].buf.pv;
    460    _TRY(_nErr, _pfn(*_in0, *_in0Len));
    461    _CATCH(_nErr) {}
    462    return _nErr;
    463 }
    464 static __inline int _skel_method_1(int (*_pfn)(char*, uint32_t, uint32_t*), uint32_t _sc, remote_arg* _pra) {
    465    remote_arg* _praEnd;
    466    char* _rout0[1];
    467    uint32_t _rout0Len[1];
    468    uint32_t _rout1[1];
    469    uint32_t* _primIn;
    470    int _numIn[1];
    471    uint32_t* _primROut;
    472    remote_arg* _praIn;
    473    remote_arg* _praROut;
    474    int _nErr = 0;
    475    _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc) + REMOTE_SCALARS_INHANDLES(_sc) + REMOTE_SCALARS_OUTHANDLES(_sc));
    476    _ASSERT(_nErr, (_pra + ((1 + 2) + (0 + 0))) <= _praEnd);
    477    _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
    478    _ASSERT(_nErr, _pra[0].buf.nLen >= 4);
    479    _primIn = _pra[0].buf.pv;
    480    _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 4);
    481    _primROut = _pra[(_numIn[0] + 1)].buf.pv;
    482    _COPY(_rout0Len, 0, _primIn, 0, 4);
    483    _praIn = (_pra + 1);
    484    _praROut = (_praIn + _numIn[0] + 1);
    485    _ASSERT(_nErr, (int)((_praROut[0].buf.nLen / 1)) >= (int)(_rout0Len[0]));
    486    _rout0[0] = _praROut[0].buf.pv;
    487    _TRY(_nErr, _pfn(*_rout0, *_rout0Len, _rout1));
    488    _COPY(_primROut, 0, _rout1, 0, 4);
    489    _CATCH(_nErr) {}
    490    return _nErr;
    491 }
    492 static __inline int _skel_method_2(int (*_pfn)(void), uint32_t _sc, remote_arg* _pra) {
    493    remote_arg* _praEnd;
    494    int _nErr = 0;
    495    _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc) + REMOTE_SCALARS_INHANDLES(_sc) + REMOTE_SCALARS_OUTHANDLES(_sc));
    496    _ASSERT(_nErr, (_pra + ((0 + 0) + (0 + 0))) <= _praEnd);
    497    _TRY(_nErr, _pfn());
    498    _CATCH(_nErr) {}
    499    return _nErr;
    500 }
    501 __QAIC_SKEL_EXPORT int __QAIC_SKEL(chre_slpi_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_SKEL_ATTRIBUTE {
    502    switch(REMOTE_SCALARS_METHOD(_sc))
    503    {
    504       case 0:
    505       return _skel_method_2((void*)__QAIC_IMPL(chre_slpi_start_thread), _sc, _pra);
    506       case 1:
    507       return _skel_method_2((void*)__QAIC_IMPL(chre_slpi_wait_on_thread_exit), _sc, _pra);
    508       case 2:
    509       return _skel_method_2((void*)__QAIC_IMPL(chre_slpi_initialize_reverse_monitor), _sc, _pra);
    510       case 3:
    511       return _skel_method_2((void*)__QAIC_IMPL(chre_slpi_stop_thread), _sc, _pra);
    512       case 4:
    513       return _skel_method_1((void*)__QAIC_IMPL(chre_slpi_get_message_to_host), _sc, _pra);
    514       case 5:
    515       return _skel_method((void*)__QAIC_IMPL(chre_slpi_deliver_message_from_host), _sc, _pra);
    516    }
    517    return AEE_EUNSUPPORTED;
    518 }
    519 #ifdef __cplusplus
    520 }
    521 #endif
    522 #endif //_CHRE_SLPI_SKEL_H
    523