/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2025 Intel Corporation */
#include "qat_freebsd.h"
#include "adf_cfg.h"
#include "adf_common_drv.h"
#include "adf_dbgfs.h"
#include "adf_accel_devices.h"
#include "icp_qat_uclo.h"
#include "icp_qat_fw.h"
#include "icp_qat_fw_init_admin.h"
#include "adf_cfg_strings.h"
#include "adf_dev_err.h"
#include "adf_uio.h"
#include "adf_transport_access_macros.h"
#include "adf_transport_internal.h"
#include <sys/mutex.h>
#include <linux/delay.h>
#include "adf_accel_devices.h"
#include "adf_cfg.h"
#include "adf_common_drv.h"
#include "icp_qat_fw.h"

#if defined(QAT_UIO)
#include "adf_cfg_device.h"
#endif /* QAT_UIO*/

/* Mask used to check the CompressAndVerify capability bit */
#define DC_CNV_EXTENDED_CAPABILITY (0x01)

/* Mask used to check the CompressAndVerifyAndRecover capability bit */
#define DC_CNVNR_EXTENDED_CAPABILITY (0x100)

static LIST_HEAD(service_table);
static DEFINE_MUTEX(service_lock);

static int adf_dev_init_locked(struct adf_accel_dev *accel_dev);
static int adf_dev_start_locked(struct adf_accel_dev *accel_dev);
static int adf_dev_stop_locked(struct adf_accel_dev *accel_dev);
static void adf_dev_shutdown_locked(struct adf_accel_dev *accel_dev);

static void
adf_service_add(struct service_hndl *service)
{
        mutex_lock(&service_lock);
        list_add(&service->list, &service_table);
        mutex_unlock(&service_lock);
}

int
adf_service_register(struct service_hndl *service)
{
        memset(service->init_status, 0, sizeof(service->init_status));
        memset(service->start_status, 0, sizeof(service->start_status));
        adf_service_add(service);
        return 0;
}

static void
adf_service_remove(struct service_hndl *service)
{
        mutex_lock(&service_lock);
        list_del(&service->list);
        mutex_unlock(&service_lock);
}

int
adf_service_unregister(struct service_hndl *service)
{
        int i;

        for (i = 0; i < ARRAY_SIZE(service->init_status); i++) {
                if (service->init_status[i] || service->start_status[i]) {
                        pr_err("QAT: Could not remove active service [%d]\n",
                               i);
                        return EFAULT;
                }
        }
        adf_service_remove(service);
        return 0;
}

static int
adf_cfg_add_device_params(struct adf_accel_dev *accel_dev)
{
        char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
        char hw_version[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
        char mmp_version[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
        struct adf_hw_device_data *hw_data = NULL;
        unsigned long val;
        if (!accel_dev)
                return -EINVAL;

        hw_data = accel_dev->hw_device;

        if (adf_cfg_section_add(accel_dev, ADF_GENERAL_SEC))
                goto err;

        snprintf(key, sizeof(key), ADF_DEV_MAX_BANKS);
        val = GET_MAX_BANKS(accel_dev);
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)&val, ADF_DEC))
                goto err;

        snprintf(key, sizeof(key), ADF_DEV_CAPABILITIES_MASK);
        val = hw_data->accel_capabilities_mask;
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)val, ADF_HEX))
                goto err;

        snprintf(key, sizeof(key), ADF_DEV_PKG_ID);
        val = accel_dev->accel_id;
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)&val, ADF_DEC))
                goto err;

        snprintf(key, sizeof(key), ADF_DEV_NODE_ID);
        val = dev_to_node(GET_DEV(accel_dev));
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)&val, ADF_DEC))
                goto err;

        snprintf(key, sizeof(key), ADF_DEV_MAX_RINGS_PER_BANK);
        val = hw_data->num_rings_per_bank;
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)&val, ADF_DEC))
                goto err;

        snprintf(key, sizeof(key), ADF_HW_REV_ID_KEY);
        snprintf(hw_version,
                 ADF_CFG_MAX_VAL_LEN_IN_BYTES,
                 "%d",
                 accel_dev->accel_pci_dev.revid);
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)hw_version, ADF_STR))
                goto err;

        snprintf(key, sizeof(key), ADF_MMP_VER_KEY);
        snprintf(mmp_version,
                 ADF_CFG_MAX_VAL_LEN_IN_BYTES,
                 "%d.%d.%d",
                 accel_dev->fw_versions.mmp_version_major,
                 accel_dev->fw_versions.mmp_version_minor,
                 accel_dev->fw_versions.mmp_version_patch);
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)mmp_version, ADF_STR))
                goto err;

        return 0;
