/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at
 * http://www.opensource.org/licenses/cddl1.txt.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004-2012 Emulex. All rights reserved.
 * Use is subject to license terms.
 */

#include <emlxs.h>


/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
EMLXS_MSG_DEF(EMLXS_DIAG_C);

uint32_t emlxs_diag_pattern[256] = {
        /* Walking ones */
        0x80000000, 0x40000000, 0x20000000, 0x10000000,
        0x08000000, 0x04000000, 0x02000000, 0x01000000,
        0x00800000, 0x00400000, 0x00200000, 0x00100000,
        0x00080000, 0x00040000, 0x00020000, 0x00010000,
        0x00008000, 0x00004000, 0x00002000, 0x00001000,
        0x00000800, 0x00000400, 0x00000200, 0x00000100,
        0x00000080, 0x00000040, 0x00000020, 0x00000010,
        0x00000008, 0x00000004, 0x00000002, 0x00000001,

        /* Walking zeros */
        0x7fffffff, 0xbfffffff, 0xdfffffff, 0xefffffff,
        0xf7ffffff, 0xfbffffff, 0xfdffffff, 0xfeffffff,
        0xff7fffff, 0xffbfffff, 0xffdfffff, 0xffefffff,
        0xfff7ffff, 0xfffbffff, 0xfffdffff, 0xfffeffff,
        0xffff7fff, 0xffffbfff, 0xffffdfff, 0xffffefff,
        0xfffff7ff, 0xfffffbff, 0xfffffdff, 0xfffffeff,
        0xffffff7f, 0xffffffbf, 0xffffffdf, 0xffffffef,
        0xfffffff7, 0xfffffffb, 0xfffffffd, 0xfffffffe,

        /* all zeros */
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
        0x00000000, 0x00000000, 0x00000000, 0x00000000,

        /* all ones */
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,

        /* all 5's */
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,
        0x55555555, 0x55555555, 0x55555555, 0x55555555,

        /* all a's */
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
        0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,

        /* all 5a's */
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,
        0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a, 0x5a5a5a5a,

        /* all a5's */
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5,
        0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5
};


/* Default pkt callback routine */
static void
emlxs_diag_pkt_callback(fc_packet_t *pkt)
{
        emlxs_port_t *port = (emlxs_port_t *)pkt->pkt_ulp_private;

        /* Set the completed flag and wake up sleeping threads */
        mutex_enter(&EMLXS_PKT_LOCK);
        pkt->pkt_tran_flags |= FC_TRAN_COMPLETED;
        cv_broadcast(&EMLXS_PKT_CV);
        mutex_exit(&EMLXS_PKT_LOCK);

        return;

} /* emlxs_diag_pkt_callback() */


