// SPDX-License-Identifier: GPL-2.0
/*
 *    driver for Microchip PQI-based storage controllers
 *    Copyright (c) 2019-2021 Microchip Technology Inc. and its subsidiaries
 *    Copyright (c) 2016-2018 Microsemi Corporation
 *    Copyright (c) 2016 PMC-Sierra, Inc.
 *
 *    Questions/Comments/Bugfixes to storagedev@microchip.com
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/reboot.h>
#include <linux/cciss_ioctl.h>
#include <linux/blk-mq-pci.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_transport_sas.h>
#include <asm/unaligned.h>
#include "smartpqi.h"
#include "smartpqi_sis.h"

#if !defined(BUILD_TIMESTAMP)
#define BUILD_TIMESTAMP
#endif

#define DRIVER_VERSION          "2.1.10-020"
#define DRIVER_MAJOR            2
#define DRIVER_MINOR            1
#define DRIVER_RELEASE          10
#define DRIVER_REVISION         20

#define DRIVER_NAME             "Microchip SmartPQI Driver (v" \
                                DRIVER_VERSION BUILD_TIMESTAMP ")"
#define DRIVER_NAME_SHORT       "smartpqi"

#define PQI_EXTRA_SGL_MEMORY    (12 * sizeof(struct pqi_sg_descriptor))

#define PQI_POST_RESET_DELAY_SECS                       5
#define PQI_POST_OFA_RESET_DELAY_UPON_TIMEOUT_SECS      10

MODULE_AUTHOR("Microchip");
MODULE_DESCRIPTION("Driver for Microchip Smart Family Controller version "
        DRIVER_VERSION);
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL");

static void pqi_take_ctrl_offline(struct pqi_ctrl_info *ctrl_info);
static void pqi_ctrl_offline_worker(struct work_struct *work);
static int pqi_scan_scsi_devices(struct pqi_ctrl_info *ctrl_info);
static void pqi_scan_start(struct Scsi_Host *shost);
static void pqi_start_io(struct pqi_ctrl_info *ctrl_info,
        struct pqi_queue_group *queue_group, enum pqi_io_path path,
        struct pqi_io_request *io_request);
static int pqi_submit_raid_request_synchronous(struct pqi_ctrl_info *ctrl_info,
        struct pqi_iu_header *request, unsigned int flags,
        struct pqi_raid_error_info *error_info);
static int pqi_aio_submit_io(struct pqi_ctrl_info *ctrl_info,
        struct scsi_cmnd *scmd, u32 aio_handle, u8 *cdb,
        unsigned int cdb_length, struct pqi_queue_group *queue_group,
        struct pqi_encryption_info *encryption_info, bool raid_bypass);
static  int pqi_aio_submit_r1_write_io(struct pqi_ctrl_info *ctrl_info,
        struct scsi_cmnd *scmd, struct pqi_queue_group *queue_group,
        struct pqi_encryption_info *encryption_info, struct pqi_scsi_dev *device,
        struct pqi_scsi_dev_raid_map_data *rmd);
static int pqi_aio_submit_r56_write_io(struct pqi_ctrl_info *ctrl_info,
        struct scsi_cmnd *scmd, struct pqi_queue_group *queue_group,
        struct pqi_encryption_info *encryption_info, struct pqi_scsi_dev *device,
        struct pqi_scsi_dev_raid_map_data *rmd);
static void pqi_ofa_ctrl_quiesce(struct pqi_ctrl_info *ctrl_info);
static void pqi_ofa_ctrl_unquiesce(struct pqi_ctrl_info *ctrl_info);
static int pqi_ofa_ctrl_restart(struct pqi_ctrl_info *ctrl_info, unsigned int delay_secs);
static void pqi_ofa_setup_host_buffer(struct pqi_ctrl_info *ctrl_info);
static void pqi_ofa_free_host_buffer(struct pqi_ctrl_info *ctrl_info);
static int pqi_ofa_host_memory_update(struct pqi_ctrl_info *ctrl_info);
static int pqi_device_wait_for_pending_io(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device, unsigned long timeout_msecs);

/* for flags argument to pqi_submit_raid_request_synchronous() */
#define PQI_SYNC_FLAGS_INTERRUPTABLE    0x1

static struct scsi_transport_template *pqi_sas_transport_template;

static atomic_t pqi_controller_count = ATOMIC_INIT(0);

enum pqi_lockup_action {
        NONE,
        REBOOT,
        PANIC
};

static enum pqi_lockup_action pqi_lockup_action = NONE;

static struct {
        enum pqi_lockup_action  action;
        char                    *name;
} pqi_lockup_actions[] = {
        {
                .action = NONE,
                .name = "none",
        },
        {
                .action = REBOOT,
                .name = "reboot",
        },
        {
                .action = PANIC,
                .name = "panic",
        },
};

static unsigned int pqi_supported_event_types[] = {
        PQI_EVENT_TYPE_HOTPLUG,
        PQI_EVENT_TYPE_HARDWARE,
        PQI_EVENT_TYPE_PHYSICAL_DEVICE,
        PQI_EVENT_TYPE_LOGICAL_DEVICE,
        PQI_EVENT_TYPE_OFA,
        PQI_EVENT_TYPE_AIO_STATE_CHANGE,
        PQI_EVENT_TYPE_AIO_CONFIG_CHANGE,
};

static int pqi_disable_device_id_wildcards;
module_param_named(disable_device_id_wildcards,
        pqi_disable_device_id_wildcards, int, 0644);
MODULE_PARM_DESC(disable_device_id_wildcards,
        "Disable device ID wildcards.");

static int pqi_disable_heartbeat;
module_param_named(disable_heartbeat,
        pqi_disable_heartbeat, int, 0644);
MODULE_PARM_DESC(disable_heartbeat,
        "Disable heartbeat.");

static int pqi_disable_ctrl_shutdown;
module_param_named(disable_ctrl_shutdown,
        pqi_disable_ctrl_shutdown, int, 0644);
MODULE_PARM_DESC(disable_ctrl_shutdown,
        "Disable controller shutdown when controller locked up.");

static char *pqi_lockup_action_param;
module_param_named(lockup_action,
        pqi_lockup_action_param, charp, 0644);
MODULE_PARM_DESC(lockup_action, "Action to take when controller locked up.\n"
        "\t\tSupported: none, reboot, panic\n"
        "\t\tDefault: none");

static int pqi_expose_ld_first;
module_param_named(expose_ld_first,
        pqi_expose_ld_first, int, 0644);
MODULE_PARM_DESC(expose_ld_first, "Expose logical drives before physical drives.");

static int pqi_hide_vsep;
module_param_named(hide_vsep,
        pqi_hide_vsep, int, 0644);
MODULE_PARM_DESC(hide_vsep, "Hide the virtual SEP for direct attached drives.");

static char *raid_levels[] = {
        "RAID-0",
        "RAID-4",
        "RAID-1(1+0)",
        "RAID-5",
        "RAID-5+1",
        "RAID-6",
        "RAID-1(Triple)",
};

static char *pqi_raid_level_to_string(u8 raid_level)
{
        if (raid_level < ARRAY_SIZE(raid_levels))
                return raid_levels[raid_level];

        return "RAID UNKNOWN";
}

#define SA_RAID_0               0
#define SA_RAID_4               1
#define SA_RAID_1               2       /* also used for RAID 10 */
#define SA_RAID_5               3       /* also used for RAID 50 */
#define SA_RAID_51              4
#define SA_RAID_6               5       /* also used for RAID 60 */
#define SA_RAID_TRIPLE          6       /* also used for RAID 1+0 Triple */
#define SA_RAID_MAX             SA_RAID_TRIPLE
#define SA_RAID_UNKNOWN         0xff

static inline void pqi_scsi_done(struct scsi_cmnd *scmd)
{
        pqi_prep_for_scsi_done(scmd);
        scmd->scsi_done(scmd);
}

static inline void pqi_disable_write_same(struct scsi_device *sdev)
{
        sdev->no_write_same = 1;
}

static inline bool pqi_scsi3addr_equal(u8 *scsi3addr1, u8 *scsi3addr2)
{
        return memcmp(scsi3addr1, scsi3addr2, 8) == 0;
}

static inline bool pqi_is_logical_device(struct pqi_scsi_dev *device)
{
        return !device->is_physical_device;
}

static inline bool pqi_is_external_raid_addr(u8 *scsi3addr)
{
        return scsi3addr[2] != 0;
}

static inline bool pqi_ctrl_offline(struct pqi_ctrl_info *ctrl_info)
{
        return !ctrl_info->controller_online;
}

static inline void pqi_check_ctrl_health(struct pqi_ctrl_info *ctrl_info)
{
        if (ctrl_info->controller_online)
                if (!sis_is_firmware_running(ctrl_info))
                        pqi_take_ctrl_offline(ctrl_info);
}

static inline bool pqi_is_hba_lunid(u8 *scsi3addr)
{
        return pqi_scsi3addr_equal(scsi3addr, RAID_CTLR_LUNID);
}

static inline enum pqi_ctrl_mode pqi_get_ctrl_mode(struct pqi_ctrl_info *ctrl_info)
{
        return sis_read_driver_scratch(ctrl_info);
}

static inline void pqi_save_ctrl_mode(struct pqi_ctrl_info *ctrl_info,
        enum pqi_ctrl_mode mode)
{
        sis_write_driver_scratch(ctrl_info, mode);
}

static inline void pqi_ctrl_block_scan(struct pqi_ctrl_info *ctrl_info)
{
        ctrl_info->scan_blocked = true;
        mutex_lock(&ctrl_info->scan_mutex);
}

static inline void pqi_ctrl_unblock_scan(struct pqi_ctrl_info *ctrl_info)
{
        ctrl_info->scan_blocked = false;
        mutex_unlock(&ctrl_info->scan_mutex);
}

static inline bool pqi_ctrl_scan_blocked(struct pqi_ctrl_info *ctrl_info)
{
        return ctrl_info->scan_blocked;
}

static inline void pqi_ctrl_block_device_reset(struct pqi_ctrl_info *ctrl_info)
{
        mutex_lock(&ctrl_info->lun_reset_mutex);
}

static inline void pqi_ctrl_unblock_device_reset(struct pqi_ctrl_info *ctrl_info)
{
        mutex_unlock(&ctrl_info->lun_reset_mutex);
}

static inline void pqi_scsi_block_requests(struct pqi_ctrl_info *ctrl_info)
{
        struct Scsi_Host *shost;
        unsigned int num_loops;
        int msecs_sleep;

        shost = ctrl_info->scsi_host;

        scsi_block_requests(shost);

        num_loops = 0;
        msecs_sleep = 20;
        while (scsi_host_busy(shost)) {
                num_loops++;
                if (num_loops == 10)
                        msecs_sleep = 500;
                msleep(msecs_sleep);
        }
}

static inline void pqi_scsi_unblock_requests(struct pqi_ctrl_info *ctrl_info)
{
        scsi_unblock_requests(ctrl_info->scsi_host);
}

static inline void pqi_ctrl_busy(struct pqi_ctrl_info *ctrl_info)
{
        atomic_inc(&ctrl_info->num_busy_threads);
}

static inline void pqi_ctrl_unbusy(struct pqi_ctrl_info *ctrl_info)
{
        atomic_dec(&ctrl_info->num_busy_threads);
}

static inline bool pqi_ctrl_blocked(struct pqi_ctrl_info *ctrl_info)
{
        return ctrl_info->block_requests;
}

static inline void pqi_ctrl_block_requests(struct pqi_ctrl_info *ctrl_info)
{
        ctrl_info->block_requests = true;
}

static inline void pqi_ctrl_unblock_requests(struct pqi_ctrl_info *ctrl_info)
{
        ctrl_info->block_requests = false;
        wake_up_all(&ctrl_info->block_requests_wait);
}

static void pqi_wait_if_ctrl_blocked(struct pqi_ctrl_info *ctrl_info)
{
        if (!pqi_ctrl_blocked(ctrl_info))
                return;

        atomic_inc(&ctrl_info->num_blocked_threads);
        wait_event(ctrl_info->block_requests_wait,
                !pqi_ctrl_blocked(ctrl_info));
        atomic_dec(&ctrl_info->num_blocked_threads);
}

#define PQI_QUIESCE_WARNING_TIMEOUT_SECS                10

static inline void pqi_ctrl_wait_until_quiesced(struct pqi_ctrl_info *ctrl_info)
{
        unsigned long start_jiffies;
        unsigned long warning_timeout;
        bool displayed_warning;

        displayed_warning = false;
        start_jiffies = jiffies;
        warning_timeout = (PQI_QUIESCE_WARNING_TIMEOUT_SECS * PQI_HZ) + start_jiffies;

        while (atomic_read(&ctrl_info->num_busy_threads) >
                atomic_read(&ctrl_info->num_blocked_threads)) {
                if (time_after(jiffies, warning_timeout)) {
                        dev_warn(&ctrl_info->pci_dev->dev,
                                "waiting %u seconds for driver activity to quiesce\n",
                                jiffies_to_msecs(jiffies - start_jiffies) / 1000);
                        displayed_warning = true;
                        warning_timeout = (PQI_QUIESCE_WARNING_TIMEOUT_SECS * PQI_HZ) + jiffies;
                }
                usleep_range(1000, 2000);
        }

        if (displayed_warning)
                dev_warn(&ctrl_info->pci_dev->dev,
                        "driver activity quiesced after waiting for %u seconds\n",
                        jiffies_to_msecs(jiffies - start_jiffies) / 1000);
}

