/*
 * 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.
 */

/*
 * This file sets up the interrupts with the system and also processes
 * interrupts from the hardware.
 */

/* ---- Driver specific header ---- */
#include <smartpqi.h>

/* ---- Forward declarations of private methods ---- */
static int add_intrs(pqi_state_t *s, int type);
static uint_t intr_handler(caddr_t arg1, caddr_t arg2);
static void sync_error(pqi_state_t *s, pqi_io_request_t *io,
    pqi_io_response_t *rsp);
static void process_raid_io_error(pqi_io_request_t *io);
static void process_aio_io_error(pqi_io_request_t *io);
static void disable_aio_path(pqi_io_request_t *io);

/*
 * smartpqi_register_intrs -- Figure out which type of interrupts and register
 *                            them with the framework.
 */
int
smartpqi_register_intrs(pqi_state_t *s)
{
        int     intr_types;

        /* ---- Get supported interrupt types ---- */
        if (ddi_intr_get_supported_types(s->s_dip, &intr_types) !=
            DDI_SUCCESS) {
                dev_err(s->s_dip, CE_NOTE,
                    "failed to get supported intr types");
                return (FALSE);
        }

        if (intr_types & DDI_INTR_TYPE_MSIX) {
                if (add_intrs(s, DDI_INTR_TYPE_MSIX) == TRUE) {
                        s->s_intr_type = DDI_INTR_TYPE_MSIX;
                        return (TRUE);
                }
        } else if (intr_types & DDI_INTR_TYPE_MSI) {
                if (add_intrs(s, DDI_INTR_TYPE_MSI) == TRUE) {
                        s->s_intr_type = DDI_INTR_TYPE_MSI;
                        return (TRUE);
                }
        } else if (intr_types & DDI_INTR_TYPE_FIXED) {
                if (add_intrs(s, DDI_INTR_TYPE_FIXED) == TRUE) {
                        s->s_intr_type = DDI_INTR_TYPE_FIXED;
                        return (TRUE);
                }
        } else {
                /* ---- Warning since it's a DDI framework error ---- */
                dev_err(s->s_dip, CE_WARN,
                    "ddi_intr_get_supported_types returned bogus type of 0x%x",
                    intr_types);
        }

        return (FALSE);
}

/*
 * smartqpi_unregister_intrs -- Disable and remove interrupt handlers
 */
void
smartpqi_unregister_intrs(pqi_state_t *s)
{
        int     i;

        /* --- First disable the interrupts ---- */
        if (s->s_intr_cap & DDI_INTR_FLAG_BLOCK) {
                (void) ddi_intr_block_disable(s->s_itable, s->s_intr_cnt);
        } else {
                for (i = 0; i < s->s_intr_cnt; i++) {
                        (void) ddi_intr_disable(s->s_itable[i]);
                }
        }

        /* ---- Next remove the interrupt handlers ---- */
        for (i = 0; i < s->s_intr_cnt; i++) {
                (void) ddi_intr_remove_handler(s->s_itable[i]);
                (void) ddi_intr_free(s->s_itable[i]);
        }

        kmem_free(s->s_itable, s->s_intr_size);
        /* ---- Just in case ---- */
        s->s_itable = NULL;
        s->s_intr_size = 0;
}

