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(&inst->refctr);
 21	adf_dev_put(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(&inst->refctr); i++)
 31			qat_crypto_put_instance(inst);
 32
 33		if (inst->sym_tx)
 34			adf_remove_ring(inst->sym_tx);
 35
 36		if (inst->sym_rx)
 37			adf_remove_ring(inst->sym_rx);
 38
 39		if (inst->pke_tx)
 40			adf_remove_ring(inst->pke_tx);
 41
 42		if (inst->pke_rx)
 43			adf_remove_ring(inst->pke_rx);
 44
 45		list_del(&inst->list);
 46		kfree(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(&GET_DEV(tmp_dev)) ||
 61		     dev_to_node(&GET_DEV(tmp_dev)) < 0) &&
 62		    adf_dev_started(tmp_dev) &&
 63		    !list_empty(&tmp_dev->crypto_list)) {
 64			ctr = atomic_read(&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(tmp_dev) &&
 77			    !list_empty(&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(&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(&inst->refctr);
103	}
104	return inst;
105}
106
107/**
108 * qat_crypto_vf_dev_config()
109 *     create dev config required to create 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(&accel_dev->crypto_list);
143	ret = adf_cfg_get_param_value(accel_dev, SEC, ADF_NUM_CY, val);
144	if (ret)
145		return ret;
146
147	ret = kstrtoul(val, 0, &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(&inst->list, &accel_dev->crypto_list);
160		inst->id = i;
161		atomic_set(&inst->refctr, 0);
162		inst->accel_dev = accel_dev;
163
164		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_BANK_NUM, i);
165		ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
166		if (ret)
167			goto err;
168
169		ret = kstrtoul(val, 10, &sym_bank);
170		if (ret)
171			goto err;
172
173		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_BANK_NUM, i);
174		ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
175		if (ret)
176			goto err;
177
178		ret = kstrtoul(val, 10, &asym_bank);
179		if (ret)
180			goto err;
181
182		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_SIZE, i);
183		ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
184		if (ret)
185			goto err;
186
187		ret = kstrtoul(val, 10, &num_msg_sym);
188		if (ret)
189			goto err;
190
191		num_msg_sym = num_msg_sym >> 1;
192
193		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_SIZE, i);
194		ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
195		if (ret)
196			goto err;
197
198		ret = kstrtoul(val, 10, &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(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_TX, i);
205		ret = adf_create_ring(accel_dev, SEC, sym_bank, num_msg_sym,
206				      msg_size, key, NULL, 0, &inst->sym_tx);
207		if (ret)
208			goto err;
209
210		msg_size = msg_size >> 1;
211		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_TX, i);
212		ret = adf_create_ring(accel_dev, SEC, asym_bank, num_msg_asym,
213				      msg_size, key, NULL, 0, &inst->pke_tx);
214		if (ret)
215			goto err;
216
217		msg_size = ICP_QAT_FW_RESP_DEFAULT_SZ;
218		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_RX, i);
219		ret = adf_create_ring(accel_dev, SEC, sym_bank, num_msg_sym,
220				      msg_size, key, qat_alg_callback, 0,
221				      &inst->sym_rx);
222		if (ret)
223			goto err;
224
225		snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_RX, i);
226		ret = adf_create_ring(accel_dev, SEC, asym_bank, num_msg_asym,
227				      msg_size, key, qat_alg_asym_callback, 0,
228				      &inst->pke_rx);
229		if (ret)
230			goto err;
231
232		INIT_LIST_HEAD(&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(&qat_crypto);
282}
283
284int qat_crypto_unregister(void)
285{
286	return adf_service_unregister(&qat_crypto);
287}