/*
 * Copyright 2004-2008, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2002/03, Thomas Kurschel. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */

/*!     Emulation of SCSI commands that a device cannot handle.

        Some SCSI devices don't support all SCSI commands, especially
        those connected via ATAPI, USB or FireWire. These commands are
        emulated here.
*/


#include "scsi_internal.h"

#include <vm/vm.h>

#include <string.h>


// move some function to end of file to avoid inlining
static void set_sense(scsi_ccb *request, int sense_key, int sense_asc);
static bool copy_sg_data(scsi_ccb *request, uint offset, uint allocation_length,
        void *buffer, int size, bool to_buffer);
static void get_emulation_buffer(scsi_ccb *request);
static void replace_request_data(scsi_ccb *request);
static void release_emulation_buffer(scsi_ccb *request);
static void restore_request_data(scsi_ccb *request);


/*! Free emulation buffer */
void
scsi_free_emulation_buffer(scsi_device_info *device)
{
        if (device->buffer_area)
                delete_area(device->buffer_area);

        device->buffer_area = 0;
        device->buffer = NULL;
        device->buffer_sg_list = NULL;
        device->buffer_size = 0;

        if (device->buffer_sem > 0)
                delete_sem(device->buffer_sem);
}


/*!     Setup buffer used to emulate unsupported SCSI commands
        buffer_size must be power of two
*/
status_t
scsi_init_emulation_buffer(scsi_device_info *device, size_t buffer_size)
{
        physical_entry map[1];
        size_t total_size;

        SHOW_FLOW0(3, "");

        device->buffer_sem = create_sem(1, "SCSI emulation buffer");
        if (device->buffer_sem < 0) {
                SHOW_ERROR(1, "cannot create DMA buffer semaphore (%s)", strerror(device->buffer_sem));
                return device->buffer_sem;
        }

        // we append S/G list to buffer as it must be locked as well
        total_size = (buffer_size + sizeof(physical_entry) + B_PAGE_SIZE - 1)
                & ~(B_PAGE_SIZE - 1);

        void* address;
        virtual_address_restrictions virtualRestrictions = {};
        virtualRestrictions.address_specification = B_ANY_KERNEL_ADDRESS;
        physical_address_restrictions physicalRestrictions = {};
        physicalRestrictions.alignment = buffer_size;
        device->buffer_area = create_area_etc(B_SYSTEM_TEAM, "ATAPI buffer",
                total_size, B_32_BIT_CONTIGUOUS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,
                0, 0, &virtualRestrictions, &physicalRestrictions, &address);
                // TODO: Use B_CONTIGUOUS, if possible!

        if (device->buffer_area < 0) {
                SHOW_ERROR( 1, "cannot create DMA buffer (%s)", strerror(device->buffer_area));

                delete_sem(device->buffer_sem);
                return device->buffer_area;
        }

        get_memory_map(address, B_PAGE_SIZE, map, 1);

        // get aligned part
        phys_addr_t physicalAddress = map[0].address;

        SHOW_FLOW(3, "physical = %#" B_PRIxPHYSADDR ", address = %p",
                physicalAddress, address);

        device->buffer = (char*)address;
        device->buffer_size = buffer_size;
        // s/g list is directly after buffer
        device->buffer_sg_list = (physical_entry*)((char*)address + buffer_size);
        device->buffer_sg_list[0].address = physicalAddress;
        device->buffer_sg_list[0].size = buffer_size;
        device->buffer_sg_count = 1;

        return B_OK;
}


