ipc.h

Go to the documentation of this file.

/*
 *  Copyright (c) Texas Instruments Incorporated 2018
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/* @} */
 
#ifndef IPC_H_
#define IPC_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
#include <ti/csl/soc.h>
#include <ti/csl/csl_types.h>
 
#include <ti/drv/ipc/include/ipc_types.h>
#include <ti/drv/ipc/include/ipc_rsctypes.h>
#include <ti/drv/ipc/include/ipc_config.h>
#include <ti/drv/ipc/include/ipc_mp.h>
#include <ti/drv/ipc/include/ipc_virtio.h>
#include <ti/drv/ipc/soc/ipc_soc.h>
#include <string.h>
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
typedef struct RPMessage_Object_s* RPMessage_Handle;
 
typedef void (*RPMessage_Callback)(RPMessage_Handle handle, void* arg, void* data,
                                      uint16_t len, uint32_t src);
 
typedef void (*RPMessage_ProcCallback)(uint32_t srcEndPt, uint32_t srcProcId,
                                       uint32_t destEndPt, void* arg);
 
 
/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */
 
typedef struct Ipc_InitPrms_s
{
    uint32_t                instId;
    Ipc_PhyToVirtFxn        phyToVirtFxn;
    Ipc_VirtToPhyFxn        virtToPhyFxn;
    Ipc_OsalPrms            osalPrms;
    Ipc_NewMsgReceivedFxn   newMsgFxn;
    Ipc_RpMboxMsgFxn       rpMboxMsgFxn;
    Ipc_PrintFxn           printFxn;
} Ipc_InitPrms;
 
typedef struct RPMessage_Params_s
{
    uint32_t  requestedEndpt;
    uint32_t  numBufs;
    void*     buf;
    uint32_t  bufSize;
    void*     stackBuffer;
    uint32_t  stackSize;
} RPMessage_Params;
 
typedef struct RPMessage_Stats_s
{
    uint32_t recvTotalMessages;
    uint32_t recvMessagesLiveTransferred;
    uint32_t recvMessagesQueued;
    uint32_t recvBufferAllocFailures;
    uint32_t recvEndpointFindFails;
} RPMessage_Stats;
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
void IpcInitPrms_init(uint32_t instId, Ipc_InitPrms *initPrms);
 
int32_t Ipc_init(const Ipc_InitPrms *cfg);
 
int32_t Ipc_deinit(void);
 
uint32_t RPMessage_getMessageBufferSize(void);
 
 
uint32_t RPMessage_getObjMemRequired(void);
 
int32_t RPMessage_init(RPMessage_Params *params);
 
int32_t RPMessage_lateInit(uint32_t proc);
 
 
void RPMessage_deInit(void);
 
 
int32_t RPMessageParams_init(RPMessage_Params *params);
 
RPMessage_Handle RPMessage_create(RPMessage_Params *params, uint32_t *endPt);
 
int32_t RPMessage_setCallback(RPMessage_Handle handle, RPMessage_Callback cb, void* arg);
 
int32_t RPMessage_setCallbackForProc(RPMessage_ProcCallback cb, void* arg, int32_t priority);
 
int32_t RPMessage_deleteCallbackForProc(void);
 
int32_t RPMessage_recv(RPMessage_Handle handle, void* data, uint16_t *len,
                      uint32_t *rplyEndPt, uint32_t *fromProcId, uint32_t timeout);
 
int32_t RPMessage_recvNb(RPMessage_Handle handle, void* data, uint16_t *len,
                   uint32_t *rplyEndPt, uint32_t *fromProcId);
 
int32_t RPMessage_send(RPMessage_Handle handle,
                      uint32_t dstProc,
                      uint32_t dstEndPt,
                      uint32_t srcEndPt,
                      void*    data,
                      uint16_t len);
 
int32_t RPMessage_delete(RPMessage_Handle *handlePtr);
 
void RPMessage_unblock(RPMessage_Handle handle);
 
 
int32_t RPMessage_getRemoteEndPt(uint32_t currProcId, const char* name, uint32_t *remoteProcId,
                             uint32_t *remoteEndPt, uint32_t timeout);
 
/*
 *  \brief Wait for an endpoint to become available on another
 *         processor with token.
 *
 *  Block the current task until the specified processor announces the
 *  named endpoint.  The name is a string that identifies the service
 *  that is offered on the endpoint.  This allows an application to both
 *  wait for the remote processor to signal that it is ready to
 *  communicate and to lookup services by name.  The procId can be that
 *  of a specific processor or PRMessage_ANY to wait for any processor
 *  to announce the named endpoint.  Suitable values for timeout are the
 *  same as for the ti.sysbios.knl.Semaphore module.
 *  This is the same as RPMessage_getRemoteEndPt, except that a token
 *  can be taken with the request, which can be used by the application
 *  to unblock the request in order to unblock it's waiting task.
 *
 *  \param currProcId    [IN] Remote processor ID
 *  \param name      [IN] Name of the endpoint
 *  \param remoteProcId    [OUT] Remote processor ID
 *  \param remoteEndPt    [OUT] Remote endpoint ID
 *  \param timeout    [IN] Timeout value (in system ticks)
 *  \param token      [IN] User-provided token that can be used to unblock the function
 *
 *  Restrictions:
 *  -  The token passed must be unique for each call.
 *
 *  \return     - #IPC_SOK: Endpoint successfully returned
 *              - #IPC_ETIMEOUT: Time out occured
 *              - #IPC_EFAIL:    Invalid input
 *              - #IPC_E_NO_ENDPOINT: End point not found
 */
int32_t RPMessage_getRemoteEndPtToken(uint32_t currProcId, const char* name, uint32_t *remoteProcId,
                             uint32_t *remoteEndPt, uint32_t timeout, uint32_t token);
 
void RPMessage_unblockGetRemoteEndPt(uint32_t token);
 
int32_t RPMessage_announce(uint32_t remoteProcId, uint32_t endPt,
       const char* name);
 
void RPMessage_getStats(RPMessage_Stats *stats);
 
void Ipc_mailboxEnableNewMsgInt(uint16_t selfId, uint16_t remoteProcId);
 
void Ipc_mailboxDisableNewMsgInt(uint16_t selfId, uint16_t remoteProcId);
 
/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */
 
/* None */
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef IPC_H_ */
 
/* @} */