/*
 * Copyright 2013, Jérôme Duval, korli@users.berlios.de.
 * Distributed under the terms of the MIT License.
 */


#include "VirtioSCSIPrivate.h"

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


#define VIRTIO_SCSI_ID_GENERATOR "virtio_scsi/id"
#define VIRTIO_SCSI_ID_ITEM "virtio_scsi/id"
#define VIRTIO_SCSI_BRIDGE_PRETTY_NAME "Virtio SCSI Bridge"
#define VIRTIO_SCSI_CONTROLLER_PRETTY_NAME "Virtio SCSI Controller"

#define VIRTIO_SCSI_DEVICE_MODULE_NAME "busses/scsi/virtio_scsi/driver_v1"
#define VIRTIO_SCSI_SIM_MODULE_NAME "busses/scsi/virtio_scsi/sim/driver_v1"


device_manager_info *gDeviceManager;
scsi_for_sim_interface *gSCSI;


//      #pragma mark - SIM module interface


static void
set_scsi_bus(scsi_sim_cookie cookie, scsi_bus bus)
{
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        sim->SetBus(bus);
}


static void
scsi_io(scsi_sim_cookie cookie, scsi_ccb *request)
{
        CALLED();
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        if (sim->ExecuteRequest(request) == B_BUSY)
                gSCSI->requeue(request, true);
}


static uchar
abort_io(scsi_sim_cookie cookie, scsi_ccb *request)
{
        CALLED();
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        return sim->AbortRequest(request);
}


static uchar
reset_device(scsi_sim_cookie cookie, uchar targetID, uchar targetLUN)
{
        CALLED();
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        return sim->ResetDevice(targetID, targetLUN);
}


static uchar
terminate_io(scsi_sim_cookie cookie, scsi_ccb *request)
{
        CALLED();
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        return sim->TerminateRequest(request);
}


static uchar
path_inquiry(scsi_sim_cookie cookie, scsi_path_inquiry *info)
{
        CALLED();

        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        if (sim->Bus() == NULL)
                return SCSI_NO_HBA;

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


//! this is called immediately before the SCSI bus manager scans the bus
static uchar
scan_bus(scsi_sim_cookie cookie)
{
        CALLED();

        return SCSI_REQ_CMP;
}


static uchar
reset_bus(scsi_sim_cookie cookie)
{
        CALLED();

        return SCSI_REQ_CMP;
}


/*!     Get restrictions of one device
        (used for non-SCSI transport protocols and bug fixes)
*/
static void
get_restrictions(scsi_sim_cookie cookie, uchar targetID, bool *isATAPI,
        bool *noAutoSense, uint32 *maxBlocks)
{
        CALLED();
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        sim->GetRestrictions(targetID, isATAPI, noAutoSense, maxBlocks);
}


static status_t
ioctl(scsi_sim_cookie cookie, uint8 targetID, uint32 op, void *buffer,
        size_t length)
{
        CALLED();
        VirtioSCSIController *sim = (VirtioSCSIController *)cookie;
        return sim->Control(targetID, op, buffer, length);
}


//      #pragma mark -


static status_t
sim_init_bus(device_node *node, void **_cookie)
{
        CALLED();

        VirtioSCSIController *controller =  new(std::nothrow)
                VirtioSCSIController(node);
        if (controller == NULL)
                return B_NO_MEMORY;
        status_t status = controller->InitCheck();
        if (status < B_OK) {
                delete controller;
                return status;
        }

        *_cookie = controller;
        return B_OK;
}


static void
sim_uninit_bus(void *cookie)
{
        CALLED();
        VirtioSCSIController *controller = (VirtioSCSIController*)cookie;

        delete controller;
}


//      #pragma mark -


static float
virtio_scsi_supports_device(device_node *parent)
{
        const char *bus;
        uint16 deviceType;

        // make sure parent is really the Virtio bus manager
        if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
                return -1;

        if (strcmp(bus, "virtio"))
                return 0.0;

        // check whether it's really a Virtio SCSI Device
        if (gDeviceManager->get_attr_uint16(parent, VIRTIO_DEVICE_TYPE_ITEM,
                        &deviceType, true) != B_OK || deviceType != VIRTIO_DEVICE_ID_SCSI)
                return 0.0;

        TRACE("Virtio SCSI device found!\n");

        return 0.6f;
}


static status_t
virtio_scsi_register_device(device_node *parent)
{
        CALLED();
        virtio_device_interface* virtio = NULL;
        virtio_device* virtioDevice = NULL;
        struct virtio_scsi_config config;

        gDeviceManager->get_driver(parent, (driver_module_info **)&virtio,
                (void **)&virtioDevice);

        status_t status = virtio->read_device_config(virtioDevice, 0, &config,
                sizeof(struct virtio_scsi_config));
        if (status != B_OK)
                return status;

        uint32 max_targets = config.max_target + 1;
        uint32 max_luns = config.max_lun + 1;
        uint32 max_blocks = 0x10000;
        if (config.max_sectors != 0)
                max_blocks = config.max_sectors;

        device_attr attrs[] = {
                { SCSI_DEVICE_MAX_TARGET_COUNT, B_UINT32_TYPE,
                        { .ui32 = max_targets }},
                { SCSI_DEVICE_MAX_LUN_COUNT, B_UINT32_TYPE,
                        { .ui32 = max_luns }},
                { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
                        { .string = VIRTIO_SCSI_BRIDGE_PRETTY_NAME }},

                // DMA properties
                { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = max_blocks }},
                { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE,
                        { .ui32 = config.seg_max }},
                { NULL }
        };

        return gDeviceManager->register_node(parent, VIRTIO_SCSI_DEVICE_MODULE_NAME,
                attrs, NULL, NULL);
}


