/*
 * Copyright 2009, Michael Lotz, mmlr@mlotz.ch.
 * Distributed under the terms of the MIT License.
 */
 
#include "ATAPrivate.h"
 
 
ATARequest::ATARequest(bool hasLock)
	:
	fHasLock(hasLock),
	fDevice(NULL),
	fTimeout(0),
	fBytesLeft(0),
	fIsWrite(false),
	fUseDMA(false),
	fCCB(NULL)
{
	if (hasLock)
		mutex_init(&fLock, "ata request");
 
	ClearSense();
}
 
 
ATARequest::~ATARequest()
{
	if (fHasLock)
		mutex_destroy(&fLock);
}
 
 
void
ATARequest::SetStatus(uint8 status)
{
	fStatus = status;
}
 
 
void
ATARequest::SetSense(uint8 key, uint16 codeQualifier)
{
	fSenseKey = key;
	fSenseCode = (uint8)(codeQualifier >> 8);
	fSenseQualifier = (uint8)(codeQualifier & 0xff);
}
 
 
void
ATARequest::ClearSense()
{
	fSenseKey = fSenseCode = fSenseQualifier = 0;
}
 
 
void
ATARequest::SetDevice(ATADevice *device)
{
	fDevice = device;
}
 
 
void
ATARequest::SetTimeout(bigtime_t timeout)
{
	fTimeout = timeout;
}
 
 
void
ATARequest::SetIsWrite(bool isWrite)
{
	fIsWrite = isWrite;
}
 
 
void
ATARequest::SetUseDMA(bool useDMA)
{
	fUseDMA = useDMA;
}
 
 
void
ATARequest::SetBytesLeft(uint32 bytesLeft)
{
	fBytesLeft = bytesLeft;
}
 
 
status_t
ATARequest::Start(scsi_ccb *ccb)
{
	if (mutex_trylock(&fLock) != B_OK)
		return B_BUSY;
 
	fCCB = ccb;
	fStatus = SCSI_REQ_CMP;
	fCCB->device_status = SCSI_STATUS_GOOD;
	fIsWrite = false;
	return B_OK;
}
 
 
status_t
ATARequest::Finish(bool resubmit)
{
	// when the request completed and has set sense
    // data, report this to the scsi stack by setting
    // CHECK CONDITION status
	if (fStatus == SCSI_REQ_CMP && fSenseKey != 0) {
		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) {
			// we cannot copy sense directly as sense buffer may be too small
			scsi_sense sense;
			_FillSense(&sense);
 
			size_t senseLength = MIN(sizeof(fCCB->sense), sizeof(sense));
			memcpy(fCCB->sense, &sense, senseLength);
			fCCB->sense_resid = SCSI_MAX_SENSE_SIZE - senseLength;
			fCCB->subsys_status |= SCSI_AUTOSNS_VALID;
			ClearSense();
		}
	} else
		fCCB->subsys_status = fStatus;
 
	mutex_unlock(&fLock);
 
	if (resubmit)
		gSCSIModule->resubmit(fCCB);
	else
		gSCSIModule->finished(fCCB, 1);
 
	return B_OK;
}
 
 
void
ATARequest::RequestSense()
{
	// 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_sense sense;
	if (fSenseKey != 0)
		_FillSense(&sense);
	else
		memset(&sense, 0, sizeof(sense));
 
	scsi_cmd_request_sense *command = (scsi_cmd_request_sense *)fCCB->cdb;
	copy_sg_data(fCCB, 0, command->allocation_length, &sense, sizeof(sense),
		false);
 
	fCCB->data_resid = fCCB->data_length - MIN(MIN(sizeof(sense),
		command->allocation_length), fCCB->data_length);
	ClearSense();
}
 
 
void
ATARequest::PrepareSGInfo()
{
	fSGElementsLeft = fCCB->sg_count;
	fCurrentSGElement = fCCB->sg_list;
	fCurrentSGOffset = 0;
	fHasOddByte = false;
	fCCB->data_resid = fCCB->data_length;
}
 
 
void
ATARequest::AdvanceSG(uint32 bytes)
{
	uint32 bytesLeft = fCurrentSGElement->size - fCurrentSGOffset;
	if (bytesLeft <= bytes) {
		fCurrentSGOffset = 0;
		fCurrentSGElement++;
		fSGElementsLeft--;
	} else
		fCurrentSGOffset += bytes;
}
 
 
void
ATARequest::SetOddByte(uint8 byte)
{
	fOddByte = byte;
	fHasOddByte = true;
}
 
 
bool
ATARequest::GetOddByte(uint8 *byte)
{
	if (!fHasOddByte)
		return false;
 
	if (byte != NULL)
		*byte = fOddByte;
 
	fHasOddByte = false;
	return true;
}
 
 
void
ATARequest::_FillSense(scsi_sense *sense)
{
	memset(sense, 0, sizeof(*sense));
	sense->error_code = SCSIS_CURR_ERROR;
	sense->sense_key = fSenseKey;
	sense->add_sense_length = sizeof(*sense) - 7;
	sense->asc = fSenseCode;
	sense->ascq = fSenseQualifier;
	sense->sense_key_spec.raw.SKSV = 0;	// no additional info
}