/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2023 Tintri by DDN, Inc. All rights reserved.
 * Copyright 2019 RackTop Systems, Inc.
 */

/*
 * Utility routines that have common usage throughout the driver.
 */
#include <smartpqi.h>

/* ---- Forward declarations for support/utility functions ---- */
static void reinit_io(pqi_io_request_t *io);
static void dump_raid(pqi_state_t *s, void *v, pqi_index_t idx);
static void dump_aio(void *v);
static void show_error_detail(pqi_state_t *s);
static void cmd_start_time(pqi_cmd_t *c);
static void cmd_finish_task(void *v);


/*
 * Entry points for this file
 */

#ifdef DEBUG
int     pqi_shuffle_delay = 0;
#endif  /* DEBUG */

static void
cmd_remove_group(pqi_cmd_t *c)
{
        pqi_io_request_t        *io = c->pc_io_rqst;
        pqi_device_t            *d = c->pc_device;

        /*
         * This would be a good place to send a SCSI TASK MANAGEMENT
         * command to cancel an individual command, but we don't
         * have any documentation on the HBA to describe how that
         * might be done.
         */
        if (io != NULL) {
                pqi_queue_group_t       *qg = io->io_queue_group;
                int                     path = io->io_queue_path;

                /*
                 * The lock ordering is such that the driver must drop
                 * the device lock in order to grab the queue lock.
                 * We must also drop the cmd mutex to prevent possible deadlock.
                 */
                mutex_exit(&c->pc_mutex);
                mutex_exit(&d->pd_mutex);
                mutex_enter(&qg->submit_lock[path]);
                if (list_link_active(&io->io_list_node)) {
                        list_remove(&qg->request_list[path], io);
                }
                mutex_exit(&qg->submit_lock[path]);
#ifdef DEBUG
                if (pqi_shuffle_delay != 0) { /* try to force deadlock error */
                        pqi_state_t     *s = c->pc_softc;
                        pqi_lun_reset(s, d);
                        delay(pqi_shuffle_delay * drv_usectohz(1000000));
                }
#endif  /* DEBUG */
                mutex_enter(&d->pd_mutex);
                mutex_enter(&c->pc_mutex);
        }
}

