/*
 * 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 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * scsa2usb_ms_cbi.c:
 *
 * This file implements USB Mass Storage Class
 * Control Bulk Interrupt (CB/CBI) transport v1.0
 * http://www.usb.org/developers/data/devclass/usbmass-cbi10.pdf
 */
#include <sys/usb/usba/usbai_version.h>
#include <sys/scsi/scsi.h>
#include <sys/callb.h>          /* needed by scsa2usb.h */
#include <sys/strsubr.h>

#include <sys/usb/usba.h>
#include <sys/usb/usba/usba_private.h>
#include <sys/usb/usba/usba_ugen.h>

#include <sys/usb/clients/mass_storage/usb_cbi.h>
#include <sys/usb/scsa2usb/scsa2usb.h>

/*
 * Function Prototypes
 */
int             scsa2usb_cbi_transport(scsa2usb_state_t *, scsa2usb_cmd_t *);
static int      scsa2usb_handle_cbi_status(usb_intr_req_t *);
static void     scsa2usb_cbi_reset_recovery(scsa2usb_state_t *);
static void     scsa2usb_cbi_handle_error(scsa2usb_state_t *, int, usb_cr_t);
static usb_intr_req_t *scsa2usb_cbi_start_intr_polling(scsa2usb_state_t *);
void            scsa2usb_cbi_stop_intr_polling(scsa2usb_state_t *);

/* extern functions */
extern void     scsa2usb_setup_next_xfer(scsa2usb_state_t *, scsa2usb_cmd_t *);
extern int      scsa2usb_handle_data_start(scsa2usb_state_t *,
                    scsa2usb_cmd_t *, usb_bulk_req_t *);
extern void     scsa2usb_handle_data_done(scsa2usb_state_t *, scsa2usb_cmd_t *,
                    usb_bulk_req_t *);
extern usb_bulk_req_t *scsa2usb_init_bulk_req(scsa2usb_state_t *,
                            size_t, uint_t, usb_req_attrs_t, usb_flags_t);
extern int      scsa2usb_clear_ept_stall(scsa2usb_state_t *, uint_t,
                    usb_pipe_handle_t, char *);
extern void     scsa2usb_close_usb_pipes(scsa2usb_state_t *);

#ifdef DEBUG    /* debugging information */
extern void     scsa2usb_print_cdb(scsa2usb_state_t *, scsa2usb_cmd_t *);
#endif  /* DEBUG */


/*
 * scsa2usb_cbi_transport:
 *      Implements the CB/CBI state machine by these steps:
 *      a) Issues command to the device over control pipe.
 *      b) Start Data Phase if applicable
 *      c) Start Status Phase
 *
 *      returns TRAN_* values and not USB_SUCCESS/FAILURE
 *
 * scsa2usb_cbi_transport() handles the normal transitions or
 * continuation after clearing stalls or error recovery.
 *
 * Command Phase:
 *      prepare a valid command and transport it on default pipe
 *      if error on default-pipe:
 *              set pkt_reason to CMD_TRAN_ERR
 *              new pkt state is SCSA2USB_PKT_DO_COMP
 *              do reset recovery synchronously
 *      else
 *              proceed to data phase
 *
 * Data Phase:
 *      if data in:
 *              setup data in on bulkin
 *      else if data out:
 *              setup data out on bulkout
 *
 *      data: (in)
 *              copy data transferred so far, no more data to transfer
 *
 *              if stall on bulkin pipe
 *                      terminate data transfers, set cmd_done
 *                      clear stall on bulkin syncrhonously
 *              else if other exception
 *                      set pkt_reason to CMD_TRAN_ERR
 *                      new pkt state is SCSA2USB_PKT_DO_COMP
 *                      do reset recovery synchronously
 *              else (no error)
 *                      receive status
 *
 *       data: (out)
 *              if stall on bulkout pipe
 *                      terminate data transfers
 *                      clear stall on bulkout synchronously USBA
 *              else if other exception
 *                      set pkt_reason to CMD_TRAN_ERR
 *                      new pkt state is SCSA2USB_PKT_DO_COMP
 *                      do reset recovery synchronously
 *              else (no error)
 *                      receive status
 *
 * Status Phase: (on Interrupt pipe for CBI devices only)
 *      if error
 *              if stall
 *                      new pkt state is SCSA2USB_PKT_DO_COMP
 *                      clear stall on interrupt pipe
 *              else
 *                      set pkt_reason to CMD_TRAN_ERR
 *                      new pkt state is SCSA2USB_PKT_DO_COMP
 *                      do reset recovery synchronously
 *      else (no error)
 *              goto read status
 *
 * read status:
 *      if not OK or phase error
 *              new pkt state is SCSA2USB_PKT_DO_COMP
 *              set pkt reason CMD_TRAN_ERR
 *              reset recovery synchronously
 *      else (status ok)
 *              goto  SCSA2USB_PKT_DO_COMP
 *
 * The reset recovery walks sequentially thru device reset, clearing
 * stalls and pipe resets. When the reset recovery completes we return
 * to the taskq thread.
 *
 * Clearing stalls clears the stall condition, resets the pipe, and
 * then returns to the transport.
 */
