haiku.git

/*
 * 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"


ATADevice::ATADevice(ATAChannel *channel, uint8 index)
	:
	fChannel(channel),
	fRegisterMask(0),
	fUseDMA(channel->UseDMA()),
	fDMAMode(0),
	fDMAFailures(0),
	fTotalSectors(0),
	fBlockSize(512),
	fPhysicalBlockSize(512),
	fBlockOffset(0),
	fIndex(index),
	fUse48Bits(false)
{
	memset(&fInfoBlock, 0, sizeof(fInfoBlock));
	memset(&fTaskFile, 0, sizeof(fTaskFile));
}


ATADevice::~ATADevice()
{
}


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

	fRegisterMask = 0;
	fTaskFile.write.command = ATA_COMMAND_GET_MEDIA_STATUS;

	request->SetTimeout(15 * 1000 * 1000);
	status_t result = fChannel->SendRequest(request, ATA_DEVICE_READY_REQUIRED);
	if (result != B_OK) {
		TRACE_ERROR("failed to send test unit ready request\n");
		return result;
	}

	return fChannel->FinishRequest(request, ATA_WAIT_FINISH
		| ATA_DEVICE_READY_REQUIRED, ATA_ERROR_NO_MEDIA | ATA_ERROR_ABORTED
		| ATA_ERROR_MEDIA_CHANGE_REQUESTED | ATA_ERROR_MEDIUM_CHANGED);
}


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

	// we should also ask for FLUSH CACHE support, but everyone denies it
	// (looks like they cheat to gain some performance advantage, but
	//  that's pretty useless: everyone does it...)
	if (!fInfoBlock.write_cache_supported)
		return B_OK;

	fRegisterMask = 0;
	fTaskFile.lba.command
		= fUse48Bits ? ATA_COMMAND_FLUSH_CACHE_EXT : ATA_COMMAND_FLUSH_CACHE;

	request->SetTimeout(60 * 1000 * 1000);
	status_t result = fChannel->SendRequest(request, ATA_DEVICE_READY_REQUIRED);
	if (result != B_OK) {
		TRACE_ERROR("failed to send synchronize cache request\n");
		return result;
	}

	return fChannel->FinishRequest(request, ATA_WAIT_FINISH
		| ATA_DEVICE_READY_REQUIRED, ATA_ERROR_ABORTED);
}


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

	fRegisterMask = 0;
	fTaskFile.lba.command = ATA_COMMAND_MEDIA_EJECT;

	request->SetTimeout(15 * 1000 * 1000);
	status_t result = fChannel->SendRequest(request, ATA_DEVICE_READY_REQUIRED);
	if (result != B_OK) {
		TRACE_ERROR("failed to send eject request\n");
		return result;
	}

	return fChannel->FinishRequest(request, ATA_WAIT_FINISH
		| ATA_DEVICE_READY_REQUIRED, ATA_ERROR_ABORTED | ATA_ERROR_NO_MEDIA);
}


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

	scsi_ccb *ccb = request->CCB();
	scsi_cmd_inquiry *command = (scsi_cmd_inquiry *)ccb->cdb;
	if (command->evpd || command->page_code) {
		request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST, SCSIS_ASC_INV_CDB_FIELD);
		return B_ERROR;
	}

	scsi_res_inquiry data;
	memset(&data, 0, sizeof(data));

	data.device_type = IsATAPI()
		? fInfoBlock.word_0.atapi.command_packet_set : scsi_dev_direct_access;
	data.device_qualifier = scsi_periph_qual_connected;

	data.device_type_modifier = 0;
	data.removable_medium = fInfoBlock.word_0.ata.removable_media_device;

	data.ansi_version = 2;
	data.ecma_version = 0;
	data.iso_version = 0;

	data.response_data_format = 2;
	data.term_iop = false;
		// to be changed if we support TERM I/O

	data.additional_length = sizeof(scsi_res_inquiry) - 4;

	data.soft_reset = false;
	data.cmd_queue = 0;
	data.linked = false;

	// these values are free-style
	data.sync = false;
	data.write_bus16 = true;
	data.write_bus32 = false;

	data.relative_address = false;

	// the following fields are *much* to small, sigh...
	memcpy(data.vendor_ident, fInfoBlock.model_number,
		sizeof(data.vendor_ident));
	swap_words(data.vendor_ident, sizeof(data.vendor_ident));

	memcpy(data.product_ident, fInfoBlock.model_number + 8,
		sizeof(data.product_ident));
	swap_words(data.product_ident, sizeof(data.product_ident));

	memcpy(data.product_rev, "    ", sizeof(data.product_rev));

	uint32 allocationLength = command->allocation_length;
	copy_sg_data(ccb, 0, allocationLength, &data, sizeof(data), false);
	ccb->data_resid = ccb->data_length - MIN(MIN(sizeof(data),
		allocationLength), ccb->data_length);
	return B_OK;
}


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

	scsi_ccb *ccb = request->CCB();
	scsi_cmd_read_capacity *command = (scsi_cmd_read_capacity *)ccb->cdb;
	if (command->pmi || command->lba) {
		request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST, SCSIS_ASC_INV_CDB_FIELD);
		return B_ERROR;
	}

	scsi_res_read_capacity data;
	memset(&data, 0, sizeof(data));

	data.block_size = B_HOST_TO_BENDIAN_INT32(fBlockSize);

	if (fTotalSectors <= UINT_MAX) {
		uint32 lastBlock = fTotalSectors - 1;
		data.lba = B_HOST_TO_BENDIAN_INT32(lastBlock);
	} else
		data.lba = UINT_MAX;
	TRACE("returning last block: %" B_PRIu32 "\n",
		B_BENDIAN_TO_HOST_INT32(data.lba));

	copy_sg_data(ccb, 0, ccb->data_length, &data, sizeof(data), false);
	ccb->data_resid = MAX(ccb->data_length - sizeof(data), 0);
	return B_OK;
}


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

	scsi_ccb *ccb = request->CCB();
	scsi_cmd_read_capacity_long *command
		= (scsi_cmd_read_capacity_long *)ccb->cdb;
	if (command->pmi || command->lba) {
		request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST, SCSIS_ASC_INV_CDB_FIELD);
		return B_ERROR;
	}

	uint32 allocationLength = B_BENDIAN_TO_HOST_INT32(command->alloc_length);

	scsi_res_read_capacity_long data;
	memset(&data, 0, sizeof(data));

	data.block_size = B_HOST_TO_BENDIAN_INT32(fBlockSize);

	uint64 lastBlock = fTotalSectors - 1;
	data.lba = B_HOST_TO_BENDIAN_INT64(lastBlock);
	TRACE("returning last block: %" B_PRIu64 "\n",
		B_BENDIAN_TO_HOST_INT64(data.lba));

	size_t copySize = min_c(allocationLength, sizeof(data));

	copy_sg_data(ccb, 0, ccb->data_length, &data, copySize, false);
	ccb->data_resid = MAX(ccb->data_length - copySize, 0);
	return B_OK;
}


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

	scsi_ccb *ccb = request->CCB();
	request->SetDevice(this);

	// ATA devices have one LUN only
	if (ccb->target_lun != 0) {
		TRACE_ERROR("invalid target lun %d for ATA device\n", ccb->target_lun);
		request->SetStatus(SCSI_SEL_TIMEOUT);
		return B_BAD_INDEX;
	}

	TRACE("request: 0x%02x\n", ccb->cdb[0]);

	switch (ccb->cdb[0]) {
		case SCSI_OP_TEST_UNIT_READY:
			return TestUnitReady(request);

		case SCSI_OP_FORMAT: /* FORMAT UNIT */
			// we could forward ccb to disk, but modern disks cannot
			// be formatted anyway, so we just refuse ccb
			// (exceptions are removable media devices, but to my knowledge
			// they don't have to be formatted as well)
			request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST, SCSIS_ASC_INV_OPCODE);
			return B_ERROR;

		case SCSI_OP_INQUIRY:
 			return Inquiry(request);

		case SCSI_OP_START_STOP:
		{
			scsi_cmd_ssu *command = (scsi_cmd_ssu *)ccb->cdb;

			// with no LoEj bit set, we should only allow/deny further access
			// we ignore that (unsupported for ATA)
			// with LoEj bit set, we should additionally either load or eject
			// the medium (start = 0 - eject; start = 1 - load)

			if (!command->start) {
				// we must always flush cache if start = 0
				SynchronizeCache(request);
			}

			if (command->load_eject) {
				if (!command->start)
					return Eject(request);
				else {
					request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST,
						SCSIS_ASC_PARAM_NOT_SUPPORTED);
					return B_ERROR;
				}
			}

			return B_OK;
		}

		case SCSI_OP_READ_CAPACITY:
			return ReadCapacity(request);

		case SCSI_OP_SERVICE_ACTION_IN:
			if ((ccb->cdb[1] & 0x1f) == SCSI_SAI_READ_CAPACITY_16)
				return ReadCapacity16(request);
			break;

		case SCSI_OP_SYNCHRONIZE_CACHE:
			// we ignore range and immediate bit, we always immediately
			// flush everything
			return SynchronizeCache(request);

		// sadly, there are two possible read/write operation codes;
		// at least, the third one, read/write(12), is not valid for DAS
		case SCSI_OP_READ_6:
		case SCSI_OP_WRITE_6:
		{
			scsi_cmd_rw_6 *command = (scsi_cmd_rw_6 *)ccb->cdb;
			uint32 address = ((uint32)command->high_lba << 16)
				| ((uint32)command->mid_lba << 8) | (uint32)command->low_lba;

			request->SetIsWrite(command->opcode == SCSI_OP_WRITE_6);
			return ExecuteReadWrite(request, address, command->length != 0
				? command->length : 256);
		}

		case SCSI_OP_READ_10:
		case SCSI_OP_WRITE_10:
		{
			scsi_cmd_rw_10 *command = (scsi_cmd_rw_10 *)ccb->cdb;
			uint32 address = B_BENDIAN_TO_HOST_INT32(command->lba);
			uint32 sectorCount = B_BENDIAN_TO_HOST_INT16(command->length);

			request->SetIsWrite(command->opcode == SCSI_OP_WRITE_10);
			if (sectorCount > 0)
				return ExecuteReadWrite(request, address, sectorCount);
			else {
				// we cannot transfer zero blocks (apart from LBA48)
				request->SetStatus(SCSI_REQ_CMP);
				return B_OK;
			}
		}

		case SCSI_OP_READ_12:
		case SCSI_OP_WRITE_12:
		{
			scsi_cmd_rw_12 *command = (scsi_cmd_rw_12 *)ccb->cdb;
			uint32 address = B_BENDIAN_TO_HOST_INT32(command->lba);
			uint32 sectorCount = B_BENDIAN_TO_HOST_INT32(command->length);

			request->SetIsWrite(command->opcode == SCSI_OP_WRITE_12);
			if (sectorCount > 0)
				return ExecuteReadWrite(request, address, sectorCount);
			else {
				// we cannot transfer zero blocks (apart from LBA48)
				request->SetStatus(SCSI_REQ_CMP);
				return B_OK;
			}
		}

		case SCSI_OP_READ_16:
		case SCSI_OP_WRITE_16:
		{
			scsi_cmd_rw_16 *command = (scsi_cmd_rw_16 *)ccb->cdb;
			uint64 address = B_BENDIAN_TO_HOST_INT64(command->lba);
			uint32 sectorCount = B_BENDIAN_TO_HOST_INT32(command->length);

			request->SetIsWrite(command->opcode == SCSI_OP_WRITE_16);
			if (sectorCount > 0)
				return ExecuteReadWrite(request, address, sectorCount);
			else {
				// we cannot transfer zero blocks (apart from LBA48)
				request->SetStatus(SCSI_REQ_CMP);
				return B_OK;
			}
		}
	}

	TRACE("command not implemented\n");
	request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST, SCSIS_ASC_INV_OPCODE);
	return B_ERROR;
}