void
pqi_process_io_intr(pqi_state_t *s, pqi_queue_group_t *qg)
{
        pqi_index_t             oq_pi;
        pqi_index_t             oq_ci;
        pqi_io_request_t        *io;
        pqi_io_response_t       *rsp;
        uint16_t                rqst_ix;
        uint8_t                 rqst_gen;
        int                     response_cnt = 0;
        int                     qnotify;

        oq_ci = qg->oq_ci_copy;
        atomic_inc_32(&s->s_intr_count);

        mutex_enter(&s->s_intr_mutex);
        for (;;) {
                (void) ddi_dma_sync(s->s_queue_dma->handle,
                    (uintptr_t)qg->oq_pi -
                    (uintptr_t)s->s_queue_dma->alloc_memory,
                    sizeof (oq_pi), DDI_DMA_SYNC_FORCPU);

                oq_pi = *qg->oq_pi;
                if (oq_pi == oq_ci)
                        break;

                rsp = (pqi_io_response_t *)(qg->oq_element_array +
                    (oq_ci * PQI_OPERATIONAL_OQ_ELEMENT_LENGTH));
                (void) ddi_dma_sync(s->s_queue_dma->handle,
                    (uintptr_t)rsp - (uintptr_t)s->s_queue_dma->alloc_memory,
                    sizeof (*rsp), DDI_DMA_SYNC_FORCPU);
                rqst_ix = PQI_REQID_INDEX(rsp->request_id);
                ASSERT(rqst_ix < s->s_max_io_slots);
                rqst_gen = PQI_REQID_GEN(rsp->request_id);
                io = &s->s_io_rqst_pool[rqst_ix];

                if (!pqi_service_io(io, rqst_gen)) {
                        /*
                         * Generation does not match, this response must be
                         * a stale response for a previous (timed out) i/o req.
                         */
                        goto skipto;
                }
                ASSERT(io->io_refcount == 1);

                if (io->io_cmd != NULL) {
                        pqi_cmd_t       *cmd = io->io_cmd;

                        if ((cmd->pc_flags & PQI_FLAG_TIMED_OUT) != 0)
                                goto skipto;
                }

                io->io_iu_type = rsp->header.iu_type;
                switch (rsp->header.iu_type) {
                case PQI_RESPONSE_IU_RAID_PATH_IO_SUCCESS:
                case PQI_RESPONSE_IU_AIO_PATH_IO_SUCCESS:
                case PQI_RESPONSE_IU_GENERAL_MANAGEMENT:
                case PQI_RESPONSE_IU_TASK_MANAGEMENT:
                        io->io_status = PQI_DATA_IN_OUT_GOOD;
                        break;
                case PQI_RESPONSE_IU_RAID_PATH_IO_ERROR:
                        io->io_status = PQI_DATA_IN_OUT_ERROR;
                        sync_error(s, io, rsp);
                        process_raid_io_error(io);
                        break;
                case PQI_RESPONSE_IU_AIO_PATH_IO_ERROR:
                        io->io_status = PQI_DATA_IN_OUT_ERROR;
                        sync_error(s, io, rsp);
                        process_aio_io_error(io);
                        break;
                case PQI_RESPONSE_IU_AIO_PATH_DISABLED:
                        io->io_status = PQI_DATA_IN_OUT_PROTOCOL_ERROR;
                        disable_aio_path(io);
                        break;

                default:
                        ASSERT(0);
                        break;
                }
                io->io_cb(io, io->io_context);
skipto:
                response_cnt++;
                oq_ci = (oq_ci + 1) % s->s_num_elements_per_oq;
        }

        if (response_cnt) {
                qg->cmplt_count += response_cnt;
                qg->oq_ci_copy = oq_ci;
                ddi_put32(s->s_datap, qg->oq_ci, oq_ci);
        }
        mutex_exit(&s->s_intr_mutex);

        mutex_enter(&s->s_mutex);
        qnotify = HBA_QUIESCED_PENDING(s);
        mutex_exit(&s->s_mutex);

        if (qnotify)
                pqi_quiesced_notify(s);

}

