]>
Commit | Line | Data |
---|---|---|
67c2315d HG |
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__ */ |