/*
 * Copyright 2021 David Sebek, dasebek@gmail.com
 * Copyright 2008-2013 Axel Dörfler, axeld@pinc-software.de
 * Copyright 2002/03 Thomas Kurschel
 * All rights reserved. Distributed under the terms of the MIT License.
 */


/*!     Peripheral driver to handle any kind of SCSI disks,
        i.e. hard disk and floopy disks (ZIP etc.)

        Much work is done by scsi_periph and block_io.

        You'll find das_... all over the place. This stands for
        "Direct Access Storage" which is the official SCSI name for
        normal (floppy/hard/ZIP)-disk drives.
*/


#include "scsi_disk.h"

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

#include <AutoDeleter.h>

#include <fs/devfs.h>
#include <util/fs_trim_support.h>

#include "dma_resources.h"
#include "IORequest.h"
#include "IOSchedulerSimple.h"


//#define TRACE_SCSI_DISK
#ifdef TRACE_SCSI_DISK
#       define TRACE(x...) dprintf("scsi_disk: " x)
#else
#       define TRACE(x...) ;
#endif


static const uint8 kDriveIcon[] = {
        0x6e, 0x63, 0x69, 0x66, 0x08, 0x03, 0x01, 0x00, 0x00, 0x02, 0x00, 0x16,
        0x02, 0x3c, 0xc7, 0xee, 0x38, 0x9b, 0xc0, 0xba, 0x16, 0x57, 0x3e, 0x39,
        0xb0, 0x49, 0x77, 0xc8, 0x42, 0xad, 0xc7, 0x00, 0xff, 0xff, 0xd3, 0x02,
        0x00, 0x06, 0x02, 0x3c, 0x96, 0x32, 0x3a, 0x4d, 0x3f, 0xba, 0xfc, 0x01,
        0x3d, 0x5a, 0x97, 0x4b, 0x57, 0xa5, 0x49, 0x84, 0x4d, 0x00, 0x47, 0x47,
        0x47, 0xff, 0xa5, 0xa0, 0xa0, 0x02, 0x00, 0x16, 0x02, 0xbc, 0x59, 0x2f,
        0xbb, 0x29, 0xa7, 0x3c, 0x0c, 0xe4, 0xbd, 0x0b, 0x7c, 0x48, 0x92, 0xc0,
        0x4b, 0x79, 0x66, 0x00, 0x7d, 0xff, 0xd4, 0x02, 0x00, 0x06, 0x02, 0x38,
        0xdb, 0xb4, 0x39, 0x97, 0x33, 0xbc, 0x4a, 0x33, 0x3b, 0xa5, 0x42, 0x48,
        0x6e, 0x66, 0x49, 0xee, 0x7b, 0x00, 0x59, 0x67, 0x56, 0xff, 0xeb, 0xb2,
        0xb2, 0x03, 0xa7, 0xff, 0x00, 0x03, 0xff, 0x00, 0x00, 0x04, 0x01, 0x80,
        0x07, 0x0a, 0x06, 0x22, 0x3c, 0x22, 0x49, 0x44, 0x5b, 0x5a, 0x3e, 0x5a,
        0x31, 0x39, 0x25, 0x0a, 0x04, 0x22, 0x3c, 0x44, 0x4b, 0x5a, 0x31, 0x39,
        0x25, 0x0a, 0x04, 0x44, 0x4b, 0x44, 0x5b, 0x5a, 0x3e, 0x5a, 0x31, 0x0a,
        0x04, 0x22, 0x3c, 0x22, 0x49, 0x44, 0x5b, 0x44, 0x4b, 0x08, 0x02, 0x27,
        0x43, 0xb8, 0x14, 0xc1, 0xf1, 0x08, 0x02, 0x26, 0x43, 0x29, 0x44, 0x0a,
        0x05, 0x44, 0x5d, 0x49, 0x5d, 0x60, 0x3e, 0x5a, 0x3b, 0x5b, 0x3f, 0x08,
        0x0a, 0x07, 0x01, 0x06, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x10, 0x01, 0x17,
        0x84, 0x00, 0x04, 0x0a, 0x01, 0x01, 0x01, 0x00, 0x0a, 0x02, 0x01, 0x02,
        0x00, 0x0a, 0x03, 0x01, 0x03, 0x00, 0x0a, 0x04, 0x01, 0x04, 0x10, 0x01,
        0x17, 0x85, 0x20, 0x04, 0x0a, 0x06, 0x01, 0x05, 0x30, 0x24, 0xb3, 0x99,
        0x01, 0x17, 0x82, 0x00, 0x04, 0x0a, 0x05, 0x01, 0x05, 0x30, 0x20, 0xb2,
        0xe6, 0x01, 0x17, 0x82, 0x00, 0x04
};