pqi_cmd_action_t
pqi_cmd_action_nolock(pqi_cmd_t *c, pqi_cmd_action_t a)
{
        pqi_device_t    *d = c->pc_device;
        pqi_state_t     *s = c->pc_softc;
        struct scsi_pkt *pkt;

        mutex_enter(&c->pc_mutex);
        /*
         * Don't change cmd if we are in middle of a timeout.
         */
        if ((c->pc_flags & PQI_FLAG_TIMED_OUT) != 0) {
                a = PQI_CMD_FAIL;
                goto skipto;
        }
        c->pc_last_action = c->pc_cur_action;
        c->pc_cur_action = a;
        switch (a) {
        case PQI_CMD_QUEUE:
                list_insert_tail(&d->pd_cmd_list, c);

                /*
                 * Set the start time now in case the HBA hangs. That will
                 * allow the timeout processing to handle these commands, which
                 * in theory have been started but not really started, without
                 * the need for special handling logic in the timeout scan.
                 */
                cmd_start_time(c);
                break;

        case PQI_CMD_START:
                if (c->pc_last_action == PQI_CMD_FAIL) {
                        list_remove(&d->pd_cmd_list, c);

                        pkt = CMD2PKT(c);
                        if (pkt == NULL) {
                                pqi_io_request_t        *io = c->pc_io_rqst;

                                io->io_status = PQI_DATA_IN_OUT_TIMEOUT;
                                (*io->io_cb)(io, io->io_context);
                                pqi_free_io(io);
                                c->pc_io_rqst = NULL;
                        } else {
                                pqi_free_io(c->pc_io_rqst);
                                c->pc_io_rqst = NULL;
                                (void) ddi_taskq_dispatch(s->s_complete_taskq,
                                    cmd_finish_task, c, 0);
                        }
                        a = PQI_CMD_FAIL;
                } else {
                        /*
                         * Now that the command is actually being sent to the
                         * HBA reset the start so that a timeout will occur
                         * only after the HBA has had the command for some
                         * amount of time as defined by the SCSI packet.
                         */
                        cmd_start_time(c);
                }
                break;

        case PQI_CMD_FAIL:
                if (c->pc_last_action == PQI_CMD_START) {
                        /*
                         * There's no means to cancel a command that has
                         * been passed to the HBA, at least none without more
                         * documentation. So, if the command has been passed
                         * to the HBA the queue slot must remain active until
                         * the command completes. If it fails to complete
                         * then it will be freed by cmd_timeout_scan() when
                         * the action is PQI_CMD_TIMEOUT. So, for now keep
                         * the action as being PQI_CMD_START.
                         */
                        a = PQI_CMD_START;
                } else {
                        /*
                         * Don't do any actual processing here to cancel and
                         * free the command. By leaving the pc_cur_action
                         * set to PQI_CMD_FAIL the command will be freed
                         * when pqi_start_io() calls pqi_cmd_action(). The need
                         * for handling the error case in this manner is due
                         * to a small window in pqi_start_io() where the command
                         * has been removed from the group queue and before
                         * pqi_cmd_action() is called. It would be possible
                         * to fix by adding an additional lock to
                         * pqi_io_request_t or handle the issue in this manner.
                         * Less locks == good.
                         */
                        /*
                         * We could have come in here during a cmd timeout
                         * lock shuffle so last action might be timeout here.
                         */
                        ASSERT(c->pc_last_action == PQI_CMD_TIMEOUT ||
                            c->pc_last_action == PQI_CMD_QUEUE);
                }
                break;

        case PQI_CMD_TIMEOUT:
                list_remove(&d->pd_cmd_list, c);
                /*
                 * Set a flag to prevent this command from changing while we
                 * shuffle locks below.
                 */
                c->pc_flags |= PQI_FLAG_TIMED_OUT;
                cmd_remove_group(c);

                /*
                 * When a timeout has occurred it means something has gone
                 * wrong with the HBA or drive.  Timed out io requests are
                 * marked and the cmd was marked and removed from the chain
                 * above so it should not have changed state when we dropped
                 * and re-grabbed the locks.
                 */
                ASSERT3U(c->pc_cur_action, ==, PQI_CMD_TIMEOUT);

                c->pc_flags &= ~PQI_FLAG_TIMED_OUT;
                /*
                 * Internal commands to the driver will not have a SCSI packet
                 * associated.
                 */
                pkt = CMD2PKT(c);
                if (pkt == NULL) {
                        pqi_io_request_t        *io = c->pc_io_rqst;

                        io->io_status = PQI_DATA_IN_OUT_TIMEOUT;
                        (*io->io_cb)(io, io->io_context);
                        pqi_free_io(c->pc_io_rqst);
                        c->pc_io_rqst = NULL;
                } else {
                        pqi_free_io(c->pc_io_rqst);
                        c->pc_io_rqst = NULL;
                        mutex_exit(&c->pc_mutex);
                        (void) ddi_taskq_dispatch(s->s_complete_taskq,
                            cmd_finish_task, c, 0);
                        return (a);
                }
                break;

        case PQI_CMD_CMPLT:
                if (c->pc_last_action == PQI_CMD_TIMEOUT)
                        break;

                list_remove(&d->pd_cmd_list, c);

                pqi_free_io(c->pc_io_rqst);
                c->pc_io_rqst = NULL;
                if (CMD2PKT(c) != NULL) {
                        /*
                         * ddi_taskq_dispatch doesn't always start a separate
                         * thread. Under some conditions this will turn into
                         * a direct call to cmd_finish_task(). That in turn
                         * calls into the SCSA layer which can call
                         * tran_ini_pkt which will eventually try to call
                         * pqi_cmd_action(). So, need to drop the mutex before
                         * making the call to ddi_taskq_dispatch and then
                         * return.
                         */
                        mutex_exit(&c->pc_mutex);
                        (void) ddi_taskq_dispatch(s->s_complete_taskq,
                            cmd_finish_task, c, 0);
                        return (a);
                }
                break;

        default:
                cmn_err(CE_PANIC,
                    "%s: Unknown action request: %d", __func__, a);
        }
skipto:
        mutex_exit(&c->pc_mutex);
        return (a);
}

pqi_cmd_action_t
pqi_cmd_action(pqi_cmd_t *c, pqi_cmd_action_t a)
{
        pqi_device_t            *d = c->pc_device;
        pqi_cmd_action_t        rval;

        mutex_enter(&d->pd_mutex);
        rval = pqi_cmd_action_nolock(c, a);
        mutex_exit(&d->pd_mutex);

        return (rval);
}