extern uint32_t
emlxs_diag_echo_run(emlxs_port_t *port, uint32_t did, uint32_t pattern)
{
        emlxs_hba_t *hba = HBA;
        uint32_t i = 0;
        uint32_t rval = FC_SUCCESS;
        int32_t pkt_ret;
        fc_packet_t *pkt;
        ELS_PKT *els;
        clock_t timeout;
        uint8_t *pkt_resp;
        char *pattern_buffer;
        uint32_t length;
        uint32_t *lptr;
        NODELIST *ndlp;
        uint8_t *pat;

        /* Check did */
        if (did == 0) {
                did = port->did;
        }

        /* Check if device is ready */
        if ((hba->state < FC_LINK_UP) || (port->did == 0)) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "ECHO: HBA not ready.");

                return (FC_TRAN_BUSY);
        }

        /* Check for the host node */
        ndlp = emlxs_node_find_did(port, port->did, 1);

        if (!ndlp || !ndlp->nlp_active) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "ECHO: HBA not ready.");

                return (FC_TRAN_BUSY);
        }

        length = 124;

        /* Prepare ECHO pkt */
        if (!(pkt = emlxs_pkt_alloc(port, sizeof (uint32_t) + length,
            sizeof (uint32_t) + length, 0, KM_NOSLEEP))) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "ECHO: Unable to allocate packet. size=%x",
                    sizeof (uint32_t) + length);

                return (FC_NOMEM);
        }

        /* pkt initialization */
        pkt->pkt_tran_type = FC_PKT_EXCHANGE;
        pkt->pkt_timeout = 60;

        /* Build the fc header */
        pkt->pkt_cmd_fhdr.d_id = did;
        pkt->pkt_cmd_fhdr.r_ctl = R_CTL_EXTENDED_SVC | R_CTL_UNSOL_CONTROL;
        pkt->pkt_cmd_fhdr.s_id = port->did;
        pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
        pkt->pkt_cmd_fhdr.f_ctl =
            F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE | F_CTL_END_SEQ;
        pkt->pkt_cmd_fhdr.seq_id = 0;
        pkt->pkt_cmd_fhdr.df_ctl = 0;
        pkt->pkt_cmd_fhdr.seq_cnt = 0;
        pkt->pkt_cmd_fhdr.ox_id = 0xffff;
        pkt->pkt_cmd_fhdr.rx_id = 0xffff;
        pkt->pkt_cmd_fhdr.ro = 0;
        pkt->pkt_comp = emlxs_diag_pkt_callback;

        /* Build the command */
        els = (ELS_PKT *) pkt->pkt_cmd;
        els->elsCode = 0x10;
        pattern_buffer = (char *)els->un.pad;

        if (pattern) {
                /* Fill the transmit buffer with the pattern */
                lptr = (uint32_t *)pattern_buffer;

                for (i = 0; i < length; i += 4) {
                        *lptr++ = pattern;
                }
        } else {
                /* Program the default echo pattern */
                bzero(pattern_buffer, length);
                (void) snprintf(pattern_buffer, length,
                    "Emulex. We network storage. Emulex. We network storage. "
                    "Emulex. We network storage. Emulex. We network storage.");
        }

        /* Send ECHO pkt */
        if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "ECHO: Packet send failed.");

                goto done;
        }

        /* Wait for ECHO completion */
        mutex_enter(&EMLXS_PKT_LOCK);
        timeout = emlxs_timeout(hba, (pkt->pkt_timeout + 15));
        pkt_ret = 0;
        while ((pkt_ret != -1) && !(pkt->pkt_tran_flags & FC_TRAN_COMPLETED)) {
                pkt_ret =
                    cv_timedwait(&EMLXS_PKT_CV, &EMLXS_PKT_LOCK, timeout);

        }
        mutex_exit(&EMLXS_PKT_LOCK);

        if (pkt_ret == -1) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
                    "Packet timed out.");

                return (FC_ABORTED);
        }

        if (pkt->pkt_state != FC_PKT_SUCCESS) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
                    "Transport error.");

                rval = FC_TRANSPORT_ERROR;
                goto done;
        }

        /* Check response payload */
        pkt_resp = (uint8_t *)pkt->pkt_resp + 4;
        pat = (uint8_t *)pattern_buffer;
        rval = FC_SUCCESS;

        for (i = 0; i < length; i++, pkt_resp++, pat++) {
                if (*pkt_resp != *pat) {
                        EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
                            "Data miscompare. did=%06x length=%d. Offset %d "
                            "value %02x should be %02x.", did, length, i,
                            *pkt_resp, *pat);

                        rval = EMLXS_TEST_FAILED;

                        break;
                }
        }

        if (rval == FC_SUCCESS) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_complete_msg,
                    "did=%06x  length=%d  pattern=%02x,%02x,%02x,%02x...",
                    did, length, pattern_buffer[0] & 0xff,
                    pattern_buffer[1] & 0xff, pattern_buffer[2] & 0xff,
                    pattern_buffer[3] & 0xff);
        }

done:

        /* Free the echo pkt */
        emlxs_pkt_free(pkt);

        return (rval);

} /* emlxs_diag_echo_run() */


