drivers/crypto/qat/qat_common/adf_init.c

   1 /*
   2   This file is provided under a dual BSD/GPLv2 license.  When using or
   3   redistributing this file, you may do so under either license.
   4
   5   GPL LICENSE SUMMARY
   6   Copyright(c) 2014 Intel Corporation.
   7   This program is free software; you can redistribute it and/or modify
   8   it under the terms of version 2 of the GNU General Public License as
   9   published by the Free Software Foundation.
  10
  11   This program is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14   General Public License for more details.
  15
  16   Contact Information:
  17   qat-linux@intel.com
  18
  19   BSD LICENSE
  20   Copyright(c) 2014 Intel Corporation.
  21   Redistribution and use in source and binary forms, with or without
  22   modification, are permitted provided that the following conditions
  23   are met:
  24
  25     * Redistributions of source code must retain the above copyright
  26       notice, this list of conditions and the following disclaimer.
  27     * Redistributions in binary form must reproduce the above copyright
  28       notice, this list of conditions and the following disclaimer in
  29       the documentation and/or other materials provided with the
  30       distribution.
  31     * Neither the name of Intel Corporation nor the names of its
  32       contributors may be used to endorse or promote products derived
  33       from this software without specific prior written permission.
  34
  35   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  36   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  38   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  39   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  42   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  43   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  44   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  45   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46 */
  47 #include <linux/mutex.h>
  48 #include <linux/list.h>
  49 #include <linux/bitops.h>
  50 #include <linux/delay.h>
  51 #include "adf_accel_devices.h"
  52 #include "adf_cfg.h"
  53 #include "adf_common_drv.h"
  54
  55 static LIST_HEAD(service_table);
  56 static DEFINE_MUTEX(service_lock);
  57
  58 static void adf_service_add(struct service_hndl *service)
  59 {
  60         mutex_lock(&service_lock);
  61         list_add(&service->list, &service_table);
  62         mutex_unlock(&service_lock);
  63 }
  64
  65 int adf_service_register(struct service_hndl *service)
  66 {
  67         memset(service->init_status, 0, sizeof(service->init_status));
  68         memset(service->start_status, 0, sizeof(service->start_status));
  69         adf_service_add(service);
  70         return 0;
  71 }
  72
  73 static void adf_service_remove(struct service_hndl *service)
  74 {
  75         mutex_lock(&service_lock);
  76         list_del(&service->list);
  77         mutex_unlock(&service_lock);
  78 }
  79
  80 int adf_service_unregister(struct service_hndl *service)
  81 {
  82         int i;
  83
  84         for (i = 0; i < ARRAY_SIZE(service->init_status); i++) {
  85                 if (service->init_status[i] || service->start_status[i]) {
  86                         pr_err("QAT: Could not remove active service\n");
  87                         return -EFAULT;
  88                 }
  89         }
  90         adf_service_remove(service);
  91         return 0;
  92 }
  93
  94 /**
  95  * adf_dev_init() - Init data structures and services for the given accel device
  96  * @accel_dev: Pointer to acceleration device.
  97  *
  98  * Initialize the ring data structures and the admin comms and arbitration
  99  * services.
 100  *
 101  * Return: 0 on success, error code otherwise.
 102  */
 103 int adf_dev_init(struct adf_accel_dev *accel_dev)
 104 {
 105         struct service_hndl *service;
 106         struct list_head *list_itr;
 107         struct adf_hw_device_data *hw_data = accel_dev->hw_device;
 108         int ret;
 109
 110         if (!hw_data) {
 111                 dev_err(&GET_DEV(accel_dev),
 112                         "Failed to init device - hw_data not set\n");
 113                 return -EFAULT;
 114         }
 115
 116         if (!test_bit(ADF_STATUS_CONFIGURED, &accel_dev->status)) {
 117                 dev_err(&GET_DEV(accel_dev), "Device not configured\n");
 118                 return -EFAULT;
 119         }
 120
 121         if (adf_init_etr_data(accel_dev)) {
 122                 dev_err(&GET_DEV(accel_dev), "Failed initialize etr\n");
 123                 return -EFAULT;
 124         }
 125
 126         if (hw_data->init_admin_comms && hw_data->init_admin_comms(accel_dev)) {
 127                 dev_err(&GET_DEV(accel_dev), "Failed initialize admin comms\n");
 128                 return -EFAULT;
 129         }
 130
 131         if (hw_data->init_arb && hw_data->init_arb(accel_dev)) {
 132                 dev_err(&GET_DEV(accel_dev), "Failed initialize hw arbiter\n");
 133                 return -EFAULT;
 134         }
 135
 136         hw_data->enable_ints(accel_dev);
 137
 138         if (adf_ae_init(accel_dev)) {
 139                 dev_err(&GET_DEV(accel_dev),
 140                         "Failed to initialise Acceleration Engine\n");
 141                 return -EFAULT;
 142         }
 143         set_bit(ADF_STATUS_AE_INITIALISED, &accel_dev->status);
 144
 145         if (adf_ae_fw_load(accel_dev)) {
 146                 dev_err(&GET_DEV(accel_dev),
 147                         "Failed to load acceleration FW\n");
 148                 return -EFAULT;
 149         }
 150         set_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status);
 151
 152         if (hw_data->alloc_irq(accel_dev)) {
 153                 dev_err(&GET_DEV(accel_dev), "Failed to allocate interrupts\n");
 154                 return -EFAULT;
 155         }
 156         set_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status);
 157
 158         /*
 159          * Subservice initialisation is divided into two stages: init and start.
 160          * This is to facilitate any ordering dependencies between services
 161          * prior to starting any of the accelerators.
 162          */
 163         list_for_each(list_itr, &service_table) {
 164                 service = list_entry(list_itr, struct service_hndl, list);
 165                 if (service->event_hld(accel_dev, ADF_EVENT_INIT)) {
 166                         dev_err(&GET_DEV(accel_dev),
 167                                 "Failed to initialise service %s\n",
 168                                 service->name);
 169                         return -EFAULT;
 170                 }
 171                 set_bit(accel_dev->accel_id, service->init_status);
 172         }
 173
 174         hw_data->enable_error_correction(accel_dev);
 175         ret = hw_data->enable_vf2pf_comms(accel_dev);
 176
 177         return ret;
 178 }
 179 EXPORT_SYMBOL_GPL(adf_dev_init);
 180
 181 /**
 182  * adf_dev_start() - Start acceleration service for the given accel device
 183  * @accel_dev:    Pointer to acceleration device.
 184  *
 185  * Function notifies all the registered services that the acceleration device
 186  * is ready to be used.
 187  * To be used by QAT device specific drivers.
 188  *
 189  * Return: 0 on success, error code otherwise.
 190  */
 191 int adf_dev_start(struct adf_accel_dev *accel_dev)
 192 {
 193         struct adf_hw_device_data *hw_data = accel_dev->hw_device;
 194         struct service_hndl *service;
 195         struct list_head *list_itr;
 196
 197         set_bit(ADF_STATUS_STARTING, &accel_dev->status);
 198
 199         if (adf_ae_start(accel_dev)) {
 200                 dev_err(&GET_DEV(accel_dev), "AE Start Failed\n");
 201                 return -EFAULT;
 202         }
 203         set_bit(ADF_STATUS_AE_STARTED, &accel_dev->status);
 204
 205         if (hw_data->send_admin_init(accel_dev)) {
 206                 dev_err(&GET_DEV(accel_dev), "Failed to send init message\n");
 207                 return -EFAULT;
 208         }
 209
 210         list_for_each(list_itr, &service_table) {
 211                 service = list_entry(list_itr, struct service_hndl, list);
 212                 if (service->event_hld(accel_dev, ADF_EVENT_START)) {
 213                         dev_err(&GET_DEV(accel_dev),
 214                                 "Failed to start service %s\n",
 215                                 service->name);
 216                         return -EFAULT;
 217                 }
 218                 set_bit(accel_dev->accel_id, service->start_status);
 219         }
 220
 221         clear_bit(ADF_STATUS_STARTING, &accel_dev->status);
 222         set_bit(ADF_STATUS_STARTED, &accel_dev->status);
 223
 224         if (!list_empty(&accel_dev->crypto_list) &&
 225             (qat_algs_register() || qat_asym_algs_register())) {
 226                 dev_err(&GET_DEV(accel_dev),
 227                         "Failed to register crypto algs\n");
 228                 set_bit(ADF_STATUS_STARTING, &accel_dev->status);
 229                 clear_bit(ADF_STATUS_STARTED, &accel_dev->status);
 230                 return -EFAULT;
 231         }
 232         return 0;
 233 }
 234 EXPORT_SYMBOL_GPL(adf_dev_start);
 235
 236 /**
 237  * adf_dev_stop() - Stop acceleration service for the given accel device
 238  * @accel_dev:    Pointer to acceleration device.
 239  *
 240  * Function notifies all the registered services that the acceleration device
 241  * is shuting down.
 242  * To be used by QAT device specific drivers.
 243  *
 244  * Return: void
 245  */
 246 void adf_dev_stop(struct adf_accel_dev *accel_dev)
 247 {
 248         struct service_hndl *service;
 249         struct list_head *list_itr;
 250         bool wait = false;
 251         int ret;
 252
 253         if (!adf_dev_started(accel_dev) &&
 254             !test_bit(ADF_STATUS_STARTING, &accel_dev->status))
 255                 return;
 256
 257         clear_bit(ADF_STATUS_STARTING, &accel_dev->status);
 258         clear_bit(ADF_STATUS_STARTED, &accel_dev->status);
 259
 260         if (!list_empty(&accel_dev->crypto_list)) {
 261                 qat_algs_unregister();
 262                 qat_asym_algs_unregister();
 263         }
 264
 265         list_for_each(list_itr, &service_table) {
 266                 service = list_entry(list_itr, struct service_hndl, list);
 267                 if (!test_bit(accel_dev->accel_id, service->start_status))
 268                         continue;
 269                 ret = service->event_hld(accel_dev, ADF_EVENT_STOP);
 270                 if (!ret) {
 271                         clear_bit(accel_dev->accel_id, service->start_status);
 272                 } else if (ret == -EAGAIN) {
 273                         wait = true;
 274                         clear_bit(accel_dev->accel_id, service->start_status);
 275                 }
 276         }
 277
 278         if (wait)
 279                 msleep(100);
 280
 281         if (test_bit(ADF_STATUS_AE_STARTED, &accel_dev->status)) {
 282                 if (adf_ae_stop(accel_dev))
 283                         dev_err(&GET_DEV(accel_dev), "failed to stop AE\n");
 284                 else
 285                         clear_bit(ADF_STATUS_AE_STARTED, &accel_dev->status);
 286         }
 287 }
 288 EXPORT_SYMBOL_GPL(adf_dev_stop);
 289
 290 /**
 291  * adf_dev_shutdown() - shutdown acceleration services and data strucutures
 292  * @accel_dev: Pointer to acceleration device
 293  *
 294  * Cleanup the ring data structures and the admin comms and arbitration
 295  * services.
 296  */
 297 void adf_dev_shutdown(struct adf_accel_dev *accel_dev)
 298 {
 299         struct adf_hw_device_data *hw_data = accel_dev->hw_device;
 300         struct service_hndl *service;
 301         struct list_head *list_itr;
 302
 303         if (!hw_data) {
 304                 dev_err(&GET_DEV(accel_dev),
 305                         "QAT: Failed to shutdown device - hw_data not set\n");
 306                 return;
 307         }
 308
 309         if (test_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status)) {
 310                 adf_ae_fw_release(accel_dev);
 311                 clear_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status);
 312         }
 313
 314         if (test_bit(ADF_STATUS_AE_INITIALISED, &accel_dev->status)) {
 315                 if (adf_ae_shutdown(accel_dev))
 316                         dev_err(&GET_DEV(accel_dev),
 317                                 "Failed to shutdown Accel Engine\n");
 318                 else
 319                         clear_bit(ADF_STATUS_AE_INITIALISED,
 320                                   &accel_dev->status);
 321         }
 322
 323         list_for_each(list_itr, &service_table) {
 324                 service = list_entry(list_itr, struct service_hndl, list);
 325                 if (!test_bit(accel_dev->accel_id, service->init_status))
 326                         continue;
 327                 if (service->event_hld(accel_dev, ADF_EVENT_SHUTDOWN))
 328                         dev_err(&GET_DEV(accel_dev),
 329                                 "Failed to shutdown service %s\n",
 330                                 service->name);
 331                 else
 332                         clear_bit(accel_dev->accel_id, service->init_status);
 333         }
 334
 335         hw_data->disable_iov(accel_dev);
 336
 337         if (test_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status)) {
 338                 hw_data->free_irq(accel_dev);
 339                 clear_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status);
 340         }
 341
 342         /* Delete configuration only if not restarting */
 343         if (!test_bit(ADF_STATUS_RESTARTING, &accel_dev->status))
 344                 adf_cfg_del_all(accel_dev);
 345
 346         if (hw_data->exit_arb)
 347                 hw_data->exit_arb(accel_dev);
 348
 349         if (hw_data->exit_admin_comms)
 350                 hw_data->exit_admin_comms(accel_dev);
 351
 352         adf_cleanup_etr_data(accel_dev);
 353         adf_dev_restore(accel_dev);
 354 }
 355 EXPORT_SYMBOL_GPL(adf_dev_shutdown);
 356
 357 int adf_dev_restarting_notify(struct adf_accel_dev *accel_dev)
 358 {
 359         struct service_hndl *service;
 360         struct list_head *list_itr;
 361
 362         list_for_each(list_itr, &service_table) {
 363                 service = list_entry(list_itr, struct service_hndl, list);
 364                 if (service->event_hld(accel_dev, ADF_EVENT_RESTARTING))
 365                         dev_err(&GET_DEV(accel_dev),
 366                                 "Failed to restart service %s.\n",
 367                                 service->name);
 368         }
 369         return 0;
 370 }
 371
 372 int adf_dev_restarted_notify(struct adf_accel_dev *accel_dev)
 373 {
 374         struct service_hndl *service;
 375         struct list_head *list_itr;
 376
 377         list_for_each(list_itr, &service_table) {
 378                 service = list_entry(list_itr, struct service_hndl, list);
 379                 if (service->event_hld(accel_dev, ADF_EVENT_RESTARTED))
 380                         dev_err(&GET_DEV(accel_dev),
 381                                 "Failed to restart service %s.\n",
 382                                 service->name);
 383         }
 384         return 0;
 385 }