/*
 * Copyright 2004-2011, Haiku, Inc. All RightsReserved.
 * Copyright 2002-2003, Thomas Kurschel. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */


//!     Handling of removable media.


#include "scsi_periph_int.h"

#include <string.h>


void
periph_media_changed(scsi_periph_device_info *device, scsi_ccb *request)
{
        uint32 backup_flags;
        uint8 backup_cdb[SCSI_MAX_CDB_SIZE];
        uchar backup_cdb_len;
        int64 backup_sort;
        bigtime_t backup_timeout;
        uchar *backup_data;
        const physical_entry *backup_sg_list;
        uint16 backup_sg_count;
        uint32 backup_data_len;

        // if there is no hook, the driver doesn't handle removal devices
        if (!device->removable) {
                SHOW_ERROR0( 1, "Driver doesn't support medium changes, but there occured one!?" );
                return;
        }

        // when medium has changed, tell all handles
        periph_media_changed_public(device);

        // the peripheral driver may need a fresh ccb; sadly, we cannot allocate one
        // as this may lead to a deadlock if all ccb are in use already; thus, we
        // have to backup all relevant data of current ccb and use it instead of a 
        // new one - not pretty but working (and performance is not an issue in this
        // path)
        backup_flags = request->flags;
        memcpy(backup_cdb, request->cdb, SCSI_MAX_CDB_SIZE);
        backup_cdb_len = request->cdb_length;
        backup_sort = request->sort;
        backup_timeout = request->timeout;
        backup_data = request->data;
        backup_sg_list = request->sg_list;
        backup_sg_count = request->sg_count;
        backup_data_len = request->data_length;

        if (device->callbacks->media_changed != NULL)
                device->callbacks->media_changed(device->periph_device, request);

        request->flags = backup_flags;
        memcpy(request->cdb, backup_cdb, SCSI_MAX_CDB_SIZE);
        request->cdb_length = backup_cdb_len;
        request->sort = backup_sort;
        request->timeout = backup_timeout;
        request->data = backup_data;
        request->sg_list = backup_sg_list;
        request->sg_count = backup_sg_count;
        request->data_length = backup_data_len;
}


void
periph_media_changed_public(scsi_periph_device_info *device)
{
        scsi_periph_handle_info *handle;

        mutex_lock(&device->mutex);

        // when medium has changed, tell all handles    
        // (this must be atomic for each handle!)
        for (handle = device->handles; handle; handle = handle->next)
                handle->pending_error = B_DEV_MEDIA_CHANGED;

        mutex_unlock(&device->mutex);
}


/** send TUR */

static err_res
send_tur(scsi_periph_device_info *device, scsi_ccb *request)
{
        scsi_cmd_tur *cmd = (scsi_cmd_tur *)request->cdb;

        request->flags = SCSI_DIR_NONE | SCSI_ORDERED_QTAG;

        request->data = NULL;
        request->sg_list = NULL;
        request->data_length = 0;
        request->timeout = device->std_timeout;
        request->sort = -1;
        request->sg_list = NULL;

        memset(cmd, 0, sizeof(*cmd));
        cmd->opcode = SCSI_OP_TEST_UNIT_READY;

        request->cdb_length = sizeof(*cmd);

        device->scsi->sync_io(request);

        return periph_check_error(device, request);
}


/** wait until device is ready */

static err_res
wait_for_ready(scsi_periph_device_info *device, scsi_ccb *request)
{       
        int retries = 0;
        
        while (true) {
                err_res res;

                // we send TURs until the device is OK or all hope is lost
                res = send_tur(device, request);

                switch (res.action) {
                        case err_act_ok:
                                return MK_ERROR(err_act_ok, B_OK);

                        case err_act_retry:
                                if (++retries >= 3)
                                        return MK_ERROR(err_act_fail, res.error_code);
                                break;

                        case err_act_many_retries:
                                if (++retries >= 30)
                                        return MK_ERROR(err_act_fail, res.error_code);
                                break;

                        default:
                                SHOW_FLOW( 3, "action: %x, error: %x", (int)res.action, (int)res.error_code);
                                return res;
                }
        }
}


status_t
periph_get_media_status(scsi_periph_handle_info *handle)
{
        scsi_periph_device_info *device = handle->device;
        scsi_ccb *request;
        err_res res;
        status_t err;

        mutex_lock(&device->mutex);

        // removal requests are returned to exactly one handle
        // (no real problem, as noone check medias status "by mistake") 
        if (device->removal_requested) {
                device->removal_requested = false;
                err = B_DEV_MEDIA_CHANGE_REQUESTED;
                goto err;
        }

        // if there is a pending error (read: media has changed), return once per handle
        err = handle->pending_error;
        if (err != B_OK) {
                handle->pending_error = B_OK;
                goto err;
        }

        SHOW_FLOW0( 3, "" );

        mutex_unlock(&device->mutex);

        // finally, ask the device itself
                
        request = device->scsi->alloc_ccb(device->scsi_device);
        if (request == NULL)
                return B_NO_MEMORY;

        res = wait_for_ready(device, request);

        device->scsi->free_ccb(request);

        SHOW_FLOW(3, "error_code: %x", (int)res.error_code);

        return res.error_code;  

err:    
        mutex_unlock(&device->mutex);
        return err;
}


/*!     Send START/STOP command to device
        start - true for start, false for stop
        withLoadEject - if true, then lock drive on start and eject on stop
*/
err_res
periph_send_start_stop(scsi_periph_device_info *device, scsi_ccb *request,
        bool start, bool withLoadEject)
{
        scsi_cmd_ssu *cmd = (scsi_cmd_ssu *)request->cdb;

        // this must be ordered, so all previous commands are really finished
        request->flags = SCSI_DIR_NONE | SCSI_ORDERED_QTAG;

        request->data = NULL;
        request->sg_list = NULL;
        request->data_length = 0;
        request->timeout = device->std_timeout;
        request->sort = -1;
        request->sg_list = NULL;

        memset(cmd, 0, sizeof(*cmd));
        cmd->opcode = SCSI_OP_START_STOP;
        // we don't want to poll; we give a long timeout instead
        // (well - the default timeout _is_ large)
        cmd->immediately = 0;
        cmd->start = start;
        cmd->load_eject = withLoadEject;

        request->cdb_length = sizeof(*cmd);

        device->scsi->sync_io(request);

        return periph_check_error(device, request);
}