/*
 * Copyright 2007, Ithamar R. Adema. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


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

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


#define DRIVER_PRETTY_NAME	"Legacy SATA"
#define CONTROLLER_NAME		DRIVER_PRETTY_NAME
#define CONTROLLER_MODULE_NAME	"busses/ata/legacy_sata/driver_v1"
#define CHANNEL_MODULE_NAME	"busses/ata/legacy_sata/channel/v1"

#define TRACE(a...)		dprintf(DRIVER_PRETTY_NAME ": " a)
#define FLOW(a...)		dprintf(DRIVER_PRETTY_NAME ": " a)

#define PCI_vendor_VIA		0x1106
#define PCI_device_VIA6420	0x3149
#define PCI_device_VIA6421	0x3249
#define PCI_device_VIA8237A	0x0591

#define PCI_vendor_ALI		0x10b9
#define PCI_device_ALI5289	0x5289
#define PCI_device_ALI5287	0x5287
#define PCI_device_ALI5281	0x5281

#define PCI_vendor_NVIDIA	0x10de
#define PCI_device_NF2PROS1	0x008e
#define PCI_device_NF3PROS1	0x00e3
#define PCI_device_NF3PROS2	0x00ee
#define PCI_device_MCP4S1	0x0036
#define PCI_device_MCP4S2	0x003e
#define PCI_device_CK804S1	0x0054
#define PCI_device_CK804S2	0x0055
#define PCI_device_MCP51S1	0x0266
#define PCI_device_MCP51S2	0x0267
#define PCI_device_MCP55S1	0x037e
#define PCI_device_MCP55S2	0x037f
#define PCI_device_MCP61S1	0x03e7
#define PCI_device_MCP61S2	0x03f6
#define PCI_device_MCP61S3	0x03f7

#define ID(v,d) (((v)<< 16) | (d))


static const char * const kChannelNames[] = {
	"Primary Channel", "Secondary Channel",
	"Tertiary Channel", "Quaternary Channel"
};

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


static float
controller_supports(device_node *parent)
{
	uint16 vendor_id;
	uint16 device_id;
	status_t res;
	const char *bus = NULL;

	// get the bus (should be PCI)
	if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false) != B_OK)
		return B_ERROR;
	if (strcmp(bus, "pci") != 0) {
		return B_ERROR;
	}

	// get vendor and device ID
	if ((res = sDeviceManager->get_attr_uint16(parent, B_DEVICE_VENDOR_ID, &vendor_id, false)) != B_OK
		|| (res = sDeviceManager->get_attr_uint16(parent, B_DEVICE_ID, &device_id, false)) != B_OK) {
		return res;
	}

	switch (ID(vendor_id, device_id)) {
		/* VIA SATA chipsets */
		case ID(PCI_vendor_VIA, PCI_device_VIA6420):
		case ID(PCI_vendor_VIA, PCI_device_VIA6421):
		case ID(PCI_vendor_VIA, PCI_device_VIA8237A):
			break;

		/* ALI SATA chipsets */
		case ID(PCI_vendor_ALI, PCI_device_ALI5281):
		case ID(PCI_vendor_ALI, PCI_device_ALI5287):
		case ID(PCI_vendor_ALI, PCI_device_ALI5289):
			break;

		/* NVidia NForce chipsets */
		case ID(PCI_vendor_NVIDIA, PCI_device_NF2PROS1):
		case ID(PCI_vendor_NVIDIA, PCI_device_NF3PROS1):
		case ID(PCI_vendor_NVIDIA, PCI_device_NF3PROS2):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP4S1):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP4S2):
		case ID(PCI_vendor_NVIDIA, PCI_device_CK804S1):
		case ID(PCI_vendor_NVIDIA, PCI_device_CK804S2):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP51S1):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP51S2):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP55S1):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP55S2):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP61S1):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP61S2):
		case ID(PCI_vendor_NVIDIA, PCI_device_MCP61S3):
			break;

		default:
			return 0.0f;
	}

	TRACE("controller found! vendor 0x%04x, device 0x%04x\n", vendor_id, device_id);

	return 0.8f;
}