boolean_t
pqi_is_offline(pqi_state_t *s)
{
        return (s->s_offline);
}

/*
 * pqi_alloc_io -- return next available slot.
 */
pqi_io_request_t *
pqi_alloc_io(pqi_state_t *s)
{
        pqi_io_request_t        *io     = NULL;
        uint16_t                loop;
        uint16_t                i;

        mutex_enter(&s->s_io_mutex);
        i = s->s_next_io_slot; /* just a hint */
        s->s_io_need++;
        for (;;) {
                for (loop = 0; loop < s->s_max_io_slots; loop++) {
                        /*
                         * Controller offline can only occur if the HBA is going
                         * through reset due to firmware hang.
                         */
                        if (pqi_is_offline(s)) {
                                mutex_exit(&s->s_io_mutex);
                                return (NULL);
                        }
                        io = &s->s_io_rqst_pool[i];
                        i = (i + 1) % s->s_max_io_slots;
                        if (io->io_refcount == 0) {
                                io->io_refcount = 1;
                                break;
                        }
                }
                if (loop != s->s_max_io_slots)
                        break;

                s->s_io_had2wait++;
                s->s_io_wait_cnt++;
                if (cv_wait_sig(&s->s_io_condvar, &s->s_io_mutex) == 0) {
                        s->s_io_sig++;
                        io = NULL;
                        break;
                }
                i = s->s_next_io_slot; /* just a hint */
        }
        s->s_next_io_slot = i;
        mutex_exit(&s->s_io_mutex);

        if (io != NULL)
                reinit_io(io);
        return (io);
}

void
pqi_free_io(pqi_io_request_t *io)
{
        pqi_state_t     *s = io->io_softc;

        mutex_enter(&s->s_io_mutex);
        ASSERT(io->io_refcount == 1);
        io->io_refcount = 0;
        reinit_io(io);
        if (s->s_io_wait_cnt != 0) {
                s->s_io_wait_cnt--;
                cv_signal(&s->s_io_condvar);
        }
        mutex_exit(&s->s_io_mutex);
}


/*
 * Time out an in progress i/o.
 * If the i/o has been serviced then return false (can't timeout),
 * otherwise increment the generation counter and return true.
 */
boolean_t
pqi_timeout_io(pqi_io_request_t *io)
{
        mutex_enter(&io->io_lock);
        if (io->io_serviced) {
                /*
                 * Can't timeout this io, it's already been serviced.
                 */
                mutex_exit(&io->io_lock);
                return (B_FALSE);
        }
        io->io_gen = (io->io_gen + 1) % PQI_NGENS;
        mutex_exit(&io->io_lock);
        return (B_TRUE);
}

/*
 * Check if an i/o is serviceable (generation counter matches).
 * If so, mark it as serviced and return true.
 * Otherwise, return false.
 */
boolean_t
pqi_service_io(pqi_io_request_t *io, uint8_t generation)
{
        mutex_enter(&io->io_lock);
        if (io->io_gen != generation) {
                /*
                 * Can't service this io, it's already been timed out.
                 */
                mutex_exit(&io->io_lock);
                return (B_FALSE);
        }
        io->io_serviced = B_TRUE;
        mutex_exit(&io->io_lock);
        return (B_TRUE);
}

void
pqi_dump_io(pqi_io_request_t *io)
{
        pqi_iu_header_t *hdr = io->io_iu;
        pqi_state_t     *s;

        if (io->io_cmd != NULL) {
                s = io->io_cmd->pc_softc;
        } else {
                /*
                 * Early on, during driver attach, commands are run without
                 * a pqi_cmd_t structure associated. These io requests are
                 * low level operations direct to the HBA. So, grab a
                 * reference to the first and only instance through the
                 * DDI interface. Even though there might be multiple HBA's
                 * grabbing the first is okay since dump_raid() only references
                 * the debug level which will be the same for all the
                 * controllers.
                 */
                s = ddi_get_soft_state(pqi_state, 0);
        }

        if (hdr->iu_type == PQI_REQUEST_IU_AIO_PATH_IO) {
                dump_aio(io->io_iu);
        } else if (hdr->iu_type == PQI_REQUEST_IU_RAID_PATH_IO) {
                dump_raid(s, io->io_iu, io->io_pi);
        }
}

