rpmsg.h

Go to the documentation of this file.

/*
 * Remote processor messaging
 *
 * Copyright (C) 2011 Texas Instruments, Inc.
 * Copyright (C) 2011 Google, Inc.
 * All rights reserved.
 * Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _RPMSG_H_
#define _RPMSG_H_
 
#include <metal/compiler.h>
#include <metal/mutex.h>
#include <metal/list.h>
#include <metal/utilities.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
 
#if defined __cplusplus
extern "C" {
#endif
 
/* Configurable parameters */
#define RPMSG_NAME_SIZE                 (32)
#define RPMSG_ADDR_BMP_SIZE             (128)
 
#define RPMSG_NS_EPT_ADDR               (0x35)
#define RPMSG_RESERVED_ADDRESSES        (1024)
#define RPMSG_ADDR_ANY                  0xFFFFFFFF
 
/* Error macros. */
#define RPMSG_SUCCESS                   0
#define RPMSG_ERROR_BASE                -2000
#define RPMSG_ERR_NO_MEM                (RPMSG_ERROR_BASE - 1)
#define RPMSG_ERR_NO_BUFF               (RPMSG_ERROR_BASE - 2)
#define RPMSG_ERR_PARAM                 (RPMSG_ERROR_BASE - 3)
#define RPMSG_ERR_DEV_STATE             (RPMSG_ERROR_BASE - 4)
#define RPMSG_ERR_BUFF_SIZE             (RPMSG_ERROR_BASE - 5)
#define RPMSG_ERR_INIT                  (RPMSG_ERROR_BASE - 6)
#define RPMSG_ERR_ADDR                  (RPMSG_ERROR_BASE - 7)
#define RPMSG_ERR_PERM                  (RPMSG_ERROR_BASE - 8)
#define RPMSG_EOPNOTSUPP                (RPMSG_ERROR_BASE - 9)
 
struct rpmsg_endpoint;
struct rpmsg_device;
 
/* Returns positive value on success or negative error value on failure */
typedef int (*rpmsg_ept_cb)(struct rpmsg_endpoint *ept, void *data,
                            size_t len, uint32_t src, void *priv);
typedef void (*rpmsg_ept_release_cb)(struct rpmsg_endpoint *ept);
typedef void (*rpmsg_ns_unbind_cb)(struct rpmsg_endpoint *ept);
typedef void (*rpmsg_ns_bind_cb)(struct rpmsg_device *rdev,
                                 const char *name, uint32_t dest);

struct rpmsg_endpoint {
        char name[RPMSG_NAME_SIZE];

        struct rpmsg_device *rdev;

        uint32_t addr;

        uint32_t dest_addr;

        uint32_t refcnt;

        rpmsg_ept_release_cb release_cb;

        rpmsg_ept_cb cb;

        rpmsg_ns_unbind_cb ns_unbind_cb;

        struct metal_list node;

        void *priv;
};

struct rpmsg_device_ops {
        int (*send_offchannel_raw)(struct rpmsg_device *rdev,
                                   uint32_t src, uint32_t dst,
                                   const void *data, int len, int wait);

        void (*hold_rx_buffer)(struct rpmsg_device *rdev, void *rxbuf);

        void (*release_rx_buffer)(struct rpmsg_device *rdev, void *rxbuf);

        void *(*get_tx_payload_buffer)(struct rpmsg_device *rdev,
                                       uint32_t *len, int wait);

        int (*send_offchannel_nocopy)(struct rpmsg_device *rdev,
                                      uint32_t src, uint32_t dst,
                                      const void *data, int len);

        int (*release_tx_buffer)(struct rpmsg_device *rdev, void *txbuf);

        int (*get_rx_buffer_size)(struct rpmsg_device *rdev);

        int (*get_tx_buffer_size)(struct rpmsg_device *rdev);
};

struct rpmsg_device {
        struct metal_list endpoints;

        struct rpmsg_endpoint ns_ept;

        unsigned long bitmap[metal_bitmap_longs(RPMSG_ADDR_BMP_SIZE)];
        unsigned int bitnext;

        metal_mutex_t lock;