int
scsa2usb_cbi_transport(scsa2usb_state_t *scsa2usbp, scsa2usb_cmd_t *cmd)
{
        int                     i, rval = TRAN_ACCEPT;
        mblk_t                  *data;
        usb_cr_t                completion_reason;
        usb_cb_flags_t          cb_flags;
        usb_bulk_req_t          *data_req;
        usb_intr_req_t          *status_req;

        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_cbi_transport: cmd = 0x%p", (void *)cmd);
        ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));

Cmd_Phase:
        if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {

                return (TRAN_FATAL_ERROR);
        }

        /*
         * Start command phase (C - in CBI)
         */
        data = allocb_wait(CBI_CLASS_CMD_LEN, BPRI_LO, STR_NOSIG, NULL);

        /* Initialize the data */
        for (i = 0; i < CBI_CLASS_CMD_LEN; i++) {
                *data->b_wptr++ = cmd->cmd_cdb[i];
        }

        SCSA2USB_PRINT_CDB(scsa2usbp, cmd);     /* print the CDB */

        /* Send the Command to the device */
        mutex_exit(&scsa2usbp->scsa2usb_mutex);
        rval = usb_pipe_sync_ctrl_xfer(scsa2usbp->scsa2usb_dip,
            scsa2usbp->scsa2usb_default_pipe,
            CBI_REQUEST_TYPE,                   /* bmRequestType */
            0,                                  /* bRequest */
            CBI_WVALUE,                         /* wValue */
            scsa2usbp->scsa2usb_intfc_num,      /* wIndex */
            CBI_CLASS_CMD_LEN,                  /* wLength */
            &data,                              /* data */
            USB_ATTRS_PIPE_RESET,               /* attributes */
            &completion_reason, &cb_flags, USB_FLAGS_SLEEP);
        mutex_enter(&scsa2usbp->scsa2usb_mutex);

        USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_cbi_transport: sent cmd = 0x%x  rval = %d",
            cmd->cmd_cdb[SCSA2USB_OPCODE], rval);

        SCSA2USB_FREE_MSG(data);        /* get rid of the data */
        if (rval != USB_SUCCESS) {
                scsa2usb_cbi_handle_error(scsa2usbp, rval, completion_reason);

                return (TRAN_FATAL_ERROR);
        }

        /*
         * Xferred command to the device.
         * Start data phase (B - in CBI)
         */

        /*
         * we've not transferred any data yet; updated in
         * scsa2usb_handle_data_done
         */
        cmd->cmd_resid_xfercount = 0;

        /* if data to be xferred ? */
        if (cmd->cmd_xfercount) {

                /* Initialize a bulk_req_t */
                data_req = scsa2usb_init_bulk_req(scsa2usbp, 0,
                    cmd->cmd_timeout, USB_ATTRS_PIPE_RESET, USB_FLAGS_SLEEP);

                /* start I/O to/from the device */
                rval = scsa2usb_handle_data_start(scsa2usbp, cmd,
                    data_req);
                /* handle data returned */
                scsa2usb_handle_data_done(scsa2usbp, cmd,
                    data_req);
                if (rval != USB_SUCCESS) {
                        /*
                         * we ran into an error and it wasn't a STALL
                         */
                        if (data_req->bulk_completion_reason == USB_CR_STALL) {
                                if (scsa2usbp->scsa2usb_cur_pkt) {
                                        scsa2usbp->scsa2usb_cur_pkt->
                                            pkt_reason = CMD_TRAN_ERR;
                                }
                        } else {
                                scsa2usb_cbi_handle_error(scsa2usbp,
                                    rval, data_req->bulk_completion_reason);

                                /* get rid of req */
                                SCSA2USB_FREE_BULK_REQ(data_req);

                                return (TRAN_FATAL_ERROR);
                        }
                }

                SCSA2USB_FREE_BULK_REQ(data_req); /* get rid of bulk_req */
        }

        /* CB devices don't do status over interrupt pipe */
        if (SCSA2USB_IS_CB(scsa2usbp)) {
                USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
                    "scsa2usb_cbi_transport: CB done rval = %d", rval);
                goto end_it;
        }

        /*
         * Start status phase (I - in CBI)
         */

        /* Get Status over interrupt pipe */
        if ((status_req = scsa2usb_cbi_start_intr_polling(scsa2usbp)) == NULL) {

                return (TRAN_FATAL_ERROR); /* lack of better return code */
        }

        rval = scsa2usb_handle_cbi_status(status_req);

        usb_free_intr_req(status_req);

        /* stop interrupt pipe polling (CBI only) */
        if (SCSA2USB_IS_CBI(scsa2usbp)) {
                scsa2usb_cbi_stop_intr_polling(scsa2usbp);
        }