err:
        device_printf(GET_DEV(accel_dev),
                      "Failed to add internal values to accel_dev cfg\n");
        return -EINVAL;
}

static int
adf_cfg_add_fw_version(struct adf_accel_dev *accel_dev)
{
        char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
        char fw_version[ADF_CFG_MAX_VAL_LEN_IN_BYTES];

        snprintf(key, sizeof(key), ADF_UOF_VER_KEY);
        snprintf(fw_version,
                 ADF_CFG_MAX_VAL_LEN_IN_BYTES,
                 "%d.%d.%d",
                 accel_dev->fw_versions.fw_version_major,
                 accel_dev->fw_versions.fw_version_minor,
                 accel_dev->fw_versions.fw_version_patch);
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)fw_version, ADF_STR))
                return EFAULT;

        return 0;
}

static int
adf_cfg_add_ext_params(struct adf_accel_dev *accel_dev)
{
        char key[ADF_CFG_MAX_KEY_LEN_IN_BYTES];
        struct adf_hw_device_data *hw_data = accel_dev->hw_device;
        unsigned long val;

        snprintf(key, sizeof(key), ADF_DC_EXTENDED_FEATURES);

        val = hw_data->extended_dc_capabilities;
        if (adf_cfg_add_key_value_param(
                accel_dev, ADF_GENERAL_SEC, key, (void *)val, ADF_HEX))
                return -EINVAL;

        return 0;
}

void
adf_error_notifier(uintptr_t arg)
{
        struct adf_accel_dev *accel_dev = (struct adf_accel_dev *)arg;
        struct service_hndl *service;
        struct list_head *list_itr;

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (service->event_hld(accel_dev, ADF_EVENT_ERROR))
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to send error event to %s.\n",
                                      service->name);
        }
}

/**
 * adf_set_ssm_wdtimer() - Initialize the slice hang watchdog timer.
 *
 * Return: 0 on success, error code otherwise.
 */
int
adf_set_ssm_wdtimer(struct adf_accel_dev *accel_dev)
{
        struct adf_hw_device_data *hw_data = accel_dev->hw_device;
        struct adf_bar *misc_bar =
            &GET_BARS(accel_dev)[hw_data->get_misc_bar_id(hw_data)];
        struct resource *csr = misc_bar->virt_addr;
        u32 i;
        unsigned int mask;
        u32 clk_per_sec = hw_data->get_clock_speed(hw_data);
        u32 timer_val = ADF_WDT_TIMER_SYM_COMP_MS * (clk_per_sec / 1000);
        u32 timer_val_pke = ADF_GEN2_SSM_WDT_PKE_DEFAULT_VALUE;
        char timer_str[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };

        /* Get Watch Dog Timer for CySym+Comp from the configuration */
        if (!adf_cfg_get_param_value(accel_dev,
                                     ADF_GENERAL_SEC,
                                     ADF_DEV_SSM_WDT_BULK,
                                     (char *)timer_str)) {
                if (!compat_strtouint((char *)timer_str,
                                      ADF_CFG_BASE_DEC,
                                      &timer_val))
                        /* Convert msec to CPP clocks */
                        timer_val = timer_val * (clk_per_sec / 1000);
        }
        /* Get Watch Dog Timer for CyAsym from the configuration */
        if (!adf_cfg_get_param_value(accel_dev,
                                     ADF_GENERAL_SEC,
                                     ADF_DEV_SSM_WDT_PKE,
                                     (char *)timer_str)) {
                if (!compat_strtouint((char *)timer_str,
                                      ADF_CFG_BASE_DEC,
                                      &timer_val_pke))
                        /* Convert msec to CPP clocks */
                        timer_val_pke = timer_val_pke * (clk_per_sec / 1000);
        }

        for (i = 0, mask = hw_data->accel_mask; mask; i++, mask >>= 1) {
                if (!(mask & 1))
                        continue;
                /* Enable Watch Dog Timer for CySym + Comp */
                ADF_CSR_WR(csr, ADF_SSMWDT(i), timer_val);
                /* Enable Watch Dog Timer for CyAsym */
                ADF_CSR_WR(csr, ADF_SSMWDTPKE(i), timer_val_pke);
        }
        return 0;
}

