BPicture: Fix archive constructor.

[haiku.git] / src / add-ons / kernel / bus_managers / ide / queuing.c

/*
** Copyright 2002/03, Thomas Kurschel. All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/

/*
        Part of Open IDE bus manager

        Command queuing functions
*/

#include "ide_internal.h"
#include "ide_sim.h"
#include "ide_cmds.h"

#include <string.h>
#include <malloc.h>


// maximum number of errors until command queuing is disabled
#define MAX_CQ_FAILURES 3


/** convert tag to request */

static inline ide_qrequest *
tag2request(ide_device_info *device, int tag)
{
        ide_qrequest *qrequest = &device->qreq_array[tag];

        if (qrequest->running)
                return qrequest;

        return NULL;
}


/**     service device
 *
 *      (expects locked bus and bus in "accessing" state)
 *      returns true if servicing a command (implies having bus unlocked)
 *      returns false on error
 */

static bool
service_device(ide_device_info *device)
{
        ide_qrequest *qrequest;
        int tag;

        SHOW_FLOW0( 3, "Start servicing" );

        // delete timeout first

        // we must unlock bus before cancelling timer: if the timeout has
        // just been fired we have to wait for it, but in turn it waits 
        // for the ide bus -> deadlock
        IDE_UNLOCK(device->bus);

        cancel_timer(&device->reconnect_timer.te);

        // between IDE_UNLOCK and cancel_timer the request may got
        // discarded due to timeout, so it's not a hardware problem
        // if servicing fails

        // further, the device discards the entire queue if anything goes
        // wrong, thus we call send_abort_queue on each error
        // (we could also discard the queue without telling the device,
        //  but we prefer setting the device into a safe state)

        // ask device to continue               
        if (!device_start_service(device, &tag)) {
                send_abort_queue(device);
                goto err;
        }

        SHOW_FLOW0( 3, "device starts service" );

        // get tag of request
        qrequest = tag2request(device, tag);
        if (qrequest == NULL) {
                send_abort_queue(device);
                goto err;
        }

        SHOW_FLOW( 3, "continue request %p with tag %d", qrequest, tag );

        device->bus->active_qrequest = qrequest;

        // from here on, queuing is ATA read/write specific, so you have to
        // modify that if you want to support ATAPI queuing!
        if (check_rw_error(device, qrequest)) {
                // if a read/write error occured, the request really failed
                finish_reset_queue(qrequest);
                goto err;
        }

        // all ATA commands continue with a DMA request 
        if (!prepare_dma(device, qrequest)) {
                // this is effectively impossible: before the command was initially
                // sent, prepare_dma had been called and obviously didn't fail,
                // so why should it fail now?
                device->subsys_status = SCSI_HBA_ERR;
                finish_reset_queue(qrequest);
                goto err;       
        }

        SHOW_FLOW0( 3, "launch DMA" );
        
        start_dma_wait_no_lock(device, qrequest);

        return true;

err:
        // don't start timeout - all requests have been discarded at this point
        IDE_LOCK(device->bus);
        return false;
}


/**     check if some device on bus wants to continue queued requests;
 *
 *      (expects locked bus and bus in "accessing" state)
 *      returns true if servicing a command (implies having bus unlocked)
 *      returns false if nothing to service
 */

bool
try_service(ide_device_info *device)
{
        bool this_device_needs_service;
        ide_device_info *other_device;

        other_device = device->other_device;

        // first check whether current device requests service
        // (the current device is selected anyway, so asking it is fast)
        this_device_needs_service = check_service_req(device);

        // service other device first as it was certainly waiting
        // longer then the current device
        if (other_device != device && check_service_req(other_device)) {
                if (service_device(other_device)) {
                        // we handed over control; start timeout for device
                        // (see below about fairness)
                        if (device->num_running_reqs > 0) {
                                if (!device->reconnect_timer_installed) {
                                        device->reconnect_timer_installed = true;
                                        add_timer(&device->reconnect_timer.te, reconnect_timeout,
                                                IDE_RELEASE_TIMEOUT, B_ONE_SHOT_RELATIVE_TIMER);
                                }
                        }
                        return true;
                }
        }

        // service our device second
        if (this_device_needs_service) {
                if (service_device(device))
                        return true;
        }

        // if device has pending reqs, start timeout.
        // this may sound strange as we cannot be blamed if the
        // other device blocks us. But: the timeout is delayed until
        // the bus is idle, so once the other device finishes its
        // access, we have a chance of servicing all the pending 
        // commands before the timeout handler is executed
        if (device->num_running_reqs > 0) {
                if (!device->reconnect_timer_installed) {
                        device->reconnect_timer_installed = true;
                        add_timer(&device->reconnect_timer.te, reconnect_timeout, 
                                IDE_RELEASE_TIMEOUT, B_ONE_SHOT_RELATIVE_TIMER);
                }
        }

        return false;
}