extern uint32_t
emlxs_diag_biu_run(emlxs_hba_t *hba, uint32_t pattern)
{
        emlxs_port_t *port = &PPORT;
        MAILBOXQ *mbq = NULL;
        MATCHMAP *mp = NULL;
        MATCHMAP *mp1 = NULL;
        uint32_t i;
        uint8_t *inptr;
        uint8_t *outptr;
        int32_t rval = FC_SUCCESS;
        uint32_t *lptr;

        /* Check if device is ready */
        if (hba->state < FC_LINK_DOWN) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "BIU: HBA not ready.");

                return (FC_TRAN_BUSY);
        }

        /*
         * Get a buffer which will be used for the mailbox command
         */
        if ((mbq = (MAILBOXQ *) emlxs_mem_get(hba, MEM_MBOX)) == 0) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "BIU: Mailbox allocation failed.");

                rval = FC_NOMEM;
                goto done;
        }

        /*
         * Setup and issue mailbox RUN BIU DIAG command Setup test buffers
         */
        if (((mp = (MATCHMAP *) emlxs_mem_get(hba, MEM_BUF)) == 0) ||
            ((mp1 = (MATCHMAP *) emlxs_mem_get(hba, MEM_BUF)) == 0)) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "BIU: Buffer allocation failed.");

                rval = FC_NOMEM;
                goto done;
        }

        if (pattern) {
                /* Fill the transmit buffer with the pattern */
                lptr = (uint32_t *)mp->virt;

                for (i = 0; i < MEM_ELSBUF_SIZE; i += 4) {
                        *lptr++ = pattern;
                }
        } else {
                /* Copy the default pattern into the trasmit buffer */
                bcopy((caddr_t)&emlxs_diag_pattern[0], (caddr_t)mp->virt,
                    MEM_ELSBUF_SIZE);
        }
        EMLXS_MPDATA_SYNC(mp->dma_handle, 0, MEM_ELSBUF_SIZE,
            DDI_DMA_SYNC_FORDEV);

        bzero(mp1->virt, MEM_ELSBUF_SIZE);
        EMLXS_MPDATA_SYNC(mp1->dma_handle, 0, MEM_ELSBUF_SIZE,
            DDI_DMA_SYNC_FORDEV);

        /* Create the biu diag request */
        (void) emlxs_mb_run_biu_diag(hba, mbq, mp->phys, mp1->phys);

        rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 60);

        if (rval == MBX_TIMEOUT) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_failed_msg,
                    "BUI diagnostic timed out.");

                rval = EMLXS_TEST_FAILED;
                goto done;
        }

        EMLXS_MPDATA_SYNC(mp1->dma_handle, 0, MEM_ELSBUF_SIZE,
            DDI_DMA_SYNC_FORKERNEL);

        outptr = mp->virt;
        inptr = mp1->virt;

        for (i = 0; i < MEM_ELSBUF_SIZE; i++, outptr++, inptr++) {
                if (*outptr != *inptr) {
                        EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_failed_msg,
                            "Data miscompare. Offset %d value %02x should "
                            "be %02x.", i, *inptr, *outptr);

                        rval = EMLXS_TEST_FAILED;
                        goto done;
                }
        }

        /* Wait half second before returning */
        delay(drv_usectohz(500000));
        rval = FC_SUCCESS;

        EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_complete_msg, "Status Good.");

done:

        if (mp) {
#ifdef FMA_SUPPORT
                if (emlxs_fm_check_dma_handle(hba, mp->dma_handle)
                    != DDI_FM_OK) {
                        EMLXS_MSGF(EMLXS_CONTEXT,
                            &emlxs_invalid_dma_handle_msg,
                            "diag_biu_run: hdl=%p",
                            mp->dma_handle);
                        rval = EMLXS_TEST_FAILED;
                }
#endif  /* FMA_SUPPORT */
                emlxs_mem_put(hba, MEM_BUF, (void *)mp);
        }
        if (mp1) {
#ifdef FMA_SUPPORT
                if (emlxs_fm_check_dma_handle(hba, mp1->dma_handle)
                    != DDI_FM_OK) {
                        EMLXS_MSGF(EMLXS_CONTEXT,
                            &emlxs_invalid_dma_handle_msg,
                            "diag_biu_run: hdl=%p",
                            mp1->dma_handle);
                        rval = EMLXS_TEST_FAILED;
                }
#endif  /* FMA_SUPPORT */
                emlxs_mem_put(hba, MEM_BUF, (void *)mp1);
        }
        if (mbq) {
                emlxs_mem_put(hba, MEM_MBOX, (void *)mbq);
        }

        return (rval);

} /* emlxs_diag_biu_run() */


extern uint32_t
emlxs_diag_post_run(emlxs_hba_t *hba)
{
        emlxs_port_t *port = &PPORT;
        uint32_t rval = FC_SUCCESS;

        if (hba->flag & (FC_OFFLINE_MODE | FC_OFFLINING_MODE)) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "POST: HBA shutdown.");

                return (FC_TRAN_BUSY);
        }

        /* Take board offline */
        if ((rval = emlxs_offline(hba, 0))) {
                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_failed_msg,
                    "Unable to take adapter offline.");

                rval = FC_RESETFAIL;
        }

        /* Restart the adapter */
        rval = EMLXS_SLI_HBA_RESET(hba, 1, 1, 0);

        switch (rval) {
        case 0:

                (void) emlxs_online(hba);

                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_complete_msg,
                    "Status good.");

                rval = FC_SUCCESS;

                break;

        case 1: /* failed */

                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_failed_msg,
                    "HBA reset failed.");

                rval = FC_RESETFAIL;

                break;


        case 2: /* failed */

                EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
                    "HBA busy. Quiece and retry.");

                rval = FC_STATEC_BUSY;

                break;

        }

        return (rval);

} /* emlxs_diag_post_run() */