static inline bool pqi_device_offline(struct pqi_scsi_dev *device)
{
        return device->device_offline;
}

static inline void pqi_ctrl_ofa_start(struct pqi_ctrl_info *ctrl_info)
{
        mutex_lock(&ctrl_info->ofa_mutex);
}

static inline void pqi_ctrl_ofa_done(struct pqi_ctrl_info *ctrl_info)
{
        mutex_unlock(&ctrl_info->ofa_mutex);
}

static inline void pqi_wait_until_ofa_finished(struct pqi_ctrl_info *ctrl_info)
{
        mutex_lock(&ctrl_info->ofa_mutex);
        mutex_unlock(&ctrl_info->ofa_mutex);
}

static inline bool pqi_ofa_in_progress(struct pqi_ctrl_info *ctrl_info)
{
        return mutex_is_locked(&ctrl_info->ofa_mutex);
}

static inline void pqi_device_remove_start(struct pqi_scsi_dev *device)
{
        device->in_remove = true;
}

static inline bool pqi_device_in_remove(struct pqi_scsi_dev *device)
{
        return device->in_remove;
}

static inline int pqi_event_type_to_event_index(unsigned int event_type)
{
        int index;

        for (index = 0; index < ARRAY_SIZE(pqi_supported_event_types); index++)
                if (event_type == pqi_supported_event_types[index])
                        return index;

        return -1;
}

static inline bool pqi_is_supported_event(unsigned int event_type)
{
        return pqi_event_type_to_event_index(event_type) != -1;
}

static inline void pqi_schedule_rescan_worker_with_delay(struct pqi_ctrl_info *ctrl_info,
        unsigned long delay)
{
        if (pqi_ctrl_offline(ctrl_info))
                return;

        schedule_delayed_work(&ctrl_info->rescan_work, delay);
}

static inline void pqi_schedule_rescan_worker(struct pqi_ctrl_info *ctrl_info)
{
        pqi_schedule_rescan_worker_with_delay(ctrl_info, 0);
}

#define PQI_RESCAN_WORK_DELAY   (10 * PQI_HZ)

static inline void pqi_schedule_rescan_worker_delayed(struct pqi_ctrl_info *ctrl_info)
{
        pqi_schedule_rescan_worker_with_delay(ctrl_info, PQI_RESCAN_WORK_DELAY);
}

static inline void pqi_cancel_rescan_worker(struct pqi_ctrl_info *ctrl_info)
{
        cancel_delayed_work_sync(&ctrl_info->rescan_work);
}

static inline u32 pqi_read_heartbeat_counter(struct pqi_ctrl_info *ctrl_info)
{
        if (!ctrl_info->heartbeat_counter)
                return 0;

        return readl(ctrl_info->heartbeat_counter);
}

static inline u8 pqi_read_soft_reset_status(struct pqi_ctrl_info *ctrl_info)
{
        return readb(ctrl_info->soft_reset_status);
}

static inline void pqi_clear_soft_reset_status(struct pqi_ctrl_info *ctrl_info)
{
        u8 status;

        status = pqi_read_soft_reset_status(ctrl_info);
        status &= ~PQI_SOFT_RESET_ABORT;
        writeb(status, ctrl_info->soft_reset_status);
}

static int pqi_map_single(struct pci_dev *pci_dev,
        struct pqi_sg_descriptor *sg_descriptor, void *buffer,
        size_t buffer_length, enum dma_data_direction data_direction)
{
        dma_addr_t bus_address;

        if (!buffer || buffer_length == 0 || data_direction == DMA_NONE)
                return 0;

        bus_address = dma_map_single(&pci_dev->dev, buffer, buffer_length,
                data_direction);
        if (dma_mapping_error(&pci_dev->dev, bus_address))
                return -ENOMEM;

        put_unaligned_le64((u64)bus_address, &sg_descriptor->address);
        put_unaligned_le32(buffer_length, &sg_descriptor->length);
        put_unaligned_le32(CISS_SG_LAST, &sg_descriptor->flags);

        return 0;
}

static void pqi_pci_unmap(struct pci_dev *pci_dev,
        struct pqi_sg_descriptor *descriptors, int num_descriptors,
        enum dma_data_direction data_direction)
{
        int i;

        if (data_direction == DMA_NONE)
                return;

        for (i = 0; i < num_descriptors; i++)
                dma_unmap_single(&pci_dev->dev,
                        (dma_addr_t)get_unaligned_le64(&descriptors[i].address),
                        get_unaligned_le32(&descriptors[i].length),
                        data_direction);
}

static int pqi_build_raid_path_request(struct pqi_ctrl_info *ctrl_info,
        struct pqi_raid_path_request *request, u8 cmd,
        u8 *scsi3addr, void *buffer, size_t buffer_length,
        u16 vpd_page, enum dma_data_direction *dir)
{
        u8 *cdb;
        size_t cdb_length = buffer_length;

        memset(request, 0, sizeof(*request));

        request->header.iu_type = PQI_REQUEST_IU_RAID_PATH_IO;
        put_unaligned_le16(offsetof(struct pqi_raid_path_request,
                sg_descriptors[1]) - PQI_REQUEST_HEADER_LENGTH,
                &request->header.iu_length);
        put_unaligned_le32(buffer_length, &request->buffer_length);
        memcpy(request->lun_number, scsi3addr, sizeof(request->lun_number));
        request->task_attribute = SOP_TASK_ATTRIBUTE_SIMPLE;
        request->additional_cdb_bytes_usage = SOP_ADDITIONAL_CDB_BYTES_0;

        cdb = request->cdb;

        switch (cmd) {
        case INQUIRY:
                request->data_direction = SOP_READ_FLAG;
                cdb[0] = INQUIRY;
                if (vpd_page & VPD_PAGE) {
                        cdb[1] = 0x1;
                        cdb[2] = (u8)vpd_page;
                }
                cdb[4] = (u8)cdb_length;
                break;
        case CISS_REPORT_LOG:
        case CISS_REPORT_PHYS:
                request->data_direction = SOP_READ_FLAG;
                cdb[0] = cmd;
                if (cmd == CISS_REPORT_PHYS)
                        cdb[1] = CISS_REPORT_PHYS_FLAG_OTHER;
                else
                        cdb[1] = ctrl_info->ciss_report_log_flags;
                put_unaligned_be32(cdb_length, &cdb[6]);
                break;
        case CISS_GET_RAID_MAP:
                request->data_direction = SOP_READ_FLAG;
                cdb[0] = CISS_READ;
                cdb[1] = CISS_GET_RAID_MAP;
                put_unaligned_be32(cdb_length, &cdb[6]);
                break;
        case SA_FLUSH_CACHE:
                request->header.driver_flags = PQI_DRIVER_NONBLOCKABLE_REQUEST;
                request->data_direction = SOP_WRITE_FLAG;
                cdb[0] = BMIC_WRITE;
                cdb[6] = BMIC_FLUSH_CACHE;
                put_unaligned_be16(cdb_length, &cdb[7]);
                break;
        case BMIC_SENSE_DIAG_OPTIONS:
                cdb_length = 0;
                fallthrough;
        case BMIC_IDENTIFY_CONTROLLER:
        case BMIC_IDENTIFY_PHYSICAL_DEVICE:
        case BMIC_SENSE_SUBSYSTEM_INFORMATION:
        case BMIC_SENSE_FEATURE:
                request->data_direction = SOP_READ_FLAG;
                cdb[0] = BMIC_READ;
                cdb[6] = cmd;
                put_unaligned_be16(cdb_length, &cdb[7]);
                break;
        case BMIC_SET_DIAG_OPTIONS:
                cdb_length = 0;
                fallthrough;
        case BMIC_WRITE_HOST_WELLNESS:
                request->data_direction = SOP_WRITE_FLAG;
                cdb[0] = BMIC_WRITE;
                cdb[6] = cmd;
                put_unaligned_be16(cdb_length, &cdb[7]);
                break;
        case BMIC_CSMI_PASSTHRU:
                request->data_direction = SOP_BIDIRECTIONAL;
                cdb[0] = BMIC_WRITE;
                cdb[5] = CSMI_CC_SAS_SMP_PASSTHRU;
                cdb[6] = cmd;
                put_unaligned_be16(cdb_length, &cdb[7]);
                break;
        default:
                dev_err(&ctrl_info->pci_dev->dev, "unknown command 0x%c\n", cmd);
                break;
        }

        switch (request->data_direction) {
        case SOP_READ_FLAG:
                *dir = DMA_FROM_DEVICE;
                break;
        case SOP_WRITE_FLAG:
                *dir = DMA_TO_DEVICE;
                break;
        case SOP_NO_DIRECTION_FLAG:
                *dir = DMA_NONE;
                break;
        default:
                *dir = DMA_BIDIRECTIONAL;
                break;
        }

        return pqi_map_single(ctrl_info->pci_dev, &request->sg_descriptors[0],
                buffer, buffer_length, *dir);
}

static inline void pqi_reinit_io_request(struct pqi_io_request *io_request)
{
        io_request->scmd = NULL;
        io_request->status = 0;
        io_request->error_info = NULL;
        io_request->raid_bypass = false;
}

static struct pqi_io_request *pqi_alloc_io_request(
        struct pqi_ctrl_info *ctrl_info)
{
        struct pqi_io_request *io_request;
        u16 i = ctrl_info->next_io_request_slot;        /* benignly racy */

        while (1) {
                io_request = &ctrl_info->io_request_pool[i];
                if (atomic_inc_return(&io_request->refcount) == 1)
                        break;
                atomic_dec(&io_request->refcount);
                i = (i + 1) % ctrl_info->max_io_slots;
        }

        /* benignly racy */
        ctrl_info->next_io_request_slot = (i + 1) % ctrl_info->max_io_slots;

        pqi_reinit_io_request(io_request);

        return io_request;
}

static void pqi_free_io_request(struct pqi_io_request *io_request)
{
        atomic_dec(&io_request->refcount);
}

static int pqi_send_scsi_raid_request(struct pqi_ctrl_info *ctrl_info, u8 cmd,
        u8 *scsi3addr, void *buffer, size_t buffer_length, u16 vpd_page,
        struct pqi_raid_error_info *error_info)
{
        int rc;
        struct pqi_raid_path_request request;
        enum dma_data_direction dir;

        rc = pqi_build_raid_path_request(ctrl_info, &request, cmd, scsi3addr,
                buffer, buffer_length, vpd_page, &dir);
        if (rc)
                return rc;

        rc = pqi_submit_raid_request_synchronous(ctrl_info, &request.header, 0, error_info);

        pqi_pci_unmap(ctrl_info->pci_dev, request.sg_descriptors, 1, dir);

        return rc;
}

/* helper functions for pqi_send_scsi_raid_request */

static inline int pqi_send_ctrl_raid_request(struct pqi_ctrl_info *ctrl_info,
        u8 cmd, void *buffer, size_t buffer_length)
{
        return pqi_send_scsi_raid_request(ctrl_info, cmd, RAID_CTLR_LUNID,
                buffer, buffer_length, 0, NULL);
}

static inline int pqi_send_ctrl_raid_with_error(struct pqi_ctrl_info *ctrl_info,
        u8 cmd, void *buffer, size_t buffer_length,
        struct pqi_raid_error_info *error_info)
{
        return pqi_send_scsi_raid_request(ctrl_info, cmd, RAID_CTLR_LUNID,
                buffer, buffer_length, 0, error_info);
}

static inline int pqi_identify_controller(struct pqi_ctrl_info *ctrl_info,
        struct bmic_identify_controller *buffer)
{
        return pqi_send_ctrl_raid_request(ctrl_info, BMIC_IDENTIFY_CONTROLLER,
                buffer, sizeof(*buffer));
}

static inline int pqi_sense_subsystem_info(struct  pqi_ctrl_info *ctrl_info,
        struct bmic_sense_subsystem_info *sense_info)
{
        return pqi_send_ctrl_raid_request(ctrl_info,
                BMIC_SENSE_SUBSYSTEM_INFORMATION, sense_info,
                sizeof(*sense_info));
}

static inline int pqi_scsi_inquiry(struct pqi_ctrl_info *ctrl_info,
        u8 *scsi3addr, u16 vpd_page, void *buffer, size_t buffer_length)
{
        return pqi_send_scsi_raid_request(ctrl_info, INQUIRY, scsi3addr,
                buffer, buffer_length, vpd_page, NULL);
}

static int pqi_identify_physical_device(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device,
        struct bmic_identify_physical_device *buffer, size_t buffer_length)
{
        int rc;
        enum dma_data_direction dir;
        u16 bmic_device_index;
        struct pqi_raid_path_request request;

        rc = pqi_build_raid_path_request(ctrl_info, &request,
                BMIC_IDENTIFY_PHYSICAL_DEVICE, RAID_CTLR_LUNID, buffer,
                buffer_length, 0, &dir);
        if (rc)
                return rc;

        bmic_device_index = CISS_GET_DRIVE_NUMBER(device->scsi3addr);
        request.cdb[2] = (u8)bmic_device_index;
        request.cdb[9] = (u8)(bmic_device_index >> 8);

        rc = pqi_submit_raid_request_synchronous(ctrl_info, &request.header, 0, NULL);

        pqi_pci_unmap(ctrl_info->pci_dev, request.sg_descriptors, 1, dir);

        return rc;
}

static inline u32 pqi_aio_limit_to_bytes(__le16 *limit)
{
        u32 bytes;

        bytes = get_unaligned_le16(limit);
        if (bytes == 0)
                bytes = ~0;
        else
                bytes *= 1024;

        return bytes;
}