static scsi_periph_interface* sSCSIPeripheral;
static device_manager_info* sDeviceManager;


static status_t
update_capacity(das_driver_info* device)
{
        TRACE("update_capacity()\n");

        scsi_ccb *ccb = device->scsi->alloc_ccb(device->scsi_device);
        if (ccb == NULL)
                return B_NO_MEMORY;

        status_t status = sSCSIPeripheral->check_capacity(
                device->scsi_periph_device, ccb);

        device->scsi->free_ccb(ccb);

        return status;
}


static status_t
get_geometry(das_handle* handle, device_geometry* geometry)
{
        das_driver_info* info = handle->info;

        status_t status = update_capacity(info);
        if (status != B_OK)
                return status;

        devfs_compute_geometry_size(geometry, info->capacity, info->block_size);
        geometry->bytes_per_physical_sector = info->physical_block_size;

        geometry->device_type = B_DISK;
        geometry->removable = info->removable;

        // TBD: for all but CD-ROMs, read mode sense - medium type
        // (bit 7 of block device specific parameter for Optical Memory Block Device)
        // (same for Direct-Access Block Devices)
        // (same for write-once block devices)
        // (same for optical memory block devices)
        geometry->read_only = false;
        geometry->write_once = false;

        TRACE("scsi_disk: get_geometry(): %" B_PRId32 ", %" B_PRId32 ", %" B_PRId32
                ", %" B_PRId32 ", %d, %d, %d, %d, %" B_PRId32 "\n", geometry->bytes_per_sector,
                geometry->sectors_per_track, geometry->cylinder_count,
                geometry->head_count, geometry->device_type,
                geometry->removable, geometry->read_only, geometry->write_once,
                geometry->bytes_per_physical_sector);

        return B_OK;
}


static status_t
load_eject(das_driver_info *device, bool load)
{
        TRACE("load_eject()\n");

        scsi_ccb *ccb = device->scsi->alloc_ccb(device->scsi_device);
        if (ccb == NULL)
                return B_NO_MEMORY;

        err_res result = sSCSIPeripheral->send_start_stop(
                device->scsi_periph_device, ccb, load, true);

        device->scsi->free_ccb(ccb);

        return result.error_code;
}


static status_t
synchronize_cache(das_driver_info *device)
{
        TRACE("synchronize_cache()\n");

        scsi_ccb *ccb = device->scsi->alloc_ccb(device->scsi_device);
        if (ccb == NULL)
                return B_NO_MEMORY;

        err_res result = sSCSIPeripheral->synchronize_cache(
                device->scsi_periph_device, ccb);

        device->scsi->free_ccb(ccb);

        return result.error_code;
}


static status_t
trim_device(das_driver_info* device, fs_trim_data* trimData)
{
        TRACE("trim_device()\n");

        trimData->trimmed_size = 0;

        scsi_ccb* request = device->scsi->alloc_ccb(device->scsi_device);
        if (request == NULL)
                return B_NO_MEMORY;

        scsi_block_range* blockRanges = (scsi_block_range*)
                malloc(trimData->range_count * sizeof(*blockRanges));
        if (blockRanges == NULL)
                return B_NO_MEMORY;

        MemoryDeleter deleter(blockRanges);

        for (uint32 i = 0; i < trimData->range_count; i++) {
                uint64 startBytes = trimData->ranges[i].offset;
                uint64 sizeBytes = trimData->ranges[i].size;
                uint32 blockSize = device->block_size;

                // Align to a block boundary so we don't discard blocks
                // that could also contain some other data
                uint64 blockOffset = startBytes % blockSize;
                if (blockOffset == 0) {
                        blockRanges[i].lba = startBytes / blockSize;
                        blockRanges[i].size = sizeBytes / blockSize;
                } else {
                        blockRanges[i].lba = startBytes / blockSize + 1;
                        blockRanges[i].size = (sizeBytes - (blockSize - blockOffset))
                                / blockSize;
                }
        }

        // Check ranges against device capacity and make them fit
        for (uint32 i = 0; i < trimData->range_count; i++) {
                if (blockRanges[i].lba >= device->capacity) {
                        dprintf("trim_device(): range offset (LBA) %" B_PRIu64
                                " exceeds device capacity %" B_PRIu64 "\n",
                                blockRanges[i].lba, device->capacity);
                        return B_BAD_VALUE;
                }
                uint64 maxSize = device->capacity - blockRanges[i].lba;
                blockRanges[i].size = min_c(blockRanges[i].size, maxSize);
        }

        uint64 trimmedBlocks;
        status_t status = sSCSIPeripheral->trim_device(device->scsi_periph_device,
                request, blockRanges, trimData->range_count, &trimmedBlocks);

        device->scsi->free_ccb(request);
        // Some blocks may have been trimmed even if trim_device returns a failure
        trimData->trimmed_size = trimmedBlocks * device->block_size;

        return status;
}