end_it:
        if ((rval == USB_SUCCESS) &&            /* CSW was ok */
            (scsa2usbp->scsa2usb_cur_pkt->pkt_reason == CMD_CMPLT) &&
            (cmd->cmd_xfercount != 0) &&        /* more data to xfer */
            !cmd->cmd_done) {                   /* we aren't done yet */
                scsa2usb_setup_next_xfer(scsa2usbp, cmd);
                goto Cmd_Phase;
        } else {
                if (SCSA2USB_IS_CB(scsa2usbp)) {
                        cmd->cmd_done = 1;
                        SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);
                }
        }

        return (rval == USB_SUCCESS ? TRAN_ACCEPT : TRAN_FATAL_ERROR);
}


/*
 * scsa2usb_cbi_handle_error:
 *      handle errors from transport that are not STALL conditions
 */
static void
scsa2usb_cbi_handle_error(scsa2usb_state_t *scsa2usbp, int rval, usb_cr_t cr)
{
        struct scsi_pkt *pkt = scsa2usbp->scsa2usb_cur_pkt;

        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_cbi_handle_error: data error %d cr = %d", rval, cr);

        SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);

        /* do reset error recovery */
        switch (cr) {
        case USB_CR_STALL:
                if (pkt) {
                        pkt->pkt_reason = CMD_TRAN_ERR;
                        *(pkt->pkt_scbp) = STATUS_CHECK;
                }
                break;
        case USB_CR_TIMEOUT:
                if (pkt) {
                        pkt->pkt_reason = CMD_TIMEOUT;
                        pkt->pkt_statistics |= STAT_TIMEOUT;
                }
                break;
        case USB_CR_DEV_NOT_RESP:
                scsa2usb_cbi_stop_intr_polling(scsa2usbp);
                if (pkt) {
                        pkt->pkt_reason = CMD_DEV_GONE;
                        /* scsi_poll relies on this */
                        pkt->pkt_state = STATE_GOT_BUS;
                }
                break;
        default:
                if (pkt) {
                        pkt->pkt_reason = CMD_TRAN_ERR;
                }
                scsa2usb_cbi_reset_recovery(scsa2usbp);
        }
}


/*
 * scsa2usb_cbi_start_intr_polling:
 *      start polling asynchronously without notification
 */
static usb_intr_req_t *
scsa2usb_cbi_start_intr_polling(scsa2usb_state_t *scsa2usbp)
{
        int rval;
        usb_pipe_state_t   pipe_state;
        usb_intr_req_t *req = NULL;

        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_cbi_start_intr_polling:");

        if (!SCSA2USB_IS_CBI(scsa2usbp)) {

                return (NULL);
        }

        req = usb_alloc_intr_req(scsa2usbp->scsa2usb_dip, 0, USB_FLAGS_SLEEP);
        req->intr_client_private = (usb_opaque_t)scsa2usbp;
        req->intr_attributes = USB_ATTRS_ONE_XFER | USB_ATTRS_PIPE_RESET |
            USB_ATTRS_SHORT_XFER_OK;
        req->intr_len = scsa2usbp->scsa2usb_intr_ept.wMaxPacketSize;
        req->intr_timeout = 20; /* arbitrary large for now */
        mutex_exit(&scsa2usbp->scsa2usb_mutex);

        if ((rval = usb_pipe_intr_xfer(scsa2usbp->scsa2usb_intr_pipe, req,
            USB_FLAGS_SLEEP)) != USB_SUCCESS) {
                mutex_enter(&scsa2usbp->scsa2usb_mutex);
                USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
                    "polling failed rval: %d", rval);

                /* clear stall */
                if (req->intr_completion_reason == USB_CR_STALL) {
                        (void) scsa2usb_clear_ept_stall(scsa2usbp,
                            scsa2usbp->scsa2usb_intr_ept.bEndpointAddress,
                            scsa2usbp->scsa2usb_intr_pipe, "intr");
                }

                /* handle other errors here */
                scsa2usb_cbi_handle_error(scsa2usbp, rval,
                    req->intr_completion_reason);
                mutex_exit(&scsa2usbp->scsa2usb_mutex);

                usb_free_intr_req(req);
                req = NULL;
        }

        rval = usb_pipe_get_state(scsa2usbp->scsa2usb_intr_pipe,
            &pipe_state, USB_FLAGS_SLEEP);
        if (pipe_state != USB_PIPE_STATE_ACTIVE) {
                USB_DPRINTF_L2(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
                    "intr pipes state: %d, rval: %d", pipe_state, rval);
        }
        mutex_enter(&scsa2usbp->scsa2usb_mutex);

        return (req);
}