/**
 * adf_dev_init() - Init data structures and services for the given accel device
 * @accel_dev: Pointer to acceleration device.
 *
 * Initialize the ring data structures and the admin comms and arbitration
 * services.
 *
 * Return: 0 on success, error code otherwise.
 */
int
adf_dev_init(struct adf_accel_dev *accel_dev)
{
        int ret = 0;

        mutex_lock(&accel_dev->lock);
        ret = adf_dev_init_locked(accel_dev);
        mutex_unlock(&accel_dev->lock);

        return ret;
}

static int
adf_dev_init_locked(struct adf_accel_dev *accel_dev)
{
        struct service_hndl *service;
        struct list_head *list_itr;
        struct adf_hw_device_data *hw_data = accel_dev->hw_device;
        char value[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
        int ret = 0;
        sysctl_ctx_init(&accel_dev->sysctl_ctx);
        set_bit(ADF_STATUS_SYSCTL_CTX_INITIALISED, &accel_dev->status);

        if (!hw_data) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to init device - hw_data not set\n");
                return EFAULT;
        }
        if (hw_data->reset_hw_units)
                hw_data->reset_hw_units(accel_dev);

        if (!test_bit(ADF_STATUS_CONFIGURED, &accel_dev->status) &&
            !accel_dev->is_vf) {
                device_printf(GET_DEV(accel_dev), "Device not configured\n");
                return EFAULT;
        }

        if (adf_init_etr_data(accel_dev)) {
                device_printf(GET_DEV(accel_dev), "Failed initialize etr\n");
                return EFAULT;
        }

        if (hw_data->init_device && hw_data->init_device(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to initialize device\n");
                return EFAULT;
        }

        if (hw_data->init_accel_units && hw_data->init_accel_units(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed initialize accel_units\n");
                return EFAULT;
        }

        if (hw_data->init_admin_comms && hw_data->init_admin_comms(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed initialize admin comms\n");
                return EFAULT;
        }

        if (hw_data->init_arb && hw_data->init_arb(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed initialize hw arbiter\n");
                return EFAULT;
        }

        if (hw_data->set_asym_rings_mask)
                hw_data->set_asym_rings_mask(accel_dev);

        hw_data->enable_ints(accel_dev);

        if (adf_ae_init(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to initialise Acceleration Engine\n");
                return EFAULT;
        }

        set_bit(ADF_STATUS_AE_INITIALISED, &accel_dev->status);

        if (adf_ae_fw_load(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to load acceleration FW\n");
                return EFAULT;
        }
        set_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status);

        if (hw_data->alloc_irq(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to allocate interrupts\n");
                return EFAULT;
        }
        set_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status);

        if (hw_data->init_ras && hw_data->init_ras(accel_dev)) {
                device_printf(GET_DEV(accel_dev), "Failed to init RAS\n");
                return EFAULT;
        }

        hw_data->enable_ints(accel_dev);

        hw_data->enable_error_correction(accel_dev);

        ret = hw_data->csr_info.pfvf_ops.enable_comms(accel_dev);
        if (ret)
                return ret;

        if (adf_cfg_add_device_params(accel_dev))
                return EFAULT;

        if (hw_data->add_pke_stats && hw_data->add_pke_stats(accel_dev))
                return EFAULT;

        if (hw_data->add_misc_error && hw_data->add_misc_error(accel_dev))
                return EFAULT;
        /*
         * Subservice initialisation is divided into two stages: init and start.
         * This is to facilitate any ordering dependencies between services
         * prior to starting any of the accelerators.
         */
        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (service->event_hld(accel_dev, ADF_EVENT_INIT)) {
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to initialise service %s\n",
                                      service->name);
                        return EFAULT;
                }
                set_bit(accel_dev->accel_id, service->init_status);
        }

        /* Read autoreset on error parameter */
        ret = adf_cfg_get_param_value(accel_dev,
                                      ADF_GENERAL_SEC,
                                      ADF_AUTO_RESET_ON_ERROR,
                                      value);
        if (!ret) {
                if (compat_strtouint(value,
                                     10,
                                     &accel_dev->autoreset_on_error)) {
                        device_printf(
                            GET_DEV(accel_dev),
                            "Failed converting %s to a decimal value\n",
                            ADF_AUTO_RESET_ON_ERROR);
                        return EFAULT;
                }
        }

        return 0;
}

/**
 * adf_dev_start() - Start acceleration service for the given accel device
 * @accel_dev:    Pointer to acceleration device.
 *
 * Function notifies all the registered services that the acceleration device
 * is ready to be used.
 * To be used by QAT device specific drivers.
 *
 * Return: 0 on success, error code otherwise.
 */
int
adf_dev_start(struct adf_accel_dev *accel_dev)
{
        int ret = 0;

        mutex_lock(&accel_dev->lock);
        ret = adf_dev_start_locked(accel_dev);
        mutex_unlock(&accel_dev->lock);

        return ret;
}

static int
adf_dev_start_locked(struct adf_accel_dev *accel_dev)
{
        struct adf_hw_device_data *hw_data = accel_dev->hw_device;
        struct service_hndl *service;
        struct list_head *list_itr;

        set_bit(ADF_STATUS_STARTING, &accel_dev->status);
        if (adf_ae_start(accel_dev)) {
                device_printf(GET_DEV(accel_dev), "AE Start Failed\n");
                return EFAULT;
        }

        set_bit(ADF_STATUS_AE_STARTED, &accel_dev->status);
        if (hw_data->send_admin_init(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to send init message\n");
                return EFAULT;
        }

        if (adf_cfg_add_fw_version(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to update configuration FW version\n");
                return EFAULT;
        }

        if (hw_data->measure_clock)
                hw_data->measure_clock(accel_dev);

        /*
         * Set ssm watch dog timer for slice hang detection
         * Note! Not supported on devices older than C62x
         */
        if (hw_data->set_ssm_wdtimer && hw_data->set_ssm_wdtimer(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "QAT: Failed to set ssm watch dog timer\n");
                return EFAULT;
        }

        if (hw_data->int_timer_init && hw_data->int_timer_init(accel_dev)) {
                device_printf(GET_DEV(accel_dev),
                              "Failed to init heartbeat interrupt timer\n");
                return -EFAULT;
        }

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (service->event_hld(accel_dev, ADF_EVENT_START)) {
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to start service %s\n",
                                      service->name);
                        return EFAULT;
                }
                set_bit(accel_dev->accel_id, service->start_status);
        }

        if (accel_dev->is_vf || !accel_dev->u1.pf.vf_info) {
                /*Register UIO devices */
                if (adf_uio_register(accel_dev)) {
                        adf_uio_remove(accel_dev);
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to register UIO devices\n");
                        set_bit(ADF_STATUS_STARTING, &accel_dev->status);
                        clear_bit(ADF_STATUS_STARTED, &accel_dev->status);
                        return ENODEV;
                }
        }

        if (!test_bit(ADF_STATUS_RESTARTING, &accel_dev->status) &&
            adf_cfg_add_ext_params(accel_dev))
                return EFAULT;

        clear_bit(ADF_STATUS_STARTING, &accel_dev->status);
        set_bit(ADF_STATUS_STARTED, &accel_dev->status);

        adf_dbgfs_add(accel_dev);

        return 0;
}

/**
 * adf_dev_stop() - Stop acceleration service for the given accel device
 * @accel_dev:    Pointer to acceleration device.
 *
 * Function notifies all the registered services that the acceleration device
 * is shuting down.
 * To be used by QAT device specific drivers.
 *
 * Return: 0 on success, error code otherwise.
 */
int
adf_dev_stop(struct adf_accel_dev *accel_dev)
{
        int ret = 0;

        mutex_lock(&accel_dev->lock);
        ret = adf_dev_stop_locked(accel_dev);
        mutex_unlock(&accel_dev->lock);

        return ret;
}

static int
adf_dev_stop_locked(struct adf_accel_dev *accel_dev)
{
        struct service_hndl *service;
        struct list_head *list_itr;

        if (!test_bit(ADF_STATUS_CONFIGURED, &accel_dev->status))
                return 0;

        if (!adf_dev_started(accel_dev) &&
            !test_bit(ADF_STATUS_STARTING, &accel_dev->status)) {
                return 0;
        }

        if (adf_dev_stop_notify_sync(accel_dev)) {
                device_printf(
                    GET_DEV(accel_dev),
                    "Waiting for device un-busy failed. Retries limit reached\n");
                return EBUSY;
        }

        adf_dbgfs_rm(accel_dev);

        clear_bit(ADF_STATUS_STARTING, &accel_dev->status);
        clear_bit(ADF_STATUS_STARTED, &accel_dev->status);

        if (accel_dev->hw_device->int_timer_exit)
                accel_dev->hw_device->int_timer_exit(accel_dev);

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (!test_bit(accel_dev->accel_id, service->start_status))
                        continue;
                clear_bit(accel_dev->accel_id, service->start_status);
        }

        if (accel_dev->is_vf || !accel_dev->u1.pf.vf_info) {
                /* Remove UIO Devices */
                adf_uio_remove(accel_dev);
        }

        if (test_bit(ADF_STATUS_AE_STARTED, &accel_dev->status)) {
                if (adf_ae_stop(accel_dev))
                        device_printf(GET_DEV(accel_dev),
                                      "failed to stop AE\n");
                else
                        clear_bit(ADF_STATUS_AE_STARTED, &accel_dev->status);
        }

        return 0;
}

/**
 * adf_dev_shutdown() - shutdown acceleration services and data strucutures
 * @accel_dev: Pointer to acceleration device
 *
 * Cleanup the ring data structures and the admin comms and arbitration
 * services.
 */
void
adf_dev_shutdown(struct adf_accel_dev *accel_dev)
{
        mutex_lock(&accel_dev->lock);
        adf_dev_shutdown_locked(accel_dev);
        mutex_unlock(&accel_dev->lock);
}

static void
adf_dev_shutdown_locked(struct adf_accel_dev *accel_dev)
{
        struct adf_hw_device_data *hw_data = accel_dev->hw_device;
        struct service_hndl *service;
        struct list_head *list_itr;

        if (!test_bit(ADF_STATUS_CONFIGURED, &accel_dev->status))
                return;

        if (test_bit(ADF_STATUS_SYSCTL_CTX_INITIALISED, &accel_dev->status)) {
                sysctl_ctx_free(&accel_dev->sysctl_ctx);
                clear_bit(ADF_STATUS_SYSCTL_CTX_INITIALISED,
                          &accel_dev->status);
        }

        if (!hw_data) {
                device_printf(
                    GET_DEV(accel_dev),
                    "QAT: Failed to shutdown device - hw_data not set\n");
                return;
        }

        if (test_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status)) {
                adf_ae_fw_release(accel_dev);
                clear_bit(ADF_STATUS_AE_UCODE_LOADED, &accel_dev->status);
        }

        if (test_bit(ADF_STATUS_AE_INITIALISED, &accel_dev->status)) {
                if (adf_ae_shutdown(accel_dev))
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to shutdown Accel Engine\n");
                else
                        clear_bit(ADF_STATUS_AE_INITIALISED,
                                  &accel_dev->status);
        }

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (!test_bit(accel_dev->accel_id, service->init_status))
                        continue;
                if (service->event_hld(accel_dev, ADF_EVENT_SHUTDOWN))
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to shutdown service %s\n",
                                      service->name);
                else
                        clear_bit(accel_dev->accel_id, service->init_status);
        }

        hw_data->disable_iov(accel_dev);

        if (test_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status)) {
                hw_data->free_irq(accel_dev);
                clear_bit(ADF_STATUS_IRQ_ALLOCATED, &accel_dev->status);
        }

        /* Delete configuration only if not restarting */
        if (!test_bit(ADF_STATUS_RESTARTING, &accel_dev->status)) {
                adf_cfg_del_all(accel_dev);
#ifdef QAT_UIO
                adf_cfg_device_clear_all(accel_dev);
#endif
        }

        if (hw_data->remove_pke_stats)
                hw_data->remove_pke_stats(accel_dev);

        if (hw_data->remove_misc_error)
                hw_data->remove_misc_error(accel_dev);

        if (hw_data->exit_ras)
                hw_data->exit_ras(accel_dev);

        if (hw_data->exit_arb)
                hw_data->exit_arb(accel_dev);

        if (hw_data->exit_admin_comms)
                hw_data->exit_admin_comms(accel_dev);

        if (hw_data->exit_accel_units)
                hw_data->exit_accel_units(accel_dev);

        adf_cleanup_etr_data(accel_dev);
        if (hw_data->restore_device)
                hw_data->restore_device(accel_dev);
}

