/*
 * Copyright 2009, Michael Lotz, mmlr@mlotz.ch.
 * Copyright 2008, Marcus Overhagen.
 * Copyright 2004-2008, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2002-2003, Thomas Kurschel.
 *
 * Distributed under the terms of the MIT License.
 */

#include "ATAPrivate.h"

ATAPIDevice::ATAPIDevice(ATAChannel *channel, uint8 index)
        :       ATADevice(channel, index)
{
}


ATAPIDevice::~ATAPIDevice()
{
}


status_t
ATAPIDevice::SendPacket(ATARequest *request)
{
        TRACE_FUNCTION("%p\n", request);

        // only READ/WRITE commands can use DMA
        // (the device may support it always, but IDE controllers don't
        // report how much data is transmitted, and this information is
        // crucial for the SCSI protocol)
        // special offer: let READ_CD commands use DMA too
        uint8 command = fPacket[0];
        request->SetUseDMA(UseDMA() && request->CCB()->sg_list != NULL
                && (command == SCSI_OP_READ_6 || command == SCSI_OP_WRITE_6
                || command == SCSI_OP_READ_10 || command == SCSI_OP_WRITE_10
                || command == SCSI_OP_READ_12 || command == SCSI_OP_WRITE_12
                || command == SCSI_OP_READ_CD)
                && fChannel->PrepareDMA(request) == B_OK);
        TRACE("using dma: %s\n", request->UseDMA() ? "yes" : "no");

        if (!request->UseDMA())
                request->PrepareSGInfo();

        if (_FillTaskFilePacket(request) != B_OK) {
                TRACE_ERROR("failed to setup transfer request\n");
                if (request->UseDMA())
                        fChannel->FinishDMA();
                return B_ERROR;
        }

        status_t result = fChannel->SendRequest(request, 0);
        if (result != B_OK) {
                TRACE_ERROR("failed to send packet request\n");
                if (request->UseDMA())
                        fChannel->FinishDMA();
                return result;
        }

        // wait for device to get ready for packet transmission
        if (fChannel->Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
                ATA_CHECK_ERROR_BIT | ATA_CHECK_DEVICE_FAULT, 100 * 1000) != B_OK) {
                TRACE_ERROR("timeout waiting for data request\n");
                if (request->UseDMA())
                        fChannel->FinishDMA();

                request->SetStatus(SCSI_SEQUENCE_FAIL);
                return B_TIMED_OUT;
        }

        // make sure device really asks for command packet
        fRegisterMask = ATA_MASK_INTERRUPT_REASON;
        fChannel->ReadRegs(this);

        if (!fTaskFile.packet_res.cmd_or_data
                || fTaskFile.packet_res.input_or_output) {
                TRACE_ERROR("device doesn't ask for packet\n");
                if (request->UseDMA())
                        fChannel->FinishDMA();

                request->SetStatus(SCSI_SEQUENCE_FAIL);
                return B_ERROR;
        }

        // some old drives need a delay before submitting the packet
        spin(10);

        // write packet
        if (fChannel->WritePIO(fPacket, sizeof(fPacket)) != B_OK) {
                TRACE_ERROR("failed to write packet\n");
                if (request->UseDMA())
                        fChannel->FinishDMA();

                request->SetStatus(SCSI_HBA_ERR);
                return B_ERROR;
        }

        if (!request->HasData())
                return _FinishRequest(request, ATA_WAIT_FINISH);

        if (request->UseDMA()) {
                fChannel->PrepareWaitingForInterrupt();
                fChannel->StartDMA();

                result = fChannel->WaitForInterrupt(request->Timeout());
                status_t dmaResult = fChannel->FinishDMA();
                if (result != B_OK) {
                        request->SetStatus(SCSI_CMD_TIMEOUT);
                        return B_TIMED_OUT;
                }

                result = _FinishRequest(request, ATA_WAIT_FINISH);
                if (result != B_OK) {
                        TRACE_ERROR("device indicates transfer error after dma\n");
                        return result;
                }

                // for ATAPI it's ok for the device to send too much
                if (dmaResult == B_OK || dmaResult == B_DEV_DATA_OVERRUN) {
                        fDMAFailures = 0;
                        request->CCB()->data_resid = 0;
                        return B_OK;
                }

                TRACE_ERROR("dma transfer failed\n");
                request->SetSense(SCSIS_KEY_HARDWARE_ERROR,
                        SCSIS_ASC_LUN_COM_FAILURE);
                fDMAFailures++;
                if (fDMAFailures >= ATA_MAX_DMA_FAILURES) {
                        TRACE_ALWAYS("disabling DMA after %u failures\n", fDMAFailures);
                        fUseDMA = false;
                }

                return B_ERROR;
        }

        result = fChannel->Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
                ATA_CHECK_ERROR_BIT | ATA_CHECK_DEVICE_FAULT, request->Timeout());
        if (result != B_OK) {
                if (result == B_TIMED_OUT) {
                        TRACE_ERROR("timeout waiting for device to request data\n");
                        request->SetStatus(SCSI_CMD_TIMEOUT);
                        return B_TIMED_OUT;
                } else
                        return _FinishRequest(request, 0);
        }

        // PIO data transfer
        while (true) {
                fRegisterMask = ATA_MASK_INTERRUPT_REASON | ATA_MASK_BYTE_COUNT;
                fChannel->ReadRegs(this);

                if (fTaskFile.packet_res.cmd_or_data) {
                        TRACE_ERROR("device expecting command instead of data\n");
                        request->SetStatus(SCSI_SEQUENCE_FAIL);
                        return B_ERROR;
                }

                size_t length = fTaskFile.packet_res.byte_count_0_7
                        | ((size_t)fTaskFile.packet_res.byte_count_8_15 << 8);
                TRACE("about to transfer %lu bytes\n", length);

                request->SetBytesLeft(length);
                fChannel->ExecutePIOTransfer(request);

                result = fChannel->Wait(0, ATA_STATUS_BUSY, 0, request->Timeout());
                if (result != B_OK) {
                        if (result == B_TIMED_OUT) {
                                TRACE_ERROR("timeout waiting for device to finish transfer\n");
                                request->SetStatus(SCSI_CMD_TIMEOUT);
                                return B_TIMED_OUT;
                        } else
                                return _FinishRequest(request, 0);
                }

                if ((fChannel->AltStatus() & ATA_STATUS_DATA_REQUEST) == 0) {
                        // transfer complete
                        TRACE("pio transfer complete\n");
                        break;
                }
        }

        return _FinishRequest(request, ATA_WAIT_FINISH);
}