static uint_t supported_event_types[] = {
        PQI_EVENT_TYPE_HOTPLUG,
        PQI_EVENT_TYPE_HARDWARE,
        PQI_EVENT_TYPE_PHYSICAL_DEVICE,
        PQI_EVENT_TYPE_LOGICAL_DEVICE,
        PQI_EVENT_TYPE_AIO_STATE_CHANGE,
        PQI_EVENT_TYPE_AIO_CONFIG_CHANGE,
        PQI_EVENT_TYPE_HEARTBEAT
};

int
pqi_map_event(uint8_t event)
{
        int i;

        for (i = 0; i < sizeof (supported_event_types) / sizeof (uint_t); i++)
                if (supported_event_types[i] == event)
                        return (i);
        return (-1);
}

boolean_t
pqi_supported_event(uint8_t event)
{
        return (pqi_map_event(event) == -1 ? B_FALSE : B_TRUE);
}

char *
pqi_event_to_str(uint8_t event)
{
        switch (event) {
        case PQI_EVENT_TYPE_HOTPLUG: return ("Hotplug");
        case PQI_EVENT_TYPE_HARDWARE: return ("Hardware");
        case PQI_EVENT_TYPE_PHYSICAL_DEVICE:
                return ("Physical Device");
        case PQI_EVENT_TYPE_LOGICAL_DEVICE: return ("logical Device");
        case PQI_EVENT_TYPE_AIO_STATE_CHANGE:
                return ("AIO State Change");
        case PQI_EVENT_TYPE_AIO_CONFIG_CHANGE:
                return ("AIO Config Change");
        case PQI_EVENT_TYPE_HEARTBEAT: return ("Heartbeat");
        default: return ("Unsupported Event Type");
        }
}

char *
bool_to_str(int v)
{
        return (v ? "T" : "f");
}

char *
dtype_to_str(int t)
{
        switch (t) {
        case DTYPE_DIRECT: return ("Direct");
        case DTYPE_SEQUENTIAL: return ("Sequential");
        case DTYPE_ESI: return ("ESI");
        case DTYPE_ARRAY_CTRL: return ("RAID");
        default: return ("Ughknown");
        }
}

static ddi_dma_attr_t single_dma_attrs = {
        .dma_attr_version =     DMA_ATTR_V0,
        .dma_attr_addr_lo =     0x0ull,
        .dma_attr_addr_hi =     0xffffffffffffffffull,
        .dma_attr_count_max =   0x7ffffull,
        .dma_attr_align =       4096,
        .dma_attr_burstsizes =  0x78,
        .dma_attr_minxfer =     1,
        .dma_attr_maxxfer =     0x007ffffull,
        .dma_attr_seg =         0xffffffffull,
        .dma_attr_sgllen =      1,
        .dma_attr_granular =    512,
        .dma_attr_flags =       0,
};

pqi_dma_overhead_t *
pqi_alloc_single(pqi_state_t *s, size_t len)
{
        pqi_dma_overhead_t      *d;
        ddi_dma_cookie_t        cookie;

        d = kmem_zalloc(sizeof (*d), KM_SLEEP);
        d->len_to_alloc = len;

        if (ddi_dma_alloc_handle(s->s_dip, &single_dma_attrs,
            DDI_DMA_SLEEP, 0, &d->handle) != DDI_SUCCESS)
                goto error_out;

        if (ddi_dma_mem_alloc(d->handle, len, &s->s_reg_acc_attr,
            DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, 0,
            &d->alloc_memory, &len, &d->acc) != DDI_SUCCESS)
                goto error_out;

        bzero(d->alloc_memory, len);
        if (ddi_dma_addr_bind_handle(d->handle, NULL, d->alloc_memory, len,
            DDI_DMA_RDWR, DDI_DMA_SLEEP, 0, &cookie, &d->cookie_count) !=
            DDI_SUCCESS)
                goto error_out;

        d->dma_addr = cookie.dmac_laddress;
        if (d->cookie_count != 1)
                ddi_dma_nextcookie(d->handle, &d->second);

        return (d);

error_out:
        pqi_free_single(s, d);
        return (NULL);
}

void
pqi_free_single(pqi_state_t *s __unused, pqi_dma_overhead_t *d)
{
        (void) ddi_dma_unbind_handle(d->handle);
        if (d->alloc_memory != NULL)
                ddi_dma_mem_free(&d->acc);
        if (d->handle != NULL)
                ddi_dma_free_handle(&d->handle);
        kmem_free(d, sizeof (*d));
}