static status_t
controller_probe(device_node *parent)
{
	device_node *controller_node;
	device_node *channels[4];
	uint16 command_block_base[4];
	uint16 control_block_base[4];
	pci_device_module_info *pci;
	uint8 num_channels = 2;
	uint32 bus_master_base;
	pci_device *device = NULL;
	uint16 device_id;
	uint16 vendor_id;
	uint8 int_num;
	status_t res;
	uint8 index;

	TRACE("controller_probe\n");

	sDeviceManager->get_driver(parent, (driver_module_info **)&pci, (void **)&device);

	device_id = pci->read_pci_config(device, PCI_device_id, 2);
	vendor_id = pci->read_pci_config(device, PCI_vendor_id, 2);
	int_num = pci->read_pci_config(device, PCI_interrupt_line, 1);
	bus_master_base = pci->read_pci_config(device, PCI_base_registers + 16, 4);

	/* Default PCI assigments */
	command_block_base[0] = pci->read_pci_config(device, PCI_base_registers + 0, 4);
	control_block_base[0] = pci->read_pci_config(device, PCI_base_registers + 4, 4);
	command_block_base[1] = pci->read_pci_config(device, PCI_base_registers + 8, 4);
	control_block_base[1] = pci->read_pci_config(device, PCI_base_registers + 12, 4);

	/* enable PCI interrupt */
	pci->write_pci_config(device, PCI_command, 2,
		pci->read_pci_config(device, PCI_command, 2) & ~PCI_command_int_disable);

	if (vendor_id == PCI_vendor_NVIDIA) {
		/* enable control access */
		pci->write_pci_config(device, 0x50, 1,
			pci->read_pci_config(device, 0x50, 1) | 0x04);
	}

	switch (ID(vendor_id, device_id)) {
		case ID(PCI_vendor_VIA,PCI_device_VIA6421):
			/* newer SATA chips has resources in one BAR for each channel */
			num_channels = 4;
			command_block_base[0] = pci->read_pci_config(device, PCI_base_registers + 0, 4);
			control_block_base[0] = command_block_base[0] + 8;
			command_block_base[1] = pci->read_pci_config(device, PCI_base_registers + 4, 4);
			control_block_base[1] = command_block_base[1] + 8;
			command_block_base[2] = pci->read_pci_config(device, PCI_base_registers + 8, 4);
			control_block_base[2] = command_block_base[2] + 8;
			command_block_base[3] = pci->read_pci_config(device, PCI_base_registers + 12, 4);
			control_block_base[3] = command_block_base[3] + 8;
			break;

		case ID(PCI_vendor_ALI, PCI_device_ALI5287):
			num_channels = 4;
			command_block_base[2] = pci->read_pci_config(device, PCI_base_registers + 0, 4) + 8;
			control_block_base[2] = pci->read_pci_config(device, PCI_base_registers + 4, 4) + 4;
			command_block_base[3] = pci->read_pci_config(device, PCI_base_registers + 8, 4) + 8;
			control_block_base[3] = pci->read_pci_config(device, PCI_base_registers + 12, 4) + 4;
			break;
	}

	bus_master_base &= PCI_address_io_mask;
	for (index = 0; index < num_channels; index++) {
		command_block_base[index] &= PCI_address_io_mask;
		control_block_base[index] &= PCI_address_io_mask;
	}

	res = sATAAdapter->detect_controller(pci, device, parent, bus_master_base,
		CONTROLLER_MODULE_NAME, "" /* XXX: unused: controller_driver_type*/, CONTROLLER_NAME, true,
		true, 1, 0xffff, 0x10000, &controller_node);
	// don't register if controller is already registered!
	// (happens during rescan; registering new channels would kick out old channels)
	if (res != B_OK)
		goto err;
	if (controller_node == NULL) {
		res = B_IO_ERROR;
		goto err;
	}

	// ignore errors during registration of channels - could be a simple rescan collision

	for (index = 0; index < num_channels; index++) {
		res = sATAAdapter->detect_channel(pci, device, controller_node, CHANNEL_MODULE_NAME,
			true, command_block_base[index], control_block_base[index], bus_master_base,
			int_num, index, kChannelNames[index], &channels[index], false);

		dprintf("%s: %s\n", kChannelNames[index], strerror(res));
	}


	TRACE("controller_probe success\n");
	return B_OK;

err:
	TRACE("controller_probe failed (%s)\n", strerror(res));
	return res;
}