void
ATADevice::GetRestrictions(bool *noAutoSense, uint32 *maxBlocks)
{
	if (IsATAPI())
		*noAutoSense = true;
	else {
		if (fUse48Bits)
			*maxBlocks = 0xffff;
		else
			*maxBlocks = 0x100;
	}
}


status_t
ATADevice::Control(uint32 opcode, void *buffer, size_t length)
{
	if (opcode == B_GET_DEVICE_NAME) {
		// Swap words
		char name[sizeof(fInfoBlock.model_number)];
		memcpy(name, fInfoBlock.model_number, sizeof(name));
		swap_words(name, sizeof(name));

		// Remove trailing spaces
		int32 nameLength = sizeof(name) - 2;
		while (nameLength > 0 && name[nameLength - 1] == ' ')
			nameLength--;

		// TODO: make string prettier, ie. "WDC" -> "Western Digital", ...
		return user_strlcpy((char*)buffer, name,
			min_c((size_t)nameLength + 1, length)) >= 0 ? B_OK : B_BAD_ADDRESS;
	}
	return B_BAD_VALUE;
}


status_t
ATADevice::Select()
{
	status_t err = fChannel->SelectDevice(fIndex);
#if 1
    // for debugging only
	if (fChannel->SelectedDevice() != fIndex) {
		TRACE_ERROR("device %d not selected!\n", fIndex);
		return B_ERROR;
	}
#endif
	return err;
}


