drivers/crypto/caam/qi.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Public definitions for the CAAM/QI (Queue Interface) backend.
   4  *
   5  * Copyright 2013-2016 Freescale Semiconductor, Inc.
   6  * Copyright 2016-2017 NXP
   7  */
   8
   9 #ifndef __QI_H__
  10 #define __QI_H__
  11
  12 #include <soc/fsl/qman.h>
  13 #include "compat.h"
  14 #include "desc.h"
  15 #include "desc_constr.h"
  16
  17 /*
  18  * CAAM hardware constructs a job descriptor which points to a shared descriptor
  19  * (as pointed by context_a of to-CAAM FQ).
  20  * When the job descriptor is executed by DECO, the whole job descriptor
  21  * together with shared descriptor gets loaded in DECO buffer, which is
  22  * 64 words (each 32-bit) long.
  23  *
  24  * The job descriptor constructed by CAAM hardware has the following layout:
  25  *
  26  *      HEADER          (1 word)
  27  *      Shdesc ptr      (1 or 2 words)
  28  *      SEQ_OUT_PTR     (1 word)
  29  *      Out ptr         (1 or 2 words)
  30  *      Out length      (1 word)
  31  *      SEQ_IN_PTR      (1 word)
  32  *      In ptr          (1 or 2 words)
  33  *      In length       (1 word)
  34  *
  35  * The shdesc ptr is used to fetch shared descriptor contents into DECO buffer.
  36  *
  37  * Apart from shdesc contents, the total number of words that get loaded in DECO
  38  * buffer are '8' or '11'. The remaining words in DECO buffer can be used for
  39  * storing shared descriptor.
  40  */
  41 #define MAX_SDLEN       ((CAAM_DESC_BYTES_MAX - DESC_JOB_IO_LEN) / CAAM_CMD_SZ)
  42
  43 /* Length of a single buffer in the QI driver memory cache */
  44 #define CAAM_QI_MEMCACHE_SIZE   768
  45
  46 extern bool caam_congested __read_mostly;
  47
  48 /*
  49  * This is the request structure the driver application should fill while
  50  * submitting a job to driver.
  51  */
  52 struct caam_drv_req;
  53
  54 /*
  55  * caam_qi_cbk - application's callback function invoked by the driver when the
  56  *               request has been successfully processed.
  57  * @drv_req: original request that was submitted
  58  * @status: completion status of request (0 - success, non-zero - error code)
  59  */
  60 typedef void (*caam_qi_cbk)(struct caam_drv_req *drv_req, u32 status);
  61
  62 enum optype {
  63         ENCRYPT,
  64         DECRYPT,
  65         NUM_OP
  66 };
  67
  68 /**
  69  * caam_drv_ctx - CAAM/QI backend driver context
  70  *
  71  * The jobs are processed by the driver against a driver context.
  72  * With every cryptographic context, a driver context is attached.
  73  * The driver context contains data for private use by driver.
  74  * For the applications, this is an opaque structure.
  75  *
  76  * @prehdr: preheader placed before shrd desc
  77  * @sh_desc: shared descriptor
  78  * @context_a: shared descriptor dma address
  79  * @req_fq: to-CAAM request frame queue
  80  * @rsp_fq: from-CAAM response frame queue
  81  * @cpu: cpu on which to receive CAAM response
  82  * @op_type: operation type
  83  * @qidev: device pointer for CAAM/QI backend
  84  */
  85 struct caam_drv_ctx {
  86         u32 prehdr[2];
  87         u32 sh_desc[MAX_SDLEN];
  88         dma_addr_t context_a;
  89         struct qman_fq *req_fq;
  90         struct qman_fq *rsp_fq;
  91         int cpu;
  92         enum optype op_type;
  93         struct device *qidev;
  94 } ____cacheline_aligned;
  95
  96 /**
  97  * caam_drv_req - The request structure the driver application should fill while
  98  *                submitting a job to driver.
  99  * @fd_sgt: QMan S/G pointing to output (fd_sgt[0]) and input (fd_sgt[1])
 100  *          buffers.
 101  * @cbk: callback function to invoke when job is completed
 102  * @app_ctx: arbitrary context attached with request by the application
 103  *
 104  * The fields mentioned below should not be used by application.
 105  * These are for private use by driver.
 106  *
 107  * @hdr__: linked list header to maintain list of outstanding requests to CAAM
 108  * @hwaddr: DMA address for the S/G table.
 109  */
 110 struct caam_drv_req {
 111         struct qm_sg_entry fd_sgt[2];
 112         struct caam_drv_ctx *drv_ctx;
 113         caam_qi_cbk cbk;
 114         void *app_ctx;
 115 } ____cacheline_aligned;
 116
 117 /**
 118  * caam_drv_ctx_init - Initialise a CAAM/QI driver context
 119  *
 120  * A CAAM/QI driver context must be attached with each cryptographic context.
 121  * This function allocates memory for CAAM/QI context and returns a handle to
 122  * the application. This handle must be submitted along with each enqueue
 123  * request to the driver by the application.
 124  *
 125  * @cpu: CPU where the application prefers to the driver to receive CAAM
 126  *       responses. The request completion callback would be issued from this
 127  *       CPU.
 128  * @sh_desc: shared descriptor pointer to be attached with CAAM/QI driver
 129  *           context.
 130  *
 131  * Returns a driver context on success or negative error code on failure.
 132  */
 133 struct caam_drv_ctx *caam_drv_ctx_init(struct device *qidev, int *cpu,
 134                                        u32 *sh_desc);
 135
 136 /**
 137  * caam_qi_enqueue - Submit a request to QI backend driver.
 138  *
 139  * The request structure must be properly filled as described above.
 140  *
 141  * @qidev: device pointer for QI backend
 142  * @req: CAAM QI request structure
 143  *
 144  * Returns 0 on success or negative error code on failure.
 145  */
 146 int caam_qi_enqueue(struct device *qidev, struct caam_drv_req *req);
 147
 148 /**
 149  * caam_drv_ctx_busy - Check if there are too many jobs pending with CAAM
 150  *                     or too many CAAM responses are pending to be processed.
 151  * @drv_ctx: driver context for which job is to be submitted
 152  *
 153  * Returns caam congestion status 'true/false'
 154  */
 155 bool caam_drv_ctx_busy(struct caam_drv_ctx *drv_ctx);
 156
 157 /**
 158  * caam_drv_ctx_update - Update QI driver context
 159  *
 160  * Invoked when shared descriptor is required to be change in driver context.
 161  *
 162  * @drv_ctx: driver context to be updated
 163  * @sh_desc: new shared descriptor pointer to be updated in QI driver context
 164  *
 165  * Returns 0 on success or negative error code on failure.
 166  */
 167 int caam_drv_ctx_update(struct caam_drv_ctx *drv_ctx, u32 *sh_desc);
 168
 169 /**
 170  * caam_drv_ctx_rel - Release a QI driver context
 171  * @drv_ctx: context to be released
 172  */
 173 void caam_drv_ctx_rel(struct caam_drv_ctx *drv_ctx);
 174
 175 int caam_qi_init(struct platform_device *pdev);
 176 void caam_qi_shutdown(struct device *dev);
 177
 178 /**
 179  * qi_cache_alloc - Allocate buffers from CAAM-QI cache
 180  *
 181  * Invoked when a user of the CAAM-QI (i.e. caamalg-qi) needs data which has
 182  * to be allocated on the hotpath. Instead of using malloc, one can use the
 183  * services of the CAAM QI memory cache (backed by kmem_cache). The buffers
 184  * will have a size of 256B, which is sufficient for hosting 16 SG entries.
 185  *
 186  * @flags: flags that would be used for the equivalent malloc(..) call
 187  *
 188  * Returns a pointer to a retrieved buffer on success or NULL on failure.
 189  */
 190 void *qi_cache_alloc(gfp_t flags);
 191
 192 /**
 193  * qi_cache_free - Frees buffers allocated from CAAM-QI cache
 194  *
 195  * Invoked when a user of the CAAM-QI (i.e. caamalg-qi) no longer needs
 196  * the buffer previously allocated by a qi_cache_alloc call.
 197  * No checking is being done, the call is a passthrough call to
 198  * kmem_cache_free(...)
 199  *
 200  * @obj: object previously allocated using qi_cache_alloc()
 201  */
 202 void qi_cache_free(void *obj);
 203
 204 #endif /* __QI_H__ */