/*
 * Copyright 2017, Alexander Coers. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#include "highpoint_ata.h"

#include <ata_adapter.h>
#include <malloc.h>
#include <KernelExport.h>

#include <stdlib.h>
#include <string.h>


#define INFO(a...)			dprintf("Highpoint-IDE: " a)

//#define TRACE_HIGHPOINT
#ifdef TRACE_HIGHPOINT
#define TRACE(a...)		dprintf("Highpoint-IDE: " a)
#define TRACE_ONLY
#else
#define TRACE(a...)
#define TRACE_ONLY __attribute__((unused))
#endif


#define HIGHPOINT_IDE_PCI_CONTROLLER_MODULE_NAME "busses/ata/highpoint_ide_pci/driver_v1"
#define HIGHPOINT_IDE_PCI_CHANNEL_MODULE_NAME    "busses/ata/highpoint_ide_pci/channel/v1"


static ata_for_controller_interface *sATA;
static ata_adapter_interface *sATAAdapter;
static device_manager_info *sDeviceManager;

struct HPT_controller_info *HPT_info;


// #pragma mark - helper functions


static void
set_channel(void *cookie, ata_channel channel)
{
	TRACE("set_channel()\n");

	sATAAdapter->set_channel((ata_adapter_channel_info *)cookie, channel);
}


static status_t
write_command_block_regs(void *channel_cookie, ata_task_file *tf,
	ata_reg_mask mask)
{
	TRACE("write_command_block_regs()\n");

	return sATAAdapter->write_command_block_regs(
		(ata_adapter_channel_info *)channel_cookie, tf, mask);
}


static status_t
read_command_block_regs(void *channel_cookie, ata_task_file *tf,
	ata_reg_mask mask)
{
	TRACE("read_command_block_regs()\n");

	return sATAAdapter->read_command_block_regs(
		(ata_adapter_channel_info *)channel_cookie, tf, mask);
}


static uint8
get_altstatus(void *channel_cookie)
{
	TRACE("get_altstatus()\n");

	return sATAAdapter->get_altstatus(
		(ata_adapter_channel_info *)channel_cookie);
}


static status_t
write_device_control(void *channel_cookie, uint8 val)
{
	TRACE("write_device_control()\n");

	return sATAAdapter->write_device_control(
		(ata_adapter_channel_info *)channel_cookie, val);
}


static status_t
write_pio(void *channel_cookie, uint16 *data, int count, bool force_16bit)
{
	TRACE("write_pio()\n");

	return sATAAdapter->write_pio((ata_adapter_channel_info *)channel_cookie,
		data, count, force_16bit);
}


static status_t
read_pio(void *channel_cookie, uint16 *data, int count, bool force_16bit)
{
	TRACE("read_pio()\n");

	return sATAAdapter->read_pio((ata_adapter_channel_info *)channel_cookie,
		data, count, force_16bit);
}


static status_t
prepare_dma(void *channel_cookie, const physical_entry *sg_list,
	size_t sg_list_count, bool to_device)
{
	TRACE("prepare_dma()\n");

	return sATAAdapter->prepare_dma((ata_adapter_channel_info *)channel_cookie,
		sg_list, sg_list_count, to_device);
}


static status_t
start_dma(void *channel_cookie)
{
	TRACE("start_dma()\n");

	return sATAAdapter->start_dma((ata_adapter_channel_info *)channel_cookie);
}


static status_t
finish_dma(void *channel_cookie)
{
	TRACE("finish_dma()\n");

	return sATAAdapter->finish_dma((ata_adapter_channel_info *)channel_cookie);
}


static status_t
init_channel(device_node *node, void **channel_cookie)
{
	status_t result;
	uint8 channel_index;

	TRACE("init_channel(): node: %p, cookie: %p\n", node, channel_cookie);

#if 0 /* debug */
	uint8 bus = 0, device = 0, function = 0;
	uint16 vendorID=0xffff, deviceID=0xffff;
	sDeviceManager->get_attr_uint16(node, B_DEVICE_VENDOR_ID, &vendorID, true);
	sDeviceManager->get_attr_uint16(node, B_DEVICE_ID, &deviceID, true);
	TRACE("init_channel():init_channel(): bus %3d, device %2d, function %2d: vendor %04x, device %04x\n",
		bus, device, function, vendorID, deviceID);
	if (vendorID != ATA_HIGHPOINT_ID) {
		TRACE ("unsupported! Vendor ID: %x\n",vendorID);
		return B_ERROR;
	}