status_t
ATADevice::SetFeature(int feature)
{
	TRACE("device_set_feature: feature %d\n", feature);

	ATARequest request(false);
	request.SetDevice(this);
	request.SetTimeout(1 * 1000 * 1000);

	fTaskFile.write.features = feature;
	fTaskFile.write.command = ATA_COMMAND_SET_FEATURES;
	fRegisterMask = ATA_MASK_FEATURES;

	status_t result = fChannel->SendRequest(&request, ATA_DEVICE_READY_REQUIRED);
	if (result != B_OK) {
		TRACE_ERROR("sending set feature request failed\n");
		return result;
	}

	result = fChannel->FinishRequest(&request,
		ATA_WAIT_FINISH | ATA_DEVICE_READY_REQUIRED, ATA_ERROR_ABORTED);
	if (result != B_OK) {
		TRACE_ERROR("set feature request failed\n");
		return result;
	}

	return B_OK;
}


status_t
ATADevice::DisableCommandQueueing()
{
	if (!fInfoBlock.read_write_dma_queued_supported)
		return B_OK;

	if (fInfoBlock.release_interrupt_supported) {
		status_t result = SetFeature(
			ATA_COMMAND_SET_FEATURES_DISABLE_RELEASE_INT);
		if (result != B_OK) {
			TRACE_ERROR("failed to disable release interrupt\n");
			return result;
		}
	}

	if (fInfoBlock.service_interrupt_supported) {
		status_t result = SetFeature(
			ATA_COMMAND_SET_FEATURES_DISABLE_SERVICE_INT);
		if (result != B_OK) {
			TRACE_ERROR("failed to disable service interrupt\n");
			return result;
		}
	}

	return B_OK;
}