/*!     Some ATAPI devices don't like 6 byte read/write commands, so
        we translate them to their 10 byte counterparts;
        USB devices usually don't like 10 bytes either
*/
static bool
scsi_read_write_6(scsi_ccb *request)
{
        scsi_cmd_rw_6 *cmd = (scsi_cmd_rw_6 *)request->orig_cdb;
        scsi_cmd_rw_10 *cdb = (scsi_cmd_rw_10 *)request->cdb;

        SHOW_FLOW0(3, "patching READ/WRITE(6) to READ/WRITE(10)");

        request->cdb_length = sizeof(*cdb);
        memset(cdb, 0, sizeof(*cdb));

        cdb->opcode = cmd->opcode + (SCSI_OP_READ_10 - SCSI_OP_READ_6);
        cdb->lun = cmd->lun;
        cdb->lba = B_HOST_TO_BENDIAN_INT32((uint32)cmd->low_lba
                | ((uint32)cmd->mid_lba << 8) | ((uint32)cmd->high_lba << 16));
        if (cmd->length == 0)
                cdb->length = B_HOST_TO_BENDIAN_INT16(256);
        else
                cdb->length = B_HOST_TO_BENDIAN_INT16((uint16)cmd->length);
        cdb->control = cmd->control;

#if 0
        {
                static uint32 lastLBA = 0;
                static uint16 lastLength = 0;
                static uint32 contigCount = 0;
                static uint64 totalContig = 0;

                uint32 currentLBA = B_BENDIAN_TO_HOST_INT32(cdb->lba);
                uint16 currentLength = B_BENDIAN_TO_HOST_INT16(cdb->length);

                if (lastLBA + lastLength == currentLBA) {
                        contigCount++;
                        totalContig++;
                } else
                        contigCount = 0;

                lastLBA = currentLBA;
                lastLength = currentLength;

                dprintf("scsi_read_write_6: %lld lba %ld; length: %d\n", totalContig,
                        B_BENDIAN_TO_HOST_INT32(cdb->lba),
                        B_BENDIAN_TO_HOST_INT16(cdb->length));
        }
#endif

        return true;
}


/*!     All ATAPI devices don't like 6 byte MODE SENSE, so we translate
        that to 10 byte MODE SENSE
*/
static bool
scsi_start_mode_sense_6(scsi_ccb *request)
{
        scsi_cmd_mode_sense_6 *cmd = (scsi_cmd_mode_sense_6 *)request->orig_cdb;
        scsi_cmd_mode_sense_10 *cdb = (scsi_cmd_mode_sense_10 *)request->cdb;

        SHOW_FLOW0(3, "patching MODE SENSE(6) to MODE SENSE(10)");

        request->cdb_length = sizeof(*cdb);
        memset(cdb, 0, sizeof(*cdb));

        cdb->opcode = SCSI_OP_MODE_SENSE_10;
        cdb->disable_block_desc = cmd->disable_block_desc;
        cdb->lun = cmd->lun;
        cdb->page_code = cmd->page_code;
        cdb->page_control = cmd->page_control;

        size_t allocationLength = cmd->allocation_length
                - sizeof(scsi_cmd_mode_sense_6) + sizeof(scsi_cmd_mode_sense_10);
        cdb->allocation_length = B_HOST_TO_BENDIAN_INT16(allocationLength);

        SHOW_FLOW(3, "allocation_length=%" B_PRIuSIZE, allocationLength);

        cdb->control = cmd->control;

        // data header of 10 byte version is longer, so use internal buffer
        // and copy it back once the command is finished
        get_emulation_buffer(request);
        replace_request_data(request);

        // restrict data buffer len to length specified in cdb
        request->data_length = allocationLength;
        return true;
}