#endif

	result = sATAAdapter->init_channel(node,
		(ata_adapter_channel_info **)channel_cookie,
		sizeof(ata_adapter_channel_info), sATAAdapter->inthand);
	// from here we have valid channel...
	ata_adapter_channel_info *channel TRACE_ONLY = NULL;
	channel = (ata_adapter_channel_info *)*channel_cookie;

	if (sDeviceManager->get_attr_uint8(node, ATA_ADAPTER_CHANNEL_INDEX,
			&channel_index, false) != B_OK)  {
		TRACE("init_channel(): channel not set, strange!\n");
		return B_ERROR;
	}

	TRACE("init_channel(): channel command %x, control %x, result: %d \n",
		channel->command_block_base,
		channel->control_block_base, (int)result);
	TRACE("init_channel(): index #%d done. HPT_info deviceID: %04x, config option %x, "
		"revision %2d, function %2d \n", channel_index, HPT_info->deviceID,
		HPT_info->configOption, HPT_info->revisionID, HPT_info->function);
	return result;
}


static void
uninit_channel(void *channel_cookie)
{
	TRACE("uninit_channel()\n");

	sATAAdapter->uninit_channel((ata_adapter_channel_info *)channel_cookie);
}


static void
channel_removed(void *channel_cookie)
{
	TRACE("channel_removed()\n");

	sATAAdapter->channel_removed((ata_adapter_channel_info *)channel_cookie);
}


static status_t
init_controller(device_node *node, ata_adapter_controller_info **cookie)
{
	pci_device_module_info *pci;
	pci_device *pci_device;
	pci_info info;
	uint16 devID = 0xffff;
	uint8 revisionID = 0xff;
	uint8 function = 0xff;

	status_t result;

	// we need some our info structure here
	HPT_info = (struct HPT_controller_info *) malloc(sizeof(HPT_controller_info));
	if (HPT_info == NULL)
		return B_NO_MEMORY;

	result = sATAAdapter->init_controller(node, cookie,
		sizeof(ata_adapter_controller_info));

	if (result == B_OK) {
		// get device info
		device_node *parent = sDeviceManager->get_parent_node(node);
		sDeviceManager->get_driver(parent, (driver_module_info **)&pci, (void **)&pci_device);
		// read registers
		pci->get_pci_info(pci_device,&info);
		devID = info.device_id;
		revisionID = info.revision;
		function = info.function;

		HPT_info->deviceID = devID;
		HPT_info->revisionID = revisionID;
		HPT_info->function = function;

		INFO("found: device: %x, revision: %x, function: %x\n",devID,revisionID,function);

		// setting different config options
		if (devID == ATA_HPT366) {
			switch (revisionID) {
			case 0:
				HPT_info->configOption = CFG_HPT366_OLD;
				HPT_info->maxDMA = ATA_ULTRA_DMA4;
				break;
			case 1:
			case 2:
				HPT_info->configOption = CFG_HPT366;
				HPT_info->maxDMA = ATA_ULTRA_DMA4;
				break;
			case 3:
				HPT_info->configOption = CFG_HPT370;
				HPT_info->maxDMA = ATA_ULTRA_DMA5;
				break;
			case 5:
				HPT_info->configOption = CFG_HPT372;
				HPT_info->maxDMA = ATA_ULTRA_DMA6;
				break;
			default:
				HPT_info->configOption = CFG_HPTUnknown;
				HPT_info->maxDMA = ATA_ULTRA_DMA0;
			}
		} else {
			if (devID == ATA_HPT374) {
				HPT_info->configOption = CFG_HPT374;
				HPT_info->maxDMA = ATA_ULTRA_DMA6;
			} else {
				// all other versions use this config
				HPT_info->configOption = CFG_HPT372;
				HPT_info->maxDMA = ATA_ULTRA_DMA6;
			}
		}

		if (HPT_info->configOption == CFG_HPT366_OLD) {
			/* disable interrupt prediction */
			pci->write_pci_config(pci_device, 0x51, 1, (pci->read_pci_config(pci_device, 0x51, 1) & ~0x80));
			INFO("Highpoint-ATA: old revision found.\n");
	    } else {
			/* disable interrupt prediction */
			pci->write_pci_config(pci_device, 0x51, 1, (pci->read_pci_config(pci_device, 0x51, 1) & ~0x03));
			pci->write_pci_config(pci_device, 0x55, 1, (pci->read_pci_config(pci_device, 0x55, 1) & ~0x03));

			/* enable interrupts */
			pci->write_pci_config(pci_device, 0x5a, 1, (pci->read_pci_config(pci_device, 0x5a, 1) & ~0x10));

			/* set clocks etc */
			if (HPT_info->configOption < CFG_HPT372) {
    			pci->write_pci_config(pci_device, 0x5b, 1, 0x22);
	    	} else {
    			pci->write_pci_config(pci_device, 0x5b, 1,
		     		(pci->read_pci_config(pci_device, 0x5b, 1) & 0x01) | 0x20);
	    	}
		}
	}
	return result;
}


