remoteproc.h

Go to the documentation of this file.

/*
 * Remoteproc Framework
 *
 * Copyright(c) 2018 Xilinx Ltd.
 * Copyright(c) 2011 Texas Instruments, Inc.
 * Copyright(c) 2011 Google, Inc.
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef REMOTEPROC_H
#define REMOTEPROC_H
 
#include <metal/io.h>
#include <metal/mutex.h>
#include <metal/compiler.h>
 
#if defined __cplusplus
extern "C" {
#endif
 
#define RSC_NOTIFY_ID_ANY 0xFFFFFFFFU
 
#define RPROC_MAX_NAME_LEN 32
 
METAL_PACKED_BEGIN
struct resource_table {
        uint32_t ver;
        uint32_t num;
        uint32_t reserved[2];
        uint32_t offset[0];
} METAL_PACKED_END;
 
METAL_PACKED_BEGIN
struct fw_rsc_hdr {
        uint32_t type;
        uint8_t data[0];
} METAL_PACKED_END;
 
enum fw_resource_type {
        RSC_CARVEOUT = 0,
        RSC_DEVMEM = 1,
        RSC_TRACE = 2,
        RSC_VDEV = 3,
        RSC_LAST = 4,
        RSC_VENDOR_START = 128,
        RSC_VENDOR_END = 512,
};
 
#define FW_RSC_U64_ADDR_ANY 0xFFFFFFFFFFFFFFFFUL
#define FW_RSC_U32_ADDR_ANY 0xFFFFFFFFUL
 
METAL_PACKED_BEGIN
struct fw_rsc_carveout {
        uint32_t type;
        uint32_t da;
        uint32_t pa;
        uint32_t len;
        uint32_t flags;
        uint32_t reserved;
        uint8_t name[RPROC_MAX_NAME_LEN];
} METAL_PACKED_END;
 
METAL_PACKED_BEGIN
struct fw_rsc_devmem {
        uint32_t type;
        uint32_t da;
        uint32_t pa;
        uint32_t len;
        uint32_t flags;
        uint32_t reserved;
        uint8_t name[RPROC_MAX_NAME_LEN];
} METAL_PACKED_END;
 
METAL_PACKED_BEGIN
struct fw_rsc_trace {
        uint32_t type;
        uint32_t da;
        uint32_t len;
        uint32_t reserved;
        uint8_t name[RPROC_MAX_NAME_LEN];
} METAL_PACKED_END;
 
METAL_PACKED_BEGIN
struct fw_rsc_vdev_vring {
        uint32_t da;
        uint32_t align;
        uint32_t num;
        uint32_t notifyid;
        uint32_t reserved;
} METAL_PACKED_END;
 
METAL_PACKED_BEGIN
struct fw_rsc_vdev {
        uint32_t type;
        uint32_t id;
        uint32_t notifyid;
        uint32_t dfeatures;
        uint32_t gfeatures;
        uint32_t config_len;
        uint8_t status;
        uint8_t num_of_vrings;
        uint8_t reserved[2];
        struct fw_rsc_vdev_vring vring[0];
} METAL_PACKED_END;
 
METAL_PACKED_BEGIN
struct fw_rsc_vendor {
        uint32_t type;
        uint32_t len;
} METAL_PACKED_END;
 
struct loader_ops;
struct image_store_ops;
struct remoteproc_ops;
 
struct remoteproc_mem {
        metal_phys_addr_t da;
        metal_phys_addr_t pa;
        size_t size;
        char name[RPROC_MAX_NAME_LEN];
        struct metal_io_region *io;
        struct metal_list node;
};
 
struct remoteproc {
        metal_mutex_t lock;
        void *rsc_table;
        size_t rsc_len;
        struct metal_io_region *rsc_io;
        struct metal_list mems;
        struct metal_list vdevs;
        unsigned long bitmap;
        const struct remoteproc_ops *ops;
        metal_phys_addr_t bootaddr;
        const struct loader_ops *loader;
        unsigned int state;
        void *priv;
};
 
struct remoteproc_ops {
        struct remoteproc *(*init)(struct remoteproc *rproc,
                                   const struct remoteproc_ops *ops, void *arg);
        void (*remove)(struct remoteproc *rproc);
        void *(*mmap)(struct remoteproc *rproc,
                      metal_phys_addr_t *pa, metal_phys_addr_t *da,
                      size_t size, unsigned int attribute,
                      struct metal_io_region **io);
        int (*handle_rsc)(struct remoteproc *rproc, void *rsc, size_t len);
        int (*config)(struct remoteproc *rproc, void *data);
        int (*start)(struct remoteproc *rproc);
        int (*stop)(struct remoteproc *rproc);
        int (*shutdown)(struct remoteproc *rproc);
        int (*notify)(struct remoteproc *rproc, uint32_t id);
        struct remoteproc_mem *(*get_mem)(struct remoteproc *rproc,
                                          const char *name,
                                          metal_phys_addr_t pa,
                                          metal_phys_addr_t da,
                                          void *va, size_t size,
                                          struct remoteproc_mem *buf);
};
 
/* Remoteproc error codes */
#define RPROC_EBASE     0
#define RPROC_ENOMEM    (RPROC_EBASE + 1)
#define RPROC_EINVAL    (RPROC_EBASE + 2)
#define RPROC_ENODEV    (RPROC_EBASE + 3)
#define RPROC_EAGAIN    (RPROC_EBASE + 4)
#define RPROC_ERR_RSC_TAB_TRUNC (RPROC_EBASE + 5)
#define RPROC_ERR_RSC_TAB_VER   (RPROC_EBASE + 6)
#define RPROC_ERR_RSC_TAB_RSVD  (RPROC_EBASE + 7)
#define RPROC_ERR_RSC_TAB_VDEV_NRINGS (RPROC_EBASE + 9)
#define RPROC_ERR_RSC_TAB_NP          (RPROC_EBASE + 10)
#define RPROC_ERR_RSC_TAB_NS          (RPROC_EBASE + 11)
#define RPROC_ERR_LOADER_STATE (RPROC_EBASE + 12)
#define RPROC_EMAX      (RPROC_EBASE + 16)
#define RPROC_EPTR      (void *)(-1)
#define RPROC_EOF       (void *)(-1)
 
