/*
 * 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 (C) 2013 Hewlett-Packard Development Company, L.P.
 */

#include "cpqary3.h"

/*
 * Function     :       cpqary3_hw_isr
 * Description  :       This routine determines if this instance of the
 *                      HBA interrupted and if positive triggers a software
 *                      interrupt.
 *                      For SAS controllers which operate in performant mode
 *                      we clear the interrupt.
 *                      For CISS controllers which operate in simple mode
 *                      we get the tag value.
 * Called By    :       kernel
 * Parameters   :       per-controller
 * Calls        :       cpqary3_check_ctlr_intr()
 * Return Values:       DDI_INTR_CLAIMED/UNCLAIMED
 *                      [We either CLAIM the interrupt or Discard it]
 */
uint_t
cpqary3_hw_isr(caddr_t per_ctlr)
{
        uint8_t                 need_swintr;
        cpqary3_t               *cpqary3p;
        cpqary3_drvr_replyq_t   *replyq_ptr;
        volatile CfgTable_t     *ctp;
        uint32_t                spr0;
        uint32_t                doorbell_status;
        uint32_t                tag;

        cpqary3p = (void *)per_ctlr;
        ctp = (CfgTable_t *)cpqary3p->ct;
        replyq_ptr = (cpqary3_drvr_replyq_t *)cpqary3p->drvr_replyq;

        if (CPQARY3_FAILURE == cpqary3p->check_ctlr_intr(cpqary3p)) {
                if (cpqary3p->heartbeat ==
                    DDI_GET32(cpqary3p, &ctp->HeartBeat)) {
                        if (0x2 & ddi_get32(cpqary3p->odr_handle,
                            (uint32_t *)cpqary3p->odr)) {
                                spr0 = ddi_get32(cpqary3p->spr0_handle,
                                    (uint32_t *)cpqary3p->spr0);
                                spr0 = spr0 >> 16;
                                cmn_err(CE_WARN, "CPQary3 : %s HBA firmware "
                                    "Locked !!!  Lockup Code: 0x%x",
                                    cpqary3p->hba_name, spr0);
                                cmn_err(CE_WARN, "CPQary3 : Please reboot "
                                    "the system");
                                ddi_put32(cpqary3p->odr_cl_handle,
                                    (uint32_t *)cpqary3p->odr_cl, 0x2);
                                cpqary3_intr_onoff(cpqary3p,
                                    CPQARY3_INTR_DISABLE);
                                if (cpqary3p->host_support & 0x4) {
                                        cpqary3_lockup_intr_onoff(cpqary3p,
                                            CPQARY3_LOCKUP_INTR_DISABLE);
                                }
                                cpqary3p->controller_lockup = CPQARY3_TRUE;
                        }
                        return (DDI_INTR_CLAIMED);
                }
                return (DDI_INTR_UNCLAIMED);
        }

        /* PERF */

        /*
         * We decided that we will have only one retrieve function for
         * both simple and performant mode. To achieve this we have to mimic
         * what controller does for performant mode in simple mode.
         * For simple mode we are making replq_simple_ptr and
         * replq_headptr of performant
         * mode point to the same location in the reply queue.
         * For the performant mode, we clear the interrupt
         */

        if (!(cpqary3p->bddef->bd_flags & SA_BD_SAS)) {
                while ((tag = ddi_get32(cpqary3p->opq_handle,
                    (uint32_t *)cpqary3p->opq)) != 0xFFFFFFFF) {
                        replyq_ptr->replyq_simple_ptr[0] = tag;
                        replyq_ptr->replyq_simple_ptr[0] |=
                            replyq_ptr->simple_cyclic_indicator;
                        ++replyq_ptr->simple_index;

                        if (replyq_ptr->simple_index == replyq_ptr->max_index) {
                                replyq_ptr->simple_index = 0;
                                /* Toggle at wraparound */
                                replyq_ptr->simple_cyclic_indicator =
                                    (replyq_ptr->simple_cyclic_indicator == 0) ?
                                    1 : 0;
                                replyq_ptr->replyq_simple_ptr =
                                    /* LINTED: alignment */
                                    (uint32_t *)(replyq_ptr->replyq_start_addr);
                        } else {
                                replyq_ptr->replyq_simple_ptr += 2;
                        }
                }
        } else {
                doorbell_status = ddi_get32(cpqary3p->odr_handle,
                    (uint32_t *)cpqary3p->odr);
                if (doorbell_status & 0x1) {
                        ddi_put32(cpqary3p->odr_cl_handle,
                            (uint32_t *)cpqary3p->odr_cl,
                            (ddi_get32(cpqary3p->odr_cl_handle,
                            (uint32_t *)cpqary3p->odr_cl) | 0x1));
                        doorbell_status = ddi_get32(cpqary3p->odr_handle,
                            (uint32_t *)cpqary3p->odr);
                }
        }

        /* PERF */

        /*
         * If s/w interrupt handler is already running, do not trigger another
         * since packets have already been transferred to Retrieved Q.
         * Else, Set swintr_flag to state to the s/w interrupt handler
         * that it has a job to do.
         * trigger the s/w interrupt handler
         * Claim the interrupt
         */

        mutex_enter(&cpqary3p->hw_mutex);

        if (cpqary3p->swintr_flag == CPQARY3_TRUE) {
                need_swintr = CPQARY3_FALSE;
        } else {
                need_swintr = CPQARY3_TRUE;
                cpqary3p->swintr_flag = CPQARY3_TRUE;
        }

        mutex_exit(&cpqary3p->hw_mutex);

        if (CPQARY3_TRUE == need_swintr)
                ddi_trigger_softintr(cpqary3p->cpqary3_softintr_id);

        return (DDI_INTR_CLAIMED);
}

/*
 * Function     :       cpqary3_sw_isr
 * Description  :       This routine determines if this instance of the
 *                      software interrupt handler was triggered by its
 *                      respective h/w interrupt handler and if affermative
 *                      processes the completed commands.
 * Called By    :       kernel (Triggered by : cpqary3_hw_isr)
 * Parameters   :       per-controller
 * Calls        :       cpqary3_retrieve()
 * Return Values:       DDI_INTR_CLAIMED/UNCLAIMED
 *                      [We either CLAIM the interrupr or DON'T]
 */
uint_t
cpqary3_sw_isr(caddr_t per_ctlr)
{
        cpqary3_t       *cpqary3p;

        cpqary3p = (void *)per_ctlr;
        if (!cpqary3p) {
                cmn_err(CE_PANIC, "CPQary3 : Software Interrupt Service "
                    "Routine invoked with NULL pointer argument \n");
        }

        /*
         * Ensure that our hardware routine actually triggered this routine.
         * If it was not the case, do NOT CLAIM the interrupt
         */

        mutex_enter(&cpqary3p->hw_mutex);
        if (CPQARY3_TRUE != cpqary3p->swintr_flag) {
                mutex_exit(&cpqary3p->hw_mutex);
                return (DDI_INTR_UNCLAIMED);
        }

        cpqary3p->swintr_flag = CPQARY3_FALSE;

        /* PERF */
        mutex_exit(&cpqary3p->hw_mutex);
        (void) cpqary3_retrieve(cpqary3p);
        /* PERF */

        return (DDI_INTR_CLAIMED);
}