1// SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
2/* Copyright(c) 2014 - 2020 Intel Corporation */
3#include <linux/module.h>
4#include <linux/slab.h>
5#include "adf_accel_devices.h"
6#include "adf_common_drv.h"
7#include "adf_transport.h"
8#include "adf_cfg.h"
9#include "adf_cfg_strings.h"
10#include "adf_gen2_hw_data.h"
11#include "qat_crypto.h"
12#include "icp_qat_fw.h"
13
14#define SEC ADF_KERNEL_SEC
15
16static struct service_hndl qat_crypto;
17
18void qat_crypto_put_instance(struct qat_crypto_instance *inst)
19{
20 atomic_dec(v: &inst->refctr);
21 adf_dev_put(accel_dev: inst->accel_dev);
22}
23
24static int qat_crypto_free_instances(struct adf_accel_dev *accel_dev)
25{
26 struct qat_crypto_instance *inst, *tmp;
27 int i;
28
29 list_for_each_entry_safe(inst, tmp, &accel_dev->crypto_list, list) {
30 for (i = 0; i < atomic_read(v: &inst->refctr); i++)
31 qat_crypto_put_instance(inst);
32
33 if (inst->sym_tx)
34 adf_remove_ring(ring: inst->sym_tx);
35
36 if (inst->sym_rx)
37 adf_remove_ring(ring: inst->sym_rx);
38
39 if (inst->pke_tx)
40 adf_remove_ring(ring: inst->pke_tx);
41
42 if (inst->pke_rx)
43 adf_remove_ring(ring: inst->pke_rx);
44
45 list_del(entry: &inst->list);
46 kfree(objp: inst);
47 }
48 return 0;
49}
50
51struct qat_crypto_instance *qat_crypto_get_instance_node(int node)
52{
53 struct adf_accel_dev *accel_dev = NULL, *tmp_dev;
54 struct qat_crypto_instance *inst = NULL, *tmp_inst;
55 unsigned long best = ~0;
56
57 list_for_each_entry(tmp_dev, adf_devmgr_get_head(), list) {
58 unsigned long ctr;
59
60 if ((node == dev_to_node(dev: &GET_DEV(tmp_dev)) ||
61 dev_to_node(dev: &GET_DEV(tmp_dev)) < 0) &&
62 adf_dev_started(accel_dev: tmp_dev) &&
63 !list_empty(head: &tmp_dev->crypto_list)) {
64 ctr = atomic_read(v: &tmp_dev->ref_count);
65 if (best > ctr) {
66 accel_dev = tmp_dev;
67 best = ctr;
68 }
69 }
70 }
71
72 if (!accel_dev) {
73 pr_debug_ratelimited("QAT: Could not find a device on node %d\n", node);
74 /* Get any started device */
75 list_for_each_entry(tmp_dev, adf_devmgr_get_head(), list) {
76 if (adf_dev_started(accel_dev: tmp_dev) &&
77 !list_empty(head: &tmp_dev->crypto_list)) {
78 accel_dev = tmp_dev;
79 break;
80 }
81 }
82 }
83
84 if (!accel_dev)
85 return NULL;
86
87 best = ~0;
88 list_for_each_entry(tmp_inst, &accel_dev->crypto_list, list) {
89 unsigned long ctr;
90
91 ctr = atomic_read(v: &tmp_inst->refctr);
92 if (best > ctr) {
93 inst = tmp_inst;
94 best = ctr;
95 }
96 }
97 if (inst) {
98 if (adf_dev_get(accel_dev)) {
99 dev_err(&GET_DEV(accel_dev), "Could not increment dev refctr\n");
100 return NULL;
101 }
102 atomic_inc(v: &inst->refctr);
103 }
104 return inst;
105}
106
107/**
108 * qat_crypto_vf_dev_config() - create dev config required to create
109 * crypto inst.
110 *
111 * @accel_dev: Pointer to acceleration device.
112 *
113 * Function creates device configuration required to create
114 * asym, sym or, crypto instances
115 *
116 * Return: 0 on success, error code otherwise.
117 */
118int qat_crypto_vf_dev_config(struct adf_accel_dev *accel_dev)
119{
120 u16 ring_to_svc_map = GET_HW_DATA(accel_dev)->ring_to_svc_map;
121
122 if (ring_to_svc_map != ADF_GEN2_DEFAULT_RING_TO_SRV_MAP) {
123 dev_err(&GET_DEV(accel_dev),
124 "Unsupported ring/service mapping present on PF");
125 return -EFAULT;
126 }
127
128 return GET_HW_DATA(accel_dev)->dev_config(accel_dev);
129}
130
131static int qat_crypto_create_instances(struct adf_accel_dev *accel_dev)
132{
133 unsigned long num_inst, num_msg_sym, num_msg_asym;
134 char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
135 char val[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
136 unsigned long sym_bank, asym_bank;
137 struct qat_crypto_instance *inst;
138 int msg_size;
139 int ret;
140 int i;
141
142 INIT_LIST_HEAD(list: &accel_dev->crypto_list);
143 ret = adf_cfg_get_param_value(accel_dev, SEC, ADF_NUM_CY, value: val);
144 if (ret)
145 return ret;
146
147 ret = kstrtoul(s: val, base: 0, res: &num_inst);
148 if (ret)
149 return ret;
150
151 for (i = 0; i < num_inst; i++) {
152 inst = kzalloc_node(sizeof(*inst), GFP_KERNEL,
153 dev_to_node(&GET_DEV(accel_dev)));
154 if (!inst) {
155 ret = -ENOMEM;
156 goto err;
157 }
158
159 list_add_tail(new: &inst->list, head: &accel_dev->crypto_list);
160 inst->id = i;
161 atomic_set(v: &inst->refctr, i: 0);
162 inst->accel_dev = accel_dev;
163
164 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_SYM_BANK_NUM, i);
165 ret = adf_cfg_get_param_value(accel_dev, SEC, name: key, value: val);
166 if (ret)
167 goto err;
168
169 ret = kstrtoul(s: val, base: 10, res: &sym_bank);
170 if (ret)
171 goto err;
172
173 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_ASYM_BANK_NUM, i);
174 ret = adf_cfg_get_param_value(accel_dev, SEC, name: key, value: val);
175 if (ret)
176 goto err;
177
178 ret = kstrtoul(s: val, base: 10, res: &asym_bank);
179 if (ret)
180 goto err;
181
182 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_SYM_SIZE, i);
183 ret = adf_cfg_get_param_value(accel_dev, SEC, name: key, value: val);
184 if (ret)
185 goto err;
186
187 ret = kstrtoul(s: val, base: 10, res: &num_msg_sym);
188 if (ret)
189 goto err;
190
191 num_msg_sym = num_msg_sym >> 1;
192
193 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_ASYM_SIZE, i);
194 ret = adf_cfg_get_param_value(accel_dev, SEC, name: key, value: val);
195 if (ret)
196 goto err;
197
198 ret = kstrtoul(s: val, base: 10, res: &num_msg_asym);
199 if (ret)
200 goto err;
201 num_msg_asym = num_msg_asym >> 1;
202
203 msg_size = ICP_QAT_FW_REQ_DEFAULT_SZ;
204 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_SYM_TX, i);
205 ret = adf_create_ring(accel_dev, SEC, bank_num: sym_bank, num_mgs: num_msg_sym,
206 msg_size, ring_name: key, NULL, poll_mode: 0, ring_ptr: &inst->sym_tx);
207 if (ret)
208 goto err;
209
210 msg_size = msg_size >> 1;
211 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_ASYM_TX, i);
212 ret = adf_create_ring(accel_dev, SEC, bank_num: asym_bank, num_mgs: num_msg_asym,
213 msg_size, ring_name: key, NULL, poll_mode: 0, ring_ptr: &inst->pke_tx);
214 if (ret)
215 goto err;
216
217 msg_size = ICP_QAT_FW_RESP_DEFAULT_SZ;
218 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_SYM_RX, i);
219 ret = adf_create_ring(accel_dev, SEC, bank_num: sym_bank, num_mgs: num_msg_sym,
220 msg_size, ring_name: key, callback: qat_alg_callback, poll_mode: 0,
221 ring_ptr: &inst->sym_rx);
222 if (ret)
223 goto err;
224
225 snprintf(buf: key, size: sizeof(key), ADF_CY "%d" ADF_RING_ASYM_RX, i);
226 ret = adf_create_ring(accel_dev, SEC, bank_num: asym_bank, num_mgs: num_msg_asym,
227 msg_size, ring_name: key, callback: qat_alg_asym_callback, poll_mode: 0,
228 ring_ptr: &inst->pke_rx);
229 if (ret)
230 goto err;
231
232 INIT_LIST_HEAD(list: &inst->backlog.list);
233 spin_lock_init(&inst->backlog.lock);
234 }
235 return 0;
236err:
237 qat_crypto_free_instances(accel_dev);
238 return ret;
239}
240
241static int qat_crypto_init(struct adf_accel_dev *accel_dev)
242{
243 if (qat_crypto_create_instances(accel_dev))
244 return -EFAULT;
245
246 return 0;
247}
248
249static int qat_crypto_shutdown(struct adf_accel_dev *accel_dev)
250{
251 return qat_crypto_free_instances(accel_dev);
252}
253
254static int qat_crypto_event_handler(struct adf_accel_dev *accel_dev,
255 enum adf_event event)
256{
257 int ret;
258
259 switch (event) {
260 case ADF_EVENT_INIT:
261 ret = qat_crypto_init(accel_dev);
262 break;
263 case ADF_EVENT_SHUTDOWN:
264 ret = qat_crypto_shutdown(accel_dev);
265 break;
266 case ADF_EVENT_RESTARTING:
267 case ADF_EVENT_RESTARTED:
268 case ADF_EVENT_START:
269 case ADF_EVENT_STOP:
270 default:
271 ret = 0;
272 }
273 return ret;
274}
275
276int qat_crypto_register(void)
277{
278 memset(&qat_crypto, 0, sizeof(qat_crypto));
279 qat_crypto.event_hld = qat_crypto_event_handler;
280 qat_crypto.name = "qat_crypto";
281 return adf_service_register(service: &qat_crypto);
282}
283
284int qat_crypto_unregister(void)
285{
286 return adf_service_unregister(service: &qat_crypto);
287}
288

source code of linux/drivers/crypto/intel/qat/qat_common/qat_crypto.c