]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
1 | /* SPDX-License-Identifier: BSD-3-Clause |
2 | * Copyright(c) 2016-2018 Intel Corporation | |
7c673cae FG |
3 | */ |
4 | ||
5 | #include <string.h> | |
6 | ||
7 | #include <rte_common.h> | |
8 | #include <rte_malloc.h> | |
9 | #include <rte_cryptodev_pmd.h> | |
10 | ||
11 | #include "rte_kasumi_pmd_private.h" | |
12 | ||
13 | static const struct rte_cryptodev_capabilities kasumi_pmd_capabilities[] = { | |
14 | { /* KASUMI (F9) */ | |
15 | .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, | |
16 | {.sym = { | |
17 | .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, | |
18 | {.auth = { | |
19 | .algo = RTE_CRYPTO_AUTH_KASUMI_F9, | |
20 | .block_size = 8, | |
21 | .key_size = { | |
22 | .min = 16, | |
23 | .max = 16, | |
24 | .increment = 0 | |
25 | }, | |
26 | .digest_size = { | |
27 | .min = 4, | |
28 | .max = 4, | |
29 | .increment = 0 | |
30 | }, | |
11fdf7f2 | 31 | .iv_size = { 0 } |
7c673cae FG |
32 | }, } |
33 | }, } | |
34 | }, | |
35 | { /* KASUMI (F8) */ | |
36 | .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, | |
37 | {.sym = { | |
38 | .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, | |
39 | {.cipher = { | |
40 | .algo = RTE_CRYPTO_CIPHER_KASUMI_F8, | |
41 | .block_size = 8, | |
42 | .key_size = { | |
43 | .min = 16, | |
44 | .max = 16, | |
45 | .increment = 0 | |
46 | }, | |
47 | .iv_size = { | |
48 | .min = 8, | |
49 | .max = 8, | |
50 | .increment = 0 | |
51 | } | |
52 | }, } | |
53 | }, } | |
54 | }, | |
55 | RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() | |
56 | }; | |
57 | ||
58 | /** Configure device */ | |
59 | static int | |
11fdf7f2 TL |
60 | kasumi_pmd_config(__rte_unused struct rte_cryptodev *dev, |
61 | __rte_unused struct rte_cryptodev_config *config) | |
7c673cae FG |
62 | { |
63 | return 0; | |
64 | } | |
65 | ||
66 | /** Start device */ | |
67 | static int | |
68 | kasumi_pmd_start(__rte_unused struct rte_cryptodev *dev) | |
69 | { | |
70 | return 0; | |
71 | } | |
72 | ||
73 | /** Stop device */ | |
74 | static void | |
75 | kasumi_pmd_stop(__rte_unused struct rte_cryptodev *dev) | |
76 | { | |
77 | } | |
78 | ||
79 | /** Close device */ | |
80 | static int | |
81 | kasumi_pmd_close(__rte_unused struct rte_cryptodev *dev) | |
82 | { | |
83 | return 0; | |
84 | } | |
85 | ||
86 | ||
87 | /** Get device statistics */ | |
88 | static void | |
89 | kasumi_pmd_stats_get(struct rte_cryptodev *dev, | |
90 | struct rte_cryptodev_stats *stats) | |
91 | { | |
92 | int qp_id; | |
93 | ||
94 | for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) { | |
95 | struct kasumi_qp *qp = dev->data->queue_pairs[qp_id]; | |
96 | ||
97 | stats->enqueued_count += qp->qp_stats.enqueued_count; | |
98 | stats->dequeued_count += qp->qp_stats.dequeued_count; | |
99 | ||
100 | stats->enqueue_err_count += qp->qp_stats.enqueue_err_count; | |
101 | stats->dequeue_err_count += qp->qp_stats.dequeue_err_count; | |
102 | } | |
103 | } | |
104 | ||
105 | /** Reset device statistics */ | |
106 | static void | |
107 | kasumi_pmd_stats_reset(struct rte_cryptodev *dev) | |
108 | { | |
109 | int qp_id; | |
110 | ||
111 | for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) { | |
112 | struct kasumi_qp *qp = dev->data->queue_pairs[qp_id]; | |
113 | ||
114 | memset(&qp->qp_stats, 0, sizeof(qp->qp_stats)); | |
115 | } | |
116 | } | |
117 | ||
118 | ||
119 | /** Get device info */ | |
120 | static void | |
121 | kasumi_pmd_info_get(struct rte_cryptodev *dev, | |
122 | struct rte_cryptodev_info *dev_info) | |
123 | { | |
124 | struct kasumi_private *internals = dev->data->dev_private; | |
125 | ||
126 | if (dev_info != NULL) { | |
11fdf7f2 | 127 | dev_info->driver_id = dev->driver_id; |
7c673cae | 128 | dev_info->max_nb_queue_pairs = internals->max_nb_queue_pairs; |
11fdf7f2 TL |
129 | /* No limit of number of sessions */ |
130 | dev_info->sym.max_nb_sessions = 0; | |
7c673cae FG |
131 | dev_info->feature_flags = dev->feature_flags; |
132 | dev_info->capabilities = kasumi_pmd_capabilities; | |
133 | } | |
134 | } | |
135 | ||
136 | /** Release queue pair */ | |
137 | static int | |
138 | kasumi_pmd_qp_release(struct rte_cryptodev *dev, uint16_t qp_id) | |
139 | { | |
140 | struct kasumi_qp *qp = dev->data->queue_pairs[qp_id]; | |
141 | ||
142 | if (qp != NULL) { | |
143 | rte_ring_free(qp->processed_ops); | |
144 | rte_free(qp); | |
145 | dev->data->queue_pairs[qp_id] = NULL; | |
146 | } | |
147 | return 0; | |
148 | } | |
149 | ||
150 | /** set a unique name for the queue pair based on its name, dev_id and qp_id */ | |
151 | static int | |
152 | kasumi_pmd_qp_set_unique_name(struct rte_cryptodev *dev, | |
153 | struct kasumi_qp *qp) | |
154 | { | |
155 | unsigned n = snprintf(qp->name, sizeof(qp->name), | |
156 | "kasumi_pmd_%u_qp_%u", | |
157 | dev->data->dev_id, qp->id); | |
158 | ||
11fdf7f2 | 159 | if (n >= sizeof(qp->name)) |
7c673cae FG |
160 | return -1; |
161 | ||
162 | return 0; | |
163 | } | |
164 | ||
165 | /** Create a ring to place processed ops on */ | |
166 | static struct rte_ring * | |
167 | kasumi_pmd_qp_create_processed_ops_ring(struct kasumi_qp *qp, | |
168 | unsigned ring_size, int socket_id) | |
169 | { | |
170 | struct rte_ring *r; | |
171 | ||
172 | r = rte_ring_lookup(qp->name); | |
173 | if (r) { | |
11fdf7f2 TL |
174 | if (rte_ring_get_size(r) == ring_size) { |
175 | KASUMI_LOG(INFO, "Reusing existing ring %s" | |
7c673cae FG |
176 | " for processed packets", |
177 | qp->name); | |
178 | return r; | |
179 | } | |
180 | ||
11fdf7f2 | 181 | KASUMI_LOG(ERR, "Unable to reuse existing ring %s" |
7c673cae FG |
182 | " for processed packets", |
183 | qp->name); | |
184 | return NULL; | |
185 | } | |
186 | ||
187 | return rte_ring_create(qp->name, ring_size, socket_id, | |
188 | RING_F_SP_ENQ | RING_F_SC_DEQ); | |
189 | } | |
190 | ||
191 | /** Setup a queue pair */ | |
192 | static int | |
193 | kasumi_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id, | |
194 | const struct rte_cryptodev_qp_conf *qp_conf, | |
9f95a23c | 195 | int socket_id) |
7c673cae FG |
196 | { |
197 | struct kasumi_qp *qp = NULL; | |
198 | ||
199 | /* Free memory prior to re-allocation if needed. */ | |
200 | if (dev->data->queue_pairs[qp_id] != NULL) | |
201 | kasumi_pmd_qp_release(dev, qp_id); | |
202 | ||
203 | /* Allocate the queue pair data structure. */ | |
204 | qp = rte_zmalloc_socket("KASUMI PMD Queue Pair", sizeof(*qp), | |
205 | RTE_CACHE_LINE_SIZE, socket_id); | |
206 | if (qp == NULL) | |
207 | return (-ENOMEM); | |
208 | ||
209 | qp->id = qp_id; | |
210 | dev->data->queue_pairs[qp_id] = qp; | |
211 | ||
212 | if (kasumi_pmd_qp_set_unique_name(dev, qp)) | |
213 | goto qp_setup_cleanup; | |
214 | ||
215 | qp->processed_ops = kasumi_pmd_qp_create_processed_ops_ring(qp, | |
216 | qp_conf->nb_descriptors, socket_id); | |
217 | if (qp->processed_ops == NULL) | |
218 | goto qp_setup_cleanup; | |
219 | ||
9f95a23c TL |
220 | qp->sess_mp = qp_conf->mp_session; |
221 | qp->sess_mp_priv = qp_conf->mp_session_private; | |
7c673cae FG |
222 | |
223 | memset(&qp->qp_stats, 0, sizeof(qp->qp_stats)); | |
224 | ||
225 | return 0; | |
226 | ||
227 | qp_setup_cleanup: | |
228 | rte_free(qp); | |
229 | ||
230 | return -1; | |
231 | } | |
232 | ||
7c673cae FG |
233 | /** Return the number of allocated queue pairs */ |
234 | static uint32_t | |
235 | kasumi_pmd_qp_count(struct rte_cryptodev *dev) | |
236 | { | |
237 | return dev->data->nb_queue_pairs; | |
238 | } | |
239 | ||
240 | /** Returns the size of the KASUMI session structure */ | |
241 | static unsigned | |
11fdf7f2 | 242 | kasumi_pmd_sym_session_get_size(struct rte_cryptodev *dev __rte_unused) |
7c673cae FG |
243 | { |
244 | return sizeof(struct kasumi_session); | |
245 | } | |
246 | ||
247 | /** Configure a KASUMI session from a crypto xform chain */ | |
11fdf7f2 TL |
248 | static int |
249 | kasumi_pmd_sym_session_configure(struct rte_cryptodev *dev __rte_unused, | |
250 | struct rte_crypto_sym_xform *xform, | |
251 | struct rte_cryptodev_sym_session *sess, | |
252 | struct rte_mempool *mempool) | |
7c673cae | 253 | { |
11fdf7f2 TL |
254 | void *sess_private_data; |
255 | int ret; | |
256 | ||
7c673cae | 257 | if (unlikely(sess == NULL)) { |
11fdf7f2 TL |
258 | KASUMI_LOG(ERR, "invalid session struct"); |
259 | return -EINVAL; | |
7c673cae FG |
260 | } |
261 | ||
11fdf7f2 TL |
262 | if (rte_mempool_get(mempool, &sess_private_data)) { |
263 | KASUMI_LOG(ERR, | |
264 | "Couldn't get object from session mempool"); | |
265 | return -ENOMEM; | |
7c673cae FG |
266 | } |
267 | ||
11fdf7f2 TL |
268 | ret = kasumi_set_session_parameters(sess_private_data, xform); |
269 | if (ret != 0) { | |
270 | KASUMI_LOG(ERR, "failed configure session parameters"); | |
271 | ||
272 | /* Return session to mempool */ | |
273 | rte_mempool_put(mempool, sess_private_data); | |
274 | return ret; | |
275 | } | |
276 | ||
277 | set_sym_session_private_data(sess, dev->driver_id, | |
278 | sess_private_data); | |
279 | ||
280 | return 0; | |
7c673cae FG |
281 | } |
282 | ||
283 | /** Clear the memory of session so it doesn't leave key material behind */ | |
284 | static void | |
11fdf7f2 TL |
285 | kasumi_pmd_sym_session_clear(struct rte_cryptodev *dev, |
286 | struct rte_cryptodev_sym_session *sess) | |
7c673cae | 287 | { |
11fdf7f2 TL |
288 | uint8_t index = dev->driver_id; |
289 | void *sess_priv = get_sym_session_private_data(sess, index); | |
290 | ||
291 | /* Zero out the whole structure */ | |
292 | if (sess_priv) { | |
293 | memset(sess_priv, 0, sizeof(struct kasumi_session)); | |
294 | struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv); | |
295 | set_sym_session_private_data(sess, index, NULL); | |
296 | rte_mempool_put(sess_mp, sess_priv); | |
297 | } | |
7c673cae FG |
298 | } |
299 | ||
300 | struct rte_cryptodev_ops kasumi_pmd_ops = { | |
301 | .dev_configure = kasumi_pmd_config, | |
302 | .dev_start = kasumi_pmd_start, | |
303 | .dev_stop = kasumi_pmd_stop, | |
304 | .dev_close = kasumi_pmd_close, | |
305 | ||
306 | .stats_get = kasumi_pmd_stats_get, | |
307 | .stats_reset = kasumi_pmd_stats_reset, | |
308 | ||
309 | .dev_infos_get = kasumi_pmd_info_get, | |
310 | ||
311 | .queue_pair_setup = kasumi_pmd_qp_setup, | |
312 | .queue_pair_release = kasumi_pmd_qp_release, | |
7c673cae FG |
313 | .queue_pair_count = kasumi_pmd_qp_count, |
314 | ||
11fdf7f2 TL |
315 | .sym_session_get_size = kasumi_pmd_sym_session_get_size, |
316 | .sym_session_configure = kasumi_pmd_sym_session_configure, | |
317 | .sym_session_clear = kasumi_pmd_sym_session_clear | |
7c673cae FG |
318 | }; |
319 | ||
320 | struct rte_cryptodev_ops *rte_kasumi_pmd_ops = &kasumi_pmd_ops; |