#pragma pack(1)

struct bmic_sense_feature_buffer {
        struct bmic_sense_feature_buffer_header header;
        struct bmic_sense_feature_io_page_aio_subpage aio_subpage;
};

#pragma pack()

#define MINIMUM_AIO_SUBPAGE_BUFFER_LENGTH       \
        offsetofend(struct bmic_sense_feature_buffer, \
                aio_subpage.max_write_raid_1_10_3drive)

#define MINIMUM_AIO_SUBPAGE_LENGTH      \
        (offsetofend(struct bmic_sense_feature_io_page_aio_subpage, \
                max_write_raid_1_10_3drive) - \
                sizeof_field(struct bmic_sense_feature_io_page_aio_subpage, header))

static int pqi_get_advanced_raid_bypass_config(struct pqi_ctrl_info *ctrl_info)
{
        int rc;
        enum dma_data_direction dir;
        struct pqi_raid_path_request request;
        struct bmic_sense_feature_buffer *buffer;

        buffer = kmalloc(sizeof(*buffer), GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;

        rc = pqi_build_raid_path_request(ctrl_info, &request, BMIC_SENSE_FEATURE, RAID_CTLR_LUNID,
                buffer, sizeof(*buffer), 0, &dir);
        if (rc)
                goto error;

        request.cdb[2] = BMIC_SENSE_FEATURE_IO_PAGE;
        request.cdb[3] = BMIC_SENSE_FEATURE_IO_PAGE_AIO_SUBPAGE;

        rc = pqi_submit_raid_request_synchronous(ctrl_info, &request.header, 0, NULL);

        pqi_pci_unmap(ctrl_info->pci_dev, request.sg_descriptors, 1, dir);

        if (rc)
                goto error;

        if (buffer->header.page_code != BMIC_SENSE_FEATURE_IO_PAGE ||
                buffer->header.subpage_code !=
                        BMIC_SENSE_FEATURE_IO_PAGE_AIO_SUBPAGE ||
                get_unaligned_le16(&buffer->header.buffer_length) <
                        MINIMUM_AIO_SUBPAGE_BUFFER_LENGTH ||
                buffer->aio_subpage.header.page_code !=
                        BMIC_SENSE_FEATURE_IO_PAGE ||
                buffer->aio_subpage.header.subpage_code !=
                        BMIC_SENSE_FEATURE_IO_PAGE_AIO_SUBPAGE ||
                get_unaligned_le16(&buffer->aio_subpage.header.page_length) <
                        MINIMUM_AIO_SUBPAGE_LENGTH) {
                goto error;
        }

        ctrl_info->max_transfer_encrypted_sas_sata =
                pqi_aio_limit_to_bytes(
                        &buffer->aio_subpage.max_transfer_encrypted_sas_sata);

        ctrl_info->max_transfer_encrypted_nvme =
                pqi_aio_limit_to_bytes(
                        &buffer->aio_subpage.max_transfer_encrypted_nvme);

        ctrl_info->max_write_raid_5_6 =
                pqi_aio_limit_to_bytes(
                        &buffer->aio_subpage.max_write_raid_5_6);

        ctrl_info->max_write_raid_1_10_2drive =
                pqi_aio_limit_to_bytes(
                        &buffer->aio_subpage.max_write_raid_1_10_2drive);

        ctrl_info->max_write_raid_1_10_3drive =
                pqi_aio_limit_to_bytes(
                        &buffer->aio_subpage.max_write_raid_1_10_3drive);

error:
        kfree(buffer);

        return rc;
}

static int pqi_flush_cache(struct pqi_ctrl_info *ctrl_info,
        enum bmic_flush_cache_shutdown_event shutdown_event)
{
        int rc;
        struct bmic_flush_cache *flush_cache;

        flush_cache = kzalloc(sizeof(*flush_cache), GFP_KERNEL);
        if (!flush_cache)
                return -ENOMEM;

        flush_cache->shutdown_event = shutdown_event;

        rc = pqi_send_ctrl_raid_request(ctrl_info, SA_FLUSH_CACHE, flush_cache,
                sizeof(*flush_cache));

        kfree(flush_cache);

        return rc;
}

int pqi_csmi_smp_passthru(struct pqi_ctrl_info *ctrl_info,
        struct bmic_csmi_smp_passthru_buffer *buffer, size_t buffer_length,
        struct pqi_raid_error_info *error_info)
{
        return pqi_send_ctrl_raid_with_error(ctrl_info, BMIC_CSMI_PASSTHRU,
                buffer, buffer_length, error_info);
}

#define PQI_FETCH_PTRAID_DATA           (1 << 31)

static int pqi_set_diag_rescan(struct pqi_ctrl_info *ctrl_info)
{
        int rc;
        struct bmic_diag_options *diag;

        diag = kzalloc(sizeof(*diag), GFP_KERNEL);
        if (!diag)
                return -ENOMEM;

        rc = pqi_send_ctrl_raid_request(ctrl_info, BMIC_SENSE_DIAG_OPTIONS,
                diag, sizeof(*diag));
        if (rc)
                goto out;

        diag->options |= cpu_to_le32(PQI_FETCH_PTRAID_DATA);

        rc = pqi_send_ctrl_raid_request(ctrl_info, BMIC_SET_DIAG_OPTIONS, diag,
                sizeof(*diag));

out:
        kfree(diag);

        return rc;
}

static inline int pqi_write_host_wellness(struct pqi_ctrl_info *ctrl_info,
        void *buffer, size_t buffer_length)
{
        return pqi_send_ctrl_raid_request(ctrl_info, BMIC_WRITE_HOST_WELLNESS,
                buffer, buffer_length);
}

#pragma pack(1)

struct bmic_host_wellness_driver_version {
        u8      start_tag[4];
        u8      driver_version_tag[2];
        __le16  driver_version_length;
        char    driver_version[32];
        u8      dont_write_tag[2];
        u8      end_tag[2];
};

#pragma pack()

static int pqi_write_driver_version_to_host_wellness(
        struct pqi_ctrl_info *ctrl_info)
{
        int rc;
        struct bmic_host_wellness_driver_version *buffer;
        size_t buffer_length;

        buffer_length = sizeof(*buffer);

        buffer = kmalloc(buffer_length, GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;

        buffer->start_tag[0] = '<';
        buffer->start_tag[1] = 'H';
        buffer->start_tag[2] = 'W';
        buffer->start_tag[3] = '>';
        buffer->driver_version_tag[0] = 'D';
        buffer->driver_version_tag[1] = 'V';
        put_unaligned_le16(sizeof(buffer->driver_version),
                &buffer->driver_version_length);
        strncpy(buffer->driver_version, "Linux " DRIVER_VERSION,
                sizeof(buffer->driver_version) - 1);
        buffer->driver_version[sizeof(buffer->driver_version) - 1] = '\0';
        buffer->dont_write_tag[0] = 'D';
        buffer->dont_write_tag[1] = 'W';
        buffer->end_tag[0] = 'Z';
        buffer->end_tag[1] = 'Z';

        rc = pqi_write_host_wellness(ctrl_info, buffer, buffer_length);

        kfree(buffer);

        return rc;
}

#pragma pack(1)

struct bmic_host_wellness_time {
        u8      start_tag[4];
        u8      time_tag[2];
        __le16  time_length;
        u8      time[8];
        u8      dont_write_tag[2];
        u8      end_tag[2];
};

#pragma pack()

static int pqi_write_current_time_to_host_wellness(
        struct pqi_ctrl_info *ctrl_info)
{
        int rc;
        struct bmic_host_wellness_time *buffer;
        size_t buffer_length;
        time64_t local_time;
        unsigned int year;
        struct tm tm;

        buffer_length = sizeof(*buffer);

        buffer = kmalloc(buffer_length, GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;

        buffer->start_tag[0] = '<';
        buffer->start_tag[1] = 'H';
        buffer->start_tag[2] = 'W';
        buffer->start_tag[3] = '>';
        buffer->time_tag[0] = 'T';
        buffer->time_tag[1] = 'D';
        put_unaligned_le16(sizeof(buffer->time),
                &buffer->time_length);

        local_time = ktime_get_real_seconds();
        time64_to_tm(local_time, -sys_tz.tz_minuteswest * 60, &tm);
        year = tm.tm_year + 1900;

        buffer->time[0] = bin2bcd(tm.tm_hour);
        buffer->time[1] = bin2bcd(tm.tm_min);
        buffer->time[2] = bin2bcd(tm.tm_sec);
        buffer->time[3] = 0;
        buffer->time[4] = bin2bcd(tm.tm_mon + 1);
        buffer->time[5] = bin2bcd(tm.tm_mday);
        buffer->time[6] = bin2bcd(year / 100);
        buffer->time[7] = bin2bcd(year % 100);

        buffer->dont_write_tag[0] = 'D';
        buffer->dont_write_tag[1] = 'W';
        buffer->end_tag[0] = 'Z';
        buffer->end_tag[1] = 'Z';

        rc = pqi_write_host_wellness(ctrl_info, buffer, buffer_length);

        kfree(buffer);

        return rc;
}

#define PQI_UPDATE_TIME_WORK_INTERVAL   (24UL * 60 * 60 * PQI_HZ)

static void pqi_update_time_worker(struct work_struct *work)
{
        int rc;
        struct pqi_ctrl_info *ctrl_info;

        ctrl_info = container_of(to_delayed_work(work), struct pqi_ctrl_info,
                update_time_work);

        rc = pqi_write_current_time_to_host_wellness(ctrl_info);
        if (rc)
                dev_warn(&ctrl_info->pci_dev->dev,
                        "error updating time on controller\n");

        schedule_delayed_work(&ctrl_info->update_time_work,
                PQI_UPDATE_TIME_WORK_INTERVAL);
}

static inline void pqi_schedule_update_time_worker(struct pqi_ctrl_info *ctrl_info)
{
        schedule_delayed_work(&ctrl_info->update_time_work, 0);
}

static inline void pqi_cancel_update_time_worker(struct pqi_ctrl_info *ctrl_info)
{
        cancel_delayed_work_sync(&ctrl_info->update_time_work);
}

static inline int pqi_report_luns(struct pqi_ctrl_info *ctrl_info, u8 cmd, void *buffer,
        size_t buffer_length)
{
        return pqi_send_ctrl_raid_request(ctrl_info, cmd, buffer, buffer_length);
}

static int pqi_report_phys_logical_luns(struct pqi_ctrl_info *ctrl_info, u8 cmd, void **buffer)
{
        int rc;
        size_t lun_list_length;
        size_t lun_data_length;
        size_t new_lun_list_length;
        void *lun_data = NULL;
        struct report_lun_header *report_lun_header;

        report_lun_header = kmalloc(sizeof(*report_lun_header), GFP_KERNEL);
        if (!report_lun_header) {
                rc = -ENOMEM;
                goto out;
        }

        rc = pqi_report_luns(ctrl_info, cmd, report_lun_header, sizeof(*report_lun_header));
        if (rc)
                goto out;

        lun_list_length = get_unaligned_be32(&report_lun_header->list_length);

again:
        lun_data_length = sizeof(struct report_lun_header) + lun_list_length;

        lun_data = kmalloc(lun_data_length, GFP_KERNEL);
        if (!lun_data) {
                rc = -ENOMEM;
                goto out;
        }

        if (lun_list_length == 0) {
                memcpy(lun_data, report_lun_header, sizeof(*report_lun_header));
                goto out;
        }

        rc = pqi_report_luns(ctrl_info, cmd, lun_data, lun_data_length);
        if (rc)
                goto out;

        new_lun_list_length =
                get_unaligned_be32(&((struct report_lun_header *)lun_data)->list_length);

        if (new_lun_list_length > lun_list_length) {
                lun_list_length = new_lun_list_length;
                kfree(lun_data);
                goto again;
        }

out:
        kfree(report_lun_header);

        if (rc) {
                kfree(lun_data);
                lun_data = NULL;
        }

        *buffer = lun_data;

        return rc;
}

static inline int pqi_report_phys_luns(struct pqi_ctrl_info *ctrl_info, void **buffer)
{
        return pqi_report_phys_logical_luns(ctrl_info, CISS_REPORT_PHYS, buffer);
}

static inline int pqi_report_logical_luns(struct pqi_ctrl_info *ctrl_info, void **buffer)
{
        return pqi_report_phys_logical_luns(ctrl_info, CISS_REPORT_LOG, buffer);
}

static int pqi_get_device_lists(struct pqi_ctrl_info *ctrl_info,
        struct report_phys_lun_extended **physdev_list,
        struct report_log_lun_extended **logdev_list)
{
        int rc;
        size_t logdev_list_length;
        size_t logdev_data_length;
        struct report_log_lun_extended *internal_logdev_list;
        struct report_log_lun_extended *logdev_data;
        struct report_lun_header report_lun_header;

        rc = pqi_report_phys_luns(ctrl_info, (void **)physdev_list);
        if (rc)
                dev_err(&ctrl_info->pci_dev->dev,
                        "report physical LUNs failed\n");

        rc = pqi_report_logical_luns(ctrl_info, (void **)logdev_list);
        if (rc)
                dev_err(&ctrl_info->pci_dev->dev,
                        "report logical LUNs failed\n");

        /*
         * Tack the controller itself onto the end of the logical device list.
         */

        logdev_data = *logdev_list;

        if (logdev_data) {
                logdev_list_length =
                        get_unaligned_be32(&logdev_data->header.list_length);
        } else {
                memset(&report_lun_header, 0, sizeof(report_lun_header));
                logdev_data =
                        (struct report_log_lun_extended *)&report_lun_header;
                logdev_list_length = 0;
        }

        logdev_data_length = sizeof(struct report_lun_header) +
                logdev_list_length;

        internal_logdev_list = kmalloc(logdev_data_length +
                sizeof(struct report_log_lun_extended), GFP_KERNEL);
        if (!internal_logdev_list) {
                kfree(*logdev_list);
                *logdev_list = NULL;
                return -ENOMEM;
        }

        memcpy(internal_logdev_list, logdev_data, logdev_data_length);
        memset((u8 *)internal_logdev_list + logdev_data_length, 0,
                sizeof(struct report_log_lun_extended_entry));
        put_unaligned_be32(logdev_list_length +
                sizeof(struct report_log_lun_extended_entry),
                &internal_logdev_list->header.list_length);

        kfree(*logdev_list);
        *logdev_list = internal_logdev_list;

        return 0;
}

static inline void pqi_set_bus_target_lun(struct pqi_scsi_dev *device,
        int bus, int target, int lun)
{
        device->bus = bus;
        device->target = target;
        device->lun = lun;
}

static void pqi_assign_bus_target_lun(struct pqi_scsi_dev *device)
{
        u8 *scsi3addr;
        u32 lunid;
        int bus;
        int target;
        int lun;

        scsi3addr = device->scsi3addr;
        lunid = get_unaligned_le32(scsi3addr);

        if (pqi_is_hba_lunid(scsi3addr)) {
                /* The specified device is the controller. */
                pqi_set_bus_target_lun(device, PQI_HBA_BUS, 0, lunid & 0x3fff);
                device->target_lun_valid = true;
                return;
        }

        if (pqi_is_logical_device(device)) {
                if (device->is_external_raid_device) {
                        bus = PQI_EXTERNAL_RAID_VOLUME_BUS;
                        target = (lunid >> 16) & 0x3fff;
                        lun = lunid & 0xff;
                } else {
                        bus = PQI_RAID_VOLUME_BUS;
                        target = 0;
                        lun = lunid & 0x3fff;
                }
                pqi_set_bus_target_lun(device, bus, target, lun);
                device->target_lun_valid = true;
                return;
        }

        /*
         * Defer target and LUN assignment for non-controller physical devices
         * because the SAS transport layer will make these assignments later.
         */
        pqi_set_bus_target_lun(device, PQI_PHYSICAL_DEVICE_BUS, 0, 0);
}

static void pqi_get_raid_level(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        int rc;
        u8 raid_level;
        u8 *buffer;

        raid_level = SA_RAID_UNKNOWN;

        buffer = kmalloc(64, GFP_KERNEL);
        if (buffer) {
                rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr,
                        VPD_PAGE | CISS_VPD_LV_DEVICE_GEOMETRY, buffer, 64);
                if (rc == 0) {
                        raid_level = buffer[8];
                        if (raid_level > SA_RAID_MAX)
                                raid_level = SA_RAID_UNKNOWN;
                }
                kfree(buffer);
        }

        device->raid_level = raid_level;
}

static int pqi_validate_raid_map(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device, struct raid_map *raid_map)
{
        char *err_msg;
        u32 raid_map_size;
        u32 r5or6_blocks_per_row;

        raid_map_size = get_unaligned_le32(&raid_map->structure_size);

        if (raid_map_size < offsetof(struct raid_map, disk_data)) {
                err_msg = "RAID map too small";
                goto bad_raid_map;
        }

        if (device->raid_level == SA_RAID_1) {
                if (get_unaligned_le16(&raid_map->layout_map_count) != 2) {
                        err_msg = "invalid RAID-1 map";
                        goto bad_raid_map;
                }
        } else if (device->raid_level == SA_RAID_TRIPLE) {
                if (get_unaligned_le16(&raid_map->layout_map_count) != 3) {
                        err_msg = "invalid RAID-1(Triple) map";
                        goto bad_raid_map;
                }
        } else if ((device->raid_level == SA_RAID_5 ||
                device->raid_level == SA_RAID_6) &&
                get_unaligned_le16(&raid_map->layout_map_count) > 1) {
                /* RAID 50/60 */
                r5or6_blocks_per_row =
                        get_unaligned_le16(&raid_map->strip_size) *
                        get_unaligned_le16(&raid_map->data_disks_per_row);
                if (r5or6_blocks_per_row == 0) {
                        err_msg = "invalid RAID-5 or RAID-6 map";
                        goto bad_raid_map;
                }
        }

        return 0;

bad_raid_map:
        dev_warn(&ctrl_info->pci_dev->dev,
                "logical device %08x%08x %s\n",
                *((u32 *)&device->scsi3addr),
                *((u32 *)&device->scsi3addr[4]), err_msg);

        return -EINVAL;
}

static int pqi_get_raid_map(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        int rc;
        u32 raid_map_size;
        struct raid_map *raid_map;

        raid_map = kmalloc(sizeof(*raid_map), GFP_KERNEL);
        if (!raid_map)
                return -ENOMEM;

        rc = pqi_send_scsi_raid_request(ctrl_info, CISS_GET_RAID_MAP,
                device->scsi3addr, raid_map, sizeof(*raid_map), 0, NULL);
        if (rc)
                goto error;

        raid_map_size = get_unaligned_le32(&raid_map->structure_size);

        if (raid_map_size > sizeof(*raid_map)) {

                kfree(raid_map);

                raid_map = kmalloc(raid_map_size, GFP_KERNEL);
                if (!raid_map)
                        return -ENOMEM;

                rc = pqi_send_scsi_raid_request(ctrl_info, CISS_GET_RAID_MAP,
                        device->scsi3addr, raid_map, raid_map_size, 0, NULL);
                if (rc)
                        goto error;

                if (get_unaligned_le32(&raid_map->structure_size)
                        != raid_map_size) {
                        dev_warn(&ctrl_info->pci_dev->dev,
                                "requested %u bytes, received %u bytes\n",
                                raid_map_size,
                                get_unaligned_le32(&raid_map->structure_size));
                        rc = -EINVAL;
                        goto error;
                }
        }

        rc = pqi_validate_raid_map(ctrl_info, device, raid_map);
        if (rc)
                goto error;

        device->raid_map = raid_map;

        return 0;

error:
        kfree(raid_map);

        return rc;
}

static void pqi_set_max_transfer_encrypted(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        if (!ctrl_info->lv_drive_type_mix_valid) {
                device->max_transfer_encrypted = ~0;
                return;
        }

        switch (LV_GET_DRIVE_TYPE_MIX(device->scsi3addr)) {
        case LV_DRIVE_TYPE_MIX_SAS_HDD_ONLY:
        case LV_DRIVE_TYPE_MIX_SATA_HDD_ONLY:
        case LV_DRIVE_TYPE_MIX_SAS_OR_SATA_SSD_ONLY:
        case LV_DRIVE_TYPE_MIX_SAS_SSD_ONLY:
        case LV_DRIVE_TYPE_MIX_SATA_SSD_ONLY:
        case LV_DRIVE_TYPE_MIX_SAS_ONLY:
        case LV_DRIVE_TYPE_MIX_SATA_ONLY:
                device->max_transfer_encrypted =
                        ctrl_info->max_transfer_encrypted_sas_sata;
                break;
        case LV_DRIVE_TYPE_MIX_NVME_ONLY:
                device->max_transfer_encrypted =
                        ctrl_info->max_transfer_encrypted_nvme;
                break;
        case LV_DRIVE_TYPE_MIX_UNKNOWN:
        case LV_DRIVE_TYPE_MIX_NO_RESTRICTION:
        default:
                device->max_transfer_encrypted =
                        min(ctrl_info->max_transfer_encrypted_sas_sata,
                                ctrl_info->max_transfer_encrypted_nvme);
                break;
        }
}

static void pqi_get_raid_bypass_status(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        int rc;
        u8 *buffer;
        u8 bypass_status;

        buffer = kmalloc(64, GFP_KERNEL);
        if (!buffer)
                return;

        rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr,
                VPD_PAGE | CISS_VPD_LV_BYPASS_STATUS, buffer, 64);
        if (rc)
                goto out;

#define RAID_BYPASS_STATUS              4
#define RAID_BYPASS_CONFIGURED          0x1
#define RAID_BYPASS_ENABLED             0x2

        bypass_status = buffer[RAID_BYPASS_STATUS];
        device->raid_bypass_configured =
                (bypass_status & RAID_BYPASS_CONFIGURED) != 0;
        if (device->raid_bypass_configured &&
                (bypass_status & RAID_BYPASS_ENABLED) &&
                pqi_get_raid_map(ctrl_info, device) == 0) {
                device->raid_bypass_enabled = true;
                if (get_unaligned_le16(&device->raid_map->flags) &
                        RAID_MAP_ENCRYPTION_ENABLED)
                        pqi_set_max_transfer_encrypted(ctrl_info, device);
        }

out:
        kfree(buffer);
}

/*
 * Use vendor-specific VPD to determine online/offline status of a volume.
 */

static void pqi_get_volume_status(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        int rc;
        size_t page_length;
        u8 volume_status = CISS_LV_STATUS_UNAVAILABLE;
        bool volume_offline = true;
        u32 volume_flags;
        struct ciss_vpd_logical_volume_status *vpd;

        vpd = kmalloc(sizeof(*vpd), GFP_KERNEL);
        if (!vpd)
                goto no_buffer;

        rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr,
                VPD_PAGE | CISS_VPD_LV_STATUS, vpd, sizeof(*vpd));
        if (rc)
                goto out;

        if (vpd->page_code != CISS_VPD_LV_STATUS)
                goto out;

        page_length = offsetof(struct ciss_vpd_logical_volume_status,
                volume_status) + vpd->page_length;
        if (page_length < sizeof(*vpd))
                goto out;

        volume_status = vpd->volume_status;
        volume_flags = get_unaligned_be32(&vpd->flags);
        volume_offline = (volume_flags & CISS_LV_FLAGS_NO_HOST_IO) != 0;

out:
        kfree(vpd);
no_buffer:
        device->volume_status = volume_status;
        device->volume_offline = volume_offline;
}

