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);

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);

void remoteproc_add_mem(struct remoteproc *rproc, struct remoteproc_mem *mem);

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_ */