/*!     All ATAPI devices don't like 6 byte MODE SELECT, so we translate
        that to 10 byte MODE SELECT
*/
static bool
scsi_start_mode_select_6(scsi_ccb *request)
{
        scsi_device_info *device = request->device;
        scsi_cmd_mode_select_6 *cmd = (scsi_cmd_mode_select_6 *)request->orig_cdb;
        scsi_cmd_mode_select_10 *cdb = (scsi_cmd_mode_select_10 *)request->cdb;
        scsi_mode_param_header_6 header_6;
        scsi_mode_param_header_10 *header_10 = (scsi_mode_param_header_10 *)device->buffer;
        size_t param_list_length_6, param_list_length_10;

        SHOW_FLOW0(3, "patching MODE SELECT(6) to MODE SELECT(10)");

        // calculate new data buffer size
        param_list_length_6 = cmd->param_list_length;
        param_list_length_10 = param_list_length_6
                - sizeof(scsi_mode_param_header_6) + sizeof(scsi_mode_param_header_10);

        // we need to replace data header, thus use internal buffer
        get_emulation_buffer(request);

        // make sure our buffer is large enough
        if (param_list_length_10 > device->buffer_size)
                goto err;

        // construct new cdb
        request->cdb_length = sizeof(*cdb);
        memset(cdb, 0, sizeof(*cdb));

        cdb->opcode = SCSI_OP_MODE_SELECT_10;
        cdb->save_pages = cmd->save_pages;
        cdb->pf = cmd->pf;
        cdb->lun = cmd->lun;
        cdb->param_list_length = B_HOST_TO_BENDIAN_INT16(param_list_length_10);

        SHOW_FLOW(3, "param_list_length=%ld", param_list_length_6);

        cdb->control = cmd->control;

        // copy and adapt header
        if (!copy_sg_data(request, 0, param_list_length_6, &header_6, sizeof(header_6), true))
                goto err;

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

        // mode_data_len is reserved for MODE SELECT
        header_10->medium_type = header_6.medium_type;
        header_10->dev_spec_parameter = header_6.dev_spec_parameter;
        header_10->block_desc_length = B_HOST_TO_BENDIAN_INT16(
                (uint16)header_6.block_desc_length);

        // append actual mode select data
        if (!copy_sg_data(request, sizeof(header_6), param_list_length_6, header_10 + 1,
                        param_list_length_10 - sizeof(*header_10), true))
                goto err;

        replace_request_data(request);

        // restrict buffer size to the one specified in cdb
        request->data_length = param_list_length_10;
        return true;

err:
        release_emulation_buffer(request);

        set_sense(request, SCSIS_KEY_ILLEGAL_REQUEST, SCSIS_ASC_INV_PARAM_LIST_FIELD);
        return false;
}


/*!     Emulation procedure at start of command
        returns false if command is to be finished without further execution
*/
bool
scsi_start_emulation(scsi_ccb *request)
{
        //snooze( 1000000 );

        SHOW_FLOW(3, "command=%x", request->cdb[0]);

        memcpy(request->orig_cdb, request->cdb, SCSI_MAX_CDB_SIZE);
        request->orig_cdb_length = request->cdb_length;

        switch (request->orig_cdb[0]) {
                case SCSI_OP_READ_6:
                case SCSI_OP_WRITE_6:
                        return scsi_read_write_6(request);

                case SCSI_OP_MODE_SENSE_6:
                        return scsi_start_mode_sense_6(request);

                case SCSI_OP_MODE_SELECT_6:
                        return scsi_start_mode_select_6(request);
        }

        return true;
}