#define PQI_DEVICE_PHY_MAP_SUPPORTED    0x10

static int pqi_get_physical_device_info(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device,
        struct bmic_identify_physical_device *id_phys)
{
        int rc;

        memset(id_phys, 0, sizeof(*id_phys));

        rc = pqi_identify_physical_device(ctrl_info, device,
                id_phys, sizeof(*id_phys));
        if (rc) {
                device->queue_depth = PQI_PHYSICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH;
                return rc;
        }

        scsi_sanitize_inquiry_string(&id_phys->model[0], 8);
        scsi_sanitize_inquiry_string(&id_phys->model[8], 16);

        memcpy(device->vendor, &id_phys->model[0], sizeof(device->vendor));
        memcpy(device->model, &id_phys->model[8], sizeof(device->model));

        device->box_index = id_phys->box_index;
        device->phys_box_on_bus = id_phys->phys_box_on_bus;
        device->phy_connected_dev_type = id_phys->phy_connected_dev_type[0];
        device->queue_depth =
                get_unaligned_le16(&id_phys->current_queue_depth_limit);
        device->active_path_index = id_phys->active_path_number;
        device->path_map = id_phys->redundant_path_present_map;
        memcpy(&device->box,
                &id_phys->alternate_paths_phys_box_on_port,
                sizeof(device->box));
        memcpy(&device->phys_connector,
                &id_phys->alternate_paths_phys_connector,
                sizeof(device->phys_connector));
        device->bay = id_phys->phys_bay_in_box;

        memcpy(&device->page_83_identifier, &id_phys->page_83_identifier,
                sizeof(device->page_83_identifier));

        if ((id_phys->even_more_flags & PQI_DEVICE_PHY_MAP_SUPPORTED) &&
                id_phys->phy_count)
                device->phy_id =
                        id_phys->phy_to_phy_map[device->active_path_index];
        else
                device->phy_id = 0xFF;

        return 0;
}