status_t
ATADevice::ConfigureDMA()
{
	if (!fUseDMA)
		return B_OK;

	if (!fInfoBlock.dma_supported) {
		TRACE_ALWAYS("DMA not supported by device\n");
		fUseDMA = false;
		return B_OK;
	}

	#define CHECK_DMA_MODE(element, mode) \
		if (fInfoBlock.element) { \
			fDMAMode = mode; \
			modeCount++; \
		}

	uint32 modeCount = 0;

	CHECK_DMA_MODE(multiword_dma_0_selected, 0x00);
	CHECK_DMA_MODE(multiword_dma_1_selected, 0x01);
	CHECK_DMA_MODE(multiword_dma_2_selected, 0x02);

	if (fInfoBlock.word_88_valid) {
		CHECK_DMA_MODE(ultra_dma_0_selected, 0x10);
		CHECK_DMA_MODE(ultra_dma_1_selected, 0x11);
		CHECK_DMA_MODE(ultra_dma_2_selected, 0x12);
		CHECK_DMA_MODE(ultra_dma_3_selected, 0x13);
		CHECK_DMA_MODE(ultra_dma_4_selected, 0x14);
		CHECK_DMA_MODE(ultra_dma_5_selected, 0x15);
		CHECK_DMA_MODE(ultra_dma_6_selected, 0x16);
	}

	#undef CHECK_DMA_MODE

	if (modeCount != 1) {
		TRACE_ERROR("more than one DMA mode selected, not using DMA\n");
		fUseDMA = false;
		return B_OK;
	}

	TRACE_ALWAYS("using DMA mode 0x%02x\n", fDMAMode);
	return B_OK;
}


status_t
ATADevice::Configure()
{
	// warning: ata == 0 means "this is ata"...
	if (fInfoBlock.word_0.ata.ata_device != ATA_WORD_0_ATA_DEVICE) {
		// CF has either magic header or CFA bit set
		// we merge it to "CFA bit set" for easier (later) testing
		if (fInfoBlock.word_0.raw == ATA_WORD_0_CFA_MAGIC)
			fInfoBlock.compact_flash_assoc_supported = true;
		else {
			TRACE_ERROR("infoblock indicates non-ata device\n");
			return B_ERROR;
		}
	}

	if (!fInfoBlock.lba_supported || (fInfoBlock.lba_sector_count == 0
		&& fInfoBlock.lba48_sector_count == 0)) {
		TRACE_ERROR("non-lba devices not supported\n");
		return B_ERROR;
	}

	fTotalSectors = fInfoBlock.SectorCount(fUse48Bits, false);
	fBlockSize = fInfoBlock.SectorSize();
	fPhysicalBlockSize = fInfoBlock.PhysicalSectorSize();
	fBlockOffset = fInfoBlock.BlockOffset();

	fTaskFile.lba.mode = ATA_MODE_LBA;
	fTaskFile.lba.device = fIndex;

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

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

	return B_OK;
}


