/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * ISSUES
 */

#include <sys/scsi/scsi.h>
#include <sys/note.h>
#include <sys/scsi/adapters/fasreg.h>
#include <sys/scsi/adapters/fasvar.h>
#include <sys/scsi/adapters/fascmd.h>

#include <sys/vtrace.h>

#ifdef  FASDEBUG
extern int  fasdebug;
extern int  fasdebug_instance; /* debug all instances */
#endif  /* FASDEBUG */

void fas_complete_arq_pkt(struct scsi_pkt *pkt);
void fas_call_pkt_comp(register struct fas *fas,
    register struct fas_cmd *sp);
void fas_empty_callbackQ(struct fas *fas);
int fas_init_callbacks(struct fas *fas);
void fas_destroy_callbacks(struct fas *fas);
void fas_printf(struct fas *fas, const char *fmt, ...);

int
fas_init_callbacks(struct fas *fas)
{
        mutex_init(&fas->f_c_mutex, NULL, MUTEX_DRIVER, fas->f_iblock);

        return (0);
}

void
fas_destroy_callbacks(struct fas *fas)
{
        mutex_destroy(&fas->f_c_mutex);
}

void
fas_empty_callbackQ(struct fas *fas)
{
        register struct fas_cmd *sp;

        TRACE_0(TR_FAC_SCSI, TR_FAS_EMPTY_CALLBACKQ_START,
            "fas_empty_callbackQ_start");

        mutex_enter(&fas->f_c_mutex);

        /*
         * don't recurse into calling back: the target driver
         * may call scsi_transport() again which may call
         * fas_empty_callbackQ again
         */
        if (fas->f_c_in_callback) {
                goto done;
        }
        fas->f_c_in_callback = 1;

        while (fas->f_c_qf) {
                register struct fas_cmd *qf = fas->f_c_qf;

                fas->f_c_qf = fas->f_c_qb = NULL;
                mutex_exit(&fas->f_c_mutex);

                while (qf) {
                        sp = qf;
                        qf =   sp->cmd_forw;
                        (*sp->cmd_pkt->pkt_comp)(sp->cmd_pkt);
                }

                mutex_enter(&fas->f_c_mutex);
        }

        fas->f_c_in_callback = 0;
done:
        mutex_exit(&fas->f_c_mutex);

        TRACE_0(TR_FAC_SCSI, TR_FAS_EMPTY_CALLBACKQ_END,
            "fas_empty_callbackQ_end");
}


/*
 * fas_call_pkt_comp does sanity checking to ensure that we don't
 * call completion twice on the same packet or a packet that has been freed.
 * if there is a completion function specified, the packet is queued
 * up and it is left to the fas_callback thread to empty the queue at
 * a lower priority; note that there is one callback queue per fas
 *
 * we use a separate thread for calling back into the target driver
 * this thread unqueues packets from the callback queue
 */
void
fas_call_pkt_comp(register struct fas *fas, register struct fas_cmd *sp)
{
        TRACE_0(TR_FAC_SCSI, TR_FAS_CALL_PKT_COMP_START,
            "fas_call_pkt_comp_start");

        ASSERT(sp != 0);
        ASSERT((sp->cmd_flags & CFLAG_COMPLETED) == 0);
        ASSERT((sp->cmd_flags & CFLAG_FREE) == 0);
        ASSERT(sp->cmd_flags & CFLAG_FINISHED);
        ASSERT(fas->f_ncmds >= fas->f_ndisc);
        ASSERT((sp->cmd_flags & CFLAG_CMDDISC) == 0);
        ASSERT(sp != fas->f_current_sp);
        ASSERT(sp != fas->f_active[sp->cmd_slot]->f_slot[sp->cmd_tag[1]]);

        sp->cmd_flags &= ~CFLAG_IN_TRANSPORT;
        sp->cmd_flags |= CFLAG_COMPLETED;
        sp->cmd_qfull_retries = 0;

        /*
         * if this was an auto request sense, complete immediately to free
         * the arq pkt
         */
        if (sp->cmd_pkt->pkt_comp && !(sp->cmd_flags & CFLAG_CMDARQ)) {

                if (sp->cmd_pkt->pkt_reason != CMD_CMPLT) {
                        IPRINTF6("completion for %d.%d, sp=0x%p, "
                            "reason=%s, stats=%x, state=%x\n",
                                Tgt(sp), Lun(sp), (void *)sp,
                                scsi_rname(sp->cmd_pkt->pkt_reason),
                                sp->cmd_pkt->pkt_statistics,
                                sp->cmd_pkt->pkt_state);
                } else {
                        EPRINTF2("completion queued for %d.%dn",
                                Tgt(sp), Lun(sp));
                }

                /*
                 * append the packet or start a new queue
                 */
                mutex_enter(&fas->f_c_mutex);
                if (fas->f_c_qf) {
                        /*
                         * add to tail
                         */
                        register struct fas_cmd *dp = fas->f_c_qb;
                        ASSERT(dp != NULL);
                        fas->f_c_qb =   sp;
                        sp->cmd_forw = NULL;
                        dp->cmd_forw = sp;
                } else {
                        /*
                         * start new queue
                         */
                        fas->f_c_qf = fas->f_c_qb = sp;
                        sp->cmd_forw = NULL;
                }
                mutex_exit(&fas->f_c_mutex);

        } else if ((sp->cmd_flags & CFLAG_CMDARQ) && sp->cmd_pkt->pkt_comp) {
                /*
                 * pkt_comp may be NULL when we are aborting/resetting but then
                 * the callback will be redone later
                 */
                fas_complete_arq_pkt(sp->cmd_pkt);

        } else  {
                EPRINTF2("No completion routine for 0x%p reason %x\n",
                    (void *)sp, sp->cmd_pkt->pkt_reason);
        }
        TRACE_0(TR_FAC_SCSI, TR_FAS_CALL_PKT_COMP_END,
            "fas_call_pkt_comp_end");
}