/*
 * Copyright 2007-2009, Marcus Overhagen. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include "ahci_controller.h"

#include <KernelExport.h>
#include <string.h>
#include <new>

#define TRACE(a...) dprintf("ahci: " a)
//#define FLOW(a...)	dprintf("ahci: " a)
#define FLOW(a...)


//	#pragma mark - SIM module interface


static void
ahci_set_scsi_bus(scsi_sim_cookie cookie, scsi_bus bus)
{
}


//! execute request
static void
ahci_scsi_io(scsi_sim_cookie cookie, scsi_ccb *request)
{
	FLOW("ahci_scsi_io, cookie %p, path_id %u, target_id %u, target_lun %u\n",
		cookie, request->path_id, request->target_id, request->target_lun);
	static_cast<AHCIController *>(cookie)->ExecuteRequest(request);
}


//! abort request
static uchar
ahci_abort_io(scsi_sim_cookie cookie, scsi_ccb *request)
{
	TRACE("ahci_abort_io, cookie %p\n", cookie);
	return static_cast<AHCIController *>(cookie)->AbortRequest(request);
}


static uchar
ahci_reset_device(scsi_sim_cookie cookie, uchar targetID, uchar targetLUN)
{
	TRACE("ahci_reset_device, cookie %p\n", cookie);
	return static_cast<AHCIController *>(cookie)->ResetDevice(targetID, targetLUN);
}


//! terminate request
static uchar
ahci_terminate_io(scsi_sim_cookie cookie, scsi_ccb *request)
{
	TRACE("ahci_terminate_io, cookie %p\n", cookie);
	return static_cast<AHCIController *>(cookie)->TerminateRequest(request);
}


//! get information about bus
static uchar
ahci_path_inquiry(scsi_sim_cookie cookie, scsi_path_inquiry *info)
{
	TRACE("ahci_path_inquiry, cookie %p\n", cookie);

	memset(info, 0, sizeof(*info));
	info->version_num = 1;
	// supports tagged requests and soft reset
	info->hba_inquiry = 0; // SCSI_PI_TAG_ABLE | SCSI_PI_SOFT_RST;
	// controller is 32, devices are 0 to 31
	info->initiator_id = 32;
	// adapter command queue size
	info->hba_queue_size = 1;

	return SCSI_REQ_CMP;
}


//! this is called immediately before the SCSI bus manager scans the bus
static uchar
ahci_scan_bus(scsi_sim_cookie cookie)
{
	TRACE("ahci_scan_bus, cookie %p\n", cookie);

	return SCSI_REQ_CMP;
}


static uchar
ahci_reset_bus(scsi_sim_cookie cookie)
{
	TRACE("ahci_reset_bus, cookie %p\n", cookie);

	return SCSI_REQ_CMP;
}


/*!	Get restrictions of one device
	(used for non-SCSI transport protocols and bug fixes)
*/
static void
ahci_get_restrictions(scsi_sim_cookie cookie, uchar targetID, bool *isATAPI,
	bool *noAutoSense, uint32 *maxBlocks)
{
	TRACE("ahci_get_restrictions, cookie %p\n", cookie);

	static_cast<AHCIController *>(cookie)->GetRestrictions(targetID, isATAPI, noAutoSense, maxBlocks);
}


static status_t
ahci_ioctl(scsi_sim_cookie cookie, uint8 targetID, uint32 op, void *buffer,
	size_t length)
{
	TRACE("ahci_ioctl, cookie %p\n", cookie);
	return B_DEV_INVALID_IOCTL;
}


//	#pragma mark -


static status_t
ahci_sim_init_bus(device_node *node, void **_cookie)
{
	TRACE("ahci_sim_init_bus\n");

	// get the PCI device from our parent's parent
	device_node *parent = gDeviceManager->get_parent_node(node);
	device_node *pciParent = gDeviceManager->get_parent_node(parent);
	gDeviceManager->put_node(parent);

	pci_device_module_info *pci;
	pci_device *pciDevice;
	gDeviceManager->get_driver(pciParent, (driver_module_info **)&pci,
		(void **)&pciDevice);
	gDeviceManager->put_node(pciParent);

	TRACE("ahci_sim_init_bus: pciDevice %p\n", pciDevice);

	AHCIController *controller =  new(std::nothrow) AHCIController(node, pci,
		pciDevice);
	if (!controller)
		return B_NO_MEMORY;
	status_t status = controller->Init();
	if (status < B_OK) {
		delete controller;
		return status;
	}

	*_cookie = controller;
	TRACE("cookie = %p\n", *_cookie);
	return B_OK;
}


static void
ahci_sim_uninit_bus(void *cookie)
{
	TRACE("ahci_sim_uninit_bus, cookie %p\n", cookie);
	AHCIController *controller = static_cast<AHCIController *>(cookie);

	controller->Uninit();
	delete controller;
}


static void
ahci_sim_bus_removed(void *cookie)
{
	TRACE("ahci_sim_bus_removed, cookie %p\n", cookie);
}


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

		default:
			return B_ERROR;
	}
}


scsi_sim_interface gAHCISimInterface = {
	{
		{
			AHCI_SIM_MODULE_NAME,
			0,
			std_ops
		},
		NULL,	// supported devices
		NULL,	// register node
		ahci_sim_init_bus,
		ahci_sim_uninit_bus,
		NULL,	// register child devices
		NULL,	// rescan
		ahci_sim_bus_removed
	},
	ahci_set_scsi_bus,
	ahci_scsi_io,
	ahci_abort_io,
	ahci_reset_device,
	ahci_terminate_io,
	ahci_path_inquiry,
	ahci_scan_bus,
	ahci_reset_bus,
	ahci_get_restrictions,
	ahci_ioctl
};