adf_accel_engine.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /* SPDX-License-Identifier: BSD-3-Clause */
    2 /* Copyright(c) 2007-2022 Intel Corporation */
    3 /* $FreeBSD$ */
    4 #include "qat_freebsd.h"
    5 #include "adf_cfg.h"
    6 #include "adf_common_drv.h"
    7 #include "adf_accel_devices.h"
    8 #include "icp_qat_uclo.h"
    9 #include "icp_qat_fw.h"
   10 #include "icp_qat_fw_init_admin.h"
   11 #include "adf_cfg_strings.h"
   12 #include "adf_transport_access_macros.h"
   13 #include "adf_transport_internal.h"
   14 #include <sys/firmware.h>
   15 #include <dev/pci/pcivar.h>
   16 #include "adf_cfg.h"
   17 #include "adf_accel_devices.h"
   18 #include "adf_common_drv.h"
   19 #include "icp_qat_uclo.h"
   20 #include "icp_qat_hw.h"
   21 
   22 #define MMP_VERSION_LEN 4
   23 
   24 struct adf_mmp_version_s {
   25         u8 ver_val[MMP_VERSION_LEN];
   26 };
   27 
   28 static int
   29 request_firmware(const struct firmware **firmware_p, const char *name)
   30 {
   31         int retval = 0;
   32         if (NULL == firmware_p) {
   33                 return -1;
   34         }
   35         *firmware_p = firmware_get(name);
   36         if (NULL == *firmware_p) {
   37                 retval = -1;
   38         }
   39         return retval;
   40 }
   41 
   42 int
   43 adf_ae_fw_load(struct adf_accel_dev *accel_dev)
   44 {
   45         struct adf_fw_loader_data *loader_data = accel_dev->fw_loader;
   46         struct adf_hw_device_data *hw_device = accel_dev->hw_device;
   47         const void *fw_addr, *mmp_addr;
   48         u32 fw_size, mmp_size;
   49         s32 i = 0;
   50         u32 max_objs = 1;
   51         const char *obj_name = NULL;
   52         struct adf_mmp_version_s mmp_ver = { { 0 } };
   53         unsigned int cfg_ae_mask = 0;
   54 
   55         if (!hw_device->fw_name)
   56                 return 0;
   57 
   58         if (request_firmware(&loader_data->uof_fw, hw_device->fw_name)) {
   59                 device_printf(GET_DEV(accel_dev),
   60                               "Failed to load UOF FW %s\n",
   61                               hw_device->fw_name);
   62                 goto out_err;
   63         }
   64 
   65         if (request_firmware(&loader_data->mmp_fw, hw_device->fw_mmp_name)) {
   66                 device_printf(GET_DEV(accel_dev),
   67                               "Failed to load MMP FW %s\n",
   68                               hw_device->fw_mmp_name);
   69                 goto out_err;
   70         }
   71 
   72         fw_size = loader_data->uof_fw->datasize;
   73         fw_addr = loader_data->uof_fw->data;
   74         mmp_size = loader_data->mmp_fw->datasize;
   75         mmp_addr = loader_data->mmp_fw->data;
   76 
   77         memcpy(&mmp_ver, mmp_addr, MMP_VERSION_LEN);
   78 
   79         accel_dev->fw_versions.mmp_version_major = mmp_ver.ver_val[0];
   80         accel_dev->fw_versions.mmp_version_minor = mmp_ver.ver_val[1];
   81         accel_dev->fw_versions.mmp_version_patch = mmp_ver.ver_val[2];
   82 
   83         if (hw_device->accel_capabilities_mask &
   84             ADF_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC)
   85                 if (qat_uclo_wr_mimage(loader_data->fw_loader,
   86                                        mmp_addr,
   87                                        mmp_size)) {
   88                         device_printf(GET_DEV(accel_dev),
   89                                       "Failed to load MMP\n");
   90                         goto out_err;
   91                 }
   92 
   93         if (hw_device->get_objs_num)
   94                 max_objs = hw_device->get_objs_num(accel_dev);
   95 
   96         for (i = max_objs - 1; i >= 0; i--) {
   97                 /* obj_name is used to indicate the firmware name in MOF,
   98                  * config unit0 must be loaded at end for authentication
   99                  */
  100                 if (hw_device->get_obj_name && hw_device->get_obj_cfg_ae_mask) {
  101                         unsigned long service_mask = hw_device->service_mask;
  102                         enum adf_accel_unit_services service_type =
  103                             ADF_ACCEL_SERVICE_NULL;
  104 
  105                         if (hw_device->get_service_type)
  106                                 service_type =
  107                                     hw_device->get_service_type(accel_dev, i);
  108                         else
  109                                 service_type = BIT(i);
  110 
  111                         if (service_mask && !(service_mask & service_type))
  112                                 continue;
  113 
  114                         obj_name =
  115                             hw_device->get_obj_name(accel_dev, service_type);
  116                         cfg_ae_mask =
  117                             hw_device->get_obj_cfg_ae_mask(accel_dev,
  118                                                            service_type);
  119 
  120                         if (!obj_name) {
  121                                 device_printf(
  122                                     GET_DEV(accel_dev),
  123                                     "Invalid object (service = %lx)\n",
  124                                     BIT(i));
  125                                 goto out_err;
  126                         }
  127                         if (!cfg_ae_mask)
  128                                 continue;
  129                         if (qat_uclo_set_cfg_ae_mask(loader_data->fw_loader,
  130                                                      cfg_ae_mask)) {
  131                                 device_printf(GET_DEV(accel_dev),
  132                                               "Invalid config AE mask\n");
  133                                 goto out_err;
  134                         }
  135                 }
  136 
  137                 if (qat_uclo_map_obj(
  138                         loader_data->fw_loader, fw_addr, fw_size, obj_name)) {
  139                         device_printf(GET_DEV(accel_dev),
  140                                       "Failed to map UOF firmware\n");
  141                         goto out_err;
  142                 }
  143                 if (qat_uclo_wr_all_uimage(loader_data->fw_loader)) {
  144                         device_printf(GET_DEV(accel_dev),
  145                                       "Failed to load UOF firmware\n");
  146                         goto out_err;
  147                 }
  148                 qat_uclo_del_obj(loader_data->fw_loader);
  149                 obj_name = NULL;
  150         }
  151 
  152         return 0;
  153 
  154 out_err:
  155         adf_ae_fw_release(accel_dev);
  156         return EFAULT;
  157 }
  158 
  159 void
  160 adf_ae_fw_release(struct adf_accel_dev *accel_dev)
  161 {
  162         struct adf_fw_loader_data *loader_data = accel_dev->fw_loader;
  163         struct adf_hw_device_data *hw_device = accel_dev->hw_device;
  164 
  165         if (!hw_device->fw_name)
  166                 return;
  167         if (loader_data->fw_loader)
  168                 qat_uclo_del_obj(loader_data->fw_loader);
  169         if (loader_data->fw_loader && loader_data->fw_loader->mobj_handle)
  170                 qat_uclo_del_mof(loader_data->fw_loader);
  171         qat_hal_deinit(loader_data->fw_loader);
  172         if (loader_data->uof_fw)
  173                 firmware_put(loader_data->uof_fw, FIRMWARE_UNLOAD);
  174         if (loader_data->mmp_fw)
  175                 firmware_put(loader_data->mmp_fw, FIRMWARE_UNLOAD);
  176         loader_data->uof_fw = NULL;
  177         loader_data->mmp_fw = NULL;
  178         loader_data->fw_loader = NULL;
  179 }
  180 
  181 int
  182 adf_ae_start(struct adf_accel_dev *accel_dev)
  183 {
  184         struct adf_fw_loader_data *loader_data = accel_dev->fw_loader;
  185         struct adf_hw_device_data *hw_data = accel_dev->hw_device;
  186         uint32_t ae_ctr;
  187 
  188         if (!hw_data->fw_name)
  189                 return 0;
  190 
  191         ae_ctr = qat_hal_start(loader_data->fw_loader);
  192         device_printf(GET_DEV(accel_dev),
  193                       "qat_dev%d started %d acceleration engines\n",
  194                       accel_dev->accel_id,
  195                       ae_ctr);
  196         return 0;
  197 }
  198 
  199 int
  200 adf_ae_stop(struct adf_accel_dev *accel_dev)
  201 {
  202         struct adf_fw_loader_data *loader_data = accel_dev->fw_loader;
  203         struct adf_hw_device_data *hw_data = accel_dev->hw_device;
  204         uint32_t ae_ctr, ae, max_aes = GET_MAX_ACCELENGINES(accel_dev);
  205 
  206         if (!hw_data->fw_name)
  207                 return 0;
  208 
  209         for (ae = 0, ae_ctr = 0; ae < max_aes; ae++) {
  210                 if (hw_data->ae_mask & (1 << ae)) {
  211                         qat_hal_stop(loader_data->fw_loader, ae, 0xFF);
  212                         ae_ctr++;
  213                 }
  214         }
  215         device_printf(GET_DEV(accel_dev),
  216                       "qat_dev%d stopped %d acceleration engines\n",
  217                       accel_dev->accel_id,
  218                       ae_ctr);
  219         return 0;
  220 }
  221 
  222 static int
  223 adf_ae_reset(struct adf_accel_dev *accel_dev, int ae)
  224 {
  225         struct adf_fw_loader_data *loader_data = accel_dev->fw_loader;
  226 
  227         qat_hal_reset(loader_data->fw_loader);
  228         if (qat_hal_clr_reset(loader_data->fw_loader))
  229                 return EFAULT;
  230 
  231         return 0;
  232 }
  233 
  234 int
  235 adf_ae_init(struct adf_accel_dev *accel_dev)
  236 {
  237         struct adf_fw_loader_data *loader_data;
  238         struct adf_hw_device_data *hw_device = accel_dev->hw_device;
  239 
  240         if (!hw_device->fw_name)
  241                 return 0;
  242 
  243         loader_data = malloc(sizeof(*loader_data), M_QAT, M_WAITOK | M_ZERO);
  244 
  245         accel_dev->fw_loader = loader_data;
  246         if (qat_hal_init(accel_dev)) {
  247                 device_printf(GET_DEV(accel_dev), "Failed to init the AEs\n");
  248                 free(loader_data, M_QAT);
  249                 return EFAULT;
  250         }
  251         if (adf_ae_reset(accel_dev, 0)) {
  252                 device_printf(GET_DEV(accel_dev), "Failed to reset the AEs\n");
  253                 qat_hal_deinit(loader_data->fw_loader);
  254                 free(loader_data, M_QAT);
  255                 return EFAULT;
  256         }
  257         return 0;
  258 }
  259 
  260 int
  261 adf_ae_shutdown(struct adf_accel_dev *accel_dev)
  262 {
  263         struct adf_fw_loader_data *loader_data = accel_dev->fw_loader;
  264         struct adf_hw_device_data *hw_device = accel_dev->hw_device;
  265 
  266         if (!hw_device->fw_name)
  267                 return 0;
  268 
  269         qat_hal_deinit(loader_data->fw_loader);
  270         free(accel_dev->fw_loader, M_QAT);
  271         accel_dev->fw_loader = NULL;
  272         return 0;
  273 }

Cache object: 808c696022fb9e7f3e844ed34a56592b

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/qat/qat_common/adf_accel_engine.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/qat/qat_common/adf_accel_engine.c