bool
initialize_qreq_array(ide_device_info *device, int queue_depth)
{
        int i;

        device->queue_depth = queue_depth;

        SHOW_FLOW( 3, "queue depth=%d", device->queue_depth );

        device->qreq_array = (ide_qrequest *)malloc(queue_depth * sizeof(ide_qrequest));
        if (device->qreq_array == NULL)
                return false;

        memset(device->qreq_array, 0, queue_depth * sizeof(ide_qrequest));

        device->free_qrequests = NULL;

        for (i = queue_depth - 1; i >= 0 ; --i) {
                ide_qrequest *qrequest = &device->qreq_array[i];

                qrequest->next = device->free_qrequests;
                device->free_qrequests = qrequest;

                qrequest->running = false;
                qrequest->device = device;
                qrequest->tag = i;
                qrequest->request = NULL;
        }

        return true;
}


void
destroy_qreq_array(ide_device_info *device)
{
        if (device->qreq_array) {
                free(device->qreq_array);
                device->qreq_array = NULL;
        }

        device->num_running_reqs = 0;
        device->queue_depth = 0;
        device->free_qrequests = NULL;
}


/** change maximum number of queuable requests */

static bool
change_qreq_array(ide_device_info *device, int queue_depth)
{
        ide_qrequest *qreq_array = device->qreq_array;
        ide_qrequest *old_free_qrequests = device->free_qrequests;
        int old_queue_depth = queue_depth;

        // be very causious - even if no queuing supported, we still need
        // one queue entry; if this allocation fails, we have a device that
        // cannot accept any command, which would be odd
        if (initialize_qreq_array( device, queue_depth)) {
                free(qreq_array);
                return true;
        }

        device->qreq_array = qreq_array;
        device->num_running_reqs = 0;
        device->queue_depth = old_queue_depth;
        device->free_qrequests = old_free_qrequests;
        return false;
}


/**     reconnect timeout worker
 *      must be called as a synced procedure call, i.e.
 *      the bus is allocated for us
 */

void
reconnect_timeout_worker(ide_bus_info *bus, void *arg)
{
        ide_device_info *device = (ide_device_info *)arg;

        // perhaps all requests have been successfully finished
        // when the synced pc was waiting; in this case, everything's fine
        // (this is _very_ important if the other device blocks the bus
        // for a long time - if this leads to a reconnect timeout, the
        // device has a last chance by servicing all requests without
        // delay, in which case this function gets delayed until all
        // pending requests are finished and the following test would
        // make sure that this false alarm gets ignored)
        if (device->num_running_reqs > 0) {
                // if one queued command fails, all of them fail        
                send_abort_queue(device);

                // if too many timeouts occure, disable CQ
                if (++device->CQ_failures > MAX_CQ_FAILURES) {
                        device->CQ_enabled = false;

                        change_qreq_array(device, 1);
                }
        }

        // we've blocked the bus in dpc - undo that
        scsi->unblock_bus(device->bus->scsi_cookie);
}


/** dpc callback for reconnect timeout */

static void
reconnect_timeout_dpc(void *arg)
{
        ide_device_info *device = (ide_device_info *)arg;

        // even though we are in the service thread, 
        // the bus can be in use (e.g. by an ongoing PIO command),
        // so we have to issue a synced procedure call which
        // waits for the command to be finished

        // meanwhile, we don't want any command to be issued to this device
        // as we are going to discard the entire device queue;
        // sadly, we don't have a reliable XPT device handle, so we block
        // bus instead (as this is an error handler, so performance is
        // not crucial)
        scsi->block_bus(device->bus->scsi_cookie);
        schedule_synced_pc(device->bus, &device->reconnect_timeout_synced_pc, device);
}


/** timer function for reconnect timeout */

int32
reconnect_timeout(timer *arg)
{
        ide_device_info *device = ((ide_device_timer_info *)arg)->device;
        ide_bus_info *bus = device->bus;

        // we are polite and let the service thread do the job
        scsi->schedule_dpc(bus->scsi_cookie, device->reconnect_timeout_dpc, 
                reconnect_timeout_dpc, device);
                
        return B_INVOKE_SCHEDULER;
}


/**     tell device to abort all queued requests
 *      (tells XPT to resubmit these requests)
 *      return: true - abort successful
 *              false - abort failed (in this case, nothing can be done)
 */

bool
send_abort_queue(ide_device_info *device)
{
        int status;
        ide_bus_info *bus = device->bus;

        SHOW_FLOW0( 3, "" );

        device->tf.write.command = IDE_CMD_NOP;
        // = discard outstanding commands
        device->tf.write.features = IDE_CMD_NOP_NOP;

        device->tf_param_mask = ide_mask_features;

        if (!send_command(device, NULL, true, 0, ide_state_accessing))
                goto err;

        if (!wait_for_drdy(device))
                goto err;

        // device must answer "command rejected" and discard outstanding commands
        status = bus->controller->get_altstatus(bus->channel_cookie);

        if ((status & ide_status_err) == 0)
                goto err;

        if (!bus->controller->read_command_block_regs(bus->channel_cookie,
                        &device->tf, ide_mask_error)) {
                // don't bother trying bus_reset as controller disappeared
                device->subsys_status = SCSI_HBA_ERR;
                return false;
        }

        if ((device->tf.read.error & ide_error_abrt) == 0)
                goto err;

        finish_all_requests(device, NULL, 0, true);
        return true;

err:
        // ouch! device didn't react - we have to reset it
        return reset_device(device, NULL);
}