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