static status_t
controller_init(device_node *node, void **controller_cookie)
{
	return sATAAdapter->init_controller(
		node, (ata_adapter_controller_info**)controller_cookie,
		sizeof(ata_adapter_controller_info));
}


static void
controller_uninit(void *controller_cookie)
{
	sATAAdapter->uninit_controller((ata_adapter_controller_info*)controller_cookie);
}


static void
controller_removed(void *controller_cookie)
{
	sATAAdapter->controller_removed((ata_adapter_controller_info*)controller_cookie);
}


static status_t
channel_init(device_node *node, void **channel_cookie)
{
	return sATAAdapter->init_channel(node,
		(ata_adapter_channel_info**)channel_cookie,
		sizeof(ata_adapter_channel_info), sATAAdapter->inthand);
}


static void
channel_uninit(void *channel_cookie)
{
	sATAAdapter->uninit_channel((ata_adapter_channel_info*)channel_cookie);
}


static void
channel_removed(void *channel_cookie)
{
	sATAAdapter->channel_removed((ata_adapter_channel_info*)channel_cookie);
}


static void
channel_set(void *channel_cookie, ata_channel channel)
{
	sATAAdapter->set_channel((ata_adapter_channel_info*)channel_cookie,
		channel);
}


static status_t
task_file_write(void *channel_cookie, ata_task_file *tf, ata_reg_mask mask)
{
	return sATAAdapter->write_command_block_regs(
		(ata_adapter_channel_info*)channel_cookie, tf, mask);
}


static status_t
task_file_read(void *channel_cookie, ata_task_file *tf, ata_reg_mask mask)
{
	return sATAAdapter->read_command_block_regs(
		(ata_adapter_channel_info*)channel_cookie, tf, mask);
}


static uint8
altstatus_read(void *channel_cookie)
{
	return sATAAdapter->get_altstatus(
		(ata_adapter_channel_info*)channel_cookie);
}


static status_t
device_control_write(void *channel_cookie, uint8 val)
{
	return sATAAdapter->write_device_control(
		(ata_adapter_channel_info*)channel_cookie, val);
}


static status_t
pio_write(void *channel_cookie, uint16 *data, int count, bool force_16bit)
{
	return sATAAdapter->write_pio((ata_adapter_channel_info*)channel_cookie,
		data, count, force_16bit);
}


static status_t
pio_read(void *channel_cookie, uint16 *data, int count, bool force_16bit)
{
	return sATAAdapter->read_pio((ata_adapter_channel_info*)channel_cookie,
		data, count, force_16bit);
}


static status_t
dma_prepare(void *channel_cookie, const physical_entry *sg_list,
	size_t sg_list_count, bool write)
{
	return sATAAdapter->prepare_dma((ata_adapter_channel_info*)channel_cookie,
		sg_list, sg_list_count, write);
}


static status_t
dma_start(void *channel_cookie)
{
	return sATAAdapter->start_dma((ata_adapter_channel_info*)channel_cookie);
}


static status_t
dma_finish(void *channel_cookie)
{
	return sATAAdapter->finish_dma((ata_adapter_channel_info*)channel_cookie);
}


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 sChannelInterface = {
	{
		{
			CHANNEL_MODULE_NAME,
			0,
			NULL
		},

		NULL,
		NULL,
		channel_init,
		channel_uninit,
		NULL,
		NULL,
		channel_removed,
	},

	channel_set,

	task_file_write,
	task_file_read,

	altstatus_read,
	device_control_write,

	pio_write,
	pio_read,

	dma_prepare,
	dma_start,
	dma_finish,
};

static driver_module_info sControllerInterface = {
	{
		CONTROLLER_MODULE_NAME,
		0,
		NULL
	},

	controller_supports,
	controller_probe,
	controller_init,
	controller_uninit,
	NULL,	// register child devices
	NULL,	// rescan
	controller_removed,
};

module_info *modules[] = {
	(module_info *)&sControllerInterface,
	(module_info *)&sChannelInterface,
	NULL
};