/*
 * Copyright 2008, Michael Lotz. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#include <KernelExport.h>
#include <stdlib.h>
#include <string.h>

#include <ata_adapter.h>

#define IT8211_CONTROLLER_MODULE_NAME "busses/ata/it8211/driver_v1"
#define IT8211_CHANNEL_MODULE_NAME "busses/ata/it8211/channel/v1"

#define PCI_VENDOR_ITE                  0x1283
#define PCI_DEVICE_ITE_IT8211   0x8211

static ata_adapter_interface *sATAAdapter;
static device_manager_info *sDeviceManager;


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


static status_t
it8211_write_command_block_regs(void *channelCookie, ata_task_file *taskFile,
        ata_reg_mask registerMask)
{
        return sATAAdapter->write_command_block_regs(
                (ata_adapter_channel_info *)channelCookie, taskFile, registerMask);
}


static status_t
it8211_read_command_block_regs(void *channelCookie, ata_task_file *taskFile,
        ata_reg_mask registerMask)
{
        return sATAAdapter->read_command_block_regs(
                (ata_adapter_channel_info *)channelCookie, taskFile, registerMask);
}


static uint8
it8211_get_altstatus(void *channelCookie)
{
        return sATAAdapter->get_altstatus((ata_adapter_channel_info *)channelCookie);
}


static status_t
it8211_write_device_control(void *channelCookie, uint8 value)
{
        return sATAAdapter->write_device_control(
                (ata_adapter_channel_info *)channelCookie, value);
}


static status_t
it8211_write_pio(void *channelCookie, uint16 *data, int count, bool force16bit)
{
        return sATAAdapter->write_pio(
                (ata_adapter_channel_info *)channelCookie, data, count, force16bit);
}


static status_t
it8211_read_pio(void *channelCookie, uint16 *data, int count, bool force16bit)
{
        return sATAAdapter->read_pio(
                (ata_adapter_channel_info *)channelCookie, data, count, force16bit);
}


static status_t
it8211_prepare_dma(void *channelCookie, const physical_entry *sgList,
        size_t sgListCount, bool toDevice)
{
        return sATAAdapter->prepare_dma((ata_adapter_channel_info *)channelCookie,
                sgList, sgListCount, toDevice);
}


static status_t
it8211_start_dma(void *channelCookie)
{
        return sATAAdapter->start_dma((ata_adapter_channel_info *)channelCookie);
}


static status_t
it8211_finish_dma(void *channelCookie)
{
        return sATAAdapter->finish_dma((ata_adapter_channel_info *)channelCookie);
}


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


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


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


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


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


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


static status_t
probe_controller(device_node *parent)
{
        return sATAAdapter->probe_controller(parent,
                IT8211_CONTROLLER_MODULE_NAME, "it8211",
                "ITE IT8211", IT8211_CHANNEL_MODULE_NAME,
                true,           /* DMA */
                true,           /* command queuing */
                1,                      /* 16 bit alignment */
                0xffff,         /* 64k boundary */
                0x10000,        /* up to 64k per scatter/gather block */
                false);         /* no compatibility mode */
}


static float
supports_device(device_node *parent)
{
        const char *bus;
        uint16 vendorID;
        uint16 deviceID;

        if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, 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;
        }

        if (strcmp(bus, "pci") != 0 || vendorID != PCI_VENDOR_ITE
                || deviceID != PCI_DEVICE_ITE_IT8211)
                return 0.0f;

        return 1.0f;
}


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


// exported interface
static ata_controller_interface sChannelInterface = {
        {
                {
                        IT8211_CHANNEL_MODULE_NAME,
                        0,
                        NULL
                },

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

        &it8211_set_channel,
        &it8211_write_command_block_regs,
        &it8211_read_command_block_regs,
        &it8211_get_altstatus,
        &it8211_write_device_control,
        &it8211_write_pio,
        &it8211_read_pio,
        &it8211_prepare_dma,
        &it8211_start_dma,
        &it8211_finish_dma
};


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

        &supports_device,
        &probe_controller,
        &init_controller,
        &uninit_controller,
        NULL,   // register child devices
        NULL,   // rescan
        &controller_removed
};


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