void
pqi_show_dev_state(pqi_state_t *s)
{
        uint32_t dev_status = G32(s, pqi_registers.device_status);

        switch (dev_status & 0xf) {
        case 0:
                cmn_err(CE_NOTE, "Power_On_And_Reset");
                break;

        case 1:
                cmn_err(CE_NOTE, "PQI_Status_Available");
                break;

        case 2:
                cmn_err(CE_NOTE, "All_Registers_Ready");
                break;

        case 3:
                cmn_err(CE_NOTE,
                    "Adminstrator_Queue_Pair_Ready");
                break;

        case 4:
                cmn_err(CE_NOTE, "Error: %s %s",
                    dev_status & 0x100 ? "(OP OQ Error)" : "",
                    dev_status & 0x200 ? "(OP IQ Error)" : "");
                show_error_detail(s);
                break;

        default:
                cmn_err(CE_WARN, "Unknown HBA status: 0x%x", dev_status);
                break;
        }
}

char *
cdb_to_str(uint8_t scsi_cmd)
{
        switch (scsi_cmd) {
        case SCMD_INQUIRY: return ("Inquiry");
        case SCMD_TEST_UNIT_READY: return ("TestUnitReady");
        case SCMD_READ: return ("Read");
        case SCMD_READ_G1: return ("Read G1");
        case SCMD_RESERVE: return ("Reserve");
        case SCMD_RELEASE: return ("Release");
        case SCMD_WRITE: return ("Write");
        case SCMD_WRITE_G1: return ("Write G1");
        case SCMD_START_STOP: return ("StartStop");
        case SCMD_READ_CAPACITY: return ("ReadCap");
        case SCMD_MODE_SENSE: return ("ModeSense");
        case SCMD_MODE_SELECT: return ("ModeSelect");
        case SCMD_SVC_ACTION_IN_G4: return ("ActionInG4");
        case SCMD_MAINTENANCE_IN: return ("MaintenanceIn");
        case SCMD_GDIAG: return ("ReceiveDiag");
        case SCMD_SDIAG: return ("SendDiag");
        case SCMD_LOG_SENSE_G1: return ("LogSenseG1");
        case SCMD_PERSISTENT_RESERVE_IN: return ("PgrReserveIn");
        case SCMD_PERSISTENT_RESERVE_OUT: return ("PgrReserveOut");
        case BMIC_READ: return ("BMIC Read");
        case BMIC_WRITE: return ("BMIC Write");
        case CISS_REPORT_LOG: return ("CISS Report Logical");
        case CISS_REPORT_PHYS: return ("CISS Report Physical");
        default: return ("unmapped");
        }
}

char *
io_status_to_str(int val)
{
        switch (val) {
        case PQI_DATA_IN_OUT_GOOD: return ("Good");
        case PQI_DATA_IN_OUT_UNDERFLOW: return ("Underflow");
        case PQI_DATA_IN_OUT_ERROR: return ("ERROR");
        case PQI_DATA_IN_OUT_PROTOCOL_ERROR: return ("Protocol Error");
        case PQI_DATA_IN_OUT_HARDWARE_ERROR: return ("Hardware Error");
        default: return ("UNHANDLED");
        }
}

char *
scsi_status_to_str(uint8_t val)
{
        switch (val) {
        case STATUS_GOOD: return ("Good");
        case STATUS_CHECK: return ("Check");
        case STATUS_MET: return ("Met");
        case STATUS_BUSY: return ("Busy");
        case STATUS_INTERMEDIATE: return ("Intermediate");
        case STATUS_RESERVATION_CONFLICT: return ("Reservation Conflict");
        case STATUS_TERMINATED: return ("Terminated");
        case STATUS_QFULL: return ("QFull");
        case STATUS_ACA_ACTIVE: return ("ACA Active");
        case STATUS_TASK_ABORT: return ("Task Abort");
        default: return ("Illegal Status");
        }
}

char *
iu_type_to_str(int val)
{
        switch (val) {
        case PQI_RESPONSE_IU_RAID_PATH_IO_SUCCESS: return ("Success");
        case PQI_RESPONSE_IU_AIO_PATH_IO_SUCCESS: return ("AIO Success");
        case PQI_RESPONSE_IU_GENERAL_MANAGEMENT: return ("General");
        case PQI_RESPONSE_IU_RAID_PATH_IO_ERROR: return ("IO Error");
        case PQI_RESPONSE_IU_AIO_PATH_IO_ERROR: return ("AIO IO Error");
        case PQI_RESPONSE_IU_AIO_PATH_DISABLED: return ("AIO Path Disabled");
        default: return ("UNHANDLED");
        }
}