/*
 * scsa2usb_cbi_stop_intr_polling:
 *      Stop polling on interrupt pipe (for status)
 */
void
scsa2usb_cbi_stop_intr_polling(scsa2usb_state_t *scsa2usbp)
{
        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_cbi_stop_intr_polling:");

        ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));

        if (!SCSA2USB_IS_CBI(scsa2usbp)) {

                return;
        }

        if (scsa2usbp->scsa2usb_intr_pipe) {
                mutex_exit(&scsa2usbp->scsa2usb_mutex);
                usb_pipe_stop_intr_polling(scsa2usbp->scsa2usb_intr_pipe,
                    USB_FLAGS_SLEEP);
                mutex_enter(&scsa2usbp->scsa2usb_mutex);
        }
}


/*
 * scsa2usb_handle_cbi_status:
 *      Handle CBI status results
 */
static int
scsa2usb_handle_cbi_status(usb_intr_req_t *req)
{
        int rval = USB_SUCCESS;
        int status;
        char *msg;
        scsa2usb_cmd_t *cmd;
        scsa2usb_state_t *scsa2usbp = (scsa2usb_state_t *)
            req->intr_client_private;

        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_handle_cbi_status: req: 0x%p", (void *)req);

        ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));
        ASSERT(req->intr_data != NULL);

        cmd = PKT2CMD(scsa2usbp->scsa2usb_cur_pkt);
        status = *(req->intr_data->b_rptr + 1) & CBI_STATUS_MASK;

        /*
         * CBI status contains ASC and ASCQ.
         * SCMD_REQUEST_SENSE and SCMD_INQUIRY don't affect the sense data
         * on CBI devices. So, we can ignore that info for these 2 commands.
         *
         * (See details in UFI spec section 3.5 - that says that INQUIRY,
         * SEND_DIAG, and REQUEST_SENSE ought to be supported by any deivce
         * irrespective).
         */
        if ((cmd->cmd_cdb[SCSA2USB_OPCODE] == SCMD_REQUEST_SENSE) ||
            (cmd->cmd_cdb[SCSA2USB_OPCODE] == SCMD_INQUIRY)) {
                USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
                    "scsa2usb_handle_cbi_status: CBI STATUS = (0x%x, 0x%x)",
                    *(req->intr_data->b_rptr), *(req->intr_data->b_rptr+1));

                SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);

                return (USB_SUCCESS);
        }

        switch (status) {
        case CBI_STATUS_PASS:
                msg = "PASSED";
                /* non-zero command completion interrupt */
                if (*(req->intr_data->b_rptr)) {
                        *(scsa2usbp->scsa2usb_cur_pkt->pkt_scbp) = STATUS_CHECK;
                        cmd->cmd_done = 1;
                }
                break;
        case CBI_STATUS_FAILED:
        case CBI_STATUS_PERSISTENT_FAIL:
                msg = (status == CBI_STATUS_PERSISTENT_FAIL) ?
                    "PERSISTENT_FAILURE" : "FAILED";
                *(scsa2usbp->scsa2usb_cur_pkt->pkt_scbp) = STATUS_CHECK;
                cmd->cmd_done = 1;
                break;
        case CBI_STATUS_PHASE_ERR:
                msg = "PHASE_ERR";
                scsa2usb_cbi_reset_recovery(scsa2usbp);
                rval = USB_FAILURE;
                break;
        }

        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "CBI STATUS = 0x%x %s (0x%x, 0x%x)", status, msg,
            *(req->intr_data->b_rptr), *(req->intr_data->b_rptr+1));

        /* we are done and ready to callback */
        SCSA2USB_SET_PKT_DO_COMP_STATE(scsa2usbp);

        return (rval);
}