/*! Back-translate MODE SENSE 10 to MODE SENSE 6 */
static void
scsi_finish_mode_sense_10_6(scsi_ccb *request)
{
        scsi_device_info *device = request->device;
        scsi_mode_param_header_6 header_6;
        scsi_mode_param_header_10 *header_10 = (scsi_mode_param_header_10 *)device->buffer;
        int transfer_size_6, transfer_size_10;

        if (request->subsys_status != SCSI_REQ_CMP
                || request->device_status != SCSI_STATUS_GOOD) {
                // on error, do nothing
                restore_request_data(request);
                release_emulation_buffer(request);
                return;
        }

        // check how much data we got from device and thus will copy into
        // request data
        transfer_size_10 = request->data_length - request->data_resid;
        transfer_size_6 = transfer_size_10
                - sizeof(scsi_mode_param_header_10 *) + sizeof(scsi_mode_param_header_6 *);

        SHOW_FLOW(0, "fixing MODE SENSE(6) (%d bytes)", transfer_size_6);

        restore_request_data(request);

        // adapt header

        // convert total length
        // (+1 is there because mode_data_len in 10 byte header ignores first
        // two bytes, whereas in the 6 byte header it ignores only one byte)
        header_6.mode_data_length = B_BENDIAN_TO_HOST_INT16(header_10->mode_data_length)
                - sizeof(scsi_mode_param_header_10) + sizeof(scsi_mode_param_header_6)
                + 1;

        header_6.medium_type = header_10->medium_type;
        header_6.dev_spec_parameter = header_10->dev_spec_parameter;
        header_6.block_desc_length = B_BENDIAN_TO_HOST_INT16(header_10->block_desc_length);

        // copy adapted header
        copy_sg_data(request, 0, transfer_size_6, &header_6, sizeof(header_6), false);

        // copy remaining data
        copy_sg_data(request, sizeof(header_6), transfer_size_6,
                header_10 + 1, transfer_size_10 - sizeof(*header_10), false);

        request->data_resid = request->data_length - transfer_size_6;

        release_emulation_buffer(request);
}


/*! Back-translate MODE SELECT 10 to MODE SELECT 6 */
static void
scsi_finish_mode_select_10_6(scsi_ccb *request)
{
        SHOW_FLOW0(3, "fixing MODE SELECT(6)");

        // adjust transmission length as we've used the longer
        // mode select 10 data header
        request->data_resid += sizeof(scsi_mode_param_header_6)
                - sizeof(scsi_mode_param_header_10);

        restore_request_data(request);
        release_emulation_buffer(request);
}


/*! Fix inquiry data; some ATAPI devices return wrong version */
static void
scsi_finish_inquiry(scsi_ccb *request)
{
        int transferSize;
        scsi_res_inquiry res;

        SHOW_FLOW0(3, "fixing INQUIRY");

        if (request->subsys_status != SCSI_REQ_CMP
                || request->device_status != SCSI_STATUS_GOOD)
                return;

        transferSize = request->data_length - request->data_resid;

        copy_sg_data(request, 0, transferSize, &res, sizeof(res), true);

        SHOW_FLOW(3, "ANSI version: %d, response data format: %d",
                res.ansi_version, res.response_data_format);

        res.ansi_version = 2;
        res.response_data_format = 2;

        copy_sg_data(request, 0, transferSize, &res, sizeof(res), false);
}


/*! Adjust result of emulated request */
void
scsi_finish_emulation(scsi_ccb *request)
{
        SHOW_FLOW0(3, "");

        switch ((((int)request->cdb[0]) << 8) | request->orig_cdb[0]) {
                case (SCSI_OP_MODE_SENSE_10 << 8) | SCSI_OP_MODE_SENSE_6:
                        scsi_finish_mode_sense_10_6(request);
                        break;

                case (SCSI_OP_MODE_SELECT_10 << 8) | SCSI_OP_MODE_SELECT_6:
                        scsi_finish_mode_select_10_6(request);
                        break;

                case (SCSI_OP_INQUIRY << 8) | SCSI_OP_INQUIRY:
                        scsi_finish_inquiry(request);
                        break;
        }

        // restore cdb
        memcpy(request->cdb, request->orig_cdb, SCSI_MAX_CDB_SIZE);
        request->cdb_length = request->orig_cdb_length;
}