static void
uninit_controller(ata_adapter_controller_info *controller)
{
	TRACE("uninit_controller()\n");
	free(HPT_info);
	sATAAdapter->uninit_controller(controller);
}


static void
controller_removed(ata_adapter_controller_info *controller)
{
	TRACE("controller_removed()\n");

	return sATAAdapter->controller_removed(controller);
}


static status_t
probe_controller(device_node *parent)
{
	status_t result;
	result = sATAAdapter->probe_controller(parent,
		HIGHPOINT_IDE_PCI_CONTROLLER_MODULE_NAME, "highpoint_ide_pci",
		"Highpoint IDE PCI Controller",
		HIGHPOINT_IDE_PCI_CHANNEL_MODULE_NAME,
		true,
		true,					// assume that command queuing works
		1,						// assume 16 bit alignment is enough
		0xffff,					// boundary is on 64k according to spec
		0x10000,				// up to 64k per S/G block according to spec
		false);					// by default, compatibility mode is used, not for HPT!

	TRACE("probe_controller(): probe result: %x\n",(int)result);
	return result;
}


static float
supports_device(device_node *parent)
{
	TRACE("supports_device()\n");

	const char *bus;
	uint16 baseClass, subClass;
	uint16 vendorID;
	uint16 deviceID;
	float result = -1.0f;

	// make sure parent is an PCI IDE mass storage host adapter device node
	if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false) != B_OK
		|| sDeviceManager->get_attr_uint16(parent, B_DEVICE_TYPE, &baseClass, false) != B_OK
		|| sDeviceManager->get_attr_uint16(parent, B_DEVICE_SUB_TYPE, &subClass, false) != B_OK
		|| sDeviceManager->get_attr_uint16(parent, B_DEVICE_VENDOR_ID, &vendorID, false) != B_OK
		|| sDeviceManager->get_attr_uint16(parent, B_DEVICE_ID, &deviceID, false) != B_OK)
		return -1.0f;

	// No PCI bus OR no mass storage OR no Highpoint device = bail out
	if (vendorID != ATA_HIGHPOINT_ID) {
		TRACE("supports_device(): unsupported device: vendor ID: %x, deviceID: %x\n",vendorID, deviceID);
		return 0.0f;
	}

	// check if mass storage controller
	if ((subClass == PCI_ide) || (subClass == PCI_mass_storage_other)) {
		switch (deviceID) {
 		case ATA_HPT302:
 			// UDMA 6
 		case ATA_HPT366:
 			// UDMA 4, Rev 0 & 2
 			// UDMA 5, Rev 3
 		 	// UDMA 6, Rev 5
 		case ATA_HPT371:
 		case ATA_HPT372:
 		case ATA_HPT374:
 			// UDMA 6
			result = 1.0f;
			break;
		default:
			// device not supported, should be covered by generic ata driver
			result = 0.0f;
		}
	}
	INFO("supporting device Vendor ID: %x, deviceID: %x, result %f\n", vendorID, deviceID, result);
	return result;
}

// #pragma mark - module dependencies

module_dependency module_dependencies[] = {
	{ ATA_FOR_CONTROLLER_MODULE_NAME, (module_info **)&sATA },
	{ B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
	{ ATA_ADAPTER_MODULE_NAME, (module_info **)&sATAAdapter },
	{}
};


static ata_controller_interface channel_interface = {
	{
		{
			HIGHPOINT_IDE_PCI_CHANNEL_MODULE_NAME,
			0,
			NULL
		},

		NULL,	// supports device
		NULL,	// register device
		init_channel,
		uninit_channel,
		NULL,	// register child devices
		NULL,	// rescan
		channel_removed,
	},

	&set_channel,

	&write_command_block_regs,
	&read_command_block_regs,

	&get_altstatus,
	&write_device_control,

	&write_pio,
	&read_pio,

	&prepare_dma,
	&start_dma,
	&finish_dma,
};


static driver_module_info controller_interface = {
	{
		HIGHPOINT_IDE_PCI_CONTROLLER_MODULE_NAME,
		0,
		NULL
	},

	supports_device,
	probe_controller,
	(status_t (*)(device_node *, void **))	init_controller,
	(void (*)(void *))						uninit_controller,
	NULL,	// register child devices
	NULL,	// rescan
	(void (*)(void *))						controller_removed,
};

module_info *modules[] = {
	(module_info *)&controller_interface,
	(module_info *)&channel_interface,
	NULL
};