static int pqi_get_logical_device_info(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        int rc;
        u8 *buffer;

        buffer = kmalloc(64, GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;

        /* Send an inquiry to the device to see what it is. */
        rc = pqi_scsi_inquiry(ctrl_info, device->scsi3addr, 0, buffer, 64);
        if (rc)
                goto out;

        scsi_sanitize_inquiry_string(&buffer[8], 8);
        scsi_sanitize_inquiry_string(&buffer[16], 16);

        device->devtype = buffer[0] & 0x1f;
        memcpy(device->vendor, &buffer[8], sizeof(device->vendor));
        memcpy(device->model, &buffer[16], sizeof(device->model));

        if (device->devtype == TYPE_DISK) {
                if (device->is_external_raid_device) {
                        device->raid_level = SA_RAID_UNKNOWN;
                        device->volume_status = CISS_LV_OK;
                        device->volume_offline = false;
                } else {
                        pqi_get_raid_level(ctrl_info, device);
                        pqi_get_raid_bypass_status(ctrl_info, device);
                        pqi_get_volume_status(ctrl_info, device);
                }
        }

out:
        kfree(buffer);

        return rc;
}

static int pqi_get_device_info(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device,
        struct bmic_identify_physical_device *id_phys)
{
        int rc;

        if (device->is_expander_smp_device)
                return 0;

        if (pqi_is_logical_device(device))
                rc = pqi_get_logical_device_info(ctrl_info, device);
        else
                rc = pqi_get_physical_device_info(ctrl_info, device, id_phys);

        return rc;
}

static void pqi_show_volume_status(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        char *status;
        static const char unknown_state_str[] =
                "Volume is in an unknown state (%u)";
        char unknown_state_buffer[sizeof(unknown_state_str) + 10];

        switch (device->volume_status) {
        case CISS_LV_OK:
                status = "Volume online";
                break;
        case CISS_LV_FAILED:
                status = "Volume failed";
                break;
        case CISS_LV_NOT_CONFIGURED:
                status = "Volume not configured";
                break;
        case CISS_LV_DEGRADED:
                status = "Volume degraded";
                break;
        case CISS_LV_READY_FOR_RECOVERY:
                status = "Volume ready for recovery operation";
                break;
        case CISS_LV_UNDERGOING_RECOVERY:
                status = "Volume undergoing recovery";
                break;
        case CISS_LV_WRONG_PHYSICAL_DRIVE_REPLACED:
                status = "Wrong physical drive was replaced";
                break;
        case CISS_LV_PHYSICAL_DRIVE_CONNECTION_PROBLEM:
                status = "A physical drive not properly connected";
                break;
        case CISS_LV_HARDWARE_OVERHEATING:
                status = "Hardware is overheating";
                break;
        case CISS_LV_HARDWARE_HAS_OVERHEATED:
                status = "Hardware has overheated";
                break;
        case CISS_LV_UNDERGOING_EXPANSION:
                status = "Volume undergoing expansion";
                break;
        case CISS_LV_NOT_AVAILABLE:
                status = "Volume waiting for transforming volume";
                break;
        case CISS_LV_QUEUED_FOR_EXPANSION:
                status = "Volume queued for expansion";
                break;
        case CISS_LV_DISABLED_SCSI_ID_CONFLICT:
                status = "Volume disabled due to SCSI ID conflict";
                break;
        case CISS_LV_EJECTED:
                status = "Volume has been ejected";
                break;
        case CISS_LV_UNDERGOING_ERASE:
                status = "Volume undergoing background erase";
                break;
        case CISS_LV_READY_FOR_PREDICTIVE_SPARE_REBUILD:
                status = "Volume ready for predictive spare rebuild";
                break;
        case CISS_LV_UNDERGOING_RPI:
                status = "Volume undergoing rapid parity initialization";
                break;
        case CISS_LV_PENDING_RPI:
                status = "Volume queued for rapid parity initialization";
                break;
        case CISS_LV_ENCRYPTED_NO_KEY:
                status = "Encrypted volume inaccessible - key not present";
                break;
        case CISS_LV_UNDERGOING_ENCRYPTION:
                status = "Volume undergoing encryption process";
                break;
        case CISS_LV_UNDERGOING_ENCRYPTION_REKEYING:
                status = "Volume undergoing encryption re-keying process";
                break;
        case CISS_LV_ENCRYPTED_IN_NON_ENCRYPTED_CONTROLLER:
                status = "Volume encrypted but encryption is disabled";
                break;
        case CISS_LV_PENDING_ENCRYPTION:
                status = "Volume pending migration to encrypted state";
                break;
        case CISS_LV_PENDING_ENCRYPTION_REKEYING:
                status = "Volume pending encryption rekeying";
                break;
        case CISS_LV_NOT_SUPPORTED:
                status = "Volume not supported on this controller";
                break;
        case CISS_LV_STATUS_UNAVAILABLE:
                status = "Volume status not available";
                break;
        default:
                snprintf(unknown_state_buffer, sizeof(unknown_state_buffer),
                        unknown_state_str, device->volume_status);
                status = unknown_state_buffer;
                break;
        }

        dev_info(&ctrl_info->pci_dev->dev,
                "scsi %d:%d:%d:%d %s\n",
                ctrl_info->scsi_host->host_no,
                device->bus, device->target, device->lun, status);
}

static void pqi_rescan_worker(struct work_struct *work)
{
        struct pqi_ctrl_info *ctrl_info;

        ctrl_info = container_of(to_delayed_work(work), struct pqi_ctrl_info,
                rescan_work);

        pqi_scan_scsi_devices(ctrl_info);
}

static int pqi_add_device(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        int rc;

        if (pqi_is_logical_device(device))
                rc = scsi_add_device(ctrl_info->scsi_host, device->bus,
                        device->target, device->lun);
        else
                rc = pqi_add_sas_device(ctrl_info->sas_host, device);

        return rc;
}

#define PQI_REMOVE_DEVICE_PENDING_IO_TIMEOUT_MSECS      (20 * 1000)

static inline void pqi_remove_device(struct pqi_ctrl_info *ctrl_info, struct pqi_scsi_dev *device)
{
        int rc;

        pqi_device_remove_start(device);

        rc = pqi_device_wait_for_pending_io(ctrl_info, device,
                PQI_REMOVE_DEVICE_PENDING_IO_TIMEOUT_MSECS);
        if (rc)
                dev_err(&ctrl_info->pci_dev->dev,
                        "scsi %d:%d:%d:%d removing device with %d outstanding command(s)\n",
                        ctrl_info->scsi_host->host_no, device->bus,
                        device->target, device->lun,
                        atomic_read(&device->scsi_cmds_outstanding));

        if (pqi_is_logical_device(device))
                scsi_remove_device(device->sdev);
        else
                pqi_remove_sas_device(device);
}

/* Assumes the SCSI device list lock is held. */

static struct pqi_scsi_dev *pqi_find_scsi_dev(struct pqi_ctrl_info *ctrl_info,
        int bus, int target, int lun)
{
        struct pqi_scsi_dev *device;

        list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry)
                if (device->bus == bus && device->target == target && device->lun == lun)
                        return device;

        return NULL;
}

static inline bool pqi_device_equal(struct pqi_scsi_dev *dev1, struct pqi_scsi_dev *dev2)
{
        if (dev1->is_physical_device != dev2->is_physical_device)
                return false;

        if (dev1->is_physical_device)
                return dev1->wwid == dev2->wwid;

        return memcmp(dev1->volume_id, dev2->volume_id, sizeof(dev1->volume_id)) == 0;
}

enum pqi_find_result {
        DEVICE_NOT_FOUND,
        DEVICE_CHANGED,
        DEVICE_SAME,
};

static enum pqi_find_result pqi_scsi_find_entry(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device_to_find, struct pqi_scsi_dev **matching_device)
{
        struct pqi_scsi_dev *device;

        list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry) {
                if (pqi_scsi3addr_equal(device_to_find->scsi3addr, device->scsi3addr)) {
                        *matching_device = device;
                        if (pqi_device_equal(device_to_find, device)) {
                                if (device_to_find->volume_offline)
                                        return DEVICE_CHANGED;
                                return DEVICE_SAME;
                        }
                        return DEVICE_CHANGED;
                }
        }

        return DEVICE_NOT_FOUND;
}

static inline const char *pqi_device_type(struct pqi_scsi_dev *device)
{
        if (device->is_expander_smp_device)
                return "Enclosure SMP    ";

        return scsi_device_type(device->devtype);
}

#define PQI_DEV_INFO_BUFFER_LENGTH      128

static void pqi_dev_info(struct pqi_ctrl_info *ctrl_info,
        char *action, struct pqi_scsi_dev *device)
{
        ssize_t count;
        char buffer[PQI_DEV_INFO_BUFFER_LENGTH];

        count = scnprintf(buffer, PQI_DEV_INFO_BUFFER_LENGTH,
                "%d:%d:", ctrl_info->scsi_host->host_no, device->bus);

        if (device->target_lun_valid)
                count += scnprintf(buffer + count,
                        PQI_DEV_INFO_BUFFER_LENGTH - count,
                        "%d:%d",
                        device->target,
                        device->lun);
        else
                count += scnprintf(buffer + count,
                        PQI_DEV_INFO_BUFFER_LENGTH - count,
                        "-:-");

        if (pqi_is_logical_device(device))
                count += scnprintf(buffer + count,
                        PQI_DEV_INFO_BUFFER_LENGTH - count,
                        " %08x%08x",
                        *((u32 *)&device->scsi3addr),
                        *((u32 *)&device->scsi3addr[4]));
        else
                count += scnprintf(buffer + count,
                        PQI_DEV_INFO_BUFFER_LENGTH - count,
                        " %016llx", device->sas_address);

        count += scnprintf(buffer + count, PQI_DEV_INFO_BUFFER_LENGTH - count,
                " %s %.8s %.16s ",
                pqi_device_type(device),
                device->vendor,
                device->model);

        if (pqi_is_logical_device(device)) {
                if (device->devtype == TYPE_DISK)
                        count += scnprintf(buffer + count,
                                PQI_DEV_INFO_BUFFER_LENGTH - count,
                                "SSDSmartPathCap%c En%c %-12s",
                                device->raid_bypass_configured ? '+' : '-',
                                device->raid_bypass_enabled ? '+' : '-',
                                pqi_raid_level_to_string(device->raid_level));
        } else {
                count += scnprintf(buffer + count,
                        PQI_DEV_INFO_BUFFER_LENGTH - count,
                        "AIO%c", device->aio_enabled ? '+' : '-');
                if (device->devtype == TYPE_DISK ||
                        device->devtype == TYPE_ZBC)
                        count += scnprintf(buffer + count,
                                PQI_DEV_INFO_BUFFER_LENGTH - count,
                                " qd=%-6d", device->queue_depth);
        }

        dev_info(&ctrl_info->pci_dev->dev, "%s %s\n", action, buffer);
}

/* Assumes the SCSI device list lock is held. */

static void pqi_scsi_update_device(struct pqi_scsi_dev *existing_device,
        struct pqi_scsi_dev *new_device)
{
        existing_device->device_type = new_device->device_type;
        existing_device->bus = new_device->bus;
        if (new_device->target_lun_valid) {
                existing_device->target = new_device->target;
                existing_device->lun = new_device->lun;
                existing_device->target_lun_valid = true;
        }

        if ((existing_device->volume_status == CISS_LV_QUEUED_FOR_EXPANSION ||
                existing_device->volume_status == CISS_LV_UNDERGOING_EXPANSION) &&
                new_device->volume_status == CISS_LV_OK)
                existing_device->rescan = true;

        /* By definition, the scsi3addr and wwid fields are already the same. */

        existing_device->is_physical_device = new_device->is_physical_device;
        existing_device->is_external_raid_device =
                new_device->is_external_raid_device;
        existing_device->is_expander_smp_device =
                new_device->is_expander_smp_device;
        existing_device->aio_enabled = new_device->aio_enabled;
        memcpy(existing_device->vendor, new_device->vendor,
                sizeof(existing_device->vendor));
        memcpy(existing_device->model, new_device->model,
                sizeof(existing_device->model));
        existing_device->sas_address = new_device->sas_address;
        existing_device->raid_level = new_device->raid_level;
        existing_device->queue_depth = new_device->queue_depth;
        existing_device->aio_handle = new_device->aio_handle;
        existing_device->volume_status = new_device->volume_status;
        existing_device->active_path_index = new_device->active_path_index;
        existing_device->phy_id = new_device->phy_id;
        existing_device->path_map = new_device->path_map;
        existing_device->bay = new_device->bay;
        existing_device->box_index = new_device->box_index;
        existing_device->phys_box_on_bus = new_device->phys_box_on_bus;
        existing_device->phy_connected_dev_type = new_device->phy_connected_dev_type;
        memcpy(existing_device->box, new_device->box,
                sizeof(existing_device->box));
        memcpy(existing_device->phys_connector, new_device->phys_connector,
                sizeof(existing_device->phys_connector));
        existing_device->next_bypass_group = 0;
        kfree(existing_device->raid_map);
        existing_device->raid_map = new_device->raid_map;
        existing_device->raid_bypass_configured =
                new_device->raid_bypass_configured;
        existing_device->raid_bypass_enabled =
                new_device->raid_bypass_enabled;
        existing_device->device_offline = false;

        /* To prevent this from being freed later. */
        new_device->raid_map = NULL;
}

static inline void pqi_free_device(struct pqi_scsi_dev *device)
{
        if (device) {
                kfree(device->raid_map);
                kfree(device);
        }
}

/*
 * Called when exposing a new device to the OS fails in order to re-adjust
 * our internal SCSI device list to match the SCSI ML's view.
 */

static inline void pqi_fixup_botched_add(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device)
{
        unsigned long flags;

        spin_lock_irqsave(&ctrl_info->scsi_device_list_lock, flags);
        list_del(&device->scsi_device_list_entry);
        spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags);

        /* Allow the device structure to be freed later. */
        device->keep_device = false;
}

static inline bool pqi_is_device_added(struct pqi_scsi_dev *device)
{
        if (device->is_expander_smp_device)
                return device->sas_port != NULL;

        return device->sdev != NULL;
}