/*! Set sense of request */
static void
set_sense(scsi_ccb *request, int sense_key, int sense_asc)
{
        scsi_sense *sense = (scsi_sense *)request->sense;

        SHOW_FLOW( 3, "sense_key=%d, sense_asc=%d", sense_key, sense_asc );

        request->subsys_status = SCSI_REQ_CMP;
        request->device_status = SCSI_STATUS_CHECK_CONDITION;

        // TBD: we can only handle requests with autosense
        //              without autosense, we had to manage virtual sense data,
        //              which is probably not worth the hazzle
        if ((request->flags & SCSI_DIS_AUTOSENSE) != 0)
                return;

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

        sense->error_code = SCSIS_CURR_ERROR;
        sense->sense_key = sense_key;
        sense->add_sense_length = sizeof(*sense) - 7;
        sense->asc = (sense_asc >> 8) & 0xff;
        sense->ascq = sense_asc;
        sense->sense_key_spec.raw.SKSV = 0;     // no additional info

        request->subsys_status |= SCSI_AUTOSNS_VALID;
}


/*!     Copy data between request data and buffer
        request                 - request to copy data from/to
        offset                  - offset of data in request
        allocation_length- limit of request's data buffer according to CDB
        buffer                  - data to copy data from/to
        size                    - number of bytes to copy
        to_buffer               - true: copy from request to buffer
                                          false: copy from buffer to request
        return: true, if data of request was large enough
*/
static bool
copy_sg_data(scsi_ccb *request, uint offset, uint allocation_length,
        void *buffer, int size, bool to_buffer)
{
        const physical_entry *sg_list = request->sg_list;
        int sg_count = request->sg_count;
        int req_size;

        SHOW_FLOW(3, "offset=%u, req_size_limit=%d, size=%d, sg_list=%p, sg_count=%d, %s buffer",
                offset, allocation_length, size, sg_list, sg_count, to_buffer ? "to" : "from");

        // skip unused S/G entries
        while (sg_count > 0 && offset >= sg_list->size) {
                offset -= sg_list->size;
                ++sg_list;
                --sg_count;
        }

        if (sg_count == 0)
                return 0;

        // remaining bytes we are allowed to copy from/to request
        req_size = min_c(allocation_length, request->data_length) - offset;

        // copy one S/G entry at a time
        for (; size > 0 && req_size > 0 && sg_count > 0; ++sg_list, --sg_count) {
                size_t bytes;

                bytes = min_c(size, req_size);
                bytes = min_c(bytes, sg_list->size);

                SHOW_FLOW(0, "buffer = %p, virt_addr = %#" B_PRIxPHYSADDR ", bytes = %"
                        B_PRIuSIZE ", to_buffer = %d", buffer, sg_list->address + offset,
                        bytes, to_buffer);

                if (to_buffer) {
                        vm_memcpy_from_physical(buffer, sg_list->address + offset, bytes,
                                false);
                } else {
                        vm_memcpy_to_physical(sg_list->address + offset, buffer, bytes,
                                false);
                }

                buffer = (char *)buffer + bytes;
                size -= bytes;
                offset = 0;
        }

        return size == 0;
}


/*! Allocate emulation buffer */
static void
get_emulation_buffer(scsi_ccb *request)
{
        scsi_device_info *device = request->device;

        SHOW_FLOW0(3, "");

        acquire_sem(device->buffer_sem);
}


/*!     Replace request data with emulation buffer, saving original pointer;
        you must have called get_emulation_buffer() first
*/
static void
replace_request_data(scsi_ccb *request)
{
        scsi_device_info *device = request->device;

        SHOW_FLOW0(3, "");

        request->orig_sg_list = request->sg_list;
        request->orig_sg_count = request->sg_count;
        request->orig_data_length = request->data_length;

        request->sg_list = device->buffer_sg_list;
        request->sg_count = device->buffer_sg_count;
        request->data_length = device->buffer_size;
}


/*! Release emulation buffer */
static void
release_emulation_buffer(scsi_ccb *request)
{
        SHOW_FLOW0(3, "");

        release_sem(request->device->buffer_sem);
}


/*! Restore original request data pointers */
static void
restore_request_data(scsi_ccb *request)
{
        SHOW_FLOW0(3, "");

        request->sg_list = request->orig_sg_list;
        request->sg_count = request->orig_sg_count;
        request->data_length = request->orig_data_length;
}