status_t
ATAPIDevice::ExecuteIO(ATARequest *request)
{
        scsi_ccb *ccb = request->CCB();
        if (ccb->target_lun != 0) {
                TRACE_ERROR("invalid target lun %d\n", ccb->target_lun);
                request->SetStatus(SCSI_SEL_TIMEOUT);
                return B_BAD_INDEX;
        }

        // ATAPI command packets are 12 bytes long;
        // if the command is shorter, remaining bytes must be padded with zeros
        memset(fPacket, 0, sizeof(fPacket));
        memcpy(fPacket, ccb->cdb, ccb->cdb_length);

        request->SetDevice(this);
        request->SetIsWrite((ccb->flags & SCSI_DIR_MASK) == SCSI_DIR_OUT);
        return SendPacket(request);
}


status_t
ATAPIDevice::Configure()
{
        if (fInfoBlock.word_0.atapi.atapi_device != ATA_WORD_0_ATAPI_DEVICE) {
                TRACE_ERROR("infoblock indicates non-atapi device\n");
                return B_ERROR;
        }

        fTaskFile.packet.lun = 0;

        status_t result = ConfigureDMA();
        if (result != B_OK)
                return result;

        result = DisableCommandQueueing();
        if (result != B_OK)
                return result;

        return B_OK;
}


status_t
ATAPIDevice::_FillTaskFilePacket(ATARequest *request)
{
        scsi_ccb *ccb = request->CCB();
        fRegisterMask = ATA_MASK_FEATURES | ATA_MASK_BYTE_COUNT;
        fTaskFile.packet.dma = request->UseDMA() ? 1 : 0;
        fTaskFile.packet.ovl = 0;
        fTaskFile.packet.byte_count_0_7 = ccb->data_length & 0xff;
        fTaskFile.packet.byte_count_8_15 = ccb->data_length >> 8;
        fTaskFile.packet.command = ATA_COMMAND_PACKET;
        return B_OK;
}


status_t
ATAPIDevice::_FinishRequest(ATARequest *request, uint32 flags)
{
        if (fChannel->FinishRequest(request, flags
                | ATA_CHECK_DEVICE_FAULT, 0) != B_OK) {
                // when we get an error from a packet device, we instruct the
                // scsi layer to do a request sense. but since we don't want to
                // return an emulated sense coming from ata, we clear our sense
                // key first so that the next request sense will go to the packet
                // device directly (as a packet command).
                request->ClearSense();
                request->SetStatus(SCSI_REQ_CMP_ERR);
                request->CCB()->device_status = SCSI_STATUS_CHECK_CONDITION;
                return B_ERROR;
        }

        return B_OK;
}