static int
add_intrs(pqi_state_t *s, int type)
{
        dev_info_t      *dip    = s->s_dip;
        int             avail;
        int             actual;
        int             count   = 0;
        int             i;
        int             ret;

        /* ---- Get number of interrupts ---- */
        ret = ddi_intr_get_nintrs(dip, type, &count);
        if (ret != DDI_SUCCESS || count <= 0) {
                dev_err(s->s_dip, CE_NOTE, "ddi_intr_get_nintrs failed, "
                    "ret=%d, count=%d", ret, count);
                return (FALSE);
        }

        /* ---- Get number of available interrupts ---- */
        ret = ddi_intr_get_navail(dip, type, &avail);
        if (ret != DDI_SUCCESS || avail == 0) {
                dev_err(s->s_dip, CE_NOTE, "ddi_intr_get_navail failed, "
                    "ret=%d, avail=%d", ret, avail);
                return (FALSE);
        }

        if (type != DDI_INTR_TYPE_FIXED)
                count = 1;

        s->s_intr_size = count * sizeof (ddi_intr_handle_t);
        s->s_itable = kmem_zalloc(s->s_intr_size, KM_SLEEP);
        ret = ddi_intr_alloc(dip, s->s_itable, type, 0, count, &actual,
            DDI_INTR_ALLOC_NORMAL);
        if (ret != DDI_SUCCESS || actual == 0) {
                dev_err(s->s_dip, CE_NOTE, "ddi_intr_alloc failed, ret=%d",
                    ret);
                return (FALSE);
        }

        /* ---- Use count return or abort? Make note of at least---- */
        if (actual < count) {
                dev_err(s->s_dip, CE_NOTE,
                    "interrupts: requested=%d, received=%d",
                    count, actual);
        }
        s->s_intr_cnt = actual;

        /* ---- Get priority for first intr, assume rest are the same ---- */
        if ((ret = ddi_intr_get_pri(s->s_itable[0], &s->s_intr_pri)) !=
            DDI_SUCCESS) {
                dev_err(s->s_dip, CE_NOTE, "ddi_intr_get_pri failed, ret=%d",
                    ret);
                goto failure;
        }

        /* ---- Test for high level mutex ---- */
        if (s->s_intr_pri >= ddi_intr_get_hilevel_pri()) {
                dev_err(s->s_dip, CE_NOTE, "Hi level interrupts not supported");
                goto failure;
        }

        /* ---- Install interrupt handler ---- */
        for (i = 0; i < actual; i++) {
                if ((ret = ddi_intr_add_handler(s->s_itable[i], intr_handler,
                    (caddr_t)s, (caddr_t)(uintptr_t)i)) != DDI_SUCCESS) {
                        dev_err(s->s_dip, CE_NOTE,
                            "ddi_intr_add_handler failed, index=%d, ret=%d",
                            i, ret);
                        goto failure;
                }
        }

        if ((ret = ddi_intr_get_cap(s->s_itable[0], &s->s_intr_cap))
            != DDI_SUCCESS) {
                dev_err(s->s_dip, CE_NOTE, "ddi_intr_get_cap failed, ret=%d",
                    ret);
                goto failure;
        }

        /* ---- Enable interrupts ---- */
        if (s->s_intr_cap & DDI_INTR_FLAG_BLOCK) {
                (void) ddi_intr_block_enable(s->s_itable, s->s_intr_cnt);
        } else {
                /* --- Enable interrupts for either MSI or FIXED ---- */
                for (i = 0; i < actual; i++)
                        (void) ddi_intr_enable(s->s_itable[i]);
        }

        return (TRUE);

failure:
        /* ---- Free allocated interrupts pointers ---- */
        for (i = 0; i < actual; i++)
                (void) ddi_intr_free(s->s_itable[i]);
        kmem_free(s->s_itable, s->s_intr_size);
        s->s_itable = NULL;
        s->s_intr_size = 0;
        return (FALSE);
}

static void
disable_aio_path(pqi_io_request_t *io)
{
        pqi_device_t    *devp;

        devp = io->io_cmd->pc_device;
        devp->pd_aio_enabled = 0;
}

static void
process_raid_io_error(pqi_io_request_t *io)
{
        pqi_raid_error_info_t   ei;
        pqi_cmd_t               *cmd;
        int                     sense_len;
        int                     statusbuf_len;
        int                     sense_len_to_copy;
        struct scsi_arq_status  *arq;
        struct scsi_pkt         *pkt;

        if ((ei = io->io_error_info) != NULL) {
                io->io_status = ei->data_out_result;
                if ((cmd = io->io_cmd) == NULL || cmd->pc_pkt == NULL)
                        return;

                pkt = cmd->pc_pkt;
                pkt->pkt_resid -= ei->data_out_transferred;
                /* LINTED E_BAD_PTR_CAST_ALIGN */
                arq = (struct scsi_arq_status *)pkt->pkt_scbp;
                *((uchar_t *)&arq->sts_status) = ei->status;
                *((uchar_t *)&arq->sts_rqpkt_status) = STATUS_GOOD;
                arq->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
                    STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS |
                    STATE_ARQ_DONE;

                sense_len = ei->sense_data_length;
                if (sense_len == 0)
                        sense_len = ei->response_data_length;

                if (sense_len == 0) {
                        /* ---- auto request sense failed ---- */
                        arq->sts_rqpkt_status.sts_chk = 1;
                        arq->sts_rqpkt_resid = cmd->pc_statuslen;
                        return;
                } else if (sense_len < cmd->pc_statuslen) {
                        /* ---- auto request sense short ---- */
                        arq->sts_rqpkt_resid = cmd->pc_statuslen -
                            sense_len;
                } else {
                        /* ---- auto request sense complete ---- */
                        arq->sts_rqpkt_resid = 0;
                }
                arq->sts_rqpkt_statistics = 0;
                pkt->pkt_state |= STATE_ARQ_DONE;
                if (cmd->pc_statuslen > PQI_ARQ_STATUS_NOSENSE_LEN) {
                        statusbuf_len = cmd->pc_statuslen -
                            PQI_ARQ_STATUS_NOSENSE_LEN;
                } else {
                        statusbuf_len = 0;
                }

                if (sense_len > sizeof (ei->data))
                        sense_len = sizeof (ei->data);
                sense_len_to_copy = min(sense_len, statusbuf_len);

                if (sense_len_to_copy) {
                        (void) memcpy(&arq->sts_sensedata, ei->data,
                            sense_len_to_copy);
                }
        } else {
                /*
                 * sync_error is called before this and sets io_error_info
                 * which means the value must be non-zero
                 */
                ASSERT(0);
        }
}