status_t
ATADevice::Identify()
{
	snprintf(fDebugContext, sizeof(fDebugContext), "%s %" B_PRIu32 "-%u",
		IsATAPI() ? "pi" : "", fChannel->ChannelID(), fIndex);

	ATARequest request(false);
	request.SetDevice(this);
	request.SetTimeout(20 * 1000 * 1000);

	fRegisterMask = 0;
	fTaskFile.write.command = IsATAPI() ? ATA_COMMAND_IDENTIFY_PACKET_DEVICE
		: ATA_COMMAND_IDENTIFY_DEVICE;

	if (fChannel->SendRequest(&request,
			IsATAPI() ? 0 : ATA_DEVICE_READY_REQUIRED) != B_OK) {
		TRACE_ERROR("sending identify request failed\n");
		return B_ERROR;
	}

	if (fChannel->Wait(ATA_STATUS_BUSY | ATA_STATUS_DATA_REQUEST, 0,
			ATA_WAIT_ANY_BIT, 100 * 1000) != B_OK) {
		TRACE_ALWAYS("no data request and not busy within 100ms, assuming "
			"no device present\n");
		return B_TIMED_OUT;
	}

	if (fChannel->Wait(ATA_STATUS_DATA_REQUEST, ATA_STATUS_BUSY,
			ATA_CHECK_ERROR_BIT | ATA_CHECK_DEVICE_FAULT,
			IsATAPI() ? 20 * 1000 * 1000 : 500 * 1000) != B_OK) {
		TRACE_ERROR("timeout waiting for identify request\n");
		return B_TIMED_OUT;
	}

	// get the infoblock
	fChannel->ReadPIO((uint8 *)&fInfoBlock, sizeof(fInfoBlock));

	if (fChannel->WaitDataRequest(false) != B_OK) {
		TRACE_ERROR("device disagrees on info block length\n");
		return B_ERROR;
	}

	if (fChannel->FinishRequest(&request,
			ATA_WAIT_FINISH | (IsATAPI() ? 0 : ATA_DEVICE_READY_REQUIRED),
			ATA_ERROR_ABORTED) != B_OK) {
		TRACE_ERROR("failed to finish identify request\n");
		return B_ERROR;
	}

	if (1) {
		// print device information
		char modelNumber[sizeof(fInfoBlock.model_number) + 1];
		char serialNumber[sizeof(fInfoBlock.serial_number) + 1];
		char firmwareRev[sizeof(fInfoBlock.firmware_revision) + 1];
		strlcpy(modelNumber, fInfoBlock.model_number, sizeof(modelNumber));
		strlcpy(serialNumber, fInfoBlock.serial_number, sizeof(serialNumber));
		strlcpy(firmwareRev, fInfoBlock.firmware_revision, sizeof(firmwareRev));
		swap_words(modelNumber, sizeof(modelNumber) - 1);
		swap_words(serialNumber, sizeof(serialNumber) - 1);
		swap_words(firmwareRev, sizeof(firmwareRev) - 1);
		TRACE_ALWAYS("model number: %s\n", modelNumber);
		TRACE_ALWAYS("serial number: %s\n", serialNumber);
  		TRACE_ALWAYS("firmware rev.: %s\n", firmwareRev);
	}

	return B_OK;
}