static status_t
virtio_scsi_init_driver(device_node *node, void **_cookie)
{
        CALLED();
        *_cookie = node;
        return B_OK;
}


static status_t
virtio_scsi_register_child_devices(void *cookie)
{
        CALLED();
        device_node *node = (device_node *)cookie;

        int32 id = gDeviceManager->create_id(VIRTIO_SCSI_ID_GENERATOR);
        if (id < 0)
                return id;

        device_attr attrs[] = {
                { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
                        { .string = SCSI_FOR_SIM_MODULE_NAME }},
                { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
                        { .string = VIRTIO_SCSI_CONTROLLER_PRETTY_NAME }},
                { SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE,
                        { .string = VIRTIO_SCSI_DEVICE_MODULE_NAME }},
                { B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { .ui32 = 255 }},
                { VIRTIO_SCSI_ID_ITEM, B_UINT32_TYPE, { .ui32 = (uint32)id }},
                        { NULL }
        };

        status_t status = gDeviceManager->register_node(node,
                VIRTIO_SCSI_SIM_MODULE_NAME, attrs, NULL, NULL);
        if (status < B_OK)
                gDeviceManager->free_id(VIRTIO_SCSI_ID_GENERATOR, id);

        return status;
}


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

                default:
                        return B_ERROR;
        }
}


static scsi_sim_interface sVirtioSCSISimInterface = {
        {
                {
                        VIRTIO_SCSI_SIM_MODULE_NAME,
                        0,
                        std_ops
                },
                NULL,   // supported devices
                NULL,   // register node
                sim_init_bus,
                sim_uninit_bus,
                NULL,   // register child devices
                NULL,   // rescan
                NULL    // bus_removed
        },
        set_scsi_bus,
        scsi_io,
        abort_io,
        reset_device,
        terminate_io,
        path_inquiry,
        scan_bus,
        reset_bus,
        get_restrictions,
        ioctl
};


static driver_module_info sVirtioSCSIDevice = {
        {
                VIRTIO_SCSI_DEVICE_MODULE_NAME,
                0,
                std_ops
        },
        virtio_scsi_supports_device,
        virtio_scsi_register_device,
        virtio_scsi_init_driver,
        NULL,   // uninit_driver,
        virtio_scsi_register_child_devices,
        NULL,   // rescan
        NULL,   // device_removed
};


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


module_info *modules[] = {
        (module_info *)&sVirtioSCSIDevice,
        (module_info *)&sVirtioSCSISimInterface,
        NULL
};