void
pqi_free_mem_len(mem_len_pair_t *m)
{
        kmem_free(m->mem, m->len);
}

mem_len_pair_t
pqi_alloc_mem_len(int len)
{
        mem_len_pair_t m;
        m.len = len;
        m.mem = kmem_alloc(m.len, KM_SLEEP);
        *m.mem = '\0';
        return (m);
}

/*
 * []------------------------------------------------------------------[]
 * | Support/utility functions for main functions above                 |
 * []------------------------------------------------------------------[]
 */

typedef struct qual {
        int     q_val;
        char    *q_str;
} qual_t;

typedef struct code_qual {
        int     cq_code;
        qual_t  *cq_list;
} code_qual_t;

/*
 * These messages come from pqi2r01 spec section 5.6 table 18.
 */
static qual_t pair0[] = { {0, "No error"}, {0, NULL} };
static qual_t pair1[] = { {0, "Error detected during initialization"},
        { 0, NULL } };
static qual_t pair2[] = { {1, "Invalid PD Function"},
        {2, "Invalid paramter for PD function"},
        {0, NULL } };
static qual_t pair3[] = { {0, "Error creating admin queue pair"},
        { 1, "Error deleting admin queue pair"},
        { 0, NULL} };
static qual_t pair4[] = { {1, "Invalid IU type in general" },
        {2, "Invalid IU length in general admin request"},
        {0, NULL} };
static qual_t pair5[] = { {1, "Internal error" },
        {2, "OQ spanning conflict"},
        {0, NULL} };
static qual_t pair6[] = { {1, "Error completing PQI soft reset"},
        {2, "Error completing PQI firmware reset"},
        {3, "Error completing PQI hardware reset"},
        {0, NULL} };
static code_qual_t cq_table[] = {
        { 0, pair0 },
        { 1, pair1 },
        { 2, pair2 },
        { 3, pair3 },
        { 4, pair4 },
        { 5, pair5 },
        { 6, pair6 },
        { 0, NULL },
};

/*
 * cmd_finish_task -- taskq to complete command processing
 *
 * Under high load the driver will run out of IO slots which causes command
 * requests to pause until a slot is free. Calls to pkt_comp below can circle
 * through the SCSI layer and back into the driver to start another command
 * request and therefore possibly pause. If cmd_finish_task() was called on
 * the interrupt thread a hang condition could occur because IO slots wouldn't
 * be processed and then freed. So, this portion of the command completion
 * is run on a taskq.
 */
static void
cmd_finish_task(void *v)
{
        pqi_cmd_t       *c = v;
        struct scsi_pkt *pkt = CMD2PKT(c);

        if (c->pc_poll)
                sema_v(c->pc_poll);

        if (pkt != NULL && (pkt->pkt_flags & FLAG_NOINTR) == 0 &&
            (pkt->pkt_comp != NULL))
                (*pkt->pkt_comp)(pkt);
}

static void
cmd_start_time(pqi_cmd_t *c)
{
        c->pc_start_time = gethrtime();
        if (CMD2PKT(c) != NULL) {
                c->pc_expiration = c->pc_start_time +
                    ((hrtime_t)c->pc_pkt->pkt_time * NANOSEC);
        } else {
                c->pc_expiration = c->pc_start_time + 5 * NANOSEC;
        }
}

static void
show_error_detail(pqi_state_t *s)
{
        uint32_t error_reg = G32(s, pqi_registers.device_error);
        uint8_t         code, qualifier;
        qual_t          *p;
        code_qual_t     *cq;

        code = error_reg & 0xff;
        qualifier = (error_reg >> 8) & 0xff;

        for (cq = cq_table; cq->cq_list != NULL; cq++) {
                if (cq->cq_code == code) {
                        for (p = cq->cq_list; p->q_str != NULL; p++) {
                                if (p->q_val == qualifier) {
                                        cmn_err(CE_NOTE,
                                            "[code=%x,qual=%x]: %s",
                                            code, qualifier, p->q_str);
                                        return;
                                }
                        }
                }
        }
        cmn_err(CE_NOTE, "Undefined code(%x)/qualifier(%x)",
            code, qualifier);
}