static status_t
do_io(void* cookie, IOOperation* operation)
{
        das_driver_info* info = (das_driver_info*)cookie;

        // TODO: this can go away as soon as we pushed the IOOperation to the upper
        // layers - we can then set scsi_periph::io() as callback for the scheduler
        size_t bytesTransferred;
        status_t status = sSCSIPeripheral->io(info->scsi_periph_device, operation,
                &bytesTransferred);

        info->io_scheduler->OperationCompleted(operation, status, bytesTransferred);
        return status;
}


//      #pragma mark - device module API


static status_t
das_init_device(void* _info, void** _cookie)
{
        das_driver_info* info = (das_driver_info*)_info;

        // and get (initial) capacity
        scsi_ccb *request = info->scsi->alloc_ccb(info->scsi_device);
        if (request == NULL)
                return B_NO_MEMORY;

        sSCSIPeripheral->check_capacity(info->scsi_periph_device, request);
        info->scsi->free_ccb(request);

        *_cookie = info;
        return B_OK;
}


static void
das_uninit_device(void* _cookie)
{
        das_driver_info* info = (das_driver_info*)_cookie;

        delete info->io_scheduler;
}


static status_t
das_open(void* _info, const char* path, int openMode, void** _cookie)
{
        das_driver_info* info = (das_driver_info*)_info;

        das_handle* handle = (das_handle*)malloc(sizeof(das_handle));
        if (handle == NULL)
                return B_NO_MEMORY;

        handle->info = info;

        status_t status = sSCSIPeripheral->handle_open(info->scsi_periph_device,
                (periph_handle_cookie)handle, &handle->scsi_periph_handle);
        if (status < B_OK) {
                free(handle);
                return status;
        }

        *_cookie = handle;
        return B_OK;
}


static status_t
das_close(void* cookie)
{
        das_handle* handle = (das_handle*)cookie;
        TRACE("close()\n");

        sSCSIPeripheral->handle_close(handle->scsi_periph_handle);
        return B_OK;
}


static status_t
das_free(void* cookie)
{
        das_handle* handle = (das_handle*)cookie;
        TRACE("free()\n");

        sSCSIPeripheral->handle_free(handle->scsi_periph_handle);
        free(handle);
        return B_OK;
}


static status_t
das_io(void *cookie, io_request *request)
{
        das_handle* handle = (das_handle*)cookie;

        return handle->info->io_scheduler->ScheduleRequest(request);
}


