/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright 2017-2018 NXP
 */

#ifndef CAAM_JR_PVT_H
#define CAAM_JR_PVT_H

#include <desc/ipsec.h>
#include <dpaax_iova_table.h>

/* NXP CAAM JR PMD device name */

#define CAAM_JR_ALG_UNSUPPORT   (-1)

/* Minimum job descriptor consists of a oneword job descriptor HEADER and
 * a pointer to the shared descriptor.
 */
#define MIN_JOB_DESC_SIZE       (CAAM_CMD_SZ + CAAM_PTR_SZ)
#define CAAM_JOB_DESC_SIZE      13

/* CTX_POOL_NUM_BUFS is set as per the ipsec-secgw application */
#define CTX_POOL_NUM_BUFS       32000
#define CTX_POOL_CACHE_SIZE     512

#define DIR_ENC                 1
#define DIR_DEC                 0

#define JR_MAX_NB_MAX_DIGEST    32

#define RTE_CAAM_JR_PMD_MAX_NB_SESSIONS 2048


/* Return codes for SEC user space driver APIs */
enum sec_return_code_e {
        SEC_SUCCESS = 0,               /* Operation executed successfully.*/
        SEC_INVALID_INPUT_PARAM,       /* API received an invalid input
                                        * parameter
                                        */
        SEC_OUT_OF_MEMORY,             /* Memory allocation failed. */
        SEC_DESCRIPTOR_IN_FLIGHT,      /* API function indicates there are
                                        * descriptors in flight
                                        * for SEC to process.
                                        */
        SEC_LAST_DESCRIPTOR_IN_FLIGHT, /* API function indicates there is one
                                        * last descriptor in flight
                                        * for SEC to process that.
                                        */
        SEC_PROCESSING_ERROR,          /* Indicates a SEC processing error
                                        * occurred on a Job Ring which requires
                                        * a SEC user space driver shutdown. Can
                                        * be returned from sec_poll_job_ring().
                                        * Then the only other API that can be
                                        * called after this error is
                                        * sec_release().
                                        */
        SEC_DESC_PROCESSING_ERROR,     /* Indicates a SEC descriptor processing
                                        * error occurred on a Job Ring. Can be
                                        * returned from sec_poll_job_ring().
                                        * The driver was able to reset job ring
                                        * and job ring can be used like in a
                                        * normal case.
                                        */
        SEC_JR_IS_FULL,                 /* Job Ring is full. There is no more
                                         * room in the JR for new descriptors.
                                         * This can happen if the descriptor RX
                                         * rate is higher than SEC's capacity.
                                         */
        SEC_DRIVER_RELEASE_IN_PROGRESS, /* SEC driver shutdown is in progress,
                                         * descriptors processing or polling is
                                         * allowed.
                                         */
        SEC_DRIVER_ALREADY_INITIALIZED, /* SEC driver is already initialized.*/
        SEC_DRIVER_NOT_INITIALIZED,     /* SEC driver is NOT initialized. */
        SEC_JOB_RING_RESET_IN_PROGRESS, /* Job ring is resetting due to a
                                         * per-descriptor SEC processing error
                                         * ::SEC_desc_PROCESSING_ERROR. Reset is
                                         * finished when sec_poll_job_ring()
                                         * return. Then the job ring can be used
                                         * again.
                                         */
        SEC_RESET_ENGINE_FAILED,        /* Resetting of SEC Engine by SEC Kernel
                                         * Driver Failed
                                         */
        SEC_ENABLE_IRQS_FAILED,         /* Enabling of IRQs in SEC Kernel Driver
                                         * Failed
                                         */
        SEC_DISABLE_IRQS_FAILED,        /* Disabling of IRQs in SEC Kernel
                                         * Driver Failed
                                         */
        /* END OF VALID VALUES */

        SEC_RETURN_CODE_MAX_VALUE,      /* Invalid value for return code. It is
                                         * used to mark the end of the return
                                         * code values. @note ALL new return
                                         * code values MUST be added before
                                         * ::SEC_RETURN_CODE_MAX_VALUE!
                                         */
};

enum caam_jr_op_type {
        CAAM_JR_NONE,  /* No Cipher operations*/
        CAAM_JR_CIPHER,/* CIPHER operations */
        CAAM_JR_AUTH,  /* Authentication Operations */
        CAAM_JR_AEAD,  /* Authenticated Encryption with associated data */
        CAAM_JR_IPSEC, /* IPSEC protocol operations*/
        CAAM_JR_PDCP,  /* PDCP protocol operations*/
        CAAM_JR_PKC,   /* Public Key Cryptographic Operations */
        CAAM_JR_MAX
};