static inline long RPROC_PTR_ERR(const void *ptr)
{
        return (long)ptr;
}
 
static inline int RPROC_IS_ERR(const void *ptr)
{
        if ((unsigned long)ptr >= (unsigned long)(-RPROC_EMAX))
                return 1;
        else
                return 0;
}
 
static inline void *RPROC_ERR_PTR(long error)
{
        return (void *)error;
}
 
enum remoteproc_state {
        RPROC_OFFLINE           = 0,
        RPROC_CONFIGURED        = 1,
        RPROC_READY             = 2,
        RPROC_RUNNING           = 3,
        RPROC_SUSPENDED         = 4,
        RPROC_ERROR             = 5,
        RPROC_STOPPED           = 6,
        RPROC_LAST              = 7,
};
 
struct remoteproc *remoteproc_init(struct remoteproc *rproc,
                                   const struct remoteproc_ops *ops,
                                   void *priv);
 
int remoteproc_remove(struct remoteproc *rproc);
 
static inline void
remoteproc_init_mem(struct remoteproc_mem *mem, const char *name,
                    metal_phys_addr_t pa, metal_phys_addr_t da,
                    size_t size, struct metal_io_region *io)
{
        if (!mem || !io || size == 0)
                return;
        if (name)
                strncpy(mem->name, name, sizeof(mem->name));
        else
                mem->name[0] = 0;
        mem->pa = pa;
        mem->da = da;
        mem->io = io;
        mem->size = size;
}
 
static inline void
remoteproc_add_mem(struct remoteproc *rproc, struct remoteproc_mem *mem)
{
        if (!rproc || !mem)
                return;
        metal_list_add_tail(&rproc->mems, &mem->node);
}
 
struct metal_io_region *
remoteproc_get_io_with_name(struct remoteproc *rproc,
                            const char *name);
 
struct metal_io_region *
remoteproc_get_io_with_pa(struct remoteproc *rproc,
                          metal_phys_addr_t pa);
 
struct metal_io_region *
remoteproc_get_io_with_da(struct remoteproc *rproc,
                          metal_phys_addr_t da,
                          unsigned long *offset);
 
struct metal_io_region *
remoteproc_get_io_with_va(struct remoteproc *rproc,
                          void *va);
 
void *remoteproc_mmap(struct remoteproc *rproc,
                      metal_phys_addr_t *pa, metal_phys_addr_t *da,
                      size_t size, unsigned int attribute,
                      struct metal_io_region **io);
 
int remoteproc_set_rsc_table(struct remoteproc *rproc,
                             struct resource_table *rsc_table,
                             size_t rsc_size);
 
int remoteproc_config(struct remoteproc *rproc, void *data);
 
int remoteproc_start(struct remoteproc *rproc);
 
int remoteproc_stop(struct remoteproc *rproc);
 
int remoteproc_shutdown(struct remoteproc *rproc);
 
int remoteproc_load(struct remoteproc *rproc, const char *path,
                    void *store, const struct image_store_ops *store_ops,
                    void **img_info);
 
int remoteproc_load_noblock(struct remoteproc *rproc,
                            const void *img_data, size_t offset, size_t len,
                            void **img_info,
                            metal_phys_addr_t *pa, struct metal_io_region **io,
                            size_t *noffset, size_t *nlen,
                            size_t *nmlen, unsigned char *padding);
 
unsigned int remoteproc_allocate_id(struct remoteproc *rproc,
                                    unsigned int start,
                                    unsigned int end);
 
struct virtio_device *
remoteproc_create_virtio(struct remoteproc *rproc,
                         int vdev_id, unsigned int role,
                         void (*rst_cb)(struct virtio_device *vdev));
 
void remoteproc_remove_virtio(struct remoteproc *rproc,
                              struct virtio_device *vdev);
 
int remoteproc_get_notification(struct remoteproc *rproc,
                                uint32_t notifyid);
#if defined __cplusplus
}
#endif
 
#endif /* REMOTEPROC_H_ */