static status_t
das_ioctl(void* cookie, uint32 op, void* buffer, size_t length)
{
        das_handle* handle = (das_handle*)cookie;
        das_driver_info* info = handle->info;

        TRACE("ioctl(op = %" B_PRIu32 ")\n", op);

        switch (op) {
                case B_GET_DEVICE_SIZE:
                {
                        status_t status = update_capacity(info);
                        if (status != B_OK)
                                return status;

                        size_t size = info->capacity * info->block_size;
                        return user_memcpy(buffer, &size, sizeof(size_t));
                }

                case B_GET_GEOMETRY:
                {
                        if (buffer == NULL || length > sizeof(device_geometry))
                                return B_BAD_VALUE;

                        device_geometry geometry;
                        status_t status = get_geometry(handle, &geometry);
                        if (status != B_OK)
                                return status;

                        return user_memcpy(buffer, &geometry, length);
                }

                case B_GET_ICON_NAME:
                        // TODO: take device type into account!
                        return user_strlcpy((char*)buffer, info->removable
                                ? "devices/drive-removable-media" : "devices/drive-harddisk",
                                B_FILE_NAME_LENGTH);

                case B_GET_VECTOR_ICON:
                {
                        // TODO: take device type into account!
                        device_icon iconData;
                        if (length != sizeof(device_icon))
                                return B_BAD_VALUE;
                        if (user_memcpy(&iconData, buffer, sizeof(device_icon)) != B_OK)
                                return B_BAD_ADDRESS;

                        if (iconData.icon_size >= (int32)sizeof(kDriveIcon)) {
                                if (user_memcpy(iconData.icon_data, kDriveIcon,
                                                sizeof(kDriveIcon)) != B_OK)
                                        return B_BAD_ADDRESS;
                        }

                        iconData.icon_size = sizeof(kDriveIcon);
                        return user_memcpy(buffer, &iconData, sizeof(device_icon));
                }

                case B_EJECT_DEVICE:
                case B_SCSI_EJECT:
                        return load_eject(info, false);

                case B_LOAD_MEDIA:
                        return load_eject(info, true);

                case B_FLUSH_DRIVE_CACHE:
                        return synchronize_cache(info);

                case B_TRIM_DEVICE:
                {
                        // We know the buffer is kernel-side because it has been
                        // preprocessed in devfs
                        ASSERT(IS_KERNEL_ADDRESS(buffer));
                        return trim_device(info, (fs_trim_data*)buffer);
                }

                default:
                        return sSCSIPeripheral->ioctl(handle->scsi_periph_handle, op,
                                buffer, length);
        }
}


//      #pragma mark - scsi_periph callbacks


static void
das_set_capacity(das_driver_info* info, uint64 capacity, uint32 blockSize, uint32 physicalBlockSize)
{
        TRACE("das_set_capacity(device = %p, capacity = %" B_PRIu64
                ", blockSize = %" B_PRIu32 ")\n", info, capacity, blockSize);

        info->capacity = capacity;

        if (info->block_size != blockSize) {
                if (info->block_size != 0) {
                        dprintf("old %" B_PRId32 ", new %" B_PRId32 "\n", info->block_size,
                                blockSize);
                        panic("updating DMAResource not yet implemented...");
                }

                // TODO: we need to replace the DMAResource in our IOScheduler
                status_t status = info->dma_resource->Init(info->node, blockSize, 1024,
                        32);
                if (status != B_OK)
                        panic("initializing DMAResource failed: %s", strerror(status));

                info->io_scheduler = new(std::nothrow) IOSchedulerSimple(
                        info->dma_resource);
                if (info->io_scheduler == NULL)
                        panic("allocating IOScheduler failed.");

                // TODO: use whole device name here
                status = info->io_scheduler->Init("scsi");
                if (status != B_OK)
                        panic("initializing IOScheduler failed: %s", strerror(status));

                info->io_scheduler->SetCallback(do_io, info);
        }

        info->block_size = blockSize;
        info->physical_block_size = physicalBlockSize;
}


static void
das_media_changed(das_driver_info *device, scsi_ccb *request)
{
        // do a capacity check
        // TODO: is this a good idea (e.g. if this is an empty CD)?
        sSCSIPeripheral->check_capacity(device->scsi_periph_device, request);
}


scsi_periph_callbacks callbacks = {
        (void (*)(periph_device_cookie, uint64, uint32, uint32))das_set_capacity,
        (void (*)(periph_device_cookie, scsi_ccb *))das_media_changed
};


//      #pragma mark - driver module API


static float
das_supports_device(device_node *parent)
{
        const char *bus;
        uint8 deviceType;

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

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

        // check whether it's really a Direct Access Device
        if (sDeviceManager->get_attr_uint8(parent, SCSI_DEVICE_TYPE_ITEM,
                        &deviceType, true) != B_OK || deviceType != scsi_dev_direct_access)
                return 0.0;

        return 0.6;
}


