/*
 * Copyright 2013, Jérôme Duval, korli@users.berlios.de.
 * Copyright 2009, Michael Lotz, mmlr@mlotz.ch.
 * Distributed under the terms of the MIT License.
 */


#include "VirtioSCSIPrivate.h"

#include <strings.h>


VirtioSCSIRequest::VirtioSCSIRequest(bool hasLock)
        :
        fHasLock(hasLock),
        fStatus(SCSI_REQ_CMP),
        fTimeout(0),
        fBytesLeft(0),
        fIsWrite(false),
        fCCB(NULL)
{
        if (hasLock)
                mutex_init(&fLock, "virtio scsi request");

        fBuffer = malloc(sizeof(struct virtio_scsi_cmd_req)
                + sizeof(struct virtio_scsi_cmd_resp));
        bzero(fBuffer, sizeof(struct virtio_scsi_cmd_req)
                + sizeof(struct virtio_scsi_cmd_resp));

        fRequest = (struct virtio_scsi_cmd_req *)fBuffer;
        fResponse = (struct virtio_scsi_cmd_resp *)
                ((addr_t)fBuffer + sizeof(struct virtio_scsi_cmd_req));

        fResponse->sense_len = 0;
}


VirtioSCSIRequest::~VirtioSCSIRequest()
{
        if (fHasLock)
                mutex_destroy(&fLock);

        free(fBuffer);
}


void
VirtioSCSIRequest::SetStatus(uint8 status)
{
        fStatus = status;
}


void
VirtioSCSIRequest::SetTimeout(bigtime_t timeout)
{
        fTimeout = timeout;
}


void
VirtioSCSIRequest::SetIsWrite(bool isWrite)
{
        fIsWrite = isWrite;
}


void
VirtioSCSIRequest::SetBytesLeft(uint32 bytesLeft)
{
        fBytesLeft = bytesLeft;
}


status_t
VirtioSCSIRequest::Start(scsi_ccb *ccb)
{
        CALLED();
        if (mutex_trylock(&fLock) != B_OK)
                return B_BUSY;

        fCCB = ccb;
        fStatus = SCSI_REQ_CMP;
        fCCB->device_status = SCSI_STATUS_GOOD;
        fIsWrite = false;
        bzero(fResponse, sizeof(struct virtio_scsi_cmd_resp));

        TRACE("VirtioSCSIRequest::Start() opcode %x tid %x lun %x\n", ccb->cdb[0],
                ccb->target_id, ccb->target_lun);

        return B_OK;
}


status_t
VirtioSCSIRequest::Finish(bool resubmit)
{
        CALLED();
        fStatus = _ResponseStatus();
        fCCB->data_resid = fResponse->resid;
        fCCB->subsys_status = fStatus;

        TRACE("VirtioSCSIRequest::Finish() status 0x%x response 0x%x resid:0x%x"
                " sense_len:%x\n", fResponse->status, fResponse->response,
                fResponse->resid, fResponse->sense_len);

        if (fCCB->cdb[0] == SCSI_OP_INQUIRY) {
                // when the request is an inquiry, don't do anything
        } else if (fStatus == SCSI_REQ_CMP && fResponse->status != 0
                && HasSense()) {
                // when the request completed and has set sense
                // data, report this to the scsi stack by setting
                // CHECK CONDITION status
                TRACE("setting check condition\n");

                fCCB->subsys_status = SCSI_REQ_CMP_ERR;
                fCCB->device_status = SCSI_STATUS_CHECK_CONDITION;

                // copy sense data if caller requested it
                if ((fCCB->flags & SCSI_DIS_AUTOSENSE) == 0) {
                        size_t senseLength = min_c(sizeof(fCCB->sense),
                                fResponse->sense_len);
                        memcpy(fCCB->sense, fResponse->sense, senseLength);
                        fCCB->sense_resid = sizeof(fCCB->sense) - senseLength;
                        fCCB->subsys_status |= SCSI_AUTOSNS_VALID;
                }
        }

        scsi_ccb *ccb = fCCB;
        mutex_unlock(&fLock);

        if (resubmit)
                gSCSI->resubmit(ccb);
        else
                gSCSI->finished(ccb, 1);

        TRACE("VirtioSCSIRequest::Finish() done\n");

        return B_OK;
}