static void
process_aio_io_error(pqi_io_request_t *io __unused)
{
}

static void
sync_error(pqi_state_t *s, pqi_io_request_t *io, pqi_io_response_t *rsp)
{
        (void) ddi_dma_sync(s->s_error_dma->handle,
            rsp->error_index * PQI_ERROR_BUFFER_ELEMENT_LENGTH,
            PQI_ERROR_BUFFER_ELEMENT_LENGTH, DDI_DMA_SYNC_FORCPU);

        io->io_error_info = s->s_error_dma->alloc_memory +
            (rsp->error_index * PQI_ERROR_BUFFER_ELEMENT_LENGTH);
}

static void
process_event_intr(pqi_state_t *s)
{
        pqi_event_queue_t       *q = &s->s_event_queue;
        pqi_event_response_t    *rsp;
        int                     idx;
        int                     num_events      = 0;
        pqi_event_t             *e;
        pqi_index_t             oq_ci;
        pqi_index_t             oq_pi;

        oq_ci = q->oq_ci_copy;

        mutex_enter(&s->s_intr_mutex);
        for (;;) {
                (void) ddi_dma_sync(s->s_queue_dma->handle,
                    (uintptr_t)q->oq_pi -
                    (uintptr_t)s->s_queue_dma->alloc_memory,
                    sizeof (oq_pi), DDI_DMA_SYNC_FORCPU);
                oq_pi = *q->oq_pi;

                if (oq_pi == oq_ci)
                        break;

                num_events++;
                (void) ddi_dma_sync(s->s_queue_dma->handle,
                    (uintptr_t)q->oq_element_array +
                    (oq_ci * PQI_EVENT_OQ_ELEMENT_LENGTH) -
                    (uintptr_t)s->s_queue_dma->alloc_memory,
                    sizeof (*rsp),
                    DDI_DMA_SYNC_FORCPU);
                rsp = (pqi_event_response_t *)((uintptr_t)q->oq_element_array +
                    (oq_ci * PQI_EVENT_OQ_ELEMENT_LENGTH));
                idx = pqi_map_event(rsp->event_type);

                if (idx != -1 && rsp->request_acknowlege) {
                        e = &s->s_events[idx];
                        e->ev_pending = B_TRUE;
                        e->ev_type = rsp->event_type;
                        e->ev_id = rsp->event_id;
                        e->ev_additional = rsp->additional_event_id;
                }
                oq_ci = (oq_ci + 1) % PQI_NUM_EVENT_QUEUE_ELEMENTS;
        }

        if (num_events != 0) {
                q->oq_ci_copy = oq_ci;
                ddi_put32(s->s_datap, q->oq_ci, oq_ci);
                (void) ddi_taskq_dispatch(s->s_events_taskq, pqi_event_worker,
                    s, 0);
        }
        mutex_exit(&s->s_intr_mutex);
}

static uint_t
intr_handler(caddr_t arg1, caddr_t arg2)
{
        pqi_state_t             *s = (pqi_state_t *)arg1;
        int                     queue_group_idx = (int)(intptr_t)arg2;
        pqi_queue_group_t       *qg;

        if (!s->s_intr_ready)
                return (DDI_INTR_CLAIMED);

        qg = &s->s_queue_groups[queue_group_idx];
        pqi_process_io_intr(s, qg);
        if (queue_group_idx == s->s_event_queue.int_msg_num)
                process_event_intr(s);

        pqi_start_io(s, qg, RAID_PATH, NULL);
        pqi_start_io(s, qg, AIO_PATH, NULL);

        return (DDI_INTR_CLAIMED);
}