struct caam_jr_session {
        uint8_t dir;         /* Operation Direction */
        enum rte_crypto_cipher_algorithm cipher_alg; /* Cipher Algorithm*/
        enum rte_crypto_auth_algorithm auth_alg; /* Authentication Algorithm*/
        enum rte_crypto_aead_algorithm aead_alg; /* AEAD Algorithm*/
        enum rte_security_session_protocol proto_alg; /* Security Algorithm*/
        union {
                struct {
                        uint8_t *data;  /* pointer to key data */
                        size_t length;  /* key length in bytes */
                } aead_key;
                struct {
                        struct {
                                uint8_t *data;  /* pointer to key data */
                                size_t length;  /* key length in bytes */
                        } cipher_key;
                        struct {
                                uint8_t *data;  /* pointer to key data */
                                size_t length;  /* key length in bytes */
                        } auth_key;
                };
        };
        struct {
                uint16_t length;
                uint16_t offset;
        } iv;   /* Initialisation vector parameters */
        uint16_t auth_only_len; /* Length of data for Auth only */
        uint32_t digest_length;
        struct ipsec_encap_pdb encap_pdb;
        struct ip ip4_hdr;
        struct ipsec_decap_pdb decap_pdb;
        struct caam_jr_qp *qp;
        struct sec_cdb *cdb;    /* cmd block associated with qp */
        struct rte_mempool *ctx_pool; /* session mempool for caam_jr_op_ctx */
};

/*
 * 16-byte hardware scatter/gather table
 */

#define SEC4_SG_LEN_EXT         0x80000000      /* Entry points to table */
#define SEC4_SG_LEN_FIN         0x40000000      /* Last ent in table */
#define SEC4_SG_BPID_MASK       0x000000ff
#define SEC4_SG_BPID_SHIFT      16
#define SEC4_SG_LEN_MASK        0x3fffffff      /* Excludes EXT and FINAL */
#define SEC4_SG_OFFSET_MASK     0x00001fff

struct sec4_sg_entry {
        uint64_t ptr;
        uint32_t len;
        uint32_t bpid_offset;
};

#define MAX_SG_ENTRIES          16
#define SG_CACHELINE_0          0
#define SG_CACHELINE_1          4
#define SG_CACHELINE_2          8
#define SG_CACHELINE_3          12

/* Structure encompassing a job descriptor which is to be processed
 * by SEC. User should also initialise this structure with the callback
 * function pointer which will be called by driver after receiving processed
 * descriptor from SEC. User data is also passed in this data structure which
 * will be sent as an argument to the user callback function.
 */
struct job_descriptor {
        uint32_t desc[CAAM_JOB_DESC_SIZE];
};

struct caam_jr_op_ctx {
        struct job_descriptor jobdes;
        /* sg[0] output, sg[1] input, others are possible sub frames */
        struct sec4_sg_entry sg[MAX_SG_ENTRIES];
        struct rte_crypto_op *op;
        struct rte_mempool *ctx_pool; /* mempool pointer for caam_jr_op_ctx */
        int64_t vtop_offset;
        uint8_t digest[JR_MAX_NB_MAX_DIGEST];
};

/**
 * Checksum
 *
 * @param buffer calculate chksum for buffer
 * @param len    buffer length
 *
 * @return checksum value in host cpu order
 */
static inline uint16_t
calc_chksum(void *buffer, int len)
{
        uint16_t *buf = (uint16_t *)buffer;
        uint32_t sum = 0;
        uint16_t result;

        for (sum = 0; len > 1; len -= 2)
                sum += *buf++;

        if (len == 1)
                sum += *(unsigned char *)buf;

        sum = (sum >> 16) + (sum & 0xFFFF);
        sum += (sum >> 16);
        result = ~sum;

        return  result;
}
struct uio_job_ring {
        uint32_t jr_id;
        int uio_fd;
        void *register_base_addr;
        int map_size;
        int uio_minor_number;
};

int sec_cleanup(void);
int sec_configure(void);
void sec_uio_job_rings_init(void);
struct uio_job_ring *config_job_ring(void);
void free_job_ring(int uio_fd);

/* For Dma memory allocation of specified length and alignment */
static inline void *
caam_jr_dma_mem_alloc(size_t align, size_t len)
{
        return rte_malloc("mem_alloc", len, align);
}

/* For freeing dma memory */
static inline void
caam_jr_dma_free(void *ptr)
{
        rte_free(ptr);
}

static inline rte_iova_t
caam_jr_mem_vtop(void *vaddr)
{
        const struct rte_memseg *ms;

        ms = rte_mem_virt2memseg(vaddr, NULL);
        if (ms)
                return ms->iova + RTE_PTR_DIFF(vaddr, ms->addr);
        return (size_t)NULL;
}

static inline void *
caam_jr_dma_ptov(rte_iova_t paddr)
{
        void *va;
        va = dpaax_iova_table_get_va(paddr);
        if (likely(va != NULL))
                return va;

        return rte_mem_iova2virt(paddr);
}

/* Virtual to physical address conversion */
static inline rte_iova_t caam_jr_dma_vtop(void *ptr)
{
        return caam_jr_mem_vtop(ptr);
}

/** @brief Request to SEC kernel driver to enable interrupts for
 *         descriptor finished processing
 *  Use UIO to communicate with SEC kernel driver: write command
 *  value that indicates an IRQ enable action into UIO file descriptor
 *  of this job ring.
 *
 * @param [in]  uio_fd     Job Ring UIO File descriptor
 * @retval 0 for success
 * @retval -1 value for error
 */
int caam_jr_enable_irqs(int uio_fd);

/** @brief Request to SEC kernel driver to disable interrupts for descriptor
 *  finished processing
 *  Use UIO to communicate with SEC kernel driver: write command
 *  value that indicates an IRQ disable action into UIO file descriptor
 *  of this job ring.
 *
 * @param [in]  uio_fd    UIO File descriptor
 * @retval 0 for success
 * @retval -1 value for error
 *
 */
int caam_jr_disable_irqs(int uio_fd);

#endif