void
VirtioSCSIRequest::Abort()
{
        scsi_ccb *ccb = fCCB;
        mutex_unlock(&fLock);

        ccb->subsys_status = SCSI_REQ_ABORTED;
        gSCSI->finished(ccb, 1);
}


void
VirtioSCSIRequest::RequestSense()
{
        CALLED();
        // Copy sense data from last request into data buffer of current request.
        // The sense data of last request is still present in the current request,
        // as it isn't cleared on SCSI_OP_REQUEST_SENSE.
        scsi_cmd_request_sense *command = (scsi_cmd_request_sense *)fCCB->cdb;
        copy_sg_data(fCCB, 0, command->allocation_length, fResponse->sense,
                fResponse->sense_len, false);

        fCCB->data_resid = fCCB->data_length - min_c(min_c(fResponse->sense_len,
                command->allocation_length), fCCB->data_length);
        fResponse->sense_len = 0;
}


void
VirtioSCSIRequest::FillRequest(uint32 inCount, uint32 outCount,
        physical_entry *entries)
{
        CALLED();
        fRequest->task_attr = VIRTIO_SCSI_S_SIMPLE;
        fRequest->tag = (addr_t)fCCB;
        fRequest->lun[0] = 1;
        fRequest->lun[1] = fCCB->target_id;
        // we don't support lun >= 256
        fRequest->lun[2] = 0x40;
        fRequest->lun[3] = fCCB->target_lun & 0xff;

        memcpy(fRequest->cdb, fCCB->cdb, min_c(fCCB->cdb_length,
                min_c(sizeof(fRequest->cdb), sizeof(fCCB->cdb))));

        get_memory_map(fBuffer, sizeof(struct virtio_scsi_cmd_req)
                + sizeof(struct virtio_scsi_cmd_resp), &entries[0], 1);
        entries[0].size = sizeof(struct virtio_scsi_cmd_req);
        if (outCount > 1) {
                memcpy(entries + 1, fCCB->sg_list, fCCB->sg_count
                        * sizeof(physical_entry));
        }

        entries[outCount].address = entries[0].address
                + sizeof(struct virtio_scsi_cmd_req);
        entries[outCount].size = sizeof(struct virtio_scsi_cmd_resp);

        if (inCount > 1) {
                memcpy(entries + outCount + 1, fCCB->sg_list, fCCB->sg_count
                        * sizeof(physical_entry));
        }
}


uchar
VirtioSCSIRequest::_ResponseStatus()
{
        uchar status;

        switch (fResponse->response) {
                case VIRTIO_SCSI_S_OK:
                        status = SCSI_REQ_CMP;
                        break;
                case VIRTIO_SCSI_S_OVERRUN:
                        status = SCSI_DATA_RUN_ERR;
                        break;
                case VIRTIO_SCSI_S_ABORTED:
                        status = SCSI_REQ_ABORTED;
                        break;
                case VIRTIO_SCSI_S_BAD_TARGET:
                        status = SCSI_TID_INVALID;
                        break;
                case VIRTIO_SCSI_S_RESET:
                        status = SCSI_SCSI_BUS_RESET;
                        break;
                case VIRTIO_SCSI_S_BUSY:
                        status = SCSI_SCSI_BUSY;
                        break;
                case VIRTIO_SCSI_S_TRANSPORT_FAILURE:
                case VIRTIO_SCSI_S_TARGET_FAILURE:
                case VIRTIO_SCSI_S_NEXUS_FAILURE:
                        status = SCSI_NO_NEXUS;
                        break;
                default: /* VIRTIO_SCSI_S_FAILURE */
                        status = SCSI_REQ_CMP_ERR;
                        break;
        }

        return status;
}