static void pqi_update_device_list(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *new_device_list[], unsigned int num_new_devices)
{
        int rc;
        unsigned int i;
        unsigned long flags;
        enum pqi_find_result find_result;
        struct pqi_scsi_dev *device;
        struct pqi_scsi_dev *next;
        struct pqi_scsi_dev *matching_device;
        LIST_HEAD(add_list);
        LIST_HEAD(delete_list);

        /*
         * The idea here is to do as little work as possible while holding the
         * spinlock.  That's why we go to great pains to defer anything other
         * than updating the internal device list until after we release the
         * spinlock.
         */

        spin_lock_irqsave(&ctrl_info->scsi_device_list_lock, flags);

        /* Assume that all devices in the existing list have gone away. */
        list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry)
                device->device_gone = true;

        for (i = 0; i < num_new_devices; i++) {
                device = new_device_list[i];

                find_result = pqi_scsi_find_entry(ctrl_info, device,
                        &matching_device);

                switch (find_result) {
                case DEVICE_SAME:
                        /*
                         * The newly found device is already in the existing
                         * device list.
                         */
                        device->new_device = false;
                        matching_device->device_gone = false;
                        pqi_scsi_update_device(matching_device, device);
                        break;
                case DEVICE_NOT_FOUND:
                        /*
                         * The newly found device is NOT in the existing device
                         * list.
                         */
                        device->new_device = true;
                        break;
                case DEVICE_CHANGED:
                        /*
                         * The original device has gone away and we need to add
                         * the new device.
                         */
                        device->new_device = true;
                        break;
                }
        }

        /* Process all devices that have gone away. */
        list_for_each_entry_safe(device, next, &ctrl_info->scsi_device_list,
                scsi_device_list_entry) {
                if (device->device_gone) {
                        list_del_init(&device->scsi_device_list_entry);
                        list_add_tail(&device->delete_list_entry, &delete_list);
                }
        }

        /* Process all new devices. */
        for (i = 0; i < num_new_devices; i++) {
                device = new_device_list[i];
                if (!device->new_device)
                        continue;
                if (device->volume_offline)
                        continue;

                list_add_tail(&device->scsi_device_list_entry,
                        &ctrl_info->scsi_device_list);
                list_add_tail(&device->add_list_entry, &add_list);
                /* To prevent this device structure from being freed later. */
                device->keep_device = true;
        }

        spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags);

        /*
         * If OFA is in progress and there are devices that need to be deleted,
         * allow any pending reset operations to continue and unblock any SCSI
         * requests before removal.
         */
        if (pqi_ofa_in_progress(ctrl_info)) {
                list_for_each_entry_safe(device, next, &delete_list, delete_list_entry)
                        if (pqi_is_device_added(device))
                                pqi_device_remove_start(device);
                pqi_ctrl_unblock_device_reset(ctrl_info);
                pqi_scsi_unblock_requests(ctrl_info);
        }

        /* Remove all devices that have gone away. */
        list_for_each_entry_safe(device, next, &delete_list, delete_list_entry) {
                if (device->volume_offline) {
                        pqi_dev_info(ctrl_info, "offline", device);
                        pqi_show_volume_status(ctrl_info, device);
                }
                list_del(&device->delete_list_entry);
                if (pqi_is_device_added(device)) {
                        pqi_remove_device(ctrl_info, device);
                } else {
                        if (!device->volume_offline)
                                pqi_dev_info(ctrl_info, "removed", device);
                        pqi_free_device(device);
                }
        }

        /*
         * Notify the SCSI ML if the queue depth of any existing device has
         * changed.
         */
        list_for_each_entry(device, &ctrl_info->scsi_device_list, scsi_device_list_entry) {
                if (device->sdev && device->queue_depth != device->advertised_queue_depth) {
                        device->advertised_queue_depth = device->queue_depth;
                        scsi_change_queue_depth(device->sdev, device->advertised_queue_depth);
                        if (device->rescan) {
                                scsi_rescan_device(&device->sdev->sdev_gendev);
                                device->rescan = false;
                        }
                }
        }

        /* Expose any new devices. */
        list_for_each_entry_safe(device, next, &add_list, add_list_entry) {
                if (!pqi_is_device_added(device)) {
                        rc = pqi_add_device(ctrl_info, device);
                        if (rc == 0) {
                                pqi_dev_info(ctrl_info, "added", device);
                        } else {
                                dev_warn(&ctrl_info->pci_dev->dev,
                                        "scsi %d:%d:%d:%d addition failed, device not added\n",
                                        ctrl_info->scsi_host->host_no,
                                        device->bus, device->target,
                                        device->lun);
                                pqi_fixup_botched_add(ctrl_info, device);
                        }
                }
        }
}

static inline bool pqi_is_supported_device(struct pqi_scsi_dev *device)
{
        /*
         * Only support the HBA controller itself as a RAID
         * controller.  If it's a RAID controller other than
         * the HBA itself (an external RAID controller, for
         * example), we don't support it.
         */
        if (device->device_type == SA_DEVICE_TYPE_CONTROLLER &&
                !pqi_is_hba_lunid(device->scsi3addr))
                        return false;

        return true;
}

static inline bool pqi_skip_device(u8 *scsi3addr)
{
        /* Ignore all masked devices. */
        if (MASKED_DEVICE(scsi3addr))
                return true;

        return false;
}

static inline void pqi_mask_device(u8 *scsi3addr)
{
        scsi3addr[3] |= 0xc0;
}

static inline bool pqi_is_device_with_sas_address(struct pqi_scsi_dev *device)
{
        switch (device->device_type) {
        case SA_DEVICE_TYPE_SAS:
        case SA_DEVICE_TYPE_EXPANDER_SMP:
        case SA_DEVICE_TYPE_SES:
                return true;
        }

        return false;
}

static inline bool pqi_expose_device(struct pqi_scsi_dev *device)
{
        return !device->is_physical_device || !pqi_skip_device(device->scsi3addr);
}

static inline void pqi_set_physical_device_wwid(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device, struct report_phys_lun_extended_entry *phys_lun_ext_entry)
{
        if (ctrl_info->unique_wwid_in_report_phys_lun_supported ||
                pqi_is_device_with_sas_address(device))
                device->wwid = phys_lun_ext_entry->wwid;
        else
                device->wwid = cpu_to_be64(get_unaligned_be64(&device->page_83_identifier));
}

static int pqi_update_scsi_devices(struct pqi_ctrl_info *ctrl_info)
{
        int i;
        int rc;
        LIST_HEAD(new_device_list_head);
        struct report_phys_lun_extended *physdev_list = NULL;
        struct report_log_lun_extended *logdev_list = NULL;
        struct report_phys_lun_extended_entry *phys_lun_ext_entry;
        struct report_log_lun_extended_entry *log_lun_ext_entry;
        struct bmic_identify_physical_device *id_phys = NULL;
        u32 num_physicals;
        u32 num_logicals;
        struct pqi_scsi_dev **new_device_list = NULL;
        struct pqi_scsi_dev *device;
        struct pqi_scsi_dev *next;
        unsigned int num_new_devices;
        unsigned int num_valid_devices;
        bool is_physical_device;
        u8 *scsi3addr;
        unsigned int physical_index;
        unsigned int logical_index;
        static char *out_of_memory_msg =
                "failed to allocate memory, device discovery stopped";

        rc = pqi_get_device_lists(ctrl_info, &physdev_list, &logdev_list);
        if (rc)
                goto out;

        if (physdev_list)
                num_physicals =
                        get_unaligned_be32(&physdev_list->header.list_length)
                                / sizeof(physdev_list->lun_entries[0]);
        else
                num_physicals = 0;

        if (logdev_list)
                num_logicals =
                        get_unaligned_be32(&logdev_list->header.list_length)
                                / sizeof(logdev_list->lun_entries[0]);
        else
                num_logicals = 0;

        if (num_physicals) {
                /*
                 * We need this buffer for calls to pqi_get_physical_disk_info()
                 * below.  We allocate it here instead of inside
                 * pqi_get_physical_disk_info() because it's a fairly large
                 * buffer.
                 */
                id_phys = kmalloc(sizeof(*id_phys), GFP_KERNEL);
                if (!id_phys) {
                        dev_warn(&ctrl_info->pci_dev->dev, "%s\n",
                                out_of_memory_msg);
                        rc = -ENOMEM;
                        goto out;
                }

                if (pqi_hide_vsep) {
                        for (i = num_physicals - 1; i >= 0; i--) {
                                phys_lun_ext_entry =
                                                &physdev_list->lun_entries[i];
                                if (CISS_GET_DRIVE_NUMBER(phys_lun_ext_entry->lunid) == PQI_VSEP_CISS_BTL) {
                                        pqi_mask_device(phys_lun_ext_entry->lunid);
                                        break;
                                }
                        }
                }
        }

        if (num_logicals &&
                (logdev_list->header.flags & CISS_REPORT_LOG_FLAG_DRIVE_TYPE_MIX))
                ctrl_info->lv_drive_type_mix_valid = true;

        num_new_devices = num_physicals + num_logicals;

        new_device_list = kmalloc_array(num_new_devices,
                                        sizeof(*new_device_list),
                                        GFP_KERNEL);
        if (!new_device_list) {
                dev_warn(&ctrl_info->pci_dev->dev, "%s\n", out_of_memory_msg);
                rc = -ENOMEM;
                goto out;
        }

        for (i = 0; i < num_new_devices; i++) {
                device = kzalloc(sizeof(*device), GFP_KERNEL);
                if (!device) {
                        dev_warn(&ctrl_info->pci_dev->dev, "%s\n",
                                out_of_memory_msg);
                        rc = -ENOMEM;
                        goto out;
                }
                list_add_tail(&device->new_device_list_entry,
                        &new_device_list_head);
        }

        device = NULL;
        num_valid_devices = 0;
        physical_index = 0;
        logical_index = 0;

        for (i = 0; i < num_new_devices; i++) {

                if ((!pqi_expose_ld_first && i < num_physicals) ||
                        (pqi_expose_ld_first && i >= num_logicals)) {
                        is_physical_device = true;
                        phys_lun_ext_entry =
                                &physdev_list->lun_entries[physical_index++];
                        log_lun_ext_entry = NULL;
                        scsi3addr = phys_lun_ext_entry->lunid;
                } else {
                        is_physical_device = false;
                        phys_lun_ext_entry = NULL;
                        log_lun_ext_entry =
                                &logdev_list->lun_entries[logical_index++];
                        scsi3addr = log_lun_ext_entry->lunid;
                }

                if (is_physical_device && pqi_skip_device(scsi3addr))
                        continue;

                if (device)
                        device = list_next_entry(device, new_device_list_entry);
                else
                        device = list_first_entry(&new_device_list_head,
                                struct pqi_scsi_dev, new_device_list_entry);

                memcpy(device->scsi3addr, scsi3addr, sizeof(device->scsi3addr));
                device->is_physical_device = is_physical_device;
                if (is_physical_device) {
                        device->device_type = phys_lun_ext_entry->device_type;
                        if (device->device_type == SA_DEVICE_TYPE_EXPANDER_SMP)
                                device->is_expander_smp_device = true;
                } else {
                        device->is_external_raid_device =
                                pqi_is_external_raid_addr(scsi3addr);
                }

                if (!pqi_is_supported_device(device))
                        continue;

                /* Gather information about the device. */
                rc = pqi_get_device_info(ctrl_info, device, id_phys);
                if (rc == -ENOMEM) {
                        dev_warn(&ctrl_info->pci_dev->dev, "%s\n",
                                out_of_memory_msg);
                        goto out;
                }
                if (rc) {
                        if (device->is_physical_device)
                                dev_warn(&ctrl_info->pci_dev->dev,
                                        "obtaining device info failed, skipping physical device %016llx\n",
                                        get_unaligned_be64(&phys_lun_ext_entry->wwid));
                        else
                                dev_warn(&ctrl_info->pci_dev->dev,
                                        "obtaining device info failed, skipping logical device %08x%08x\n",
                                        *((u32 *)&device->scsi3addr),
                                        *((u32 *)&device->scsi3addr[4]));
                        rc = 0;
                        continue;
                }

                pqi_assign_bus_target_lun(device);

                if (device->is_physical_device) {
                        pqi_set_physical_device_wwid(ctrl_info, device, phys_lun_ext_entry);
                        if ((phys_lun_ext_entry->device_flags &
                                CISS_REPORT_PHYS_DEV_FLAG_AIO_ENABLED) &&
                                phys_lun_ext_entry->aio_handle) {
                                        device->aio_enabled = true;
                                        device->aio_handle =
                                                phys_lun_ext_entry->aio_handle;
                        }
                } else {
                        memcpy(device->volume_id, log_lun_ext_entry->volume_id,
                                sizeof(device->volume_id));
                }

                if (pqi_is_device_with_sas_address(device))
                        device->sas_address = get_unaligned_be64(&device->wwid);

                new_device_list[num_valid_devices++] = device;
        }

        pqi_update_device_list(ctrl_info, new_device_list, num_valid_devices);

out:
        list_for_each_entry_safe(device, next, &new_device_list_head,
                new_device_list_entry) {
                if (device->keep_device)
                        continue;
                list_del(&device->new_device_list_entry);
                pqi_free_device(device);
        }

        kfree(new_device_list);
        kfree(physdev_list);
        kfree(logdev_list);
        kfree(id_phys);

        return rc;
}

static int pqi_scan_scsi_devices(struct pqi_ctrl_info *ctrl_info)
{
        int rc;
        int mutex_acquired;

        if (pqi_ctrl_offline(ctrl_info))
                return -ENXIO;

        mutex_acquired = mutex_trylock(&ctrl_info->scan_mutex);

        if (!mutex_acquired) {
                if (pqi_ctrl_scan_blocked(ctrl_info))
                        return -EBUSY;
                pqi_schedule_rescan_worker_delayed(ctrl_info);
                return -EINPROGRESS;
        }

        rc = pqi_update_scsi_devices(ctrl_info);
        if (rc && !pqi_ctrl_scan_blocked(ctrl_info))
                pqi_schedule_rescan_worker_delayed(ctrl_info);

        mutex_unlock(&ctrl_info->scan_mutex);

        return rc;
}