/**
 * adf_dev_reset() - Reset acceleration service for the given accel device
 * @accel_dev:    Pointer to acceleration device.
 * @mode: Specifies reset mode - synchronous or asynchronous.
 * Function notifies all the registered services that the acceleration device
 * is resetting.
 * To be used by QAT device specific drivers.
 *
 * Return: 0 on success, error code otherwise.
 */
int
adf_dev_reset(struct adf_accel_dev *accel_dev, enum adf_dev_reset_mode mode)
{
        return adf_dev_aer_schedule_reset(accel_dev, mode);
}

int
adf_dev_restarting_notify(struct adf_accel_dev *accel_dev)
{
        struct service_hndl *service;
        struct list_head *list_itr;

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (service->event_hld(accel_dev, ADF_EVENT_RESTARTING))
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to restart service %s.\n",
                                      service->name);
        }
        return 0;
}

int
adf_dev_restarting_notify_sync(struct adf_accel_dev *accel_dev)
{
        int times;

        adf_dev_restarting_notify(accel_dev);
        for (times = 0; times < ADF_STOP_RETRY; times++) {
                if (!adf_dev_in_use(accel_dev))
                        break;
                dev_dbg(GET_DEV(accel_dev), "retry times=%d\n", times);
                pause_ms("adfstop", 100);
        }
        if (adf_dev_in_use(accel_dev)) {
                clear_bit(ADF_STATUS_RESTARTING, &accel_dev->status);
                device_printf(GET_DEV(accel_dev),
                              "Device still in use during reset sequence.\n");
                return EBUSY;
        }

        return 0;
}