/*
 * scsa2usb_cbi_reset_recovery:
 *      Reset the USB device in case of errors.
 */
static void
scsa2usb_cbi_reset_recovery(scsa2usb_state_t *scsa2usbp)
{
        int             i, rval;
        mblk_t          *cdb;
        usb_cr_t        completion_reason;
        usb_cb_flags_t  cb_flags;

        USB_DPRINTF_L4(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "scsa2usb_cbi_reset_recovery: (0x%p)", (void *)scsa2usbp);

        ASSERT(mutex_owned(&scsa2usbp->scsa2usb_mutex));

        if (!(SCSA2USB_DEVICE_ACCESS_OK(scsa2usbp))) {

                return;
        }

        if (scsa2usbp->scsa2usb_cur_pkt) {
                scsa2usbp->scsa2usb_cur_pkt->pkt_statistics |= STAT_DEV_RESET;
        }

        /* Allocate an mblk for CBR */
        cdb = allocb_wait(CBI_CLASS_CMD_LEN, BPRI_LO, STR_NOSIG, NULL);

        *cdb->b_wptr++ = SCMD_SDIAG;    /* Set it to DIAG */
        *cdb->b_wptr++ = CBI_SELF_TEST; /* Set it to reset */
        for (i = 2; i < CBI_CLASS_CMD_LEN; i++) {
                *cdb->b_wptr++ = CBI_CBR_VALUE; /* Set it to 0xff */
        }

        scsa2usbp->scsa2usb_pipe_state = SCSA2USB_PIPE_DEV_RESET;

        /*
         * Send a Reset request to the device
         */
        mutex_exit(&scsa2usbp->scsa2usb_mutex);
        rval = usb_pipe_sync_ctrl_xfer(scsa2usbp->scsa2usb_dip,
            scsa2usbp->scsa2usb_default_pipe,
            CBI_REQUEST_TYPE,                   /* bmRequestType */
            0,                                  /* bRequest */
            CBI_WVALUE,                         /* wValue */
            scsa2usbp->scsa2usb_intfc_num,      /* wIndex address */
            CBI_CLASS_CMD_LEN,                  /* wLength */
            &cdb,                               /* data to be sent */
            0, &completion_reason, &cb_flags, 0);
        mutex_enter(&scsa2usbp->scsa2usb_mutex);

        USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "\tCBI RESET: rval = %x cr = %x", rval, completion_reason);
        if (rval != USB_SUCCESS) {
                goto exc_exit;
        }

        /* reset and clear STALL on bulk-in pipe */
        rval = scsa2usb_clear_ept_stall(scsa2usbp,
            scsa2usbp->scsa2usb_bulkin_ept.bEndpointAddress,
            scsa2usbp->scsa2usb_bulkin_pipe, "bulk-in");
        USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "\tclear stall on bulk-in pipe: %d", rval);
        if (rval != USB_SUCCESS) {
                goto exc_exit;
        }

        /* reset and clear STALL on bulk-out pipe */
        rval = scsa2usb_clear_ept_stall(scsa2usbp,
            scsa2usbp->scsa2usb_bulkout_ept.bEndpointAddress,
            scsa2usbp->scsa2usb_bulkout_pipe, "bulk-out");
        USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
            "\tclear stall on bulk-out pipe: %d", rval);
        if (rval != USB_SUCCESS) {
                goto exc_exit;
        }

        /* reset and clear STALL on interrupt pipe */
        if (SCSA2USB_IS_CBI(scsa2usbp)) {
                rval = scsa2usb_clear_ept_stall(scsa2usbp,
                    scsa2usbp->scsa2usb_intr_ept.bEndpointAddress,
                    scsa2usbp->scsa2usb_intr_pipe, "intr");

                USB_DPRINTF_L3(DPRINT_MASK_SCSA, scsa2usbp->scsa2usb_log_handle,
                    "\tclear stall on intr pipe:  %d", rval);
        }

exc_exit:
        SCSA2USB_FREE_MSG(cdb); /* Free the data */
        scsa2usbp->scsa2usb_pipe_state &= ~SCSA2USB_PIPE_DEV_RESET;
}