static void pqi_scan_start(struct Scsi_Host *shost)
{
        struct pqi_ctrl_info *ctrl_info;

        ctrl_info = shost_to_hba(shost);

        pqi_scan_scsi_devices(ctrl_info);
}

/* Returns TRUE if scan is finished. */

static int pqi_scan_finished(struct Scsi_Host *shost,
        unsigned long elapsed_time)
{
        struct pqi_ctrl_info *ctrl_info;

        ctrl_info = shost_priv(shost);

        return !mutex_is_locked(&ctrl_info->scan_mutex);
}

static inline void pqi_set_encryption_info(struct pqi_encryption_info *encryption_info,
        struct raid_map *raid_map, u64 first_block)
{
        u32 volume_blk_size;

        /*
         * Set the encryption tweak values based on logical block address.
         * If the block size is 512, the tweak value is equal to the LBA.
         * For other block sizes, tweak value is (LBA * block size) / 512.
         */
        volume_blk_size = get_unaligned_le32(&raid_map->volume_blk_size);
        if (volume_blk_size != 512)
                first_block = (first_block * volume_blk_size) / 512;

        encryption_info->data_encryption_key_index =
                get_unaligned_le16(&raid_map->data_encryption_key_index);
        encryption_info->encrypt_tweak_lower = lower_32_bits(first_block);
        encryption_info->encrypt_tweak_upper = upper_32_bits(first_block);
}

/*
 * Attempt to perform RAID bypass mapping for a logical volume I/O.
 */

static bool pqi_aio_raid_level_supported(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev_raid_map_data *rmd)
{
        bool is_supported = true;

        switch (rmd->raid_level) {
        case SA_RAID_0:
                break;
        case SA_RAID_1:
                if (rmd->is_write && (!ctrl_info->enable_r1_writes ||
                        rmd->data_length > ctrl_info->max_write_raid_1_10_2drive))
                        is_supported = false;
                break;
        case SA_RAID_TRIPLE:
                if (rmd->is_write && (!ctrl_info->enable_r1_writes ||
                        rmd->data_length > ctrl_info->max_write_raid_1_10_3drive))
                        is_supported = false;
                break;
        case SA_RAID_5:
                if (rmd->is_write && (!ctrl_info->enable_r5_writes ||
                        rmd->data_length > ctrl_info->max_write_raid_5_6))
                        is_supported = false;
                break;
        case SA_RAID_6:
                if (rmd->is_write && (!ctrl_info->enable_r6_writes ||
                        rmd->data_length > ctrl_info->max_write_raid_5_6))
                        is_supported = false;
                break;
        default:
                is_supported = false;
                break;
        }

        return is_supported;
}

#define PQI_RAID_BYPASS_INELIGIBLE      1

static int pqi_get_aio_lba_and_block_count(struct scsi_cmnd *scmd,
        struct pqi_scsi_dev_raid_map_data *rmd)
{
        /* Check for valid opcode, get LBA and block count. */
        switch (scmd->cmnd[0]) {
        case WRITE_6:
                rmd->is_write = true;
                fallthrough;
        case READ_6:
                rmd->first_block = (u64)(((scmd->cmnd[1] & 0x1f) << 16) |
                        (scmd->cmnd[2] << 8) | scmd->cmnd[3]);
                rmd->block_cnt = (u32)scmd->cmnd[4];
                if (rmd->block_cnt == 0)
                        rmd->block_cnt = 256;
                break;
        case WRITE_10:
                rmd->is_write = true;
                fallthrough;
        case READ_10:
                rmd->first_block = (u64)get_unaligned_be32(&scmd->cmnd[2]);
                rmd->block_cnt = (u32)get_unaligned_be16(&scmd->cmnd[7]);
                break;
        case WRITE_12:
                rmd->is_write = true;
                fallthrough;
        case READ_12:
                rmd->first_block = (u64)get_unaligned_be32(&scmd->cmnd[2]);
                rmd->block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
                break;
        case WRITE_16:
                rmd->is_write = true;
                fallthrough;
        case READ_16:
                rmd->first_block = get_unaligned_be64(&scmd->cmnd[2]);
                rmd->block_cnt = get_unaligned_be32(&scmd->cmnd[10]);
                break;
        default:
                /* Process via normal I/O path. */
                return PQI_RAID_BYPASS_INELIGIBLE;
        }

        put_unaligned_le32(scsi_bufflen(scmd), &rmd->data_length);

        return 0;
}

static int pci_get_aio_common_raid_map_values(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev_raid_map_data *rmd, struct raid_map *raid_map)
{
#if BITS_PER_LONG == 32
        u64 tmpdiv;
#endif

        rmd->last_block = rmd->first_block + rmd->block_cnt - 1;

        /* Check for invalid block or wraparound. */
        if (rmd->last_block >=
                get_unaligned_le64(&raid_map->volume_blk_cnt) ||
                rmd->last_block < rmd->first_block)
                return PQI_RAID_BYPASS_INELIGIBLE;

        rmd->data_disks_per_row =
                get_unaligned_le16(&raid_map->data_disks_per_row);
        rmd->strip_size = get_unaligned_le16(&raid_map->strip_size);
        rmd->layout_map_count = get_unaligned_le16(&raid_map->layout_map_count);

        /* Calculate stripe information for the request. */
        rmd->blocks_per_row = rmd->data_disks_per_row * rmd->strip_size;
        if (rmd->blocks_per_row == 0) /* Used as a divisor in many calculations */
                return PQI_RAID_BYPASS_INELIGIBLE;
#if BITS_PER_LONG == 32
        tmpdiv = rmd->first_block;
        do_div(tmpdiv, rmd->blocks_per_row);
        rmd->first_row = tmpdiv;
        tmpdiv = rmd->last_block;
        do_div(tmpdiv, rmd->blocks_per_row);
        rmd->last_row = tmpdiv;
        rmd->first_row_offset = (u32)(rmd->first_block - (rmd->first_row * rmd->blocks_per_row));
        rmd->last_row_offset = (u32)(rmd->last_block - (rmd->last_row * rmd->blocks_per_row));
        tmpdiv = rmd->first_row_offset;
        do_div(tmpdiv, rmd->strip_size);
        rmd->first_column = tmpdiv;
        tmpdiv = rmd->last_row_offset;
        do_div(tmpdiv, rmd->strip_size);
        rmd->last_column = tmpdiv;
#else
        rmd->first_row = rmd->first_block / rmd->blocks_per_row;
        rmd->last_row = rmd->last_block / rmd->blocks_per_row;
        rmd->first_row_offset = (u32)(rmd->first_block -
                (rmd->first_row * rmd->blocks_per_row));
        rmd->last_row_offset = (u32)(rmd->last_block - (rmd->last_row *
                rmd->blocks_per_row));
        rmd->first_column = rmd->first_row_offset / rmd->strip_size;
        rmd->last_column = rmd->last_row_offset / rmd->strip_size;
#endif

        /* If this isn't a single row/column then give to the controller. */
        if (rmd->first_row != rmd->last_row ||
                rmd->first_column != rmd->last_column)
                return PQI_RAID_BYPASS_INELIGIBLE;

        /* Proceeding with driver mapping. */
        rmd->total_disks_per_row = rmd->data_disks_per_row +
                get_unaligned_le16(&raid_map->metadata_disks_per_row);
        rmd->map_row = ((u32)(rmd->first_row >>
                raid_map->parity_rotation_shift)) %
                get_unaligned_le16(&raid_map->row_cnt);
        rmd->map_index = (rmd->map_row * rmd->total_disks_per_row) +
                rmd->first_column;

        return 0;
}

static int pqi_calc_aio_r5_or_r6(struct pqi_scsi_dev_raid_map_data *rmd,
        struct raid_map *raid_map)
{
#if BITS_PER_LONG == 32
        u64 tmpdiv;
#endif

        if (rmd->blocks_per_row == 0) /* Used as a divisor in many calculations */
                return PQI_RAID_BYPASS_INELIGIBLE;

        /* RAID 50/60 */
        /* Verify first and last block are in same RAID group. */
        rmd->stripesize = rmd->blocks_per_row * rmd->layout_map_count;
#if BITS_PER_LONG == 32
        tmpdiv = rmd->first_block;
        rmd->first_group = do_div(tmpdiv, rmd->stripesize);
        tmpdiv = rmd->first_group;
        do_div(tmpdiv, rmd->blocks_per_row);
        rmd->first_group = tmpdiv;
        tmpdiv = rmd->last_block;
        rmd->last_group = do_div(tmpdiv, rmd->stripesize);
        tmpdiv = rmd->last_group;
        do_div(tmpdiv, rmd->blocks_per_row);
        rmd->last_group = tmpdiv;
#else
        rmd->first_group = (rmd->first_block % rmd->stripesize) / rmd->blocks_per_row;
        rmd->last_group = (rmd->last_block % rmd->stripesize) / rmd->blocks_per_row;
#endif
        if (rmd->first_group != rmd->last_group)
                return PQI_RAID_BYPASS_INELIGIBLE;

        /* Verify request is in a single row of RAID 5/6. */
#if BITS_PER_LONG == 32
        tmpdiv = rmd->first_block;
        do_div(tmpdiv, rmd->stripesize);
        rmd->first_row = tmpdiv;
        rmd->r5or6_first_row = tmpdiv;
        tmpdiv = rmd->last_block;
        do_div(tmpdiv, rmd->stripesize);
        rmd->r5or6_last_row = tmpdiv;
#else
        rmd->first_row = rmd->r5or6_first_row =
                rmd->first_block / rmd->stripesize;
        rmd->r5or6_last_row = rmd->last_block / rmd->stripesize;
#endif
        if (rmd->r5or6_first_row != rmd->r5or6_last_row)
                return PQI_RAID_BYPASS_INELIGIBLE;

        /* Verify request is in a single column. */
#if BITS_PER_LONG == 32
        tmpdiv = rmd->first_block;
        rmd->first_row_offset = do_div(tmpdiv, rmd->stripesize);
        tmpdiv = rmd->first_row_offset;
        rmd->first_row_offset = (u32)do_div(tmpdiv, rmd->blocks_per_row);
        rmd->r5or6_first_row_offset = rmd->first_row_offset;
        tmpdiv = rmd->last_block;
        rmd->r5or6_last_row_offset = do_div(tmpdiv, rmd->stripesize);
        tmpdiv = rmd->r5or6_last_row_offset;
        rmd->r5or6_last_row_offset = do_div(tmpdiv, rmd->blocks_per_row);
        tmpdiv = rmd->r5or6_first_row_offset;
        do_div(tmpdiv, rmd->strip_size);
        rmd->first_column = rmd->r5or6_first_column = tmpdiv;
        tmpdiv = rmd->r5or6_last_row_offset;
        do_div(tmpdiv, rmd->strip_size);
        rmd->r5or6_last_column = tmpdiv;
#else
        rmd->first_row_offset = rmd->r5or6_first_row_offset =
                (u32)((rmd->first_block % rmd->stripesize) %
                rmd->blocks_per_row);

        rmd->r5or6_last_row_offset =
                (u32)((rmd->last_block % rmd->stripesize) %
                rmd->blocks_per_row);

        rmd->first_column =
                rmd->r5or6_first_row_offset / rmd->strip_size;
        rmd->r5or6_first_column = rmd->first_column;
        rmd->r5or6_last_column = rmd->r5or6_last_row_offset / rmd->strip_size;
#endif
        if (rmd->r5or6_first_column != rmd->r5or6_last_column)
                return PQI_RAID_BYPASS_INELIGIBLE;

        /* Request is eligible. */
        rmd->map_row =
                ((u32)(rmd->first_row >> raid_map->parity_rotation_shift)) %
                get_unaligned_le16(&raid_map->row_cnt);

        rmd->map_index = (rmd->first_group *
                (get_unaligned_le16(&raid_map->row_cnt) *
                rmd->total_disks_per_row)) +
                (rmd->map_row * rmd->total_disks_per_row) + rmd->first_column;

        if (rmd->is_write) {
                u32 index;

                /*
                 * p_parity_it_nexus and q_parity_it_nexus are pointers to the
                 * parity entries inside the device's raid_map.
                 *
                 * A device's RAID map is bounded by: number of RAID disks squared.
                 *
                 * The devices RAID map size is checked during device
                 * initialization.
                 */
                index = DIV_ROUND_UP(rmd->map_index + 1, rmd->total_disks_per_row);
                index *= rmd->total_disks_per_row;
                index -= get_unaligned_le16(&raid_map->metadata_disks_per_row);

                rmd->p_parity_it_nexus = raid_map->disk_data[index].aio_handle;
                if (rmd->raid_level == SA_RAID_6) {
                        rmd->q_parity_it_nexus = raid_map->disk_data[index + 1].aio_handle;
                        rmd->xor_mult = raid_map->disk_data[rmd->map_index].xor_mult[1];
                }
#if BITS_PER_LONG == 32
                tmpdiv = rmd->first_block;
                do_div(tmpdiv, rmd->blocks_per_row);
                rmd->row = tmpdiv;
#else
                rmd->row = rmd->first_block / rmd->blocks_per_row;
#endif
        }

        return 0;
}

