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


scsi_for_sim_interface *gSCSIModule = NULL;
device_manager_info *gDeviceManager = NULL;


static status_t
ata_sim_init_bus(device_node *node, void **cookie)
{
	ATAChannel *channel = new(std::nothrow) ATAChannel(node);
	if (channel == NULL)
		return B_NO_MEMORY;

	status_t result = channel->InitCheck();
	if (result != B_OK) {
		TRACE_ERROR("failed to set up ata channel object\n");
		delete channel;
		return result;
	}

	*cookie = channel;
	return B_OK;
}


static void
ata_sim_uninit_bus(void *cookie)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	delete channel;
}


static void
ata_sim_bus_removed(void *cookie)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() != NULL) {
		gSCSIModule->block_bus(channel->Bus());
		channel->SetBus(NULL);
	}
}


static void
ata_sim_set_scsi_bus(scsi_sim_cookie cookie, scsi_bus bus)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	channel->SetBus(bus);
	channel->ScanBus();
}


static void
ata_sim_scsi_io(scsi_sim_cookie cookie, scsi_ccb *ccb)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() == NULL) {
		ccb->subsys_status = SCSI_NO_HBA;
		gSCSIModule->finished(ccb, 1);
		return;
	}

	if (channel->ExecuteIO(ccb) == B_BUSY)
		gSCSIModule->requeue(ccb, true);
}


static uchar
ata_sim_abort(scsi_sim_cookie cookie, scsi_ccb *ccb)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() == NULL)
		return SCSI_NO_HBA;

	// aborting individual commands is not possible
	return SCSI_REQ_CMP;
}


static uchar
ata_sim_reset_device(scsi_sim_cookie cookie, uchar targetId, uchar targetLun)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() == NULL)
		return SCSI_NO_HBA;

	// TODO: implement
	return SCSI_REQ_INVALID;
}


static uchar
ata_sim_term_io(scsi_sim_cookie cookie, scsi_ccb *ccb)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() == NULL)
		return SCSI_NO_HBA;

	// we don't terminate commands, ignore
	return SCSI_REQ_CMP;
}


static uchar
ata_sim_path_inquiry(scsi_sim_cookie cookie, scsi_path_inquiry *info)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() == NULL)
		return SCSI_NO_HBA;

	channel->PathInquiry(info);
	return SCSI_REQ_CMP;
}


static uchar
ata_sim_rescan_bus(scsi_sim_cookie cookie)
{
	// TODO: implement
	return SCSI_REQ_CMP;
}


static uchar
ata_sim_reset_bus(scsi_sim_cookie cookie)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	if (channel->Bus() == NULL)
		return SCSI_NO_HBA;

	//channel->Reset();
	panic("asking for trouble");
	return SCSI_REQ_CMP;
}


static void
ata_sim_get_restrictions(scsi_sim_cookie cookie, uchar targetID,
	bool *isATAPI, bool *noAutoSense, uint32 *maxBlocks)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	channel->GetRestrictions(targetID, isATAPI, noAutoSense, maxBlocks);
}


static status_t
ata_sim_control(scsi_sim_cookie cookie, uchar targetID, uint32 op, void *buffer,
	size_t length)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	return channel->Control(targetID, op, buffer, length);
}


status_t
ata_channel_added(device_node *parent)
{
	const char *controllerName;
	if (gDeviceManager->get_attr_string(parent,
		ATA_CONTROLLER_CONTROLLER_NAME_ITEM, &controllerName, true) != B_OK) {
		TRACE_ERROR("controller name missing\n");
		return B_ERROR;
	}

	int32 channelID = gDeviceManager->create_id(ATA_CHANNEL_ID_GENERATOR);
	if (channelID < 0) {
		TRACE_ERROR("out of channel ids\n");
		return B_ERROR;
	}

	device_attr attributes[] = {
		{
			B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
				{ .string = SCSI_FOR_SIM_MODULE_NAME }
		},

		{
			SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE,
				{ .string = controllerName }
		},

		// maximum number of blocks per transmission:
		// - ATAPI uses packets, i.e. normal SCSI limits apply
		//   but I'm not sure about controller restrictions
		// - ATA allows up to 256 blocks for LBA28 and 65535 for LBA48
		// to fix specific drive bugs use ATAChannel::GetRestrictions()
		{ B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { .ui32 = 0xffff } },
		{ ATA_CHANNEL_ID_ITEM, B_UINT32_TYPE, { .ui32 = (uint32)channelID } },
		{ NULL }
	};

	return gDeviceManager->register_node(parent, ATA_SIM_MODULE_NAME,
		attributes, NULL, NULL);
}


status_t
ata_interrupt_handler(void *cookie, uint8 status)
{
	ATAChannel *channel = (ATAChannel *)cookie;
	return channel->Interrupt(status);
}


static status_t
std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
		case B_MODULE_UNINIT:
			return B_OK;

		default:
			break;
	}

	return B_ERROR;
}


scsi_sim_interface ata_sim_module = {
	{
		{
			ATA_SIM_MODULE_NAME,
			0,
			std_ops
		},

		NULL, // supported devices
		NULL, // register node
		ata_sim_init_bus,
		ata_sim_uninit_bus,
		NULL, // register child devices
		NULL, // rescan
		ata_sim_bus_removed,
		NULL, // suspend
		NULL, // resume
	},

	ata_sim_set_scsi_bus,
	ata_sim_scsi_io,
	ata_sim_abort,
	ata_sim_reset_device,
	ata_sim_term_io,
	ata_sim_path_inquiry,
	ata_sim_rescan_bus,
	ata_sim_reset_bus,
	ata_sim_get_restrictions,
	ata_sim_control
};

ata_for_controller_interface ata_for_controller_module = {
	{
		{
			ATA_FOR_CONTROLLER_MODULE_NAME,
			0,
			&std_ops
		},

		NULL, // supported devices
		ata_channel_added,
		NULL,
		NULL,
		NULL
	},

	ata_interrupt_handler
};


module_dependency module_dependencies[] = {
	{ SCSI_FOR_SIM_MODULE_NAME, (module_info **)&gSCSIModule },
	{ B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&gDeviceManager },
	{}
};

module_info *modules[] = {
	(module_info *)&ata_for_controller_module,
	(module_info *)&ata_sim_module,
	NULL
};