status_t
ATADevice::ExecuteReadWrite(ATARequest *request, uint64 address,
	uint32 sectorCount)
{
	request->SetUseDMA(fUseDMA && fChannel->PrepareDMA(request) == B_OK);
	if (!request->UseDMA())
		request->PrepareSGInfo();

	request->SetBytesLeft(sectorCount * fBlockSize);
	if (_FillTaskFile(request, address) != B_OK) {
		TRACE_ERROR("failed to setup transfer request\n");
		if (request->UseDMA())
			fChannel->FinishDMA();
		return B_ERROR;
	}

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

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

		result = fChannel->WaitForInterrupt(request->Timeout());
		status_t dmaResult = fChannel->FinishDMA();
		if (result == B_OK && dmaResult == B_OK) {
			fDMAFailures = 0;
			request->CCB()->data_resid = 0;
		} else {
			if (dmaResult != B_OK) {
				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;
				}
			} else {
				// timeout
				request->SetStatus(SCSI_CMD_TIMEOUT);
			}
		}
	} else {
		if (fChannel->Wait(ATA_STATUS_DATA_REQUEST, 0, ATA_CHECK_ERROR_BIT
				| ATA_CHECK_DEVICE_FAULT, request->Timeout()) != B_OK) {
			TRACE_ERROR("timeout waiting for device to request data\n");
			request->SetStatus(SCSI_CMD_TIMEOUT);
			return B_TIMED_OUT;
		}

		if (fChannel->ExecutePIOTransfer(request) != B_OK) {
			TRACE_ERROR("executing pio transfer failed\n");
			request->SetStatus(SCSI_SEQUENCE_FAIL);
		}
	}

	return fChannel->FinishRequest(request, ATA_WAIT_FINISH
		| ATA_DEVICE_READY_REQUIRED, ATA_ERROR_ALL);
}


status_t
ATADevice::_FillTaskFile(ATARequest *request, uint64 address)
{
	// list of LBA48 opcodes
	static const uint8 s48BitCommands[2][2] = {
		{ ATA_COMMAND_READ_SECTORS_EXT, ATA_COMMAND_WRITE_SECTORS_EXT },
		{ ATA_COMMAND_READ_DMA_EXT, ATA_COMMAND_WRITE_DMA_EXT }
	};

	// list of normal LBA opcodes
	static const uint8 s28BitCommands[2][2] = {
		{ ATA_COMMAND_READ_SECTORS, ATA_COMMAND_WRITE_SECTORS },
		{ ATA_COMMAND_READ_DMA, ATA_COMMAND_WRITE_DMA }
	};

	uint32 sectorCount = *request->BytesLeft() / fBlockSize;
	TRACE("about to transfer %lu sectors\n", sectorCount);

	if (fUse48Bits
		&& (address + sectorCount > 0xfffffff || sectorCount > 0x100)) {
		// use LBA48 only if necessary
		if (sectorCount > 0xffff) {
			TRACE_ERROR("invalid sector count %lu\n", sectorCount);
			request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST,
				SCSIS_ASC_INV_CDB_FIELD);
			return B_ERROR;
		}

		fRegisterMask = ATA_MASK_SECTOR_COUNT_48
			| ATA_MASK_LBA_LOW_48
			| ATA_MASK_LBA_MID_48
			| ATA_MASK_LBA_HIGH_48;

		fTaskFile.lba48.sector_count_0_7 = sectorCount & 0xff;
		fTaskFile.lba48.sector_count_8_15 = (sectorCount >> 8) & 0xff;
		fTaskFile.lba48.lba_0_7 = address & 0xff;
		fTaskFile.lba48.lba_8_15 = (address >> 8) & 0xff;
		fTaskFile.lba48.lba_16_23 = (address >> 16) & 0xff;
		fTaskFile.lba48.lba_24_31 = (address >> 24) & 0xff;
		fTaskFile.lba48.lba_32_39 = (address >> 32) & 0xff;
		fTaskFile.lba48.lba_40_47 = (address >> 40) & 0xff;
		fTaskFile.lba48.command = s48BitCommands[request->UseDMA()
			? 1 : 0][request->IsWrite() ? 1 : 0];
	} else {
		// normal LBA
		if (sectorCount > 0x100) {
			TRACE_ERROR("invalid sector count %lu\n", sectorCount);
			request->SetSense(SCSIS_KEY_ILLEGAL_REQUEST,
				SCSIS_ASC_INV_CDB_FIELD);
			return B_ERROR;
		}

		fRegisterMask = ATA_MASK_SECTOR_COUNT
			| ATA_MASK_LBA_LOW
			| ATA_MASK_LBA_MID
			| ATA_MASK_LBA_HIGH
			| ATA_MASK_DEVICE_HEAD;

		fTaskFile.lba.sector_count = sectorCount & 0xff;
		fTaskFile.lba.lba_0_7 = address & 0xff;
		fTaskFile.lba.lba_8_15 = (address >> 8) & 0xff;
		fTaskFile.lba.lba_16_23 = (address >> 16) & 0xff;
		fTaskFile.lba.lba_24_27 = (address >> 24) & 0xf;
		fTaskFile.lba.command = s28BitCommands[request->UseDMA()
			? 1 : 0][request->IsWrite() ? 1 : 0];
	}

	return B_OK;
}