/*!     Called whenever a new device was added to system;
        if we really support it, we create a new node that gets
        server by the block_io module
*/
static status_t
das_register_device(device_node *node)
{
        const scsi_res_inquiry *deviceInquiry = NULL;
        size_t inquiryLength;
        uint32 maxBlocks;

        // get inquiry data
        if (sDeviceManager->get_attr_raw(node, SCSI_DEVICE_INQUIRY_ITEM,
                        (const void **)&deviceInquiry, &inquiryLength, true) != B_OK
                || inquiryLength < sizeof(scsi_res_inquiry))
                return B_ERROR;

        // get block limit of underlying hardware to lower it (if necessary)
        if (sDeviceManager->get_attr_uint32(node, B_DMA_MAX_TRANSFER_BLOCKS,
                        &maxBlocks, true) != B_OK)
                maxBlocks = INT_MAX;

        // using 10 byte commands, at most 0xffff blocks can be transmitted at once
        // (sadly, we cannot update this value later on if only 6 byte commands
        //  are supported, but the block_io module can live with that)
        maxBlocks = min_c(maxBlocks, 0xffff);

        // ready to register
        device_attr attrs[] = {
                { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "SCSI Disk" }},
                // tell block_io whether the device is removable
                {"removable", B_UINT8_TYPE, {.ui8 = deviceInquiry->removable_medium}},
                // impose own max block restriction
                {B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, {.ui32 = maxBlocks}},
                { NULL }
        };

        return sDeviceManager->register_node(node, SCSI_DISK_DRIVER_MODULE_NAME,
                attrs, NULL, NULL);
}


static status_t
das_init_driver(device_node *node, void **cookie)
{
        TRACE("das_init_driver");

        uint8 removable;
        status_t status = sDeviceManager->get_attr_uint8(node, "removable",
                &removable, false);
        if (status != B_OK)
                return status;

        das_driver_info* info = (das_driver_info*)malloc(sizeof(das_driver_info));
        if (info == NULL)
                return B_NO_MEMORY;

        memset(info, 0, sizeof(*info));

        info->dma_resource = new(std::nothrow) DMAResource;
        if (info->dma_resource == NULL) {
                free(info);
                return B_NO_MEMORY;
        }

        info->node = node;
        info->removable = removable;

        device_node* parent = sDeviceManager->get_parent_node(node);
        sDeviceManager->get_driver(parent, (driver_module_info **)&info->scsi,
                (void **)&info->scsi_device);
        sDeviceManager->put_node(parent);

        status = sSCSIPeripheral->register_device((periph_device_cookie)info,
                &callbacks, info->scsi_device, info->scsi, info->node,
                info->removable, 10, &info->scsi_periph_device);
        if (status != B_OK) {
                delete info->dma_resource;
                free(info);
                return status;
        }

        *cookie = info;
        return B_OK;
}


static void
das_uninit_driver(void *_cookie)
{
        das_driver_info* info = (das_driver_info*)_cookie;

        sSCSIPeripheral->unregister_device(info->scsi_periph_device);
        delete info->dma_resource;
        free(info);
}


static status_t
das_register_child_devices(void* _cookie)
{
        das_driver_info* info = (das_driver_info*)_cookie;
        status_t status;

        char* name = sSCSIPeripheral->compose_device_name(info->node,
                "disk/scsi");
        if (name == NULL)
                return B_ERROR;

        status = sDeviceManager->publish_device(info->node, name,
                SCSI_DISK_DEVICE_MODULE_NAME);

        free(name);
        return status;
}


static status_t
das_rescan_child_devices(void* _cookie)
{
        das_driver_info* info = (das_driver_info*)_cookie;
        uint64 capacity = info->capacity;
        update_capacity(info);
        if (info->capacity != capacity)
                sSCSIPeripheral->media_changed(info->scsi_periph_device);
        return B_OK;
}



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

struct device_module_info sSCSIDiskDevice = {
        {
                SCSI_DISK_DEVICE_MODULE_NAME,
                0,
                NULL
        },

        das_init_device,
        das_uninit_device,
        NULL, //das_remove,

        das_open,
        das_close,
        das_free,
        NULL,   // read
        NULL,   // write
        das_io,
        das_ioctl,

        NULL,   // select
        NULL,   // deselect
};

struct driver_module_info sSCSIDiskDriver = {
        {
                SCSI_DISK_DRIVER_MODULE_NAME,
                0,
                NULL
        },

        das_supports_device,
        das_register_device,
        das_init_driver,
        das_uninit_driver,
        das_register_child_devices,
        das_rescan_child_devices,
        NULL,   // removed
};

module_info* modules[] = {
        (module_info*)&sSCSIDiskDriver,
        (module_info*)&sSCSIDiskDevice,
        NULL
};