static void
pqi_catch_release(pqi_io_request_t *io __unused, void *v __unused)
{
        /*
         * This call can occur if the software times out a command because
         * the HBA hasn't responded in the default amount of time, 10 seconds,
         * and then the HBA responds. It's occurred a few times during testing
         * so catch and ignore.
         */
        cmn_err(CE_NOTE, "%s: caught", __func__);
}

static void
reinit_io(pqi_io_request_t *io)
{
        io->io_cb = pqi_catch_release;
        io->io_status = 0;
        io->io_serviced = B_FALSE;
        io->io_error_info = NULL;
        io->io_raid_bypass = B_FALSE;
        io->io_context = NULL;
        io->io_cmd = NULL;
}

mem_len_pair_t
build_cdb_str(uint8_t *cdb)
{
        mem_len_pair_t m = pqi_alloc_mem_len(64);

        m.mem[0] = '\0';

        switch (cdb[0]) {
        case SCMD_INQUIRY:
                MEMP("%s", cdb_to_str(cdb[0]));
                if ((cdb[1] & 0x1) != 0)
                        MEMP(".vpd=%x", cdb[2]);
                else if (cdb[2])
                        MEMP("Illegal CDB");
                MEMP(".len=%x", cdb[3] << 8 | cdb[4]);
                break;

        case SCMD_READ:
                MEMP("%s.lba=%x.len=%x", cdb_to_str(cdb[0]),
                    (cdb[1] & 0x1f) << 16 | cdb[2] << 8 | cdb[3],
                    cdb[4]);
                break;

        case SCMD_MODE_SENSE:
                MEMP("%s.dbd=%s.pc=%x.page_code=%x.subpage=%x."
                    "len=%x", cdb_to_str(cdb[0]),
                    bool_to_str(cdb[1] & 8), cdb[2] >> 6 & 0x3,
                    cdb[2] & 0x3f, cdb[3], cdb[4]);
                break;

        case SCMD_START_STOP:
                MEMP("%s.immed=%s.power=%x.start=%s",
                    cdb_to_str(cdb[0]), bool_to_str(cdb[1] & 1),
                    (cdb[4] >> 4) & 0xf, bool_to_str(cdb[4] & 1));
                break;

        case SCMD_SVC_ACTION_IN_G4:
        case SCMD_READ_CAPACITY:
        case SCMD_TEST_UNIT_READY:
        default:
                MEMP("%s (%x)", cdb_to_str(cdb[0]), cdb[0]);
                break;
        }
        return (m);
}

mem_len_pair_t
mem_to_arraystr(uint8_t *ptr, size_t len)
{
        mem_len_pair_t  m       = pqi_alloc_mem_len(len * 3 + 20);
        int             i;

        m.mem[0] = '\0';
        MEMP("{ ");
        for (i = 0; i < len; i++) {
                MEMP("%02x ", *ptr++ & 0xff);
        }
        MEMP(" }");

        return (m);
}

static char lun_str[64];
static char *
lun_to_str(uint8_t *lun)
{
        int     i;
        lun_str[0] = '\0';
        for (i = 0; i < 8; i++)
                (void) snprintf(lun_str + strlen(lun_str),
                    sizeof (lun_str) - strlen(lun_str), "%02x.", *lun++);
        return (lun_str);
}

static char *
dir_to_str(int dir)
{
        switch (dir) {
        case SOP_NO_DIRECTION_FLAG: return ("NoDir");
        case SOP_WRITE_FLAG: return ("Write");
        case SOP_READ_FLAG: return ("Read");
        case SOP_BIDIRECTIONAL: return ("RW");
        default: return ("Oops");
        }
}

static char *
flags_to_str(uint32_t flag)
{
        switch (flag) {
        case CISS_SG_LAST: return ("Last");
        case CISS_SG_CHAIN: return ("Chain");
        case CISS_SG_NORMAL: return ("Norm");
        default: return ("Ooops");
        }
}

/* ---- Only for use in dump_raid and dump_aio ---- */
#define SCRATCH_PRINT(args...) (void)snprintf(scratch + strlen(scratch), \
    len - strlen(scratch), args)

