Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
0002 /* Copyright(c) 2014 - 2020 Intel Corporation */
0003 #include <linux/module.h>
0004 #include <linux/slab.h>
0005 #include "adf_accel_devices.h"
0006 #include "adf_common_drv.h"
0007 #include "adf_transport.h"
0008 #include "adf_transport_access_macros.h"
0009 #include "adf_cfg.h"
0010 #include "adf_cfg_strings.h"
0011 #include "adf_gen2_hw_data.h"
0012 #include "qat_crypto.h"
0013 #include "icp_qat_fw.h"
0014 
0015 #define SEC ADF_KERNEL_SEC
0016 
0017 static struct service_hndl qat_crypto;
0018 
0019 void qat_crypto_put_instance(struct qat_crypto_instance *inst)
0020 {
0021     atomic_dec(&inst->refctr);
0022     adf_dev_put(inst->accel_dev);
0023 }
0024 
0025 static int qat_crypto_free_instances(struct adf_accel_dev *accel_dev)
0026 {
0027     struct qat_crypto_instance *inst, *tmp;
0028     int i;
0029 
0030     list_for_each_entry_safe(inst, tmp, &accel_dev->crypto_list, list) {
0031         for (i = 0; i < atomic_read(&inst->refctr); i++)
0032             qat_crypto_put_instance(inst);
0033 
0034         if (inst->sym_tx)
0035             adf_remove_ring(inst->sym_tx);
0036 
0037         if (inst->sym_rx)
0038             adf_remove_ring(inst->sym_rx);
0039 
0040         if (inst->pke_tx)
0041             adf_remove_ring(inst->pke_tx);
0042 
0043         if (inst->pke_rx)
0044             adf_remove_ring(inst->pke_rx);
0045 
0046         list_del(&inst->list);
0047         kfree(inst);
0048     }
0049     return 0;
0050 }
0051 
0052 struct qat_crypto_instance *qat_crypto_get_instance_node(int node)
0053 {
0054     struct adf_accel_dev *accel_dev = NULL, *tmp_dev;
0055     struct qat_crypto_instance *inst = NULL, *tmp_inst;
0056     unsigned long best = ~0;
0057 
0058     list_for_each_entry(tmp_dev, adf_devmgr_get_head(), list) {
0059         unsigned long ctr;
0060 
0061         if ((node == dev_to_node(&GET_DEV(tmp_dev)) ||
0062              dev_to_node(&GET_DEV(tmp_dev)) < 0) &&
0063             adf_dev_started(tmp_dev) &&
0064             !list_empty(&tmp_dev->crypto_list)) {
0065             ctr = atomic_read(&tmp_dev->ref_count);
0066             if (best > ctr) {
0067                 accel_dev = tmp_dev;
0068                 best = ctr;
0069             }
0070         }
0071     }
0072 
0073     if (!accel_dev) {
0074         pr_info("QAT: Could not find a device on node %d\n", node);
0075         /* Get any started device */
0076         list_for_each_entry(tmp_dev, adf_devmgr_get_head(), list) {
0077             if (adf_dev_started(tmp_dev) &&
0078                 !list_empty(&tmp_dev->crypto_list)) {
0079                 accel_dev = tmp_dev;
0080                 break;
0081             }
0082         }
0083     }
0084 
0085     if (!accel_dev)
0086         return NULL;
0087 
0088     best = ~0;
0089     list_for_each_entry(tmp_inst, &accel_dev->crypto_list, list) {
0090         unsigned long ctr;
0091 
0092         ctr = atomic_read(&tmp_inst->refctr);
0093         if (best > ctr) {
0094             inst = tmp_inst;
0095             best = ctr;
0096         }
0097     }
0098     if (inst) {
0099         if (adf_dev_get(accel_dev)) {
0100             dev_err(&GET_DEV(accel_dev), "Could not increment dev refctr\n");
0101             return NULL;
0102         }
0103         atomic_inc(&inst->refctr);
0104     }
0105     return inst;
0106 }
0107 
0108 /**
0109  * qat_crypto_vf_dev_config()
0110  *     create dev config required to create crypto inst.
0111  *
0112  * @accel_dev: Pointer to acceleration device.
0113  *
0114  * Function creates device configuration required to create
0115  * asym, sym or, crypto instances
0116  *
0117  * Return: 0 on success, error code otherwise.
0118  */
0119 int qat_crypto_vf_dev_config(struct adf_accel_dev *accel_dev)
0120 {
0121     u16 ring_to_svc_map = GET_HW_DATA(accel_dev)->ring_to_svc_map;
0122 
0123     if (ring_to_svc_map != ADF_GEN2_DEFAULT_RING_TO_SRV_MAP) {
0124         dev_err(&GET_DEV(accel_dev),
0125             "Unsupported ring/service mapping present on PF");
0126         return -EFAULT;
0127     }
0128 
0129     return qat_crypto_dev_config(accel_dev);
0130 }
0131 
0132 /**
0133  * qat_crypto_dev_config() - create dev config required to create crypto inst.
0134  *
0135  * @accel_dev: Pointer to acceleration device.
0136  *
0137  * Function creates device configuration required to create crypto instances
0138  *
0139  * Return: 0 on success, error code otherwise.
0140  */
0141 int qat_crypto_dev_config(struct adf_accel_dev *accel_dev)
0142 {
0143     char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
0144     int banks = GET_MAX_BANKS(accel_dev);
0145     int cpus = num_online_cpus();
0146     unsigned long val;
0147     int instances;
0148     int ret;
0149     int i;
0150 
0151     if (adf_hw_dev_has_crypto(accel_dev))
0152         instances = min(cpus, banks);
0153     else
0154         instances = 0;
0155 
0156     ret = adf_cfg_section_add(accel_dev, ADF_KERNEL_SEC);
0157     if (ret)
0158         goto err;
0159 
0160     ret = adf_cfg_section_add(accel_dev, "Accelerator0");
0161     if (ret)
0162         goto err;
0163 
0164     for (i = 0; i < instances; i++) {
0165         val = i;
0166         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_BANK_NUM, i);
0167         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0168                           key, &val, ADF_DEC);
0169         if (ret)
0170             goto err;
0171 
0172         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_BANK_NUM, i);
0173         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0174                           key, &val, ADF_DEC);
0175         if (ret)
0176             goto err;
0177 
0178         snprintf(key, sizeof(key), ADF_CY "%d" ADF_ETRMGR_CORE_AFFINITY,
0179              i);
0180         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0181                           key, &val, ADF_DEC);
0182         if (ret)
0183             goto err;
0184 
0185         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_SIZE, i);
0186         val = 128;
0187         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0188                           key, &val, ADF_DEC);
0189         if (ret)
0190             goto err;
0191 
0192         val = 512;
0193         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_SIZE, i);
0194         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0195                           key, &val, ADF_DEC);
0196         if (ret)
0197             goto err;
0198 
0199         val = 0;
0200         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_TX, i);
0201         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0202                           key, &val, ADF_DEC);
0203         if (ret)
0204             goto err;
0205 
0206         val = 2;
0207         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_TX, i);
0208         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0209                           key, &val, ADF_DEC);
0210         if (ret)
0211             goto err;
0212 
0213         val = 8;
0214         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_RX, i);
0215         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0216                           key, &val, ADF_DEC);
0217         if (ret)
0218             goto err;
0219 
0220         val = 10;
0221         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_RX, i);
0222         ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC,
0223                           key, &val, ADF_DEC);
0224         if (ret)
0225             goto err;
0226 
0227         val = ADF_COALESCING_DEF_TIME;
0228         snprintf(key, sizeof(key), ADF_ETRMGR_COALESCE_TIMER_FORMAT, i);
0229         ret = adf_cfg_add_key_value_param(accel_dev, "Accelerator0",
0230                           key, &val, ADF_DEC);
0231         if (ret)
0232             goto err;
0233     }
0234 
0235     val = i;
0236     ret = adf_cfg_add_key_value_param(accel_dev, ADF_KERNEL_SEC, ADF_NUM_CY,
0237                       &val, ADF_DEC);
0238     if (ret)
0239         goto err;
0240 
0241     set_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
0242     return 0;
0243 err:
0244     dev_err(&GET_DEV(accel_dev), "Failed to start QAT accel dev\n");
0245     return ret;
0246 }
0247 EXPORT_SYMBOL_GPL(qat_crypto_dev_config);
0248 
0249 static int qat_crypto_create_instances(struct adf_accel_dev *accel_dev)
0250 {
0251     unsigned long num_inst, num_msg_sym, num_msg_asym;
0252     char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
0253     char val[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
0254     unsigned long sym_bank, asym_bank;
0255     struct qat_crypto_instance *inst;
0256     int msg_size;
0257     int ret;
0258     int i;
0259 
0260     INIT_LIST_HEAD(&accel_dev->crypto_list);
0261     ret = adf_cfg_get_param_value(accel_dev, SEC, ADF_NUM_CY, val);
0262     if (ret)
0263         return ret;
0264 
0265     ret = kstrtoul(val, 0, &num_inst);
0266     if (ret)
0267         return ret;
0268 
0269     for (i = 0; i < num_inst; i++) {
0270         inst = kzalloc_node(sizeof(*inst), GFP_KERNEL,
0271                     dev_to_node(&GET_DEV(accel_dev)));
0272         if (!inst) {
0273             ret = -ENOMEM;
0274             goto err;
0275         }
0276 
0277         list_add_tail(&inst->list, &accel_dev->crypto_list);
0278         inst->id = i;
0279         atomic_set(&inst->refctr, 0);
0280         inst->accel_dev = accel_dev;
0281 
0282         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_BANK_NUM, i);
0283         ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
0284         if (ret)
0285             goto err;
0286 
0287         ret = kstrtoul(val, 10, &sym_bank);
0288         if (ret)
0289             goto err;
0290 
0291         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_BANK_NUM, i);
0292         ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
0293         if (ret)
0294             goto err;
0295 
0296         ret = kstrtoul(val, 10, &asym_bank);
0297         if (ret)
0298             goto err;
0299 
0300         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_SIZE, i);
0301         ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
0302         if (ret)
0303             goto err;
0304 
0305         ret = kstrtoul(val, 10, &num_msg_sym);
0306         if (ret)
0307             goto err;
0308 
0309         num_msg_sym = num_msg_sym >> 1;
0310 
0311         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_SIZE, i);
0312         ret = adf_cfg_get_param_value(accel_dev, SEC, key, val);
0313         if (ret)
0314             goto err;
0315 
0316         ret = kstrtoul(val, 10, &num_msg_asym);
0317         if (ret)
0318             goto err;
0319         num_msg_asym = num_msg_asym >> 1;
0320 
0321         msg_size = ICP_QAT_FW_REQ_DEFAULT_SZ;
0322         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_TX, i);
0323         ret = adf_create_ring(accel_dev, SEC, sym_bank, num_msg_sym,
0324                       msg_size, key, NULL, 0, &inst->sym_tx);
0325         if (ret)
0326             goto err;
0327 
0328         msg_size = msg_size >> 1;
0329         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_TX, i);
0330         ret = adf_create_ring(accel_dev, SEC, asym_bank, num_msg_asym,
0331                       msg_size, key, NULL, 0, &inst->pke_tx);
0332         if (ret)
0333             goto err;
0334 
0335         msg_size = ICP_QAT_FW_RESP_DEFAULT_SZ;
0336         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_SYM_RX, i);
0337         ret = adf_create_ring(accel_dev, SEC, sym_bank, num_msg_sym,
0338                       msg_size, key, qat_alg_callback, 0,
0339                       &inst->sym_rx);
0340         if (ret)
0341             goto err;
0342 
0343         snprintf(key, sizeof(key), ADF_CY "%d" ADF_RING_ASYM_RX, i);
0344         ret = adf_create_ring(accel_dev, SEC, asym_bank, num_msg_asym,
0345                       msg_size, key, qat_alg_asym_callback, 0,
0346                       &inst->pke_rx);
0347         if (ret)
0348             goto err;
0349 
0350         INIT_LIST_HEAD(&inst->backlog.list);
0351         spin_lock_init(&inst->backlog.lock);
0352     }
0353     return 0;
0354 err:
0355     qat_crypto_free_instances(accel_dev);
0356     return ret;
0357 }
0358 
0359 static int qat_crypto_init(struct adf_accel_dev *accel_dev)
0360 {
0361     if (qat_crypto_create_instances(accel_dev))
0362         return -EFAULT;
0363 
0364     return 0;
0365 }
0366 
0367 static int qat_crypto_shutdown(struct adf_accel_dev *accel_dev)
0368 {
0369     return qat_crypto_free_instances(accel_dev);
0370 }
0371 
0372 static int qat_crypto_event_handler(struct adf_accel_dev *accel_dev,
0373                     enum adf_event event)
0374 {
0375     int ret;
0376 
0377     switch (event) {
0378     case ADF_EVENT_INIT:
0379         ret = qat_crypto_init(accel_dev);
0380         break;
0381     case ADF_EVENT_SHUTDOWN:
0382         ret = qat_crypto_shutdown(accel_dev);
0383         break;
0384     case ADF_EVENT_RESTARTING:
0385     case ADF_EVENT_RESTARTED:
0386     case ADF_EVENT_START:
0387     case ADF_EVENT_STOP:
0388     default:
0389         ret = 0;
0390     }
0391     return ret;
0392 }
0393 
0394 int qat_crypto_register(void)
0395 {
0396     memset(&qat_crypto, 0, sizeof(qat_crypto));
0397     qat_crypto.event_hld = qat_crypto_event_handler;
0398     qat_crypto.name = "qat_crypto";
0399     return adf_service_register(&qat_crypto);
0400 }
0401 
0402 int qat_crypto_unregister(void)
0403 {
0404     return adf_service_unregister(&qat_crypto);
0405 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!