int
adf_dev_stop_notify_sync(struct adf_accel_dev *accel_dev)
{
        int times;

        struct service_hndl *service;
        struct list_head *list_itr;

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (service->event_hld(accel_dev, ADF_EVENT_STOP))
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to restart service %s.\n",
                                      service->name);
        }

        for (times = 0; times < ADF_STOP_RETRY; times++) {
                if (!adf_dev_in_use(accel_dev))
                        break;
                dev_dbg(GET_DEV(accel_dev), "retry times=%d\n", times);
                pause_ms("adfstop", 100);
        }
        if (adf_dev_in_use(accel_dev)) {
                clear_bit(ADF_STATUS_RESTARTING, &accel_dev->status);
                device_printf(GET_DEV(accel_dev),
                              "Device still in use during stop sequence.\n");
                return EBUSY;
        }

        return 0;
}

int
adf_dev_restarted_notify(struct adf_accel_dev *accel_dev)
{
        struct service_hndl *service;
        struct list_head *list_itr;

        list_for_each(list_itr, &service_table)
        {
                service = list_entry(list_itr, struct service_hndl, list);
                if (service->event_hld(accel_dev, ADF_EVENT_RESTARTED))
                        device_printf(GET_DEV(accel_dev),
                                      "Failed to restart service %s.\n",
                                      service->name);
        }
        return 0;
}