static void
dump_raid(pqi_state_t *s, void *v, pqi_index_t idx)
{
        int                     i;
        int                     len     = 512;
        caddr_t                 scratch;
        pqi_raid_path_request_t *rqst = v;
        mem_len_pair_t          cdb_data;
        caddr_t                 raw = v;

        scratch = kmem_alloc(len, KM_SLEEP);
        scratch[0] = '\0';

        if (s->s_debug_level & DBG_LVL_RAW_RQST) {
                SCRATCH_PRINT("RAW RQST: ");
                for (i = 0; i < sizeof (*rqst); i++)
                        SCRATCH_PRINT("%02x:", *raw++ & 0xff);
                cmn_err(CE_NOTE, "%s", scratch);
                scratch[0] = '\0';
        }

        if (s->s_debug_level & DBG_LVL_CDB) {
                cdb_data = build_cdb_str(rqst->rp_cdb);
                SCRATCH_PRINT("cdb(%s),", cdb_data.mem);
                pqi_free_mem_len(&cdb_data);
        }

        ASSERT0(rqst->header.reserved);
        ASSERT0(rqst->reserved1);
        ASSERT0(rqst->reserved2);
        ASSERT0(rqst->reserved3);
        ASSERT0(rqst->reserved4);
        ASSERT0(rqst->reserved5);

        if (s->s_debug_level & DBG_LVL_RQST) {
                SCRATCH_PRINT("pi=%x,h(type=%x,len=%x,id=%x)", idx,
                    rqst->header.iu_type, rqst->header.iu_length,
                    rqst->header.iu_id);
                SCRATCH_PRINT("rqst_id=%x,nexus_id=%x,len=%x,lun=(%s),"
                    "proto=%x,dir=%s,partial=%s,",
                    rqst->rp_id, rqst->rp_nexus_id, rqst->rp_data_len,
                    lun_to_str(rqst->rp_lun), rqst->protocol_specific,
                    dir_to_str(rqst->rp_data_dir),
                    bool_to_str(rqst->rp_partial));
                SCRATCH_PRINT("fence=%s,error_idx=%x,task_attr=%x,"
                    "priority=%x,additional=%x,sg=(",
                    bool_to_str(rqst->rp_fence), rqst->rp_error_index,
                    rqst->rp_task_attr,
                    rqst->rp_pri, rqst->rp_additional_cdb);
                for (i = 0; i < PQI_MAX_EMBEDDED_SG_DESCRIPTORS; i++) {
                        SCRATCH_PRINT("%lx:%x:%s,",
                            (long unsigned int)rqst->rp_sglist[i].sg_addr,
                            rqst->rp_sglist[i].sg_len,
                            flags_to_str(rqst->rp_sglist[i].sg_flags));
                }
                SCRATCH_PRINT(")");
        }

        cmn_err(CE_NOTE, "%s", scratch);
        kmem_free(scratch, len);
}

static void
dump_aio(void *v)
{
        pqi_aio_path_request_t  *rqst   = v;
        int                     i;
        int                     len     = 512;
        caddr_t                 scratch;
        mem_len_pair_t          cdb_data;

        scratch = kmem_alloc(len, KM_SLEEP);
        scratch[0] = '\0';

        cdb_data = build_cdb_str(rqst->cdb);
        SCRATCH_PRINT("cdb(%s)", cdb_data.mem);
        pqi_free_mem_len(&cdb_data);

        SCRATCH_PRINT("h(type=%x,len=%x,id=%x)",
            rqst->header.iu_type, rqst->header.iu_length,
            rqst->header.iu_id);
        SCRATCH_PRINT("rqst_id=%x,nexus_id=%x,len=%x,lun=(%s),dir=%s,"
            "partial=%s,",
            rqst->request_id, rqst->nexus_id, rqst->buffer_length,
            lun_to_str(rqst->lun_number),
            dir_to_str(rqst->data_direction), bool_to_str(rqst->partial));
        SCRATCH_PRINT("fence=%s,error_idx=%x,task_attr=%x,priority=%x,"
            "num_sg=%x,cdb_len=%x,sg=(",
            bool_to_str(rqst->fence), rqst->error_index, rqst->task_attribute,
            rqst->command_priority, rqst->num_sg_descriptors, rqst->cdb_length);
        for (i = 0; i < PQI_MAX_EMBEDDED_SG_DESCRIPTORS; i++) {
                SCRATCH_PRINT("%lx:%x:%s,",
                    (long unsigned int)rqst->ap_sglist[i].sg_addr,
                    rqst->ap_sglist[i].sg_len,
                    flags_to_str(rqst->ap_sglist[i].sg_flags));
        }
        SCRATCH_PRINT(")");

        cmn_err(CE_NOTE, "%s", scratch);
        kmem_free(scratch, len);
}