static void pqi_set_aio_cdb(struct pqi_scsi_dev_raid_map_data *rmd)
{
        /* Build the new CDB for the physical disk I/O. */
        if (rmd->disk_block > 0xffffffff) {
                rmd->cdb[0] = rmd->is_write ? WRITE_16 : READ_16;
                rmd->cdb[1] = 0;
                put_unaligned_be64(rmd->disk_block, &rmd->cdb[2]);
                put_unaligned_be32(rmd->disk_block_cnt, &rmd->cdb[10]);
                rmd->cdb[14] = 0;
                rmd->cdb[15] = 0;
                rmd->cdb_length = 16;
        } else {
                rmd->cdb[0] = rmd->is_write ? WRITE_10 : READ_10;
                rmd->cdb[1] = 0;
                put_unaligned_be32((u32)rmd->disk_block, &rmd->cdb[2]);
                rmd->cdb[6] = 0;
                put_unaligned_be16((u16)rmd->disk_block_cnt, &rmd->cdb[7]);
                rmd->cdb[9] = 0;
                rmd->cdb_length = 10;
        }
}

static void pqi_calc_aio_r1_nexus(struct raid_map *raid_map,
        struct pqi_scsi_dev_raid_map_data *rmd)
{
        u32 index;
        u32 group;

        group = rmd->map_index / rmd->data_disks_per_row;

        index = rmd->map_index - (group * rmd->data_disks_per_row);
        rmd->it_nexus[0] = raid_map->disk_data[index].aio_handle;
        index += rmd->data_disks_per_row;
        rmd->it_nexus[1] = raid_map->disk_data[index].aio_handle;
        if (rmd->layout_map_count > 2) {
                index += rmd->data_disks_per_row;
                rmd->it_nexus[2] = raid_map->disk_data[index].aio_handle;
        }

        rmd->num_it_nexus_entries = rmd->layout_map_count;
}

static int pqi_raid_bypass_submit_scsi_cmd(struct pqi_ctrl_info *ctrl_info,
        struct pqi_scsi_dev *device, struct scsi_cmnd *scmd,
        struct pqi_queue_group *queue_group)
{
        int rc;
        struct raid_map *raid_map;
        u32 group;
        u32 next_bypass_group;
        struct pqi_encryption_info *encryption_info_ptr;
        struct pqi_encryption_info encryption_info;
        struct pqi_scsi_dev_raid_map_data rmd = { 0 };

        rc = pqi_get_aio_lba_and_block_count(scmd, &rmd);
        if (rc)
                return PQI_RAID_BYPASS_INELIGIBLE;

        rmd.raid_level = device->raid_level;

        if (!pqi_aio_raid_level_supported(ctrl_info, &rmd))
                return PQI_RAID_BYPASS_INELIGIBLE;

        if (unlikely(rmd.block_cnt == 0))
                return PQI_RAID_BYPASS_INELIGIBLE;

        raid_map = device->raid_map;

        rc = pci_get_aio_common_raid_map_values(ctrl_info, &rmd, raid_map);
        if (rc)
                return PQI_RAID_BYPASS_INELIGIBLE;

        if (device->raid_level == SA_RAID_1 ||
                device->raid_level == SA_RAID_TRIPLE) {
                if (rmd.is_write) {
                        pqi_calc_aio_r1_nexus(raid_map, &rmd);
                } else {
                        group = device->next_bypass_group;
                        next_bypass_group = group + 1;
                        if (next_bypass_group >= rmd.layout_map_count)
                                next_bypass_group = 0;
                        device->next_bypass_group = next_bypass_group;
                        rmd.map_index += group * rmd.data_disks_per_row;
                }
        } else if ((device->raid_level == SA_RAID_5 ||
                device->raid_level == SA_RAID_6) &&
                (rmd.layout_map_count > 1 || rmd.is_write)) {
                rc = pqi_calc_aio_r5_or_r6(&rmd, raid_map);
                if (rc)
                        return PQI_RAID_BYPASS_INELIGIBLE;
        }

        if (unlikely(rmd.map_index >= RAID_MAP_MAX_ENTRIES))
                return PQI_RAID_BYPASS_INELIGIBLE;

        rmd.aio_handle = raid_map->disk_data[rmd.map_index].aio_handle;
        rmd.disk_block = get_unaligned_le64(&raid_map->disk_starting_blk) +
                rmd.first_row * rmd.strip_size +
                (rmd.first_row_offset - rmd.first_column * rmd.strip_size);
        rmd.disk_block_cnt = rmd.block_cnt;

        /* Handle differing logical/physical block sizes. */
        if (raid_map->phys_blk_shift) {
                rmd.disk_block <<= raid_map->phys_blk_shift;
                rmd.disk_block_cnt <<= raid_map->phys_blk_shift;
        }

        if (unlikely(rmd.disk_block_cnt > 0xffff))
                return PQI_RAID_BYPASS_INELIGIBLE;

        pqi_set_aio_cdb(&rmd);

        if (get_unaligned_le16(&raid_map->flags) & RAID_MAP_ENCRYPTION_ENABLED) {
                if (rmd.data_length > device->max_transfer_encrypted)
                        return PQI_RAID_BYPASS_INELIGIBLE;
                pqi_set_encryption_info(&encryption_info, raid_map, rmd.first_block);
                encryption_info_ptr = &encryption_info;
        } else {
                encryption_info_ptr = NULL;
        }

        if (rmd.is_write) {
                switch (device->raid_level) {
                case SA_RAID_1:
                case SA_RAID_TRIPLE:
                        return pqi_aio_submit_r1_write_io(ctrl_info, scmd, queue_group,
                                encryption_info_ptr, device, &rmd);
                case SA_RAID_5:
                case SA_RAID_6:
                        return pqi_aio_submit_r56_write_io(ctrl_info, scmd, queue_group,
                                encryption_info_ptr, device, &rmd);
                }
        }

        return pqi_aio_submit_io(ctrl_info, scmd, rmd.aio_handle,
                rmd.cdb, rmd.cdb_length, queue_group,
                encryption_info_ptr, true);
}

#define PQI_STATUS_IDLE         0x0

#define PQI_CREATE_ADMIN_QUEUE_PAIR     1
#define PQI_DELETE_ADMIN_QUEUE_PAIR     2

#define PQI_DEVICE_STATE_POWER_ON_AND_RESET             0x0
#define PQI_DEVICE_STATE_STATUS_AVAILABLE               0x1
#define PQI_DEVICE_STATE_ALL_REGISTERS_READY            0x2
#define PQI_DEVICE_STATE_ADMIN_QUEUE_PAIR_READY         0x3
#define PQI_DEVICE_STATE_ERROR                          0x4

#define PQI_MODE_READY_TIMEOUT_SECS             30
#define PQI_MODE_READY_POLL_INTERVAL_MSECS      1

static int pqi_wait_for_pqi_mode_ready(struct pqi_ctrl_info *ctrl_info)
{
        struct pqi_device_registers __iomem *pqi_registers;
        unsigned long timeout;
        u64 signature;
        u8 status;

        pqi_registers = ctrl_info->pqi_registers;
        timeout = (PQI_MODE_READY_TIMEOUT_SECS * PQI_HZ) + jiffies;

        while (1) {
                signature = readq(&pqi_registers->signature);
                if (memcmp(&signature, PQI_DEVICE_SIGNATURE,
                        sizeof(signature)) == 0)
                        break;
                if (time_after(jiffies, timeout)) {
                        dev_err(&ctrl_info->pci_dev->dev,
                                "timed out waiting for PQI signature\n");
                        return -ETIMEDOUT;
                }
                msleep(PQI_MODE_READY_POLL_INTERVAL_MSECS);
        }

        while (1) {
                status = readb(&pqi_registers->function_and_status_code);
                if (status == PQI_STATUS_IDLE)
                        break;
                if (time_after(jiffies, timeout)) {
                        dev_err(&ctrl_info->pci_dev->dev,
                                "timed out waiting for PQI IDLE\n");
                        return -ETIMEDOUT;
                }
                msleep(PQI_MODE_READY_POLL_INTERVAL_MSECS);
        }

        while (1) {
                if (readl(&pqi_registers->device_status) ==
                        PQI_DEVICE_STATE_ALL_REGISTERS_READY)
                        break;
                if (time_after(jiffies, timeout)) {
                        dev_err(&ctrl_info->pci_dev->dev,
                                "timed out waiting for PQI all registers ready\n");
                        return -ETIMEDOUT;
                }
                msleep(PQI_MODE_READY_POLL_INTERVAL_MSECS);
        }

        return 0;
}

static inline void pqi_aio_path_disabled(struct pqi_io_request *io_request)
{
        struct pqi_scsi_dev *device;

        device = io_request->scmd->device->hostdata;
        device->raid_bypass_enabled = false;
        device->aio_enabled = false;
}

static inline void pqi_take_device_offline(struct scsi_device *sdev, char *path)
{
        struct pqi_ctrl_info *ctrl_info;
        struct pqi_scsi_dev *device;

        device = sdev->hostdata;
        if (device->device_offline)
                return;

        device->device_offline = true;
        ctrl_info = shost_to_hba(sdev->host);
        pqi_schedule_rescan_worker(ctrl_info);
        dev_err(&ctrl_info->pci_dev->dev, "re-scanning %s scsi %d:%d:%d:%d\n",
                path, ctrl_info->scsi_host->host_no, device->bus,
                device->target, device->lun);
}

static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
{
        u8 scsi_status;
        u8 host_byte;
        struct scsi_cmnd *scmd;
        struct pqi_raid_error_info *error_info;
        size_t sense_data_length;
        int residual_count;
        int xfer_count;
        struct scsi_sense_hdr sshdr;

        scmd = io_request->scmd;
        if (!scmd)
                return;

        error_info = io_request->error_info;
        scsi_status = error_info->status;
        host_byte = DID_OK;

        switch (error_info->data_out_result) {
        case PQI_DATA_IN_OUT_GOOD:
                break;
        case PQI_DATA_IN_OUT_UNDERFLOW:
                xfer_count =
                        get_unaligned_le32(&error_info->data_out_transferred);
                residual_count = scsi_bufflen(scmd) - xfer_count;
                scsi_set_resid(scmd, residual_count);
                if (xfer_count < scmd->underflow)
                        host_byte = DID_SOFT_ERROR;
                break;
        case PQI_DATA_IN_OUT_UNSOLICITED_ABORT:
        case PQI_DATA_IN_OUT_ABORTED:
                host_byte = DID_ABORT;
                break;
        case PQI_DATA_IN_OUT_TIMEOUT:
                host_byte = DID_TIME_OUT;
                break;
        case PQI_DATA_IN_OUT_BUFFER_OVERFLOW:
        case PQI_DATA_IN_OUT_PROTOCOL_ERROR:
        case PQI_DATA_IN_OUT_BUFFER_ERROR:
        case PQI_DATA_IN_OUT_BUFFER_OVERFLOW_DESCRIPTOR_AREA:
        case PQI_DATA_IN_OUT_BUFFER_OVERFLOW_BRIDGE:
        case PQI_DATA_IN_OUT_ERROR:
        case PQI_DATA_IN_OUT_HARDWARE_ERROR:
        case PQI_DATA_IN_OUT_PCIE_FABRIC_ERROR:
        case PQI_DATA_IN_OUT_PCIE_COMPLETION_TIMEOUT:
        case PQI_DATA_IN_OUT_PCIE_COMPLETER_ABORT_RECEIVED:
        case PQI_DATA_IN_OUT_PCIE_UNSUPPORTED_REQUEST_RECEIVED:
        case PQI_DATA_IN_OUT_PCIE_ECRC_CHECK_FAILED:
        case PQI_DATA_IN_OUT_PCIE_UNSUPPORTED_REQUEST:
        case PQI_DATA_IN_OUT_PCIE_ACS_VIOLATION:
        case PQI_DATA_IN_OUT_PCIE_TLP_PREFIX_BLOCKED:
        case PQI_DATA_IN_OUT_PCIE_POISONED_MEMORY_READ:
        default:
                host_byte = DID_ERROR;
                break;
        }

        sense_data_length = get_unaligned_le16(&error_info->sense_data_length);
        if (sense_data_length == 0)
                sense_data_length =
                        get_unaligned_le16(&error_info->response_data_length);
        if (sense_data_length) {
                if (sense_data_length > sizeof(error_info->data))
                        sense_data_length = sizeof(error_info->data);

                if (scsi_status == SAM_STAT_CHECK_CONDITION &&
                        scsi_normalize_sense(error_info->data,
                                sense_data_length, &sshdr) &&
                                sshdr.sense_key == HARDWARE_ERROR &&
                                sshdr.asc == 0x3e) {
                        struct pqi_ctrl_info *ctrl_info = shost_to_hba(scmd->device->host);
                        struct pqi_scsi_dev *device = scmd->device->hostdata;

                        switch (sshdr.ascq) {
                        case 0x1: /* LOGICAL UNIT FAILURE */
                                if (printk_ratelimit())
                                        scmd_printk(KERN_ERR, scmd, "received 'logical unit failure' from controller for scsi %d:%d:%d:%d\n",
                                                ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
                                pqi_take_device_offline(scmd->device, "RAID");
                                host_byte = DID_NO_CONNECT;
                                break;

                        default: /* See http://www.t10.org/lists/asc-num.htm#ASC_3E */
                                if (printk_ratelimit())
                                        scmd_printk(KERN_ERR, scmd, "received unhandled error %d from controller for scsi %d:%d:%d:%d\n",
                                                sshdr.ascq, ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
                                break;
                        }
                }

                if (sense_data_length > SCSI_SENSE_BUFFERSIZE)
                        sense_data_length = SCSI_SENSE_BUFFERSIZE;
                memcpy(scmd->sense_buffer, error_info->data,