        rpmsg_ns_bind_cb ns_bind_cb;

        rpmsg_ns_bind_cb ns_unbind_cb;

        struct rpmsg_device_ops ops;

        bool support_ns;
};

int rpmsg_send_offchannel_raw(struct rpmsg_endpoint *ept, uint32_t src,
                              uint32_t dst, const void *data, int len,
                              int wait);

static inline int rpmsg_send(struct rpmsg_endpoint *ept, const void *data,
                             int len)
{
        if (!ept)
                return RPMSG_ERR_PARAM;
 
        return rpmsg_send_offchannel_raw(ept, ept->addr, ept->dest_addr, data,
                                         len, true);
}

static inline int rpmsg_sendto(struct rpmsg_endpoint *ept, const void *data,
                               int len, uint32_t dst)
{
        if (!ept)
                return RPMSG_ERR_PARAM;
 
        return rpmsg_send_offchannel_raw(ept, ept->addr, dst, data, len, true);
}

static inline int rpmsg_send_offchannel(struct rpmsg_endpoint *ept,
                                        uint32_t src, uint32_t dst,
                                        const void *data, int len)
{
        return rpmsg_send_offchannel_raw(ept, src, dst, data, len, true);
}

static inline int rpmsg_trysend(struct rpmsg_endpoint *ept, const void *data,
                                int len)
{
        if (!ept)
                return RPMSG_ERR_PARAM;
 
        return rpmsg_send_offchannel_raw(ept, ept->addr, ept->dest_addr, data,
                                         len, false);
}

static inline int rpmsg_trysendto(struct rpmsg_endpoint *ept, const void *data,
                                  int len, uint32_t dst)
{
        if (!ept)
                return RPMSG_ERR_PARAM;
 
        return rpmsg_send_offchannel_raw(ept, ept->addr, dst, data, len, false);
}

static inline int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept,
                                           uint32_t src, uint32_t dst,
                                           const void *data, int len)
{
        return rpmsg_send_offchannel_raw(ept, src, dst, data, len, false);
}

void rpmsg_hold_rx_buffer(struct rpmsg_endpoint *ept, void *rxbuf);

void rpmsg_release_rx_buffer(struct rpmsg_endpoint *ept, void *rxbuf);

void *rpmsg_get_tx_payload_buffer(struct rpmsg_endpoint *ept,
                                  uint32_t *len, int wait);

int rpmsg_release_tx_buffer(struct rpmsg_endpoint *ept, void *txbuf);

int rpmsg_get_tx_buffer_size(struct rpmsg_endpoint *ept);

int rpmsg_get_rx_buffer_size(struct rpmsg_endpoint *ept);

int rpmsg_send_offchannel_nocopy(struct rpmsg_endpoint *ept, uint32_t src,
                                 uint32_t dst, const void *data, int len);

static inline int rpmsg_sendto_nocopy(struct rpmsg_endpoint *ept,
                                      const void *data, int len, uint32_t dst)
{
        if (!ept)
                return RPMSG_ERR_PARAM;
 
        return rpmsg_send_offchannel_nocopy(ept, ept->addr, dst, data, len);
}

static inline int rpmsg_send_nocopy(struct rpmsg_endpoint *ept,
                                    const void *data, int len)
{
        if (!ept)
                return RPMSG_ERR_PARAM;
 
        return rpmsg_send_offchannel_nocopy(ept, ept->addr,
                                            ept->dest_addr, data, len);
}

int rpmsg_create_ept(struct rpmsg_endpoint *ept, struct rpmsg_device *rdev,
                     const char *name, uint32_t src, uint32_t dest,
                     rpmsg_ept_cb cb, rpmsg_ns_unbind_cb ns_unbind_cb);

void rpmsg_destroy_ept(struct rpmsg_endpoint *ept);

static inline unsigned int is_rpmsg_ept_ready(struct rpmsg_endpoint *ept)
{
        return ept && ept->rdev && ept->dest_addr != RPMSG_ADDR_ANY;
}
 
#if defined __cplusplus
}
#endif
 
#endif                          /* _RPMSG_H_ */